Algoritmo LRU (Least Recently Used, menos recientemente usada)

Definicin
El algoritmo LRU est basado en el principio de proximidad temporal de referencias: si es
probable que se vuelvan a referenciar las pginas accedidas recientemente, la pgina que se
debe reemplazar es la que no se ha referenciado desde hace ms tiempo.
Hay un aspecto sutil en este algoritmo cuando se considera su versin global. A la hora de
seleccionar una pgina, no habra que tener en cuenta el tiempo de acceso real, sino el tiempo
lgico de cada proceso. O sea, habra que seleccionar la pgina que haya sido menos
recientemente usada teniendo en cuenta el tiempo lgico de cada proceso.1
Problemtica
Si incrementamos la multiprogramacin, estamos sobrecargando nuestra memoria
o sobreasignado, lo que puede eventualmente que nos quedemos a falta de marcos o frames
disponibles para cargar las pginas. En estos casos, la solucin ms comn es la sustitucin
de pginas.2
La estrategia consiste en llevar a disco la pgina que ha permanecido por ms tiempo sin ser
accesada. El fundamento de esta estrategia es que estadsticamente se observa que mientras
ms tiempo permanece una pgina sin ser accesada, menos probable es que se accese en el
futuro inmediato.3
Ventajas
Debido al principio de cercana, esta debera ser la pgina con menos probabilidad de ser
referenciada en un futuro cercano. De hecho, la poltica LRU afina casi tanto como la poltica
ptima.
El algoritmo LRU no sufre la anomala de Belady. Pertenece a una clase de algoritmos
denominados algoritmos de pila. La propiedad de estos algoritmos es que las pginas
residentes en memoria para un sistema con marcos de pgina son siempre un subconjunto de
las que habra en un sistema con n +1 marcos.
Esta propiedad asegura que un algoritmo de este tipo nunca sufrir la anomala de Belady. 4
Desventajas
1,4 (Jess Carretero Prez, Sistemas operativos. Una visin aplicada, 2001, pg. 205-206)
2 (Fundacin Wikimedia Inc, Algoritmo de reemplazo de pginas, Wikipedia, la enciclopedia libre web site, 25 de
junio de 2016, de https://es.wikipedia.org/wiki/Algoritmo_de_reemplazo_de_p%C3%A1ginas)

3 (William Stanllings, Sistemas Operativos: Aplicativos internos y principios de diseo, Segunda Edicin, pag. 306)
4

A pesar de que el algoritmo LRU es realizable y proporciona un rendimiento bastante bueno, su

implementacin eficiente es difcil y requiere un considerable apoyo hardware. Una
implementacin del algoritmo podra basarse en utilizar un contador que se incremente por
cada referencia a memoria. Cada posicin de la tabla de pginas ha detener un campo de
tamao suficiente para que quepa el contador. Cuando se referencia aun a pgina, el valor
actual del contador se copia por hardware a la posicin de la tabla correspondiente a esa
pgina. Cuando se produce un fallo de pgina, el sistema operativo examina los contadores de
todas las pginas residentes en memoria y selecciona como vctima aquella que tiene el valor
menor. Esta implementacin es factible aunque requiere un hardware complejo y
muy especifico.5
Ejemplo prctico de aplicacin

REFERENCIAS 2
MARCO 1
2
MARCO 2
MARCO 3
MARCO 4

1 3 7 2
1 3 7 7
2 1 3 3
2 1 1
2 2

5
7
3
5
2

FALLOS

F F F

F F F

N Fallos:
N Referencias:
Rendimiento:

19
25
0,2
5

8
7
8
5
2

1
1
8
5
2

2
1
8
5
2

5
1
8
5
2

9
1
9
5
2
F

2
1
9
5
2

1
1
9
5
2

4
1
9
4
2

8
1
8
4
2

6
1
8
4
6

3
3
8
4
6

2
3
8
2
6

7
3
7
2
6

1
3
7
2
1

4
4
7
2
1

3
4
7
3
1

F F F F F F F F F

24
%

Figura 1. Ejemplo prctico de la aplicacin del algoritmo de reemplazo LRU

Fuente: (Imagen referencial segn William Stanllings, Sistemas Operativos:
Aplicativos internos y principios de diseo, Segunda Edicin)

5 (Jess Carretero Prez, Sistemas operativos. Una visin aplicada, 2001, pg. 205-206)

7
4
7
3
1

2
4
7
3
2

9
2
7
3
9

F F

Pseudocodigo
Principal
Inicio
Declarar numMarcos = 0 TIPO ENTERO
Declarar numPaginas = 0 TIPO ENTERO
Declarar yaEsta = -1 TIPO ENTERO
Declarar nulo = -1 TIPO ENTERO
Declarar mayor = -1 TIPO ENTERO
Declarar i=0, j=0, k=0, l=0, m=0, n=0, o=0, p=0, q=0, r=0, s=0, t=0 TIPO ENTERO
Escribir Ingrese la cantidad de marcos
Leer numMarcos
Escribir Ingrese la cantidad de paginas
Leer numPaginas
Declarar paginas[numPaginas] TIPO ARREGLO
Declarar marcos[numMarcos] TIPO ARREGLO
Para (i=0; i<numPaginas; i++)
Inicio
Escribir Ingrese la pgina
Leer paginas
Fin
AL INICIO TODOS LOS MARCOS ESTAN VACIOS
Para (o=0; o<numMarcos; o++)
Inicio
marcos[o][0]=(-1)
marcos[o][1]=0
fin
Para (j=0; j<numPaginas; j++)
Inicio
Para (k=0; k<numMarcos; k++)
Inicio

VERIFICA SI LA PAGINA YA ESTA EN ALGUN MARCO

Para (q=0; q<numMarcos; q++)
Inicio
Si (paginas[j]==marcos[q][0])
Inicio
yaEsta=paginas[j];
marcos[q][1]=0 SE PONE EN 0 SU TIEMPO EN MEMORIA
(DESPUES SE INCREMENTARA EN 1 POCO ANTES DE
MOSTRAR LOS marcos en consola)
interrupcion
fin
fin
Si (yaEsta>(-1))//si esta
Inicio
//se borra el valor de estas variables
mayor=(-1);
yaEsta=(-1);

fin
caso contrario
inicio
si (marcos[k][0]==(-1))
inicio
Escribir Fallo de pagina
Mostrar marcos[k][0]=paginas[j]
interrupcion
fin
caso contrario
inicio
PARA COMPROBAR SI TODAVIA QUEDAN
ESPACIOS VACIOS
Si ((k+1)<numMarcos)
Inicio
para (p=k+1; p<numMarcos; p++)
inicio

si (marcos[p][0]==(-1))
inicio
nulo=p;
interrupcion
fin
fin
fin
Si (nulo==(-1)) SI NO HAY ESPACIOS VACIOS
Inicio
CALCULA LA POSICION EN EL MARCO DE LA PAGINA
CON MAS TIEMPO EN MEMORIA
Para (l=0; l<numMarcos; l++)
Inicio
Si (l==0)
Inicio
Mayor=l;
Fin
Caso contrario
Inicio
para (m=0; m<l; m++)
Inicio
Si ((marcos[l][1]>=marcos[m]
[1])&&
(marcos[m]
[1]>=marcos[mayor][1]))
Inicio
mayor=l;
Fin
Fin
Fin
Fin
Escribir Fallo de pagina
Mostrar marcos[mayor][0]=paginas[j];
marcos[mayor][1]=1SE LE PONE CON
TIEMPO EN MEMORIA DE 1

interrupcin
fin
caso contrario
fin
SI HAY ESPACIOS VACIOS
mayor=(-1);
Escribir Fallo de pagina
marcos[nulo][0]=paginas[j];
nulo=(-1);
interrupcion
fin
fin
fin
fin
para (n=0; n<numMarcos; n++)
inicio
si ((marcos[n][0]==(-1))||(n==mayor))
inicio
fin
caso contrario
inicio
marcos[n][1]++
fin
IMPRIME LAS PGINAS DE LOS MARCOS CON SU RESPECTIVO TIEMPO EN
MEMORIA, EN EL INTERVALO DE TIEMPO ACTUAL
Escribir marcos[n][0], marcos[n][1])
fin
fin
retornar 0;
fin

