República Bolivariana de Venezuela

Ministerio del Poder Popular para la Educación Superior

Universidad Nacional Experimental de Guayana

Proyecto de carrera: Ing. Informática

Sistemas de operaciones

Profesor: Integrantes:

Damián Flores Kender Correia 24.850.467

Rosibel Vicent 20.886.714

Osner Sanchez 21.248.479

Grecia Hung 22.818.897

Carla Salges 19.728.984

Puerto Ordaz, abril de 2016

Contenido Introducción .................................................................................................................................. 4

Gestión de Memoria ...................................................................................................................... 5

Objetivos del administrador de memoria. .................................................................................. 5

Paginación simple .......................................................................................................................... 5

Paginación por demanda................................................................................................................ 6

Fallo de página ............................................................................................................................... 6

Segmentación ................................................................................................................................ 7

Objetivos ................................................................................................................................... 7

Modularidad de programas: ........................................................................................... 7

Estructuras de datos de largo variable: ........................................................................... 7

Protección: ..................................................................................................................... 7

Compartición: ................................................................................................................. 7

Enlace dinámico entre segmentos: ................................................................................. 7

Ventajas de la segmentación ...................................................................................................... 7

Segmentación / paginación ............................................................................................................ 8

Ventajas y Desventajas de Segmentación / paginación ................................................................... 9

Ventajas de la segmentación paginada: ...................................................................................... 9

Desventajas de la segmentación paginada: ................................................................................ 9

Memoria virtual ............................................................................................................................. 9

Administración de memoria virtual .............................................................................................. 10

Políticas de reemplazo ................................................................................................................. 10

Políticas de reemplazo de páginas ............................................................................................ 11

Algoritmo FIFO ............................................................................................................................. 11

Anomalía de Belady ................................................................................................................. 12

Algoritmo Óptimo ................................................................................................................... 13

Algoritmo LRU ............................................................................................................................. 13

Algoritmo de Segunda Oportunidad ............................................................................................. 15

Algoritmo NRU ............................................................................................................................. 15

Algoritmos basados en conteo ..................................................................................................... 16

Algoritmo LFU .......................................................................................................................... 16

Aging........................................................................................................................................ 17

Algoritmo MFU ........................................................................................................................ 18

Asignación de memoria ................................................................................................................ 18

Asignación estática de memoria ................................................................................................... 19

Asignación automática de memoria ............................................................................................. 19

Asignación dinámica de memoria ................................................................................................. 19

Gestión de archivos ...................................................................................................................... 19

Organización y acceso a archivos (File organizittion and access) ................................................... 20

Pilas ......................................................................................................................................... 21

Archivos Secuenciales .................................................................................................................. 21

Archivos Secuenciales indexados .............................................................................................. 22

Archivos Indexados ................................................................................................................. 22

Archivos Directos o de Dispersión ............................................................................................... 23

Directorios de Archivo .............................................................................................................. 23

Implementación de directorios ................................................................................................ 23

Operaciones que se pueden realizar con un directorio: ........................................................ 24

Designación (Naming) .............................................................................................................. 24

Sistemas de archivos. ................................................................................................................... 25

¿Qué sistemas de archivos deben utilizarse? ............................................................................ 25

Conclusión ................................................................................................................................... 26

Introducción

La memoria es uno de los recursos más valiosos que gestiona el sistema operativo.

Uno de los elementos principales que caracterizan un proceso es la memoria que utiliza. Esta

esta lógicamente separada de cualquier otro proceso del sistema. Un proceso no puede

acceder, al espacio de memoria asignado a otro proceso, lo cual es imprescindible para la

seguridad y estabilidad del sistema. El direccionamiento es una parte importante de la gestión

de memoria, puesto que influye mucho en la visión del mismo por parte de un proceso, como

el aprovechamiento del hardware y el rendimiento del sistema

Entre los principales objetivos de este documental está el conocer un poco más sobre

la gestión de memoria y todos sus componentes, así como también aprender sobre la gestión

de archivos donde básicamente su objetivo es representar y organizar la información que se

guarda en el sistema de almacenamiento.

Gestión de Memoria

La gestión de memoria o administración de memoria es el acto de gestionar

la memoria de un dispositivo informático. El proceso de asignación de memoria a los

programas que la solicitan.1 La gestión de la memoria principal de una computadora es una

tarea de suma importancia para el funcionamiento de la misma.

Los sistemas de memoria virtual separan las direcciones de memoria utilizadas por

un proceso de las direcciones físicas reales, permitiendo la separación de procesos e

incrementando la cantidad efectiva de memoria de acceso aleatorio utilizando la paginación.

La calidad de la gestión de la memoria es crucial para las prestaciones del sistema.

Entre las principales operaciones que desarrolla la administración de memoria se

encuentran la reubicación, que consiste en trasladar procesos activos dentro y fuera de la

memoria principal para maximizar la utilización del procesador; la protección, mecanismos

que protegen los procesos que se ejecutan de interferencias de otros procesos; uso compartido

de códigos y datos, con lo que el mecanismo de protección permite que ciertos procesos de

un mismo programa que comparten una tarea tengan memoria en común.

Objetivos del administrador de memoria.

Ubicar, reemplazar, cargar y descargar procesos en la memoria principal.

Proteger la memoria de accesos indeseados (accidentales o intencionados)

Permitir la compartición de zonas de memoria (indispensable para lograr la

cooperación de procesos)

Paginación simple

La paginación simple es uno de los esquemas de manejo de memoria en donde un

computador puede almacenar y recuperar datos de un dispositivo de almacenamiento

secundario para su uso en la memoria principal. En el esquema de manejo de memoria de

paginación, el sistema operativo recupera datos desde un dispositivo de almacenamiento

secundario en bloques de un mismo tamaño llamados páginas. La principal ventaja de

paginación sobre la segmentación de memoria es que permite al espacio de dirección física

de un proceso ser no contiguo. Antes de la paginación, los sistemas debían poner programas

en almacenamiento de forma contigua, lo que causaba varios problemas de almacenamiento

y fragmentación.

El método básico para implementar paginación consiste en dividir la memoria física

en bloques de tamaño fijo llamados frames (marcos) y dividir la memoria lógica en bloques

de mismo tamaño llamados pages (páginas). Cuando un proceso se va a ejecutar, sus páginas

son cargadas en cualquier marco de la memoria de almacenamiento secundario. Este está

dividido en bloques de tamaño fijo del mismo tamaño de los marcos en memoria.

Paginación por demanda La paginación por demanda introdujo la idea de cargar más una porción del programa en la

memoria para su procesamiento. Con la paginación por demanda, las tareas siguen divididas en

páginas de tamaño igual que inicialmente residen en almacenamiento secundarios.

Cuando se empieza a ejecutar la tarea, sus páginas pasan a la memoria solo conforme se

necesitan. La paginación pro demanda aprovecha el hecho que los programas se escriben de manera

secuencial, de manera que mientras una sección o modulo está en proceso, los demás están ocioso

(madnick & donovan, 1974).Una de las innovaciones de mayor importancia en la paginación por

demanda es que hizo posible el amplio uso de la memoria virtual, el esquema de paginación por

demanda permite al usuario ejecuta tareas con menos memoria principal de lo que se requería si el

sistema operativo estuviera utilizando el esquema de asignación de memoria paginada que ya se

describió.

Fallo de página

Un fallo de página es la secuencia de eventos que ocurren cuando un programa intenta acceder

a datos (o código) que está en su espacio de direcciones, pero que no está actualmente ubicado en la

RAM del sistema. El sistema operativo debe manejar los fallos de página haciendo residentes en

memoria los datos accedidos, permitiendo de esta manera que el programa continúe la operación

como que si el fallo de página nunca ocurrió.

En el caso de nuestra aplicación hipotética, el CPU primeramente presenta la dirección

deseada (12374) al MMU. Sin embargo, el MMU no tiene traducción para esta dirección. Por tanto,

interrumpe al CPU y causa que se ejecute un software, conocido como el manejador de fallos de

página. El manejador de fallos de página determina lo que se debe hacer para resolver esta falla de

página. El mismo puede:

Encontrar dónde reside la página deseada en disco y la lee (este es usualmente el caso si el

fallo de página es por una página de código)

Determina que la página deseada ya está en RAM (pero no está asignada al proceso actual) y

reconfigura el MMU para que apunte a el

Apunta a una página especial que solamente contiene ceros y asigna una nueva página para

el proceso solamente si este intenta alguna vez escribir a la página especial (esto se llama una página

de copia en escritura y es utilizada a menudo por páginas que contienen datos inicializados a cero)

Obtener la página deseada desde otro lugar (lo que se discute en detalle más adelante)

Mientras que las primeras tres acciones son relativamente sencillas, la última no lo es. Por

eso necesitamos cubrir algunos tópicos adicionales.

Segmentación

Es un esquema de manejo de memoria mediante el cual la estructura del programa

refleja su división lógica, llevándose a cabo una agrupación lógica de la información en

bloques de tamaño variable denominados segmentos. Cada uno de ellos tienen información

lógica del programa: subrutina, arreglo, etc. Luego, cada espacio de direcciones de programa

consiste de una colección de segmentos, que generalmente reflejan la división lógica del

programa.

Objetivos

Modularidad de programas: Cada rutina del programa puede ser un bloque

sujeto a cambios y recopilaciones, sin afectar por ello al resto del programa.

Estructuras de datos de largo variable: Ejm. Stack, donde cada estructura

tiene su propio tamaño y este puede variar.

Protección: Se pueden proteger los módulos del segmento contra accesos no

autorizados.

Compartición: Dos o más procesos pueden ser un mismo segmento, bajo reglas de

protección; aunque no sean propietarios de los mismos.

Enlace dinámico entre segmentos: Puede evitarse realizar todo el proceso de

enlace antes de comenzar a ejecutar un programa. Los enlaces se establecerán sólo

cuando sea necesario.

Ventajas de la segmentación

El esquema de segmentación ofrece las siguientes ventajas:

El programador puede conocer las unidades lógicas de su programa, dándoles un

tratamiento particular.

Es posible compilar módulos separados como segmentos el enlace entre los

segmentos puede suponer hasta tanto se haga una referencia entre segmentos.

Debido a que es posible separar los módulos, se hace más fácil la modificación de los

mismos. Cambios dentro de un módulo no afecta al resto de los módulos.

Es fácil el compartir segmentos.

Es posible que los segmentos crezcan dinámicamente según las necesidades del

programa en ejecución.

Existe la posibilidad de definir segmentos que aún no existan. Así, no se asignará

memoria, sino a partir del momento que sea necesario hacer usos del segmento. Un

ejemplo de esto, serían los arreglos cuya dimensión no se conoce hasta tanto no se

comienza a ejecutar el programa. En algunos casos, incluso podría retardar la

asignación de memoria hasta el momento en el cuál se referencia el arreglo u otra estructura de datos por primera vez.

Segmentación / paginación

Paginación y segmentación son técnicas diferentes, cada una de las cuales busca

brindar las ventajas enunciadas anteriormente.

Para la segmentación se necesita que estén cargadas en memoria áreas de tamaños

variables. Si se requiere cargar un segmento en memoria que antes estuvo en ella y fue

removido a memoria secundaria, se necesita encontrar una región de la memoria lo

suficientemente grande para contenerlo, lo cual no es siempre factible. En cambio recargar

una página implica sólo encontrar un marco de página disponible.

A nivel de paginación, si quiere referenciar en forma cíclica n páginas, estas deberán

ser cargadas una a una, generándose varias interrupciones por fallas de páginas. Bajo

segmentación, esta página podría conformar un sólo segmento, ocurriendo una sola

interrupción por falla de segmento. No obstante, si bajo segmentación se desea acceder un

área muy pequeña dentro de un segmento muy grande, este deberá cargarse completamente

en memoria, desperdiciándose memoria. Bajo paginación sólo se cargará la página que

contiene los ítems referenciados.

Puede hacerse una combinación de segmentación y paginación para obtener las ventajas de

ambas. En lugar de tratar un segmento como una unidad contigua, éste puede dividirse en

páginas. Cada segmento puede ser descrito por su propia tabla de páginas.

Las direcciones tienen tres componentes: (s, p, d), donde la primera indica el número

del segmento, la segunda el número de la página dentro del segmento y la tercera el

desplazamiento dentro de la página. Se deberán usar varias tablas:

SMT (tabla de mapas de segmentos): Una para cada proceso. En cada entrada de la

SMT se almacena la información descrita bajo segmentación pura, pero en el campo

de dirección se indicara la dirección de la PMT (tabla de mapas de páginas) que

describe a las diferentes páginas de cada segmento.

PMT (tabla de mapas de páginas): Una por segmento; cada entrada de la PMT

describe una página de un segmento, en la forma que se presentó la página pura.

TBM (tabla de bloques de memoria): Para controlar asignación de páginas por parte

del sistema operativo.

JT (tabla de Jobs): Que contiene las direcciones de comienzo de cada una de las SMT

de los procesos que se ejecutan en memoria.

Ventajas y Desventajas de Segmentación / paginación

Ventajas de la segmentación paginada:

El esquema de segmentación paginada tiene todas las ventajas de la segmentación y

la paginación:

Debido a que los espacios de memorias son segmentados, se garantiza la facilidad de

implantar la compartición y enlace.

Como los espacios de memoria son paginados, se simplifican las estrategias de

almacenamiento.

Se elimina el problema de la fragmentación externa y la necesidad de compactación.

Desventajas de la segmentación paginada:

Los tres componentes de la dirección y el proceso de formación de direcciones hacen

que se incremente el costo de su implantación. El costo es mayor que en el caso de

segmentación pura o paginación pura.

Se hace necesario mantener un número mayor de tablas en memoria, lo que implica

un mayor costo de almacenamiento.

Sigue existiendo el problema de fragmentación interna de todas -o casi todas- las

páginas finales de cada uno de los segmentos. Bajo paginación pura se desperdicia

sólo la última página asignada, mientras que bajo segmentación paginada el

desperdicio puede ocurrir en todos los segmentos asignados.

Memoria virtual Es una técnica de gerencia de memoria, usada por un sistema operativo, donde

memoria no contigua es presentada al software como memoria contigua. Esta memoria

contigua es llamada VAS (virtual address space) o espacio de dirección virtual.

En términos técnicos, la memoria virtual permite a un software correr en un espacio

de memoria que no necesariamente pertenece a la memoria física de una computadora. Para

esto se debe emular un CPU que trate a toda la memoria (virtual y principal) como un bloque

igual, y determinar cuándo se requiere de una memoria u otra.

Los programas corriendo en una computadora utilizan esta memoria como si se tratase

de completamente de la memoria RAM. La memoria virtual se utiliza cuando la memoria

principal (RAM) no alcanza, utilizando espacio en disco duro para extenderla. Generalmente

el archivo utilizado para guardar la memoria virtual es llamado "archivo de paginación".

Administración de memoria virtual Es un método mediante el cual, un sistema operativo simula tener más memoria

principal que la que existe físicamente. Para implementar la memoria virtual se utiliza un

medio de almacenamiento secundario de alta velocidad de acceso, generalmente en disco

duro de la máquina. Un sistema de memoria virtual se implementa utilizando paginación

como método de administración de memoria básica y algún mecanismo de intercambio (para

descargar páginas de la memoria principal hacia el disco duro y para cargar esas páginas de

nuevo a la memoria).

La memoria virtual es una técnica para proporcionar la simulación de un espacio de

memoria mucho mayor que la memoria física de una máquina. Esta “ilusión” permite que los

programas se hagan sin tener en cuenta el tamaño exacto de la memoria física. La ilusión de

la memoria virtual esta soportada por el mecanismo de traducción de memoria, junto con una

gran cantidad de almacenamiento rápido en disco duro. Así en cualquier momento el espacio

de direcciones virtual hace un seguimiento de tal forma que una pequeña parte de él, está en

memoria real y el resto almacenado en el disco, y puede ser referenciado fácilmente.

Políticas de reemplazo En la gestión de la memoria virtual, toma gran importancia lo que se denomina

política de reemplazo, que es la que decide que página de las presentes en memoria es la que

va a ser sustituida I En esta política se encuentran involucrados varios conceptos, que aunque

distintos, están fuertemente interrelacionados

A.- La cantidad de memoria (número de marcos) física asignada a cada proceso en el sistema

B.-Si el conjunto de páginas a tener en cuenta a la hora de ser reemplazadas incluye solamente

a las del proceso que ha provocado el fallo de página o a todas las residentes en memoria (de

los distintos procesos)

C.-De entre las páginas consideradas, cual es la que debe seleccionarse para ser reemplazada

El punto A plantea lo que se conoce como el problema de la asignación de marcos.

Las soluciones a este problema pasan por intentar asignar a cada proceso un número de

marcos variable que se adapta a la localidad del proceso (es decir a sus necesidades de

memoria en las distintas fases de su ejecución)

El punto B plantea lo que se conoce como reemplazo local o reemplazo global

El punto C es lo que es normalmente referido como política de reemplazo o

algoritmos de reemplazo de páginas

Políticas de reemplazo de páginas Los criterios a seguir para implementar un algoritmo de reemplazo de páginas son

fundamentalmente dos:

• Minimizar el número de fallos de página, como se ha razonado en el apartado anterior.

Explotar la localidad temporal de los programas será fundamental.

• Sencillez de implementación. Un algoritmo complejo, como veremos, puede requerir

intervención adicional en los accesos a memoria, lo que implicará o pérdida de rendimiento,

o un hardware costoso, lo que a su vez redundará probablemente en pérdida de rendimiento.

Si incrementamos la multiprogramación, estamos sobrecargando nuestra memoria o sobre

asignado, lo que puede eventualmente que nos quedemos falta de marcos

o frames disponibles para cargar las páginas. En estos casos, la solución más común es la

sustitución de páginas. En este sentido el procedimiento de reemplazo es:

1. Encontrar la ubicación en disco de la página deseada.

1. Buscar un marco libre:

2. si hay un frame o marco libre, utilizarlo.

3. De lo contrario, utilizar un Algoritmo de Reemplazo de Página con el fin de

seleccionar un marco víctima.

4. Escribir la página víctima en disco; ajustar las tablas de marcos y páginas.

2. Traer la página al nuevo frame libre. Actualizar la tabla de página.

3. Reiniciar el proceso de usuario.

Para implementar cualquier algoritmo que realice la elección del marco víctima (y por

supuesto de la página que será enviada a memoria secundaria) se tienen ciertas

consideraciones:

Para referirnos a una página se habla de su número de página, por ejemplo página

1, p1 o simplemente 1.

Por otra parte, siempre que se haya referenciado a una página e inmediatamente se

referencie de nuevo, no hay fallo de página.

Se debe conocer el número de frames disponibles. A mayor cantidad de marcos, menos

fallas de página.

Algoritmo FIFO

El algoritmo FIFO reemplaza las páginas de la forma que el primero que entra es el

primero que sale. Asocia a cada página el instante en el que se trajo a la memoria, así cuando

se tenga que reemplazar una página, se elige la más antigua.

En la imagen vemos 19 páginas entrando en una memoria de tres frames. El resultado

obtenido fueron 15 fallos de página.

A pesar de que es un algoritmo fácil de comprender y programar, su rendimiento no siempre

es bueno. Un ejemplo claro es cuando la página puede contener una variable cuyo valor

inicial se asignó hace tiempo pero que se utiliza constantemente por lo que puede prescindir

de páginas que accede con frecuencia.

Anomalía de Belady

Ésta anomalía fue descubierta y demostrada en 1969 por el científico de la

computación Laszlo Belady y consiste en que al aumentar el número de marcos en la

memoria física, es posible tener más fallos de página. En la siguiente imagen vemos la

diferencia, con el mismo orden de páginas, con tres y cuatro marcos en la memoria.

Notamos que con tres marcos solo tiene nueve fallos y que con cuatro marcos tiene diez.

Aunque el ejemplo solo trata con pocos marcos, es sorprendente el comportamiento que se

podría ver con muchos más. Antes de éste descubrimiento se creía que FIFO era el mejor

algoritmo para el manejo de páginas, pero se tuvo que buscar alternativas a causa de esta

sorprendente anomalía. Actualmente esta anomalía es más bien utilizada como una simple

curiosidad que demuestra que los sistemas pueden tener a veces comportamientos

inesperados.

Algoritmo Óptimo

El Algoritmo Óptimo, también conocido como OPT se originó luego del

descubrimiento de la Anomalía de Belady en la búsqueda de un algoritmo mucho más

óptimo. El algoritmo elige la página de la memoria que vaya a ser referenciada más tarde, las

páginas se rotulan con el número de instrucciones que se ejecutarán antes de que se haga la

primera referencia a ella y, cuando se presenta un fallo de página, se reemplaza la que más

instrucciones falten para referenciarla para así ir aplazando lo más que se pueda los fallos de

página. Por desgracia, este algoritmo es irrealizable, ya que no hay una forma de predecir

qué páginas referenciará un proceso en el futuro.

En la imagen vemos la cadena de referencias para una página y cómo se usa la

memoria (en este caso de 3 frames o marcos). Se comienza tal como el algoritmo

FIFO ingresando las páginas a la memoria; el primer caso de memoria llena sucede cuando

entra la página 1 y quiere entrar la página 2. La víctima debe ser decidida de tal forma que la

página no sea referenciada más o sea referenciada mucho después. En este caso la página 5

no es referenciada más, por lo que es reemplazada por la página 2. El algoritmo genera

finalmente 7 fallos de página, versus por ejemplo los 10 fallos que FIFO genera.

Como es un algoritmo que no se puede poner en práctica, se ejecuta en simuladores

en los cuales se demuestra que es un muy buen algoritmo que reduce mucho las fallas y que

se encuentra entre los algoritmos con mejor eficiencia por lo que es el algoritmo utilizado

para estudios comparativos.

Algoritmo LRU

La estrategia consiste en llevar a disco la página que ha permanecido por más tiempo

sin ser accesada. El fundamento de esta estrategia es que estadísticamente se observa que

mientras más tiempo permanece una página sin ser accesada, menos probable es que se

accese en el futuro inmediato. Desventaja: El alto costo de implementación en cuanto a los

recursos. Pese a ser un buen algoritmo en teoría, su implementación no lo es tanto. Esta puede

ser llevada a cabo por una lista enlazada con todas las páginas ordenadas, pero al momento

de ser referenciada una página esta tiene que cambiar de lugar, lo cual involucra un alto costo

asociado. Otro mecanismo es llevar un contador por medio de hardware, el cual es

incrementado cada vez que la página es accedida.

De acuerdo con el string entregado, podemos apreciar que cuando se llega al número

3 en el string, el numero al que reemplaza es el 8, ya que fue el último en ser accedido, previo

a él está el 2 y previo a el 1, de esta manera se continua completando el marco hasta el término

del string++.

Implementación con Contador. Es asociada a cada tabla de página un campo de tiempo y

el CPU lleva un contador o reloj el cual se incrementa en cada referencia a memoria que se

realiza. Al momento de realizar el llamado a una página, este contador es copiado en el campo

de tiempo que está en su tabla correspondiente. Temas a tener en cuenta:

siempre se tiene la última referencia a cada página.

Esta implementación hace necesaria la búsqueda en las tablas de página de la página

menos utilizada.

Se hacen necesario incorporar grandes contadores en el CPU, y tener un cuidado con

el probable desbordamiento que pudiera tener.

Implementación con Pila. Se mantiene una pila, con los números en una lista doblemente

