Upload
kender-correia
View
16
Download
3
Embed Size (px)
DESCRIPTION
Gestión de archivos en sistemas operativos
Citation preview
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.