PDF de programación - Sistemas operativos II

Sistemas operativos II

Memoria en UNIX

Introducción
Espacio de direcciones de los procesos
Organización de la memoria física
Robo de páginas e intercambio

Memoria en UNIX

Introducción
Espacio de direcciones de los procesos
Organización de la memoria física
Robo de páginas e intercambio

Memoria en UNIX

Introducción
Espacio de direcciones de los procesos
Organización de la memoria física
Robo de páginas e intercambio

Generalidades

I Los procesos se ejecutan en un espacio de direcciones virtual
I Usualmente la memoria física está dividida en trozos de

tamaño fijo denominados marcos o páginas físicas

I Tamaño de página depende del procesador. En sistemas

actuales típicamente 4Kbytes

I Lo procesos trabajan con direcciones virtuales compuestas por

número de página y desplazamineto dentro de la página.
Ejemplo: en un sistema con páginas de 4K la dirección
0x800c03a9, corespondería a desplazamiento 0x3a9 en la
página 0x800c0

I La traslación de número de página y desplazamiento a número
de página física (marco) y desplazamiento se hace en tiempo
de ejecución con ayuda del hardware

Esquema del direccionamiento en la arquitectura i386

Esquema del direccionamiento en la arquitectura i386

Generalidades

I Si el sistema soporta memoria virtual

I un proceso no tiene que estar en memoria totalmente para
poderse ejecutar: la tabla de páginas ha de tener un bit que
indica si está o no en memoria.

I El S.O. guarda información de dónde en el almacenamiento
secundario está cada página no residente en memoria física

I Cuando se crea un proceso se necesita memoria para las

estructuras proc y u area

I el código y los datos inicializados residen en el fichero de disco
I la pila y los datos sin inicializar se ajustan durante la ejecución
I solo se asigna memoria para aquellas páginas que son

referenciadas: paginación bajo demanda pura

Generalidades

I Las páginas de memoria no usadas se sacan de la memoria:

robo de páginas.

I En unix el proceso que realiza esta tarea es pageout,

pagedaemon o paged

I Si se produce hiperpaginación (los procesos tienen menos
páginas que su working set en memoria), se intercambian
procesos enteros a disco.

I En unix esto lo hace el swapper (sched)

Memoria en UNIX

Introducción
Espacio de direcciones de los procesos
Organización de la memoria física
Robo de páginas e intercambio

Memoria en unix: regiones

I En su acepción mas simple, un proceso consta de tres

regiones: código, datos y pila.

I código (text) Contiene el código de las funciones del

programa. Es de solo lectura

I datos (data + bss) Contiene los datos (variables globales,

tanto inicializadas como sin inicialización explicita) del
proceso. El mónticulo (heap) suele ser parte de esta región

I pila (stack). Usado para pasar los parámetros a las funciones y

por éstas para sus variables locales

memoria en unix: regiones

I Cada proceso tiene una tabla de regiones del proceso con
referencias a las entradas en la tabla de regiones del kernel
que constituyen el proceso

I cada entrada de la tabla de regiones que contiene

I donde (dirección virtual) comienza y termina la región
I permisos de la región (solo lectura, lectura-escritura, lectura

ejecución . . . )

I puntero a entrada en la tabla de regiones del kernel

memoria en unix: regiones

I El kernel contiene una tabla de regiones del kernel
I En la tabla de regiones del kernel hay un puntero a los mapas
de traducción de direcciones virtuales a reales (dependientes
de la implementación)

I Cada entrada en la tabla de regiones del kernel contiene
I puntero al inodo cuyos contenidos se cargan en esa región
I tipo de región (código, datos, pila, memoria compartida,

mmaped file)

I temaño de la región
I localización de la región en memoria física
I contador de referencias

operaciones sobre regiones

I las operaciones sobre regiones que hace el kernel son
I asignar una región (fork(), exec(), shmget())
I encadenar una región a un proceso (fork(), exec(),

shmat())

I cambiar el tamaño de una región (brk(), sbrk(), (malloc()))
I cargar una región (exec())
I desasignar una región (exec(), exit(), shmctl(IPC RMID, ))
I desencadenar una región del espacio de direcciones de

un proceso (exec(), exit(), shmdt())

I duplicar una región (fork())

memoria en System V R4

I El espacio de direcciones de un proceso se almacena como una

lista enlazada de sus segmentos (código, datos, pila . . . )

I en la estructuta proc hay una referencia a una estructura as

(address space)

I la estructura as contiene la referencia a la primera de las

estructuras de la lista que describe los segmentos que
constituyen el espacio de direcciones

I cada segmento esta descrito por una estructura seg que

contiene una referencia a una estructura segvn data.

memoria en System V R4

I Según el tipo de segmento (vnode o anónimo) en la

estructura segvn data hay la referencia adecuada

I segmento vnode. Es un segmento asociado con un fichero que
tiene un vnode. Se trata de código o de un fichero sobre el que
se ha hecho mmap(). El miembro vp de la estructura
segvn data tiene esta referencia

I segmento anónimo. Segmento no asociado a un fichero, p.e.
datos o pila. Está descrito por una estructura anon map. Las
páginas anónimas de este segmento ocupan direcciones
virtuales contiguas y sus descriptores se mantienen en el array
anon de estas estructuras

memoria en System V R4: estructura as

La información mas relevante en la estructura as es

I primer segmento (región) en el espacio de direcciones

(struct seg *a segs)

I último segmeto referenciado (struct seg *a seglast)
I tamaño espacio virtual (size t a size)
I memoria fisica usada (size t a rss)
I informacio traducción direcciones (hardware address

translation) (struct hat a hat)

Ejemplo struct as en OpenSolaris

struct as {

a_flags;

/* protect certain fields in the structure */
/* as attributes */
/* used for collecting statistics */
/* used by as_rangelock */
/* hat structure */

kmutex_t a_contents;
uchar_t
uchar_ta_vbits;
kcondvar_t a_cv;
structhat *a_hat;
structhrmstat *a_hrm; /* ref and mod bits */
caddr_ta_userlimit;
struct seg *a_seglast;/* last segment hit on the addr space */
krwlock_t a_lock;
size_ta_size;
struct seg *a_lastgap;/* last seg found by as_gap() w/ AS_HI (mmap) */
struct seg *a_lastgaphl; /* last seg saved in as_gap() either for */

/* protects segment related fields */
/* size of address space */

/* highest allowable address in this as */

/* AS_HI or AS_LO used in as_addseg() */
/* segments in this address space. (AVL tree) */
/* watched pages (procfs) */
/* mappings changed, rebuild a_objectdir */

avl_tree_t a_segtree;
avl_tree_t a_wpage;
uchar_ta_updatedir;
timespec_t a_updatetime;/* time when mappings last changed */
vnode_t**a_objectdir;
size_ta_sizedir;
struct as_callback *a_callbacks; /* callback list */
void *a_xhat;
proc_t*a_proc;

/* object directory (procfs) */
/* size of object directory */

/* list of xhat providers */
/* back pointer to proc */

};

memoria en System V R4: estructura seg

La estructura seg describe los segmentos del espacio de direcciones
del proceso

I direccion virtual cominezo del segmento (addr t s base)
I tamaño del segmento (unsigned s size)
I referencia a la estructura as que contiene este segmento

(struct as *s as)

I punteros para manterner la lista de estructuras seg que

configuran el espacio de direcciones del proceso (struct seg
*s next,*s prev)

I array de punteros a las posibles operaciones sobre el segmento

(struct seg ops *s ops)

I referencia a la estructura segvn data con los detalles

específicos de este segmento (void *s data)

Ejemplo struct seg en OpenSolaris

struct seg {

/* base virtual address */
/* size in bytes */
/* max page size code */
/* flags for segment, see below */

caddr_ts_base;
size_ts_size;
uint_ts_szc;
uint_ts_flags;
structas *s_as; /* containing address space */
avl_node_t s_tree;/* AVL tree links to segs in this as */
structseg_ops *s_ops;/* ops vector: see below */
void *s_data;
/* private data for instance */

};

memoria en System V R4: estructura segvn data

I la estructura segvn data, accesible desde la estructura seg

contiene los detalles específicos del segmento

I protección del segmento (miembro unsigned char prot):

indica qué accesos están permitidos al segmento (lectura
escritura o ejecución)

I protección de las páginas (miembro unsigned char

pageprot): indica si deben comprobarse los bits de protección
de cada página

I indicación de si se ha reservado swap para este segmento

size t swresv

I tipo de compartición del segmento (miembro type:

MAP PRIVATE, MAP SHARED)

I si el segmento es un segmento asociado a un vnodo, una

referencia a dicho vnodo, asi como el offset, figuran en esta
estructura en los miembros vp y offset

I si el segmento está formado por páginas anónimas la

información relativa a dichas páginas esta accesible a través de
struct anon map *amp

Ejemplo struct segvn data en OpenSolaris

typedef struct

segvn_data {

/* protect segvn_data and vpage array */
/* serialize insertions into seg_pcache */
/* true if per page protections present */
/* current segment prot if pageprot == 0 */
/* maximum segment protections */
/* type of sharing done */
/* starting offset of vnode for mapping */
/* vnode that segment mapping is to */
/* starting index into anon_map anon array */
/* pointer to anon share structure, if needed */
/* per-page information, if needed */
/* mapping credentials */

krwlock_t lock;
kmutex_t segp_slock;
uchar_t pageprot;
uchar_t prot;
uchar_t maxprot;
uchar_t type;
u_offset_t offset;
struct
vnode *vp;
ulong_t anon_index;
anon_map *amp;
struct
vpage *vpage;
struct
cred *cred;
struct
size_t
swresv;
uchar_t advice;
uchar_t pageadvice;
ushort_t flags;
ssize_t softlockcnt;
lgrp_mem_policy_info_t policy_info; /* memory allocation policy */

/* swap space reserved for t