Instituto Tecnolgico Superior de Huichapan

ING. EN SISTEMAS COMPUTACIONALES. SISTEMAS OPERATIVOS RESUMEN UNIDAD 3: ADMINISTACIN DE MEMORIA PROFESOR: CARLOS ESPINOZA GALICIA

ALUMNO:

ALEJANDRA CRUZ TOVAR SEMESTRE 3

GRUPO 1

Contenido
ING. EN SISTEMAS COMPUTACIONALES..............................................................1 SISTEMAS OPERATIVOS ......................................................................................1 PROFESOR: CARLOS ESPINOZA GALICIA.....................................................1

ALUMNO: ALEJANDRA CRUZ TOVAR...............................................................1 GRUPO 1 SEMESTRE 3.................................................................................1

Contenido...........................................................................................................2 ADMINISTRACION DE MEMORIA..........................................................................4 ADMINISTRACION DE MEMORIA BASICA..............................................................4 MONOPROGRAMACION SIN INTERCAMBIO NI PAGINACION.................................6 REUBICACIN......................................................................................................9 PROTECCIN.......................................................................................................9 INTERCAMBIO...................................................................................................10 ADMINISTRACION DE MEMORIA CON LISTAS ENLAZADAS................................10 MEMORIA VIRTUAL............................................................................................11 PAGINACIN......................................................................................................12 TABLA DE PGINAS...........................................................................................13 TABLAS DE PGINAS INVERTIDAS ...................................................................14 BUFFER DE TRADUCCION ADELANTADA...........................................................15 MANEJO DE TLB POR SOFTWARE...................................................................17 ......................................................................................................................... 17 PTIMO DE REMPLAZO DE PAGINA...................................................................17 NO USADA RECIENTEMENTE (LRU, LEAST RECENTLY U SED)............................18 ALGORITMO DE REMPLAZO DE PAGINAS PRIMERO EN ENTRAR, ULTIMO EN SALIR................................................................................................................ 18 ALGORITMO DE REMPLAZO DE PAGINAS TIPO RELOJ.......................................19

ALMACENAMIENTO INTERMEDIO DE PGINAS..................................................20 MODELADO DE ALGORITMOS DE REEMPLAZO DE PGINAS..............................21 ANOMALA DE BELADY ....................................................................................21 LA CADENA DE DISTANCIAS .........................................................................23

PREDICCIN DE TAZAS DE FALLO DE PGINA..................................................24 ASPECTOS DE DISENO DE LOS SISTEMAS DE PAGINACION..............................25 CONTROL DE CARGA........................................................................................26 TAMAO DE PGINA .......................................................................................27 ESPACIOS DE INSTRUCCIONES Y DE DATOS SEPARADOS ............................28 CONTROL DE CARGA.........................................................................................29 ASPECTOS DE IMPLEMENTACION....................................................................30 MANEJO DE FALLOS DE PGINA........................................................................30 SEGMENTACIN................................................................................................31

ADMINISTRACION DE MEMORIA
En un sistema monoprogramado, la memoria principal se divide en dos partes: una parte para el sistema operativo (monitor residente, ncleo) y otra parte para el programa que se ejecuta en ese instante. En un sistema multiprogramado, la parte de "usuario" de la memoria debe Subdividirse an ms para hacer sitio a varios procesos. La tarea de subdivisin la lleva a cabo dinmicamente el sistema operativo y se conoce como administracin de memoria. En un sistema multiprogramado resulta vital una gestin efectiva de la memoria. Si solo hay unos pocos procesos en memoria, entonces la mayor parte del tiempo estarn esperando a la E/S y el procesador estar desocupado. Por ello, hace falta repartir eficientemente la memoria para meter tantos procesos como sea posible.

ADMINISTRACION DE MEMORIA BASICA

La tarea central de cualquier sistema de gestin de memoria es traer los programas a memoria principal para su ejecucin en el procesador. En casi todos los sistemas multiprogramados modernos, esta tarea supone un esquema sofisticado conocido

como memoria virtual. La memoria virtual esta, a su vez, basada en el uso de una de dos tcnicas bsicas; intercambio y/o paginacin. Antes de ver estas tcnicas de memoria virtual, se debe preparar el terreno considerando tcnicas ms simples que no requieren el uso de memoria virtual. Una de estas tcnicas, la particin, se ha venido usando con distintas variantes en algunos sistemas operativos ahora obsoletos. Las otras dos tcnicas, la paginacin simple o intercambio simple, no se usan en solitario. No obstante, el estudio de la memoria virtual resultara ms sencillo si se Consid0eran en primer lugar estas dos tcnicas, sin tener en cuenta la memoria virtual.

MULTIPROGRAMACIN

CON

PARTICIONES

FIJAS

En la mayora de los esquemas de administracin de memoria, se puede suponer que el sistema operativo ocupa una parte fija de memoria principal y que el resto de la memoria est disponible para ser usado por varios procesos. El esquema ms sencillo de admiracin de la memoria disponible es dividirla en regiones con limites fijos. Tamaos de Particin Emplear particiones de igual tamao. En este caso, cualquier proceso cuyo tamao sea menor o igual que el tamao de la particin puede cargarse en cualquier particin libre. Si todas las particiones estn ocupadas y no hay procesos residentes en estado Listo o Ejecutando, el sistema operativo puede sacar un proceso de alguna de las particiones y cargar otro proceso de forma que haya trabajo para el procesador. Las particiones fijas de igual tamao plantean dos dificultades: Un programa puede ser demasiado grande para caber en la particin. En este caso, el programador debe disear el programa mediante superposiciones, para que solo una parte del programa este en memoria principal en cada instante. Cuando se necesita un mdulo que no est presente, el programa de usuario debe cargar dicho modulo en la particin del programa, Superponindose a los programas y datos que se encuentren en ella.

