t3 introducción a los so

Tema 3: Introducción a los SO

ÍNDICE

1. INTRODUCCIÓN........................................................................................................ 3

SO POR SUS SERVICIOS .................................................................................................. 4 SO POR SU ESTRUCTURA................................................................................................ 6

2. FUNCIONES DEL SO................................................................................................. 7

GESTIÓN DE PROCESOS .................................................................................................. 7 Implementación ........................................................................................................ 8 Estados ..................................................................................................................... 9 Planificación de procesos......................................................................................... 9 Ejercicios ................................................................................................................ 15 Sincronización y bloqueo entre procesos ............................................................... 19 Interbloqueos .......................................................................................................... 21

GESTIÓN DE MEMORIA................................................................................................. 22

Asignación contigua ............................................................................................... 22 Asignación no Contigua ......................................................................................... 27 Memoria Virtual ..................................................................................................... 32 Ejercicios ................................................................................................................ 34 Gestión de memoria en Unix/Linux........................................................................ 39 Protección de memoria........................................................................................... 40

GESTIÓN DE DISPOSITIVOS DE E/S ............................................................................... 41

Técnicas de transferencia....................................................................................... 42 GESTIÓN DEL SISTEMA DE FICHEROS............................................................................ 43

Nombre de los archivos .......................................................................................... 43 Tipos de archivos.................................................................................................... 44 Atributos de los archivos ........................................................................................ 45 Sistemas de archivos............................................................................................... 46 Tipos de sistemas de archivos ................................................................................ 50 Ejercicios (Gestión de Procesos) .............................¡Error! Marcador no definido.

Introducción a los SO

1. Introducción

El SO es el SW básico del ordenador. Es un conjunto de programas que

controlan directamente el HW del ordenador, proporcionando una interfaz, sencilla de

utilizar, que facilite el manejo del mismo.

Por ejemplo, no tenemos por qué saber exactamente en qué parte del disco

duro tenemos guardado cada documento que hemos creado, ya que es el SO el que se

encarga de hacerlo.

El SO se carga una vez que la BIOS reconoce a la CPU, la memoria, las

unidades de disco y cualquier otro dispositivo conectado al ordenador como el teclado,

el ratón, la impresora, etc., verificando así que no existen errores de conexión y que

todos los dispositivos se han reconocido y trabajan correctamente. A este primer

diagnóstico se le denomina POST.

Los objetivos que persigue un SO son dos:

• Hacer cómoda la utilización de una computadora.

• Utilizar los recursos HW de la computadora (procesador, memoria,

dispositivos, etc.) de forma eficiente.

Empezaremos el tema viendo los diferentes tipos de sistema operativos.

Básicamente se cubrirán dos clasificaciones: SO por su estructura y SO por los servicios

que ofrece.

3


SO por sus servicios

Esta clasificación es la más usada y conocida por el usuario final:

• Dependiendo del número de usuarios que puedan explotar simultáneamente

el sistema, este puede ser:

o Monousuario: soportan un usuario a la vez. Todos los dispositivos HW

están a disposición de ese usuario y no pueden ser utilizados por otros

hasta que este no finalice su uso. No importa el número de procesadores

o el número de procesos que el usuario pueda ejecutar simultáneamente.

o Multiusuarios: son capaces de dar servicio a más de un usuario a la vez,

compartiendo CPU y recursos del sistema simultáneamente. Los usuarios

pueden utilizar el ordenador principal de la siguiente manera: mediante

terminales tontos (monitor y teclado), o bien mediante ordenadores

cliente conectados al servidor. No importa el número de procesadores ni

de procesos ejecutados.

• Dependiendo del número de procesos que se puedan ejecutar

simultáneamente. Un ordenador que tenga un único procesador sólo puede

realizar una tarea por vez, por ello habrá que matizar la palabra

simultáneamente:

o Monotarea o monoprogramado: sólo se puede cargar en memoria

principal un proceso, aquel que se va a ejecutar. Los recursos del sistema

estarán disponible al programa hasta que finalice su ejecución.

Un SO monotarea puede ser multiusuario, varios usuarios pueden

intentar ejecutar sus programas en el mismo ordenador de forma

simultánea, aunque no es lo habitual. En este caso el SO dispondrá de

listas de procesos, e irá asignado prioridades a cada uno de los mismos.

o Multitarea: varios procesos están cargados simultáneamente en memoria

principal. Cuando sólo se dispone de un procesador, se debe dividir el

tiempo de uso del procesador entre todos aquellos procesos que se

deseen ejecutar. Así todos los procesos tardarán individualmente más

tiempo en ejecutarse, pero comparándolo con la monotarea, el tiempo

4


medio de espera será mucho menor. Únicamente si el sistema es

multiprocesador la concurrencia es real.

• Dependiendo del número de procesadores que se puedan utilizar

simultáneamente:

o Monoproceso: es capaz de manejar solamente un procesador, de manera

que si tuviese más sería inútil. En estos SO los procesos irán alternando

su ocupación en la CPU, como ya se ha comentado. El ordenador que

tenga instalado este tipo de SO puede ser monotarea o multitarea,

monousuario o multiusuario.

o Multiproceso: en caso de que la computadora tenga más de un

procesador, es capaz de usarlo simultáneamente para distribuir su carga

de trabajo. Estos sistema trabajan de dos formas:

Asimétrica: el SO reparte las tareas, que está realizando, entre los

procesadores. Determinados procesos los ejecutará siempre un

procesador, y el otro procesador sólo se utilizará para realizar

procesos de usuario. En este caso, es posible que un proceso esté

siempre trabajando y el otro, en ocasiones, sin actividad.

Simétrica: los procesos son enviados indistintamente a cualquiera

de los procesadores disponibles.

5


SO por su estructura

Los primeros SO se denominaron monolíticos: el SO era un solo programa, que

una vez creado e instalado era prácticamente imposible de modificar. Cuando los

diseñadores del SO, por necesidades específicas, querían introducir modificaciones en

él, la labor era realmente complicada, ya que era necesario volver a configurar todo el

SO. Ejemplo: programación convencional vs. programación estructurada.

Actualmente los SO se organizan en capas, concretamente en 5 niveles o capas.

Cada uno de estos niveles se comunica con el nivel inmediatamente inferior y superior,

de tal forma que todos ellos están coordinados y pueden conseguir el objetivo del SO.

Veamos cada una de esas capas:

• Nivel 1, gestión del procesador: en este nivel se encuentra la parte del SO

encargada de gestionar la CPU. En los SO multiproceso o multitarea, este

nivel, se encarga de compartir la CPU entre los distintos procesos que desean

ejecutarse.

• Nivel 2, gestión de memoria: este nivel es el encargado de repartir la

memoria disponible entre los procesos. Se realizan funciones de asignación y

liberación de memoria, así como de proteger la zona de memoria ocupada

por un proceso para que no sea ocupada por otro diferente.

• Nivel 3, gestión de procesos: este nivel se encarga de la creación y

destrucción de los procesos, intercambio de mensajes y detección y arranque

de los mismos.

• Nivel 4, gestión de dispositivos: encargado de gestionar las entradas y

salidas (E/S): asignación y liberación de dispositivos de E/S, y planificación

de la E/S.

• Nivel 5, gestión de información: en este nivel el SO gestiona los nombres de

archivos, directorios, atributos de los mismos, protección de acceso, etc. Se

crean, destruyen y modifican archivos y directorios.

6


2. Funciones del SO

En concordancia con la estructura por niveles del SO, es posible analizar las

funciones principales del mismo. Algunas de las funciones principales de un SO son:

• Gestión de procesos.

• Gestión de memoria.

• Gestión de los dispositivos de E/S.

• Gestión del sistema de archivos.

• Gestión de la red.

• Protección.

En este tema trataremos los cuatro primeros servicios.

Gestión de procesos

Un proceso se puede definir como un programa en ejecución. Presenta las

siguientes características:

• Para iniciar su ejecución debe estar cargado en memoria y tener asignado

todos los recursos que necesite.

• Está protegido, ningún otro proceso puede escribir en la zona de memoria

perteneciente a ese proceso.

• Puede pertenecer al usuario o ser propio del sistema operativo.

No hay que confundir proceso con programa, un programa no es un proceso

siempre y cuando no esté en ejecución. Por ejemplo, Microsoft Word será simplemente

un archivo almacenado en el disco duro si no se está ejecutando. Una vez se ejecute, el

archivo Microsoft Word seguirá donde estaba originalmente, pero las instrucciones

necesarias para su ejecución se habrán cargado en memoria. Una vez que se está

ejecutando el programa, se convierte en proceso.

7


Implementación

Cada vez que un programa se convierte en proceso, es decir, cada vez que se

ejecuta, además de ubicarse en memoria las instrucciones que permiten su ejecución, se

le asocia una estructura de datos. Esta estructura de datos es única para cada proceso, y

lo identifica de forma inequívoca, en ella se almacena información necesaria sobre el

proceso, para asegurar una correcta ejecución. A esta estructura de datos se le conoce

con el nombre de Bloque de Control de Procesos o PCB.

Cada PCB contiene básicamente los siguientes datos:

• Identificador del proceso: a cada proceso dependiendo del SO se le asocia un

PID o código de identificador de proceso. Este código es normalmente un

número que el propio SO asigna. Se utilizará para identificarlo.

• Prioridad del proceso: cada proceso tiene asociada una prioridad, de forma

que, en cualquier instante, el proceso que mayor prioridad tiene asignada, de

entre los que están en estado ESPERANDO, es el que se ejecutará. La

prioridad de cada proceso la asigna automáticamente el SO. Esta prioridad

puede ser modificada por los usuarios con privilegios para ello

(normalmente el dueño de un proceso puede modificar la prioridad del

mismo, y el administrador podrá modificar la prioridad de cualquier proceso

de todos los usuarios. En Windows XP desde el administrador de tareas

Ctrl+Alt+Supr).

