REPÚBLICA BOLIVARIANA DE VENEZUELA

INSTITUTO UNIVERSITARIO DE TECNOLOGÍA

READIC UNIR
EXTENSIÓN CABIMAS

Administración de
Memorias
Autores
Nakfour Abraham
C.I. 19.831.386
Mavarez Liribeth
C.I. 22.134.122
Olarte Paola
C.I. 19.545.099

Cabimas, Septiembre 2010

 Esquema

 Jerarquía de almacenamiento
 Traducción en tiempo de compilación
 Traducción en tiempo de carga
 Traducción en tiempo de ejecución

 Funciones del administrador de memoria

 Distintos esquemas de asignación de memoria
 Asignación completa y contigua
 Particiones múltiples

 Multiprogramación con particiones fijas
 Selección del tamaño de la partición

 Algoritmos de colocación
 Multiprogramación con particiones variables o dinámicas
 Algoritmo de colocación de un programa en memoria
 Elementos de control de la memoria
 El mapa de bits
 La lista enlazada

 Sistema compañero
 Explicación

 Paginación
 Los fundamentos básicos de la paginación
 La carga de un programa en memoria en un sistema paginado

 Tabla de marcos
 Tabla de páginas
 Traducción de direcciones de un sistema paginado
 La compartición
 La protección de memoria

 La fragmentación
 Tamaño de la página
 La segmentación
 Traducción de direcciones en segmentación
 Características del sistema segmentado

 Segmentación paginada
JERARQUÍA DE ALMACENAMIENTO

Cuando el diseñador se plantea lo que es la gestión de memoria del sistema debe tener en
cuenta que la memoria es unos de los recursos críticos del sistema, es crítica porque un
programa al ejecutarse debe estar cargado en M. entonces cuanta más memoria tengamos o
mejora la optimicemos más programas podremos guardar en ella.
¿Qué quiere un diseñador?Que sea barata, gran capacidad y muy rápida.

Pero no se pueden conseguir las tres cosas.

A mayor capacidad el tiempo de acceso es mucho mayor, es más lenta.
Se observa que ha mayor capacidad menor coste por bit, comparamos Módulo de memoria y
disco duro, no cuesta lo mismo un disco duro de 8 gigas que 8 gigas de memoria Ram.
A menor tiempo de acceso, si queremos memoria más rápida, el coste se nos dispara.
Los diseñadores del sistema no pueden tener un solo tipo de memoria donde alojar todas las
memorias, existe una jerarquía de memoria.
Esa jerarquía intenta solucionar esos inconvenientes a la hora de diseñar el esquema de
memoria.

Registros Jerarquía tradicional de memoria

Caché
Memoria principal
Disco Magnético
Cinta Magnética

Registros
Caché
Volátil Memoria principal Interna
Caché de disco
No volátil Disco Magnético Externa
Cinta Magnética
Cinta magnética Disco óptico Jerarquía moderna de memoria

En esa jerarquía podemos ver que se cumplen una seria de condiciones:

 Al bajar de nivel aumenta la capacidad de la memoria.
 Al bajar de nivel disminuye el coste por bit.
 El registro es el más caro, luego la cache...
 Al bajar de nivel se observa que el tiempo de acceso aumenta. Acceder a un disco
óptico es más lento que a un disco magnético.
 Si seguimos bajando de nivel, disminuye la frecuencia de acceso: no es lo mismo que
el tiempo que es el tiempo que trae el dato, es el nº de veces que accede a esa
memoria.
Esta es la clave del funcionamiento de la jerarquía de memoria, esa disminución de frecuencia
se debe sobre todo a lo que se llama como principio de localidad o cercanía de referencia.
Sin embargo ese conjunto va cambiando a lo largo del tiempo.
Ese principio lo que establece es que un proceso durante su funcionamiento hacer referencia a
muchas funciones, pero durante un breve espacio de tiempo el proceso hace referencia a un
pequeño grupo de referencias.
La caché va a intentar que el tiempo de acceso sea mucho más rápido para no tener que
acceder a disco o Mp, distinguimos entre M Interna y M.externa, normalmente lo que es el
disco magnético se le suele conocer como M.secundaria.

Vamos a ver los pasos que hay que realizar para la carga de un programa en M.p:

Programa
fuente

Compilador
otros o ensamblador

módulos biblioteca
objeto Módulo del
objeto sistema

Enlazador

biblioteca Módulo
del sistema de carga
cargada
dinámicamente
Cargador

Imagen del proceso

en memoria

Tenemos un programa fuente, cuando lo compilamos obtenemos un módulo objeto que luego
necesita ser enlazado con el resto de los módulos objetos que tenga el sistema, para formar un
módulo de carga que es el que finalmente se introduce en memoria, una vez cargado de
memoria es cuando verdaderamente podemos decir que es un proceso, entonces tenemos toda
la imagen del proceso.
Una vez cargado en memoria se puede enlazar con bibliotecas del sistema de forma dinámica.
Esas son las fases por las que pasa el programa para convertirse en proceso.
El proceso está definido por la imagen que si recordamos tenía:
 El Bloque de control de procesos
 Datos relativas
 Instrucciones Referencias a datos físicas
Referencias a instrucciones: lógicas o simbólicas:
 La Pilas
Si se observa, consta de datos e instrucciones que tienen referencias a memoria, referencias a
datos y referencias a sus propias instrucciones.
Esas referencias, o direcciones, en realidad pueden ser de tres tipos:
Lógicas, relativas o absolutas.

Direcciones Direcciones Direcciones

simbólicas relativas absolutas
PROGRAM 0 PROGRAM 1024 PROGRAM

JUMP I JUMp 400 JUMP 1424

i 400 1424
LOAD J LOAD 1200 LOAD 2224

DATA DATA DATA

j 1200 2224

Dir simbólicas: no tienen nada que ver con la posterior ubicación física de ese dato, son
normalmente las direcciones que emplea el programador.
Dir relativa: vienen expresadas respecto a un conjunto determinado, normalmente al principio
del programa.
Estas direcciones normalmente son las que utiliza el cargador y el enlazador.
JUMP 400: desde el principio saltar 400.
Dir. absolutas o físicas: son las que realmente ocupan de memoria real, de memoria física.
Son las que realmente se usan en ejecución, el programa solo entiende de direcciones
físicas, para ellos necesitamos hacer una traducción de las simbólicas y relativas a las
físicas.

Esa traducción de direcciones, también conocida como ligadura de direcciones se puede hacer
en distintos instantes, en cualquiera de las fases que hemos vistos, por las que pasa el
programa a proceso.
 Tiempo de compilación
 Tiempo de carga
 Tiempo de ejecución.

