Tema 4 Gestión de memoria

1. Tema 4Gestión de memoria

2. Contenido • Requisitos de la gestión de memoria • Modelo de memoria de un proceso • Fases en la generación de un ejecutable • Ficheros proyectados en memoria • Servicios de gestión de memoria • Evolución de los sistemas de gestión de memoria • Memoria virtual

3. Requisitos de gestión de memoria • S.O. multiplexa recursos entre procesos • Cada proceso cree que tiene una máquina para él solo • Gestión de procesos: Reparto de procesador • Gestión de memoria: Reparto de memoria • Propiedades deseables: • Ofrecer a cada proceso un espacio lógico propio • Proporcionar protección entre procesos • Permitir que procesos compartan memoria • Dar soporte a regiones del proceso • Maximizar rendimiento del sistema

4. Funciones del gestor de memoria • Saber qué partes de la memoria están siendo utilizadas. • Cargar programas en MP para su ejecución. • Proporcionar memoria a los procesos cuando la soliciten. • Liberarla cuando se requiera. • Gestionar el intercambio (swapping). • Protección. • Entre procesos. • Entre el SO y los procesos • Memoria compartida. • Procesos que ejecutan el mismo código. • Como mecanismo de comunicación.

5. Modelo de memoria de un proceso • Un proceso está formado por una serie de regiones. • Región: zona contigua del espacio de direcciones de un proceso con las mismas propiedades. • Tipos de regiones básicos: • Texto: código • Datos • Pila

6. Programa ejemplo int a; int b = 5; void f(int c) { int d; static e = 2; b = d + 5; ....... return; } main (int argc, char **argv) { char *p; p = (char *) malloc (1024) f(b) ....... free (p) .... exit (0) } Tipos de memoria 1.- Código 2.- Datos declarados Globales Con valor inicial Sin valor inicial Locales Con valor inicial Sin valor inicial

7. Programa ejemplo: Fichero ejecutable int a; int b = 5; void f(int c) { int d; static e = 2; b = d + 5; ....... return; } main (int argc, char **argv) { char *p; p = (char *) malloc (1024) f(b) ....... free (p) .... exit (0) }

8. Programa ejemplo: Exec int a; int b = 5; void f(int c) { int d; static e = 2; b = d + 5; ....... return; } main (int argc, char **argv) { char *p; p = (char *) malloc (1024) f(b) ....... free (p) .... exit (0) }

9. Programa ejemplo: malloc int a; int b = 5; void f(int c) { int d; static e = 2; b = d + 5; ....... return; } main (int argc, char **argv) { char *p; p = (char *) malloc (1024) f(b) ....... free (p) .... exit (0) }

10. Programa ejemplo: Llamada a f int a; int b = 5; void f(int c) { int d; static e = 2; b = d + 5; ....... return; } main (int argc, char **argv) { char *p; p = (char *) malloc (1024) f(b) ....... free (p) .... exit (0) }

11. Gestión de memoria en sistemas monoprogramados • Modelo de memoria 0 SO Usuario Usuario SO FFF...

12. SO Gestión de memoria en sistemas monoprogramados II • Overlays 0 Zona común Zonade solapamiento Mod 1 Mod 2 Mod 3 FFF...

13. Multiprogramación • Ventajas: • Facilita la programación, dividiendo los programas en procesos. • Permite el servicio interactivo simultáneo a varios usuarios de forma eficiente. • Aprovecha los tiempos que los procesos pasan esperando a que se completen sus operaciones de E/S. • Aumenta el uso de la CPU. • Grado de multiprogramación: número de procesos en memoria.

14. Modelo de multiprogramación • Un proceso gasta p% de tiempo por E/S. • Si el grado de multiprogramación es n => • La probabilidad de que todos estén esperando es pn . • Utilización de la CPU: 1 - pn. • Este modelo es sólo una aproximación (supone que los n procesos son independientes). • En un sistema monoprocesador esto no es cierto (un proceso ha de esperar cuando la CPU está ocupada). • Este modelo puede proporcionar predicciones aproximadas sobre el rendimiento de la CPU.

15. Modelo de multiprogramación II