• Ubicación en memoria: el SO deberá ubicar cada proceso en una zona

independiente de memoria, la forma que tiene de elegir esta zona será

estudiada en la parte de gestión de memoria.

• Recursos utilizados: cada proceso debe tener a su disposición determinados

recursos para poder ejecutarse (discos, impresoras, procesador, etc.).

• Estado del proceso.

• Información sobre el planificador de la CPU.

• ...

8


Estados

El estado de un proceso viene definido por su actividad actual, va cambiando a

medida que se ejecuta el proceso. A continuación se muestra un diagrama con los

posibles estados y transiciones entre ellos:

Terminado

Escogido por el Planificador

Interrupción

E/S o esperando un evento E/S o evento completado

SalidaEjecución Preparado

Suspendido

• Preparado-Ejecución: un proceso es escogido por el planificador para

ejecución.

• Ejecución-Preparado: el proceso ejecutado abandona involuntariamente el

procesador bien porque ha consumido el tiempo que tenía asignado o porque

otro proceso más prioritario está preparado. En ambos casos el proceso en

ejecución se interrumpe y es expulsado.

• Ejecución-Suspendido: el proceso ejecutado abandona voluntariamente el

procesador porque tiene que esperar a que se produzca un evento externo

(finalización de una operación de E/S, por ejemplo).

• Suspendido-Preparado: el evento que estaba esperando el proceso

suspendido ha finalizado, por tanto puede pasar al estado de preparado.

• Ejecución-Terminado: el proceso ha terminado su ejecución o ha sido

eliminado.

Planificación de procesos

Una CPU no puede ejecutar dos o más procesos a la vez. Dada la elevada

rapidez a la que se ejecutan los procesos, el usuario aprecia que los procesos se ejecutan

simultáneamente, aunque la CPU los ejecute secuencialmente. Para dar la apariencia de

ejecución simultánea de varios procesos, el tiempo de CPU se debe repartir entre los

procesos a ejecutar, de modo que cada proceso tendrá disponible un intervalo de tiempo

9


de la CPU durante el cuál podrá ejecutarse. Un proceso pierde la CPU debido a los

siguientes motivos:

• Se recibe una interrupción (por ejemplo ha consumido el quantum de

tiempo).

• El proceso termina.

• Realiza una llamada al sistema que lo bloquea (operación de E/S).

Cuando un proceso se detiene temporalmente, deberá reiniciarse después,

exactamente en el mismo estado en que se encontraba cuando se detuvo. El SO guarda

el estado en el que se encontraba la tarea, guardando el contenido de los registros del

procesador y los reemplaza con los valores de la próxima tarea a ejecutar.

Este cambio de contenido da lugar a lo que se llama cambio de contexto, este

cambio requiere un tiempo muy pequeño en comparación al tiempo que se le asigna a

cada tarea para su ejecución. La operación de cambio la realiza un componente del SO

llamado dispatcher. En esta operación se salva el contexto del proceso en su PCB.

La parte del SO encargada de seleccionar el siguiente proceso para ejecución se

llama planificador, y el algoritmo que utiliza para seleccionar, algoritmo de

planificación.

Cola de procesos preparados

Cola de procesos esperando recursos

CPU

Recursos

Algoritmos de Planificación

El objetivo de un algoritmo de planificación es elegir de entre los procesos en la

cola de preparados, aquel al que se le asignará la CPU.

10


• FCFS o FIFO (First Come/In First Server/Out): primero en entrar primero en

salir. Es el más sencillo de implementar. Escoge el que lleva más tiempo en

la cola de preparados. Continuará en estado de ejecución hasta que lo

abandone voluntariamente.

El principal inconveniente es que los tiempos de respuesta variarán

fuertemente según el orden de llegada a la CPU de los procesos.

Ejemplo: Tenemos tres procesos con distintos tiempos de procesamiento:

proceso 1 con 18 unidades, proceso 2 con 6 unidades, proceso 3 con 6

unidades. Si lo ejecutamos aplicando el algoritmo FIFO:

Supongamos que el orden de llegada de los procesos es el siguiente:

PROCESO 1 --------------- PROCESO 2 --------------- PROCESO 3

Estudiando el tiempo medio de retorno, es decir, el tiempo medio que se

tarda en finalizar un proceso, tendremos: (18 + 24 + 30) / 3 = 24

Si ahora el orden de llegada de los procesos es otro:

PROCESO 2 --------------- PROCESO 3 --------------- PROCESO 1

El tiempo medio de retorno será: (6 + 12 + 30) / 3 = 16. Los procesos están

menos tiempo esperando.

Se observa que, utilizando el algoritmo FIFO, si apareciera una tarea crítica

que requiriese atención inmediata, esta tendría que esperar a la finalización

de las tareas en cola.

Proceso Ciclo llegada Ciclos CPU Prioridad

A 0 3 3

B 2 6 1

C 4 4 3

D 6 5 4

E 8 2 2

11


A X X X

B E X X X X X X

C E E E E E X X X X

D E E E E E E E X X X X X

E E E E E E E E E E E X X

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Tme = (0 + 1 + 5 + 7 + 10) / 5 = 4.6 Tmr = (3 + 7 + 9 + 12 + 12) / 5 = 8,6

• STF o SJF (Shortest Task/Job First): El planificador da prioridad a los

procesos con rachas de CPU cortas para ejecutarlos en el menor tiempo

posible. Si se está ejecutando un proceso y llega otro, independientemente de

la duración del nuevo, el proceso que se está ejecutando finalizará. A

continuación, el siguiente proceso que pasará a ejecución será el más corto

de los que haya en la cola de espera. Si hay varios procesos de igual

duración aplicamos una política FIFO para seleccionar uno de ellos. Con

este algoritmo se favorecen los procesos con más E/S. El problema que

puede presentarse es que se produzca inanición, es decir, que vayan entrando

los procesos cortos y los procesos largos no se ejecuten nunca.

Partiendo del mismo ejemplo anterior:

A X X X

B E X X X X X X

C E E E E E E E X X X X

D E E E E E E E E E X X X X X

E E X X

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Tme = (0 + 1 + 7 + 9 + 1) / 5 = 3.6 Tmr = (3 + 7 + 11 + 14 + 3) / 5 = 7,6

• SRTF: es una versión del STF, pero en este caso se asignará la CPU a aquel

proceso que le quede menos tiempo de CPU para ejecutarse. Es un algoritmo

expulsivo.

12


Partiendo del mismo ejemplo anterior:

A X X X

B E X E E E E E E X X X X X

C X X X X


E X X

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Tme = (0 + 7 + 0 + 9 + 0) / 5 = 3.2 Tmr = (3 + 13 + 4 + 14 + 2) / 5 = 7,2

• Round Robin: uno de los algoritmos más sencillo, justo y utilizado. No se

establecen prioridades, cada proceso tiene asignado un quantum de tiempo

durante el cual podrá ejecutarse, si se cumple ese tiempo y la tarea no ha

concluido, se da paso al siguiente proceso y el proceso no finalizado pasa al

final de la cola de preparados. Esta cola se gestiona con una cola FIFO.

El inconveniente es escoger un quantum adecuado, ni demasiado grande

porque degeneraría en FCFS, ni demasiado pequeño porque el coste en

cambios de contexto sería importante.

P2 P3 P4 P1

Partiendo del mismo ejemplo anterior con q = 2:

A X X E E X

B X X E E E X X E E E E E E X X

C E X X E E E E X X

D E E E X X E E E E E E X X X

E E E E E E X X

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Tme = (2 + 9 + 5 + 9 + 5) / 5 = 6 Tmr = (5 + 15 + 9 + 14 + 7) / 5 = 10

13


• Prioridades: cada proceso tiene asignada una prioridad, de forma que el

planificador selecciona el proceso con más prioridad de la cola de

preparados. Procesos con igual prioridad se seleccionan con FIFO. Existe

una versión expulsiva y otra no expulsiva. Expulsiva significa que si se está

ejecutando un proceso de prioridad media y entra un proceso de prioridad

mayor, se requisa la CPU al primer proceso y se la entrega al proceso de

mayor prioridad.

Las prioridades pueden ser estáticas o dinámicas, en función de si un proceso

mantiene o no la misma prioridad a lo largo de su vida.

Partiendo del mismo ejemplo anterior con prioridad mayor igual a 1,

expulsiva:

A X X E E E E E E E E X

B X X X X X X

C E E E E E E E X X X X


E X X

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

Tme = (8 + 0 + 7 + 9 + 0) / 5 = 4,8 Tmr = (11 + 6 + 11 + 14 + 2) / 5 = 8,8

• Cola multinivel: un algoritmo de planificación de colas de múltiples niveles,

divide la cola de procesos listos en diversas colas. Cada cola tiene su propio

algoritmo de planificación, por ejemplo una cola puede planificarse con un

algoritmo RR, mientras que otra puede planificarse con un algoritmo FCFS.

Debe existir además una planificación entre colas, la cual generalmente es

una planificación apropiativa o no expulsiva de prioridades fija.

Planificación de colas con realimentación significa que se permite que un

proceso se mueva de una cola a otra.

14


Este algoritmo de planificación es el utilizado por la mayoría de SO actuales.

A pesar de ser el esquema más general, también es el más complejo.

¿Cómo seleccionamos un algoritmo de planificación?

Como ya hemos visto, existen diversos algoritmos de planificación, cada uno

con sus propios parámetros, por lo que resulta difícil efectuar una selección. La forma

más sencilla de hacerlo es calcular los tiempos de espera (espera en la cola de

preparados), y los tiempos de respuesta (tiempo que transcurre desde que el proceso

entra en el sistema hasta que es capaz de proporcionarme un resultado), una vez

obtenidos los resultados comparamos los valores.

Ejercicios

i) Un sistema tiene los siguientes recursos: una CPU, dos discos y una

impresora. Existen dos tipos de trabajos según las necesidades de utilización

de los recursos:

