EJERCICIO 4.1
Sea un sistema de paginación con un tamaño de página P. Especifique cuál sería la fórmula matemática que determina la dirección de memoria física F a partir de la dirección virtual D, siendo la función MARCO (x) una que devuelve el numero de marco almacenado en la entrada X de la tabla de páginas.
Como nuestro tamaño de página es P y debe ser un número potencia de 2, tendremos que P será igual a la potencia b-ésima de 2. Donde b será el número de bits de desplazamiento, tanto de nuestra dirección virtual, como de nuestra dirección Física.
Si llamamos nD al número de bits de dirección y nP al número de bits de nD que se refieren a una página de la tabla de páginas (si la dirección es virtual) o a un marco de memoria(si la dirección es física), tendremos que, nD será igual a la suma de nP y b.
ND = NP + b.
Según esto, si cojo los datos de nD de la dirección lógica D, a lo cual, llamaremos nD(D), obtenemos el número de página, o dicho de otra manera, la entrada de la tabla de páginas, donde se encuentra el marco de página que nos interesa.
Si aplicamos la función Marco(x) a nuestro nd(D), obtendremos el marco de página de memoria principal, es decir, la parte de marco de nuestra dirección física, a la cual, llamaremos nM(F).
NM(F) = Marco(nd(D))
Finalmente si suponemos que el dato referido al desplazamiento es Db(F) si añadimos a nuestro número de marco, el desplazamiento, obtendremos la dirección física. :
F = NM(F) + Db(F)
EJERCICIO 4.2
¿ Es siempre el algoritmo de reemplazo LRU mejor que el FIFO? En caso afirmativo, plantee una demostración. En caso negativo, proponga un contraejemplo.
Generalmente, si es mejor el algoritmo LRU que el FIFO. Sin embargo y a pesar de que el LRU no tiene la anomalía de Belady y el FIFO si, este puede presentar un comportamiento mejor en códigos, en los cuales, se referencie con no mucha frecuencia a las mismas páginas de memoria. De este modo, se evitaría que las páginas que se sustituyen en memoria se referenciaran en un corto espacio de tiempo, con lo cual, se minimizarían los fallos de página, obteniendo así un buen rendimiento, posiblemente superior al LRU.
EJERCICIO 4.3
¿Cuál de las siguientes técnicas favorece la proximidad de referencias?
+ Un programa multiflujo.
+ El uso de listas.
+ La programación funcional.
+ La programación estructurada.
EJERCICIO 4.5
Algunas MMU no proporcionan un BIT de página accedida. Proponga una manera de simularlo. Una pista : se pueden forzar fallos de página para detectar accesos a una página.
Modificando los permisos de lectura de una página se puede conseguir que salte una excepción en el momento que se accede a una página.
EJERCICIO 4.6
Algunas MMU no proporcionan un BIT de página modificada. Proponga una manera de simularlo.
Análogamente al ejercicio anterior, se modifican los permisos en este caso de escitura, para que salte una excepción en el momento que se escribe sobre una página.
EJERCICIO 4.7
Escriba un programa que use los servicios POSIX de proyección de archivos para comparar dos archivos.
#include
#include
#include
#include
#include
#include
int main (int argc, char **argv)
{
int fd1,fd2,i = 0, Distintos = 0;
char caracter;
char *archivo1,*archivo2, *p, *q;
struct stat bstat1, bstat2;
/* Abre el primer archivo para lectura */
if ((fd1=open (argv[1], O_RDONLY))<0)
{
perror(“No puede abrirse el archivo”);
return(1);
}
/* Abre el segundo archivo para lectura */
if ((fd2=open (argv[2], O_RDONLY))<0)
{
perror(“No puede abrirse el archivo”);
return(1);
}
/* Averigua la longitud de los archivos*/
if (fstat(fd1,&bstat1)<0)
{
perror(“Error en fstat del archivo1”);
close(fd1);
close(fd2);
return(1);
}
if (fstat(fd2,&bstat2)<0)
{
perror(“Error en fstat del archivo2”);
close(fd2);
close(fd1);
return(1);
}
/* Se proyectan los archivos */
if ((archivo1=mmap((caddr_t) 0, bstat1.st_size, PROT_READ, MAP_SHARED,
fd1,0)) == MAP_FAILED)
{
perror(“Error en la proyección del archivo 1”);
close (fd1);
close (fd2);
return(1);
}
close (fd1);
if ((archivo2=mmap((caddr_t) 0, bstat2.st_size, PROT_READ, MAP_SHARED,
fd2,0)) == MAP_FAILED)
{
perror(“Error en la proyección del archivo 2”);
close (fd1);
close (fd2);
return(1);
}
/*Se cierran los archivos*/
close (fd1);
close (fd2);
/*Comprobación de tamaño y bucle para verificar si los archivos son iguales o no*/
if (bstat1.st_size != bstat2.st_size) printf (“Los archivos son diferentes en tamaño”);
else /* Bucle que comprobara si son iguales o no*/
{
p = archivo1;
q = archivo2;
while ((i<= bstat1.st_size) &&(Distintos==0))
{
*q++ = * p++;
if (q != p)Distintos = 1;
}
}
If (Distintos ==1) printf (“Los archivos son de igual tamaño pero diferente contenido”)
Else printf (“Los archivos son iguales”);
/* Deshacemos las proyecciones*/
munmap (archivo1,bstat1.st_size);
munmap (archivo2,bstat2.st_size);
}
EJERCICIO 4.8
Escriba un programa que use los servicios Win32 de proyección de archivos para comparar dos archivos.
En este caso hemos quitado algunos controles de error con el fin de simplificar el código y que sea más legible. Suponemos que estos errores no aparecerán.
#include
#include
#include
#include
#include
#include
int main (int argc, char **argv)
{
int fd1,fd2,i = 0, Distintos = 0;
char caracter;
char *p, *q;
/* Abre el primer archivo para lectura */
if ((fd1=open (argv[1], O_RDONLY))<0)
{
perror(“No puede abrirse el archivo”);
return(1);
}
/* Abre el segundo archivo para lectura */
if ((fd2=open (argv[2], O_RDONLY))<0)
{
perror(“No puede abrirse el archivo”);
return(1);
}
/* Averigua la longitud de los archivos*/
if (fstat(fd1,&bstat1)<0)
{
perror(“Error en fstat del archivo1”);
close(fd1);
close(fd2);
return(1);
}
if (fstat(fd2,&bstat2)<0)
{
perror(“Error en fstat del archivo2”);
close(fd2);
close(fd1);
return(1);
}
/* Se proyectan los archivos */
Id _Proy1 = CreateFileMapping(fd1, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, Proyección1);
Proyeccion1 = mapViewOfFile(Id _Proy1, DesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap );
Id _Proy2 = CreateFileMapping(fd2, lpFileMappingAttributes, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow, Proyección2);
Proyeccion2 = mapViewOfFile(Id _Proy2 ,DesiredAccess, dwFileOffsetHigh, dwFileOffsetLow, dwNumberOfBytesToMap );
/*Se cierran los archivos*/
close (fd1);
close (fd2);
/*Comprobación de tamaño y bucle para verificar si los archivos son iguales o no*/
if (Id _Proy1. dwNumberOfBytesToMap != Id _Proy2. dwNumberOfBytesToMap) printf (“Los archivos son diferentes en tamaño”);
else /* Bucle que comprobara si son iguales o no*/
{
p = Id _Proy1;
q = Id _Proy2;
while ((i<= Id _Proy1. dwNumberOfBytesToMap) &&(Distintos==0))
{
*q++ = * p++;
if (q != p)Distintos = 1;
}
}
If (Distintos ==1) printf (“Los archivos son de igual tamaño pero diferente contenido”)
Else printf (“Los archivos son iguales”);
/* Deshacemos las proyecciones*/
UnmapViewOfFile(Proyeccion1);
UnmapViewOfFile(Proyeccion2);
}
EJERCICIO 4.10
¿ Por qué una cache que se accede con direcciones virtuales permite que el acceso a la TLB y a la cache se hagan en paralelo y, en cambio, una que se accede con direcciones físicas no lo permite? ¿ Por qué es conveniente que las caches que se acceden con direcciones físicas tengan el mismo tamaño que la página?
Porque en el primer caso ambas direcciones se corresponden y se pueden comparar, mientras que en el segundo caso no podemos comparar dirección física con virtual.
Para poder anular la caché más fácilmente cuando haga cambios en la memoria y así evitamos posibles inconsistencias.
EJERCICIO 4.11
La secuencia que se utiliza típicamente como ejemplo de la anomalía de Belady es la siguiente:
1 2 3 4 1 2 5 1 2 3 4 5
Analice cuántos fallos de página se producen al usar el algoritmo FIFO teniendo 3 marcos y cuántos con 4 marcos. Compárelo con el algoritmo LRU. ¿Qué caracteriza a los algoritmos de reemplazo de pila?
Con 3 marcos y el algoritmo FIFO se tendrían 5 fallos de página, distribuidos en dos fallos para la página 4 y un fallo para las páginas 1, 3 y 5.
Con 4 marcos y el algoritmo FIFO se tendrían 6 fallos de página, distribuidos en dos fallos para la página 5 y un fallo para el resto de las páginas.
Con 3 marcos y el algoritmo LRU se tendrían 7 fallos de página, distribuidos en dos fallos para la página 4 y un fallo para las páginas 1,2, 3 y 5.
Con 4 marcos y el algoritmo LRU se tendrían 2 fallos de página, distribuidos en un fallo para la página 4 y un fallo para las páginas 5.
Como se puede observar el número de fallos de página es mucho inferior en LRU a medida que aumentamos el número de marcos. Sin embargo, este cambio no es tan acusado en el algoritmo FIFO que se mantiene más constante.
Esto se debe a que el algoritmo LRU no sufre la anomalía de Belady, ya que, pertenece a la familia de los algoritmos de pila. La característica principal de estos algoritmos es que las páginas residentes en memoria para un sistema con n marcos de página son siempre un subconjunto de las que habría en un subconjunto de n+1 marcos. Esta propiedad es la que asegura que estos algoritmos no sufran la anomalía de Belady.
EJERCICIO 4.12
Exponga uno o más ejemplos de las siguientes situaciones:
- Fallo de página que no implica operaciones de entrada/salida.
Ej: Cuando el SSOO comprueba que la dirección a la que se está intentando acceder es inválida y decide abortar el proceso.
Ej: Cuando se emplea buffering de páginas.
- Fallo de página que implica sólo una operación de lectura.
Ej: Cuando hay marcos libres y se quiere leer una página.
- Fallo de página que implica sólo una operación de escritura.
Ej: Cuando se quieren crear huecos libres.
- Fallo de página que implica una operación de lectura y una de escritura.
Ej: Cuando se quiere leer y no hay huecos libres.
EJERCICIO 4.14
Resuelva el ejercicio anterior suponiendo que hay buffering de páginas.
La diferencia cuando hay buffering, es que el sistema operativo reserva una serie de marcos libres en memoria y cuando se produce un fallo de página, asigna un marco libre. Hay un umbral de marcos libres, que cuando es rebasado el SSOO comienza a aplicar el algoritmo de reemplazo hasta que se llega a sobrepasar el umbral de nuevo.
EJERCICIO 4.15
Consulte las páginas de manual de los servicios dlopen y dlsym disponibles en algunos sistemas UNIX que permiten solicitar la carga de una biblioteca dinámica y acceder a un símbolo de la misma. Escriba un programa que use esta función para cargar una biblioteca dinámica y ejecutar una función de la misma.
#include
ManejadorDLL = dlopen(/Usr/lib/ficheroDLL, RTLD_LAZY); /* Abre fichero DLL*/
Error = dlerror();
If Error <> NULL printf (“ Error : %c “, Error);
Direccion_Funcion1 = dlsym(ManejadorDLL, funcion1); /* Accedemos a la funcion1 de la biblioteca dinámica ficheroDLL ubicada en /Usr/lib */
Error = dlerror();
If Error <> NULL printf (“ Error : %c “, Error);
Dlclose(ManejadorDLL); /* Cerramos la biblioteca dinámica */
En el ejemplo se simula la carga de un fichero de biblioteca, cuya ubicación y nombre son /Usr/lib/ficheroDLL, y cuyo manejador es ManejadorDLL. Despues se accede a la función que se quiera (en este caso una supuesta función “funcion1”) de esta DLL, a través de dlsym y finalmente se cierra el manejador.
EJERCICIO 4.16
Consulte el manual de los servicios LoadLibrary y GetProcAddress disponibles en Win32 que permiten solicitar la carga de una biblioteca dinámica y acceder a un símbolo de la misma. Escriba un programa que use esta función para cargar una biblioteca dinámica y ejecutar una función de la misma.
El servicio LoadLibrary tiene la siguiente sintaxis,
HINSTANCE LoadLibrary( LPCTSTR lpLibFileName // address of filename of executable module);
donde lpLibFileName se refiere a la dirección del fichero donde se encuentra la librería dinámica(*.DLL).
Si el path especificado no contiene al fichero indicado, la instrucción falla.
Si el parámetro no especifica un path, la instrucción emplea una estrategia de búsqueda para encontrar el fichero.
Si la función se cumple con éxito, es manejada por el módulo, pero si no fue así retorna un valor null, y para saber más del error habrá que llamar a GetLastError
El servicio GetProcAddress tiene la siguiente sintaxis,
GetProcAddress
The GetProcAddress function returns the address of the specified exported dynamic-link library (DLL) function.
FARPROC GetProcAddress(
HMODULE hModule, // handle to DLL module
LPCSTR lpProcName // name of function
);
donde HMODULE se refiere al manejador de la DLL que contiene la función. LoadLibrary o GetModuleHandle devuelven este manejador y LPCSTR se refiere al nombre de la función dentro del módulo DLL.
Como los lenguajes son muchos y siempre hay más de una implementación, haremos un pequeño extracto de pseudocódigo, que será suficiente para ver las líneas de código más importantes:
Suponiendo la DLL “Biblioteca” y una función dentro de esta DLL llamada “función”, además de un manejador de DLL “manejador, solo tendríamos que realizar las siguientes llamadas:
Manejador = LoadLibrary( LPCTSTR Biblioteca); // dirección de la DLL
GetProcAddress(HMODULE Manejador, LPCSTR Función); // Manejador de DLLy nombre de la función dentro de la DLL
Con esto y las declaraciones previas de librerías de sistema y de variables que siempre requiere un lenguaje tal como podría ser C, quedaría implementada la funcionalidad requerida.
EJERCICIO 4.17
Como se comento en la explicación del algoritmo de reemplazo LRU, el tiempo que se debe usar para seleccionar la página menos recientemente usada es el tiempo lógico de cada proceso y no el tiempo real. Modifique la implementación basada en contadores propuesta en el texto para que tenga en cuenta esta consideración.
Lo único que hay que hacer es usar un contador monótono creciente para dar valor al campo LRU de cada página. Con este contador, que se inicia a 1, cada vez que se toca una página se incrementa en 1 el contador. De esta forma, las páginas más recientes, tienen el contador más alto.
Este contador mide el “tiempo lógico” de un proceso en cuanto a accesos a páginas se refiere y lo relaciona con el tiempo global lógico de todos los procesos del sistema.
EJERCICIO 4.18
Un algoritmo de reemplazo no descrito en el texto es el MFU (menos frecuentemente utilizada). Este algoritmo elige para el reemplazo aquella página que se haya utilizado menos frecuentemente. Analice cuál son los puntos más fuertes y débiles de este algoritmo y plantee una implementación de este algoritmo.
La principal ventaja del algoritmo MFU es que tiene un rendimiento similar a LRU, con la ventaja de que MFU a diferencia de LRU se implementa en software, con lo cual, no necesita que la máquina en la que este implementado posea un hardware específico.
El principal problema del algoritmo MFU es que nunca olvida. Esto en determinadas circunstancias podría llevar a que el sistema operativo elimine las páginas útiles en vez de las que ya no se utilizan. La razón es que si una página se usó muy frecuentemente en el pasado, tendrá un valor de frecuencia alto y no será elegida como víctima, aunque nunca más se vuelva a usar.
Una posible implementación de MFU es usando un contador de valor inicial 0 (a nivel software) asociado a cada página e incrementarlo cada vez que se accede a la página. Para resolver el problema anterior, se podría intentar hacer una mezcla de LRU y MFU usando dos contadores.
EJERCICIO 4.19
Codifique cuál sería la rutina de tratamiento de fallo de página en un sistema con memoria virtual que no usa buffering de páginas ni preasignación de swap. Tenga en cuenta la influencia de las distintas características de las regiones (p.ej.: si es privada o compartida).
La codificación la haremos en pseudocódigo, para que la posible dificultad del lenguaje, no dificulte, la comprensión de como se resuelve el problema.
Excepción_de_MMU; /* La MMU provoca una excepción */
Cargar(dirección fallida); /* La MMU carga la dirección que provoca el fallo en un registro*/
If (página_fallida = Inválida) Then Abortar_Proceso() /* La página no valía */
Else /* La página no está en memoria pero es válida */
{
If (Marco_Libre() = TRUE) Then Escribir_Página_En_Marco_Libre(Página_Fallida, Marco)
Else
{
Algoritmo_Reemplazo(Pagina_Expulsada);
Pagina_Expulsada.Inválida = TRUE;
Página_Fallida.Válida = TRUE;
Marco.utilizado = TRUE;
}
}
EJERCICIO 4.20
Resuelva el problema anterior para un sistema con buffering de páginas y preasignación de swap.
La resolución del problema es más simple que la del ejercicio anterior, ya que, ahora tenemos preasignación de swap, con lo cual, tenemos un espacio reservado para la página expulsada( ya hay un marco). Además tenemos bufferingde páginas, con lo que, tenemos un marco libre para la página que provoca el fallo, y no tenemos que aplicar el algoritmo de reemplazo.
El código es como el del ejercicio anterior, pero más simplificado:
Excepción_de_MMU; /* La MMU provoca una excepción */
Cargar(dirección fallida); /* La MMU carga la dirección que provoca el fallo en un registro*/
If (página_fallida = Inválida) Then Abortar_Proceso() /* La página no valía */
Else /* La página no está en memoria pero es válida */
{
Escribir_Página_En_Marco_Libre(Página_Fallida, Marco) /* Ahora siempre hay un marco libre gracias al buffering de páginas*/
Pagina_Expulsada.Inválida = TRUE;
If (Pagina_Expulsada.Modificada = TRUE) then
Escribir_En_Memoria_Secundaria(Pagina_Expulsada, Hueco_Libre_Valido);
Página_Fallida.Válida = TRUE;
Marco.utilizado = TRUE;
}
EJERCICIO 4.21
En la descripción de la técnica COW se explicó que para implementar esta técnica generalmente se pone la página con una protección de solo lectura. Analice como sería la rutina de tratamiento de la excepción que se produce al escribir en una página de este tipo para implementar la técnica COW.
La excepción que llamaría a la rutina de tratamiento vendría producida por un proceso , que trata de escribir en una región compartida, cuando el SSOO utiliza la técnica COW.
La rutina tendría los siguientes pasos:
+ El SSOO crea una copia privada de la página compartida para el proceso que provocó la excepción.
+ El SSOO decrementa el contador de procesos para la región compartida (ya que el proceso de la excepción , ahora utilizará su copia privada, y por tanto, la región compartida de antes será utilizada por un proceso menos).
+ Si el contador llega a 1, se quita la marca de COW, ya que, la página ya no tendrá duplicados.
EJERCICIO 4.22
Muchas implementaciones de UNIX realizan la carga de las bibliotecas dinámicas utilizando el servicio nmap. Explique que parámetros deberían especificarse para cada una de las secciones de una biblioteca.
La llamada nmap de UNIX, ubica ficheros en memoria. Esta llamada emplea los siguientes parámetros.
caddr_t mmap(void *start, size_t length, int prot, int
flags, int fd, off_t offset);
El parámetro start, se refiere a la dirección del objeto que contendrá la ubicación en memoria. Esta dirección es una preferencia pero no una obligación.
Length se refiere al número de bytes que se quiere proyectar en memoria.
El desplazamiento de “Length” bytes se hace desde la dirección offset y desde el fichero (u otro objeto) especificado por fd en memoria.
El argumento prot describe la protección de memoria deseada. Lo forman los
siguientes bits:
PROT_EXEC Las páginas deben ser ejecutadas.
PROT_READ Las páginas deben ser leídas.
PROT_WRITE Las páginas deben ser escritas.
PROT_NONE Las páginas no pueden ser accedidas.
El parámetro flags especifica el tipo de objeto insertado,
las opciones de asociación y si las modificaciones hechas
a la copia insertada en memoria son privadas al proceso o
son compartidas por otras referencias. Tiene los bits:
MAP_FIXED No seleccionar una dirección diferente a la
especificada. Si la dirección especificada no
puede ser utilizada, mmap fallará. Si MAP_FIXED
es especificado, start debe ser un múltiplo del
tamaño de página. Utilizar esta opción es
desaconsejable.
MAP_SHARED Comparte este área con todos los otros objetos
que señalan a este objeto.
MAP_PRIVATE
Crear un área privada "copy-on-write".
Debe especificarse exactamente uno de los parámetros
MAP_SHARED o MAP_PRIVATE.
MAP_DENYWRITE, MAP_EXECUTABLE y MAP_ANONYMOUS.
VALOR DEVUELTO
Si ha funcionado mmap devuelve un puntero al área reser
vada. En caso de error, es devuelto -1, y errno es modi
ficado apropiadamente.
ERRORES
EBADF fd no es un descriptor de fichero válido (y MAP_ANONYMOUS no ha sido fijado).
EACCES MAP_PRIVATE fue indicado, pero fd no ha sido abierto para lectura. O MAP_SHARED fue invocado y PROT_WRITE fue fijado, y fd no está abierto para escritura.
EINVAL No es correcto start o length o offset. (E.g., son demasiado grandes, o no están alineados en los límites de un valor múltiplo de PAGESIZE).
ETXTBUSY MAP_DENYWRITE fue fijado pero el objeto especifi cado por fd está abierto para escritura.
EAGAIN El fichero ha sido bloqueado, o se ha bloqueado una cantidad excesiva de memoria.
ENOMEM No hay memoria disponible.
EJERCICIO 4.23
Acceda en un sistema Linux al archivo /proc/self/maps y analice su contenido.
A continuación se muestra un ejemplo del contenido del directorio /proc/sef/maps en un sistema UNIX.
Zona de memoria Permisos Tamaño
08048000-080b0000 r-xp 00000000 03:06 65286 /bin/bash
080b0000-080b4000 rw-p 00067000 03:06 65286 /bin/bash
080b4000-08106000 rwxp 00000000 00:00 0
40000000-40015000 r-xp 00000000 03:06 130571 /lib/ld-2.2.2.so
40015000-40016000 rw-p 00014000 03:06 130571 /lib/ld-2.2.2.so
40016000-40017000 r--p 00000000 03:06 131930 /usr/share/locale/es/LC_IDENTIFICATION
40017000-40018000 r--p 00000000 03:06 132014 /usr/share/locale/es/LC_MEASUREMENT
40018000-40019000 r--p 00000000 03:06 149287 /usr/share/locale/es/LC_TELEPHONE
40019000-4001a000 r--p 00000000 03:06 132015 /usr/share/locale/es/LC_ADDRESS
4001a000-4001b000 r--p 00000000 03:06 132012 /usr/share/locale/es/LC_NAME
4001b000-4001c000 r--p 00000000 03:06 132010 /usr/share/locale/es/LC_PAPER
4001c000-4001d000 r--p 00000000 03:06 34786 /usr/share/locale/es_ES/LC_MESSAGES/SYS_LC_MESSAGES
4001d000-4001e000 r--p 00000000 03:06 132013 /usr/share/locale/es_ES/LC_MONETARY
4001e000-4001f000 r--p 00000000 03:06 132002 /usr/share/locale/es_ES/LC_TIME
4001f000-40020000 r--p 00000000 03:06 132011 /usr/share/locale/es_ES/LC_NUMERIC
40022000-40023000 rw-p 00000000 00:00 0
40023000-40045000 r-xp 00000000 03:06 130568 /lib/libreadline.so.4.1
40045000-40049000 rw-p 00021000 03:06 130568 /lib/libreadline.so.4.1
40049000-4004a000 rw-p 00000000 00:00 0
4004a000-4004f000 r-xp 00000000 03:06 130566 /lib/libhistory.so.4.1
4004f000-40050000 rw-p 00004000 03:06 130566 /lib/libhistory.so.4.1
40050000-40053000 r-xp 00000000 03:06 130570 /lib/libtermcap.so.2.0.8
40053000-40054000 rw-p 00002000 03:06 130570 /lib/libtermcap.so.2.0.8
40054000-40057000 r-xp 00000000 03:06 130580 /lib/libdl-2.2.2.so
40057000-40058000 rw-p 00002000 03:06 130580 /lib/libdl-2.2.2.so
40058000-4017c000 r-xp 00000000 03:06 130576 /lib/libc-2.2.2.so
4017c000-40181000 rw-p 00123000 03:06 130576 /lib/libc-2.2.2.so
40181000-40185000 rw-p 00000000 00:00 0
40185000-4018b000 r--p 00000000 03:06 1715 /usr/share/locale/es/LC_COLLATE
4018b000-401a6000 r--p 00000000 03:06 114870 /usr/share/locale/ISO-8859-1/LC_CTYPE
401a6000-401a8000 r-xp 00000000 03:06 163335 /usr/lib/gconv/ISO8859-1.so
401a8000-401a9000 rw-p 00001000 03:06 163335 /usr/lib/gconv/ISO8859-1.so
401b2000-401bc000 r-xp 00000000 03:06 130590 /lib/libnss_files-2.2.2.so
401bc000-401bd000 rw-p 00009000 03:06 130590 /lib/libnss_files-2.2.2.so
401bd000-401c7000 r-xp 00000000 03:06 130596 /lib/libnss_nisplus-2.2.2.so
401c7000-401c8000 rw-p 00009000 03:06 130596 /lib/libnss_nisplus-2.2.2.so
401c8000-401c9000 rw-p 00000000 00:00 0
401c9000-401dc000 r-xp 00000000 03:06 130584 /lib/libnsl-2.2.2.so
401dc000-401dd000 rw-p 00012000 03:06 130584 /lib/libnsl-2.2.2.so
401dd000-401df000 rw-p 00000000 00:00 0
401df000-401e9000 r-xp 00000000 03:06 130594 /lib/libnss_nis-2.2.2.so
401e9000-401ea000 rw-p 00009000 03:06 130594 /lib/libnss_nis-2.2.2.so
bfffb000-c0000000 rwxp ffffc000 00:00 0
La peculiaridad de este archivo en relación con este tema, es que en el encontramos parámetros de la llamada locale de UNIX, que sirve para configurar parámetros compartidos del sistema tales como la región y la zona horaria.
EJERCICIO 4.24
En Win32 se pueden crear múltiples heaps. Analice en que situaciones puede ser interesante esta característica.
Un “heap” es una porción de memoria reservada para un programa con el fin de almacenar temporalmente estructuras de datos, cuya existencia, o tamaño no pueden ser determinados antes de la ejecución del programa. El programa puede solicitar memoria libre desde el “Heap” si lo necesita para mantener todos los, elementos en uso, y después, puede liberar esta memoria. También contiene algunos archivos de librerías, así como de memoria compartida (Share).
EJERCICIO 4.25
Algunas versiones de UNIX proporcionan una llamada denominada vfork que crea un hijo que utiliza directamente el mapa de memoria del proceso padre que queda bloqueado hasta que el hijo ejecuta un exec o termina. En este momento el padre recupera su mapa. Analice qué ventajas y desventajas presenta el uso de este nuevo servicio frente a la utilización del fork convencional. En este análisis suponga primero que el fork se implementa sin usar la técnica COW para a continuación considerar que si se utiliza.
En linux, fork está implementado usando la técnica COW o de páginas de copia- en-escritura (copy-on-write), así que la única penalización en que incurre fork es en el tiempo y memoria requeridos para duplicar las tablas de las páginas del padre, y para crear una única estructura de tarea (task structure) para el hijo.
La desventaja de Vfork es que se comparta memoria y la ventaja es que no se copia memoria. Sin embargo, con la técnica COW, el fork, tampoco copia en memoria y no merece la pena.
Si no se usa COW, fork copia toda la memoria y vfork no.
EJERCICIO 4.26
¿Por qué es necesario mantener al menos una página inválida entre la región de pila y la región que esta situada justo encima?
Para que haya una excepción, caso de que, se salga de la pila antes de entrar en otra región.
EJERCICIO 4.27
Analice qué puede ocurrir en un sistema que usa paginación por demanda si se recompila un programa mientras se esta ejecutando. Proponga soluciones a los problemas que pueden surgir en esta situación.
Dado que se usa el fichero para cargar en memoria, si se modifica, se mezclarán páginas del fichero antiguo con páginas del fichero nuevo y habrá posibles inconsistencias.
EJERCICIO 4.28
En POSIX se define el servicio msync que permite forzar la escritura inmediata de una región al soporte. ¿ En que situaciones puede ser interesante usar esta función?
msync vuelca a disco los cambios hechos en la copia en memoria de un fichero que ha sido mapeado en memoria empleando mmap. Sin la utilización de esta llamada no está garantizado que los cambios se escriban de vuelta
antes de que se llame a munmap. Esto puede ser muy interesante en algunos casos como por ejemplo cuando se cae inesperádamente el sistema, permitiendo tener una rutina que permita a través del servicio msync, guardar todo lo proyectado en memoria, lo más actualizado posible.
EJERCICIO 4.29
Cuando se produce un fallo en una página que pertenece a una región compartida, se trae a memoria secundaria la página y se actualiza la entrada de la tabla de páginas del proceso que causo el fallo. ¿ Cómo se enteran el resto de los procesos que comparten la página de que esta ya esta en memoria?
Se enteran porque al traer a memoria la página, el SSOO tiene almacenada información de todos los procesos que acceden a esta página compartida y en ese caso el SSOO se encarga de actualizar el bit de presente/ausente en dichos procesos.
EJERCICIO 4.30
El mecanismo de buffering permite recuperar una página que esta en la lista de libres ya que todavía no se ha reutilizado el marco que la contiene. ¿ Cómo se puede implementar esta búsqueda en la lista para que se haga de forma eficiente ?
Usando la tabla hash con direcciones físicas.
EJERCICIO 4.31
Analice que situaciones se pueden producir en el tratamiento de un fallo de TLB en un sistema que tiene una gestión software de la TLB.
En un sistema cuya TLB va gestionada por Software, y tras producirse un fallo de página ocurre lo siguiente:
+ La MMU busca la traducción en la TLB. Si la encuentra la inserta en memoria principal y listo. Pero si no la encontrara se produciría el fallo de página y se activa el SSOO.
+ El SSOO operativo busca en la tabla de páginas “a mano” e inserta en la TLB la traducción, desde donde la MMU, ya sabe introducirla en memoria principal.
EJERCICIO 4.32
Con el uso de la técnica de proyección de archivos se produce una cierta unificación entre el sistema de archivos y la gestión de memoria. Puesto que, como se verá en el capítulo dedicado a los archivos, el sistema de archivos usa una cache de bloques al disco, analice que tipo de incoherencias pueden producirse si se accede a un archivo usando la proyección y las primitivas convencionales del sistema de archivos.
Si se accede a un fichero con proyección y con operaciones de lectura/ escritura, en ocasiones, ocurre que los bloques de datos se almacenan en lugares distintos y se pueden crear incoherencias.