MONOPROGRAMACION PAGINACION.

SIN

INTERCAMBIO

NI

Este esquema de administracin de memoria consiste en ejecutar solo un programa a la vez, repartiendo la memoria entre ese programa y el sistema operativo.

A) Particiones de memoria fija con colas de entrada individuales para cada una. b) Particiones de memoria fijas con una sola cola de entrada.

REUBICACIN
En un sistema multiprogramado, la memoria disponible se encuentra normalmente compartida por varios procesos. En general, el programador no puede conocer por adelantado que otros programas residirn en memoria en el momento de la ejecucin del programa. Adems, se busca poder cargar y descargar los procesos activos en la memoria principal para maximizar el uso del procesador, manteniendo una gran reserva de procesos listos para ejecutar. Una vez que un programa haya sido descargado al disco, se limitara a declarar que, cuando vuelva a ser cargado, debe situarse en la misma regin de memoria principal que antes. De este modo, se sabe antes de tiempo donde debe situarse un programa y hay que permitir que el programa pueda moverse en memoria principal como resultado de un intercambio. Esta situacin plantea algunos asuntos tcnicos relativos al direccionamiento, que representa la imagen de un proceso

PROTECCIN
Cada proceso debe protegerse contra interferencias no deseadas de otros procesos, tanto accidentales como intencionadas. As pues, el cdigo de un proceso no puede hacer referencia a posiciones de memoria de otros procesos, con fines de lectura o escritura, sin permiso. Hasta cierto punto, satisfacer las exigencias de reubicacin aumenta la dificultad de satisfaccin de las exigencias de proteccin. Puesto que se desconoce la ubicacin de un programa en memoria principal, es imposible comprobar las direcciones absolutas durante la compilacin para asegurar la proteccin. Es ms, la mayora de los lenguajes de programacin permiten el clculo dinmico de direcciones durante la ejecucin, generando, por ejemplo, un ndice de un vector o un puntero a una estructura de datos. Por tanto, todas las referencias a memoria generadas por un proceso deben comprobarse durante la ejecucin para asegurar que solo hacen referencia al espacio de memoria destinado a dicho proceso. Afortunadamente, como se vern, los mecanismos que respaldan la reubicacin tambin forman parte bsica del cumplimiento de las necesidades de proteccin.

INTERCAMBIO
Cualquier mecanismo de proteccin que se implemente debe tener la flexibilidad de permitir el acceso de varios procesos a la misma zona de memoria principal. Por ejemplo, si una serie de procesos estn ejecutando el mismo programa, resultara beneficioso permitir a cada proceso que acceda a la misma copia del programa, en lugar de tener cada uno su propia copia aparte. Los procesos que cooperan en una tarea pueden necesitar acceso compartido a la misma estructura de datos. El sistema de gestin de memoria debe, por tanto, permitir accesos controlados a las reas compartidas de la memoria, sin comprometer la proteccin bsica. De nuevo, se ver que los mecanismos empleados para respaldar la reubicacin forman parte bsica de las capacidades de comparticin.

ADMINISTRACION ENLAZADAS.

DE

MEMORIA

CON

LISTAS

Puesto que la compactacin de memoria consume tiempo, atae al diseador del sistema operativo decidir adecuadamente como asignar un proceso a memoria (como llenar los huecos). Cuando llega el momento de cargar o traer un proceso a memoria principal y, si hay libre ms de un bloque de memoria de tamao suficiente, el sistema operativo debe decidir cul asignar. Los tres algoritmos de ubicacin que se pueden considerar son el del mejor ajuste (best-fit), el del primer ajuste (first-fit) y el del siguiente ajuste (next-fit). Todos ellos se limitan a elegir entre los bloques de memoria libres que son mayores o iguales que el proceso a traer. El mejor ajuste elige el bloque de tamao ms parecido al solicitado. El primer ajuste comienza recorriendo la memoria desde el principio y escoge el primer bloque disponible que sea suficientemente grande. El siguiente ajuste recorre la memoria desde el lugar de la ltima ubicacin y elige el siguiente bloque disponible que sea suficientemente grande.

MEMORIA VIRTUAL
Hace mucho tiempo aparecieron los primeros programas que eran demasiado grandes para caber en la memoria disponible. La solucin que se adopta comnmente era dividir el programa en segmentos llamados superposiciones (overlays) Es posible que un proceso sea ms grande que toda la memoria principal. Se elimina as una de las limitaciones ms notorias de la programacin. Sin el esquema que se ha expuesto, un programador debe ser consciente de cuanta memoria tiene disponible. Si el programa que est escribiendo es demasiado grande, el programador debe idear formas de estructurar el programa en fragmentos que puedan cargarse de forma separada con algn tipo de estrategia de superposicin. Con una memoria virtual basada en paginacin o segmentacin, este trabajo queda para el sistema operativo y el hardware. En lo que atae al

programador, se las arregla con una memoria enorme, dependiendo del tamao de almacenamiento en disco. El sistema operativo cargara automticamente en memoria principal los fragmentos de un proceso cuando los necesita.