• Tipo1: 13 unidades de tiempo repartidas del siguiente modo: 1 para

CPU, 3 para disco1, 2 para CPU, 6 para impresora y 1 para CPU.

• Tipo2: 16 unidades de tiempo repartidas del siguiente modo: 6 para

CPU, 1 para disco1, 3 para CPU, 2 para disco 2, 1 para CPU, 1 para

impresora y 2 para CPU.

Suponiendo que en el sistema hay un trabajo de cada tipo, calcular el tiempo

medio de respuesta en el sistema y el tiempo de espera para cada trabajo con

los siguientes algoritmos de planificación de la CPU:

• FCFS

15


• Prioridad expulsiva (mayor la del proceso 1)

• RR con quatum q = 1

ii) Dada la siguiente situación en un sistema de planificación con prioridades

expulsivas:

PROCESO LLEGADA CPU PRIORIDAD

A 0 8 5

B 3 4 7

C 6 2 9

D 10 3 8

E 15 6 1

F 17 4 5

Suponiendo que las prioridades son crecientes con su valor, obtener el

diagrama de ocupación de la CPU, el tiempo medio de retorno y el de espera

de los procesos.

iii) Suponiendo los siguientes procesos a ejecutar en el sistema:

PROCESO LLEGADA CPU

A 0 3

B 1 5

C 3 2

D 9 5

E 12 5

Se pide dibujar el diagrama de ocupación de la CPU, e indicar los tiempos

medios de respuesta y espera para las siguientes estrategias de planificación:

• RR con q = 2

• Colas multinivel con realimentación, donde cada cola se gestiona como

un RR de q = 2i, y la llegada de un proceso a una cola más prioritaria

nunca interrumpe la ejecución de un proceso.

16


Un proceso de una cola (i) pasa a pertenecer a otra cola (i + 1) cuando agota

su quantum q sin finalizar su ejecución. La cola por la que entran los

procesos nuevos es la 0, siendo esta la más prioritaria.

C1 q = 21 = 2

C2 q = 22 = 4

C0 q = 20 = 1

CPU

iv) Este algoritmo es una versión modificada del RR tradicional que da mejor

servicio a los procesos que ya se han ejecutado, durante un cierto periodo de

tiempo, que a los recién llegados.

La cola de preparados se divide en dos: una de procesos NUEVOS y otra de

ACEPTADOS. Se escoge siempre para ejecución un proceso de la cola de

ACEPTADOS, mediante una estrategia Round Robin con q = 1, y los

procesos que llegan al sistema se esperan en la cola de NUEVOS hasta que

pueden pasar a la de ACEPTADOS.

Cuando un proceso llega al sistema su prioridad es 0, y a cada unidad de

tiempo el algoritmo recalcula las prioridades para todos los procesos de la

forma siguiente:

• Si un proceso está en la cola de NUEVOS, se incrementa su prioridad en

2.

• Si un proceso está en la cola de ACEPTADOS, se incrementa su

prioridad en 1.

Cuando la prioridad de un proceso NUEVO se hace mayor o igual a la de

cualquier proceso de la cola de ACEPTADOS, el proceso NUEVO se inserta

en ella. En caso de que se vacíe la cola de ACEPTADOS, se introduce en

17


ella el proceso más prioritario de la cola de NUEVOS. Un proceso es más

prioritario cuanto mayor es su valor numérico asociado.

Suponiendo la siguiente situación:

PROCESO LLEGADA CPU

A 0 5

B 1 4

C 3 2

D 9 6

E 11 3

Representar el diagrama de ocupación de la CPU y calcular los tiempos

medios de espera y retorno en el sistema.

ACEPTADOS RR q = 1

NUEVOS

CPU

18


Sincronización y bloqueo entre procesos

Hasta ahora hemos hablado de procesos como entidades independientes:

• No comparten estado.

• Su ejecución es determinista, es decir la ejecución del mismo proceso con los

mismos datos produce los mismos resultados.

• Cada proceso avanza a un ritmo arbitrario.

Suele ocurrir en multiprogramación que varios procesos necesiten utilizar las

mismas variables de memoria, por ejemplo, estaremos hablando en ese caso de procesos

cooperantes.

Esta fase de ejecución del proceso es lo que se conoce como sección crítica:

aquella en la que el SO tiene que sincronizar los procesos para asegurar una ejecución

ordenada.

Ejemplo de sección crítica

19


Otro ejemplo puede ser un programa que accede a una variable de memoria y

modifica su contenido. Supongamos que ese programa necesitara ese valor

posteriormente. Si, entre tanto, la CPU asigna su tiempo de ejecución a un proceso

nuevo, y este necesita tomar el valor de esa misma variable para modificarlo, cuando el

primer proceso vuelva a ejecución no encontrará el valor deseado, y se producirán

conflictos y errores en la ejecución de los procesos.

El hecho de que dos o más procesos se ejecuten de forma concurrente, implica

que cada uno de ellos estará en un estado diferente. La sincronización implica que dos o

más procesos concurrentes no podrán utilizar los mismos recursos en el mismo instante

de tiempo. Por ello, algunos procesos estarán en ejecución mientras otros están

bloqueados. Por tanto, la sección crítica debe ejecutarse en exclusión mutua. La

exclusión mutua es un mecanismo por el que se asegura que sólo un proceso estará

haciendo algo en un instante determinado y los otros estarán excluidos. Para lograr la

exclusión mutua se usan algunas técnicas para lograr entrar a la sección crítica, como es

el caso de los semáforos.

Mecanismos de sincronización. Semáforos

Un semáforo S es una variable entera a la que, salvo por la asignación de valores

iniciales, sólo puede accederse mediante dos operaciones: reservar y liberar. A esto se le

puede añadir una cola de procesos para recordar el orden en que se hicieron las

peticiones.

Al principio del programa principal se inicializa la posición de memoria a 1. A

continuación, cada vez que un proceso quiera acceder a dicho recurso (por ejemplo, un

fichero), hará primero una petición para reservarlo. Cuando el SO ejecuta esa llamada,

comprueba el valor que hay en la posición de memoria del semáforo, y si es distinto de

cero, se limita a restarle 1 y devolver el control al proceso; sin embargo, si ya es cero,

duerme al proceso que hizo la petición y lo mete en la cola de suspendidos, en espera de

que el semáforo se ponga a un valor distinto de cero.

Por último, cuando el proceso ha terminado el acceso al recurso, realiza una

petición para liberar el semáforo. Cuando el SO la ejecuta, comprueba si la cola del

semáforo está vacía, en cuyo caso se limita a incrementar el valor del semáforo,

20


mientras que si tiene algún proceso, lo despierta, de modo que vuelve a recibir ciclos de

CPU y sigue su ejecución.

Interbloqueos

Un proceso dentro de un sistema de multiprogramación está en un estado de

interbloqueo si está suspendido en espera de un evento determinado que no ocurrirá.

Imagina dos procesos que desean imprimir un gran archivo situado en una cinta

al mismo tiempo. El proceso A solicita en uso exclusivo la impresora mientras el

proceso B solicita el uso exclusivo de la cinta. El proceso A no puede comenzar la

impresión porque no tiene acceso a la cinta, pero no libera la impresora. Mientras tanto,

el proceso B no inicia la impresión ya que no tiene acceso a la impresora, pero no libera

la apropiación de la cinta. Se dice que los procesos se han bloqueado y permanecerá así

para siempre, en un bucle de espera infinita, si el SO no se encarga de solucionarlo.

Los SO emplean distintas técnicas para enfrentarse al problema de los

interbloqueos:

• Detección y recuperación: los bloqueos se producen, pero el SO se encarga

de detectarlos y recuperarse de ellos.

• Prevención: se establecen determinadas reglas, a la hora de asignar los

recursos, con el fin de asegurar que no se produzcan interbloqueos.

• Predicción: asegura que no ocurre interbloqueo basándose en el

conocimiento de las necesidades futuras de los procesos. El problema es que

es difícil conocer el futuro.

• Algoritmo del avestruz: es decir, meter la cabeza bajo tierra e ignorar el

problema. Técnica utilizada en la mayoría de los SO, dada la baja

probabilidad de que ocurra el interbloqueo y el coste que conlleva evitarlo.

21


Gestión de memoria

Para ejecutar un proceso, éste debe cargarse en memoria. Generalmente el

proceso reside en disco como archivo binario ejecutable. El conjunto de procesos en

disco que esperan entrar en la memoria para ejecutarse integran la cola de entrada.

El procedimiento normal consiste en seleccionar uno de los procesos de la cola

de entrada y cargarlo en memoria. Una vez el proceso se ha ejecutado, el programa

termina y su espacio de memoria se libera, quedando disponible para otro proceso.

El propósito de este punto es presentar la gestión de memoria dentro de un SO.

La memoria es un dispositivo organizado en celdas de tamaño fijo (palabra), cada una

de las cuales tiene asignada una dirección. La labor del administrador de memoria es

llevar un registro de las partes de memoria que están siendo utilizadas y las que no, con

el fin de asignar espacio en memoria a los procesos que lo necesiten y liberarlo cuando

terminen. Además se encargará de controlar el intercambio entre la memoria principal y

el disco, siempre y cuando los procesos sean tan grandes que no quepan de una sola vez

en memoria.

Nos vamos a centrar en el estudio de las técnicas más usuales en el manejo de

memoria.

Asignación contigua

El esquema más sencillo de asignación de memoria, es aquel en el que sólo se

tiene un proceso en memoria en cada instante (SO monotarea). Se utiliza toda la

memoria y toda la potencia del procesador.

0

SO

PROCESO A

(300K)

...

512K 22


El SO reside en memoria baja y un proceso de usuario se ejecuta en memoria

alta, debemos proteger el código y los datos del SO frente a cambios (accidentales o

deliberados) provocados por el proceso de usuario. Esta protección debe ser

proporcionada por el HW.

Por motivos de utilización y tiempos de respuesta, vamos a trabajar con sistemas

multiprogramados, donde varios procesos pueden residir a la vez en memoria.

A su vez el esquema más sencillo de administración de memoria en un sistema

multiprogramado es la asignación contigua de particiones fijas o variables.

Particiones Fijas

Consiste en dividir la memoria reservada a los usuarios en particiones de tamaño

fijo. Cada partición puede contener exactamente un proceso. De esta forma, el nivel de

multiprogramación está limitado por el número de particiones.

El planificador tiene en cuenta los requerimientos de memoria de cada uno de

los procesos y las particiones de memoria disponibles. Si consideramos que todas las

particiones son del mismo tamaño, cuando un proceso desee ejecutarse, el SO busca una

partición libre y se la asigna. El principal problema es la fragmentación interna que se

produce cuando un proceso necesita una cantidad de memoria menor que el tamaño de

la partición, desaprovechando la diferencia.

SO

PROCESO A

(5K) Bloque 8K

Bloque 8K

Fragmentación Interna

PROCESO B

(8K)

...

Para minimizar el problema de la fragmentación interna, se puede dividir la

memoria en particiones variables e intentar asignar a cada proceso aquella partición que

menos fragmentación interna produzca.

23


Particiones Variables

En este esquema el SO mantiene una tabla que indica qué particiones de

memoria están libres y cuáles están ocupadas. Inicialmente toda la memoria está

disponible para los procesos de usuario, y se considera como un gran bloque de

memoria disponible. Cada vez que llega un proceso y necesita memoria, se busca un

hueco de tamaño suficiente para albergarlo. Si lo encontramos, sólo asignamos la

cantidad de memoria necesaria, quedando disponible el resto para satisfacer solicitudes

posteriores. Al llegar a este punto se comprobará si hay procesos esperando memoria y

si los hay buscar una partición para ubicarlos.

Por ejemplo, supongamos que tenemos 2560K de memoria disponible y un SO

residente de 400K. Esta situación deja 2160K para los procesos de usuario. Suponiendo

una planificación de trabajos FCFS y los siguientes procesos en la cola de entrada: P1

600K, P2 1000K, P3 300K, P4 700K, P5 500K. Los procesos se ubicarían en memoria

de la siguiente manera: 0 0 0 0 0 0

SO

SO

SO

SO

SO

SO

SO

400K 400K 400K 400K 400K 400K

FIN P1

P5

P5

P1

P1

P1

900K 900K 1000K 1000K 1000K 1000K 1000K 1000K

FIN P2

P4

P4

P4

P4

1700K 1700K 1700K 1700K

P2

2000K 2000K 2000K 2000K 2000K FIN P3

P3

P3

P3

P3

P3

2300K 2300K 2300K 2300K 2300K 2300K

2160K

24


Este ejemplo ilustra varios puntos. En general, en cualquier momento hay un

conjunto de huecos de distintos tamaños y dispersos por toda la memoria. Cuando llega

un proceso y necesita memoria, buscamos en este conjunto un hueco con el tamaño

suficiente para el proceso. Si el hueco es demasiado grande, se divide en dos: una parte

se asigna al proceso que llega y la otra se devuelve al conjunto de huecos. Cuando

termina un proceso, libera su bloque de memoria, el cual se coloca de nuevo en el

conjunto de huecos libres. Si el nuevo hueco es adyacente a otros, los fusionamos

formando uno mayor. Al llegar a este punto, como ya se ha dicho, necesitaríamos

comprobar si hay procesos esperando memoria y si esta nueva memoria liberada y

recombinada puede satisfacer las solicitudes de algunos de estos procesos.

Las estrategias más comunes para seleccionar una partición libre de un conjunto

de particiones disponibles son:

• Primer ajuste: asigna el primer hueco que tenga tamaño suficiente. La

búsqueda puede comenzar desde el principio o partir de la búsqueda anterior.

• Mejor ajuste: asigna el hueco más pequeño que tenga tamaño suficiente. Hay

que recorrer toda la lista a menos que se encuentre ordenada por tamaños.

• Peor ajuste: asigna el hueco más grande. Una vez más hay que buscar en

toda la lista, a menos que, como en el caso anterior, estén ordenados por

tamaño.

Las simulaciones han mostrado que tanto el primer ajuste como el mejor ajuste

son mejores que el peor ajuste en cuanto a la reducción del tiempo y de la utilización del

almacenamiento. Ni el primer ajuste ni el mejor ajuste son definitivamente superiores

uno respecto al otro en relación con la utilización del almacenamiento, pero por lo

general el primer ajuste es más rápido.

Este esquema produce fragmentación externa cuando el espacio de memoria

libre es suficiente para atender una solicitud pero no es contiguo, entonces habrá que

recurrir a la técnica de la compactación, que consiste en desplazar el contenido de la

memoria de forma que quede junta toda la memoria libre en un único bloque de gran

tamaño. Es importante destacar que la compactación sólo es posible si las direcciones se

relocalizan dinámicamente en el momento de la ejecución.

25


SO SO

PROCESO A

(5KB) PROCESO A

(3KB)

PROCESO B PROCESO B

(8KB)

(5KB)

PROCESO C

Fragmentación Externa

Compactación

Ejercicio: Consideremos un sistema con 4200 palabras de memoria principal, y

con un mecanismo de particiones variables. En un instante la memoria está

ocupada por 3 bloques de código/datos de la forma:

Dirección inicial Longitud

1000 1000

2900 500

3400 800

Cuando se carga un nuevo bloque en memoria, se utiliza la siguiente estrategia:

• Se busca el mejor ajuste.

• Si falla, se crea un hueco mayor desplazando los bloques de memoria hacia

la dirección 0. Esta acción siempre empieza con el bloque actualmente en la

dirección de memoria más baja, y prosigue únicamente hasta encontrar un

hueco suficiente para el nuevo bloque.

A partir de este momento, hay que cargar tres bloques de 500, 1200 y 200 (en

ese orden). Especificar el contenido de la memoria una vez satisfechas las

peticiones.

26


Solución: 0 0 0

P1

0

P1

1000

P4 1000

P4 1000

P1

1000

P1

2000

P4

1500

P5

1500

P5 2000

2500 2700 2700 P6

2900

P2 2900

P2 2900

P2 2900

P2

3400

4200

P3

3400

4200

P3

3400

4200

P3

3400

P3

4200

Asignación no Contigua

En este apartado se presentan las técnicas de paginación, segmentación y

segmentación paginada, técnicas que no requieren la asignación de un bloque contiguo

de memoria a un proceso, es decir, a un proceso se le pueda asignar memoria física

donde quiera que esta esté disponible.

Paginación

La paginación consiste en dividir la memoria física o RAM en bloques iguales

de tamaño fijo llamados marcos, y los programas en partes del mismo tamaño,

denominadas páginas. Cuando un proceso llega a ejecutarse se examina su tamaño,

expresado en páginas, y se comprueba si hay memoria disponible, es decir marcos no

asignados. Si hay tantos marcos libres como páginas tiene el proceso, se asignan y se

van registrando en la tabla de páginas.

27


0

1

2

3

Tabla páginas

1

4

3

7

Pag. Marco

Memoria física

Página 0

Página 1

Página 2

Página 3

01234567

Nº marco

Página 0

Página 1

Página 2

Página 3

Memoria lógica

Cada dirección generada por la CPU (dirección lógica) se divide en dos partes:

un número de página (p) y el desplazamiento dentro de la página (d). El número de

página se utiliza como índice en una tabla de páginas, que contiene la dirección base

para cada página, en memoria física. La dirección base se combina con el

desplazamiento para obtener la dirección física.

CPU p d m d

Memoria Física

m

Tabla de Páginas

Dirección Física Dirección Lógica

El tamaño de página, al igual que el tamaño de marco, viene definido por el HW.

Generalmente es una potencia de dos, lo que facilita la traducción de una dirección

lógica a un número de página y un desplazamiento. Si el tamaño de la página es de 2n

bits, los n bits de menor peso representan el desplazamiento en la página, y los bits

restantes el número de página.

Este esquema no produce fragmentación externa. Sin embargo se puede producir

fragmentación interna cuando un proceso no es múltiplo del tamaño marco/página, en

cuyo caso el último marco estará parcialmente vacío. Otra ventaja es la posibilidad de

compartir memoria entre varios procesos, cuando varias páginas apuntan a un mismo

marco.

28


Ejemplo: supongamos un tamaño de página de 4 palabras y una memoria física

de 32 palabras (8 páginas). La dirección lógica 0 es la página 0, desplazamiento 0. Al

usar el índice de la tabla de páginas, encontramos que la página 0 está en el marco 5.

Así, la dirección lógica 0 corresponde a la dirección física 20 (= (5 * 4 palabras) + 0).

La dirección lógica 3 (página 0, desplazamiento 3) corresponde a la dirección física 23

(= (5 * 4) + 3). La dirección lógica 4 corresponde a la dirección física 24 (= (6 * 4) +

0). La dirección lógica 13 corresponde a la dirección física 9.

Dir. Lógica Dir. Física

a b c d

e f g h

i j k l

m n o p

0 1 2 3

4 5 6 7

8 9

10 11

12 13 14 15

Memoria lógica

0

1

2

3

Tabla páginas

5

6

1

2

i j k l

m n o p

a b c d

e f g h

0

12

4

8

20

24

16

28

Memoria física

29


Segmentación

Se dividen los programas en bloques de tamaño variable llamados segmentos.

Las direcciones lógicas se descomponen en un número de segmento (s) y un

desplazamiento (d) dentro de él. El número de segmento se utiliza como índice en la

tabla de segmentos. Cada entrada de la tabla tiene una base (dirección de inicio del

segmento en memoria física) y un límite (longitud del segmento) para el segmento. El

desplazamiento de la dirección lógica debe estar entre 0 y el límite del segmento, si es

así se suma a la base del segmento para producir la dirección física.

CPU s d

Memoria Física

Límite

Tabla de Segmentos

Dirección Lógica

Base

< Si

No, error de direccionamiento

+

Ejemplo: tenemos cinco segmentos numerados del 0 al 4, que se almacenan en

memoria física tal como se muestra. La tabla de segmentos tiene una entrada separada

para cada segmento, proporcionando la dirección de inicio del segmento en la memoria

física (la base) y la longitud del segmento (el límite). Por ejemplo, el segmento 2 tiene

400 bytes de longitud y comienza en la localidad 4300 de modo que una referencia al

byte 53 del segmento 2 corresponde a la localidad 4300 + 53 = 4353. Una referencia al

segmento 3, byte 852, corresponde a 4052, la base del segmento 3200 + 852 =

4052.Una referencia al byte 1222 del segmento 0 generaría un error, ya que este

segmento sólo tiene 1000 bytes de longitud.

30


Segmento 0

Segmento 3

Segmento 2

Memoria física

Segmento 4

Segmento 1

0

1400

2400

3200

4300

4700

5700

6300

6700

Segmento 3

Segmento 4

Segmento 0

Segmento 1

Segmento 2

Límite Base

1000 400 400 1100 1000

1400 6300 4300 3200 4700

01234

Tabla Segmentos

Segmentación Paginada

Tanto la paginación como la segmentación tienen sus ventajas y desventajas,

esta técnica consiste en combinar las dos anteriores.

Surge ante el problema de tablas de segmentos muy grandes. La solución

consiste en paginar los segmentos. La diferencia entre esto y la segmentación pura está

en que la entrada de la tabla de segmentos no contiene la dirección base del segmento en

memoria física, sino la dirección base de una tabla de páginas para dicho segmento. El

desplazamiento en el segmento se divide en un número de página y un desplazamiento

en la página. El número de página se utiliza como índice en una tabla de páginas, a fin

de obtener el número de marco. Por último el número de marco se combina con el

desplazamiento para formar la dirección física.

31


CPU s d

Memoria Física

Límite segment

Tabla de Segmentos

Dirección Lógica

Base Tabla Pág +

Si

No, error de direccionamiento

≤p d’

m d’ m

Tabla de Páginas

Dirección Física

Memoria Virtual

El ordenador dispone de memoria central o principal, pero esta es limitada y, en

grandes sistemas, casi siempre insuficiente. El método diseñado por Fotheringan se

conoce con el nombre de memoria virtual. El diseñador consideró que el programa que

se iba a ubicar en memoria podría ser excesivamente grande para el tamaño físico de

esta, por tanto esta técnica permite ejecutar procesos que no están completamente

cargados en memoria. Permanece en memoria la parte del programa que se está

ejecutando, mientras el resto seguirá ubicada en el disco.

Si, en un momento dado, es necesario ejecutar una parte del programa que está

almacenada en memoria virtual (en el disco duro), esta pasará a memoria RAM para su

ejecución, y la parte del programa que estaba en memoria RAM se almacenará en el

disco duro.

Con esta técnica se consigue disponer, casi siempre, de RAM libre necesaria

para el propio procesador.

No obstante la memoria virtual no es fácil de implementar. Generalmente se

hace mediante la paginación por demanda, la segmentación por demanda también puede

usarse pero es más complejo debido a que los segmentos tienen tamaños variables.

32


Paginación por demanda

Cuando se quiere ejecutar un proceso se carga en memoria. Sin embargo en vez

de intercambiar todo el proceso hacia la memoria, se utiliza un paginador, que trata con

las páginas individuales de un proceso. El paginador adivina qué páginas se usarán, y

las cargará en memoria. Así evita colocar en memoria páginas que no se utilizarán,

reduciendo el tiempo de intercambio y la cantidad de memoria física necesaria.

Este esquema requiere que se añadan más bits a cada entrada de la tabla de

páginas: un bit válido-inválido. Cuando este bit está como válido, quiere decir que la

página se encuentra en memoria. La ejecución de un proceso continua normalmente

mientras se acceda a páginas residentes en memoria, en caso contrario se produce un

fallo de página y se ha de incorporar la nueva página a memoria desde el disco.

Algoritmo de Reemplazo de Páginas

Un algoritmo de reemplazo de páginas se activará cuando se produzca un fallo

de página y no exista en memoria ningún marco libre donde ubicar dicha página. En

esta situación habrá que seleccionar una página víctima, del conjunto de marcos de

memoria, extraerla y ubicar aquella que generó este fallo, cambiar la tabla de páginas y

reiniciar la ejecución. Si la página víctima fue modificada mientras estuvo en memoria,

se escribirá su contenido en el disco.

Existen muchos y diferentes algoritmos para el reemplazo de páginas, algunos

de los cuales se describen a continuación. En general se busca aquel que presente la

menor tasa de fallos de página.

• Algoritmo FIFO (First In First Out): primero en entrar, primero en salir. Es

el algoritmo de reemplazo de páginas más sencillo. Asocia a cada página el

instante de tiempo en el cual se trajo a memoria. Cuando hay que reemplazar

una página se escoge la más antigua. Su rendimiento no siempre es bueno.

• Algoritmo Óptimo: tiene la menor tasa de fallos de página de todos los

algoritmos. Consiste en reemplazar la página que no se usará durante el

mayor periodo de tiempo. Es un algoritmo teórico, pues exige conocer las

futuras referencias a páginas.

• LRU (Last Recently Used): este algoritmo reemplazará la página que no se

ha utilizado durante el mayor periodo de tiempo. Se asocia a cada página el

instante de tiempo en el que se utilizó por última vez.

33


Ejercicios

i) Un determinado SO gestiona la memoria virtual mediante la paginación por

demanda. La dirección lógica tiene 24 bits, de los cuales 14 indican el

número de página. La memoria física tiene 5 tramas. El algoritmo de

reemplazo de páginas es el LRU LOCAL, y se ha implementado mediante un

contador asociado a cada página que indica el instante de tiempo en que se

referenció la página por última vez.

Las tablas de páginas en el instante 16 son:

Proceso Página Bit válido Trama Contador

A

0

1

2

3

v

v

i

i

1

2

-

-

10

15

6

5

B

0

1

2

3

4

v

i

i

v

v

0

-

-

3

4

7

2

3

4

11

Indicar las direcciones físicas generadas para la siguiente secuencia de

direcciones lógicas (de izquierda a derecha y de arriba a abajo):

(A, 2900) (B, 1200) (A, 1850) (A, 3072) (B, 527)

(B, 2987) (A, 27) (A, 2000) (B, 4800) (B, 1500)

ii) En un determinado sistema con memoria virtual por paginación, una

dirección lógica consta de 16 bits, 10 de offset (desplazamiento) y 6 para el

número de página. Se dispone de 4 tramas. Dada la siguiente secuencia de

direcciones lógicas (ordenadas de izquierda a derecha):

512 1102 2147 3245 5115 5200 4090

4207 1070 6200 7168 8200 7200 8300

9300 7410 8525 9700 5300 4387 1007

34


Se pide:

• Dar la secuencia de referencias a páginas.

• Contar el número de fallos de página suponiendo los algoritmos de

reemplazo FIFO, LRU y ÓPTIMO.

iii) En un sistema paginado con 4 tramas en memoria, se hacen las siguientes

referencias a páginas:

{c, a, d, b, e, b, a, b, c, d}

Suponiendo que tenemos inicialmente en memoria las páginas {a, b, c, d}

(en ese orden), analícese el contenido en memoria para cada una de las

siguientes políticas de reemplazo:

• ÓPTIMO.

• FIFO.

• LRU.

iv) Sea un sistema de memoria virtual con paginación por demanda, en el que:

• Una dirección lógica consta de 12 bits, de los cuales 3 son para el

número de página.

• Una dirección física contiene 11 bits.

• Existen dos procesos (A y B), y toda la memoria física se reparte

entre estos dos procesos por igual.

• Se utiliza un algoritmo de reemplazo local de páginas LRU.

Dar para la siguiente secuencia de direcciones lógicas, el correspondiente

mapa de memoria:

(A, 1035) (B, 312) (A, 530) (B, 780) (A, 600)

(A, 2000) (B, 1400) (B, 927) (A, 1030) (A, 1720)

Hiperpaginación o Thrashing

Si el número de marcos asignados a un proceso desciende por debajo del número

mínimo requerido, se debe suspender la ejecución. Si el proceso no tiene este número de

35


marcos provocará fallos de página constantemente, teniendo que reemplazar páginas

que casi de inmediato se volverán a referenciar. A esta altísima actividad de paginación

se le llama hiperpaginación. Un proceso está en hiperpaginación si está más tiempo

paginando que en ejecución.

La hiperpaginación ocasiona severos problemas de rendimiento. Al aumentar el

nivel de multiprogramación, también aumenta la utilización de la CPU, aunque cada vez

con mayor lentitud hasta alcanzar un punto máximo. Si se incrementa más el nivel de

multiprogramación, comienza la hiperpaginación y la utilización de la CPU decae

rápidamente.

Los efectos de la hiperpaginación se pueden limitar utilizando un algoritmo de

reemplazo local. Con este tipo de reemplazo, si en un proceso comienza la

hiperpaginación, no puede robar marcos de otro proceso y provocar que éste también

entre en hiperpaginación. Las páginas se reemplazan considerando el proceso al cual

pertenecen. Sin embargo, si los procesos están en hiperpaginación, el tiempo de servicio

de fallo de página aumentará y por consiguiente, el tiempo de acceso aumentará incluso

para procesos que no estén en hiperpaginación.

Para evitar la hiperpaginación hay que ofrecer a un proceso todos los marcos

libres que necesite.

36


Archivo Pagefile.sys

Los SO Microsoft Windows, para realizar la gestión de la memoria virtual,

necesitan disponer de un espacio determinado en el disco duro. Concretamente, los

sistemas Microsoft recomiendan un archivo cuyo tamaño máximo y mínimo, viene