enlazada. Con esta modalidad ya no se hace necesario realizar una búsqueda, como lo es con

el contador, pero se tiene que realizar el cambio en los punteros de la lista. Para ir

estructurando la pila, cada página referenciada se va colocando al tope de ésta.

De acuerdo a la figura 3, se presenta una representación de cada cambio en la pila

siendo la posición de la izquierda el tope de ésta.

Algoritmo de Segunda Oportunidad

Este es un algoritmo que deriva del algoritmo FIFO. El Algoritmo de Segunda

Oportunidad evita deshacerse de una página de uso frecuente, hace uso del bit R

inspeccionándolo de tal forma que, si es 0, la página es antigua y no utilizada, por lo que, en

caso de fallo de página, es reemplazada de manera inmediata. En caso de que dicho bit sea

1, es cambiado a cero y se cambia al final de la lista de páginas como si hubiera llegado en

ese momento a la memoria. Luego continua la búsqueda siguiendo lo que avanza en la lista.

En la imagen vemos como se ejecuta el algoritmo, las páginas fueron identificadas, a

modo de este ejemplo, con letras de la A a la H según el orden de llegada y mostradas en una

lista enlazada. A es la primera página cargada y la que con menos frecuencia se ocupa

mientras que H es la página más reciente cargada. Supongamos que ocurre un fallo de página.

La página más antigua en nuestro ejemplo es A, si éste tiene el bit R a cero, se saca

de la memoria. Por el contrario, si R vale 1, A se coloca al final de la lista, poniéndose a cero

el bit R. Dejando como búsqueda adecuada de página con B.

Lo principal de este algoritmo de segunda oportunidad es ir viendo las páginas

antiguas sin referencias, si es que todas tienen más de una referencia entonces se aplica

normalmente el algoritmo FIFO.

Algoritmo NRU

El algoritmo Not Recently Used (NRU), No utilizado recientemente, Enhanced second-

chance o Segunda oportunidad mejorado[1] es uno de los esquemas que intentan aproximarse

al algoritmo LRU. Específicamente es una modificación del algoritmo de segunda

oportunidad, el cual considera el bit de referencia R y el bit de modificación M como un par

ordenado (R, M) respectivamente. Existen cuatro clases de páginas descritas por este par que

se mencionan a continuación.

Clase 0 (0, 0) La página no ha sido ni usada ni modificada recientemente. Ésta página es

la mejor candidata a ser reemplazada.

Clase 1 (0, 1) La página no ha sido recientemente usada pero sí fue modificada. No es

tan buena como la primera opción, pues la página deberá ser escrita antes de ser

reemplazada.

Clase 2 (1, 0) La página fue recientemente usada y no modificada. El argumento de este

algoritmo es que ésta página probablemente vuelva a ser usada.

Clase 3 (1, 1) La página fue usada y modificada. Considerando las descripciones

anteriores se aprecia que la página podría volver a ser usada y además escrita al disco.

Cuando una página se debe reemplazar, se usa la misma lógica que el algoritmo de reloj,

pero en vez de revisar si el bit de referencia de la página es un 1, se examina la clase a la que

pertenece la víctima. Dependiendo de la implementación la página (aleatoria o la primera

que se encuentre) con la clase más pequeña es reemplazada. Para encontrarla es posible que

se deba revisar la cola circular varias veces antes de encontrar la víctima.

Una duda interesante que surge es cómo puede haber páginas modificadas pero no usadas

(clase 1). Esto sucede cuando páginas de clase 3, luego de una interrupción de reloj el bit de

referencia es puesto en 0 pero los cambios aún deben ser escritos en disco por lo que el bit

de modificación sigue en 1.

La diferencia más grande entre éste algoritmo y el de segunda oportunidad es que en este

se da preferencia a aquellas páginas que han sido modificadas, de tal forma de reducir el I/O

de disco asociado a éstas. Es un algoritmo eficiente de implementar con rendimiento bueno

mas no óptimo, además de que se debe hacer una búsqueda a través de cada par de bits.

Algoritmos basados en conteo

En este caso la idea es mantener un contador del número de referencias que se han

hecho a cada página. Acá se enmarcan dos algoritmos que definen a estos contadores: el LFU

centrado en reemplazar las páginas menos usadas y el MFU, que reemplaza las páginas más

usadas.

Algoritmo LFU

El algoritmo Least frequently used (LFU) o Menos frecuentemente utilizado pide que

la página con el menor contador sea reemplazada. Esto se justifica en que una página usada

con mucha frecuencia tendrá un contador más grande. Un problema de este esquema es

cuando una página es usada intensamente durante la fase inicial de un proceso y luego no

vuelve a ser usada, lo cual genera un contador mucho mayor y la página permanece en

memoria sin poder ser sacada. Una solución a lo anterior es realizar un corrimiento de 1 bit

del contador a intervalos regulares de tiempo de tal forma de nivelar los contadores de forma

exponencial y así no habrán páginas estancadas.

El ejemplo en la imagen muestra una cadena de bits de referencias. Las invocaciones

de las páginas figuran con sus respectivos frames y cada uno tiene un contador que indica la

cantidad de veces que se ha llamado a una página. Así, páginas cuya frecuencia es la mas

