PDF de programación - Tema 8 - Gestión de memoria - Sistemas Operativos: Programación de Sistemas

Imágen de pdf Tema 8 - Gestión de memoria - Sistemas Operativos: Programación de Sistemas

Tema 8 - Gestión de memoria - Sistemas Operativos: Programación de Sistemasgráfica de visualizaciones

Actualizado el 26 de Octubre del 2020 (Publicado el 23 de Febrero del 2018)
576 visualizaciones desde el 23 de Febrero del 2018
309,9 KB
30 paginas
Creado hace 14a (17/01/2007)
Tema 8 : Gestión de memoria

Sistemas Operativos:
Programación de Sistemas

Oscar Déniz Suárez
Alexis Quesada Arencibia
Francisco J. Santana Pérez
Curso 2006-07

Introducción

otros objetos
y bibliotecas

bibliotecas
del sistema

bibliotecas
dinámicas

programa fuente

compilador

módulo objeto

enlazador
(linker)

programa ejecutable

cargador

carga

programa y datos

binarios en memoria

HARDWARE

ejecución

compilación

Fichero ejecutable

(principal)

cabecera

código

datos

inicializados

direcciones

Introducción
 A cada proceso se le asocia un espacio de
 Este espacio incluye:
 el código del proceso
 los datos del proceso
• variables inicializadas
• variables no inicializadas (bss)
utilizadas por el proceso

 el código y los datos de bibliotecas compartidas
 la pila usada por el proceso

Introducción

Direcciones altas

kernel

c0000000

parámetros y entorno

pila

datos no inici.(bss)
datos inicializados

código

exec los pone a 0

Leídos de
disco por exec

Direcciones bajas

Introducción
 Es importante entender la diferencia entre
dirección física y dirección lógica (virtual)

 Los procesos trabajan con espacio de

direcciones virtuales

 Algún módulo software y/o hardware se

encarga de traducir de direcciones virtuales a
físicas

 Zonas de memoria contiguas en espacio virtual

no tienen porqué estar físicamente contiguas

Introducción
 Dirección física: la que llega al chip de
 Dirección lógica o virtual: la generada por la
 El dispositivo que traduce direcciones virtuales

memoria
CPU
a físicas se llama unidad de manejo de
memoria (MMU, en inglés)
de direcciones físicas no tienen por qué
coincidir

 El espacio de direcciones lógicas y el espacio

 Ejemplo: registro base

Introducción

Fichero fuente
(principal.cc)

#include<stream.h>

main()
{
int cont;
...
cont++
...
}

Fichero ejecutable

(principal)

Memoria lógica del

proceso

cabecera

código

datos

inicializados

código

datos

inicializados

datos sin
inicializar

pila

Memoria física

MR

Proceso

Espacio de direcciones

simbólicas

Espacio de direcciones lógicas/físicas

Introducción

Dirección
lógica o
virtual

CPU

MMU

CPU

dir. lógica
1234

+

80000

registro base
MMU

dir. física
81234
memoria

Memoria

Disco

Controlador

de

memoria

Controlador

de
disco

Dirección física

Introducción
 En sistemas multiusario como Linux, a veces
conviene no mantener todo el espacio de
direcciones de un proceso en memoria, sobre
todo cuando está inactivo

 Así, otros procesos puede usar ese espacio
 Mediante el intercambio o swapping se

pueden llevar zonas de memoria a memoria
secundaria y viceversa

Introducción
 Para conocer las direcciones de memoria

donde se encuentran los segmentos de
código y de datos de un proceso hay
disponibles los siguientes símbolos:
extern int _end;
extern int _etext;
extern int _edata;

Introducción

parámetros y entorno

pila

program
break

datos no inici.(bss)

datos inicializados

código

_end

_data

_etext

El sistema de ficheros proc
 Pseudo-Sistema de ficheros montado

automáticamente en Linux que almacena
información del estado del sistema

 El sistema de ficheros proc no está asociado a

un dispositivo: es una “ventana” al kernel

 Es una forma conveniente de consultar y (en
algunos casos) modificar cosas en el sistema

El sistema de ficheros proc

 El fichero /proc/$pid/maps contiene información sobre los segmentos de
 Contiene rangos de direcciones, permisos, etc., no solo de su código sino

memoria de un proceso
también de las librerías compartidas a las que tiene acceso (p.ej. libc)

address perms offset dev inode pathname
08048000-08056000 r-xp 00000000 03:0c 64593 /usr/sbin/gpm
08056000-08058000 rw-p 0000d000 03:0c 64593 /usr/sbin/gpm
08058000-0805b000 rwxp 00000000 00:00 0
40000000-40013000 r-xp 00000000 03:0c 4165 /lib/ld-2.2.4.so
40013000-40015000 rw-p 00012000 03:0c 4165 /lib/ld-2.2.4.so
4001f000-40135000 r-xp 00000000 03:0c 45494 /lib/libc-2.2.4.so
40135000-4013e000 rw-p 00115000 03:0c 45494 /lib/libc-2.2.4.so
4013e000-40142000 rw-p 00000000 00:00 0
bffff000-c0000000 rwxp 00000000 00:00 0
 Consultar man 5 proc

Gestión de la memoria
#include <unistd.h>
int brk(char *endds);
char *sbrk(int incr);

el proceso que las invoca

 Permiten cambiar el tamaño del segmento de datos de
 brk establece la posición del program break
 sbrk varía el tamaño del segmento de datos:

 incr>0 incrementa memoria
 incr<0 reduce memoria

Gestión de la memoria

parámetros y entorno

parámetros y entorno

pila

pila

segmento de datos

segmento de datos

código

código

Gestión de la memoria
 La librería C estándar nos proporciona:
#include <stdlib.h>
void *malloc(size_t size);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);
void free(void *ptr);