PAGINACIN
El termino memoria virtual se asocia normalmente con sistemas que emplean paginacin, aunque tambin se puede usar memoria virtual basada en la segmentacin, que se tratara despus. El uso de la paginacin en la memoria virtual fue presentado por primera vez en el computador Atlas [KILB62] y pronto alcanzo un uso comercial muy extendido. En el estudio de la paginacin simple se indic que cada proceso tiene su propia tabla de pginas y que, cuando carga todas sus pginas en memoria principal, se crea y carga en memoria principal una tabla de pginas. Cada entrada de la tabla de pginas contiene el nmero de marco de la pgina correspondiente en memoria principal. Cuando se considera un esquema de memoria virtual basado en la paginacin se necesita la misma estructura, una tabla de pginas.

TABLA DE PGINAS
As pues, el mecanismo bsico de lectura de una palabra de memoria supone la traduccin por medio de la tabla de pginas de una direccin virtual o lgica, formada por un nmero de pgina y un desplazamiento, a una direccin fsica que est formada por un nmero de marco y un desplazamiento. Puesto que la tabla de pginas es de longitud variable, en funcin del tamao del proceso, no es posible suponer que quepa en los registros. En su lugar, debe estar en memoria principal para ser accesible.

Cuando se est ejecutando un proceso en particular, la direccin de comienzo de la tabla de pginas para este proceso se mantiene en un registro. El nmero de pgina de la direccin virtual se emplea como ndice en esta tabla para buscar el nmero de marco correspondiente. Este se combina con la parte de desplazamiento de la direccin virtual para generar la direccin real deseada.

TABLAS DE PGINAS INVERTIDAS

Este mtodo se emplea en el AS/400 de IBM [CORA88, SCHL89] y en las estaciones de trabajo RISC Sistema/600 de IBM [CHAN88, CHAN90a, WATE86]. Esta tcnica tambin la utiliza una implementacin del sistema operativo Mach en el RT-PC [RASH88]. Con este mtodo, la parte del nmero de pgina en una direccin virtual se contrasta en una tabla de dispersin por medio de una funcin de dispersin simple'. La tabla de dispersin contiene un puntero a la tabla de pginas invertida, que contiene a su vez las entradas de la tabla de pginas. Con esta estructura, hay una entrada en la tabla de dispersin y la tabla de pginas invertida por cada pgina de memoria real en lugar de una por cada pgina

virtual. As pues, se necesita una parte fija de la memoria real para las tablas, sin reparar en el nmero de procesos o de pginas virtuales soportados. Puesto que ms de una direccin de memoria pueden corresponderse con la misma entrada de la tabla de dispersin, para gestionar las colisiones se emplea una tcnica de encadenamiento. La tcnica de dispersin genera normalmente cadenas cortas, de dos a tres entradas cada una.

BUFFER DE TRADUCCION ADELANTADA

En principio, cada referencia a memoria virtual puede generar dos accesos a memoria: uno para obtener la entrada de la tabla de pginas correspondiente y otro para obtener el dato deseado. As pues, un esquema sencillo de memoria virtual podra tener el efecto de doblar el tiempo de acceso a memoria. Para solucionar este problema, la mayora de los esquemas de memoria virtual hacen uso de una cache especial para las entradas de la tabla de pginas, llamada generalmente buffer de traduccin adelantada (TLB, Translation Lookaside Buffer). Esta cache funciona del mismo modo que una memoria cache y contiene aquellas entradas de la tabla de pginas usadas hace menos tiempo. La organizacin del hardware de paginacin resultante. Dada por una direccin virtual, el procesador examinara primero la TLB. Si la entrada de tabla de pginas

buscada est presente (un acierto en la TLB), se obtiene el nmero de marco y se forma la direccin real. Si no se Encuentra la entrada de la tabla de pginas buscada (un fallo de TLB), el procesador emplea el nmero de pgina para buscar en la tabla de pginas del proceso y examinar la entrada correspondiente de la tabla de pginas. Si se encuentra activo el bit de presencia, es que la pagina esta en memoria principal y el procesador puede obtener el nmero de marco de la entrada de la tabla de pginas para formar la direccin real. El procesador, adems, actualiza la TLB para incluir esta nueva entrada de la tabla de pginas. Por ltimo, si el bit de presencia no est activo, es que la pgina buscada no est en memoria principal y se produce un fallo en el acceso a memoria, llamado fallo de pgina. En este punto, se abandona el mbito del hardware y se invoca al sistema operativo, que carga la pgina necesaria y actualiza la tabla de pginas.

MANEJO DE TLB POR SOFTWARE

Existe una serie de detalles adicionales sobre la organizacin real de la TLB. Puesto que la TLB contiene solo algunas de las entradas de la tabla de pginas completa, no se puede indexar simplemente la TLB por el nmero de pgina. En su lugar, cada entrada de la TLB debe incluir el nmero de pgina, adems de la entrada completa a la tabla de pginas. El procesador estar equipado con hardware que permita consultar simultneamente varias entradas de la TLB para determinar si hay una coincidencia en el nmero de pgina. Esta tcnica llamada correspondencia asociativa y contrasta con la correspondencia directa, que se emplea para buscar en la tabla de pginas. El diseador de la TLB debe tener tambin en cuenta la forma en que se organizan las entradas en la TLB y que entrada reemplazar cuando se introduce una nueva. Estas cuestiones deben considerarse en cualquier diseo de cache de hardware. Este problema no se trata aqu; se debe consultar un tratado de diseo de caches para obtener ms detalles (por ejemplo, [STAL93a]). Por ltimo, el mecanismo de memoria virtual debe interactuar con el sistema de cache (no con la cache TLB, sino con la cache de memoria principal).Una direccin virtual tendr normalmente un formato de numero de pgina ms desplazamiento.