baja son reemplazadas por otras, (En este caso la página #3 de frecuencia 1 es reemplazada

por la página #28). Finalmente se observa el balance entre páginas traídas y páginas retiradas.

Aging

Este algoritmo desciende del NFU, mejorándolo al realizar un corrimiento de 1 bit a

la derecha antes de aumentar el contador de uso en 1 bit a la izquierda en su forma binaria.

Esto provoca que las páginas cuyas referencias son más actuales tengan más importancia que

aquellas que fueron referidas hace tiempo, asegurando que páginas usadas recientemente

pero no frecuentemente tengan mayor prioridad frente a páginas usadas hace tiempo pero con

mayor referencia. Así la página con el menor contador es elegida para ser reemplazada.

En el ejemplo de la imagen se presentan dos páginas con sus bits de referencia y

contadores (en formato binario). La página 1 tiene los bits de referencia 1,1,1,0,0,0 que

indican una alta frecuencia de uso pero estos no son actuales; la página 2 tiene bits 0,0,0,0,1,1

lo que indica poca frecuencia de uso pero muy actual. Siguiendo el algoritmo, se toma el

contador en binario y se efectúa un corrimiento de 1 bit a la derecha y se le adjunta el bit de

referencia a la izquierda, todo esto por cada tick de reloj. Finalmente el contador de la página

1 es 0001110, versus el de la página 2 que es 11000000, reflejando que la página 1 tiene

menor importancia que la página 2 pues esta última es más reciente, por lo que la página 1

eventualmente debe ser reemplazada.

Algoritmo MFU

El algoritmo Most frequently used (MFU) o Mas frecuentemente utilizado, que al

contrario del LFU está basado en el argumento de que la página con el menor contador fue

probablemente traída hace poco y aún no ha sido usada, por lo que la página con el mayor

contador será la «víctima» en este caso.

El ejemplo en la imagen presenta los frames y contadores para una cadena de

referencias dada. En caso de que dos o más contadores fueran iguales, se reemplaza la página

que haya llegado primero. En el ejemplo ocurren 10 reemplazos de página considerando

llenar frames vacíos y reemplazos efectivos de página.

Ninguno de estos algoritmos es utilizado comúnmente. La implementación que requieren es

cara, y no se aproximan lo suficiente al algoritmo óptimo.

Asignación de memoria La asignación de memoria consiste en el proceso de asignar memoria para propósitos

específicos, ya sea en tiempo de compilación o de ejecución. Si es en tiempo de compilación

es estática, si es en tiempo de ejecución es dinámica y si son variables locales a un grupo de

sentencias se denomina automática.

Asignación estática de memoria La Asignación estática de memoria consiste en el proceso de asignar

memoria en tiempo de compilación antes de que el programa asociado sea

ejecutado, a diferencia de la asignación dinámica o la automática donde la

memoria se asigna a medida que se necesita en tiempo de ejecución

Asignación automática de memoria Las variables automáticas son variables locales a un bloque de sentencias (subrutina,

función o procedimiento). Pueden ser asignadas automáticamente en la pila de datos cuando

se entra en el bloque de código. Cuando se sale del bloque, las variables son automáticamente

desasignadas.3 Las variables automáticas tendrán un valor sin definir cuando son declaradas,

por tanto es buena práctica de programación inicializarlas con un valor válido antes de

usarlas.

Asignación dinámica de memoria Asignación dinámica de la memoria es la asignación de almacenamiento de memoria

para utilización por parte de un programa de computador durante el tiempo de ejecución de

ese programa. Es una manera de distribuir la propiedad de recursos de memoria limitada

entre muchas piezas de código y datos. Un objeto asignado dinámicamente permanece

asignado hasta que es desasignado explícitamente, o por el programador o por un recolector

de basura; esto es notablemente diferente de la asignación automática de memoria y de la

asignación estática de memoria (la de las variables estáticas). Se dice que tal objeto tiene

tiempo de vida dinámico

Gestión de archivos Un sistema de gestión de archivos es el software que proporciona a los usuarios y

aplicaciones servicios para el uso, acceso y control de accesos, tanto de archivos como a

directorios. Esta encargada de gestionar los datos que residen en almacenamiento secundario.

Los datos lógicamente relacionados ubicados en almacenamiento secundario se

organizan generalmente en colecciones caracterizadas. El sistema de gestión de archivos

debe ocultar a los usuarios todos los aspectos específicos de dispositivos necesarios para la

manipulación de archivos y proporcionarles una abstracción de un espacio simple y uniforme

de archivos con nombre.

Un archivo puede aparecer ante los usuarios como un array lineal de caracteres o de

tipo registro, otra abstracción lógica pero no muy implementada consiste en considerar los

archivos como extensión del espacio de direcciones virtuales. La idea es liberar a los usuarios

de tener que trasladar explícitamente datos entre memoria principal y almacenamiento

secundario y tener que manejar los datos de forma diferente dependiendo de donde están

físicamente almacenado.

Las responsabilidades mas comunes del sistema de gestión de archivos son:

Traducción de las peticiones de acceso desde el espacio lógico de direcciones de

archivo físico.

Trasmisión de elementos de archivo entre almacenamiento principal y secundario.

Gestión del almacenamiento secundario, por ejemplo: llevar control del estado,

asignación y designación del espacio.

Soporte para protección y compartición de archivos, recuperación y posiblemente

restauración de archivos después de caídas del sistema.

El subsistema de gestión e archivos puede implementarse como una o más capas del

SO. Sus servicios básicos, tales como la transmisión de bloques de datos, son necesarios para

soportar la gestión de memoria virtual y el intercambio (swapping), estas funciones se sitúan

entre el núcleo y el gestor de memoria, otros servicios e archivos tales como la gestión de

directorios la traducción de peticiones de acceso lógico a físico, los proporciona el sistema

de archivos (capa 4).

Los archivos de una instalación informática pueden ser almacenados en una variedad

de dispositivos físicos como unidades de disco, cintas magnéticas o memorias de

semiconductores.

Organización y acceso a archivos (File organizittion and access)

En esta parte vamos a usar el término organización de archivos para referirnos a la

estructura lógica de los registros determinada por la manera en que se accede a ellos. La

organización física del archivo en almacenamiento secundario depende de la estrategia de

agrupación y de la estrategia de asignación de archivos.

Para seleccionar una organización de archivos hay diversos criterios que son importantes:

1. Acceso Rápido para recuperar la información

2. Fácil actualización

3. Economia de almacenamiento

4. Mantenimiento simple.

5. Fiabilidad para asegurar la confianza de los datos.

La prioridad relativa de estos criterios va a depender de las aplicaciones que va a usar el

archivo.

El número de alternativas de organización de archivos que se han implementado o

propuesto es inmanejable,incluso para un libro dedicado a los sistemas de archivos.

La mayor parte de las estructuras empleadas en los sistemas reales se encuadran en una de

estas categorias o puede implementarse como una combinación de estas:

1. Pilas (The pile)

2. Archivos secuenciales (sequential file)

3. Archivos Secuenciales indexados. (indexed sequential file)

4. Archivos indexados.(indexed file)

5. Archivos directos o de dispersión (direct, or hashed, file).

Pilas

La forma menos complicada de organización de archivos puede denominarse la pila.

Los datos se recolectan en el orden en que llegan. Cada registro consiste en una ráfaga de

datos. El propósito de la pila es simplemente acumular la masa de datos y guardarlo. Como

no hay estructura para el archivo de la pila. el acceso a registro es por búsqueda exhaustiva.

Si se quiere todos los registros que contienen un campo particular o que tienen un valor

determinado para ese campo, debe buscarse en el archivo entero.

Los archivos de pilas se aplican cuando los datos se recogen y almacenan antes de

procesarlos o cuando no son fáciles de organizar. Este tipo de archivo usa bien el espacio

cuando los datos almacenados varían en tamaño y en estructuras. Este tipo de archivos no se

adapta a la mayoría de las aplicaciones.

Archivos Secuenciales

La forma más común de estructura de archivo es el archivo secuencial. En este tipo

de archivo, un formato fijo es usado para los registros. Todos los registros tienen el mismo

tamaño, constan del mismo número de campos de tamaño fijo en un orden particular. Como

se conocen la longitud y la posición de cada campo, solamente los valores de los campos se

necesitan almacenarse; el nombre del campo y longitud de cada campo son atributos

de la estructura de archivos.

Un campo particular, generalmente el primero de cada registro se conoce como el

campo clave. El campo clave identifica unívocamente al registro. así, los valores de la clave

para registros diferentes son siempre diferentes.

Los archivos secuenciales son típicamente utilizados en aplicaciones de proceso de

lotes Y son óptimos para dichas aplicaciones si se procesan todos los registros. La

organización secuencias de archivos es la única que es fácil de usar tanto en disco como en

cinta.

Para las aplicaciones interactivas que incluyen peticione s o actualizaciones de

registros individuales, los archivos secuenciales ofrecen un rendimiento pobre.

Normalmente un archivo secuencial se almacena en bloques, en un orden secuencial

simple de los registros. La organización física del archivo en una cinta o disco se corresponde

exactamente con la ubicación lógica del archivo. En este caso, el procedimiento para ubicar

los nuevos registros en un archivo de pila separado, llamado archivo de registro (log file) o

archivo de transacciones. Periódicamente, se realiza una actualización por lotes que mezcla

el archivo de registro con el archivo maestro para producir un nuevo archivo en secuencia

correcta de claves.

Archivos Secuenciales indexados

Un método popular para superar las desventajas de los archivos secuenciales es el del

archivo secuencias indexado. El archivo secuencial indexado mantiene las caracteristicas

básicas de los archivos secuenciales: los registros están organizados en una secuencia basada

en un campo. Dos características se añaden: un índice del archivo para soportar los accesos

aleatorios y un archivo de desbordamiento ( overflow ). El indice provee una capacidad de

búsqueda para llegar rapidamente a las proximidades de un registro deseado. El archivo de

desbordamiento (overflow) es similar al archivo de registro usado en un archivo secuencial,

pero esta intregrado de forma que los registros del archivo de desbordamiento se ubican en

la dirección de un puntero desde si registro precedente. En la estructura secuencial indexada

mas simple, se usa un solo nivel de indexacion. El indice, en este caso, es un archivo

secuencial simple. Cada registro del archivo indice tiene dos campos: un campo clave, que

es el mismo que el campo clave del archivo principal y un puntero al archivo principal. Para

encontrar un campo especifico se busca en el indice hasta encontrar el valor mayor de la

clave que es igual o precede al valor deseado de la clave. La busqueda continua en el archivo

principal a partir de la posición indicada por el puntero.

Archivos Indexados

Los archivos secuenciales indexados retienen la limitación del archivo secuencial:

la eficacia en el procesamiento se limita al basado en un único campo del archivo. Cuando

es necesario buscar un registro basándose en algún otro atributo distinto del campo clave

ambas formas de archivo secuencial no son adecuadas. En algunas aplicaciones esta

flexibilidad es deseable.

Para alcanzar esta flexibilidad, se necesita una estructura que utilice múltiples índices,

uno para cada tipo de campo que pueda ser objeto de la búsqueda.

Se suelen utilizar dos tipos de índices. Uno índice exhaustivo contiene una entrada para cada

registro del archivo principal. Otro índice parcial contendrá entradas a los registros donde

este el campo de interés.

Con registros de longitud variable, algunos registros no contendrán todos los campos.

Los archivos indexados son muy utilizados en aplicaciones donde es crítica la

oportunidad de la información y donde los datos son rara vez procesados de forma

exhaustiva.

Archivos Directos o de Dispersión

Los archivos directos explotan la capacidad de los discos para acceder directamente

a cualquier bloque de dirección conocida. Como en los archivos secuenciales y secuenciales

indexados, se requiere un campo clave en cada registro. Sin embargo, aquí no hay concepto

de ordenamiento secuencial.

Directorios de Archivo

Asociado con algunos sistemas de gestión de archivos o cualquier colección de

archivos suele haber un directorio de archivos. El directorio contiene información acerca de

los archivos, incluyendo atributos, localización y propietario. Mucha de esta información,

especialmente la concernida con el almacenamiento es gestionada por el sistema operativo.

El directorio es propiamente un archivo, poseído por el sistema y, accesible a traces de

diversas rutinas de gestión de archivos. Aunque alguna información en los directorios está

disponible para los usuarios y aplicaciones, en general, la información se proporciona

indirectamente a través de rutinas del sistema. De este modo los usuarios pueden acceder

directamente al directorio, incluso en modo de solo lectura.

Implementación de directorios

La manera en que la información se almacena difiere mucho en los diferentes

sistemas. Parte de la información puede almacenarse en un registro de cabecera asociado al

archivo, esto reduce el espacio necesario para el directorio, haciendo más fácil mantener todo

el directorio.

La forma más fácil de estructuración de un directorio es una lista de entradas, unas

para cada archivo. Esta estructura puede representarse con un simple archivo secuencial, con

el nombre del archivo haciendo las veces de clave.

Operaciones que se pueden realizar con un directorio:

1. Buscar: Cuando alguien referencia el archivo, debe buscarse en el directorio la entrada

correspondiente al archivo.

2. Crear archivo: Al crear un nuevo archivo. debe añadirse una entrada al directorio.

3. Borrar archivo: Al borrar un archivo, debe eliminarse una entrada al directorio.

4. Listar directorio: Puede solicitarse todo el directorio o una parte.

Una simple lista no se ajusta bien a estas operaciones. Si el directorio es una simple

lista secuencias, no ofrecerá ayuda en la organización de los archivos y obligara al usuario a

tener cuidado de no usar el mismo nombre para dos tipos diferentes de archivos. Para resolver

este problema se puede acudir a un esquema de dos niveles donde hay un directorio para cada

usuario.

Un método más potente y flexible es el directorio jerárquico o estructurado en árbol.

Existe un directorio maestro que contiene un número determinado de directorios de usuario.

Cada uno de estos directorios puede tener a su vez subdirectorios y archivos como entradas.

Esto se cumple en cualquier nivel.

Para organizar cada directorio y subdirectorio. El método más simple es almacenar cada

directorio como un archivo secuencial. Cuando los directorios contengan un número muy

grande de entradas, tal organización puede conducir a tiempos de, búsqueda

innecesariamente grandes. En ese caso se prefiere una estructura de dispersión.

Designación (Naming)

Los usuarios necesitan poder referirse a un archivo mediante un nombre simbólico.

Cada archivo del sistema debe tener un nombre único para que las referencias al archivo no

sean ambiguas. Por otro lado, es una carga inaceptable para los usuarios el proporcionar

nombres únicos.

El uso de directorios estructurados en arbol minimiza la dificultad de asignar nombres

unicos. Cualquier archivo del sistema puede ser localizado siguiendo un camino desde, el

directorio raíz o maestro. Descendiendo por varias ramas hasta que se alcance el archivo. La

serie de nombres de directorios, terminados con el propio nombre del archivo, constituye el

propio nombre del camino del archivo.

Cada usuario interactivo o proceso tiene asociado un directorio actual, conocido a

menudo como directorio de trabajo.

Sistemas de archivos.

Un sistema de archivos son los métodos y estructuras de datos que un sistema

operativo utiliza para seguir la pista de los archivos de un disco o partición; es decir, es la

manera en la que se organizan los archivos en el disco. El término también es utilizado para

referirse a una partición o disco que se está utilizando para almacenamiento, o el tipo del

sistema de archivos que utiliza. Así uno puede decir “tengo dos sistemas de archivo”

refiriéndose a que tiene dos particiones en las que almacenar archivos, o que uno utiliza el

sistema de “archivos extendido”, refiriéndose al tipo del sistema de archivos.

La diferencia entre un disco o partición y el sistema de archivos que contiene es

importante. Unos pocos programas (incluyendo, razonablemente, aquellos que crean

sistemas de archivos) trabajan directamente en los sectores crudos del disco o partición; si

hay un archivo de sistema existente allí será destruido o corrompido severamente. La mayoría

de programas trabajan sobre un sistema de archivos, y por lo tanto no utilizarán una partición

que no contenga uno (o que contenga uno del tipo equivocado).

¿Qué sistemas de archivos deben utilizarse?

Existe generalmente poca ventaja en utilizar muchos sistemas de archivos distintos.

Actualmente, el más popular sistema de archivos es ext3, debido a que es un sistema de

archivos con bitácora. Hoy en día es la opción más inteligente. Reiserfs es otra elección

popular porque también posee bitácora. Dependiendo de la sobrecarga del listado de

estructuras, velocidad, fiabilidad (percibible), compatibilidad, y otras varias razones, puede

ser aconsejable utilizar otro sistema de archivos. Estas necesidades deben decidirse en base

a cada caso.

Un sistema de archivos que utiliza bitácora se denomina sistema de archivos con

bitácora. Un sistema de archivos con bitácora mantiene un diario, la bitácora, de lo que ha

ocurrido en el sistema de archivos. Cuando sobreviene una caída del sistema, o su hijo de dos

años pulsa el botón de apagado como el mío adora hacer, un sistema de archivos con bitácora

se diseña para utilizar los diarios del sistema de archivos para recuperar datos perdidos o no

guardados. Esto reduce la pérdida de datos y se convertirá en una característica estándar en

los sistemas de archivos de Linux. De cualquier modo, no extraiga una falsa sensación de

seguridad de esto. Como todo en esta vida, puede haber errores. Procure siempre guardar sus

datos para prevenir emergencias.

Conclusión

La gestión de Memoria es el proceso que dinámicamente el sistema operativo realiza

para subdividir la Memoria, esta cumple un papel muy importante para la realización de

procesos y aplicaciones que realiza el sistema operativo, por lo tanto, la misma debe proteger

las zonas asignadas a cada proceso de accesos por parte de terceros, para evitar cualquier

clase de problema incluso que se cuelgue el sistema.

Si hablamos de memoria virtual tenemos que ella se adapta más que todo a los tipos

de procesos que se realizan en cada sistema operativo de alguna manera siendo más efectivo

cada uno en el manejo de procesos especializados que tiene más sin embargo sin poder lograr

un objetivo común que es la velocidad en cuanto a la velocidad de las aplicaciones por

completo. El uso de la memoria virtual ayuda a aprovechar mejor la memoria. Por eso

muchos sistemas operativos utilizan este esquema para la administración de memoria.

Cada vez se mejora más la forma en que la memoria virtual es manejada en los

sistemas operativos y no parece que pueda ser reemplazada en un futuro cercano. Sino todo

lo contrario.