Traducción en tiempo de compilación

En tiempo de compilación o enlazado, observar que lo que tenemos que hacer es generar ya
un módulo de carga con direcciones físicas, eso implica que el programador, el cargador o el
enlazador tenga que tener conocimiento de la gestión de memoria, qué partes están libres y
qué partes están ocupadas.
Por otro lado, el modo de carga que se genera, solamente se puede ejecutar en la zona que se
haya especificado, no puede cambiar de lugar, si varía de zona tiene que volver a compilarlo
de nuevo.
Si un proceso sale de memoria y luego entra de nuevo debe ser en la misma zona de memoria.
Para solventar esos problemas la otra manera es que se realice en tiempo de carga.

Traducción en tiempo de carga

En tiempo de carga por un lado elimina que el programador conozca cómo se está
gestionando la memoria.
En este caso la gestión de memoria la va a realizar el cargador que decide donde va a ubicar el
proceso, pero estamos en lo mismo de antes. Puede que yo introduzca el programa en
memoria física, y ya tenga las direcciones físicas, por lo que no puedo cambiarlo de sitio.
Si un proceso se suspende, cuando se vuelve a activar se sitúa en la misma zona de memoria.

Traducción en tiempo de ejecución

En el último momento.
Cuando yo vaya a ejecutar la instrucción es cuando se va a traducir la dirección.
Este esquema es un método muy flexible, porque el proceso puede estar ubicado en cualquier
parte, ya que es justo cuando voy a ejecutarlo es cuando lo traduzco.
Esa traducción necesita la ayuda del hardware, y tampoco es un hardware muy complejo, el
criterio concedía el hardware necesario para realizar esa traducción en tiempo de ejecución.

dirección base límite

dirección dirección
relativa absoluta si
CPU + <= Memoria

no

error de direccionamiento

El programa que está ubicado en memoria sólo tiene direcciones relativas, entonces las CPU
va generando todas la direcciones relativas, y nosotros le sumamos el contenido de un registro
hardware que contiene el inicio donde está ubicado el proceso, entonces obtenemos la
dirección absoluta, posteriormente podemos comparar esa dir absoluta con otro registro
hardware que lo que contiene es el límite de la zona de memoria ocupada por el proceso, si
está dentro del límite podremos acceder a memoria, si está fuera del límite provocaremos un
error de direccionamiento.
Observar que con dos registros hardware y una suma y comparación podemos realizar la
traducción
Proporciona un mecanismo de protección de la memoria porque si se pasa del límite que tiene
cada proceso daríamos un error de direccionamiento.
Con este esquema el proceso lo puedo poner en cualquier parte de la memoria, porque la
traducción la hago justo cuando lo voy a ejecutar.
Cada vez que cambiemos de proceso o de contesto, esos registros límite y base deben
actualizarse, y deben almacenarse en el BCP para que cada vez que cambiemos de proceso
tengamos un valor válido.

FUNCIONES DEL ADMINISTRADOR DE MEMORIA

Debe conocer:
Qué zonas de la memoria están libres y qué zonas ocupadas.
Introducir los procesos en memoria.
Se encarga de asignar y desasignar memoria a los procesos conforme vayan necesitando y
liberando.
Debe controlar el intercambio entre Mp y Ms.
Además de esas funciones, el administrador de memoria debe cumplir 3 requisitos:
Protección:
No solo debe proteger la zona de memoria del proceso, sino de la memoria del sistema
operativo u otro proceso.
Compartición de memoria:
cuando se ejecutan dos procesos iguales, debe permitir que dos procesos compartan la
memoria.
Reubicación:
Un proceso puede cambiar de zona de memoria durante su ejecución.
Este requisito tiene sentido evidentemente es sistema multiprogramado.
En un sistema mono programado no tiene sentido porque si solo hay un proceso, ¿para
qué lo voy a cambiar de sitio.

Distintos esquemas de asignación de memoria

Esquemas de gestión de memoria

 Asignación completa y contigua: el proceso se ejecuta en una zona continua

 Máquina desnuda
 Mono programación
 Particiones múltiples:
 Particiones fijas
 Sistema compañero
 Particiones variables.

 Asignación completa y no contigua:

 Paginación
 Segmentación
 Segmentación-paginación

 Asignación parcial y no contigua:

 Memoria Virtual

Asignación completa y contigua:

El proceso se ejecuta en una zona continua

Máquina desnuda: Es un sistema donde no hay S.O y no hay gestor de Memoria, quien lleva
la cuenta es el propio programador.
Suelen ser pequeños microprocesadores, señales de humo, dedicados a una sola cosa.

Mono programación: La Memoria. dividida en dos partes:

Una parte en el S.O. en unos extremos de la memoria, zona alta o baja, y el resto se deja para
procesos de usuarios, ej: MSDOS.
La elección de donde se debe encontrar el S.O. vendrá dada por donde se encuentra el vector
de interrupciones, lo normal es situarlo junto al vector de interrupciones, parte alta o baja,
algunos sistemas prefieren separarlo.
Es un sistema simple que requiere de una protección del S.O, que el proceso de usuario no
pueda acceder al S.O. Para ello necesita un registro hardware, ya sea un único registro o dos
registros.
¿qué le pasa al MS-DOS? no hay registro límite y cualquier proceso puede cargarse el S.O
fácilmente, observar que la protección tampoco es muy complicada, las direcciones que se
generan se recuperan con el registro límite.
Ej. IBM1120 y Spectrum : zona baja y 2115B: zona alta

Particiones múltiples:
Particiones fijas
Sistema compañero
Particiones variables.

Sistema Límite Sistema

Operativo Superior Operativo
Registro + Usuario
límite Vector de
interrupciones
Usuario

Usuario
Límite
Registro Libre inferior
Límite
Sistema Libre
Operativo
+ Vector de
Libre Vector de Interrupciones
interrupciones

Zona baja Zona Alta Sin vector de

interrupciones

MULTIPROGRAMACIÓN CON PARTICIONES FIJAS

Es la estrategia más simple, consiste en dividir la memoria en una serie de particiones, en

cada una de esas particiones se aloja un proceso.
El nº y tamaño de esas particiones se caracteriza porque es un número fijo que se establece en
la fase de generación del sistema.

Selección del tamaño de la partición

El diseñador del sistema antes de implementar el sistema debe establecer los valores.
Hay que tener en cuenta:
 el nº de particiones va a determinar el grado de multiprogramación del sistema, ya que