16. Reubicación • En un sistema multiprogramado es imposible conocer en tiempo de compilación y montaje qué direcciones ocupará un proceso en memoria => reubicación • Solución: emplear direcciones lógicas • Tres alternativas: • Reubicación hardware • Reubicación software • Programa reubicable (no tiene direcciones absolutas)

17. Reubicación hardware • Hardware encargado de traducción • El S.O. se encarga de: • Almacena por cada proceso su función de traducción • Especifica al hardware qué función aplicar para cada proceso • Programa se carga en memoria sin modificar • Para el ejemplo anterior:

18. Reubicación software • Traducción de direcciones durante carga del programa • Programa en memoria distinto del ejecutable • Desventajas: • No asegura protección • No permite mover programa en tiempo de ejecución • Para el ejemplo anterior:

19. Protección • Monoprogramación: Protección del SO • Multiprogramación: Además procesos entre sí • Traducción debe crear espacios disjuntos • Necesario validar todas las direcciones que genera el programa • La detección debe realizarla el hardware del procesador • El tratamiento lo hace el SO (envía KILL al proceso)

20. Reubicación y protección

21. Compartir memoria • Direcciones lógicas de 2 o más procesos se corresponden con misma dirección física • Bajo control del S.O. • Beneficios: • Procesos ejecutando mismo programa comparten su código • Mecanismo de comunicación entre procesos muy rápido • Requiere asignación no contigua:

22. Maximizar rendimiento • Reparto de memoria maximizando grado de multiprogramación • Aprovechamiento de memoria óptimo e irrealizable: • Paginación: solución factible con aprovechamiento aceptable • Uso de memoria virtual para aumentar grado de multiprogramación

23. Fases en generación de ejecutable • Aplicación: conjunto de módulos en lenguaje de alto nivel • Procesado en dos fases: Compilación y Montaje • Compilación: • Resuelve referencias dentro cada módulo fuente • Genera módulo objeto • Montaje (o enlace): • Resuelve referencias entre módulos objeto • Resuelve referencias a símbolos de bibliotecas • Genera fichero ejecutable • Carga en memoria • Añade rutinas de biblioteca

24. Bibliotecas estáticas • Biblioteca: colección de módulos objeto relacionados • Bibliotecas del sistema o creadas por el usuario • Bibliotecas Estáticas: • Montaje: enlaza los módulos objeto del programa y de las bibliotecas • Ejecutable autocontenido • Desventajas del montaje estático: • Ejecutables grandes • Código de función de biblioteca repetido en muchos ejecutables • Múltiples copias en memoria del código de función de biblioteca • Actualización de biblioteca implica volver a montar

25. Bibliotecas dinámicas • Carga y montaje de biblioteca en tiempo de ejecución • Ejecutable contiene: • Nombre de la biblioteca • Rutina encargada de carga y montaje en tiempo de ejecución ante primera referencia • Ventajas del montaje dinámico: • Menor tamaño ejecutables • Código de rutinas de biblioteca sólo en fichero de biblioteca • Procesos pueden compartir código de biblioteca • Actualización automática de bibliotecas: Uso de versiones

26. Bibliotecas dinámicas

27. Bibliotecas dinámicas • Proceso: • El programa principal llama a la pseudo función XX • Esta función contacta con el SO y le pide la función XX • El SO comprueba que la función XX está definida en una biblioteca dinámica. • El SO operativo comprueba si XX ya está cargada en memoria por algún proceso • En caso negativo la carga • En caso positivo comparte esa zona de memoria con este proceso • El SO devuelve un puntero a la Pseudo XX para que pase la llamada a XX

28. Formato del ejecutable • Distintos fabricantes usan diferentes formatos • Ejemplo: Executable and Linkable Format (ELF) • Estructura: Cabecera y conjunto de secciones • Cabecera: • Número mágico • Punto de entrada del programa • Tabla de secciones

29. Formato del ejecutable