Cdigo en C
//Nota: El -1 significa que no hay nada, que esta vacio el espacio
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
int numMarcos=0, numPaginas=0;
int yaEsta=(-1); //indica si la pagina a poner ya esta o no en el marco y la almacena
aqui
int nulo=(-1); //posicion del marco vacio
int mayor=(-1);//posicion de la pagina del marco con mayor tiempo en memoria
int i=0, j=0, k=0, l=0, m=0, n=0, o=0, p=0, q=0, r=0, s=0, t=0; //contadores

printf("Ingrese la cantidad de marcos:\n");

scanf("%d", &numMarcos);
printf("Ingrese la cantidad de paginas:\n");
scanf("%d", &numPaginas);
int paginas[numPaginas];//arreglo para las paginas a poner en los marcos
int marcos[numMarcos][numMarcos];//arreglo para los marcos y el tiempo que llevan
sus paginas en memoria
for (i=0; i<numPaginas; i++)
{
printf("Ingrese la pagina %d: \n", (i+1));
scanf("%d", &paginas[i]);
}
//al inicio todos los marcos estan vacios
for (o=0; o<numMarcos; o++)
{
marcos[o][0]=(-1);
marcos[o][1]=0;

for (j=0; j<numPaginas; j++)

{
for (k=0; k<numMarcos; k++)
{
//verificar si la pagina ya esta en algun marco
for (q=0; q<numMarcos; q++)
{
if (paginas[j]==marcos[q][0])
{
yaEsta=paginas[j];
marcos[q][1]=0;//se pone en 0 su tiempo en memoria (despues se
incrementara en 1 poco antes de mostrar los marcos en consola)
break;
}
}
if (yaEsta>(-1))//si esta
{
//se borra el valor de estas variables
mayor=(-1);
yaEsta=(-1);
break;
}
else //si no esta
{
if (marcos[k][0]==(-1))
{
printf("Fallo de pagina\n");
marcos[k][0]=paginas[j];
break;
}
else
{

//ALGORITMO PARA COMPROBAR SI TODAVIA QUEDAN ESPACIOS VACIOS

if ((k+1)<numMarcos)
{
for (p=k+1; p<numMarcos; p++)
{
if (marcos[p][0]==(-1))
{
nulo=p;
break;
}
}
}

if (nulo==(-1))//si no hay espacios vacios

{
//algoritmo para calcular la posicion en el marco de la pagina con mas
tiempo en memoria
for (l=0; l<numMarcos; l++)
{
if(l==0)
{
mayor=l;
}
else
{
for (m=0; m<l; m++)
{
if((marcos[l][1]>=marcos[m][1])&&(marcos[m]
[1]>=marcos[mayor][1]))
{
mayor=l;
}
}
}

printf("Fallo de pagina\n");
marcos[mayor][0]=paginas[j];
marcos[mayor][1]=1;//se le pone con tiempo en memoria de 1

break;

}
else
{
//si hay espacios vacios
mayor=(-1);
printf("Fallo de pagina\n");
marcos[nulo][0]=paginas[j];
nulo=(-1);
break;
}
}
}
}
for (n=0; n<numMarcos; n++)
{
if ((marcos[n][0]==(-1))||(n==mayor))
{
}
else
{
marcos[n][1]++;//se incrementa el tiempo en memoria de las paginas de los
marcos (excepto las vacias y la reemplazada si hubiera)
}
//imprime las paginas de los marcos con su respectivo tiempo en memoria, en el
intervalo de tiempo actual
printf("%d(%d) ", marcos[n][0], marcos[n][1]);

}
printf("\n\n");
}
return 0;
}

Cdigo en Java
void lru() {
int i, j, duration[], max;
reset();
show();
duration = new int[f];
boolean found = false;
for (i = 0; i < n; i++) {
for (j = 0; j < f; j++) {
duration[j]++;
}
for (j = 0; j < f; j++) {
if (page[i] == frames[j]) {
found = true;
duration[j] = 0;
}
}
if (found == false) {
max = 0;
for (j = 0; j < f; j++) {
if (duration[j] > duration[max]) {
max = j;
}
}
frames[max] = page[i];
duration[max] = 0;
faults++;
}
display();
found = false;

}
System.out.println("Numero de fallas = " + faults);
System.out.println("Tasa de fallas = " + (faults * 1.0 / n));

Conclusin

El algoritmo LRU, por su principio de proximidad temporal, tiene la ventaja de que luego de
cada referencia, se actualiza una lista que indica cuan reciente fue la ltima referencia a una
pgina determinada. Si se produce un desacierto, se reemplaza aquella pgina cuya ltima

referencia se ha producido en el pasado ms lejano, diversas simulaciones indica que las

mejores razones de acierto se producen utilizando este algoritmo.