si en cada partición hay un proceso y hay 3 particiones solo podré tener 3 procesos
simultáneamente, si quiero un grado de multiprogramación elevado necesitaré muchas
particiones.
 el tamaño determina dos aspectos:
  el tamaño máximo de un proceso, para que se pueda ejecutar un proceso
necesito asignarlo a una partición, por lo tanto el tamaño máximo de un
proceso es el tamaño máximo de la partición.
 el tamaño tb va a afectar a la cantidad de memoria que asigne a un proceso, es
decir, una vez que establezca las particiones cuando tengo el proceso le asigno
un proceso, y ese proceso puede o no ocuparla entera, si no ocupa toda la
partición, hay un desperdicio de memoria que se conoce como fragmentación
interna.
Tenemos 2 alternativas:
Todas las particiones del mismo tamaño: Es una estrategia más simple, pero es poco
flexible,
Particiones de distinto tamaño

ALGORITMOS DE COLOCACIÓN

Yo tengo una serie de procesos, ¿dónde ubico cada proceso?

Estos algoritmos dependen de la partición que hayamos elegido.
Particiones iguales: es trivial el algoritmo, se mete en cualquier partición de forma
automática.
Particiones distintas: hay varias alternativas.
Una cola de procesos por partición: llega el proceso y lo sitúo en la cola donde menor
fragmentación interna genere. Cuando la partición queda libre selecciono el primero de la cola
Inconveniente: puede haber particiones libres con procesos esperando en otra cola porque su
partición está ocupada
Sistema Operativo

Procesos
Nuevos

Otra alternativa es tener una única cola de procesos:

Sistema
Operativo

Procesos nuevos
Llega un proceso y lo situó en la cola, cuando una partición queda libre tendré que seleccionar
que proceso de la cola va en esa partición, es digamos la selección de un proceso.
Para seleccionar ese proceso hay diversos algoritmos, los que más se suelen emplear son:
Mejor ajuste: Cuando una partición queda libre, elegimos el proceso que menor
fragmentación interna produzca.
Primer ajuste: Vamos recorriendo la cola hasta encontrar el primer proceso que quepa en la
partición.
Si se observa, toda esta función de colocar procesos en memoria, en una partición determinar
es en hacer que un proceso sea aceptado en el sistema, que pase de ese estado de nuevo a un
estado de listo, esa transición de nuevo a listo es del planificador a largo plazo.
Todos estos algoritmos es el planificador a largo plazo.

Protección entre particiones: debo evitar que un proceso acceda a zonas de memoria fuera de
su partición:
Hay dos alternativas:
dos registros límites, zona superior y zona inferior de la partición: parto de una dirección
absoluta.

límite inferior límite superior

dir. absoluta
CPU >= < si Memoria

no no
error de direccionamiento

Partimos de una dirección absoluta, y a hay que comprobar que la dirección se encuentre entre
los dos límites

Dos registros, un registro base y otra longitud:

longitud base

dir. relativa dir. absoluta

CPU <= + Memoria
Si Sí

no
error de direccionamiento

Partimos de una dirección relativa, se compara con la longitud, si está dentro de la partición se
puede acceder a él.
¿Cuál es mejor?El de base y longitud: Al ejecutarse direcciones relativas la traducción de
direcciones se produce en el momento de ejecución, por lo cual el proceso es reubicable y
puede cambiar de partición, mientras que con uno de registro límite la traducción debe ser
previa a la ejecución del proceso.
Con el registro longitud y base, la ventaja que tiene es que al partir de una dirección relativa
mientras realiza la protección hace la traducción direcciones en tiempo de ejecución y con eso
se puede reubicar el proceso en otra partición.
El otro aspecto son los elementos de control que necesitamos para llevar a cabo el control de
la memoria, qué zona de la memoria están libres y qué zonas están ocupadas.
En este caso el único elemento que necesitamos en usa tabla de particiones, que tiene una
entrada por partición, y contiene la dirección base de la partición el tamaño y como se
encuentra.
Número de la Base de la partición Tamaño de la Estado de la partición
partición partición
0 0K 100K ASIGNADA
1 100K 300K LIBRE
2 400K 100K ASIGNADA
3 500K 250K ASIGNADA
4 750K 150K ASIGNADA
5 900K 100K LIBRE

Esa tabla es la que se crea en el momento de la generación del sistema.

Inconvenientes: Por un lado, presenta fragmentación interna, si el proceso no ocupa toda la
partición se desperdicia espacio.
El tamaño de la partición es fijo. Si quiero cambiar el tamaño tengo que volver a
generar el sistema, esto implica que el grado de multiprogramación del sistema sea
también fijo.
El tamaño del proceso está limitado a la máxima partición.

Sistema que lo usan:

IBM
OS/MFT (OperativeSystemMultiprogramingwith a FixedNumber o Task)

MULTIPROGRAMACIÓN CON PARTICIONES VARIABLES O DINÁMICAS

El sistema IBM o OS/MUT, intenta vencer los inconvenientes anteriores.

Usa la memoria que él necesite, se va creando lo que necesita.
Si un sistema se suspende o bloquea se va de memoria y deja ese espacio para otro proceso.
Con este esquema las particiones en nº y tamaño van cambiando a lo largo del tiempo.
Los procesos son reubicables.

Sistema 128k Sistema 128k Sistema 128k Sistema 128k

Operativo Operativo Operativo Operativo

Proceso1 320k Proceso1 320k Proceso1 320k

Espacio 896k
de Proceso 2 Proceso 2 224k
procesos 224k

576k 288k
320k Proceso 3
64k

Sistema 128k Sistema 128k Sistema 128k Sistema 128k

Operativo Operativo Operativo Operativo

Proceso 1 320k Proceso 1 320k 320k Proceso 2 224k

96k
224k Proceso 4 128k Proceso 4 128k Proceso 4 128k
96k 96k 96k

Proceso 3 288k Proceso 3 288k Proceso 3 288k Proceso 3 288k

64k 64k 64k 64k

Inconveniente: si observamos a cada proceso le damos la memoria que él necesita, por lo cual
el proceso no tienen fragmentación interna.

Pero al final vamos creando huecos en memoria cada vez más pequeños, esos huecos tan
pequeños son difíciles de asignar a un proceso, por lo cual nos podemos encontrar con lo que
se conoce como fragmentación externa: memoria libre en el sistema que no puede ser
asignada a ningún proceso.