PTIMO DE REMPLAZO DE PAGINA

LA POLITICA PTIMO selecciona para reemplazar la pgina que tiene que esperar una mayor cantidad tiempo hasta que se produzca la referencia siguiente. Se puede demostrar que esta poltica genera el menor nmero de fallos de pgina [BELA66]. Sin duda, este algoritmo resulta imposible de implementar, puesto que requiere que el sistema operativo tenga un conocimiento exacto

de los sucesos futuros. Sin embargo, sirve como un estndar con el que comparar los otros algoritmos. La figura 7.14 ofrece un ejemplo del optimo remplazo de pgina El ejemplo supone una asignacin constante de tres marcos para el proceso. La ejecucin del proceso hace referencia a cinco pginas distintas. La cadena de referencias a las pginas durante la ejecucin del programa es: 232 152453252 lo que significa que la primera referencia es a la pgina 2, la segunda a la 3 y as sucesivamente. El algoritmo ptimo origina tres fallos de pgina despus de haber llenado los marcos Asignados.

NO USADA RECIENTEMENTE RECENTLY U SED)

(LRU,

LEAST

La poltica de la usada hace ms tiempo (LRU, Least Recently U sed) reemplaza la pgina de memoria que no ha sido referenciada desde hace ms tiempo. Debido al principio de cercana, esta debera ser la pgina con menor probabilidad de ser referenciada en un futuro cercano. De hecho, la poltica LRU afina casi tanto como la poltica ptima. El problema de este mtodo es su dificultad de implementacin. Una solucin sera etiquetar cada pgina con el instante de su ltima referencia; esto tendra que hacerse para cada referencia a memoria, tanto para instrucciones como datos. Incluso si el hardware respaldara este esquema, la sobrecarga resultara tremenda. Como alternativa, se podra mantener una pila de referencias a pgina, aunque tambin con un coste elevado. La figura 7.14 muestra un ejemplo del comportamiento del LRU, utilizando la misma cadena de referencias. En este caso, se producen cuatro fallos de pgina.

ALGORITMO DE REMPLAZO DE PAGINAS PRIMERO EN ENTRAR, ULTIMO EN SALIR

La primera en entrar, primera en salir (fifo) trata los marcos asignados a un proceso como un buffer circular y las pginas se suprimen de memoria segn la tcnica de espera circular (round-

robiri). Todo lo que se necesita es un puntero que circule a travs de los marcos del proceso. Esta es, por tanto, una de las polticas de reemplazo ms sencillas de implementar. La lgica que hay detrs de esta eleccin, adems de su sencillez, es reemplazar la pgina que ha estado ms tiempo en memoria: Una pgina introducida en memoria hace mucho tiempo puede haber cado en desuso. Este razonamiento ser a menudo incorrecto, porque habr regiones de programa o de datos que son muy usadas a lo largo de la vida de un programa. Con el algoritmo FIFO, estas pginas se cargaran y expulsaran repetidas veces. Continuando con el ejemplo de la figura 7.14, la poltica FIFO genera seis fallos de pgina. Ntese que la LRU se da cuenta de que las pginas 2 y 5 se referencian ms frecuentemente que las otras, mientras que la FIFO no lo hace.

ALGORITMO DE RELOJ.

REMPLAZO DE PAGINAS TIPO

Si bien la poltica LRU se acerca mucho a la poltica optima, es difcil de implementar e impone una sobrecarga significativa. Por otro lado, la poltica FIFO es muy simple de implementar, pero su rendimiento es relativamente pobre. A lo largo de los aos, los diseadores de sistemas operativos han probado una serie de algoritmos para aproximarse al rendimiento de la LRU sin introducir mucha sobrecarga. Muchos de esos algoritmos son variantes de un esquema denominado poltica del reloj.

ALMACENAMIENTO INTERMEDIO DE PGINAS

A pesar de que las polticas LRU y del reloj son superiores a la FIFO, ambas poseen una complejidad y sobrecarga que esta ltima no padece. Adems, el coste de reemplazar una pgina que ha sido modificada es mayor que el de una que no lo ha sido, porque la primera debe volver a escribirse en memoria secundaria.

Una estrategia interesante que puede mejorar el rendimiento de la paginacin y permitir el uso de una poltica de reemplazo de pginas ms sencilla es el almacenamiento intermedio de pginas. Un mtodo representativo es el del VAX/VMS. VMS emplea una estrategia de asignacin variable y reemplazo local. El algoritmo de reemplazo de pginas es simplemente un FIFO. Para mejorar el rendimiento, no se pierde la pista de la pgina reemplazada, sino que se asigna a una de las dos listas siguientes: la lista de pginas libres, si la pgina no ha sido modificada o la lista de pginas modificadas, si lo ha sido. Ntese que la pagina no se mueve fsicamente de la memoria principal; en su lugar, se suprime su entrada en la tabla de pginas y se pone en la lista de pginas libres o modificadas.

MODELADO PGINAS

DE

ALGORITMOS

DE

REEMPLAZO

DE

ANOMALA DE BELADY
Se podra pensar que entre ms marcos de pgina se tenga la memoria, menos fallos de pgina tendr un programa pero no siempre sucede as. Belady et al. (1969) descubrieron un contraejemplo en el que FIFO causaba ms fallos de pgina con cuatro marcos de pgina que con tres. Esta extraa situacin se conoce como anomala de Belady.
Ejemplo: 0 1 2 3 4 0 1 0 2 1 0 3 2 1 0 3 2 1 0 3 4 1 0 4 1 0 4 1 0 2 4 1 3 2 4 3 2 4 Pagina ms reciente 1 2 3 0 1 4 0

Pagina ms antigua P P P P P P 9 fallos de pagina P P P P

FIFO con tres marcos de pgina. Las P indican las referencias que casan fallos de pgina. 4.5.2 Algoritmo de pila Ante la anomala de belady se comenz a investigar, estos trabajos condujeron al desarrollo de todo una teora de algoritmos de reemplazo de pginas y sus propiedades. Todos estos trabajos parten de la observacin que un proceso genera una serie de referencias a la memoria conforme se ejecuta. Cada referencia a la memoria corresponde a una pgina virtual especfica. Por tanto en lo conceptual, el acceso de un proceso a la memoria puede representarse con una lista (ordenada) de un numero de pagina. Esta lista se denomina cadena de referencias. Un sistema de paginacin puede representarse con 3 elementos: 1. La cadena de referencias del proceso en ejecucin. 2. El algoritmo de reemplazo de paginas.
3. EEl numero de marcos de pagina con que cuenta la memoria,

m.

Algunas de las propiedades del modelo reemplazo de pginas LRU son: Primera, cuando hace referencia a una pgina, siempre se coloca en la parte superior de m. segunda, si la pgina solicitada ya estaba en m, todas las pginas que estaban arriba bajan una posicin. Una transicin del interior del rectngulo hacia afuera de l corresponde al desalojo de la pgina de la memoria. Tercera, las pginas que estaban debajo de la pgina solicitada no se mueven. As el contenido de M representa con exactitud el contenido de el algoritmo de LRU.

Aunque en este ejemplo usamos LRU el modelo tambin funciona con otros algoritmos. En particular, hay una clase de algoritmos en especial interesante: los que tienen la propiedad M(m,r)< M(m+1,r) En un marco de pgina, el tamao de la memoria y volvemos a ejecutar el proceso, en todos los puntos durante la ejecucin todas las pginas que estaban presentes en la primera ocasin tan lo estarn en la segunda, junto con una pgina adicional. Llamamos algoritmos de pila a los que tienen esta propiedad. Estos no presentan la anomala de Belady y por ello loa doran los tericos de la memoria virtual.

LA CADENA DE DISTANCIAS
En el caso de los algoritmos de pila, resulta conveniente representar la cadena de referencias de una forma ms abstracta que con los nmeros de pginas reales . Para entender esto se denotara una referencia a una pgina con la distancia desde la parte superior de la pila superior donde se coloc la pgina. Cabe sealar que la cadena de distancias no solo depende de la cadena de referencias, sino tambin de el algoritmo de paginacin. Con la misma cadena de referencia original, un algoritmo distinto tomara decisiones diferentes respecto a cuales paginas desalojar. Para ello se produce una sucesin de pilas distinta. Las propiedades estadsticas de la cadena de distintas tienen un impacto importante en el desempeo del algoritmo.

PREDICCIN DE TAZAS DE FALLO DE PGINA

Una de las propiedades agradables de la cadena de distancias es que puede servir para predecir el nmero de fallos de pgina que se presentaran con memorias de diferente tamao. En las figuras se mostrara lo antes dicho con el objetivo de realizar una pasada por la cadena de distancias y, a partir de la informacin recabada, predecir el nmero de fallos de pgina que tendra el proceso en memorias de 1, 2, 3,n marcos de pgina, donde n es el nmero de pginas virtuales del espacio de direcciones del proceso. Lo primero que hace el algoritmo es explorar la cadena de distancias, pagina por pgina, llevando en cuenta las veces que aparece 1, las veces que aparece2, etc. Ci es el nmero de veces que aparece i. En este ejemplo, sucede cuatro veces que la pgina solicitada ya estaba en la parte superior de la pila. En 3 ocasiones se solicit la pgina que estaba una posicin ms abajo, y as en forma sucesiva. C& es el nmero de veces que aparece & en la cadena de distancias.

Veces C2+C3+C4++C& aparece 1 en C3+C4+C5++C&

que F1=19 F2=17 la F3=16

F4=12 cadena de distancias. F5=10 C4+C5+C6++C& F6=10 Veces fallos de marcos pgina F7=8 que con 5 F&=8

Aparece 6 en la Cadena de distancias

Ahora calculamos el vector F con la formula

El valor de Fm es el nmero de fallos de pgina que se representaran en la cadena de distancias dada y m marcos de la pgina. Un fallo de pgina se presenta cada vez que un elemento de la cadena de distancias es m+1 o ms. La sumatoria de la formula anterior calcula el total de las veces que aparecen tales elementos.

ASPECTOS DE DISENO DE LOS SISTEMAS DE PAGINACION POLTICA DE ASIGNACIN LOCAL Y GLOBAL

En los algoritmos que eran decisivos para escoger la pgina que ser reemplazada cuando se presente un fallo de pgina, una cuestin importante asociada con esta decisin es como debe repartirse la memoria entre los procesos ejecutables que compiten entre ella. Los algoritmos locales equivalen a asignar una fraccin fija de memoria a cada proceso. Los algoritmos globales asignan en forma dinmica los marcos de pginas entre los procesos ejecutables. As, el nmero de marcos de pgina asignados a cada proceso varia con el tiempo. En general, los algoritmos globales funcionan mejor, sobre todo si el tamao del conjunto de trabajo puede variar durante la vida de los procesos. Si se usa un algoritmo local y el conjunto de trabajo crece, habr hiperpaginacion, aunque haya muchos marcos de pgina desocupados. Si el conjunto de trabajo se encoge, los

algoritmos locales desperdician memoria. Si se usa un algoritmo global, el sistema debe decidir de manera continua cuantos marcos de pgina asignara a cada proceso. Una forma de hacerlo es supervisar el tamao del conjunto de trabajo con base en los bits de envejecimiento, pero este enfoque no necesariamente previene la hiperpaginacion. Otro enfoque consiste en tener un algoritmo que asigne marcos de pgina a los procesos. Una forma de hacerlo es determinar en forma peridica el nmero de procesos ejecutables y asignar a cada proceso una porcin equitativa. Tal vez sera prudente asignar a cada proceso una cantidad mnima para que pueda ejecutarse por pequeo que sea. Se sabe que, para una clase amplia de algoritmos de reemplazo de pginas incluyen LRU, la tasa de fallos disminuye a medida que asignan ms pginas. Medir la tasa de fallos de pgina es sencillo: basta con contar el nmero de fallos por segundo, quiz calculando una medida para los segundos anteriores. Una forma es sumar el valor correspondiente al segundo actual a la ltima media calculada y dividir el resultado entre dos. En algunos casos, la decisin de adoptar una poltica local o global es independiente de el algoritmo.

CONTROL DE CARGA
Incluso con el mejor algoritmo de reemplazo y una asignacin global optima de marcos de pgina a los procesos, puede suceder que el sistema hiperpagine. De hecho, siempre que los conjuntos de trabajo combinados de todos los procesos exceden la capacidad de la memoria, cabe esperar hiperpaginacion. Un sntoma de esta situacin es que el algoritmo PFF indica que algunos procesos necesitan ms memoria pero ninguno necesita menos. En este caso, es imposible asignar ms memoria los procesos que la necesitan sin perjudicar a otros. La nica solucin real es deshacerse de algunos procesos de manera temporal. La forma de reducir el nmero de procesos que compiten por la memoria es intercambiar algunos de ellos al disco y liberar a todas las pginas

que tienen asignadas. Si la hiperpaginacion cesa, el sistema podr operar durante un rato durante estas condiciones; de lo contrario, habr que intercambiar a disco otro proceso, y as hasta que se detenga la hiperpaginacion, incluso con paginacin sigue siendo necesario el intercambio, solo que ahora se usa para reducir la demanda potencial de memoria, con el fin de recuperar bloque de ella para uso inmediato. El intercambio de procesos a disco para aliviar la carga de la memoria se asemeja a la calendarizacin de los dos niveles, en la que algunos procesos se colocan en el disco y se utiliza un calendarizador de corto plazo para los procesos restantes. Sin embargo, otro factor que debemos considerar es el grado de multiprogramacin. Cuando el nmero de procesos que est en la memoria principal es demasiado bajo, la CPU podra estar inactiva durante periodos considerables. Esta consideracin es un argumento a favor de considerar no solo el tamao de los procesos y la tasa de paginacin al decidir cuales procesos intercambiar a disco, sino tambin sus caractersticas as coma la de los dems procesos.

TAMAO DE PGINA
El tamao de pgina suele ser un parmetro que puede escoger el sistema operativo. La determinacin del tamao de pgina ptimo requiere equilibrar varios factores opuestos. Por ello, no existe un tamao ptimo para todos los casos. Por principio de cuentas, dos factores favorecen el uso de pginas pequeas. Un segmento de texto, datos o pila cualquiera no llenara un nmero entero de pginas. En promedio, la mitad de la ltima pgina estar vaca, y ese espacio adicional se desperdicia. Este desperdicio se denomina fragmentacin interna. Si hay n segmentos en la memoria y las pginas son de p bytes, se desperdiciaran np/2 bytes en fragmentacin interna. En general, un tamao de pgina grande hace que ms partes no utilizadas de los programas estn en memoria.

Por otro lado, el uso de pginas pequeas implica que los programas van a necesitar muchas y, por lo tanto, una tablea de pginas ms grande. En algunas mquinas, la tabla de pginas debe cargarse en registros de hardware cada vez que la CPU conmuta de un proceso a otro. En tales maquinas el tiempo requerido para cargar los registros de pgina aumenta a medida que disminuye el tamao de pgina. Asimismo, supongamos que cada entrada de tabla de pginas ocupa e bytes. Por lo tanto, el nmero aproximado de pginas que se requieren por proceso es s/p, y ocupan se/p bytes de espacio en la tabla de pginas. El desperdicio de memoria en la ltima pgina del proceso, debido a fragmentacin interna, es p/2. Por lo tanto, el gasto extra total que implica la tabla de pginas y la prdida por fragmentacin interna es la suma de estos trminos; Pasto adicional=se/p+p/2 El primer trmino (tamao de tabla de pginas) es grande cuando el tamao de pgina es pequeo. El segundo trmino (fragmentacin interna) es grande cuando el tamao de pgina es grande. A medida que crecen las memorias, el tamao de pgina tambin tiende a aumentar.

ESPACIOS DE INSTRUCCIONES Y SEPARADOS

DE DATOS

Casi todas las computadoras tienen u solo espacio de direcciones que contiene tanto programas como datos. Si este espacio de direcciones es lo bastante grande, todo funciona de maravilla. Sin embargo en muchas ocasiones se demasiado pequeo, y ello obliga a los programadores a hacer malabarismos para que todo quepa en el espacio de direccione. Una solucin que uso por primera vez en la PDP-11 (de 16 bits), es tener espacios de direcciones distintos para las instrucciones

(texto del programa) y los datos. Estos se llaman espacio I y Espacio D, respectivamente. Ca espacio va desde 0 hasta algn mximo, por lo regular o El enlazador debe estar enterado del uso de espacios I y D separados, porque en tal caso los datos se reubican en la direccin virtual 0 en vez de comenzar despus del programa. Cada uno tiene su propia tabla de pginas, con su propia correspondencia entre pginas virtuales y marcos de pginas fsicos. Tener espacios I y D separados no introduce complicaciones especiales y si duplica el espacio de direcciones disponible.

CONTROL DE CARGA
A veces no es posible evitar la hiperpaginacin (todos los procesos piden ms memoria y no se puede asignar a uno sin perjudicar a otro) Solucin: intercambio suspender procesos y liberar sus pginas, pero sin dejar la CPU inactiva Hay que controlar el grado de multiprogramacin Anclaje de marcos de memoria

Cuando intervienen en una operacin de E/S por DMA que no ha nalizado

A tener en cuenta, sobre todo, en algoritmos globales Administracin del espacio de intercambio Asignacin esttica por proceso, cuando ste se inicia Asignacin dinmica (los procesos pueden crecer) Interfaz de memoria virtual Hasta este punto hemos notado que la memoria virtual es transparente para los procesos y los programadores. Una estrategia para los programadores para controlar su mapa de

memoria es permitir que dos o ms procesos compartan la misma memoria. Cuando dos o ms procesos comparten las pginas, hace posible la comparticin de ancho de banda: un proceso escribe en la memoria compartida y el otro la lee. Otra estrategia de administracin avanzada de memoria es la memoria compartida distribuida, es decir, que mltiples procesos en una red compartan un conjunto de pginas, como un solo espacio de direcciones lineal compartido.

ASPECTOS DE IMPLEMENTACION MANEJO DE FALLOS DE PGINA.

Cuando ocurre un fallo de pgina en la ejecucin de un programa (esto es, cuando una direccin virtual almacenada en la MMU no encuentra su correspondiente marco en la RAM), lo que no es infrecuente, todo hay que decirlo XD, pasan todas estas cosas en nuestra computadora: 1.- El hardware hace un trap al kernel. Guarda el contador del programa en la pila. Guarda informacin acerca del estado de la instruccin en registros de la cpu. 2.- Rutina en ensamblador que guarda informacin voltil (como los registros generales) para que el SO no la destruya. Llama al SO como un procedimiento. 3.- El SO dice: "Oh, un fallo de pgina" y busca en los registros de hardware a ver qu pgina es. Si no, tendr que obtener el contador del programa, obtener la instruccin que se estaba ejecutando y analizarla a ver que ha pasado. 4.- Cuando se descubre qu direccin virtual ha provocado el fallo se comprueba si esta es vlida (de no ser as se enva una seal al proceso o se elimina directamente), si es vlida se comprueba si hay un marco de pgina disponible. Si no lo hay, se ejecuta algn algoritmo de reemplazo de pginas.

5.- Si el marco esta sucio (ha sido modificado desde que se trajo del disco) se planifica la pgina para transferirla al disco y se suspende el proceso, dejando paso a otro hasta que se haya completado la transferencia. De cualquier forma, se etiqueta el marco como "ocupado" para que nadie lo use. 6.- Cuando el marco ya est limpio (ya sea inmediatamente o despus de la transferencia), el SO busca la pgina en el disco y planifica una operacin de disco para llevarla a la memoria (mientras tanto otro proceso estar ocupando la cpu y este continuar suspendido). 7.- Cuando la interrupcin de disco avise que la pgina est en memoria se actualizan las tablas de pginas y se etiqueta el marco como "normal". 8.- La instruccin que fall se respalda al estado que tena cuando empez y se restablece el contador del programa apuntando a esa instruccin. 9.- Se planifica el proceso fallido y el SO regresa a la rutina en ensamblador que lo llam. 10.- La rutina recarga los registros y alguna otra informacin de estado y regresa al espacio de usuario para continuar la ejecucin. Aqu no ha pasado nada.

SEGMENTACIN
Otra opcin para el manejo de la memoria es usar una forma de liberar al programador de la tarea del control de las tablas en expansin y contraccin, de la misma forma que la memoria virtual elimina la preocupacin por organizar el programa en una serie de proyectos. Esto se puede lograr dotando a la mquina de varios espacios independientes de direcciones llamados segmentos. Cada segmento tiene una serie lineal de direcciones, desde 0 hasta cierto mximo. La longitud de cada segmento puede variar de 0 hasta un mximo permitido. Los distintos segmentos pueden tener y de hecho tienen por lo general, longitudes distintas. Adems, la

longitud de un segmento puede variar durante la ejecucin. La longitud de un segmento de la pila puede crecer si algo entra a la pila y decrecer si algo sale de ella. SEGMENTACIN PURA La implantacin de la segmentacin difiere del caso de la paginacin en un sentido esencial: las pginas tienen un tamao fijo y los segmentos no. La figura muestra un ejemplo de memoria fsica que contiene al principio 5 segmentos. Consideremos que el segmento 1 se elimina y su lugar se ocupa por el segmento 7, que es menor. El rea que queda entre el segmento 7 y el 2 es un hueco. Luego, el segmento 4 se reemplaza por el segmento 5 y el segmento 3 es reemplazado por el segmento 6. Despus de que el sistema est en ejecucin durante cierto tiempo, la memoria quedar dividida en varios bloques, algunos con segmentos y otros con huecos. Este fenmeno de fragmentacin externa o checkboarding, desperdicia la memoria correspondiente a los huecos, pero es fcilmente corregido mediante el uso de la compactacin. De esta forma los huecos son unificados, generando as un hueco de tamao suficiente para albergar algn otro segmento ms.

Segmento 0 (4K) Segmento 1 (8K) Segmento 2 (5K) Segmento 3 (8K) Segmento 4 (7K)

Segmento 0 (4K) Segmento 7 (5K) Hueco (3K) Segmento 2 (5K) Segmento 3 (8K)

Segmento 0 (4K) Segmento 7 (5K) Hueco (3K) Segmento 2 (5K)

Segmento 0 (4K) Segmento 7 (5K) Hueco (3K) Segmento 2 (5K) Segmento 6 (4K) Hueco (4K) Segmento 5 Hueco (3K) (4K)

Segmento 0 (4K) Segmento (5K) Segmento (5K) Segmento (4K) Segmento (4K) 7 2 6 5

Segmento 4 (7K)

Segmento 3 (8K) Segmento 5 Hueco (3K) (4K)

Hueco (10K)

(a)

a)

