El documento parece discutir la creación de cosas que ya han sido hechas anteriormente, lo que podría considerarse intelectualmente trivial. Se plantea la pregunta de si realmente hay escasez de ideas genuinamente nuevas.

1. AL MISMO
TIEMPO, MUCHOS
PARECEN TENER QUE
VER CON RECREAR
COSAS QUE NOSOTROS
U OTROS YA HEMOS
HECHO; PARECE
BASTANTE TRILLADO
INTELECTUALMENTE;
¿HAY ESCASEZ DE
IDEAS REALMENTE
NUEVAS?

2. DIEGO CAMILO AGUIRRE LORA
DAVID ESTEBAN RODRÍGUEZ GÓMEZ
Algoritmos de administración de memoria

3. PRIMER AJUSTE –
(FIRST FIT)
Algoritmo de administración y ajuste de
memoria

4. Primer ajuste- (First Fit)
Consiste en asignar el primer espacio disponible que
tenga un espacio suficiente para almacenar el
programa. Las dos principales desventajas son su alto
desperdicio interno, y el elevado uso de las primeras
posiciones de memoria. Este último inconveniente
repercute negativamente en la circuitería, debido a que
se produce un mayor desgaste en dichas posiciones.

5. Ejemplo:
 Suponiendo una memoria principal de 32 K
 Solución

6. Algoritmo
 Algorithm for allocate (n)
size(block) = n + size(header)
Scan free list for first block with nWords >= size(block)
If block not found
Failure (time for garbage collection!)
Else if free block nWords >= size(block) + threshold*
Split into a free block and an in-use block
Free block nWords = Free block nWords - size(block)
In-use block nWords = size(block)
Return pointer to in-use block
Else
Unlink block from free list
Return pointer to block
*Threshold must be at least size(header) + 1 to leave room for header and
link
Threshold can be set higher to combat fragmentation
 Allocation time is O(K) (K = number of blocks in free list)