Protección de la memoria
 Cada región de memoria de un proceso puede
tener establecidos determinados “derechos de
acceso”

 Los derechos de acceso a la memoria son
gestionados directamente por el procesador

 Linux permite a un proceso modificar las

protecciones de memoria asociadas a algunas
de las regiones de su espacio de
direccionamiento

Protección de la memoria
#include <sys/mman.h>
int mprotect(const void *addr, size_t len, int prot);
 mprotect modifica las protecciones de acceso
asociadas a la zona de memoria especificada
 prot =
 PROT_NONE = No se permite ningún acceso
 PROT_READ = Se permite leer
 PROT_WRITE = Se permite escribir
 PROT_EXE = Se permite ejecución

Bloqueo de memoria
 Un esquema de gestión de memoria

bastante empleado es la paginación por
demanda
 Carga de alguna página o escritura en
memoria secundaria => proceso suspendido
 Intolerable en sistemas de tiempo real

 Procesos con privilegios tienen la

posibilidad de bloquear ciertas páginas en
memoria

Bloqueo de memoria

 Llamadas al sistema que permiten el bloqueo/desbloqueo de zonas de

memoria:

#include <sys/mman.h>
int mlock (const void *addr, size_t len);
int munlock (const void *addr, size_t len);
int mlockall (int flags);
int munlockall (void);

 addr es la dir. de comienzo, len es el tamaño
 flags:
#define MCL_CURRENT 1
#define MCL_FUTURE 2
 El bloqueo/desbloqueo de zonas de memoria solo puede realizarlo un

/* Lock all currently mapped pages.*/
/* Lock all additions to address space. */

superusuario

Mapeado de archivos en memoria
 Se puede crear una correspondencia de un archivo de
 Las proyecciones de archivos en memoria ofrecen las

disco con la memoria, bit a bit
siguientes ventajas:
 La E/S de archivos es más rápida que si usáramos funciones
read y write, incluso aunque existe caché de disco
 El acceso es más sencillo, podemos usar punteros
 Pueden usarse para compartir datos. Puede hacerse que

múltiples procesos tengan acceso a la proyección de un fichero
en memoria

 Llamadas al sistema para gestionar la

proyección/mapeado de archivos en memoria: mmap,
munmap, mremap

Mapeado de archivos en memoria

Direcciones altas

Pila (stack)

Longitud

Porción del fichero
mapeado en memoria

Dirección de comienzo

Montículo(heap)

Datos no inicializados

(bss)

Datos incializados

Fichero

Porción del fichero
mapeado en memoria

Direcciones bajas

Texto

Dezplazamiento

Longitud

Mapeado de archivos en memoria

#include <unistd.h>
#include <sys/mman.h>
void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t

offset);
 donde:

 start = dirección de comienzo en memoria. Si NULL el sistema elige
 length = cantidad del fichero a mapear
 offset = desplazamiento de comienzo del mapeo en el archivo
 fd = descriptor del fichero a usar (previamente debe haber sido abierto)
 prot =

• PROT_NONE = No se permite ningún acceso
• PROT_READ = Se permite leer
• PROT_WRITE = Se permite escribir
• PROT_EXE = Se permite ejecución

 flags = modificadores de acceso:

• MAP_FIXED, MAP_PRIVATE, MAP_SHARED, MAP_ANON(YMOUS),

MAP_DENYWRITE,MAP_LOCKED

Mapeado de archivos en memoria
#include <unistd.h>
#include <sys/mman.h>
int munmap(void *start, size_t length);

 Tras haber usado munmap posteriores accesos a la
 Cuando un proceso termina, todas sus

región de memoria provocarán SIGSEGV
correspondencias de memoria son “desmapeadas”
automáticamente

 El cierre del fichero fd no elimina el mapeo

Mapeado de archivos en memoria

#include <unistd.h>
#include <sys/mman.h>
void *mremap(void *old_addr, size_t old_len, size_t new_len, unsigned long

flags);

 mremap modifica el tamaño de una zona de memoria
 old_addr es la dirección de inicio de la zona
 old_len es el tamaño actual de la zona
 new_len es el nuevo tamaño
 Si flags tiene activo MREMAP_MAYMOVE indicamos que la región puede
 mremap (y mmap) reservan memoria en tamaño múltiplo del tamaño de
 El tamaño de página puede obtenerse con:

moverse en memoria si es necesario
página

#include <unistd.h>
int getpagesize();

Mapeado de archivos en memoria
#include <unistd.h>
#include <sys/mman.h>
int msync(const void *start, size_t length, int flags);
 En mapeo de memoria MAP_SHARED la escritura en
disco no necesariamente se hace al escribir
 msync no sirve para MAP_PRIVATE (mapeo de solo
lectura)
 Valores de flags pueden ser uno o más de:
 MS_ASYNC = planifica una escritura y retorna
 MS_SYNC = la escritura se realiza antes de retornar
 MS_INVALIDATE = se invalidan todos los demás mapeos del
fichero para que sean actualizados con nuevos datos

Mapeado de archivos en memoria
 Mapeado anónimo:
mmap(NULL, 1, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
 MAP_ANONYMOUS implica MAP_PRIVATE
 MAP_ANONYMOUS implica que se ignora fd
 La región de memoria se inicializa a 0
 Puede usarse para hacer una implementación particular

de malloc

Dispositivos de swap

#include <unistd.h>
#include <linux/swap.h>
int swapon(const char *pathname, int swapflags);
int swapoff(const char *pathname);
 pathname es el nombre del dispositivo
 El dispositivo debe
  • Links de descarga
http://lwp-l.com/pdf9015

Comentarios de: Tema 8 - Gestión de memoria - Sistemas Operativos: Programación de Sistemas (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad