UNIVERSIDAD ANDINA DEL CUSCO

FACULTAD DE INGENIERÍA Y ARQUITECTURA

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS

TEMA:
PROYECTO DE GESTION DE MEMORIA

ASIGNATURA: Sistemas operativos

DOCENTE: Ing. Palomino Olivera, Emilio

ESTUDIANTE: Fudino Gonzales Flavio Cesar

Quispe Lira Daniel Leonard
Santos Castro Carlos
Solis García Habrahan
Valdez Terán Jair
Vela Beltrán Diego Alejandro

CUSCO – PERU
Julio 2017
Contenido
Introducción .................................................................................................................................. 4
1.1. Identificación del Problema ................................................................................................... 5
1.1.1. Descripción del problema ............................................................................................... 5
Partición dinámica ................................................................................................................. 5
Paginación por demanda....................................................................................................... 5
Hiperpaginación-Control de carga ........................................................................................ 5
Políticas de reemplazo .......................................................................................................... 5
Gestión del espacio de swap ................................................................................................. 5
Segmentación paginada ....................................................................................................... 5
Protección y compartición .................................................................................................... 5
Políticas de asignación de marcos de página ........................................................................ 5
1.1.2. Formulación interrogativa del problema ........................................................................ 6
1.1.2.1. Formulación interrogativa del problema general .................................................... 6
1.1.2.2. Formulación interrogativa de los problemas específicos......................................... 6
1.2. Limitaciones de la Investigación............................................................................................. 6
1.2.1. Entorno............................................................................................................................ 6
1.2.2. Limitaciones .................................................................................................................... 6
1.3. Objetivo de la investigación ................................................................................................... 6
1.3.1. Objetivo General ............................................................................................................. 6
1.3.2. Objetivos Específicos ....................................................................................................... 6
1.4 Hipótesis .................................................................................................................................. 7
1.4.1. Hipótesis general ............................................................................................................. 7
1.5 Metodología de la tesis ........................................................................................................... 7
1.5.1. Tipo de Investigación....................................................................................................... 7
1.5.2. Hipótesis general ............................................................................................................. 7
1.5.2. Método de investigación................................................................................................. 7
Marco Teórico ............................................................................................................................... 7
1.6. Aspectos generales................................................................................................................. 7
1.6.1. Gestión de memoria........................................................................................................ 7
1.6.1.1. Objetivos de la gestión de memoria ............................................................................ 7
Implementación de algoritmos de solución .................................................................................. 9
Partición Dinámica .................................................................................................................... 9
 VENTAJAS Y DESVENTAJAS DE LA PARTICION DINAMICA: .................................................... 9
Implementación en Java para Android................................................................................. 9
Paginación por Demanda .......................................................................................................... 9
Ventajas ............................................................................................................................... 10
Desventajas ......................................................................................................................... 10
Implementación en Java para Android............................................................................... 10
Hiperpaginación ...................................................................................................................... 10
Implementación en Java para Android............................................................................... 10
Políticas de Reemplazo............................................................................................................ 11
Algoritmo Óptimo ............................................................................................................... 11
Algoritmo FIFO .................................................................................................................... 13
Algoritmo LIFO..................................................................................................................... 15
Gestión del espacio de swap ............................................................................................... 17
Segmentación paginada ..................................................................................................... 18
Protección y compartición .................................................................................................. 18
Políticas de asignación de marcos de página ...................................................................... 19
Introducción

Tras la aparición de los sistemas operativos y su constante evolución, se fueron desarrollando

diferentes programas, servicios y aplicativos, que solucionaran los problemas existentes de los
usuarios finales, sin embargo de trasfondo todos los sistemas operativos se vieron envueltos
en una problemática, esta era tener una integra y optima gestión en los recursos de memoria,
tratando de regular el comportamiento del procesador y todos los componentes anexos a este
de manera óptima.
Se generaron diversas estrategias referentes a la asignación, reubicación y referencia de los
procesos.

Para poder lograrlo, la operación principal de la gestión de memoria es trasladar la

información que deberá ser ejecutada por la unidad central de procesamiento o procesador, a
la memoria principal. Actualmente esta administración se conoce como memoria virtual,
porque no es la memoria física del procesador sino una memoria virtual que la representa.
Entre algunas ventajas, esta memoria permite que el sistema cuente con una memoria más
extensa teniendo la misma memoria real, por lo que esta se puede utilizar de manera más
eficiente. Y por supuesto, que los programas que son utilizados no ocupen lugar innecesario.
Las técnicas que existen para la carga de programas en la memoria son: partición fija, que es la
división de la memoria libre en varias partes (de igual o distinto tamaño) y la partición
dinámica, que son las particiones de la memoria en tamaños que pueden ser variables, según
la cantidad de memoria que necesita cada proceso.
1.1. Identificación del Problema
1.1.1. Descripción del problema
Problemas y/o mejoras encontrados en gestión de memoria:

Partición dinámica
Se produce cuando la partición dinámica se desemboca en una situación en la que hay
un gran número de huecos pequeños de memoria. Conforme pasa el tiempo, la
memoria comienza a estar fragmentada y su rendimiento decae. Este fenómeno se
denomina fragmentación externa.

Paginación por demanda

Cubre todas las actividades acerca de la transferencia de información desde memoria
secundaria a memoria principal, si no existe es método no podríamos mover
información entre memorias

Hiperpaginación-Control de carga
Se produce cuando el número de marcos de página que se ha asignado al proceso no
es suficiente para almacenar las páginas referenciadas activamente por el mismo. La
hiperpaginación es una situación de alta paginación producto de que el conjunto
residente de los procesos es de tamaño reducido.

Políticas de reemplazo
Existen para satisfacer el fallo de página (Cuando un proceso necesita acceder a una
página que no está en memoria principal) de un proceso.

Gestión del espacio de swap

El sistema operativo debe gestionar el espacio de swap reservando y liberando zonas
del mismo según evolucione el sistema, hay dos alternativas a la hora de asignar
espacio de swap durante la creación de una nueva región. Una de ellas el pre-
asignación de swap donde se reserva espacio de swap al momento de crear una región
del proceso. La segunda forma es sin pre-asignación alguna de swap, sólo se reservará
cuando una página sea expulsada por primera vez.

Segmentación paginada
La segmentación paginada es una combinación de segmentación y paginación
la consecuencia de no utilizar esta técnica es básicamente la pérdida de la
optimización de los problemas individuales de ambos.

Protección y compartición
La segmentación se presta a la implementación de políticas de protección y
compartición ya que al no aplicarlas estas políticas suelen surgir errores Puesto que
cada entrada de la tabla de segmentos incluye la longitud, además de la
dirección base, un programa no podrá acceder por descuido a una posición de
memoria principal más allá de los límites de un segmento.

Políticas de asignación de marcos de página

Los marcos de página es un uso importante del uso de memoria virtual, para cada
programa es necesario asignarle un espacio de páginas en memoria virtual y los
marcos de página en memoria principal , en caso de que no se use la asignación de
marcos empezaría a sobrescribir los procesos en marcos ya existentes.
1.1.2. Formulación interrogativa del problema
1.1.2.1. Formulación interrogativa del problema general
¿Qué pasaría si gestión la de memoria no existiera?

1.1.2.2. Formulación interrogativa de los problemas específicos

¿Qué pasaría si gestión de memoria no existiera?

¿Qué pasaría si Paginación por demanda no existiera?
¿Qué pasaría si Hiperpaginación-Control de carga no existiera?
¿Qué pasaría si Políticas de reemplazo no existiera?
¿Qué pasaría si Políticas de escritura no existiera?
¿Qué pasaría si Segmentación paginada no existiera?
¿Qué pasaría si Protección y compartición no existiera?
¿Qué pasaría si Políticas de asignación de marcos de página no existiera?

1.2. Limitaciones de la Investigación

1.2.1. Entorno
Esta investigación se desarrolla:
Universidad Andina del Cusco
Facultad de Ingeniería y Arquitectura
Carrera profesional de Ingeniería de Sistemas
Curso de Sistemas Operativos

1.2.2. Limitaciones
Conocimiento con el entorno de desarrollo en Android (Android Studio)
Conocimiento en programación Android

1.3. Objetivo de la investigación

1.3.1. Objetivo General
Demostrar y desarrollar los modelos de solución y/o optimización los cuales
se obtuvieron al momento de analizar los diferentes temas y subtemas del capítulo de
gestión de memoria.

1.3.2. Objetivos Específicos

Demostrar la importancia del uso de Partición dinámica
 Demostrar la importancia del uso de Paginación por demanda
Demostrar la importancia del uso de Hiperpaginación-Control de carga
Demostrar la importancia del uso de Políticas de reemplazo
Demostrar la importancia del uso de Políticas de escritura
Demostrar la importancia del uso de Segmentación paginada
Demostrar la importancia del uso de Protección y compartición
Demostrar la importancia del uso de Políticas de asignación de marcos de página

1.4 Hipótesis
1.4.1. Hipótesis general
Mediante el presente informe demostraremos de una manera mas sencilla y practica
el comportamiento del sistema operativo frente a la gestión de memoria

1.5 Metodología de la tesis

1.5.1. Tipo de Investigación
Investigación histórica

1.5.2. Hipótesis general

Aprehensivo (Analizar, Comparar)

1.5.2. Método de investigación

Método lógico inductivo

Marco Teórico

1.6. Aspectos generales

1.6.1. Gestión de memoria

Se refiere a la tarea de subdivisión, y posterior asignación, del recurso memoria que realiza un
sistema operativo con respecto a cada proceso que lleva a cabo este de forma trasparente,
segura y eficiente. De forma que el rendimiento de la computadora, con respecto a los
procesos que lleve a cabo, sea óptimo.

1.6.1.1. Objetivos de la gestión de memoria

Independientemente de la técnica de gestión de memoria que se emplea en un determinado

sistema operativo, está siempre busca cumplir ciertos objetivos:

• Ofrecer espacios lógicos independientes: Se refiere a que el sistema operativo busca

brindarle a un determinado proceso un espacio lógico de memoria principal en el que se aloje
los datos necesarios para ejecutar dicho proceso, en el caso de un sistema con mono
programación, esto se logra cargando la dirección de memoria en la que se encuentra el
programa y pasarle el control al mismo. En el caso de un sistema con multiprogramación se
realiza un proceso de reubicación de las direcciones de memoria a las que hacen referencia las
instrucciones de un programa (direcciones lógicas) para así asignarlas a sus direcciones de
memoria principal correspondiente (direcciones físicas), dicho proceso se realiza con el fin de
que cada proceso posea un espacio lógico, o mapa, asignado.

• Protección: Se refiere a la protección que brinda un sistema operativo con respecto a

la ejecución de procesos, en el caso de un proceso con mono programación, simplemente
tiene que evitar que un proceso que este ejecutándose afecte el correcto funcionamiento del
sistema operativo en sí, en el caso de un sistema operativo con multiprogramación el además
de proteger su funcionamiento de un proceso en ejecución, también debe asegurarse de
proteger el funcionamiento de los procesos entre sí, lo cual por lo general se logra apoyándose
en el hardware, para así validar las direcciones que genera un programa al ser ejecutado.

• Compartimiento de memoria: Se refiere a que las direcciones lógicas de dos o más

procesos diferentes compartan la misma dirección física, siendo esto posible solo si el espacio
lógico de los procesos no es contiguo, sin embargo esto genera algunos problemas como por
ejemplo que una dirección de la zona compartida deba contener una dirección diferente de la
misma zona.

• Soporte de las regiones del proceso: Se refiere al control que el sistema operativo debe
tener con respecto a las regiones que conforman un espacio lógico asignado a un proceso, con
respecto a su tamaño, seguridad, accesos, etc. Esto debido a que los espacios lógicos de un
proceso por lo general poseen un comportamiento dinámico por lo que es recomendable que
el sistema operativo sepa cuando asignar o liberar la memoria física que ocupan las regiones
que conforman estos.

• Maximizar el rendimiento: La gestión de memoria busca repartir el recurso memoria

entre procesos de manera que exista un mayor grado de multiprogramación, es decir que
residan en memoria principal la mayor cantidad de proceso posibles , y reducir el desperdicio
inherente al reparto esto, con el fin de mejorar el rendimiento. Una situación óptima vendría a
ser que cualquier dirección lógica apunte a cualquier dirección física, de forma que existan
direcciones de memoria contiguas que referencien procesos diferentes, el problema es que
esta situación es imposible por el hecho de que el proceso de traducción de estas direcciones
sería muy complicado. Por tanto la solución más factible y la más empleada actualmente es la
implementación de la memoria virtual (concepto que se abordara más adelante).Antes de la
memoria virtual se usaba la técnica del swaping, la cual consistía en que los procesos que no
caben en memoria principal en un determinado momento queden suspendidos y que las
imágenes de los mismos residan en memoria secundaria. Cabe destacar que cuando el grado
de multiprogramación supera ciertos límites el rendimiento de la computadora decae de
manera significativa.

• Mapas de memoria muy grandes para los procesos: Se refiere a que el sistema
operativo busca proporcionar a los procesos espacios lógicos considerablemente más grandes
que la memoria física disponible en el sistema, debido a que esto permite a los programadores
obtener beneficios del avance tecnológico
Implementación de algoritmos de solución
Partición Dinámica
Con esta partición, las particiones son variables en número y longitud, esto quiere decir que
cuando se carga un proceso a memorial principal se le asigna el espacio que necesita en
memoria y no más. Esta partición comienza siendo muy buena pero en el trascurso de uso deja
un gran número de huecos pequeños en la memoria lo cual se le denomina fragmentación
externa.

VENTAJAS Y DESVENTAJAS DE LA PARTICION DINAMICA:

VENTAJAS:
 No existe fragmentación interna (Compactación).
 Cuando se carga un proceso en la memoria principal se le asigna exactamente tanta
memoria como necesite (No más ni menos).
 Las particiones son variables en número y longitud.

DESVENTAJAS
 El uso de la memoria es muy ineficiente, se generan muchos huecos entre las
particiones, cada vez más pequeñas, se genera la fragmentación externa. (Lo cual se
puede solucionar con el método de la compactación)
 Cada cierto tiempo se debe compactar los segmentos libres, para que estén contiguos.
El compactado toma tiempo y recursos.

Implementación en Java para Android

Paginación por Demanda
Un sistema de paginación por demanda es similar a un sistema de paginación con
intercambios. Los procesos residen en memoria secundaria (en el disco). Cuando queremos
ejecutar un proceso, lo metemos en memoria. Sin embargo, en vez de intercambiar todo el
proceso hacia la memoria, utilizamos un intercambiador perezoso. Un intercambiador
perezoso nunca reincorpora una página a memoria a menos que se necesite. Como ahora
consideramos un proceso como una secuencia de páginas, en vez de un gran espacio contiguo
de direcciones, el término intercambio es técnicamente incorrecto. Un intercambiador
manipula procesos enteros, mientras que un paginador trata con las páginas individualmente
de un proceso.
Ventajas
 A continuación se verán algunas de las ventajas de utilizar paginación por demanda:
 Al no cargar las páginas que no son utilizadas ahorra memoria para otras aplicaciones.
 Al mejorar el uso de la memoria, mejora el grado de multiprogramación.
 Carga inicial más rápida ya que solo lee del disco lo que se utilizará.
 Capacidad de hacer funcionar programas que ocupan más memoria que la poseída.
 COW (Copia en escritura): Permite utilizar las mismas páginas para dos procesos
(padre-hijo) hasta que uno de estos las modifique.

Desventajas
 La paginación por demanda puede llevarnos a las siguientes situaciones:
 Debido a la sobre-asignación podemos quedarnos sin frames libres para agregar
nuevas páginas, si esto sucede debemos recurrir a un reemplazo.
 Cada fallo de página requiere cargar a memoria una página a leer, si ocurren muchos
fallos de página el rendimiento empeora notablemente.
 Las páginas que son sacadas de los frames por intercambio pueden volver a ser
llamadas, lo que ocasiona que se lea en múltiples ocasiones la misma información.

Implementación en Java para Android

Hiperpaginación
Si el número de marcos asignados a un proceso de baja prioridad desciende por debajo del
número mínimo requerido por la arquitectura del computador, debemos suspender la
ejecución de ese proceso. Luego debemos descargar sus páginas restantes, liberando los
marcos asignados. En general, cualquier proceso que no cuente con marcos suficientes
provocará fallos de página muy frecuentemente. Si se reemplazan páginas que a su vez están
activas, estaremos sustituyendo una página que casi de inmediato se volverá a necesitar. Por
tanto, pronto vuelve a generarse otro fallo de página, ocurriendo esto una y otra vez. A esta
altísima actividad de paginación se le llama hiperpaginación (thrashing). Un sistema está en
hiperpaginación si emplea más tiempo paginando que ejecutando.

Implementación en Java para Android

De:

var A: array [1..128] of array [1..128] of integer;

 for j:= 1 to 128 do

for i:=1 to 128 do

A[i,j] := 0;

A:

Arreglo[128,128] = {1,…,128};

For(int i=0;i<128;i++){

For(int i=0;i<128;i++){

Arreglo[I,j] = 0;

Observe que la matriz está almacenada por filas. Es decir, la matriz se almacena como A[1,1] ,
A[1,2] , ..., A[2,1] , A[2,2] , ...., A[128,128] . Para páginas de 128 palabras, cada fila ocupa una
página. De esta manera, el código anterior asigna ceros a una palabra de cada página, luego
otra palabra en cada página, etc. Si el sistema operativo asigna 128 marcos al programa,
entonces ocasiona 128 x 128 = 16384 fallos de página. Si cambiamos el código a se asignan
ceros a todas las palabras de una página antes de comenzar con la siguiente, reduciendo a 128
el número de fallos de página.

Políticas de Reemplazo
Algoritmo Óptimo
Este algoritmo tiene como finalidad retirar la página que vaya a ser referenciada más tarde,
por ejemplo si hay una página A que será usada dentro de 10000 instrucciones, y una página B
que será usada dentro de 2800 instrucciones, se debería eliminar de la memoria la página A.
Como se puede deducir, para esto el sistema operativo debería ver en cuánto tiempo será
usada cada página en memoria y elegir la que está más distante. El problema de este método
es que necesita conocimiento del futuro, por lo que es imposible su implementación. Es un
algoritmo teórico. Se utiliza a los efectos comparativos con los algoritmos factibles de ser
implementados para ver cuál se aproxima más a éste.

Implementación en Java para Android

void opt() {
int i, j = 0, k, duration[], max, flag[];
reset();
show();
duration = new int[f];
flag = new int[f];
boolean found = false;

for (i = 0; i < n; i++) {

for (j = 0; j < f; j++) {
flag[j] = 0;
duration[j] = n;
}

for (k = i + 1; k < n; k++) {

for (j = 0; j < f; j++) {
if (page[k] == frames[j] && flag[j] == 0) {
duration[j] = k;
flag[j] = 1;
}
}
}

for (j = 0; j < f; j++) {

if (page[i] == frames[j]) {
found = true;
}
}
if (found == false) {
max = 0;
for (j = 0; j < f; j++) {
if (duration[j] > duration[max]) {
max = j;
}
if (frames[j] < 0) {
max = j;
break;
}
}
 frames[max] = page[i];
faults++;
}

display();
found = false;

}
System.out.println("Numero de fallas = " + faults);
System.out.println("Tasa de fallas = " + (faults * 1.0 / n));
}
Algoritmo FIFO
En este método, el sistema operativo sólo tiene que guardar en orden las páginas que fueron
cargadas, de modo que al necesitar hacer espacio pueda fácilmente elegir la primera página
cargada. Se usa una cola, al cargar una página nueva se ingresa en el último lugar. Aunque las
colas FIFO son simples e intuitivas, no se comportan de manera aceptable en la aplicación
práctica, por lo que es raro su uso en su forma simple. Uno de los problemas que presentan es
la llamada Anomalía FIFO o Anomalía de Belady. Belady encontró ejemplos en los que un
sistema con un número de marcos de páginas igual a tres tenía menos fallos de páginas que un
sistema con cuatro marcos de páginas. El problema consiste en que podemos quitar de
memoria una página de memoria muy usada, sólo porque es la más antigua.

Implementación en Java para Android

void fifo() {

int i, j, k = 0;

reset();

show();

boolean found = false;

for (i = 0; i < n; i++) {

for (j = 0; j < f; j++) {

if (page[i] == frames[j]) {

found = true;

}
 if (found == false) {

frames[k] = page[i];

if (k == f - 1) {

k = 0;

} else {

k++;

faults++;

display();

found = false;

System.out.println("Numero de fallas = " + faults);

System.out.println("Tasa de fallas = " + (faults * 1.0 / n));

void display() {

int i;

System.out.print("Marco de página " + count + " :");

for (i = 0; i < f; i++) {

if (frames[i] == -1) {

System.out.print(" ");

} else {

System.out.print(" " + frames[i]);

}
 }

System.out.print("\n");

count++;

void show() {

int i;

System.out.print("Arreglo de paginas: {");

for (i = 0; i < n; i++) {

if(i==n-1){

System.out.print(page[i]+"}");

}else{

System.out.print(page[i]+",");

System.out.print("\n\n");

Algoritmo LIFO
En informática, el término LIFO se utiliza en estructuras de datos y teoría de colas. Guarda
analogía con una pila de platos, en la que los platos van poniéndose uno sobre el otro, y si se
quiere sacar uno, se saca primero el último que se ha puesto.

Implementación en Java para Android

public class Main{

public static void main(String args[]){
(new Ventana()).setVisible(true);
}
}
import javax.swing.JOptionPane;
public class Pila{
private int numElementos;
private int elementos[];
private int indice;

public Pila(int numElementos){

this.numElementos = numElementos;
indice = -1;
elementos = new int[numElementos];
}

public boolean vacia(){

return indice == -1;
}

public boolean llena(){

return indice == numElementos - 1;
}

public void apilar(int elemento){

indice++;
try{
elementos[indice] = elemento;
}
catch(Exception ex){
JOptionPane.showMessageDialog(null, "La pila se encuentra llena");
indice--;
}
}
 public int desapilar(){
int elemento = elementos[indice];
indice--;
return elemento;
}

public int numElementos(){

return indice + 1;
}

public int[] imprimir(){

int valores[] = new int[numElementos];
for(int i = 0; i <= indice; i++)
valores[i] = elementos[i];

return valores;
}
}
Gestión del espacio de swap
El espacio de memoria de intercambio o Swap es lo que se conoce como memoria virtual. La
diferencia entre la memoria real y la virtual es que está última utiliza espacio en la unidad de
almacenamiento en lugar de un módulo de memoria. Cuando la memoria real se agota, el
sistema copia parte del contenido de esta directamente en este espacio de memoria de
intercambio a fin de poder realizar otras tareas.

Utilizar memoria virtual tiene como ventaja el proporcionar la memoria adicional necesaria
cuando la memoria real se ha agotado y se tiene que continuar un proceso. Como
consecuencia de utilizar espacio en la unidad de almacenamiento como memoria es que es
considerablemente más lenta.

¿Cuánto espacio para memoria de intercambio se debe asignar al sistema?

Menos de 1 GB RAM Doble de la cantidad total de memoria RAM.

Más de 1 GB RAM Misma cantidad del total de memoria RAM, más 2 GB.
Independientemente de la cantidad de memoria RAM disponible, el sistema podrá trabajar
normalmente con de 4 a 8 GB de memoria de intercambio, salvo que una aplicación o
programa en particular lo requiera. Los programas de instalación de la mayoría de las
distribuciones asignan hasta 4 GB si se realiza una instalación predeterminada sin personalizar
aún en sistemas con mucha memoria RAM.

Segmentación paginada
Se refiere a, como su nombre lo indica, la integración de la paginación y de la segmentación,
mediante la división de procesos en segmentos, y la división de dichos segmentos en páginas,
esta técnica requiere dos registros para hacer posible la traducción de direcciones lógicas a
direcciones físicas, el primero vendría a ser la tabla de segmentos (una por cada proceso) y el
segundo vendría a ser la tabla de páginas (una por cada segmento). Cabe destacar que esta
técnica ofrece más funciones que la paginación, pero que requiere de un Hardware más
complejo.

Protección y compartición
La segmentación se presta a la implementación de políticas de protección y compartición ya
que al no aplicarlas estas políticas suelen surgir errores Puesto que cada entrada de la tabla de
segmentos incluye la longitud, además de la dirección base, un programa no podrá acceder
por descuido a una posición de memoria principal más allá de los límites de un segmento.
Protección: Se refiere a la protección que brinda un sistema operativo con respecto a la
ejecución de procesos, en el caso de un proceso con mono programación, simplemente tiene
que evitar que un proceso que esté ejecutándose afecte el correcto funcionamiento del
sistema operativo en sí, en el caso de un sistema operativo con multiprogramación el además
de proteger su funcionamiento de un proceso en ejecución, también debe asegurarse de
proteger el funcionamiento de los procesos entre sí, lo cual por lo general se logra apoyándose
en el hardware, para así validar las direcciones que genera un programa al ser ejecutado.
Compartimiento de memoria: Se refiere a que las direcciones lógicas de dos o más procesos
diferentes compartan la misma dirección física, siendo esto posible solo si el espacio lógico de
los procesos no es contiguo, sin embargo esto genera algunos problemas como por ejemplo
que una dirección de la zona compartida deba contener una dirección diferente de la misma
zona.
Políticas de asignación de marcos de página
Se trata de la asignación del número de marcos de página va a ocupar un proceso. Estas se
clasifican en dos categorías:
 Asignación fija: Con esta estrategia se le asigna un número estático de marcos de
página a todos los procesos, por lo general esta lleva asociada una estrategia de
reemplazo global. La desventaja de esta alternativa es que la división de memoria no
satisface las necesidades dinámicas de un proceso con respecto a su tamaño.
 Asignación dinámica: Con esta estrategia el número de marcos de página asignados a
cada proceso puede cambiar con respecto a las necesidades del mismo en un
determinado instante de tiempo. Esta estrategia puede tener asociada ambas
estrategias de reemplazo, con el reemplazo local el conjunto residente del proceso
aumenta o disminuye con respecto a sus necesidades, con el reemplazo global los
procesos compiten por el uso de la memoria, quitándose páginas entre sí.