predeterminado por la cantidad de memoria RAM instalada en el sistema, siendo el

tamaño mínimo 1,5 veces la RAM física instalada y 3 veces para el tamaño máximo, de

tal manera que si nuestro PC tuviera 1 MB de RAM física instalada, el tamaño mínimo

del archivo de intercambio sería de 1,5 MB y el máximo de 3MB.

La memoria virtual se implementa en un archivo del sistema llamado

pagefile.sys, se crea en el momento de la instalación de Windows en la unidad raíz

(normalmente C:\) donde se encuentra el boot del sistema y sus atributos son de oculto.

Para comprobar que lo tenemos instalado, podemos hacerlo usando el explorador

de Windows siempre y cuando tengamos desactivada la opción "Ocultar archivos

protegidos del sistema", buscamos por “pagefile.sys” y aparecerá instalado. También

podemos comprobar que está instalado, si en una sesión iniciada en modo administrador

del sistema pulsamos en: (Inicio / Panel de Control / Sistema / Opciones Avanzadas /

Configuración (en la casilla rendimiento) / Opciones Avanzadas) o (Mi PC /

Propiedades / Opciones Avanzadas / Configuración (en la casilla rendimiento) /

Opciones Avanzadas) y aparecerá el tamaño mínimo del archivo y una opción para

cambiar el tamaño del mismo.

¿Cuándo se debe cambiar el tamaño y ubicación del archivo “pagefile.sys”?

Se recomienda modificar este valor en los siguientes casos:

• Cuando añadimos más memoria a nuestro PC con posterioridad a la

instalación de Windows XP.

• Cuando añadimos otro disco duro con posterioridad a la instalación de

Windows XP, o ya lo teníamos instalado pero no se tuvo en cuenta en el

momento de instalar Windows XP.

• Cuando tenemos un PC o Portátil que da errores de memoria virtual baja.

37


Si no nos encontramos en ninguno de estos casos es recomendable no modificar

el tamaño del archivo, ya que Windows XP escoge el valor más adecuado en el

momento de la instalación. Lo que sí es recomendable es instalar este archivo en otra

unidad de disco duro.

Ejercicio: localiza el fichero pagefile.sys, a partir del tamaño del mismo,

determina la cantidad de memoria RAM disponible en tu sistema.

¿Cómo crear y eliminar un archivo pagefile.sys?

En la parte de arriba aparecen listadas las unidades de disco disponibles.

• Eliminar un archivo Pagefile.sys:

o marcar la unidad, seleccionar la opción Sin archivo de paginación y

finalmente click en el botón "Establecer". Windows quitará el archivo

de la unidad seleccionada en el siguiente reinicio.

o Otra opción: Herramientas administrativas / Directivas de seguridad

local / Apagado: borrar el archivo de páginas de la memoria virtual

(Habilitado).

38


• Crear un archivo Pagefile.sys: marcar la unidad, seleccionar la opción

Tamaño administrado por el sistema y finalmente click en el botón

"Establecer". Windows creará el archivo en la unidad seleccionada en el

siguiente reinicio.

Nota: No se recomienda establecer un tamaño personalizado manualmente, a menos que

sepas lo que haces.

¿El sistema puede funcionar sin un archivo pagefile.sys?

SÍ, si el sistema posee la suficiente memoria RAM como para no preocuparse

cuando se estén ejecutando el máximo de aplicaciones y realizando la mayor cantidad

de tareas en un día de máximo trabajo.

Lo recomendable es NO dejar el sistema sin ningún archivo pagefile.sys, el

sistema puede llegar a necesitar algo de memoria extra en algún momento, y al no poder

usar la memoria virtual quizás pueda provocar algún tipo de crash (congelamiento) del

sistema. Muchas cosas dejarán de funcionar si lo eliminamos y muchos fabricantes

crean software basándose en que dicho archivo existe en el disco duro, y además

Windows XP no utiliza el archivo hasta que lo necesita con lo que no se obtiene ningún

beneficio eliminándolo.

Nota: En Windows 2000, si NO existe archivo de paginación, salde una ventana de

aviso en cada reinicio.

¿En qué sistemas Windows debería aparecer el archivo pagefile.sys?

En Windows 2000, XP y 2003. En Windows 98 y ME, el archivo de intercambio

se llama win386.swp. Sus funciones son las mismas que el pagefile.sys.

Gestión de memoria en Unix/Linux

En SO como UNIX y Linux, también se utiliza el esquema de Memoria Virtual

para la gestión de memoria. La diferencia fundamental respecto a Windows es que

Linux reserva una partición del disco, independiente de la partición donde está ubicada

el SO y las aplicaciones a ejecutar, en lugar de un archivo. Los fabricantes de éstos SO

39


recomiendan que esta zona sea del 20%, aproximadamente, del espacio del disco o el

doble de la capacidad de memoria RAM.

Con la gestión de memoria virtual, en Windows, puede llegar a ocurrir que el

disco duro esté tan lleno que la gestión sea difícil o imposible, ya que el espacio

destinado al intercambio suele ser espacio del disco duro en el que está instalado tanto

el SO como el SW de aplicaciones y los datos del usuario. En Unix/Linux no puede

ocurrir esto, ya que esta zona siempre estará disponible para el intercambio de

programas con la memoria principal. Normalmente al estar esta zona en un dispositivo

diferente, todo el espacio estará disponible cada vez que se encienda el ordenador.

Protección de memoria

La protección del SO es una tarea que el SO tiene que realizar para que en

ningún momento se solapen unos procesos con otros en la memoria física del

ordenador.

Esta protección se realiza normalmente por HW mediante los registros base y

límite. Mediante la información contenida en estos registros, pueden cargarse en

memoria las instrucciones correspondientes a los programas sin miedo a que ocupen

bloques físicos en los que se encuentran almacenadas otras instrucciones.

40


Gestión de dispositivos de E/S

Una de las funciones más importantes y compleja que realiza el SO es la

destinada a manejar los diferentes periféricos existentes. Debe enviar órdenes a los

dispositivos, determinar el dispositivo que necesita la atención del procesador, eliminar

posible errores, detectar interrupciones, etc.

Los dispositivos de E/S se componen de una parte mecánica y una parte

electrónica. Por ejemplo, un disco duro estará compuesto por los propios discos de

aluminio recubiertos de material magnético, las cabezas de lectura, el motor que los

hace girar, etc., y por la denominada controladora del dispositivo, componente HW

encargado de conectar físicamente el periférico a la placa base del ordenador para

establecer la comunicación. En la unidad dedicada al HW, se describen detenidamente

los tipos de controladoras atendiendo al tipo de periférico, la velocidad, la capacidad,

etc.

IMPRESORADISCO 1 DISCO 2

CONTROLADOR DISCO

CONTROLADOR IMPRESORA

El CPU MEM OTROS

CONTROLADORES …

Las controladoras o adaptadores necesitan un pequeño SW para que exista

comunicación entre el periférico y el microprocesador. Este SW, llamado controlador o

driver, se encarga de realizar funciones de traducción entre el periférico y el ordenador

para que ambos se entiendan. Los controladores suelen suministrarlos los fabricantes de

periféricos en disquetes o CD-ROM y suelen estar diseñados para varios SO; así el

mismo periférico se puede utilizar en un SO Windows o en uno Unix, dependiendo de

la controladora que se instale.

El SO se encarga de acceder a la información de la memoria principal, extraerla

en forma de impulsos eléctricos y enviarla a los diferentes dispositivos periféricos. Si la

información se envía a un disco duro, los impulsos se transforman en señales de tipo

magnético; si se envía a una impresora, se transformará en caracteres, etc.

41


Técnicas de transferencia

Muchos controladores, en particular los correspondientes a dispositivos de

bloque, permiten el Acceso directo a memoria (DMA). El objetivo del DMA es solapar

operaciones de CPU y E/S. La CPU proporciona al controlador información sobre la

dirección de memoria a la que desea acceder y el número de datos a transferir. Una vez

realizada la petición, la CPU se despreocupa momentáneamente de la transferencia y

continúa realizando otras tareas. El controlador va copiando datos del disco y

copiándolos en la memoria, una vez realizada la transferencia el controlador provoca

una interrupción que hace que la CPU abandone el trabajo que está realizando.

CPU

MEM

Cue

nta

BUFFER

REGISTROS DMA

DIR. DE MEM

CUENTA

42


Gestión del sistema de ficheros

Una vez procesada la información, ésta tiene que almacenarse de forma

permanente en los soportes externos de almacenamiento, respetando una serie de

normas y restricciones. Estas normas y restricciones vienen impuestas por el sistema de

archivos implementado. El sistema de archivos determinará la estructura, el nombre,

forma de acceso, uso y protección de los archivos que se guardarán en el disco.

Cada SO utiliza su propio sistema de archivos diferente, pero el objetivo y

función de todos ellos es el mismo: permitir al usuario un manejo fácil y lógico de sus

archivos abstrayéndose de las particularidades de los dispositivos físicos empleados.

Cada uno de ellos hace una gestión diferente del espacio de almacenamiento, lo cual

dependerá de si el sistema es monousuario o multiusuario, monotarea o multitarea,

monoproceso o multiproceso, etc.

Nombre de los archivos

Los archivos son la forma de almacenar información en el disco y poder volverla

a leer más adelante sin que el usuario tenga que preocuparse por la forma y lugar físico

de almacenamiento de la información, así como del funcionamiento real del disco.

Una característica muy importante es la forma de nombrar los archivos. Las

reglas para nombrar los archivos dependen del SO.

El SO DOS sólo admitía nombres de ocho caracteres como máximo; Unix, de

hasta once; Windows de hasta 256. Unos diferencian entre mayúsculas y minúsculas

(Unix), y otros no lo hacen (DOS). La mayoría de ellos utilizan nombres de archivo con

dos partes, separadas por un punto: nombre.extensión (tres caracteres).

Las extensiones se deben incluir en los nombres de archivo, ya que con ellas es

posible diferenciar rápidamente el tipo de archivo del que se trata. Algunas de las más

usuales en SO actuales son las siguientes:

• .TXT, archivos de texto sin formato.

• .BAS, archivos de Visual Basic.

• .BIN, archivos binarios.

43


• .DOC, archivos de Microsoft Word.

• .BMP, archivos de mapa de bits (gráficos).

• .JPG, archivos gráficos.

• .SYS, archivos de sistema.

• .DLL, bibliotecas del sistema.

• .OBJ, archivos objeto (de compilación).

• .EXE, ficheros ejecutables (aplicaciones).

• .COM, ficheros ejecutables (del sistema).

• .BAT, ficheros de procesos por lotes.

Tipos de archivos

Los archivos que gestiona un sistema operativo se clasifican en dos grandes

bloques:

• Archivos regulares o estándares, son los que contienen información del

usuario, programas, documentos, texto, gráficos, etc.

• Directorios, son archivos que contienen referencias a otros archivos o a otros

directorios. Este tipo de archivos se utiliza, únicamente, para albergar

estructuras de archivos con el fin de diferenciarlos de otros. Todos los SO

utilizan la estructura jerárquica para almacenar sus archivos. Por ello se

crean bloques (directorios) o compartimentos especiales para tener todos los

archivos bien clasificados: directorios para archivos de sistema, directorios

para archivos gráficos, etc.

En casi todos los SO existe un directorio principal, llamado raíz, del que

depende el resto de directorios o subdirectorios y la totalidad de archivos, si

bien hay excepciones, como el SO OS/400 de IBM, que no dispone de él.

• Archivos especiales: se utilizan para gestionar la entrada y salida de archivos

hacia o desde los periféricos. Son los que hemos llamado controladores.

Cada fichero/directorio se puede referenciar de dos maneras:

• Ruta absoluta: camino desde la raíz + nombre.

• Ruta relativa: camino desde el directorio actual + nombre.

44


Atributos de los archivos

Los atributos de los archivos constituyen la información adicional, además de la

que ya contienen, con la que cada archivo queda caracterizado. Además, quedan

identificadas las operaciones que se pueden realizar sobre él. Los atributos indican

cuestiones tales como nombre, hora de creación, fecha de creación, longitud, protección,

contraseña para acceder a él, fecha de actualización, etc.

De ellos, los más importantes, son los que indican qué tipo de operaciones o qué

tipo de usuarios pueden usar los archivos.

Dependiendo del tipo de SO utilizado, los atributos de protección son de mayor

o menor importancia. Ya veremos cómo cada SO tiene sus particularidades en este

aspecto.

Los atributos de protección pueden ser, de forma genérica, los siguientes:

• Sólo lectura: el archivo se puede leer, pero no se puede modificar.

• Oculto: el archivo existe, pero no se puede ver.

• Modificado: si el archivo es susceptible de modificarse o no.

• Sistema: si es un archivo de usuario o propio del SO.

Los atributos de protección dependerán del tipo de operación que se pueda

realizar sobre ellos. Las operaciones que se pueden realizar sobre un archivo son varias:

crear, eliminar, abrir, cerrar, leer, escribir, agregar, buscar, renombrar, etc.

45


Sistemas de archivos

El aspecto clave de la implementación del almacenamiento de archivos es el

registro de los clusters asociados a cada archivo. Una vez más, cada sistema de archivos

implementa métodos distintos para solucionar este problema.

Un clúster está compuesto por un determinado número de sectores que se

asocian a un único archivo. Un archivo, por tanto, se almacena en uno o más clusters de

sectores.

Un aspecto muy importante es la elección del tamaño del clúster, para esto hay

que entender que si el tamaño del clúster es muy grande, aún cuando el archivo sea de

un tamaño muy pequeño, se le asignará el clúster entero con el que se desperdiciará gran

parte de la capacidad del disco.

Por otra parte, si el tamaño del clúster es demasiado pequeño para almacenar un

archivo, harán falta muchos bloques con los que se producirá un retraso en la lectura del

archivo, al tener que localizar el disco todos los clusters que componen dicho archivo.

Una vez más, se ha de llegar a una solución de compromiso, eligiendo un tamaño de

clúster suficientemente pequeño para no desperdiciar capacidad de disco, pero

suficientemente grande como para no ralentizar en exceso la lectura de los archivos.

Diversos estudios realizados, indican que el tamaño medio de los archivos en sistemas

Unix y MS-DOS ronda el 1KB, así pues, son adecuados tamaños de bloque 512B, 1KB

o 2KB.

Si se elige un tamaño de clúster de, por ejemplo, 2KB en un disco cuyo sector

tiene 512B, cada clúster estará compuesto por cuatro sectores.

Para manejar los clusters asociados a cada archivo, se pueden utilizar varias

técnicas:

• Asignación contigua: consiste en almacenar los archivos mediante clusters

adyacentes en el disco (de esta forma, en el directorio únicamente se tendrá

que guardar la dirección en la que comienza el primer clúster, ya que los

demás se encuentran a continuación).

Su gran ventaja es su fácil implementación, pero tiene el gran problema de

que es necesario conocer con anterioridad el número de clusters que ocupará

46


el fichero y esto, en general, no ocurre. Además produce una gran

fragmentación del disco, que produce pérdida de espacio.

• Asignación enlazada: está técnica solventa algunas de las carencias de la

asignación contigua. El directorio contiene la dirección del primer clúster y

cada clúster contiene, a su vez, la dirección del siguiente o el valor null

(nulo) en caso de que sea el último del fichero. Con esta técnica se consigue

aprovechar todos y cada uno de los clusters del disco.

Como inconvenientes se pueden citar: cada clúster pierde parte de su

capacidad (ya que se ha de reservar un espacio para contener la dirección

del siguiente) y el retardo que se produce en la lectura del archivo al tener

que leer todos los anteriores antes de llegar a uno determinado. Si se pierde

un clúster se pierde todo el archivo.

• Asignación indexada: intenta eliminar los defectos de la anterior. En esta

técnica se crea una tabla por cada uno de los clusters del disco, en cada

registro se indica si dicho clúster está libre (null) o cuál es la dirección del

siguiente. De esta forma, en el directorio se asocia con el nombre del archivo

el número de clúster en el que comienza dicho archivo; con este datos y

mediante la tabla, se puede averiguar la dirección de todos los clusters que

componen dicho archivo simplemente siguiendo la lista ligada.

Con esta organización, todo el clúster estará disponible para los datos.

Además el acceso a un determinado clúster es mucho más rápido, ya que

aunque también haya que seguir la cadena de clusters, al estar la tabla en

memoria, estas consultas son mucho más rápidas y no es necesario acceder

a disco.

La desventaja que tiene este método es que toda la tabla de registros deberá

estar en la memoria principal permanentemente, con lo que la memoria

47


consumida para almacenar la tabla no estará disponible para ser usada por

otros procesos.

Esta es la técnica utilizada por MS-DOS y algunos sistemas Windows. En este

caso, a la tabla de registros se la denomina FAT (File Allocation Table, Tabla de

asignación de archivos) y se puede encontrar en sus dos versiones: FAT 16 y FAT 32,

dependiendo de si los clusters se direccionan con 16 o 32 bits respectivamente.

El sistema de archivos FAT funciona como el índice de un libro; en la FAT se

almacena información sobre dónde comienza el archivo, es decir, en qué posición del

disco está la primera parte de éste, y cuánto espacio ocupa, entre otras cosas. Este

sistema de archivos ha evolucionado a medida que lo han hecho las versiones de SO

como DOS y Windows.

Ejemplo: ejemplo de funcionamiento de lectura de un fichero en MS-DOS.

48


Supongamos que un usuario solicita leer el fichero prueba.txt. En ese caso, el

SO leerá el directorio activo (ya que se trata de una ruta relativa) en busca de la

entrada correspondiente a dicho archivo. Si éste existe, se encontrará un registro con

cierta información relativa a dicho archivo (como son los atributos del archivo y,

también, el clúster del disco en el que el archivo comienza). Con dicha información se

busca en la FAT, que se encuentra en la memoria principal, el registro perteneciente a

ese clúster y en él se encontrará la dirección del siguiente clúster en el que el archivo

está escrito. Repitiendo esta operación hasta que la dirección del siguiente clúster sea

0, obtenemos la lista completa de bloques en los que el archivo está almacenado.

Por último, los SO como Unix/Linux utilizan un sistema de archivos basados en

i-nodos. En esta técnica se asocia a cada archivo una pequeña tabla, llamada i-nodo, que

contiene los atributos y direcciones en disco de los clústers del archivo.

Atributos

Dirección clúster 1




...

Dirección clúster n

Las últimas entradas del i-nodo se reservan para cuando el archivo ocupa más

clusters de los que el i-nodo es capaz de almacenar, y pueden contener la dirección de

otro clúster en el que se guardan las demás direcciones de los clusters del archivo. A

este clúster se le llama clúster indirecto.

49


Cuando Unix/Linux abre un archivo, lo primero que hace es cargar en memoria

su i-nodo correspondiente para que el proceso sea lo más rápido posible.

Tipos de sistemas de archivos

FAT 16 y FAT 32

Tabla de Asignación de Archivos (File Allocation Table - FAT) es un sistema de

ficheros desarrollado para MS-DOS y utilizado en posteriores ediciones de Microsoft

Windows hasta Windows Me.

Sus principales ventajas son:

• Es relativamente sencillo. A causa de ello, es el formato para disquetes,

tarjetas de memoria y dispositivos similares.

• Admitido prácticamente por todos los SO existentes en la actualidad.

• Se utiliza como mecanismo de intercambio de datos entre SO distintos que

coexisten en el mismo ordenador, como por ejemplo Windows y Linux.

Supongamos el siguiente esquema de particionamiento en disco:

