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:
Escogido por el Planificador

Salida
Preparado Ejecución Terminado
Interrupción
E/S o evento completado E/S o esperando un evento
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
CPU
Recursos
Cola de procesos esperando 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.
P4 P3 P2 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.
C0 Æ q = 20 = 1
C1 Æ q = 21 = 2 CPU
C2 Æ q = 22 = 4
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.
NUEVOS
ACEPTADOS RR q = 1 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
Fragmentación Interna
PROCESO B
Bloque 8K (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
P4 P4 P4 P4
2160K FIN P2
P2
1700K 1700K 1700K 1700K
2000K 2000K 2000K 2000K 2000K

FIN P3
P3 P3 P3 P3 P3
2300K 2300K 2300K 2300K 2300K 2300K
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
PROCESO A
(5KB)
(3KB) Fragmentación
Externa
PROCESO B
PROCESO B
(8KB)
PROCESO C
(5KB) 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 0
P1 P1
1000 1000 1000 1000
P4 P4
1500 1500
P1 P1
2000 2000
P5 P5
P4
2500
2700 2700
P6
2900 2900 2900 2900
P2 P2 P2 P2
3400 3400 3400 3400
P3 P3 P3 P3
4200 4200 4200 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
Pag. Marco Nº marco

0
0 1
Página 0 1 Página 0
1 4
Página 1 2
2 3
3 7
Tabla 5
Memoria páginas
lógica 6
7 Página 3
Memoria
física
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.
Dirección Lógica Dirección Física
CPU p d m d
Memoria
Física
Tabla de Páginas
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

0 a 0 5 0
1 b
1 6
2 c
3 d 2 1
4 e 3 2 4 i
5 f j
6 g Tabla k
7 h páginas l
8 i 8 m
9 j n
10 k o
11 l p
12 m 12
13 n
14 o
15 p
Memoria 16
lógica
20 a
b
c
d
24 e
f
g
h
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.
No, error de direccionamiento

Dirección Lógica
Si
<
CPU s d +
Memoria
Física
Límite Base
Tabla de Segmentos
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
1400
Segmento 0
2400
Segmento 3
Segmento 0 Límite Base
0 1000 1400
1 400 6300
3200
2 400 4300 Segmento 3
Segmento 4 3 1100 3200
4 1000 4700
Tabla 4300
Segmento 1 Segmentos Segmento 2
4700
Segmento 2 Segmento 4
5700
6300
Segmento 1
6700
Memoria
física
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
No, error de direccionamiento

Dirección Lógica
≤ Si
CPU s d p d’
Límite Base
segment Tabla Memoria
Pág + m m d’ Física
Dirección Física
Tabla de Páginas
Tabla de Segmentos
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

0 v 1 10
1 v 2 15
A
2 i - 6
3 i - 5
0 v 0 7
1 i - 2
B 2 i - 3
3 v 3 4
4 v 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.
DISCO 1 DISCO 2 IMPRESORA
CPU MEM CONTROLADOR CONTROLADOR OTROS

El DISCO IMPRESORA … 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.
MEM
BUFFER
CPU
Cuenta
DIR. DE MEM REGISTROS

DMA
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 Región del
Región de Datos
FAT Directorio Raíz
Veamos cada una de ellas con más detalle.

Tabla de asignación de ficheros
Una partición se divide en un conjunto de clusters 1 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 16 FAT 32
0 0
1 1
2 2
3 3
... ...
n n
16 bits 32 bits
1
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 Acceso 2 ) 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
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
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

Cargado por

Copyright:

Formatos disponibles

T3 Introducción A Los SO

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

T3 Introducción A Los SO

Cargado por

Copyright:

Formatos disponibles

Tema 3: Introducción a los SO

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

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

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

GESTIÓN DEL SISTEMA DE FICHEROS............................................................................ 43

Ejercicios (Gestión de Procesos) .............................¡Error! Marcador no definido.

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

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

Los objetivos que persigue un SO son dos:

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

Empezaremos el tema viendo los diferentes tipos de sistema operativos.

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

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

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

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

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

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

Veamos cada una de esas capas:

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

En este tema trataremos los cuatro primeros servicios.

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

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

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

Cada PCB contiene básicamente los siguientes datos:

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

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

Escogido por el Planificador

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

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

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

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

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

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

Cola de procesos preparados

Cola de procesos esperando recursos

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

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

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

Ejemplo: Tenemos tres procesos con distintos tiempos de procesamiento:

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

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

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

Proceso Ciclo llegada Ciclos CPU Prioridad

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

Partiendo del mismo ejemplo anterior:

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

Partiendo del mismo ejemplo anterior:

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

Partiendo del mismo ejemplo anterior con q = 2:

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

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

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

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,