Para solucionar la fragmentación externa hay una técnica que se conoce como compactación:
o recolección de basura, incluso en algunos libres aparece como reducto de la basura.
La idea de la compactación es agrupar todos los procesos que están en memoria para formar
un gran huevo libre, esa es la idea.
El problema de la compactación son dos.

Sistema Operativo Sistema Operativo

Uso Uso
Libre Uso

Uso Uso
Libre

Uso Libre

Libre

Por un lado necesita que los problemas sean reubicables.

Es muy costoso en tiempo, mientras se produce la compactación no se puede ejecutar ningún
proceso, el sistema se paraliza.
Resuelve la fragmentación externa

Uno de los aspectos en el diseño de la compactación es saber cuándo se debe de realizar,

hay 3 alternativas:
1. Cuando haya un porcentaje de la utilización de la memoria, 80%, 70%, el problema es
que se puede compactar cuando no haya procesos que quieran acceder al sistema.
2. Cuando hay procesos esperando para entrar en memoria, el problema es que el sistema
debe estar continuamente comprobando si algún proceso está esperando.
3. Cada un tiempo determinado, 10 min, 20 min... el problema es determinar el tiempo.
ALGORITMO DE COLOCACIÓN DE UN PROGRAMA EN MEMORIA

Se encarga de colocar un proceso en uno de los bloques libres que haya, a la hora de decidir
qué algoritmo de colocación se va a usar, es necesario hacer un examen cuidadoso, no vaya a
ser que se produzca mucha fragmentación externa.

Se emplean los siguientes algoritmos:

 Primer ajuste: el proceso se coloca en el primer hueco donde quepa.
 Mejor ajuste: donde mejor quepa, dejando menos sitio.
 Siguiente ajuste: como el primero pero empezando desde el último hueco que se
asignó.
 Peor ajuste: en el que más sitio haya, en el hueco más grande.

8k 8k

12k 12k

Primer Ajuste
22k

6k

Mejor Ajuste

18k 2k
ultimo bloque
asignado 14k

8k 8k

6k 6k

14k 14k

Siguiente ajuste
36k Peor ajuste

20k

Se asigna un bloque de 16 k
En Primer ajuste: entra al principio en el hueco de 22.
En mejor ajuste: entra en el hueco de 18 k
En el peor ajuste : entra en el mayor, el de 36 k.
En el siguiente ajuste: entra en el siguiente después del anterior, donde quepa, es decir el de
36, si llega al final y no hay se debe empezar de nuevo.

¿Cuál de los 4 algoritmos es el mejor?

El peor ajuste: rompe los ajustes mayores, e impide que entren los procesos mayores.
El mejor ajuste: crea fragmentos muy pequeños, luego no se pueden utilizar. Es el peor
algoritmo de todos.
El siguiente ajuste : busca el primer hueco tras la anterior asignación, los procesos los va
ubicando en donde hay un hueco grande. ej: empiezan a entrar procesos y se van poniendo
uno tras otro, pero luego dejan de usarse y sus huecos quedan libre, pero los siguientes se
siguen asignando abajo, rompiendo espacio grande.
El primer ajuste: es el mejor, el más simple, el más rápido y el que mejor resultados da.
Siempre intenta ocupar los procesos al principio y deja los huecos grandes abajo.

ELEMENTOS DE CONTROL DE LA MEMORIA

Hay que ver los elementos que necesita el sistema para ver qué lugar está libre y cual
ocupado.
Se recurre a dos estrategias:

El mapa de bits:

Es una estrategia simple, lo que hace es tener un bit por unidad de asignación.
Puede ser bit, byte, kbyte, tan grande o tan pequeña como uno quiera.
Si el bit vale 1 es que esa unidad de asignación está ocupada, si vale 0 significa que está libre.

P1 P2 P3 P4 P5
1 1 1 1 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 0 0 0

Cuanto más grande sea la unidad de asignación, el mapa de bits es más pequeño, a mayor.
¿Cuál es mejor?
Grande: su problema es que tiene mayor fragmentación interna, porque lo mínimo que asigno
es una unidad de asignación, y si es de 32k, eso será lo mínimo que tenga asignado.
No debe ser uno muy grande ni muy pequeño.

Es complicado localizar un hueco de cierto tamaño, es decir, uno de 30 unidades de

asignación, es buscar 30 ceros consecutivos, y eso es muy costoso.

La lista Enlazada

Es una estructura que contiene información sobre todos los elementos que hay.
Cada elemento de esa lista tiene la siguiente información:

Tipo: Hueco o Proceso Comienzo Tamaño que ocupa

P 0 4 H 4 3 P 7 7 P 1 6 H 20 2 P 25 4 H 2 3
4 9
Y un puntero al siguiente elemento.
Está claro que el tamaño es mayor que el mapa de bits, porque usa más información.
La lista está ordenada por direcciones.
La ventaja que tiene la lista es que cuando acaba un proceso, el tipo casa de P a H, es muy
fácil liberar memoria.
Además en el cambio de tipo deben de hacerse la fusión de los huecos si hay dos adyacentes.
En ambos casos siempre voy a finalizar el proceso, si hay dos huecos a los lados debo
fusionarlo con los dos, si hay un hueco pues con él, si está rodeada de procesos es lo más
fácil. Para que la fusión sea más simple debe de hacerse como una lista enlazada.

Hueco libre
Proceso
Una alternativa a esa lista enlazada es tener en realidad dos listas enlazadas:
una lista de procesos
una lista de huecos
ahora cada lista la puedo ordenar como quiera, ej: la lista de procesos la ordeno por
direcciones y la de huecos por tamaño de mayor a menor. El ordenarla de menor a mayor
tamaño va a facilitar la política de colocación del proceso.
Liberar un proceso implicaría pasar de una lista a otra el elemento.
Esta estrategia de tener dos listas enlazadas, permite incluso tener una optimización, que
consiste en implementar la lista de huecos directamente en los propios huecos de memoria,
¿qué significa? voy a tener en el sistema un montón de procesos y huecos

El sistema tendrá un montón de procesos y huecos, dentro de la memoria que yo destino a los
procesos del usuario, habrá una parte que destine al sistema operativo, dentro de la parte del
sistema operativo tendré que tener almacenada la lista de procesos y la lista de huecos.

La utilización consiste en que en lugar de tener la lista de huecos en memoria, formarla

directamente sobre los propios huecos libres, en la propia memoria almaceno la información,
sólo necesito un puntero al inicio de esa lista. Lo que se consigue es ahorrarnos la memoria de
huecos libres.

SISTEMA COMPAÑERO

Hemos visto el sistema de particiones fijas, con el problema del grado de multiprogramación
fijo, tantas particiones tantos procesos.
El sistema de particiones variables, el problema era la fragmentación interna, y aparte el
control de la memoria, sea con mapa de bits o lista enlazada, no es tan fácil como en las
particiones fijas.
 El Sistema Compañero intenta vencer las dificultades y un sistema con un grado de
multiprogramación variable, que no tenga fragmentación externa y además con un control de
la memoria sencillo.

Idea Base: Asignar a los procesos, bloques de memoria, de longitud variable pero limitados.
¿en qué sentido?
Considera un tamaño de bloque mínimo= 2i
Considera un tamaño de bloque máximo=2m, la memoria física que hay para los procesos.

Entonces cada bloque que asigna se caracteriza porque se encuentra entre esos dos tamaños
pero siempre en potencia de dos.
2i 2k 2m
Inicialmente tenemos las listas i: es la lista de bloques libres de tamaño 2 n, para cada uno de
los tamaños posibles tenemos una lista de bloques libres, inicialmente todas vacías menos la
del tamaño máximo que tendrá un elemento.
Cuando un proceso pide un bloque de tamaño B, el sistema se busca un bloque 2 i libre tal que
2i-1 < B  2i, el bloque libre que más se adapte a él.
Si no hay libre, divide 2i+1, en 2 bloques de tamaño 2i, uno se queda libre y otro se asigna.
Si no hay 2i+1 se divide en uno más superior.

Se llama sistema compañero porque los que se dividen en 2 son los bloques compañeros.
Si no hay libre:
divide 2i+1 en 2 bloques:
2i (libre) y 2i (asigna)
i+1
si no hay 2
divide 2i+2 en :
2i+1 (libre)
2i+1:
2i (libre)
2i (asigna)
Ej: Un proceso pide 45K y tengo un bloque de 1M, entonces voy dividiendo.

512
1M 256
512 128
256 64
128
64 (asigna)

Memoria física 1 MB

P1 solicita 45 k 45k 64k 128 k 256 k 512 k

P2 solicita 110 k 45k 64k P2 110k 256 k 512 k

P3 solicita 160 k 45k 64k P2 110k P3 160 k 512 k

P4 solicita 95 k 45k 64k P2 110k P3 160 k P4 95k 128 k 256 k

Fin P3 45k 64k P2 110k 256 k P4 95k 128 k 256 k

Fin P2 45k 64k 128 k 256 k P4 95k 128 k 256 k

P5 Solicitud 80 k 45k 64k 80 k 256 k P4 95k 128 k 256 k

Fin P1 128 k P5 80 k 256 k P4 95k 128 k 256 k

Fin P5 512 k P4 95k 128 k 256 k

Fin P4 1 Mb

Explicación:
Tenemos un bloque de 1 Mb.
Llega un P1 y pide 45 k, lo que hago es: cojo el bloque de 1 Mb y lo divido en dos de 512 k,
uno me queda libre y divido el otro en dos de 256, uno queda libre, el otro lo divido en dos de
128, uno queda libre y el otro lo divido en dos de 64 k, los divido y queda uno de 32 k pero no
satisface los de 45 k, entonces me quedo en 64 k y se lo asigno al proceso 1.
Ahora llega el Proceso 2 que pide 110 k, como cabe en el bloque de 128 k se lo asigna.
Luego llega P3 de 160 k, le tengo que asignar 256k y como hay uno libre se lo asigno.
Llega P4 de 95k, tengo que buscar un hueco de 128k, no hay, sólo quedan de 64 k y de 512 k,
entonces divido el de 512 en dos de 256, uno lo dejo libre y el otro lo divido en dos de 128 y
se lo asigno a uno.
Termina P3 y libero memoria.
Termina P2 y libero memoria.
Llega el P5 y pide 80k le tengo que dar un bloque de 128, tengo uno libre y se lo asigno.
Termina P1 y como su hueco compañero está libre lo fusiono con el de al lado en uno de 128.
El resto de los procesos van acabando y se van fusionando con el resto de los compañeros,
hasta que al final se vuelve al 1Mb.
Este algoritmo presenta un grado de multiprogramació variable, lo que pasa es que asigna en
bloques de ciertos tamaños.
Tiene fragmentación interna y fragmentación externa.

PAGINACIÓN

El problema que se plantea en los anteriores sistemas es que intenta mantener el proceso en
una zona continua de memoria, con la paginación se rompe ese esquema de asignación
continua y se empiezan a buscar asignaciones no continuas, es decir, ya el proceso no tiene
por qué estar en una misma zona, sino que podemos romper el proceso y lo vamos alojando
en los distintos huecos de memoria, así reducimos la fragmentación interna.

Los fundamentos básicos de la paginación

La memoria se divide en una serie de unidades llamadas marcos.
El proceso lo divide en páginas.
El tamaño del marco y de la página es el mismo.
La idea de la paginación, cojo un proceso, lo divido en páginas y lo coloco en marcos.
La característica de la paginación es la separación que hace entre la visión que tiene el usuario
del proceso y la visión que tiene del sistema operativo.
El usuario va a ver su proceso como una zona contigua y el sistema lo ve como una división
de páginas, cada una en un marco.
Evidentemente para que la paginación sea efectiva nosotros vamos a necesitar un hardware
que nos permite hacer una traducción de esa página al marco.
Otra característica de la paginación es que va a poseer fragmentación interna, eso se puede ver
en el dibujo.

marco 0 pagina 3

página 0 marco 1

página 1 Hardware de marco 2 pagina1

paginación
página 2 marco 3
pag marco
pagina 3 marco 4 pagina 0

marco 5 página 2

Yo a un proceso lo debo dividir en páginas, el nº de páginas debe ser entero, si el proceso no

llega a ocupar la última página se produce la fragmentación interna.

La carga de un programa en memoria en un Sistema Paginado

Para cargar un programa en M. se realizan 3 fases:

1. Determinar el nº de páginas que tendrá el proceso, para ello se divide el tamaño del
proceso por el tamaño de la página, siempre debe ser un nº entero. Se redondea por
exceso.
2. Se buscan los marcos libres en el sistema para alojar esas páginas, para realizar esa
búsqueda de marcos libres necesitamos una estructura de control que se conoce como
la tabla de marcos (en fotocopia no aparece)
3. Una vez encontrados los marcos libres, se van cargando las páginas marco a marco.

Posteriormente para saber nosotros en qué marco está cada página necesitamos una estructura
que es la que se conoce como la tabla de marcos.

Tenemos un proceso que ocupa 4 páginas, ocupamos 4 marcos, se van asignando,

pág 0 marco 13
pág1  marco 14
pág2  marco 18
pág3 
no es necesario que estén continuos, vale cualquier marco. (fotocopia)

TABLA DE MARCOS

Es única en el sistema, y lo que contiene o indica es qué marco está libre y que marco está
ocupado, lleva el control de la memoria libre y la memoria ocupada.
Esta tabla (fotocopia) tiene una entrada por marco en el sistema.
1 entrada por marco  Nº de entradas= Tamaño M. física / Tamaño Marco
La entrada del marco dice si está libre u ocupado.
Si está ocupado lo que contiene es: el proceso y la página del proceso que está ocupando ese
puesto. El nº de página y el nº del proceso.

TABLA DE PÁGINAS

Hay una por proceso. Al contrario que la de marcos que hay una en el sistema.
Posee una entrada por página que pueda tener el proceso.
Cada entrada lo que contiene es el nº de marco donde se encuentra ubicada.
La tabla de páginas es un elemento muy importante a la hora de traducir direcciones. Cuando
nuestro programa genera una dir lógica (transparencia)
Por un lado tenemos la visión del usuario y por otra la del sistema que está toda dispersa.
El usuario genera dir lógicas dentro de la zona continua, esta zona necesita traducirse a una
dir. física, para esa traducción necesitamos de ciertas estructuras con el apoyo del hardware
para hacer traducción del nº de páginas a nº de marcos, para eso necesitamos la tabla de
páginas.
Si nos fijamos, cada vez que haya que traducir una dir de lógica a física hacemos 2 accesos a
memoria: primero accedemos a la tabla de páginas y luego a la dir. física de verdad.
Evidentemente es una traducción bastante lenta.
Para reducir ese tiempo de acceso, ese doble acceso que hay en la traducción se recurre a
diversos métodos:
Implementar toda la tabla de páginas mediante el uso de registros. Si recordamos al pico del
tema había una jerarquía de memoria, entonces una opción para reducir el tiempo de acceso lo
subimos al nivel más alto y es más rápido. El problema es que no hay muchos registros, por lo
que no es una opción válida.
Seguir bajando de nivel de la jerarquía, el siguiente nivel es la caché, una especial para la
tabla de páginas, es lo que se conoce como el buffer de traducción adelantada (TLB). Este
buffer es una memoria caché sólo para entradas de la tabla de páginas.

El hardware que se necesita para implementar toda la tabla de páginas se usa en esta
estructura. (transparencia)
La dir lógica. Cada vez que generemos una dir lógica tenemos que ir a la tabla de páginas,
para obtener el marco y con ello la dir física, con la TLB se evita ir a la tabla de páginas, es
una especie de M.c. que tiene ciertas entradas de la TP, si se encuentra ahí la entrada de la TP
se puede generar la dir física y ya se reduce un acceso, si no hay acierto, habrá que recurrir a
la TP, es una forma de optimizar el acceso a la TP.
Respecto a la figura se ve que aparte de la TLB se usa otro registro hardware RBTP (registro
base a la TP) ese registro lo que contiene es un puntero a donde comienza la TP del proceso
que está en ejecución. Cada vez que hay un cambio de proceso hay que cambiar ese registro.
En la figura se puede fijar que cuando se accede a la TP se dibuja una única flecha mientras
que la TLB tiene una especie de tridente, esto es porque la TLB tiene sólo un cjto de entradas,
y no tengo un índice sobre las entradas, por lo que tengo que buscar una a una hasta que
encuentre la que quiero.
Obtiene un rendimiento de 70 u 80 %, si falla hay 3 accesos.
Hay que llevar un buen control de la caché para evitar lo fallos.

Con la TLB, en el sistema cada vez que se genera una dir lógica, hay que controlar si la
entrada está en la TLB, si se encuentra genera la dir física, si no se encuentra hay que acceder
a la TP y actualizar la TLB, la TLB debe tener siempre las últimas entradas a las que se ha
hecho referencia.

TRADUCCIÓN DE DIRECCIONES DE UN SISTEMA PAGINADO.

La TLB no aparece.
Si se ve la figura con la otra se omite la TLB, pero se supone que está.
En la traducción de dir en un sistema paginado la dir lógica está compuesta por 2
componentes, una nº de página y un desplazamiento.
Ese nº de página se usa como índice en la tabla de páginas, cojo el nº de páginas, me voy con
el puntero y lo uso como índice, a través de la TP obtengo el nº de marco donde se encuentra
ubicada, una vez que tengo el marco, la dir física es la composición del nº de marco y el
desplazamiento.
Lo más importante de la traducción de direcciones es el tamaño de la página.
El tamaño de la página viene dado por el hardware y se realiza además en potencia de 2. Los
valores que suele traer es de 512 a 4096.
Es posible que el diseñador pueda jugar con un rango de valores y pueda elegir uno u otro. El
tamaño viene influenciado por el hardware.

El que venga el tamaño de la página en potencia de dos va a simplificar mucho el esquema, si

tenemos un espacio de dir. lógicas de 2n páginas
tenemos un tamaño de página de 2m páginas
El proceso de traducción es el siguiente, en primer lugar, se extrae el nº de páginas, que es en
realidad lo primeros m-n bits de la dirección lógica.
Yo tengo mi dirección lógica, mi espacio de dir es de 2 16 bits, mi página tiene un tamaño de
210 bits.
Por lo tanto hay 6 bits para decidir el nº de página.
m=16 y n=10
6 10
Con ese nº de página obtengo el nº de marco, voy a la tabla de página y obtengo el nº del
marco, finalmente la dirección física es
La dirección del marco es nº del marco por su tamaño más su desplazamiento.
Obtengo el marco y lo único que hago en realidad es concatenarle el desplazamiento.
A nivel de op. con el hardware son operaciones muy sencillas.

Dirección lógica 1502.

Proceso de traducción, pasarlo a formato página desplazamiento:
Es decir extraer el nº de la página.
Cojo la dir lógica, la divido por el tamaño de la página:
478
La página de desplazamiento: pág 1 y desplazamiento 478.
1502: 1024 = 1 y resto 478
Lo siguiente que tengo que hacer es pasarlo a marco desplazamiento, con eso hago uso de la
tabla de páginas: La entrada 1 dice que es el marco 2:
Marco 2 y desplazamiento 478, la dir física es:
dirección lógica de 16 bits
página desplazamiento

6 bits 10 bits
CPU 000001 0111011110 00001 0111011110 Marco 2
0
6bits 10 bits
Registro PTBR marco desplaza.
Puntero a la tabla
de páginas

000110
000101
+ 000010
101010

Tabla de páginas

En este esquema, cada vez que un proceso da una referencia, una dirección lógica, es en el
tiempo de ejecución cuando se hace la traducción de dirección lógica a física, esto permite
que los procesos sean reubicables. Era una de las características que debían tener los
administradores.

A los vectores de memoria se le pedían tres requisitos:

procesos reubicables, protección de M y compartición de Memoria.
Vamos a ver cómo influyen esos dos aspectos en la paginación:

La compartición:
En un sistema cuando tenemos varios procesos ejecutando, si todos los procesos ejecutan un
mismo código se puede dar que los procesos compartan las mismas páginas, esa compartición
se puede llevar a cabo en un sistema paginado siempre que sean páginas con código no
reentrante, es decir: páginas que no se modifican. Esas páginas que no se modifican son las
páginas que se pueden compartir.
Para poder compartir páginas, la Tabla de Marcos prefiere tener cada entrada un campo que
sea un contador de procesos que comparten la partición.
Así por ejemplo tenemos la tabla de páginas del proceso actual.
Suponer que tenemos dos procesos de 4 páginas, y comparten las 3 primeras páginas de los
marcos 3, 4 y 7. En este caso la tabla de páginas tiene un contador más, que indica el nº de
procesos que está usando esa página, si hubiera otro proceso y quisiera compartir la página el
contador tendría que incrementarse. Si un proceso libera una página debe decrementar el
contador, cuando el contador llegue a cero significa que el marco está libre.

La protección de Memoria:
Hay dos aspectos importantes:

El modo de acceso a otra página: modo lectura o escritura.

Dada una referencia a una página saber si se puede realizar una operación de lectura u
escritura.
La implementación de esta protección es bastante simple, para ello en la T. de páginas en cada
entrada almacenamos su bit de protección correspondiente, cada vez que se haga una
operación hay que comprobar esos bits.
La validez de una página: si la página es correcta o no es correcta.
Hemos visto que la dirección lógica tenía dos componentes, página y desplazamiento, vamos
a suponer que la dirección lógica tiene 16 bits, el desplazamiento de 10 bits, y para
direccionar una página emplaza 6 bits que indica que el número de páginas máximo que
puede tener un proceso es de 26= 64 páginas. El proceso no tiene por qué tener ocupada las 64
páginas. La protección de validez hace referencia a que cuando un proceso tiene 3 páginas, si
el proceso hace referencia a la página nº 10 tendría que dar un error, porque está intentando
acceder a una página que no le pertenece. La forma de implementar este mecanismo de
protección es la siguiente: hay dos alternativas:
 A través de la T. de Páginas: en cada entrada se le añade el bit de validez, es 1 o 0,
para página válida o inválida. Cada proceso tiene su propia tabla de páginas.
 Con ayuda del hardware mediante otro registro: PTBR: registro de longitud de la tabla
de página, ese registro contiene el nº de entradas válidas de la tabla de páginas. Con
ese registro cada vez que le den una dirección lógica lo primero que se hace es
comparar el nº de páginas con el registro de longitud.

LA FRAGMENTACIÓN

La fragmentación externa era memoria libre pero que no se podía asignar a un proceso.
No tiene fragmentación externa porque cualquier marco se puede asignar a cualquier proceso.

La fragmentación interna era memoria asignada a un proceso que no se usa, sí que tiene
fragmentación interna, en la última página.
En estos sistemas, lo primero que hay que hacer a la hora de ejecutar un proceso es dividirlo
en páginas, si el tamaño del proceso no es múltiplo del tamaño de la página, esta no se
ocupará entera.
Como media tiene de fragmentación interna el tamaño de la página entre dos.

TAMAÑO DE LA PÁGINA

Va a venir siempre influenciado por el hardware.

Además siempre va a ser en tamaño de dos para que la traducción sea más simple.
Sin embargo en determinas sistemas al diseñador del sistema se le ofrece un rango de valores
para que escoja uno de esos valores.
Normalmente los rangos que se ofrecen van entre 512 bytes a páginas de 8K.
A la hora de determinar qué valor debemos de coger para nuestro sistema hay dos aspectos
que influyen en la selección:
 La fragmentación interna  ¿qué es preferible? páginas pequeñas para que sea lo
menor posible la fragmentación interna.
 El tamaño de la T. de páginas  conviene páginas grandes para tener menos páginas
en cada proceso y que no ocupe mucho la tabla de páginas.

Se puede establecer una fórmula que nos de un valor óptimo del tamaño de la página.
E=Nº de bytes que ocupa una entrada en la T. de páginas
P=Tamaño de la página.
Teniendo esos valores, nosotros sabemos que por la fragmentación interna nuestro
desperdicio es la mitad del tamaño de la página, aparte de la fragmentación interna, nosotros
necesitamos tener una tabla de páginas, el tamaño de ocupa una tabla de páginas es: E*S s=nº
de entradas. Es el número de entradas por el número de bytes de cada entrada. Si la ecuación
se iguala a 0 y se deriva para calcular el óptimo nos da que el valor óptimo de P=la raíz
cuadrada de 2 por el tamaño medio de un proceso por el nº de bytes de una entrada en la tabla
de páginas.

LA SEGMENTACIÓN

Con la paginación conseguíamos que la visión del sistema y del usuario era distinta.
El usuario veía al proceso como un espacio contiguo.
El sistema veía al proceso disperso.
Se intenta asemejar a la visión del usuario.
Se intenta dividir en segmentos los distintos componentes del sistema, agrupar las dos
visiones.
Con los segmentos tendremos una dirección lógica y tendremos que hacer una traducción a
dirección física, igual que en el sistema paginado.
Para realizar esa traducción, al igual que en el sistema paginado usaremos la tabla de
segmentos.

Traducción de direcciones en segmentación

El esquema es muy similar, pero ahora las páginas son segmentos pero de un tamaño distinto.
En la tabla de segmentos hay una entrada por cada segmento que posea el proceso, esa entrada
lo que contiene la dirección de inicio donde está ubicado ese segmento, se llama base.
La amplitud o el tamaño del segmento, cada segmento puede tener un tamaño distinto.
Los bits de protección, igual que en el sistema paginado.
Una tabla de segmento es un elemento muy importante en la traducción de direcciones.
Con esta estructura sabemos la memoria que está ocupando un proceso, aparte de esta
estructura se requiere de otra para llevar el control de que memoria está libre. En este caso se
pueden emplear la lista enlazada o los mapas de bits, que son estructuras vistas en el sistema
de particiones variables.

