ADMINISTRACIÓN DE LA MEMORIA Requerimientos:

• Relocalización: Poder mover un programa/proceso dentro de la memoria, y que el proceso pueda seguir funcionando. (p.e.: cuando se lleva a disco por falta de memoria, y luego que se desocupa parte de ésta se trae nuevamente pero a un área distinta de donde estaba inicialmente).

• Protección: Impedir que un proceso pueda tener acceso y/o modificar áreas de la memoria asignada a otro proceso. Se implementa con los registros base y límite. Cada vez que el procesador accede a la memoria, revisa que el valor a referenciar (dirección que está en el registro MAR, registro de dirección de memoria) esté dentro del rango permitido. Registro base <= MAR <= Registro Límite.

• Memoria Compartida (Memory Sharing): Área de la memoria que pueden acceder más de un proceso (en contra a lo visto anteriormente en protección de la memoria). Permite que dos o más procesos se puedan comunicar o intercambiar datos. Si bien pueden acceder varios procesos, algunas veces se limita que acción pueden realizar (unos sólo escriben, otros sólo leen, unos leen y escriben, etc).

• Organización lógica: Se refiere a que los procesos se pueden dividir en varias unidades lógicas (por ejemplo módulos). Dicha división permite que cada unidad lógica puede tener distinto tipo de protección (sólo lectura, etc). Un ejemplo de esta organización son las “Librerías de Acceso Dinámicos” (las famosas DLL de Windows), las cuales son librerías que no se “linkean” en tiempo de compilación, sino que se cargan en memoria cuando se referencian en tiempo de ejecución. Si no se ocupan, no se cargan en memoria.

• Organización Física: Se refiere al área de memoria físico que se le asigna al proceso, el cual es asignado por el S.O. y es transparente para el programador. Dentro de la organización física, están los “Overlay”, que son parte del programa que son cargado en una determinada área de la memoria y luego puede ser reemplazada por otra parte del programa, un ejemplo de esto son los “niveles” de los juegos. Los Overlay son programados por el programador (el programa cuando se carga), por lo cual no es transparente a él (a diferencia de las DLL que son cargadas por el S.O. cuando se necesitan) .

Técnicas para Manejar la Memoria:

• Particiones Fijas • Particiones Variables • Paginación • Segmentación • Memoria Virtual

o Con Paginación o Con Segmentación o Con Segmentos paginados