30. Secciones del ejecutable • Variedad de tipos de secciones. Ejemplo: • Tabla de símbolos para depuración • Lista de bibliotecas dinámicas usadas • Más relevantes en mapa de memoria del proceso: • Código, Datos con valor inicial y Datos sin valor inicial • Código (texto) • Contiene código del programa • Datos con valor inicial • Variables globales inicializadas • Datos sin valor inicial • Variables globales no inicializadas • Aparece en tabla de secciones pero no se almacena en ejecutable • ¿Por qué no hay sección vinculada a variables locales?

31. Variables globales versus locales • Variables globales • Estáticas • Se crean al iniciarse programa • Existen durante ejecución del mismo • Dirección fija en memoria y en ejecutable • Variables locales y parámetros • Dinámicas • Se crean al invocar función • Se destruyen al retornar • La dirección se calcula en tiempo de ejecución • Recursividad: varias instancias de una variable

32. Variables globales versus locales • Ejemplo: int x=8; /* Variable global con valor inicial */ int y; /* Variable global sin valor inicial */ f(){ int z; /* Variable local */ ....... } main(){ ....... }

33. Crear mapa de memoria desde ejecutable • Código • Compartida, RX, T. Fijo, Soporte en Ejecutable • Datos con valor inicial • Privada, RW, T. Fijo, Soporte en Ejecutable • Datos sin valor inicial • Privada, RW, T. Fijo, Sin Soporte (rellenar 0) • Pila • Privada, RW, T. Variable, Sin Soporte (rellenar 0) • Crece hacia direcciones más bajas • Pila inicial: argumentos del programa

34. Crear mapa desde ejecutable

35. Otras regiones del mapa creadas durante ejecución • Región de Heap • Soporte de memoria dinámica (malloc en C) • Privada, RW, T. Variable, Sin Soporte (rellenar 0) • Crece hacia direcciones más altas • Fichero proyectado • Región asociada al fichero proyectado • Compartida, T. Variable, Soporte en Fichero • Protección especificada en proyección • Memoria compartida • Región asociada a la zona de memoria compartida • Compartida, T. Variable, Sin Soporte (rellenar 0) • Protección especificada en proyección • Pilas de threads • Cada pila de thread corresponde con una región • Mismas características que pila del proceso • Biblioteca dinámica • Regiones asociadas al código y datos de la biblioteca

36. Mapa de memoria de un proceso hipotético

37. Servicios de gestión de memoria • Gestor de memoria realiza funciones internas • Ofrece pocos servicios directos a aplicaciones • Servicios POSIX de gestión de memoria más usados: • Uso de memoria compartida (shm_open) • Proyección de ficheros y m. compartida (mmap) • Bloqueo de páginas en memoria principal • Asignación de memoria • Ya han sido estudiados • Presentamos ejemplos de proyección de ficheros

38. Ficheros proyectados en memoria

39. Ficheros proyectados en memoria II • Una región del proceso recibe el fichero. • Fichero como extensión del swap. • Habrá páginas del fichero en memoria principal. • El proceso direcciona dentro del fichero (región) con las instrucciones de acceso a memoria.

40. Ficheros proyectados: Servicios void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off); • Establece una proyección entre el espacio de direcciones de un proceso y un descriptor de fichero u objeto de memoria compartida. • Devuelve la dirección de memoria donde se ha proyectado el fichero. • addr dirección donde proyectar. Si NULL el SO elige una. • len especifica el número de bytes a proyectar. • prot el tipo de acceso (lectura, escritura o ejecución). • flags especifica información sobre el manejo de los datos proyectados (compartidos, privado, etc.). • fildes representa el descriptor de fichero del fichero o descriptor del objeto de memoria a proyectar. • off desplazamiento dentro del fichero a partir del cual se realiza la proyección. void munmap(void *addr, size_t len); • Desproyecta parte del espacio de direcciones de un proceso comenzando en la dirección addr.

41. Ejemplo: copia de ficheros #include <sys/types.h> #include <sys/stat.h> #include <sys/mman.h> #include <fcntl.h> #include <stdio.h> #include <unistd.h> main(int argc, char **argv) { int i, fdo, fdd; char *org, *dst, *p, *q; struct stat bstat; /* Abre el fichero origen para lectura */ fdo=open(argv[1], O_RDONLY); fdd=open(argv[2], O_CREAT|O_TRUNC|O_RDWR, 0640);