(b) (e)

(c)

(d)

Fig.. Desarrollo de fragmentacin externa mediante compactacin. Segmentacin con paginacin: MULTICS

su

correccin

En el sistema MULTICS, una direccin lgica est formada por un nmero de segmento de 18-bit y un offset de 16 bit. Aunque este esquema crea un espacio de direccin de 34-bit, la sobrecarga en la tabla de segmentos es tolerable; solo se requiere de las suficientes localidades en la tabla de segmentos como haya segmentos, puesto que no debe haber localidades vacas. Sin embargo, con segmentos de palabras de 64K, es donde cada una consiste de 36 bits, el tamao promedio de segmento puede ser grande y se podra presentar un problema de fragmentacin externa. Aunque no lo fuera, el tiempo de bsqueda para ubicar un segmento, usando primer ajuste o mejor ajuste, puede ser prolongado. Lo que puede causar desperdicio de memoria debido a la fragmentacin externa, o desperdicio de tiempo por las largas bsquedas o ambas. La solucin al problema es paginar los segmentos. La paginacin elimina la fragmentacin externa y convierte el problema de ubicacin en algo trivial: cualquier frame desocupado puede ser usado para una pgina deseada. En MULTICS, cada pgina consiste de palabras de 1K. En consecuencia, el offset del segmento (16 bits) es dividido en un nmero de pgina de 6 bit y un offset de pgina de 10 bit. El nmero de pgina se indexa en la tabla de pginas para obtener el nmero de frame. Finalmente, el nmero de frame es combinado con el offset de pgina para formar una direccin fsica Ahora se debe de tener una tabla de pginas individual para cada segmento. Sin embargo, dado que cada segmento est limitado en tamao por su ubicacin en la tabla de segmentos, la