Particiones Fijas La memoria está divida en varias particiones, las cuales no cambian su tamaño (puede ser que físicamente correspondan a varias memorias, o bien una memoria dividida en varias particiones por el administrador en el “booteo” (carga e inicialización del Sistema Operativo). Dado que las particiones poseen tamaño fijo, al cargar el proceso (que obviamente debe ser de igual o menor tamaño que la partición, de lo contrario no se podría cargar), generalmente sobra un espacio (si la partición es de 10Mb y cargo un proceso de 8Mb, me sobran 2Mb). Este espacio no puede ser asignado a otro proceso púes siempre se asigna la partición completa, por ende se pierde. Este problema se conoce como “Fragmentación interna” indicando que se pierde espacio que sobra “adentro” de la partición. Las particiones Fijas pueden tener particiones de igual tamaño o de distinto tamaño.

• Si son de igual tamaño, es más fácil poder asignar un proceso a un partición (da lo mismo, son todas iguales), pero se pierde más espacio con los procesos chicos y generalmente se penden tener menos particiones (pensando que deben ser de un tamaño suficiente para almacenar los procesos grandes)

• Si son de distinto tamaño, se podría hacer un uso más eficiente de la memoria,

pero hay que tener mas cuidado al asignar un proceso a una partición (al ser de tamaño distinto no da lo mismo cuál partición asignar). En este caso, para la asignación de una partición a un proceso, se trata de ocupar “donde mejor calza” (o mejor calce / mejor ajuste) o sea la partición más chica entre las particiones igual o más grande al proceso (la menor de las mayores al proceso), con el fin de disminuir el espacio perdido por fragmentación Interna.

Para realizar ésta asignación, se puede trabajar de dos formas:

o Usando Fila única: Cada proceso que llega se ubica al final de “LA” fila que hay, y se asignan las particiones de acuerdo al orden de llegada (FIFO) asignando la partición entre las disponible donde el proceso tenga “un mejor calce”. La desventaja de éste método es que perjudica a los procesos muy grande, porque dichos procesos a lo mejor sólo pueden ser atendidos en una partición de tamaño suficientemente grande, pero esa partición se la asignaron a un proceso más pequeño (por ende podría ir en otra partición) que llegó antes, y cuando llegó era la única partición disponible. Por lo anterior, los procesos grandes tienen menor probabilidad de poder correr, incluso puede haber inanición de estos procesos.

o Usando una fila por Partición: a diferencia del caso anterior, en éste método cada proceso se asigna a la partición que le corresponde según su tamaño usando “el mejor calce”. Si dicha partición está ocupada por otro proceso, el proceso queda en una fila de espera a que se desocupe. Este método puede generar que existan varios procesos esperando una partición mientras existan particiones más grandes sin ser utilizada.

Particiones Variables (o dinámicas) A diferencia del caso anterior, en este caso las particiones no están creadas previamente, sino que se van creando a medida que se necesitan. Por ejemplo, si tengo una memoria libre de 500 MB y llega un proceso que necesita 100Mb para ejecutar, se crea una partición de 100Mb que se asigna al proceso y se deja otra con el área libre de 400Mb. Si posteriormente llega otro proceso que requiere 150Mb, se crea la partición de 150Mb para el proceso, quedan do la partición de 100MB para el primer proceso, la de 150MB para el segundo y la de 250MB con espacio libre. El problema en este caso es lo que pasa cuando termina el proceso 1, pues quedaría un área libre de 100Mb, el proceso 2 con sus 150Mb y otra área libre de 250MB. A las áreas libres que quedan entre una partición y otra se les denomina “Fragmentación externa”, pues son espacios que existen entre las particiones (y no adentro de las particiones como es el caso de la fragmentación interna). Entre más pequeños los espacios que queden, menor probabilidad que pueda reutilizarlos (pues sólo servirían para procesos muy pequeños). Para eliminar la fragmentación externa, existe la “compactación” que consiste en mover todas las particiones usadas “hacia abajo” dejando todas juntas al inicio de la memoria y una sola partición libre al final de la memoria. Este proceso ocupa mucho recurso (tiempo, procesador, etc), por lo cual no es recomendable realizarlo constantemente. Algoritmos de Asignación de la memoria. Si a un proceso podemos asignarlo en varias particiones dentro de la memoria, ¿Dónde lo ponemos?. Según el algoritmo que utilicemos para tomar dicha determinación el uso de memoria podría variar considerablemente.

• Mejor Ajuste: Si bien es el mejor método en particiones fijas, en particiones variables es muy malo, pues genera fragmentos chicos que no pueden ser reutilizados.

• Peor Ajuste: Lo opuesto al mejor ajuste. Siempre elige la partición más grande, por lo cual el fragmento que deja también es grande y tiene mayor probabilidad de ser utilizado.

• Primer Ajuste: Empieza a buscar desde el inicio la primera partición con tamaño suficiente para asignar al proceso. Es muy rápido para asignar y está pensado para ser implementado en una lista que contenga las particiones existentes, si está libre o a quién fue asignada, el tamaño de la partición y desde que dirección de memoria comienza.

• Siguiente Ajuste: Similar a primer calce, pero se diferencia en que no comienza la búsqueda desde el inicio, sino desde donde quedó en la búsqueda anterior (en cada asignación deja un puntero apuntando a donde quedó, para la siguiente búsqueda comienza desde esa posición). Trabaja con lista circular.

Sistema Compañero (Buddy System) El sistema compañero trata de obtener lo mejor de ambos métodos (particiones fijas y particiones variable) asignando particiones variables pero de tamaños preestablecidos (no de cualquier tamaño). Logra un sistema que permite asignar particiones de una forma muy rápida. Este sistema trabaja con particiones potencia de 2. Si un proceso solicita 50 MB, este sistema le asigna una partición “de mejor calce” de tamaño 2N, para este caso, debiera ser 64MB. Supongamos que inicialmente tenemos 1GB de memoria. Si deseamos asignar 64Mb, dado que no existe una partición de dicho tamaño: La partición de 1GB se divide en 2 de 512MB Una de las particiones de 512 se divide en 2 de 256 Una de las de 256 se divide en 2 de 128 Una de las de 128 se divide en 2 de 64 Se asigna una y la otra queda libre 64 64 128 256 512 La estructura anterior equivale a un árbol. Cuando se liberan ambas hojas de un nodo (2 particiones “compañeras”) se juntan en 1 sola partición, y así sucesivamente. 1Gb 512 256 128 64

Paginación Permite relocalizar el código con la ayuda del HW. El proceso en el disco duro se divide en pedazos de un determinado tamaño (cantidad de bytes. Tamaño de los pedazos es fijo y potencia de dos). A éstos se les conoce como “páginas”. La memoria también se divide en varios bloques del mismo tamaño de las páginas. A dichos bloques se les conoce como “marcos de páginas” (frames). La paginación permite que las páginas del proceso se carguen en cualquier marco dentro de la memoria (no necesariamente ordenadas, puede ser un verdadero rompecabezas, poniendo las páginas en total desorden en la memoria). Dado lo anterior, ¿cómo puede ejecutarse un programa si una instrucción del tipo

saltar a la dirección 100, ese 100 puede estar en cualquier parte de la memoria? La respuesta está dado por la ayuda de HW y SW. Por SW (S.O.), existe una tabla por proceso (un vector) donde hace referencia al marco donde está cargada la página del proceso. Dicha tabla se llama “tabla de página” Ejemplo: Si tenemos la tabla de página del proceso A 0 1 2 3 4 5 6 7 8 9 Nos dice que la página 0 de nuestro proceso se encuentra el marco 14 de la memoria, la página 1 en el marco 5, …. Etc. (Ver dibujo) MEMORIA DISCO 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 9 …. Frames (marcos de página) Páginas

10 9 2 11 4 3 8 7 5 14

A B C D E F G H I J

F G H

J C D E

A

B I

En el HW, existe un dispositivo llamado Unidad de Administración de Memoria (MMU, Memory Management Unit) el cuál físicamente se ubica entre la CPU y la memoria, transformando los datos que viajan por el bus de direcciones, transformando direcciones lógicas (que son las que utiliza la CPU la cual piensa que el programa está ubicado en forma secuencial en algún área de la memoria), en direcciones físicas (que son las que llegan a la memoria, para poder trabajar con la dirección real donde se encuentran los datos).

¿Cómo trabaja la MMU? Para trabajar y trasformar una dirección lógica en física (o viceversa) utiliza la tabla de página. Explicaremos su funcionamiento según el siguiente ejemplo. Supongamos páginas (y por ende marcos) de tamaño 4 bytes. Si tenemos en el disco (direccionamiento lógico): 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 .. Página 0 Página 1 Página 2 Página 3 Página 4 Supongan que se desea acceder a la celda N° 14 que contiene la letra “N”. Dado que el tamaño de las páginas (y por ende el frame) es conocido (en este caso 4), podríamos calcular: Celda que se desea acceder dividido por tamaño frame : 14 / 4 = 3 (página) 2 (Offset) El resultado de la división es 3, nos indica que la celda 14 se ubica en la página N°3 El residuo de la división es 2, nos indica que ocupa la tercera posición dentro del frame (se denomina offset o corrimiento a la posición dentro del frame). ¿Por qué tercera si es 2?, porque comienza de 0. En este caso, el Offset 0 en la página corresponde a la celda 12 (letra F), el Offset 1 corresponde a la celda 13(letra U), y el Offset 3 correspondería a la celda 15 (letra C).

E J E M P L O D E L F U C N I O N A M I … .

¿De qué nos sirve saber esto? Ya sabemos que la celda buscada se encuentra en la página 3. Supongamos ahora que sabemos por la tabla de página que la página 3 se encuentra por ejemplo en el frame 10 (valor de la tabla de página del dibujo del inicio ☺ ). Dado que el frame es de tamaño 4 (igual a la página), 10 * 4 = 40, dirección física (real) del inicio del frame. Dado que el Offset obtenido anteriormente era 2, si sumamos el inicio del Frame + Offset = 40 + 2 , tenemos que la dirección física en memoria del la dirección lógica (del disco) 14 es la dirección 42. Dado que los valores están en binario, la MMU realiza este proceso de una forma muy fácil (parece truco de magia). La dirección lógica es 14 , en binario = 001110 Dado que el tamaño del frame (y por ende de la página) es 4, se requieren 2 bits para direccionar dentro de ella (log2 4) , por lo tanto separamos el número anterior dejando los dos bits de la derecha separado del resto: 0011 10 (¿qué números tenemos? Son el 3 (0011) y el 2 (10) ¿Te parecen familiares? EXACTO, corresponde al número de página y al Offset .. sin realizar ningún calculo!!! ☺ ) Ahora, por la tabla sabemos que la página 3 (011) se almacenó en el frame 10 (1010) Si del número anterior ( 0011 10) reemplazamos el N° de página por el frame, nos daría 1010 10 que corresponde al número 42!! Por lo tanto, la MMU lo único que hace es cambiar los bits que representan al número de página por los bits del número de frame, el cuál obtiene de la tabla de página.

Segmentación La segmentación es similar a la paginación, pero posee las siguientes diferencias:

• Los segmentos no necesariamente son del mismo tamaño, pero los que si está definido es el tamaño máximo que pueden tener los segmentos.

• En un segmento se almacena un “unidad lógica” (como puede ser el área de datos, el área de código, un módulo, etc.). Por lo anterior, a diferencia de las páginas donde las páginas se dividían por tamaño sin importar lo que contuvieran, acá la división no es transparente para el S.O. y/o el programador.

• También se utiliza una tabla, denominada “tabla de segmento” con una entrada por cada segmento del programa. Sin embargo, los campos de esta tabla difieren a la tabla de página, pues contiene dos campos:

o El tamaño del segmento o La dirección base (dirección de inicio del segmento)

A diferencia de la paginación, para convertir una dirección lógica en una dirección física, la MMU en lugar de sólo cambiar los primeros bits (correspondiente a la página), en la segmentación se “suma” el valor del Offset a la dirección base que se obtiene de la tabla de segmento. Ejemplo: Usando la misma dirección lógica del ejemplo anterior, y segmentos de tamaño máximo 4 (valor muy pequeño para el caso de un segmento, pero como sólo es un ejemplo….) tenemos que el Offset seguiría siendo de 2 bits (log2 4) Segmento offset 0011 10 Tabla de página: N. Segmento Tamaño Dirección Base

0000 01 0000 0001 10 0010 0010 11 1100 0011 10 0110 …. … ….

Tenemos 0110 + 10 = 1000 , que corresponde a la dirección física 8

MEMORIA VIRTUAL Ya conocemos cómo trabaja tanto la paginación como la segmentación, las cuales permiten una fácil relocalización del código y utilizar la memoria en una forma que no necesariamente requieres áreas libres contiguas. Pero, sabemos que un proceso ocupa sólo algunas áreas de la memoria que se le ha asignado en un instante dado de tiempo (no está siempre ocupando “todo” el área de código, ni todos los datos, ni toda la pila, etc). Dado lo anterior, podemos pensar que podríamos tener en memoria sólo las áreas de memoria que el proceso ocupará durante determinado tiempo, y el resto dejarlo en disco. Ventajas:

• Al ocupar menos memoria por proceso, podemos tener más procesos (aumentar la multiprogramación)

• Podríamos ejecutar programas que requieren más memoria de la que disponemos físicamente

Glosario:

• Memoria Virtual: Memoria en Disco • Memoria Real: hace regencia a la memoria “física” • Dirección Virtual: Las direcciones del programa cuando se almacena en el

disco. Dichas direcciones pueden ser mayores a la capacidad de memoria real que se posee.

• Dirección Real: Corresponde a la dirección física que se quiere referenciar (la dirección que realmente ocupa en la memoria). La dirección Virtual se transforma en real por medio de la MMU

• Fallo de Página: es el nombre de una interrupción que se produce al referenciar a una “página” que está en disco y no se ha cargado en memoria.

• Swapping (intercambio): Se refiere al proceso de llevar una página de disco a memoria y viceversa

• Trashing: el trashing (o “basureo”, “escarbar en la basura”) corresponde a cuando se intercambia (swapping) una página por otra, y la página que se “sacó” de la memoria, era justo la que se iba a utilizar más adelante. Esto es un problema dado que se gasta más tiempo en cambiar páginas que en que el proceso corra (típico problema que notamos en nuestros computadores cuando se pone muy lento y cuesta hasta que se mueva en Mouse y notamos que el disco suena mucho y/o tiene la luz de uso prendida).

• Conjunto de trabajo: Corresponde a las áreas de memoria (páginas y/o segmentos) que un programa utilizará durante un determinado instante de tiempo (por lo cuál es dinámico, el conjunto de trabajo del inicio de un programa generalmente es distinto al conjunto de trabajo del final del programa, etc).

Paginación con memoria virtual La paginación con memoria virtual funciona de forma similar a la paginación simple, con la salvedad que la tabla de página posee un campo con un bits de

“presente/ ausente”, el cual indica si la página está cargada en la memoria (en algún marco). Si indica que no está cargado y se está referenciado, se produce un “fallo de página”. Además de dicho campo, es común agregar en la tabla de página el campo de “modificado”, el cual dice que se escribió en la página. Si una página no se ha modificado, indica que la página del disco con la que está cargada en el frame son iguales, por lo cual se puede reemplazar la página del frame sin necesidad de escribir la anterior. En cambio, si se ha modificado, debo guardar los cambios de la página en el disco antes de cargar una nueva página en el frame.

Estructuras de la tabla de página: Como se mencionó, las tablas de páginas son vectores. Entre más páginas existan más grande serán las tablas de páginas. Dichas TP se almacenan en memoria, por ende, si son grandes, se ocupará mucha memoria. Dado el punto anterior, se han creado algunas estructuras con el fin de disminuir el área de memoria utilizada para almacenar la tabla de página:

• Estructura de dos niveles: La idea es “subdividir” el vector en varios vectores de tamaño N. Existe un vector de mayor nivel que apunta al inicio de cada subvector. Cuando se requiere un página, primero se busca el “rango donde se encuentra” en el vector de nivel superior, el cuál generalmente ocupa el tamaño de un página para mantenerse en memoria. Por ejemplo, supongamos que la página buscada es la número 5, si en el nivel superior las páginas van de 3 en 3 , sabemos que 5 estará entre 3 y menor a 6, por lo tanto estará apuntada por mi segunda entrada en la tabla de primer nivel. Dicha entrada me apunta a una página, la cual al cargarla en memoria (pues el segundo nivel inicialmente está en disco) me dará las entradas de la tabla de página a las páginas 3, 4 y 5.

Dado que estamos buscando la página 5, podemos observar que se encuentra en el frame 9.

• Tabla de página invertida: al igual que en dos niveles, existe una tabla

de nivel superior, pero a diferencia de la anterior, se llega a ésta tabla usando un “HASH” (una función, generalmente la función “módulo”) al número de página entregado. Con dicha función, obtenemos la dirección dentro del segundo nivel de la tabla de página donde se debiera encontrar el frame donde se encuentra cargada nuestra página. Sin embargo, tenemos un problema. Generalmente las funciones HASH nos entregan en mismo resultado para varias entradas (suponga por ejemplo la función modulo 10, para las páginas 5,15,25 … etc nos daría el mismo resultado, 5). Dado lo anterior, cada entrada en la tabla de página tiene un campo “puntero” que nos indica donde se encuentra la siguiente página que obtuvo el mismo resultado de hash, tal como sería una lista enlazada.

Segmentación con memoria virtual: La segmentación con memoria virtual funciona en forma similar a la segmentación simple, pero si un segmento no es ocupado, no se carga. Dado que los segmentos son unidades lógicas, si una determinada unidad no se utiliza, no se carga en memoria (ejemplo más clásico son los módulos). A la tabla de segmento, al igual que se hizo en la tabla de páginas, se le agregan 2 campos: El campo de segmento presente / ausente y el campo de segmento modificado. Usando Segmentos Paginados: La paginación tiene la gracia de dividir por tamaño en forma transparente al programador. El segmento divide por unidades lógicas. El mezclar segmentos y paginación permite:

• El segmento si se utiliza se carga. Si no se llega a utilizar no se cargará. • Si el segmento que se carga está paginado, sólo las áreas del segmento

que se utilice se cargará, el resto no se cargará. Para poder trabajar con este método, se requiere una tabla de segmento por cada proceso, y una tabla de página por cada segmento Algoritmos de reemplazo: Cuando se necesita intercambiar una página (swapping), debido a que ocurrió un fallo de página y todos los marcos están ocupado, ¿cuál página debiera sacar para liberar el frame? Existen varios algoritmos que tratan de solucionar el problema:

• Óptimo: Se debe sacar la página que se usará en más tiempo (o idealmente aquella que nunca se volverá a utilizar). Es imposible de implementar pero indica a que debiese tratar de llegar nuestra solución.

• Usada menos recientemente (LRU, Least Recently Used): Se debe sacar la página que se usó hace más tiempo, y por ende, tiene menos probabilidades de seer usada prontamente. Es “costosa” de implementar pues requiere tener las páginas ordenadas según hace cuanto tiempo se usaron, y volver a reordenar en cada referencia a página.

• FIFO: Fifo como algoritmo generalmente se utiliza por lo simple de implementar (una lista), pero no garantiza nada respecto al uso (similar a aleatorio), pues la primera página en entrar puede ser la más utilizada.

• FIFO de Segunda Oportunidad (También conocido como “reloj”): Similar a fifo, pero posee un bits de “referenciado”. Si después de haber sido cargada por primera vez, la página es “referenciada”, dicho bits cambia a 1. Cuando se desea intercambiar una página, si la página que llegó primero posee el bits

referenciado en 1, se cambia a 0 y se mueve la página la final de la lista. Se sigue buscando hasta encontrar la primera página que no haya sido referenciada.

• NO USADA RECIENTEMENTE (NRU, NO RECENTLY USED): Este algoritmo utiliza dos bits. Además del “referenciado” usado en algoritmos anteriores, usa el bits de modificado, el cual se enciende cuando se “modifica” una página (cambia algún valor). Los bits referenciados cada cierto intervalo de tiempo son llevado a cero (para todas las páginas al mismo tiempo). Según el valor de los bits, las páginas se clasifican en cuatro niveles. El más bajo son las que tiene ambos bits en 0, el siguiente son las que tiene el bits modificado en 1, el que sigue son las páginas con el bits referenciado en 1 y el nivel más alto son las páginas con ambos bits en 1. Este algoritmo elimina a cualquier página del nivel más bajo disponible.

ENTRADA Y SALIDA Diferencia entre dispositivos:

• Velocidad: Existe gran diferencia en las velocidades de los dispositivos. Por ejemplo teclado app. 100 bit por segundo, tarjetas GigaEthernet 1.000.000.000 bits por segundo.

• Complejidad de Control: Algunos dispositivos sólo requieren instrucción de leer y/o escribir, en cambio otros requieren instrucciones de prender motor, posicionarse en determinada posición, etc.

• Unidad de transferencia: Algunos dispositivos leen y/o escribir byte a byte, mientras otros leer y/o escriben un “bloque” de determinado tamaño

• Representación de datos: Los dispositivos pueden representar los datos de diferente forma (ejemplo: Código ASCII v/s EBCDIC, etc)

• Condiciones de error: Cada dispositivo puede tener diversos motivos de errores y/o responder de forma distinta al mismo error.

Objetivo de los S.O. para el control de los dispositivos: Permitir la “Independencia del Dispositivo” , esto es que el usuario se abstraiga de las complejidades del dispositivo, tratando a todos como si fueran iguales.

¿Cómo se logra la Independencia del dispositivo? Trabajando por niveles. El nivel inferior (los drivers) es la única parte del S.O. que sabe como trabaja el dispositivo. El drivers entrega una interfaz de alto nivel que ocupa los niveles superiores del S.O., con instrucciones de alto nivel como “leer”, “Escribir”, “abrir”, “cerrar”, etc.

El manejo del Disco: Para realizar una operación de E/S en un disco, se debe ubicar la pista a usar, lo que implica:

• Mover la cabeza de lectoescritura a la pista deseada (tiempo de seek) • Esperar que el inicio del sector pase bajo la cabeza (latencia rotacional) • Leer y/o Escribir en el sector (transferencia).

Si existen varias solicitudes en período de tiempo casi simultáneo, se puede mejorar los tiempos de respuesta ordenando las solicitudes según las siguientes políticas de planificación del disco:

• FIFO: Atiende en orden de llegada. Tiempo de respuesta muy malo. • Prioridades: Atiende según prioridad. En BASH se puede dar prioridad a los

procesos cortos para disminuir tiempos de espera promedios. • LIFO: Atiende la última solicitud pues puede ser la más cercana. Si llegan

muchas solicitudes puede producir inanición a la primera. • Primero la más cercana (SSTF, Shortest Seek Time First): Atiende la solicitud

que esté más cerca a la pista actual. Es la más eficiente en cuanto a tiempo de respuesta, pero puede producir inanición con las solicitudes que lleguen a los extremos.

• Ascensor (SCAN) : Atiende las solicitudes en orden ascendente de la posición actual. Al llegar a la última, empieza a atender las solicitudes en forma descendente (igual que un ascensor, primero para arriba, luego para abajo, y así sucesivamente).

• C-SCAN: Similar a SCAN, pero atiende las solicitudes siempre en orden ascendente. Al llegar a la última solicitud retorna al inicio (sin atender), y vuelve a atender en forma ascendente.

• Scan de N pasos: Igual que un scan, pero atiende máximo “N” solicitudes por vez. Una vez que finaliza las primeras N solicitudes, atiende las siguientes N, y así sucesivamente.

• F-Scan: Usa dos colas. Cuando empieza a atender las solicitudes, cualquier nueva solicitud es agregada a la nueva cola, por lo cual será atendida en la próxima ronda.

Sistema de Archivos: Los archivos son estructuras usadas por los S.O. para poder almacenar y luego recuperar la información en los discos (y oros medios de almacenamientos) Organización de Archivos:

• Pila: Los datos son almacenado en el orden que llegan. Cara registro puede ser de tamaño y campos distintos. Se accede a los registros por búsqueda exhaustiva

• Secuenciales: Registros del mismo tamaño y mismo tipo (mismos campos). Existe un campo denominado “Campo Clave”. Los registros están ordenado por dicho campo. Par amantener dicho orden, al agregar un nuevo campo, se inserta en otro archivo, denominado “Archivo de Logs”, y posteriormente mediante proceso batch se realiza un “Merge” entre ambos archivos. Las búsquedas son secuenciales, pero al estar ordenado por la clave, sólo se busca hasta encontrar la clave o llegar a una clave mayor a la buscada (en caso que no exista).

• Indexado Secuenciales: Es una archivo secuencial, que además posee otro archivo, denominado “índice”. Dicho índice apunta al inicio de un grupo de registros, por ejemplo puede ir de 100 en 100. Si se desea encontrar la clave 543, se sabe que está entre 500 y 600, luego se busca en el índice el 500 el cual apunta registro 500 en el archivo secuencial, y desde ahí se busca secuencialmente.

• Indexado: Permite tener índices exhaustivos a otros campos que no sean la clave. Dado que el archivo sólo lo podemos ordenar por un campo (p.e. RUT), si se desea buscar por otro campo (p.e. NOMBRE) se tendría que hacer en forma exhautiva. Al tener un índice por dicho campo (el cuál obviamente está ordenado por dicho campo), podemos buscar en forma secuencial en el índice y luego obtener los datos del archivo.

• HASH: dada su clave, obtenemos inmeditamente su posiciones aplicando una función HASH a la clave, y accediendo a la posición del archivo retornada por aquella función.

Directorios: Son estructuras (generalmente un archivo de registros) que nos permiten mantener información de los archivos almacenados, como su nombre, su tamaño, etc. Existen sistemas operativos que trabajan con:

• Un solo directorio: Todos los archivos en un mismo nivel • Un directorio por usuario: Cada usuario tiene un solo directorio donde

mantienen los archivos de dicho usuario • Estructura jerárquica de directorios: existe un directorio maestro, donde pueden

haber tanto archivos como directorios. En cada directorio pueden haber archivos y/o subdirectorios, y así recursivamente.

Administración de Almacenamiento: Indica que bloques (sectores) se asignarán a un archivo. La información de bloque a asignar se manejan en estructuras denominadas “Tablas de Asignación de Archivos” Asignación de bloques contiguos: Se requiere saber el tamaño del archivo. Tabla Asignación posee 2 campos: bloque inicial y tamaño (cantidad de bloques)

Asignación en cadena: Asigna bloques no necesariamente contiguos. Cada bloque junto con almacenar la información, posee un campo que indica la dirección del siguiente bloque (lista enlazada). Para acceder p.e. al quinto bloque, se debee leer los bloques anteriores (acceso sólo secuencial).

Asignación Indexada: Un sector del disco funciona como índice a los bloques que forman el archivo. La tabla de asignación posee un puntero a dicho sector. Para acceder a un determinado bloque, se lee el bloque con el índice y de él se obtiene la dirección del bloque a leer, por ende se puede acceder en forma directa.

Sistema de Archivo FAT Ya sabemos que “Tabla de Asignación de Archivo” (File Allocation Table, FAT), es un nombre genérico que se le da a la tabla que nos indica los bloques que componen un archivo, pero también es nombre del sistema de archivo que usó Microsoft en sus anteriores sistemas operativos. El sistema FAT estaba basado en la asignación en cadena, pero usando una “lista enlazada en vector”. Para ello usaba las siguientes estructuras: El directorio (un archivo con registros del siguiente tipo): Una estructura (denominada FAT), la cual era un vector: 0 1 2 3 4 5 6 7 8 9 10 11 … Como se puede observar, el directorio indica el primer bloque, en este caso el 5. Con dicho valor entramos a la tabla fat, el la posición 5 hay un 9, el cual nos indica que es el siguiente bloque, luego en la posición 9 hay un 10, que es el siguiente bloque, en el 10 hay un 2, que es el siguiente bloque, y en el 2 hay un FF que es un indicador de término (no hay más bloques). Originalmente (en DOS) cada posición de la tabla FAT era de 16 bits, por lo cual la cantidad máxima de bloques era 65536. Luego en los S.O. siguiente se cambió el tamaño de cada posición del vector de 16 a 32 bits, apareciendo el famoso FAT32.

Nombre del Archivo Tamaño Fecha Atributos 1er Bloque P.e: 5

FF 9 10 2

Los i-nodos (unix) Los sistemas basados en unix poseen un sistema de archivo que utiliza unas estructuras denominadas i-nodos. Los i-nodos se basan en la asignación indexada. Los campos del directorio son muy simples, pues sólo contiene el nombre del archivo y un número de i-nodo (puntero a un sector que contiene éste) Los i-nodos son estructuras más complejas, donde tienen toda la información del archivo (salvo el nombre que está en el directorio) como por ejemplo el tamaño, fecha de creación, etc., y además poseen :

• 10 punteros a los 10 primeros bloques del archivo. • 1 puntero indirecto, el cual apunta a bloque que es del tipo usado en

asignación indexada, o sea un vector con puntero a bloques del archivo • 1 puntero doble indirecto, el cual apunta a un sector con un vector de

punteros, donde cada entrada apunta a otro vector de puntero, donde las entradas apuntan a los bloques del archivo

• 1 puntero triple indirecto, el cual apunta a un vector de puntero, donde cada entrada apunta a otro vector de punteros, donde cada entrada apunta aq un tercer vector de punteros, que apunta a los bloques del archivo.

Según el tamaño del archivo, se utilizan los punteros directos, directos + indirectos, directos + indirectos + doble indirecto o en el peor de los casos (archivos mas grandes), directos + indirectos + doble indirectos + triple indirectos.

Nombre del Archivo i-nodo