8. CÓDIGO JAVA
 public class Ajustes {
 public static int ultimoBloqueAsignado = 0;

 /**
 * Implementación del método de primer ajuste.
 *
 * @param listaControl
 * - Lista de control.
 * @param tamanyo
 * - Tamaño del hueco requerido.
 * @return Devuelve el índice del lugar en el que se encuentra el primer
 * bloque libre con el que satisfacer la petición, o -1 en el caso
 * de no haber ninguno disponible.
 */
 public static int primerAjuste(List<int[]> listaControl, int tamanyo) {
 int res = 0;
 for (int[] bloque : listaControl) {
 if (bloque[0] == 0 && bloque[2] >= tamanyo) {
 break;
 }
 res++;
 }
 if (res == listaControl.size()) {
 res = -1;
 }
 return res;
 }

9. Algoritmo de administración y ajuste de memoria
Mejor ajuste –(Best Fit)

10. Mejor ajuste- (Best Fit)
Consiste en asignarle al proceso al espacio de
memoria con menor ajuste interno, el espacio vacio
al cual se le es asignado el proceso deja menos
espacio sin utilizar
Su mayor inconveniente es su orden de complejidad
debido a que hay que recorrer todo el mapa de bits o
toda la lista de control
una posible solución seria usar una lista de control
encadenada que mantenga los espacios vacios
ordenado por tamaño creciente
Otro problema es la fragmentación externa, debido
a que se asigna el menor espacio vacio posible, el
espacio sobrante será del menor tamaño posible lo
que da lugar a huecos de tamaño normalmente
insuficiente para contener programas.

11. Código en java
 public class Ajustes {
 public static int ultimoBloqueAsignado = 0;
 /**
 * Implementación del método de mejor ajuste.
 *
 * @param listaControl
 * - Lista de control.
 * @param tamanyo
 * - Tamanyo del hueco requerido.
 * @return Devuelve el índice del lugar en el que se encuentra el primer
 * bloque libre con el que satisfacer la petición, o -1 en el caso
 * de no haber ninguno disponible.
 */
 public static int mejorAjuste(List<int[]> listaControl, int tamanyo) {
 int i = 0;
 int menorBloque = -1;
 int tamMenorBloque = -1;
 for (int[] bloque : listaControl) {
 if (bloque[0] == 0 && bloque[2] >= tamanyo
 && (menorBloque == -1 || bloque[2] < tamMenorBloque)) {
 menorBloque = i;
 tamMenorBloque = bloque[2];
 }
 i++;
 }
 return menorBloque;
 }

12. SIGUIENTE AJUSTE- (NEXT FIT)
Algoritmo de administración y ajuste de memoria

13. Se continúa a partir de la
posición de la última asignación
realizada.
Es muy probable que haya un
hueco a partir de esa posición,
reduciendo la longitud de la
búsqueda.
De esta forma se resuelve el
inconveniente de usar en
exceso las primeras posiciones
de la memoria.
Cuando se alcanza el final de la
memoria se vuelve a comenzar
la búsqueda desde el principio
(por ello este criterio es también
conocido como primer ajuste
circular).
SIGUIENTE AJUSTE- (NEXT FIT)

14. public class Ajustes {
public static int ultimoBloqueAsignado = 0;
* @param listaControl
* - Lista de control.
* @param tamanyo
* - Tamanyo del hueco requerido.
* @return Devuelve el índice del lugar en el que se encuentra el
primer
* bloque libre con el que satisfacer la petición, o -1 en el
caso
* de no haber ninguno disponible.
*/
public static int siguienteAjuste(List<int[]> listaControl, int
tamanyo) {
int res = ultimoBloqueAsignado;
boolean listaRecorrida=false;
while (res!=-1) {
int bloque[] = listaControl.get(res);
if (bloque[0] == 0 && bloque[2] >= tamanyo) {
ultimoBloqueAsignado=res;
break;
}
res++;
if (res>=listaControl.size()) {
if (listaRecorrida) {
res=-1;
} else {
res%=listaControl.size();
listaRecorrida=true;
}
}
}
return res;
}
CÓDIGO EN JAVA

15. A L G O R I T M O D E A D M I N I S T R A C I Ó N Y A J U S T E
D E M E M O R I A
Peor Ajuste- (Worst Fit)

16. Peor Ajuste-
(Worst Fit)
S E B U S C A E L H U E C O C O N M A Y O R A J U S T E I N T E R N O , E L
H U E C O E L C U A L A L S E R L E A S I G N A D O E L P R O C E S O D E J A
M Á S E S P A C I O S I N U T I L I Z A R , Y S E C O R T A D E É L E L T R O Z O
N E C E S A R I O ( A S Í L A P O R C I Ó N S O B R A N T E S E R Á D E L
M A Y O R T A M A Ñ O P O S I B L E Y S E R Á M Á S A P R O V E C H A B L E ) .
T I E N E E L M I S M O I N C O N V E N I E N T E E N C U A N T O A O R D E N
D E C O M P L E J I D A D Q U E E L M E J O R A J U S T E ( D E B I D O A L A
L O N G I T U D D E L A S B Ú S Q U E D A S ) Y L A F R A G M E N T A C I Ó N
N O R E S U L T A D E M A S I A D O E F I C I E N T E .

17. public class Ajustes {
public static int ultimoBloqueAsignado = 0;
*
* @param listaControl
* - Lista de control.
* @param tamanyo
* - Tamanyo del hueco requerido.
* @return Devuelve el índice del lugar en el que se encuentra el primer
* bloque libre con el que satisfacer la petición, o -1 en el caso
* de no haber ninguno disponible.
*/
public static int peorAjuste(List<int[]> listaControl, int tamanyo) {
int i = 0;
int mayorBloque = -1;
int tamMayorBloque = -1;
for (int[] bloque : listaControl) {
if (bloque[0] == 0 && bloque[2] >= tamanyo
&& (mayorBloque == -1 || bloque[2] > tamMayorBloque)) {
mayorBloque = i;
tamMayorBloque = bloque[2];
}
i++;
}
return mayorBloque;
}
Código en Java

18. Algoritmo de administración y ajuste de memoria

19. Ajuste rápido- (Fast Fit)
Mediante listas
de control, se
agrupan los
huecos
disponibles
según su
tamaño (0 < t <
10, 10 < t <
20, etc.)
De esta
manera, cuando
se necesite un
hueco, se
seleccionarán
los del grupo
del tamaño que
corresponda.
En el caso de
que haya varios
huecos
disponibles, se
seleccionará
uno en base a
cualquiera de
los criterios
anteriores.

20. Punteros a listas Lista de punteros
Lista de huecos según
tamaño
__________________
[ ] _____ _____ _____
[ 0<t<10 ]  |_____| |_____| |_____|
[ ]
[________________ ]
[ ] _____ _____
[ 10<t<20 ]  |_____| |_____|
[ ]
[________________ ]
[ ]
[ …......... ]
[ ]
[________________ ]
[ ] _____
[ t<200 ]  |_____|
[ ]
[________________ ]

21. Algoritmo de administración
y ajuste de memoria

22.  Es una variante del ajuste rápido, en el que los huecos se dividen en
potencias de 2: 21, 22, ..., 2k. No es un método usado en la práctica, ya que
al realizar redondeos a potencias de 2, se produce un elevado desperdicio
interno. Es un método rápido tanto en la asignación como en la liberación
de bloques. El funcionamiento es el siguiente: Cuando se necesita un bloque
de tamaño T se busca en la lista de la 1ª potencia mayor o igual a T (por
ejemplo 2^k), si no hay ninguno se busca en la lista de la siguiente potencia
(2^k+1), si encontramos un bloque libre se retira y se divide por la mitad: una
parte se le asigna al proceso y la otra se almacena en la lista de los huecos
de tamaño 2^k.

23. Organización de los bloques
__________________
[ ] _____ _____ _____
[ 2^(k+1) ]  |_____| |_____|
|_____|
[ ]
[________________ ]
[ ] _____ _____
[ 2^k ]  |_____| |_____|
[ ]
[________________ ]
[ ]
[ …......... ]
[ ]
[________________ ]
[ ] _____
[ 1 ]  |_____|
[ ]
[________________ ]

24. Debido a la forma de dividir los
bloques al liberarse uno de ellos
solamente podrá fusionarse con sus
compañeros (bloques del mismo
tamaño) con los que formará un
bloque de tamaño superior.
METODO DE LOS COMPAÑEROS
División de los bloques
______________________________________________
__________
0 8
______________________________________________
__________
0 4 8 12
______________________________________________
__________
0 2 4 6 8 10
12 14
______________________________________________
__________
0 1 2 3 4 5 6 7 8 9 10 11 12

25. DiegoCamiloAguirre Lora
David Esteban Rodríguez Gómez
Gracias