tabla de pginas no tiene que ser de tamao completo, solo requiere de los espacios que son realmente necesarios. Al igual que en la paginacin, la ltima pgina de cada segmento, por lo general no estar totalmente llena. En consecuencia, se tiene, en promedio, una fragmentacin interna de media pgina por segmento. 2.2.3.- Segmentacin con paginacin: Intel 386 El sistema operativo IBM OS/2 de 32 bits es un sistema operativo que corre con las arquitecturas del procesador Intel 386 y 486. El 386 una la segmentacin con paginacin para su manejo de memoria. El nmero mximo de segmentos por proceso es de 16K y cada segmento puede llegar a ser de hasta 4 gigabytes. El tamao de pgina es de 4K.
Direccin lgica 16 0 selector 32 Tabla descriptora offset

Descriptor de segmento

Direccin lineal

directorio

pgina

offset

Marco de pgina

Direccin fsica
Directorio de pginas Registro de directorio Tabla de pginas

Registro de tabla de pgina

Registro de segmento

Fig. 16. Traduccin de direccin en el Intel 80386 El espacio de direcciones lgicas est dividido en dos particiones. La primera particin consiste en segmentos de hasta 8K los cuales son privados para ese proceso. La segunda particin tambin consiste en segmentos de hasta 8K, los cuales son compartidos entre todos los procesos. La informacin de la primera particin es guardada en la tabla descriptora local (LDT Local Descriptor Table), y la de la segunda particin es guardada en la tabla descriptora global (GDT Global Descriptor Table).

Cada registro de las tablas LDT y GDT consiste de 8 bytes con informacin detallada sobre un segmento en particular incluyendo la ubicacin base y longitud del segmento. Cada segmento es paginado, y cada pgina es de 4K. Una tabla de pginas puede entonces consistir de hasta un milln de registros. Dado que cada registro consiste de 4 bytes, cada proceso puede llegar a necesitar hasta 4 megabytes de espacio de direcciones fsica para la tabla de pginas nicamente. Claro est que no sera conveniente alojar la tabla de pginas contigua en la memoria principal. La solucin que es implementada en el esquema para el 386, es usar un esquema de paginacin de dos niveles. La direccin lineal es dividida en un nmero de pgina consistente de 20 bits y un offset de pgina de 12 bits. Siendo que se pagina a la tabla de pginas, el nmero de pginas es a su vez dividido en un apuntador para el directorio de pginas de 10 bit y en un apuntador para la tabla de pginas de 10 bit.