42. Ejemplo: copia de ficheros /* Averigua la longitud del fichero origen */ fstat(fdo, &bstat) /* Asigna tamaño al fichero destino */ ftruncate(fdd, bstat.st_size); /* Se proyecta todo el fichero origen (ver "man mmap") */ org=mmap(NULL, bstat.st_size, PROT_READ, MAP_SHARED, fdo, 0); /* Se proyecta todo el fichero destino (ver "man mmap" */ dst=mmap(NULL, bstat.st_size, PROT_WRITE, MAP_SHARED, fdd, 0); if (org == MAP_FAILED || dst == MAP_FAILED) perror("Error en mmap"); /* Se cierran los ficheros */ close(fdo); close(fdd);

43. Ejemplo: copia de ficheros /* Bucle de copia */ p=org; q=dst; for (i=0; i<bstat.st_size; i++) *q++= *p++; /* Se eliminan las proyecciones */ munmap(org, bstat.st_size); munmap(dst, bstat.st_size); }

44. Ejemplo II • Ejemplo: Cuántas veces aparece carácter en fichero int main(int argc, char **argv) { ...................................... fd=open(argv[2], O_RDONLY)); /* Abre fichero */ fstat(fd, &bstat); /* Averigua long. fichero */ /* Se proyecta el fichero */ org=mmap((caddr_t) 0, bstat.st_size, PROT_READ, MAP_SHARED, fd, 0)); close(fd); /* Se cierra el fichero */

45. Ejemplo II /* Bucle de acceso */ p=org; for (i=0; i<bstat.st_size; i++) if (*p++==caracter) contador++; /* Se elimina la proyeccion */ munmap(org, bstat.st_size); printf("%d\n", contador); }

46. Memoria compartida • La región puede proyectarse en cada proceso sobre direcciones virtuales diferentes.

47. Memoria compartida: Servicios int shm_open(char *name, int oflag, mode_t mode); • Crea un objeto de memoria a compartir entre procesos int shm_unlink(const char *name); • Borra una zona de memoria compartida. void *mmap(void *addr, size_t len, int prot,int flags, int fildes, off_t off); • Establece una proyección entre el espacio de direcciones de un proceso y un descriptor de fichero u objeto de memoria compartida. void munmap(void *addr, size_t len); • Desproyecta parte del espacio de direcciones de un proceso comenzando en la dirección addr. int close(int fd); • Cierra el descriptor de objeto de memoria compartida int ftruncate(int fd); • Asigna espacio a un fichero u objeto de memoria compartida.

48. Memoria compartida: Ejemplo (I) • Creación de un segmento de memoria compartida (proceso A): char *buffer; /* buffer a compartir */ int shd; /* se crea el objeto en un proceso */ shd = shm_open("BUFFER", O_CREAT|O_RDWR, 0777); /* se asigna espacio al segmento */ ftruncate(shd, MAX_BUFFER * sizeof(char)); /* se proyecta */ buffer = (char *) mmap(NULL, MAX_BUFFER * sizeof(char), PROT_READ | PROT_WRITE, MAP_SHARED, shd, 0);

49. Memoria compartida: Ejemplo (II) • Acceso a un segmento de memoria compartida (proceso B): char *buffer; /* buffer a compartir */ int shd; /* se crea el objeto en un proceso */ /* debe existir */ shd = shm_open("BUFFER"", O_RDWR); /* se proyecta */ buffer = (char *) mmap(NULL, MAX_BUFFER * sizeof(char), PROT_READ | PROT_WRITE, MAP_SHARED, shd, 0);

50. Utilización de memoria asignada • Se proyecta sobre la zona asignada una estructura • Se utiliza la estructura mediante un manejador (puntero) • Errores típicos de utilización: • Utilizar el manejador (puntero) después de haber liberado la memoria. Se utiliza una memoria que ya no está asignada • No liberar la memoria una vez terminado su uso. El sistema se puede quedar sin memoria • Para memoria compartida • Proyectar la misma estructura en todos los programas. ¿Compartir la definición de la estructura?