Windows (NTFS) Datos (FAT16 ó 32) Linux (ReiserFS)

o Desde Windows y Linux podremos leer y escribir en Datos.

o Desde Linux sólo podremos leer de Windows (por utilizar NTFS).

Las implementaciones más extendidas de FAT tienen algunas desventajas:

• Cuando se borran y se escriben nuevos ficheros tiende a dejar fragmentos

dispersos de estos por todo el soporte. Con el tiempo, esto hace que el

proceso de lectura o escritura sea cada vez más lento. La denominada

desfragmentación es la solución a esto, pero es un proceso largo que debe

repetirse regularmente para mantener el sistema de ficheros en perfectas

condiciones.

• Inicialmente solamente soportaba nombres cortos de fichero: ocho caracteres

para el nombre, más tres para la extensión.

• Carece de permisos de seguridad: cualquier usuario puede acceder a

cualquier fichero.

Una vez conocidas las ventajas y desventajas vamos a centrarnos en el estudio

de su funcionamiento. 50


El sistema de archivos FAT se compone de tres secciones:

• La región FAT: contiene dos copias de la tabla de asignación de archivos

(por motivos de seguridad). Esto son mapas de la partición, indicando qué

clusters están ocupados por los ficheros.

• La región del directorio raíz: es el índice principal de carpetas y ficheros.

• La región de datos: es el lugar donde se almacena el contenido de ficheros y

carpetas. Por tanto, ocupa casi toda la partición.

Partición 1 (Sistema de Archivos FAT) Partición 2

Región FAT

Región del Directorio Raíz

Región de Datos

Veamos cada una de ellas con más detalle.

Tabla de asignación de ficheros Una partición se divide en un conjunto de clusters1 de idéntico tamaño. La tabla

de asignación de archivos tiene una entrada para cada cluster del disco, donde se

almacena la siguiente información:

• La dirección del siguiente clúster en la cadena.

• Un carácter especial para indicar que el clúster es defectuoso.

• Un carácter especial para indicar que el clúster está reservado, es decir,

ocupado por un fichero (supongamos el número 1).

• El número cero para indicar que el clúster está libre.

¿Cuántas entradas tendrá la tabla FAT?

El número máximo de clusters posible depende de la variante de FAT en uso:

FAT16 usa entradas de 16 bits y FAT32 de 32 bits. El número máximo de entradas que

podemos tener es: FAT 32FAT 16

0

1

2

3

...

n

0

1

2

3

...

n

16 bits 32 bits1 Un cluster es una agrupación de sectores (unidad mínima del disco) y es la mínima cantidad de datos que recupera un SO, además es potencia de 2, es decir un cluster pueden ser 1, 2, 4, 8, 16 ... sectores.

51


• 216 = 65536 clusters para FAT16.

• 232 = 4.294.967.296 clusters para FAT32.

El directorio raíz Este índice es un tipo especial de carpeta que almacena las subcarpetas y

ficheros que componen cada carpeta de la región de datos. Cada entrada del directorio

contiene:

• Nombre del fichero o carpeta: máximo 8 caracteres.

• Extensión (sólo si se trata de ficheros): máximo 3 caracteres.

• Atributos, indican si se trata de :archivo, carpeta, oculto, del sistema.

• Fecha y hora de creación.

• Dirección del primer cluster donde están los datos.

• Tamaño que ocupa.

Región de datos Donde se almacena los ficheros. Cada fichero ocupa un número entero de

clusters (uno o más). El tamaño de cualquier archivo o carpeta puede ser ampliado

siempre que queden suficientes clusters libres. Si un determinado cluster no se ocupa

por completo, su espacio restante se desperdicia.

Por ejemplo, supongamos un cluster de 32 KB y con el Notepad

hemos creado un documento que sólo tiene la palabra "hola" (4 bytes de

longitud), nos da igual, en el disco esto ocupa físicamente 32 KB,

desperdiciando el espacio restante.

De esto se deduce que cuanto más pequeño sea el cluster, menos espacio

desperdiciamos. Es más, lo ideal es que el cluster sea justo lo mínimo que físicamente

podemos obtener, es decir un sector (512 bytes).

De forma general un fichero queda representado por un conjunto de clusters, no

necesariamente adyacentes. Esto es lo que provoca la fragmentación.

F1 F1 F1 F1 F1 F1 F1

52


Ventajas de FAT16:

• Mediante una pequeña tabla (máximo de 65535 entradas) tenemos accesibles

todos los cluster. Sabemos si están libres u ocupados, etc.

Inconvenientes de FAT16:

• Se desperdicia mucho espacio.

• Soporta discos o particiones de hasta 2GB.

La solución a este inconveniente es FAT 32.

Ventajas de FAT32:

• Se desperdicia mucho menos espacio.

• Prácticamente ya no hay un límite para el tamaño de la partición. Sopota

discos o particiones hasta 2TB.

Inconvenientes de FAT32:

• Mayor tamaño de la tabla, se tarda más tiempo en buscar en ella.

• Para optimizar los accesos se debería cargar en memoria RAM, ocupando un

espacio importante.

NTFS

NTFS (New Technology File System) es un sistema de archivos diseñado

específicamente para Windows NT, con el objetivo de crear un sistema de archivos

eficiente, robusto y con seguridad incorporada (Listas de Control de Acceso2) desde su

base. También admite compresión nativa de ficheros, encriptación (esto último sólo a

partir de Windows 2000 – Propiedades del objeto/Opciones Avanzadas) y Active

Directory (necesario cuando se trabaja con dominios).

NTFS permite definir el tamaño del clúster, a partir de 512B (tamaño mínimo de

un sector) de forma independiente al tamaño de la partición.

Es un sistema adecuado para las particiones de gran tamaño. Puede manejar

discos de hasta 2 TB.

2 Lista ordenada de todos los usuarios que pueden acceder al objeto (archivo, carpeta, ordenador, etc.) y sus permisos de acceso. (Se verá en profundidad en temas posteriores).

53

http://es.wikipedia.org/wiki/Sistema_de_archivos

http://es.wikipedia.org/wiki/Windows_NT

http://es.wikipedia.org/wiki/Windows_2000

http://es.wikipedia.org/wiki/Cl%C3%BAster_%28sistema_de_archivos%29

http://es.wikipedia.org/wiki/Partici%C3%B3n


Los inconvenientes que plantea son:

• Necesita para sí mismo una buena cantidad de espacio en disco duro, por lo

que no es recomendable su uso en discos con menos de 400 MB libres.

• No es compatible con MS-DOS, Windows 95, Windows 98 ni Windows Me.

Es decir, desde SO con sistemas de archivos FAT no se puede acceder a

particiones NTFS.

• No puede ser utilizado en disquetes.

• La conversión a NTFS es unidireccional. Si se decide actualizar la unidad,

volver a convertirla a FAT puede acarrear serios problemas

• GNU/Linux sólo tiene soporte de lectura para este sistema de ficheros, y de

escritura experimental, aunque no se suele activar por defecto (ya se ha

comentado anteriormente).

En NTFS, los nombres de archivo son almacenados en Unicode, y la estructura

de ficheros en árboles-B, una estructura de datos compleja pero eficiente, que acelera el

acceso a los ficheros y reduce la fragmentación, que era una de las lacras más criticadas

de los sistemas FAT.

Otra característica fundamental es que incorpora journaling. Cuando se tiene un

sistema de archivos "Histórico", cualquier transacción de disco que resulte en cambios

en la unidad (cualquier operación que no sea una lectura) se guarda en un log en un

archivo histórico.

Este log guarda información acerca de los cambios. Si se trabaja con Bases de

Datos, el histórico es como una lista de tareas por hacer. Periódicamente las tareas

hechas son marcadas como terminadas y borradas del archivo histórico (esto es

necesario para evitar enormes archivos históricos.)

La operación de guardar al archivo histórico supone un exceso de trabajo a las

escrituras al disco. La "magia" del sistema histórico ocurre cuando el sistema se cuelga

o hay que reiniciar de alguna manera diferente a la normal. En esos casos, el sistema

54

http://es.wikipedia.org/wiki/FAT

http://es.wikipedia.org/wiki/GNU


considera al disco "sucio" o en un estado desconocido, así que el disco ha de ser

revisado en el reinicio. Esto puede tomar varios minutos en un disco de 40 ó 60 GB,

pero si tienes un RAID interno o externo de varios cientos de GB o ya en el rango de los

TB, esta revisión puede tomar horas mientras se revisa el sistema de archivos, incluso

cuando todo el disco no está dañado.

Si el sistema histórico está activado, la revisión es mucho más eficiente. El

archivo histórico es recreado y la información guardada en este archivo se usa para

revisar sólo ciertas partes del disco que se encuentran en un estado incierto, y efectuar

las reparaciones en función de la información guardada en este archivo. Así en vez de

verificar un sistema con 600 GB en busca de daños, sólo las últimas escrituras a disco

sin realizar son revisadas. Sería en este caso como disponer de una lista de errores como

si fuera una guía, en vez de tener que buscarlos "a mano". Esto supone que las

reparaciones después de una colgada son mucho más rápidas.

Para terminar con este apartado comentar que los detalles de la implementación

de este sistema de archivos permanecen en secreto, de manera que los fabricantes y

distribuidores ajenos a Microsoft encuentran serias dificultades para proveer

herramientas que manejen NTFS, a pesar de lo cual existen varios proyectos de distintos

grados de madurez que permiten acceder para lectura e incluso escritura a particiones

NTFS desde GNU/Linux, y otros SO compatibles con este.

Ext2

(Second Extended Filesystem o Segundo Sistema de Archivos Extendido) fue el

sistema de archivos estándar en el SO GNU/Linux por varios años. La principal

desventaja de Ext2 es que no implementa el Registro por Diario o Journaling, que sí

soportan su sucesores ext3, ext4 u otros sistemas de ficheros como ReiserFS de Suse

hoy ya no en uso.

55

t3 introducción a los so

Documents