M.Física
4 12 direcc.
CPU 0001 001011110000 < + Segmento 1
física

Registro STLR < error de

direccionamiento

Longitud de la
Tabla de Segmentos 001011101110 0000010000000000

+ 011110011110 0010000000100000

Puntero 000000001000 1000000000000000

a la tabla de
segmentos 12 bits 16 bits
Tabla de Segmentos
STBR
El esquema es muy similar, pero ahora las páginas son segmentos pero de un tamaño distinto.
En la tabla de segmentos hay una entrada por cada segmento que posea el proceso, esa entrada
lo que contiene la dirección de inicio donde está ubicado ese segmento, se llama base.
La amplitud o el tamaño del segmento, cada segmento puede tener un tamaño distinto.
Los bits de protección, igual que en el sistema paginado.
Una tabla de segmento es un elemento muy importante en la traducción de direcciones.
Con esta estructura sabemos la memoria que está ocupando un proceso, aparte de esta
estructura se requiere de otra para llevar el control de que memoria está libre. En este caso se
pueden emplear la lista enlazada o los mapas de bits, que son estructuras vistas en el sistema
de particiones variables.

El esquema es muy similar al esquema paginado, la dirección lógica está compuesta por dos
componentes, por un nº de segmento y un desplazamiento, el nº de bits que determina el
desplazamiento viene dado por el tamaño máximo de un segmento.

A la hora de determinar el tamaño de cada segmento hay algo de libertad, pero el hardware
indica cual es el tamaño máximo del segmento, que nos determina los bits que hay para el
desplazamiento. Ese nº de segmento se usa como índice en la tabla de segmento.
En la tabla de segmento nos va a decir donde comienza el segmento y cuanto ocupa.
Hay más componentes: el registro

STLR (registro de longitud de la tabla de segmento)  es un registro que lo que contiene es

la longitud de la tabla de segmentos, es decir, el nº de segmentos que posee el proceso. Ese
registro se encarga de la validez de acceso a un segmento, igual que en el sistema paginado.
Cada vez que hay un cambio de proceso hay que cambiar su valor.

STBR (Registro que apunta a la tabla de segmento) es un registro hardware que cada vez
que cambiemos de proceso tenemos que cambiar el valor del registro. Apunta a la dirección
de comienzo de la tabla de segmento del proceso que está en ejecución.

En un sistema Segmentado, hay 3 aspectos de protección:

 Si se puede acceder en modo lectura o en modo escritura.

 La validez de acceso a un segmento, viene controlada por el registro de la longitud de
la tabla de segmento.
 La validez de acceso dentro de un segmento, tenemos una dirección lógica con un nº
de segmento y un desplazamiento, se supone que el desplazamiento está dentro del
segmento, eso es lo que tiene que comprobar. Se comprueba a través de la tabla de
segmentos, que aparte de tener la dirección de inicio de un segmento tiene la longitud
del segmento.

Ejemplo de cómo se analiza la traducción.

Dirección lógica de 16 bits.

Segmentación máximo= 4Kbytes
Referencia: 4848
Determinar el formato de la dirección lógica.
Hay que determinar cuántos bits corresponden al segmento y cuantos al desplazamiento.
 segmento desplazamiento
4 12

desplazamiento= 12 bits  4k = 22 210

entradas en una tabla de segmentos, ¿cuántos segmentos cómo máximo podrá haber? 16 = 24
Vamos a realizar la traducción de la dirección 4848.

1º Extraer el nº del segmento = m-n bits + significativos (16 – 12 = 4)

m= nº de bits de la dirección lógica.
n= bits que necesita para el desplazamiento.
Se divide la dirección por el tamaño del segmento máximo:
4848 div 4096 = 1
4848 mod 4096 = 753 (1,752)
El nº es fijo, no tiene porqué ocuparlo todo, por eso se ve el tamaño máximo.
2º Se comprueba si el nº de segmento es válido (STLR).
Para ello se hace uso del registro que contiene la longitud de la tabla de segmentos.
3º Usar el nº de segmento cómo índice de la tabla de segmentos (STBR)
4º Comprobar si el desplazamiento es válido (753  1950 ) (un nº supuesto)
Se compara la longitud del segmento con el desplazamiento.
5º Obtener la dirección física.
Sumar al desplazamiento la dirección base del segmento.
Si el segmento 1 comienza en la dirección 8224: 8224 + 752 = 8976 (dirección
física) .
Características del Sistema Segmentado

 Cada vez que accedemos a memoria, en realidad hay 2 accesos a memoria, en cada
referencia tenemos que ir primero a la tabla de segmentos y luego al dato, igual que en
el paginado.
Para reducir ese defecto del doble acceso se puede emplear una TLB para evitar tener
que acceder a la tabla de segmentos
 Los procesos son reubicables: cada vez que se genera una dirección en el momento de
ejecución es cuando se traduce de dirección lógica a dirección física.
 Compartición: La tabla de segmentos debe tener un contador que indica cuantos
procesos están usando ese segmento.
 Fragmentación: externa. Nosotros vamos ubicando los segmentos y puede haber
huecos que vayan sobrando muy pequeños, no se puede dar la interna, porque creamos
segmentos de una longitud variable.
 Política de ubicación de segmentos: donde ubicar cada uno de los segmentos, es
similar a las particiones variables. En los paginados daba igual porque todos eran
iguales.
 Compilación por separado de los segmentos.

SEGMENTACIÓN PAGINADA
Memoria Principal
dirección lógica

segmento página desplazamiento

Tabla de Tabla de desplazamiento

 segmentos páginas
dir. física

+ base + marco

Puntero a
la tabla de
segmentos

registro (STBR)

Has ahora hemos visto o solo segmentado o sólo segmentado, sin embargo hubo dos
arquitecturas, como eran del sistema que sacaron una arquitectura combinada que era la
segmentada paginada

Tenemos nuestro proceso, el programa lo dividimos en segmentos, igual que si fuera un

sistema segmentado, posteriormente paginamos cada uno de esos segmentos, esas páginas son
las que realmente están ubicadas en Memoria Principal.
En este caso, el proceso de traducción es algo distinto, la dirección lógica no tiene ahora 2
componentes, sino 3.

¿Cómo funciona este sistema? Cogemos el nº de segmento y a través de él obtenemos la

entrada a la tabla de segmento que apunta a una tabla de página, cogemos el nº de página y lo
usamos como índice en la tabla de página, que da el marco donde se encuentra almacenada,
en ese marco tenemos ya la dirección física.