Apuntes Fundamentos Basicos de Los Sistemas Operativos

Fundamentos bsicos de
los Sistemas Operativos
ndice de contenido
Fundamentos bsicos de los sistemas operativos
Captulo 1. Consideraciones generales de los sistemas operativos.........................7
Objetivos..................................................................................................................7
Servicios de un sistema operativo............................................................................7
Evolucin histrica...................................................................................................7
Tipos de sistemas operativos....................................................................................8
Llamadas al sistema.................................................................................................9
Estructura del ncleo de un sistema operativo.........................................................9
Captulo 2. Descripcin y control de procesos........................................................11
Espacio de direcciones de memoria lgica o virtual de un proceso.......................11
Tipos de procesos...............................................................................................11
Estados de un proceso........................................................................................11
Control de los procesos..........................................................................................12
Estructuras de control del sistema operativo.....................................................12
Creacin de procesos.........................................................................................12
Terminacin de procesos...................................................................................13
Cambio de proceso............................................................................................13
Ejecucin del sistema operativo.............................................................................13
Procesos multihilo..................................................................................................13
Control de hilos.................................................................................................14
Tipos de hilos.....................................................................................................14
Principales configuraciones en funcin del nmero y tipo de hilos soportados
por un sistema operativo....................................................................................15
Captulo 3. Planificacin de procesos......................................................................17
Niveles de planificacin.........................................................................................17
Planificador a corto plazo..................................................................................17
Planificador a medio plazo................................................................................18
Planificador a largo plazo..................................................................................18
Criterios generales considerados en la planificacin de procesos..........................18
Criterios considerados en la planificacin del procesador.....................................18
Expropiabilidad del procesador..............................................................................19
Algoritmos de planificacin...................................................................................19
Primero en llegar primero en ser servido FCFS..........................................19
Primero el proceso ms corto SJF..................................................................19
Menor tiempo restante.......................................................................................20
Planificacin de turno rotatorio.........................................................................20
Planificacin basada en prioridades..................................................................20
Planificacin basada en mltiples colas de prioridad........................................21
Mltiples colas de prioridad y realimentacin..................................................21
Planificacin por tiempo lmite.........................................................................22
Eleccin del algoritmo de planificacin............................................................22
Planificacin de hilos.............................................................................................22
Captulo 4. Sincronizacin y comunicacin de procesos.......................................23
Exclusin mutua.....................................................................................................23
Interaccin entre procesos concurrentes............................................................23
ii
Condiciones de carrera......................................................................................23
Secciones crticas...............................................................................................23
Descripcin de la exclusin mutua....................................................................23
Soluciones software a la exclusin mutua.........................................................24
Soluciones a la exclusin mutua con apoyo del hardware................................25
Semforos...............................................................................................................25
Implementacin.................................................................................................25
Utilidad de los semforos..................................................................................27
Sincronizacin de procesos...............................................................................27
Problemas potenciales asociados a un mal uso de los semforos.....................27
Problemas clsicos de sincronizacin de procesos concurrentes...........................28
El problema de los productores y los consumidores.........................................28
El problema de los lectores y los escritores......................................................28
Monitores...............................................................................................................29
Definicin..........................................................................................................29
Estructura y declaracin de un monitor.............................................................29
Uso de los monitores.........................................................................................30
Paso de mensajes....................................................................................................30
Definicin..........................................................................................................30
Especificacin de la fuente y el destino del mensaje........................................31
Esquemas de sincronizacin..............................................................................31
Formato y almacenamiento de los mensajes.....................................................32
Uso del paso de mensajes..................................................................................32
Captulo 5. Interbloqueo..........................................................................................33
Introduccin...........................................................................................................33
Definicin y condiciones del interbloqueo............................................................33
Grafos de asignacin de recursos...........................................................................33
Prevencin de interbloqueos..................................................................................34
Eliminacin de la condicin de exclusin mutua..............................................34
Eliminacin de la condicin de retencin y espera...........................................34
Eliminacin de la no existencia de expropiacin..............................................34
Eliminacin de la espera circular......................................................................34
Evitacin de interbloqeos.......................................................................................34
Estado de la asignacin de recursos: estados seguros y estados inseguros.......35
Denegacin de asignacin de recursos: el algoritmo del banquero...................35
Denegacin de la iniciacin de un proceso.......................................................35
Deteccin y recuperacin de interbloqueos...........................................................36
Algoritmos de deteccin de interbloqueos........................................................36
Frecuencia de invocacin del algoritmo de deteccin de interbloqueos...........36
Tcnicas de recuperacin del interbloqueo.......................................................36
Ventajas e inconvenientes..................................................................................36
Otras estrategias de tratamiento de interbloqueos..................................................37
Captulo 6. Administracin de memoria.................................................................38
Espacio de ncleo y espacio de usuario............................................................38
rea de intercambio en memoria secundaria....................................................38
Asignacin de memoria en sistemas monoprogramados.......................................39
Particionamiento fijo..............................................................................................40
Particiones de igual tamao...............................................................................40
Particiones de distinto tamao...........................................................................40
Traduccin de direcciones y proteccin............................................................40
iii
Particionamiento dinmico.....................................................................................41
Asignacin de espacio de memoria principal....................................................41
Traduccin de direcciones y proteccin............................................................42
Paginacin simple..................................................................................................42
Traduccin de direcciones.................................................................................43
Tablas de pginas paginadas..............................................................................44
Tablas de pginas invertidas..............................................................................45
Proteccin..........................................................................................................46
Comparticin de pginas...................................................................................46
Segmentacin simple.............................................................................................46
Traduccin de direcciones.................................................................................47
Proteccin..........................................................................................................47
Comparticin de segmentos..............................................................................47
Segmentacin con paginacin simple....................................................................48
Captulo 7. Memoria virtual....................................................................................49
Paginacin por demanda........................................................................................49
Reinicio de instrucciones...................................................................................50
Localizacin de las pginas en memoria secundaria.........................................50
Bloqueo de marcos de pgina............................................................................50
Tratamiento de un fallo de pgina.....................................................................50
Conjunto de trabajo de un proceso.........................................................................51
Reemplazamiento de pginas.................................................................................51
Algoritmo de reemplazamiento ptimo.............................................................52
Algortimo de reemplazamiento LRU................................................................52
Algoritmo de reemplazamiento mediente envejecimiento................................52
Algoritmo de reemplazamiento FIFO...............................................................52
Algoritmo de reemplazamiento de la segunda oportunidad (algoritmo del reloj)
...........................................................................................................................53
Algoritmo de reemplazamiento del reloj considerando el conjunto de trabajo.53
Conclusiones sobre los algoritmos de reemplazamiento...................................54
Asignacin de memoria principal..........................................................................54
Control de carga.....................................................................................................55
Copia en memoria secundaria de pginas modificadas..........................................55
Consideraciones adicionales sobre la paginacin por demanda.............................55
Tamao de pgina..............................................................................................55
Paginacin por adelantado.................................................................................56
Reserva de marcos libres...................................................................................56
Captulo 8. Gestin de la Entrada/Salida...............................................................57
Peticiones de E/S....................................................................................................57
Capas del ncleo de un sistema operativo encargadas de la E/S...........................57
Subsistema de E/S.............................................................................................57
Drivers de dispositivos de E/S...........................................................................58
Manejador de las interrupciones........................................................................58
Buffering................................................................................................................58
Estrategias..........................................................................................................59
Cach de buffers de bloques de disco................................................................59
iv
Spooling.................................................................................................................59
Detalles de la gestin de E/S de algunos dispositivos............................................59
Relojes...............................................................................................................59
Discos duros......................................................................................................60
Dispositivos de E/S adaptados al usuario..........................................................62
Captulo 9. Gestin de archivos...............................................................................64
Archivos.................................................................................................................64
Tipos de archivos...............................................................................................64
Atributos de un archivo.....................................................................................64
Estructura interna de un archivo........................................................................64
Mtodos de acceso a un archivo........................................................................65
Operaciones sobre archivos...............................................................................65
Directorios..............................................................................................................66
Estructura de los directorios..............................................................................66
Operaciones sobre directorios...........................................................................67
Sistemas de archivos..............................................................................................67
Estructura de un sistema de archivos.................................................................67
Montaje de un sistema de archivos....................................................................68
Asignacin de espacio.......................................................................................68
Gestin del espacio libre...................................................................................69
Implementacin de directorios..........................................................................70
Consistencia.......................................................................................................70
Recuperacin de archivos......................................................................................71
Copias de seguridad...........................................................................................71
Instantneas.......................................................................................................71
Eficiencia................................................................................................................72
Captulo 1.
Consideraciones generales de los sistemas

operativos
Un sistema operativo es una capa de software cuya funcin es administrar todos los dispositivos
hardware del computador y suministrar para usuarios y programas una interfaz apropiada con el
hardware.
Objetivos
Gestionar eficientemente los dispositivos hardware
Tiempo de procesador a los programas de usuario: planificador.
Ocupacin/gestin de memoria principal
Gestin de memoria secundaria: rea de intercambio (zona donde se almacenan los

programas que hay que ejecutar pero que an no disponen de espacio en memoria principal)
y sistema de archivos y resto de dispositivos E/S.
Ofrecer una interfaz cmoda a los usuarios. El SO proporciona una mquina virtual que envuelve al
hardware facilitando su programacin. Capas:
Hardware
Ncleo (kernel), proporciona un conjunto de instrucciones como llamadas al sistema.
Utilidades del SO (intrpretes de comandos, sistemas de ventanas, compiladores, etc).
Programas de aplicacin.
Servicios de un sistema operativo
Ejecucin de programas.
Acceso a los dispositivos de E/S.
Manipulacin del sistema de archivos
Comunicacin y sincronizacin.
Deteccin y respuesta a errores
Proteccin y seguridad.
Contabilidad.
Evolucin histrica
Procesamiento serie
Procesamiento por lotes (batch)
Multiprogramacin (multitarea). Aprovechamiento de operaciones de E/S de un proceso

para ejecutar otro.
Multiprogramacin por tiempo compartido. Debe gestionar los recursos asignndolos de

manera equitativa.
Apuntes por Demetrio Quirs Fundamentos bsicos de los Sistemas Operativos
Tipos de sistemas operativos

En funcin del nmero de usuarios simultneos
Monousuario y multiusuario.
Segn el nmero de programas cargados en memoria principal:
Monoprogramado y multiprogramado.
Se denomina grado de multiprogramacin el nmero de programas cargados en memoria

principal. Para implementar multiprogramacin se precisan algoritmos de planificacin,
mecanismos de sincronizacin y de asignacin y proteccin de memoria principal y
secundaria. El hardware tambin debe soportar proteccin de la memoria, E/S por
interrupciones y DMA. Un SO puede ser multiacceso (acceso desde dos o ms terminales)
pero no necesariamente multitarea (sistema de venta de billetes, por ejemplo). Un SO
multiprocesamiento coordina la actividad de varios procesadores. Son multiprogramados por
definicin.
En funcin de los requisitos temporales de los programas a ejecutar:
Sistemas por lotes o batch, planificacin del procesador simple; suele utilizarse E/S por
programa; gestin sencilla de la memoria principal: bloque del SO y bloque de programas
Sistemas de tiempo compartido o sistemas interactivos. Sistemas multiusuario con

multiprogramacin. El planificador debe asegurar el reparto equitativo del tiempo de
procesador as como poseer mecanismos de proteccin de MP, MS y acceso concurrente a
archivos.
Sistemas de tiempo real. Pueden ser en tiempo real estricto o suave. Las primeras requieren
un tiempo lmite preestablecido de respuesta. Utilizan un sistema de planificacin de tipo
expropiativo, en el que el proceso con ms prioridad toma el control. la gestin de la
memoria es menos exigente. (VxWorks, QNX)
Sistemas hbridos. Soportan tanto trabajos por lotes como aplicaciones interactivas o
aplicaciones suaves en tiempo real. Prioridad de ejecucin mnima para trabajos por lotes,
media para interactivos y mxima para aplicaciones en tiempo real. (UNIX, LINUX)
En funcin de la finalidad del computador.
Sistemas para macrocomputadores.
Sistemas operativos para servidores de red.
Sistemas operativos para computadoras personales.
Sistemas para computadoras de mano.
Sistemas integrados.
Otros tipos importantes de SO
Sistemas paralelos o multiprocesador. Comparten bus, reloj, memoria, E/S. Se les suele
denominar como sistemas fuertemente acoplados. Los SO paralelos ms comunes utilizan
multiprocesamiento simtrico. Cada procesador ejecuta su propia copia del SO, que se
comunican entre ellas cuando es necesario.
Sistemas distribuidos. Se ejecutan en sistemas informticos distribuidos implementados

mediante redes. Se les suele denominar sistemas dbilmente acoplados. El usuario no sabe si
el proceso se ejecuta en su propio procesador o en el de otra mquina de la red.
Captulo 1. Consideraciones generales de los sistemas operativos
Sistemas operativos de red. Posibilita el acceso a contenido y recursos entre computadoras

mediante el paso de mensajes.
Llamadas al sistema
La mayora de procesadores disponen de dos modos de operacin: modo ncleo y modo usuario.
Los programas de usuario deben hacer uso de llamadas al sistema para poder utilizar los recursos
hardware a travs del SO.
Mediante el uso de libreras de llamadas al sistema, de forma similar a como se invoca

cualquier otra funcin.
De forma directa, mediante programas en lenguaje ensamblador.
La llamada al sistema provoca una trampa (tramp), haciendo que el procesador conmute a modo
ncleo. Para poder acceder a los parmetros de la llamada al sistema se utiliza:
Cargar los parmetros en registros. Mtodo sencillo, puede que no se tengan registros
suficientes.
Almacenamiento en un bloque o tabla de memoria. Slo es necesario conocer la direccin

de comienzo del bloque.
Almacenamiento en una pila.
Las llamadas al sistema, atendiendo a su funcionalidad, se pueden agrupar en:
Control de programas en ejecucin (procesos).
Administracin de archivos y directorios.
Comunicaciones.
Gestin de dispositivos.
Gestin de informacin del sistema.
Estructura del ncleo de un sistema operativo

La forma ms eficiente de disear un SO consiste en descomponerlo en varios componentes o
subsistemas. La mayora disponen de:
Subsistema de control de procesos.
Subsistema de control de la memoria principal.
Subsistema de gestin de archivos.
Subsistema de E/S.
El ncleo de un sistema operativo se puede considerar como un conjunto lgico de mdulos

software. El nucleo puede tener
Estructura monoltica o simple. Todos los subsistemas y las estructuras de datos del ncleo
se ubican en un mismo mdulo lgico. El software del ncleo est escrito como un conjunto
de procedimientos. Un procedimiento es visible por todos los dems. (MSDOS, UNIX
tradicional).
Estructura en mdulos. Cada mdulo con una interfaz bien definida. De fcil mantenimiento
con una ligera merma en el rendimiento.
Estructura en capas o niveles. El ncleo se organiza en capas de software en la que las capas
pueden invocar a las capas inferiores, pero nunca a las superiores. Un esquema tpico en seis
capas: capa 0, controladores hardware; capa 1, control, sincronizacin y comunicacin de

procesos; capa 2, gestin de memoria; capa 3, comunicaciones entre procesos y el operador
de consola; capa 4, gestin de E/S; capa 5, programas de usuario.
Estructura extensible. Puede considerarse como un caso particular de la estructura modular.

Posee un mdulo principal, el ncleo extensible o microncleo, y varios mdulos como
extensiones del ncleo. El microncleo realiza los servicios absolutamente esenciales, los
que dependen estrechamente de la arquitectura de la mquina como la gestin de
interrupciones, comunicacin entre procesos, gestin de memoria a bajo nivel y gestin de
E/S. El resto de las funciones se realizan en modulos de extensin del ncleo. Los procesos
de usuarios se comunican con las extensiones del ncleo utilizando un mecanismo cliente
(applicacin de usuario) servidor (extensin del ncleo).
La comunicacin cliente/servidor se realiza mediante el paso de mensajes. Las ventajas de
un ncleo extensible son:
Manejabilidad. Cada extensin del ncleo se encarga de un servicio del sistema.
Extensibilidad. Aadir nuevas caractersticas aadiendo un nuevo mdulo.
Fiabilidad. Las extensiones se ejecutan como procesos de usuario. Ante el fallo de un
servicio, el resto puede seguir disponible.
Soporte simultneo de mltiples sistemas operativos. Sobre un mismo microncleo
pueden implementarse diferentes extensiones.
Portabilidad. Solo es necesario reescribir el microncleo al ser la nica parte
dependiente del hardware.
Su principal desventaja es un menor rendimiento debido al paso de mensajes (creacin,
envo, procesamiento).
10
Captulo 1. Consideraciones generales de los sistemas operativos
Captulo 2.
Descripcin y control de procesos
Un proceso es un programa en ejecucin. Tambin puede definirse como la entidad que se puede
asignar y ejecutar en un procesador: es la unidad bsica de trabajo de un sistema informtico.
Si un programa se ejecuta ms de una vez, cada copia tendr su propio proceso asignado.
Cuando un proceso puede interactuar con los usuarios se dice que est en primer plano
(foreground), en caso contrario un proceso se encuentra en segundo plano (background).
Espacio de direcciones de memoria lgica o virtual de un proceso.

El espacio de direcciones de memoria lgica o virtual de un proceso (imagen del proceso o espacio
de direcciones de usuario) se divide en varias regiones: la regin de cdigo (o regin de texto), la
regin de datos y la regin de pila.
La regin de datos puede dividirse en regin de datos inicializados, de tamao fijo, y regin de
datos no inicializados, de tamao variable.
La regin de pila se crea automticamente y su tamao se ajusta dinmicamente en tiempo de
ejecucin. El registro puntero de pila almacena la prxima entrada libre o la ltima utilizada,
dependiendo de la arquitectura del procesador.
Puesto que la regin de pila y la de datos no inicializados puede variar durante la ejecucin de un
proceso se deben reservar regiones libres adyacentes.
A parte de las regiones del espacio de direcciones de memoria lgica a las que se accede en modo
usuario, el SO ubica estructuras de datos relativas al proceso en curso que le permiten controlar su
ejecucin y que son accesibles en modo supervisor o ncleo.
Tipos de procesos
Procesos de usuario. Pueden ejecutarse en primer o segundo plano. Se ejecutan en modo

usuario.
Procesos demonio. Procesos no asociados a ningn usuario. Realizan tareas relacionadas

peridicas de administracin del sistema. Se ejecutan en modo usuario generalmente en
segundo plano.
Procesos del sistema operativo. Realizan tareas de administracin (como el intercambio de

procesos entre memoria principal y secundaria) del sistema en modo supervisor y,
generalmente, en segundo plano.
Estados de un proceso
Aunque el nmero y el nombre depende de cada sistema operativo, algunos de los estados ms
habituales son:
Nuevo.
Preparado.
Ejecutndose.
Bloqueado.
Terminado.
Adems, nos podemos encontrar con otros dos estados disponibles en algunos sistemas operativos:
11
Preparado en memoria secundaria.
Bloqueado en memoria secundaria.
Control de los procesos

Estructuras de control del sistema operativo
El sistema operativo debe mantener informacin sobre el estado de cada proceso y cada recurso.
Esta informacin se guarda en tablas en memoria
Tabla de procesos. Cada entrada en la tabla almacena un PCB (Process Control Block) con
diversa informacin:
Identificador del proceso.
Identificador del usuario.
Estado del proceso.
Contenido de algunos registros del procesador.
Informacin de planificacin del proceso.
Informacin de localizacin de la memoria principal asociada al proceso.
Informacin de tipo estadstico.
Informacin de estado de E/S.
Informacin sobre el evento por el que el proceso ha entrado en modo bloqueado.
Tablas de memoria, con informacin sobre espacio libre y asignado.
Tablas de E/S, con informacin sobre disponibilidad de dispositivos y quien lo usa.
Tablas de archivos, con informacin sobre archivos abiertos por los procesos.
Adems, podemos encontrar las pilas de control del sistema o pilas del sistema operativo, as como
pilas de interrupciones, colas de procesos preparados y bloqueados, etc.
Creacin de procesos
Comprobar si el proceso puede ser creado.
Asignar una nueva entrada de la tabla de procesos para el nuevo proceso.
Reservar espacio en memoria para el proceso.
Inicializar el bloque de control del proceso.
Establecer los enlaces adecuados.
Las causas que originan la creacin de un proceso pueden ser:
El arranque del sistema operativo.
Interaccin del usuario mediante intrprete de comandos o entorno de ventanas.
Inicio de un trabajo por lotes.
Un proceso en ejecucin invoca una llamada al sistema para crear otro proceso.
UNIX y Linux, mediante llamada a fork. Crea una copia exacta del proceso padre.
Cuando el hijo es planificado para ejecutarse, invoca a execve, y lanza el otro programa.
12
Captulo 2. Descripcin y control de procesos
En Windows,
hijo.
createprocess
utiliza otro espacio de direcciones distinto para el proceso
Terminacin de procesos
Cuando se produce una excepcin en su ejecucin.

Cuando finaliza la tarea para la que ha sido creado
En UNIX, llamada al sistema exit.
En Windows llamada a ExitProcess.
Cuando un proceso privilegiado detenga otro.
En UNIX, llamada al sistema kill.
En Windows, llamada al sistema TerminateProcess.
Una vez finalizado el proceso, hay que liberar los recursos que utilizaba. El PCB no se elimina
inmediatamente, sino despus de haber auditado los datos.
Cambio de proceso
Un proceso A se interrumpe para iniciar o continuar la ejecucin de otro proceso B: cambio de

contexto o cambio de proceso. Causas ms frecuentes para un cambio de contexto son:
El proceso en ejecucin pasa al estado bloqueado.
La terminacin voluntaria o forzada del proceso en ejecucin.
El sistema operativo termina de atender una interrupcin y existe un proceso B en estado

preparado con mayor prioridad que el proceso actual.
El proceso en ejecucin ha excedido el tiempo mximo de ejecucin ininterrumpida.
Para proceder a un cambio de contexto, el sistema operativo sigue los pasos siguientes:
Salva el contexto del proceso A en su PCB.
Se ejecuta el algoritmo de planificacin para seleccionar el proceso B.
Cargar el PCB del proceso B seleccionado.
El tiempo de conmutacin es el tiempo que se tarda en completar todo el proceso debido a las
limitaciones fsicas de los componentes.
Ejecucin del sistema operativo

En funcin de la tarea o servicio realizado, el tiempo utilizado por el sistema operativo puede ser
contabilizado a un determinado proceso. El tiempo de uso de las tareas y servicios propios de la
administracin del sistema no se contabilizan a ningn proceso de usuario; este tiempo no dedicado
a tareas de usuario se denomina sobrecarga del sistema (overhead).
El tiempo de determinadas tareas del sistema operativo, como la atencin a las interrupciones
hardware, no es sencillo asignarlas a un proceso en particular dado su carcter asncrono. UNIX,
por ejemplo, se las anota al proceso ejecutndose en el momento de producirse la interrupcin,
aunque no sea este el causante.
Procesos multihilo
Un proceso est caracterizado por dos elementos que pueden ser tratados de forma independiente:
13
Conjunto de recursos asignados: espacio de direcciones, archivos abiertos, etc.
Traza de ejecucin, hilo de control, hilo o hebra (thread). Hace referencia a las instrucciones
que ejecuta el proceso durante su tiempo de vida.
Los sistemas operativos modernos introducen el modelo de proceso multihilo: un proceso puede
estar formado por mltiples hilos. Estos sistemas operativos utilizan los procesos como unidad de
asignacin del procesador que sigue una determinada traza de ejecucin y tiene asignado una pila
de usuario, espacio de almacenamiento y un bloque de control del hilo. Este bloque de control
contiene el identificador numrico del hilo, el estado del hilo, su prioridad de ejecucin y los
valores de los registros. A un hilo se le llama a veces proceso ligero (lightweigth process).
Cada hilo perteneciente a un proceso comparte con los restantes hilos del mismo proceso los
mismos recursos bloque de control del proceso, etc.
Ventajas de procesos multihilos respecto de mltiples procesos:
Aumento del rendimiento del sistema.
Ahorro de recursos.
Comunicacin ms eficiente.
Mayor aprovechamiento de las arquitecturas multiprocesador.
Simplificacin de la estructura de las aplicaciones.
El principal inconveniente es la necesidad de sincronizacin de acceso a las estructuras de datos que

comparten los hilos.
Control de hilos
Como sucede con los procesos, un hilo puede encontrarse durante su tiempo de vida en diferentes
estados. En un determinado instante, un proceso se encontrar en un estado determinado que no
tiene por que coincidir con el estado de sus hilos. Obviamente, el estado del proceso limita el estado
en el que pueden encontrarse sus hilos: si un proceso se encuentra en estado preparado ninguno de
sus hilos puede estar ejecutndose.
La planificacin de la cola de hilos se realiza a nivel de hilos. Cuando un hilo termina su ejecucin
simplemente desaparece, ya no es planificable.
El poder realizar un cambio de hilo dentro de un mismo proceso cuando un hilo cambia al estado
bloqueado depende del tipo de implementacin de hilos que soporte el sistema operativo.
En el momento que un hilo finaliza su ejecucin sus recursos asignados son liberados. Un proceso
no puede entrar en estado terminado hasta que no hayan finalizado todos sus hilos.
Tipos de hilos
Hilos a nivel de usuario. O, simplemente, hilos de usuario, son implementados por una biblioteca
de hilos que se ejecuta a nivel de usuario. Inicialmente, una aplicacin comienza con un solo hilo.
Este proceso puede iniciar otro hilo invocando a la funcin apropiada de la biblioteca de hilos del
SO.
Cada proceso requiere una tabla de hilos, en la que cada entrada, denominada bloque de control del
hilo, mantiene la informacin asociada al hilo (contador del programa, registro de pila, etc.) Esta
tabla es similar a la tabla de procesos.
La realizacin del cambio de hilo dentro de un mismo proceso se realiza sin necesidad de realizar
un cambio de modo y un cambio de contexto. Toda esta actividad tiene lugar en modo usuario
dentro del proceso en ejecucin, sin intervencin del sistema operativo. Esto proporciona las
siguientes ventajas:
14
Portabilidad. Al no requerir la intervencin del SO, slo de la biblioteca de hilos que puede
estar disponible para mltiples SO.
Mejora del rendimiento del sistema. Al realizarse toda la gestin de hilos en modo usuario.
Planificacin independiente. Cada proceso puede emplear un algoritmo de planificacin

distinto y estos a su vez distintos del que emplee el sistema operativo.
La principal desventaja se da en aquellos sistemas operativos que solo soportan un hilo a nivel de
ncleo: cuando un hilo de un proceso entra en estado bloqueado, todo el proceso se bloquea: el
sistema operativo desconoce la existencia de hilos de usuario. Otra desventaja es que cuando un hilo
se est ejecutando no se puede planificar otro hilo de usuario del mismo proceso a no ser que el
primero ceda voluntariamente el uso del procesador.
Hilos a nivel de ncleo
Los hilos del ncleo son implementados y gestionados directamente por el ncleo del SO.
No precisan biblioteca de hilos.
El sistema mantiene una nica tabla de hilos.
Si uno se bloquea se puede planificar otro del mismo o distinto proceso.
En sistemas multiprocesador puede ejecutarse un hilo en cada procesador.
Su gestin contribuye a la sobrecarga del sistema.
Algunos SO, por ello, limitan el nmero de hilos del ncleo.
Para ahorrar en tiempo, cuando un hilo se destruye se marca como no planificable pero su
estructura de datos no se elimina, se reutiliza para otros hilos.
Principales configuraciones en funcin del nmero y tipo de hilos soportados por un

sistema operativo
Dependiendo del nmero y tipo de hilos soportados por un sistema operativo, se pueden distinguir
las siguientes configuraciones:
Mltiples hilos de usuario sin soporte de hilos del ncelo.

El sistema planifica procesos, no hilos.
La gestin de hilos la realiza una biblioteca de hilos.
Cuando un hilo realiza una llamada al sistema, comienza a ejecutarse el SO.
Si la llamada requiere el bloqueo del hilo, se bloquea el proceso completo.
No pueden ejecutarse varios hilos al mismo tiempo, ya que slo uno puede acceder al
SO.
Un hilo del ncleo por cada hilo de usuario.

No se precisa biblioteca de hilos, solo acceder a las utilidades de hilos del ncleo.
Si un hilo de usuario se bloquea se puede planificar otro del mismo proceso.
La planificacin la realiza el SO.
Debido a la sobrecarga, se limita el nmero de hilos que es posible crear.
Menor nmero de hilos del ncleo que hilos de usuario.

Se requiere biblioteca de hilos para gestin de hilos de usuario.
15
Los hilos de usuario se asocian a un nmero <= de hilos del ncleo.

Es el programador de la aplicacin quien se encarga de establecer el nmero de hilos del
ncleo que necesita.
Auna las ventajas de las dos configuraciones anteriores, si est bien implementada.
16
Captulo 3.
Planificacin de procesos
En una mquina con multiprogramacin pueden ejecutarse concurrentemente varios procesos. Si la

mquina dispone de un nico procesador, en un determinado instante de tiempo slo un proceso o
hilo puede usarlo. El sistema operativo debe decidir qu proceso es el que va a ser ejecutado.
Niveles de planificacin
Colas de procesos para planificar los recursos del procesador:
Cola de procesos en estado preparado.
Cola de procesos en estado preparado en memoria secundaria.
Cola de procesos en estado bloqueado.
Cola de procesos en estado bloqueado en memoria secundaria.
Cola de trabajos por lote o cola de entrada.
Un proceso puede pasar por varias colas. La actividad de determinar cundo se entra en una cola o
se pasa a otra se denomina planificacin de procesos y al componente que la realiza planificador. Se
distinguen tres niveles de planificacin:
Planificacin a corto plazo, que decide qu proceso ser ejecutado a continuacin.
Planificacin a medio plazo, de determina qu proceso en cola de memoria principal pasa a

cola de memoria secundaria y viceversa.
Planificacin a largo plazo, determina qu trabajo por lotes pasa a ser ejecutado mediante la
creacin de un proceso.
Adems, se puede distinguir un cuarto nivel de planificacin, la planificacin de E/S.

Cada nivel de planificacin es implementado por su propio planificador.
Planificador a corto plazo
Desde el punto de vista lgico, todo planificador se puede dividir en tres componentes o elementos:
Encolador (enqueuer), encargado de incluir al proceso en la cola de procesos preparados y

de asignarle una prioridad.
Conmutador de contexto (context switcher), encargado de guardar el contexto del proceso a

ser desalojado y cargar el contexto del proceso a ser ejecutado.
Distribuidor o despachador (dispatcher), encargado de seleccionar un proceso de la cola de

procesos preparados y cederle el control del procesador. El tiempo que transcurre entre la
detencin de un proceso y la ejecucin de otro se llama tiempo de despacho. Algunos SO no
permiten la expropiacin de un proceso que se ejecuta en modo ncleo que est realizando
una llamada al sistema. Estos sistemas se llaman de nucleo no expropiable.
Algunas circunstancias que hacen necesaria una llamada al planificador a corto plazo son:
Cuando se ha terminado de crear un nuevo proceso hijo.
Cuando un proceso entra en estado bloqueado en espera de que se producza algn evento.
Cuando se termina de atender una interrupcin.
Cuando un proceso finaliza.
17
Planificador a medio plazo
Tambin conocido como planificador de memoria o intercambiador. Decide qu procesos de

memoria principal se pasa a memoria secundaria y viceversa. Se ejecuta con menor frecuencia que
el planificador a corto plazo. Puede ser invocado cuando queda espacio libre en la memoria
principal o porque el nmero de procesos en el estado preparado cae por debajo de algn lmite
prefijado.
Planificador a largo plazo
Tambin se denomina planificador de trabajos o planificador de admisin. Decide qu trabajo de

los pendientes en la cola trabajos por lotes ser admitido para ser ejecutado.
La admisin de un trabajo consiste en la creacin de un proceso para el procesamiento de dicho
trabajo.
El planificador a largo plazo permite regular el nivel de multiprogramacin del sistema,
invocndolo cuando se termina un trabajo o tras cierto tiempo de inactividad del procesador.
A tener en cuenta es que la ejecucin de un proceso comienza con una rfaga de CPU, esto es,
utilizando el procesador de forma continuada durante un cierto periodo de tiempo. As nos podemos
encontrar con procesos limitados por CPU, en los que ste se encuentra la mayor parte del tiempo
utilizando la CPU y poco los recursos de E/S y los procesos limitados por E/S. El planificador debe
intentar seleccionar los trabajos de forma que exista un equilibrio entre procesos de un tipo y de
otro.
Algunos sistemas operativos como UNIX no disponen de planificador a largo plazo.
Criterios generales considerados en la planificacin de procesos
Equidad. Requisistos similares tiempo de uso de los recursos similares.
Previsibilidad. Caractersticas similares tiempo de ejecucin similares.
Uso equilibrado de los recursos. Mantener todos los recursos ocupados / optimizados.
Proporcionalidad. Peticiones sencillas mejor tiempo de respuesta que peticiones

complejas.
Criterios considerados en la planificacin del procesador

El planificador del procesador elige el prximo proceso que pasar a ser ejecutado en el procesador
en base a la optimizacin simultnea de alguno o alguno de los siguientes criterios:
Utilizacin del procesador o eficacia. Porcentaje de tiempo del procesador activo.
Productividad (throghput) o rendimiento. Nmero de trabajos completados por u.t. (1 hora)
Tiempo de entrega (turnaround time), tambin denominado tiempo de retorno o tiempo de

estancia. Tiempo desde que se lanza un proceso hasta que finaliza.
Tiempo de espera. Tiempo total de estancia en las colas de espera.
Tiempo de respuesta (response time). Tiempo desde que se lanza una orden hasta que se
obtiene el resultado.
Plazo de finalizacin (deadline). Tiempo mximo que un proceso tiene para ser completado
en un sistema de tiempo real.
La eleccin de los criterios a optimizar depende del tipo de sistema operativo. En un sistema por
lotes debe intentar maximizar la utilizacin del procesador y la productividad, uno de tiempo
compartido el tiempo de respuesta y uno de tiempo real el tiempo de entrega.
18
Captulo 3. Planificacin de procesos
Normalmente, el planificador optimiza los valores medios de los criterios que considera.
Es ms importante minimizar la varianza en el tiempo de respuesta que minimizar el tiempo de
respuesta promedio.
Cuando se intentan optimizar varios criterios simultneamente, se debe tener en cuenta que pueden
ser incompatibles entre s.
Expropiabilidad del procesador

Planificacin del procesador no expropiativa (non preemptive) si permite que un proceso pueda
estar ejecutndose en el procesador ininterrumpidamente.
Utilizada en sistemas por lotes.
Tambin se utiliza en sistemas en tiempo real, en el que los procesos no utilizan el

procesador por largos perodos de tiempo.
Planificacin del procesador expropiativa (preemptive) si el proceso que se est ejecutando puede
ser interrumpido en cualquier momento.
Mayor sobrecarga en el sistema
Proporciona mejor servicio a la poblacin de procesos
Requiere que el ncleo disponga de mecanismos de sincronizacin
Utilizada en sistemas de tiempo compartido o interactivos.

El tiempo mximo de ejecucin ininterrumpida se denomina quantum (cuanto).
Algoritmos de planificacin
Primero en llegar primero en ser servido FCFS
Abreviadamente FCFS (First Come First Served).
Cede el uso del procesador al primer proceso que lo solicite.
No expropiativo.
Requiere de una cola FIFO de procesos preparados.
Tiempo de espera promedio bastante grande.
Mejor para procesos largos.
Favorece a los procesos limitados por el procesador frente a los limitados por E/S.
Se desaconseja su uso como principal algoritmo de planificacin. til en combinacin con

otros.
Primero el proceso ms corto SJF
Abreviadamente SJF, Shortest Job First o SPN Shortest Job Next.
Se ejecuta primero el proceso con tiempo de procesamiento ms corto.
No expropiativo.
Si dos o ms procesos tienen el mismo tiempo de procesamiento se aplica FCFS.
Minimiza el tiempo de espera promedio de un conjunto de procesos.
19
Se suele utilizar en SO por lotes, tanto en el planificador a largo como a corto plazo.
Se precisa conocer por adelantado el tiempo de procesamiento de cada proceso.
En SO de tiempo compartido, se puede estimar la duracin de las siguientes rfagas

utilizando la duracin de las anteriores. Se suele utilizar un preditor promedio exponencial.
M n+ 1=t n+ (1)M n . donde Mn+1 es el promedio estimado para la prxima rfaga; t n es
la duracin de la ltima rfaga, Mn el promedio estimado para la ltima rfaga y el peso
que se le asigna entre 0 y 1.
Al tener que calcular estimaciones, la sobrecarga se hace mayor cuanto mayor es la

precisin del clculo.
Los procesos largos pueden sufrir inanicin.
Menor tiempo restante
Abreviadamente SRT, Shortest Remaining Time next, versin expropiativa del SFJ.
Algoritmo expropiativo.
Siempre selecciona al proceso con el menor tiempo restante de ejecucin.
Suele utilizarse en sistemas de procesos por lotes.
Requiere una estimacin de los tiempos restantes de ejecucin de la poblacin de procesos.
Puede producir inanicin a los procesos largos.
A igualdad de tiempo de servicio restante se aplica FCFS.
Planificacin de turno rotatorio
Round Robin o cclico, similar al FCFS pero expropiatorio.
Asigna el uso ininterrumpido del procesador durante un periodo de tiempo determinado

llamado cuanto, quantum o time slice.
Al finalizar el cuanto, se interrumpe el proceso actual y se ejecuta el siguiente en la cola. El

proceso interrumpido pasa al final de la cola.
Si un proceso finaliza antes que su cuanto, se planifica el siguiente proceso preparado sin
esperar a la finalizacin del cuanto.
Si finaliza el cuanto de un proceso y no existen procesos en cola, vuelve a planificarse el

mismo proceso.
Elemento clave para el rendimiento del algoritmo es la eleccin del tamao del cuanto.
Se recomienda un cuanto ligeramente mayor que el tiempo promedio de duracin de una

rfaga de procesador.
Algoritmo diseado para los sistemas de uso compartido.
El tiempo de respuesta promedio, el tiempo de retorno promedio y el tiempo de espera

promedio pueden ser largos.
Planificacin basada en prioridades
Asigna a cada proceso una determinada prioridad en el momento de su creacin.
20
Siempre se planifica para ejecucin el proceso de mayor prioridad.
La asignacin de prioridades a los procesos puede realizarse en funcin de factores internos

del sistema, como requerimientos de memoria, duracin promedio de la rfaga.. o a factores
externos, como la importancia del usuario.
Si la prioridad asignada no se modifica durante el tiempo de vida del proceso, se denomina

asignacin de prioridades esttica; dinmica si se modifica.
Puede ser expropiativo y no expropiativo. Cuando es de tipo expropiativo se dice que est
guiado por eventos (event-driven).
Un proceso con baja prioridad puede sufrir inanicin.
Tcnicas para evitar la inanicin:

Envejecimiento de procesos (aging), aumentando la prioridad conforme aumenta el
tiempo de espera.
Disminuir la prioridad del proceso en ejecucin en cada interrupcin de reloj.
Limitar el tiempo de ejecucin.
Puede darse el fenmeno de inversin de prioridad que ocurre cuando un proceso ms

prioritario debe esperar a que un recurso se libere por otro proceso con menor prioridad.
Puede resolverse mediante el traspaso o herencia de prioridad.
Planificacin basada en mltiples colas de prioridad
Se disponen varias colas cada una de las cuales dispone nicamente de procesos con un
determinado nivel de prioridad o dentro de un rango de prioridades.
Siempre se ejecuta un proceso de la cola de mayor prioridad.
Slo cuando esa cola se vaca, se ejecutan los de la siguiente cola.
Un proceso slo puede pertenecer a una cola.
Para planificar cada cola puede usarse FCFS, SJF, etc.
Puede producirse inanicin de los procesos de las colas de menor prioridad. Para evitarlo,
puede asignarse a los procesos de cada cola un porcentaje de tiempo de procesador
Mltiples colas de prioridad y realimentacin
Se permite que un proceso pueda ir cambiando de cola de prioridad durante su existencia.
Requiere definir un mecanismo que regule cmo se modifica la prioridad de los procesos,
esto es, cmo y cundo se produce el paso de una cola a otra.
Un mecanismo puede consistir en reducir la prioridad del proceso en cada cuanto de

ejecucin hasta que llega a la cola de menor prioridad, donde se queda, siendo entonces esta
cola de turno rotatorio.
Con este mecanismo se favorecen los procesos nuevos y cortos frente a los viejos y
largos.
Para evitarlo puede asignarse un cuanto de mayor tamao conforme disminuye la prioridad
de las colas.
Esta tcnica no evita compeltamente la inanicin, por lo que puede combinarse con la de
envejecimiento de procesos.
21
Planificacin por tiempo lmite
En los sistemas de tiempo real estricto el tiempo de servicio de algunos procesos debe completarse
en un determinado plazo o tiempo lmite (deadline).
El planificador slo admite en la cola de procesos preparados aquellos a los que pueda
garantizar que su tiempo de servicio se atender dentro de su tiempo lmite, en funcin de
los tiempos de espera existentes en la cola.
Debe conocerse por adelantado el tiempo de servicio y deadline de cada proceso
Eleccin del algoritmo de planificacin
En primer lugar deben fijarse los criterios de seleccin y a continuacin evaluar los diferentes
algoritmos de planificacin usando algn mtodo de evaluacin.
Modelado determinista. Evalua cada algorimo candidato usando una carga de trabajo
predeterminada e idntica para todos ellos. Es difcil establecer esta carga de manera realista
y manejable.
Modelo analtico mediante sistema de colas. Se obtiene un modelo analtico matemtico.

Cada recurso hardware del sistema y cada cola software asociada se modela como una
estacin de servicio que consta de un servidor y una cola de espera. Se establece para cada
estacin de servicio una determinada tasa de llegada y una tasa de servicio de peticiones. El
conjunto formado por las estaciones de servicio y sus clientes (los usuarios) forma un
sistema de colas que puede ser analizado usando la teora de colas.
Simulacin. Se construye un programa que reproduce el comportamiento temporal del

sistema basndose en sus estados y sus transiciones.
Planificacin de hilos
La planificacin de hilos depende de los tipos de hilos soportados por el SO.
Si slo se soportan hilos a nivel de usuario el SO no es consciente de su existencia, debiendo

ser el proceso que los lanza quien debe encargarse de su planificacin.
Si se soportan hilos del ncleo el sistem operativo los planifica utilizando alguno de los
mtodos vistos anteriormente.
El planificador debe tener en cuenta la sobrecarga que puede producir en el sistema el
cambio de contexto entre hilos de distintos procesos.
22
Captulo 4.
Sincronizacin y comunicacin de procesos
La ejecucin concurrente de procesos presenta varios problemas, todos ellos asociados al hecho de
que no es posible predecir la velocidad relativa de ejecucin de un proceso. Dicha velocidad es
funcin de la poltica de planificacin del sistema operativo, de la forma en que se tratan las
interrupciones y de la actividad de los otros procesos en el sistema.
Uno de los principales problemas de la ejecucin concurrente de procesos es que el acceso a
recursos globales compartidos (memoria, dispositivos de E/S, etc) debe controlarse de alguna forma
si se desea que el resultado de la ejecucin de un proceso sea independiente de la velocidad de
ejecucin del proceso con respecto a los otros procesos concurrentes.
Exclusin mutua
Interaccin entre procesos concurrentes
En un sistema con multiprogramacin se ejecutan mltiples procesos de manera concurrente.

Podemos distinguir
Procesos independientes, que se ejecutan sin tener en cuenta la existencia de otros procesos.
Procesos cooperantes, que intercambian informacin o colaboran entre s para compartir un

recurso o realizar alguna tarea.
Cooperacin directa: los procesos conocen la existencia e identidad de los otros procesos
con los que colaboran.
Cooperacin indirecta, los procesos no conocen la existencia e identidad de los otros
procesos y, en consecuencia, no se comunican con ellos pero deben garantizar que los
recursos queden en un estado coherente.
Condiciones de carrera
El problema denominado condicin de carrera (race condition) surge cuando mltiples procesos
independientes se ejecutan concurrentemente y acceden para leer o escribir en un recurso
compartido. En ese caso el resultado final de la ejecucin depende del rden en que se hayan
planificado los procesos.
Secciones crticas
Seccin crtica o regin crtica de un proceso es una instruccin o conjunto de instrucciones

secuenciales de su cdigo que requieren manipular un recurso compartido (variable, dato, fichero,
) con otros procesos. Dentro del cdigo de un proceso pueden existir varias regiones crticas.
Descripcin de la exclusin mutua
Las condiciones de carrera se evitaran si el uso de un recurso por parte de un proceso excluye su
uso para los restantes. Este mecanismo se denomina de exclusin mutua.
Sin ms requisitos adicionales la exclusin mutua puede producir problemas como interbloqueos o
inanicin de procesos.
El interbloqueo o bloqueo mutuo de dos o ms procesos se produce cuando dos procesos A y

B necesitan dos recursos R1 y R2 para realizar una cierta funcin. Si A posee R1 y B posee
R2, ambos se quedarn esperando por el recurso que necesitan; no pueden liberar el recurso
que poseen porque estn esperando el otro recurso para realizar la funcin correspondiente.
23
La inanicin de un proceso se produce cuando este no puede progresar al necesitar un

recurso al que nunca llega a acceder porque el sistema operativo siempre da prioridad a
otros procesos.
Para evitar esto, los mecanismos de exclusin mutua deben cumplir cinco requisitos:
1. Slo un proceso puede estar a la vez en una seccin crtica asociada a un recurso R.
2. No pueden realizarse suposiciones sobre la velocidad relativa y prioridad de ejecucin de los
procesos concurrentes.
3. Un proceso que no est ejecutando una seccin crtica asociada a un recurso R no est
impidiendo o bloqueando el uso de R a otros procesos.
4. Debe evitarse la inanicin de procesos. Un proceso no debe permanecer en su seccin crtica
por tiempo ilimitado.
5. Si ningn proceso est en una seccin crtica asociada a R, debe concederse rpidamente el
acceso a esa seccin crtica al proceso que lo solicite.
Soluciones software a la exclusin mutua
No presuponen el apoyo del sistema operativo o del hardware del ordenador para su
implementacin.
Hacen uso de un bucle de comprobacin del valor de una o varias variables cerrojo (lock). La
comprobacin del valor en un bucle se denomina cerrojo con vuelta (spinlock). Este tipo de espera
se denomina espera activa (busy waiting) o espera cclica (spin waiting).
Uso de cerrojo y alternancia estricta. Esta solucin considera la existencia de una variable
global de acceso que se usa como cerrojo y que puede tomar como valor el identificador
numrico de un proceso.
Este mtodo posee dos inconvenientes: la velocidad de ejecucin se ve limitada por el
proceso ms lento. Adems, si un proceso falla antes de cambiar el valor de la variable
global el otro proceso quedar bloqueado indefinidamente.
Algortimo de Peterson. Simplificado para dos procesos, se dispone de un vector donde cada
proceso establece a TRUE su deseo de acceder al recurso. Adems, se guarda en una variable
global el identificador del otro proceso. Un bucle de espera cclica comprueba que la
peticin pueda ser atendida y que el recurso no est siendo utilizado por el otro proceso.
#define FALSE 0
#define TRUE 1
int turno;
int peticion_rec[2];
void acceso_sc(int pid) {
int otro_pid;
otro_pid = 1 pid;
peticion_rec[pid] = TRUE;
turno = otro_pid;
while(turno == otro_pid && peticion_rec[otro_pid == TRUE):
}
Cada proceso llama a acceso_sc antes de acceder a su seccin crtica y al salir llamara a
salida_sc, que establece a FALSE su entrada en peticion_rec. Este algoritmo garantiza la
exclusin mutua ya que el proceso que primero ejecuta la instruccin
peticion_rec[pid] = TRUE obtiene el acceso al recurso. Se evita la posibilidad de
interbloqueo al almacenarse en turno el valor del pid del otro proceso.
24
Captulo 4. Sincronizacin y comunicacin de procesos
Soluciones a la exclusin mutua con apoyo del hardware
Uso de instrucciones mquina especiales que bloquean el uso del bus. Se caracterizan por
ser atmicas, es decir, se ejecutan en un nico ciclo de instruccin que no puede ser
interrumpido. Una instruccin tpica en muchos procesadores es probar y configurar (test
and set): ccc r1, cerrojo, que copiara el contenido de la posicin de memoria compartida
cerrojo en el registro r1 y escibe en cerrojo un valor distinto de cero.
El principal inconveniente es que tambin hay que realizar una espera activa para comprobar
el valor del cerrojo. Tambin pueden producirse interbloqueos.
Bloqueo de las interrupciones. Antes de entrar en una regin crtica, puede ejecutarse una
instruccin especial que bloquea el mecanismo de interrupciones del sistema, restaurndolo
al salir de la seccin crtica. Pero el sistema se puede degradar bastante al no permitirse
atender las interrupciones mas prioritarias en el momento en que llegan, Adems, se deja en
manos del proceso la decisin de ceder el procesador, pudiendose quedar el sistema colgado
si este nunca lo devuelve. Esta solucin no sirve en el caso de multiprocesadores.
Semforos
Son un mecanismo de sincronizacin de procesos concurrentes gestionados por los sistemas
operativos. Un semforo es una variable que almacena un valor entero sobre el que se pueden
realizar tres operaciones bsicas:
Asignar un valor inicial entero no negativo. S
P(S). [wait].
V(S). [signal].
= N
Disminuir en una unidad el valor del semforo. S = S 1. Si S se hace

negativo, el proceso que ha llamado al semforo pasa a la cola de procesos bloqueados
asociada al semforo.
Incrementa en una unidad el valor del semforo, S = S + 1. Si S es menor o
igual a cero, se eliminar uno de los procesos bloqueados la cola y se pasa al estado
preparado.
Los nombres P y V, se suelen encontrar como wait y signal. En este texto wait_sem y signal_sem.
El anterior es un semforo general o semforo con contador. La versin de semforo que slo puede
tomar los valores 0 y 1 se denomina semforo binario o mutex funcionando de la siguiente manera:
wait_sem(S).
Si S = 0, el proceso pasa a cola de bloqueados, si S = 1, pone el semforo a

cero y contina su ejecucin.
signal_sem(S).
Si la cola de bloqueados est vaca, pone el semforo a 1 y contina. Si no

est vaca, se elimina un proceso de la cola de bloqueados y pasa al estado preparado.
Implementacin
El sistema operativo se encarga de asignar las estructuras de datos necesarias para los semforos y
de realizar las operaciones sobre ellos.
Las operaciones wait_sem y signal_sem son implementadas por el ncleo como primitivas o
funciones atmicas, esto es, que se ejecutan como un nico ciclo de instruccin que no puede ser
interrumpido.
En la implementacin de estas primitivas en el ncleo se ha de resolver un problema de exclusin
mutua.
En sistemas monoprocesadores la exclusin mutua se garantiza bloqueando las interrupciones
cuando se est ejecutando una operacin sobre el semforo.
25
struct semaforo {
int contador;
/* Otras variables para implementar el semforo y su cola */
/* que dependen del sistema operativo */
}
void init_sem(semaforo S, int valor)
S.contador = valor;
}
void wait_sem(semaforo S) {
/* Bloqueo de interrupciones */
S.contador = S.contador 1;
if (S.contador < 0) {
/* Aadir el proceso a la cola del semforo */
/* Bloquear el proceso */
/* Desbloquear las interrupciones */
} else {
/* Desbloquear las interrupciones */
}
}
void signal_sem(semaforo S) {
/* Bloqueo de las interrupciones */
S.contador = S.contador + 1;
if (contador <= 0) {
/* Eliminar un proceso P de la cola del semforo */
/* Aadir el proceso P a la cola de procesos preparados */
}
/* Desbloqueo de las interrupciones */
}
En sistemas multiprocesador no puede emplearse la tcnica de bloqueo de interrupciones, sino que

se utilizan instrucciones especiales del procesador.
struct semaforo {
int contador;
int ocupado;
/* Otras variables para implementar el semforo y su cola */
/* que dependen del sistema operativo */
}
void init_sem(semaforo S, int valor)
S.contador = valor;
}
void wait_sem(semaforo S) {
while (!test_set_maquina(S.ocupado)) // Bucle de espera activa
S.contador = S.contador 1;
if (S.contador < 0) {
/* Aadir el proceso a la cola del semforo */
/* Bloquear el proceso */
S.ocupado = 0;
}
void signal_sem(semaforo S) {
while (!test_set_maquina(S.ocupado)) // Bucle de espera activa
S.contador = S.contador + 1;
if (contador <= 0) {
/* Eliminar un proceso P de la cola del semforo */
/* Aadir el proceso P a la cola de procesos preparados */
}
S.ocupado = 0;
}
Si el procesador no dispone de ninguna instruccin especial, debe emplearse algn algoritmo como
el de Peterson.
La cola puede gestionarse con cualquier algoritmo, siendo FIFO el ms utilizado.
26
Utilidad de los semforos

Obtencin de exclusin mutua
Se utilizan tantos semforos como recursos distintos se compartan, protegiendo el acceso a los
recursos mediante secciones crticas.
#define TRUE 1
semaforo S
void proceso_X() {
while(TRUE) {
/* Seccin no crtica */
wait_sem(S);
/* Seccin crtica asociada al recurso a utilizar */
signal_sem(S);
/* Seccin no crtica*/
}
}
Sincronizacin de procesos
En este caso basta con que el proceso que espera la ocurrencia de un suceso ejecute wait_sem para
pasar al estado bloqueado. El proceso que lanza la operacin ejecuta signal_sem para notificar que
el suceso se ha producido, provocando que el proceso que espera prosiga su ejecucin.
#define TRUE 1
semaforo S
void procesoA() {
while(TRUE) {
// . . .
wait_sem(S); // Se bloquea en espera de un evento
// . . .
}
}
void procesoB() {
while(TRUE) {
// . . .
signal_sem(S); // Notifica la ocurrencia de un evento
// . . .
}
}
void main() {
init_sem(S, 0); // Inicia el semforo binario S
ejecucin_concurrente(procesoA, procesoB);
}
Problemas potenciales asociados a un mal uso de los semforos
Una mala colocacin de las operaciones signal_sem y wait_sem puede provocar errores difciles de
detectar. En los siguientes ejemplos el semforo acceso se utiliza para garantizar exclusin mutua.
signal_sem(acceso);
// Seccin crtica
wait_sem(acceso);
En este caso se ha invertido el rden correcto de las operaciones, por lo que varios procesos podran
estar accediendo al mismo tiempo a la seccin crtica.
wait_sem(acceso);
// Seccin crtica
wait_sem(acceso)
En este ejemplo se escibe un segundo wait_sem en lugar del correcto signal_sem para indicar la
liberacin del recurso. Por tanto, el proceso nunca desbloquear el recurso, ya que una vez
27
finalizada la seccin crtica vuelve a bloquearse. El resto de procesos que intenten acceder a su
seccin crtica tambin sern bloqueados ya que el recurso nunca se ha dado por liberado
producindose un interbloqueo.
Problemas clsicos de sincronizacin de procesos concurrentes

El problema de los productores y los consumidores
Un proceso (o varios) generan datos y otro proceso (o varios) los consumen. Se utiliza un buffer (el
recurso compartido a proteger), en el que los productores escriben, si no est lleno, y los
consumidores leen, si no est vaco.
#define TRUE 1
#define N 100 // Tamao del buffer
semaforo_binario acceso;
semaforo ocupado, disponible;
void productor() {
int dato;
while (TRUE) {
dato = generar_dato();
wait_sem(disponible);
wait_sem(acceso);
escribir_buffer(dato);
signal_sem(acceso);
signal_sem(ocupado);
}
}
void consumidor() {
int dato;
while (TRUE) {
wait_sem(ocupado);
wait_sem(acceso);
leer_buffer(dato);
signal_sem(acceso);
signal_sem(disponible);
}
}
// Dato a grabar en el buffer

//
//
//
//
//
Espera/comprueba que el buffer tenga espacio libre

Espera a que el buffer est disponible
Entrar en seccin crtica: escribir en el buffer
Liberar el buffer
Avisa al consumidor de la existencia de datos
// Dato a leer del buffer

//
//
//
//
//
Espera a que haya datos disponibles en el buffer

Espera a que el buffer est disponible
Leer dato del buffer / Seccin crtica
Liberar el buffer
Informa que tras la lectura, hay espacio en el buffer
void main() {
init_sem(acceso, 1);
// Inicializa el semforo binario
init_sem(disponible, N); // Indica el espacio disponible
init_sem(ocupado, 0);
// Indica el espacio ocupado
ejecucin_concurrente(productor, consumidor);
}
Se utilizan un semforo binario para acceder al buffer y dos semforos para indicar el espacio
disponible y el ocupado en el buffer, que sern utilizados por los consumidores y productores.
El problema de los lectores y los escritores
Un ejemplo tpico de acceso a bases de datos. Mltiples lectores acceden a los registros, un escritor
slo puede acceder si no hay ningn lector accediendo. Los lectores slo pueden acceder si no se
est escribiendo. Mltiples lectores pueden estar accediendo al mismo tiempo. Slo un escritor
puede acceder.
Para llevar la cuenta del nmero de lectores se utiliza una variable global contador cuyo acceso se
protege mediante un semforo binario. Otro semforo binario controla el acceso a los datos.
28
#define TRUE 1
semaforo_binario S1, S2;
int contador = 0;
void lector() {
while (TRUE) {
wait_sem(S2);
contador = contador + 1;
if (contador == 1) wait_sem(S1);
signal_sem(S2);
leer_dato();
wait_sem(S2);
contador = contador 1;
if (contador == 0) signal_sem(S1);
signal_sem(S1);
procesar_dato();
}
}
void escritor() {
producir_dato();
wait_sem(S1);
escribir_dato();
signal_sem(S1);
}
//
//
//
//
Intenta acceder a la variable contador

Hay un lector ms accediendo
Si es el 1er lector, bloquea el acceso al escritor
Se libera el acceso a la variable contador
//
//
//
//
Solicitud de acceso a la variable contador

Hay un lector menos
No hay lectores, se permite el acceso al escritor
Libera el acceso a la variable contador
// Espera a tener acceso de escritura

// Libera el recurso
void main() {
init_sem(S1, 1);
init_sem(S2, 1);
contador = 0;
}
Monitores
Definicin
Un monitor, es un mdulo software que consta de un conjunto de procedimientos, variables y

estructuras de datos que posee la propiedad especial de que solo permite a un nico proceso
simultneamente ejecutar alguno de sus procedimientos. Las variables contenidas en un monitor
slo son accedidas por los procedimientos del monitor y no por procedimientos externos.
Para la sincronizacin de procesos, el monitor dispone de las variables de condicin, cada una de
ellas asociadas a una cola de procesos bloqueados en espera de que esa condicin se cumpla.
Sobre una variable de condicin se pueden realizar dos operaciones, en este texto:
wait_mon(X).
El proceso que realiza esta operacin queda suspendido en la cola de procesos

bloqueados asociada a la condicin X. Al contrario que en los semforos, esta operacin
siempre produce el bloqueo del proceso que la invoca.
signal_mon(X).
Comprueba si en la cola de procesos bloqueados asociada a la variable X

existe algn proceso. En ese caso, se desbloquea un proceso. Esta operacin no opera sobre
un contador. Si no hay ningn proceso en cola, esta operacin no tiene ningn efecto y la
seal de aviso se pierde. Segn la propuesta de B. Hansen (1975) el proceso que invoca esta
operacin sale del monitor inmediatamente, siendo por tanto la sentencia final del
procedimiento de un monitor.
Estructura y declaracin de un monitor
Un monitor consta de N procedimientos, M variables de condicin, un conjunto de datos y algunas

rutinas de inicializacin del monitor. En el monitor slo puede haber a la vez un proceso ejecutando
alguno de sus procedimientos.
Cuando un proceso entra en el monitor permanece hasta que invoque wait_mon(X). En ese momento
el proceso pasa a la cola de bloqueados X pudiendo entrar otro proceso al monitor. Si un proceso en
29
el monitor invoca signal_mon(X) un proceso de la cola de bloqueados es desbloqueado o, si

estuviera vaca, entrara un nuevo proceso al monitor en caso de que hubiese procesos esperando en
la cola de entrada.
Uso de los monitores
Los monitores tambin pueden utilizarse para garantizar la exclusin mutua y la sincronizacin
entre procesos.
Por la propia definicin del monitor la exclusin mutua est garantizada defininiendo el acceso a los
recursos compartidos dentro del monitor.
Mediante el uso de las variables de condicin y las operaciones
proporcionar la sincronizacin de procesos.
wait_mon
signal_mon
se puede
La solucin a los productores y consumidores utilizando monitores sera:

#define TRUE 1
#define N 100
// Capacidad
monitor mon1
// Definicin
condicion lleno vacio;
int contador;
char buffer[N];
del buffer
del monitor
// Variables de condicin
// Variables locales
void escribir(int dato) {

// Procedimiento del monitor
if (contador == N) wait_mon(lleno); // Si buffer est lleno, bloquea escritor
insertar_dato(buffer, dato);
contador = contador + 1;
if (contador == 1) signal_mon(vacio); // Si buffer no vaco, desbloquea lector
}
void leer(int dato) {
if (contador == 0) wait_mon(vacio); // Si buffer vaco, se bloquea lector
extraer_dato(buffer, dato);
contador = contador 1;
if (contador == N-1) signal_mon(lleno); // Si no lleno, desbloquea escritor
}
{
contador = 0;
}
end monitor
// Inicializacin del monitor
void productor() {
while (TRUE) {
dato = producir_dato();
mon1.escribir(dato);
}
}
void consumidor() {
while (TRUE) {
mon1.leer(dato);
consumir_dato(dato);
}
}
void main() { ejecucion_concurrente(productor, consumidor) }
Paso de mensajes
Definicin
El paso de mensajes es un mecanismo de sincronizacin y comunicacin entre procesos soportado

por los sistemas operativos tanto de sistemas centralizados como distribuidos. Un mensaje es un
conjunto de informacin que puede ser intercambiada entre un proceso emisor y un proceso
receptor.
Las operaciones bsicas son:
30
send(destino, mensaje)
receive(fuente, mensaje)
El argumento mensaje es la direccin de memoria de la estructura de datos que contiene el mensaje

a enviar o donde se almacena el mensaje a recibir.
Los aspectos bsicos a considerar son
La especificacin de la fuente y el destino del mensaje.
El esquema de sincronizacin.
El formato del mensaje.
El medio de almacenamiento.
Especificacin de la fuente y el destino del mensaje

Comunicacin directa
Emisor y receptor del mensaje especifican explcitamente a qu proceso va dirigido o de quin se

espera el mensaje. Otra posibilidad es que el receptor especifique implcitamente el proceso emisor
del mensaje, pudiendo llegar ste de cualquier emisor.
La comunicacin directa explcita es til para procesos concurrentes cooperantes, la comunicacin
directa implcita cuando un proceso realiza una operacin en funcin del mensaje enviado por un
proceso que no se conoce a priori (cola de impresin...).
Comunicacin indirecta
El proceso emisor enva el mensaje a una estructura de datos compartida, el buzn, que se
implementa como una cola de mensajes.
Un emisor un receptor: para comunicacin privada entre procesos.
Un emisor varios receptores: para difundir determinada informacin entre varios procesos.
Varios emisores un receptor: tpico en aplicaciones cliente servidor.
Varios emisores varios receptores: varios servidores atienden concurrentemente a varios

clientes.
Esquemas de sincronizacin
Pueden distinguirse varios casos en funcin de si el proceso emisor o receptor pueden pasar al
estado bloqueado al realizar una operacin send o receive.
con bloqueo: el emisor pasa al estado bloqueado hasta que el mensaje sea recibido por
el receptor o por el buzn.
Send
Send
Receive
Receive
sin bloqueo: el emisor enva el mensaje al buzn o al destinatario y sigue con su

ejecucin. Al no garantizarse su recepcin deben emplearse mensajes de respuesta. El
emisor tambin podra estar intentando enviar el mensaje repetidamente, degradando el
rendimiento
con bloqueo: el receptor permanece en estado bloqueado en espera un mensaje. Si
este nunca llega, el receptor quedara indefinidamente bloqueado.
sin bloqueo. El receptor obtiene un mensaje de un buzn o un emisor y prosigue su
ejecucin. El mensaje puede ser nulo o no.
El esquema ms utilizado es el envo sin bloqueo y la recepcin con bloqueo. El envio y recepcin
con bloqueo se conoce como cita (rendezvous) entre emisor y receptor.
31
Formato y almacenamiento de los mensajes
El mensaje est formado por una cabecera y un cuerpo.

La longitud del mensaje puede ser fija o variable. Los mensajes de longitud fija son ms eficientes
para el sistema operativo, siendo los de longitud variable ms sencillos para el programador de los
procesos emisores.
Dependiendo de la capacidad de las colas de mensajes tenemos
Mecanismo de mensajes sin buffer, en el que los mensajes nunca pueden esperar y el proceso
emisor se bloquea en espera de su recepcin.
Mecanismo de mensajes con buffer, en el que los mensajes se almacenan en un buffer

normalmente gestionado por un algoritmo de tipo FIFO.
Uso del paso de mensajes
Se pueden utilizar para intercambiar informacin entre procesos as como para garantizar la
exclusin mutua y la sincronizacin.
#define TRUE 1
#define N 5
// Nmero de procesos
void proceso(int i) {
mensaje testigo;
while (TRUE) {
// Seccin no crtica
receive(buzon1, testigo);
// Seccin crtica
send(buzon1, testigo);
// Seccin no crtica
}
}
void main() {
mensaje nulo;
crear_buzon(buzon1);
send(buzon1, nulo);
ejecucion_concurrente(proceso(1),..., proceso(N));
}
Ejemplo de exclusin mutua utilizando un buzn y send sin bloqueo y receive con bloqueo. El
mensaje se utiliza como paso de testigo para ir pasando la utilizacin del recurso entre procesos.
32
Captulo 5.
Interbloqueo
Introduccin
De forma general, un recurso hardware o software se puede clasificar en:
Recurso reutilizable, como archivos, semforos, y elementos hardware. Una instancia de un

recurso reutilizable slo puede asignarse a un proceso como mximo. Slo cuando un
proceso finaliza el uso de de una instancia de un recurso reutilizable puede ser usada por
otro. Los recursos hardware son reutilizables.
Recurso consumible, como buffers de entrada/salida y mensajes. Estos recursos pueden

crearse y posteriormente consumirse (destruirse).
Definicin y condiciones del interbloqueo

De forma general puede definirse como aquella situacin en la que un conjunto de procesos est
bloqueado en espera de la liberacin de uno o varios recursos que se encuentran asignados a otros
procesos del mismo conjunto.
Para que se produzca el interbloqueo es necesario que se produzcan cuatro condiciones:
1. Exclusin mutua, por la que cada instancia de un recurso solo puede ser asignada a un
proceso como mximo.
2. Retencin y espera. Cada proceso retiene los recursos asignados mientras espera adquirir
otros que necesita.
3. No existencia de expropiacin. Si un proceso posee un recurso, no se le puede expropiar.
4. Espera circular, en la que una cadena de procesos se encuentra uno esperando la liberacin
de un recurso que posee el siguiente en la cadena y el ltimo espera por el primero.
Tres son las principales estrategias para el tratamiento de los interbloqueos:
1. Prevencin de interbloqueos, impidiendo que alguna de las cuatro condiciones anteriores
llegue a producirse.
2. Evitacin de interbloqueos, examinando las consecuencias de asignar los recuros antes de
hacerlo.
3. Deteccin y recuperacin de interbloqueos, comprobando cada cierto tiempo la existencia
de interbloqueos y actuando para eliminarlos de haberse producido.
Grafos de asignacin de recursos

Un grafo de asignacin de recursos puede utilizarse para detectar la presencia de interbloqueos,
suponiendo que las condiciones de exclusin mutua y no expropiacin ya se cumplen. Con los
grafos se comprueba si existe condiciones de retencin y espera y espera circular.
Si el grafo no contiene ningn camino que sea un ciclo puede garantizarse la no existencia de
interbloqueos. Si aun habiendo un ciclo alguno de los recursos dispone de ms de una instancia y
esa instancia no forma parte de otro ciclo no existe interbloqueo.
Cada proceso se representa con un cculo y cada recurso con un cuadrado. Cada instancia de un
recurso se representa con un punto dentro del cuadrado. Si un proceso ha solicitado un recurso y se
encuentra bloqueado se representa una flecha que sale del proceso hacia el recurso. Si un proceso
tiene asignada una instancia de un recurso se representa una flecha desde la instancia del recurso
hasta el proceso.
33
Figura 5.1: Grafo de asignacin de recursos.

Con un ciclo, pero sin interbloqueos.
Prevencin de interbloqueos
Esta estrategia persigue eliminar alguna de las cuatro condiciones necesarias para la existencia de
interbloqueos.
Eliminacin de la condicin de exclusin mutua
Esta condicin no puede eliminarse en recursos compartidos si se quiere garantizar la integridad y

no corrupcin.
Eliminacin de la condicin de retencin y espera
Puede eliminarse haciendo que un proceso solicite al mismo tiempo todos los recursos que precisa,
no concedindoselos si alguno no se encuentra disponible. Requiere el previo conocimiento de las
necesidades. Puede degradar el rendimiento del sistema o provocar inanicin si un proceso retiene
un recurso y otros esperan a obtenerlo. Los recursos pueden verse infrautilizados.
Eliminacin de la no existencia de expropiacin
La expropiacin solo es posible si el sistema puede salvar el estado en que se encuentra antes de la
expropiacin para poder restaurarlo al mismo estado una vez devuelto. Aumenta la sobrecarga del
sistema.
Eliminacin de la espera circular
Puede eliminarse asignando un nmero a cada recurso y obligando a que los procesos slo puedan
solicitar los recursos en orden ascendente. La principal desventaja es que los recursos deben ser
solicitados en ese orden y no cuando realmente se necesiten.
Evitacin de interbloqeos
Consiste en conceder slo aquellas peticiones de recursos que tengan garantizado que no
conducirn a un estado de interbloqueo.
Un proceso debe especificar por adelantado todos los recursos que va a necesitar. Despus, los va
solicitando conforme los va necesitando. Si la concesin es segura, no conduce a interbloqueo, se
realiza.
El sistema operativo debe llevar la cuenta de los recursos disponibles, el nmero de recursos
asignados a cada proceso y el nmero de recursos que restan por asignar. Adems comprueba que la
asignacin es segura.
34
Captulo 5. Interbloqueo
Estado de la asignacin de recursos: estados seguros y estados inseguros.
Se dispone de:
Vector de recursos existentes, RE; cada elemento del vector R En indica la cantidad de instancias n
existentes del recurso R.
Vector de recursos disponibles, RD; donde se indica el nmero de instancias disponibles del recurso
R.
Matriz N de recursos mximos necesitados por cada proceso. Cada fila corresponde a un proceso y
cada columna a un recurso existente en el sistema.
Matriz A de recursos asignados a cada proceso, correspondiendo cada fila a un proceso y cada
columna al nmero de recursos asignados
El estado del sistema con respecto a la asignacin de sus recursos en un instante determinado queda
definido por los vectores RE, RD y las matrices N y A.
Un estado se dice que es seguro si posibilita al menos una secuencia de asignacin de recursos a los
procesos que garantiza que estos puedan finalizar sin producirse interbloqueos. Un estado inseguro
no ofrece esa garanta, aunque no necesariamente tiene que conducir a un estado de interbloqueo.
En la prctica, habra que comprobar que ( N i Ai)R D , esto es, que los recursos necesitados
menos los asignados no superan los recursos disponibles.
Ver ejemplos 5.3 y 5.4 en el libro de teora, pginas 176-179.
Denegacin de asignacin de recursos: el algoritmo del banquero.
Consiste en no conceder una peticin de recurso si esta concesin puede conducir a un estado
inseguro.
Este algoritmo asegura que el nmero de recursos asignados a todos los procesos nunca puede
exceder del nmero de recursos del sistema y que nunca se puede hacer una asignacin peligrosa,
que conduzca a un estado inseguro. Para ello:
1. Se parte de un estado inicial seguro Sk, con k = 0: Sk = {N, A, RE, RD}
2. Cuando un proceso solicita un recurso se simula su concesin y se crea un estado ficticio
S' = {N', A', RE, R'D}
3. Se comprueba si S' es seguro. Si lo es, S k+1 = S', en caso contrario se deniega la peticin y se
bloquea el proceso hasta que se le puedan conceder los recursos.
4. Volver al paso 2.
Denegacin de la iniciacin de un proceso
Esta tcnica consiste en no iniciar un proceso si el nmero mximo de recursos que va a necesitar
durante su ejecucin puede conducir a un estado de interbloqueo. Esta tcnica no es ptima, ya que
supone que todos los procesos van a solicitar simultaneamente todas las instancias de recursos que
van a necesitar.
En la prctica se trata de determinar que el proceso p+1 puede iniciar su ejecucin si el nmero
mximo de instancias j que necesita sumadas al nmero mximo de instancias de esos recursos
necesitadas por los procesos existentes no superan el nmero de instancias existentes.
35
Deteccin y recuperacin de interbloqueos

Esta estrategia consiste en no limitar las asignaciones de recursos a los procesos y comprobar
periodicamente si se ha producido algn interbloqueo. En caso afirmativo, se emplea alguna tcnica
para recuperar el sistema del interbloqueo.
Algoritmos de deteccin de interbloqueos
El algoritmo de Coffman emplea RE, vector de recursos existentes; RD, vector de recursos
disponibles; A, matriz de recursos asignados a cada proceso; y M, matriz de recursos adicionales
necesitados por cada proceso.
Inicialmente todos los procesos estn sin marcar y se van marcando aquellos que pueden ser
completados. Los procesos marcados no pueden provocar interbloqueo. Si al finalizar el algoritmo
queda ms de un proceso sin marcar existe interbloqueo.
1. Se marca cada proceso que tenga su fila en A a cero, dado que ese proceso no tiene ningn
recurso asignado y, por tanto, no puede producir interbloqueo.
2. Se realiza la asignacin X = RD, donde X es un vector auxiliar.
3. Para cada proceso i no marcado se comprueba M i X
4. Si no existe ningn i que cumpla la condicin, el algoritmo finaliza. Si existe un proceso i
que cumpla la condicin se marca el proceso y se ejecuta hasta que finalice y libere los
recursos, se realiza X = X + Ai (que incrementa los recursos disponibles con los liberados
por el proceso i) y se vuelve al paso 3.
Frecuencia de invocacin del algoritmo de deteccin de interbloqueos
Invocarlo cada vez que se solicite un recurso aumenta la sobrecarga del sistema. Una solucin
ptima puede ser invocarlo cada T unidades de tiempo o cuando el nivel de utilizacin del
procesador caiga por debajo de un lmite, lo que podra denotar inactividad por existencia de
interbloqueo.
Tcnicas de recuperacin del interbloqueo
Recuperacin mediante expropiacin de recursos. Mediante algn criterio de seleccin se

van expropiando recursos a algunos procesos y concedindoselos a otros para conseguir salir
del interbloqueo.
Recuperacin mediante el retroceso de los procesos interbloqueados a algn punto de

control previo. En cada punto de control se guarda el contexto de cada proceso. En caso de
interbloqueo se restaura el contexto anterior.
Recuperacin mediante aborto selectivo de procesos, estableciendo un criterio para ir

abortando procesos (bloqueados o no).
Recuperacin mediante el aborto de todos los procesos bloqueados. La solucin ms

drstica pero la ms utilizada.
Ventajas e inconvenientes
La deteccin y recuperacin de interbloqueos permite una mayor concurrencia de procesos ya que

no limita el nmero de asignaciones. Sin embargo, la deteccin introduce sobrecarga aunque puede
limitarse con algoritmos eficaces. La recuperacin s produce elevada sobrecarga y
desaprovechamiento de recursos. Es eficaz en sistemas con baja probabilidad de interbloqueos.
36
Captulo 5. Interbloqueo
Otras estrategias de tratamiento de interbloqueos
Estrategias mixtas, agrupando los recursos en diferentes clases, ordenando las clases para
evitar la espera circular y utilizando para cada clase la estrategia ms oportuna.
Ignorar los interbloqueos. Sistemas como UNIX o Windows no utilizan ninguna estrategia
de tratamiento de interbloqueos.
37
Captulo 6.
Administracin de memoria
Para que un programa pueda ser ejecutado por el procesador primero debe ser cargado en la
memoria principal. El subsistema de administracin de la memoria principal es el encargado de
administrar, junto con el hardware, la memoria principal entre todos los procesos que se ejecutan en
el computador.
Tcnicas de asignacin contigua. Todo el espacio de direcciones lgicas de un proceso se

carga de forma contigua en memoria principal.
Particionamiento fijo.
Particionamiento dinmico.
Tcnicas de asignacin no contigua. El espacio de direcciones lgicas de un proceso se

divide en bloques de igual o distinto tamao. Los bloques de un mismo proceso no tienen
por qu estar cargados de forma contigua en memoria principal.
Paginacin simple: bloques del mismo tamao.
Segmentacin simple: bloques de distinto tamao.
Espacio de ncleo y espacio de usuario
Al espacio ocupado por el cdigo, las estructuras de datos y la pila o pilas del ncleo del sistema
operativo se le llama espacio del ncleo. El acceso al espacio del ncleo slo puede realizarse en
modo ncleo.
Al espacio ocupado por la imagen de un proceso, es decir, a su espacio de direcciones de memoria
lgica se denomina espacio de usuario. El acceso al espacio de usuario puede realizarse en modo
ncleo o modo usuario.
En definitiva, en la memoria principal de un sistema multiprogramado pueden distinguirse el
espacio del ncleo, uno o varios espacios de usuario y espacio libre.
rea de intercambio en memoria secundaria
Un programa es un archivo ejecutable que reside en memoria secundaria dentro de algn directorio
del sistema de archivos.
El sistema operativo reserva espacio en memoria secundaria para almacenar las imgenes de los
procesos. A dicho espacio se le denomina rea de intercambio.
Se denomina intercambio (swapping) a la operacin de cargar la imagen de un proceso desde el rea
de intercambio a memoria principal y viceversa. Se habla de intercambio fuera de memoria
principal (swapping out), al paso de la imagen desde el rea de memoria principal al rea de
intercambio y de intercambio dentro de memoria principal (swapping in) al caso contrario.
La operacin de swapping out se suele realizar
Cuando se requiere espacio en memoria principal para cargar otros procesos.
Cuando otro proceso requiere de ms espacio debido al crecimiento de su regin de datos o

de pila.
Cuando es necesario regular el grado de multiprogramacin del sistema.
La operacin de swapping in suele realizarse
Cuando se desea aumentar el grado de multiprogramacin.
39
Existe espacio en memoria principal para cargar ms procesos.
Existe un proceso de mayor prioridad en el rea de intercambio.
Si el sistema no soporta memoria virtual la imagen del proceso se intercambia al completo.

La operacin de intercambio es realizada por un proceso del sistema denominado intercambiador,
encargado de
Gestionar y asignar el espacio de intercambio.
Seleccionar procesos para ser intercambiados fuera de memoria principal. Se esogen

primero aquellos procesos bloqueados con menor prioridad y mayor tiempo de residencia en
memoria. A continuacin se escogen los preparados con los mismos criterios anteriores.
Seleccionar procesos para ser intercambiados dentro de memoria principal. Se escogen

aquellos procesos preparados para ejecucin que lleven mayor tiempo de espera o con
mayor prioridad.
Puede considerarse que el intercambiador realiza las funciones del planificador a medio plazo.
No se trabaja directamente con el archivo ejecutable asociado al proceso y se trabaja con una
imagen en el rea de intercambio debido a que
Una operacin de lectura escritura es ms rpida en el rea de intercambio que en el sistema

de ficheros.
La imagen de un proceso es una entidad dinmica cuyo contenido suele diferir del archivo
ejecutable conforme va ejecutndose el proceso.
Asignacin de memoria en sistemas monoprogramados

En sistemas monoprogramados la memoria principal se divide en dos particiones. Una est
reservada para contener permanentemente aquellas partes del sistema operativo que deben estar
siempre en memoria principal. A este conjunto del sistema operativo residente en memoria se
denomina monitor del sistema operativo.
La memoria no ocupada conforma otra particin en la que se carga de forma temporal un proceso
de usuario o alguna parte no residente del sistema operativo.
En funcin de en qu parte de la memoria, direcciones bajas o direcciones altas, se encuentra el
monitor del sistema operativo podemos encontrarnos con tres posibles configuraciones de memoria:
40
Configuracin 1. La memoria principal se implementa con una memoria RAM. El sistema

operativo ocupa desde la direccin fsica 0 hasta DirF1. La parte superior, desde DirF+1 hasta
DirMAX est disponible. Esta configuracin no es usada actualmente, pero s en los primeros
micro y macrocomputadores.
Configuracin 2. La memoria principal se implementa mediante una RAM y una ROM. El

SO ocupa la ROM en la parte superior de la memoria principal, desde Dir F1+1 hasta DirMAX.
Sistema poco flexible, pero utilizado en sistemas integrados y computadores de mano.
Configuracin 3. La memoria principal se implementa con una RAM y una ROM. La

particin del sistema operativo ocupa la parte inferior de la RAM, en la que se almacena el
cargador de programas y el intrprete de comandos. El resto de la RAM forma la particin
de usuario y en la ROM se almacenan los vectores de interrupcin del hardware y las rutinas
de servicio de interrupcin. Esta memoria es conocida como BIOS, Basic Input Output
System. Configuracin utilizada en los primeros microcomputadores. MsDOS.
Captulo 6. Administracin de memoria
Para garantizar la proteccin del sistema operativo y evitar que los procesos de usuario hagan
referencia a direcciones fsicas del espacio del sistema operativo se utilizan uno o dos registros para
almacenar la direccin base de inicio de la particin y/o el tamao de la particin.
Particionamiento fijo
La forma ms sencilla de gestionar la memoria en sistemas multiprogramados consiste en dividir la
memoria principal en un nmero fijo de N particiones que pueden ser de igual o diferente tamao.
Esta divisin puede realizarse manualmente al arrancar el sistema o de manera automtica.
Esta tcnica se conoce como particionamiento fijo.
Se reserva una particin para contener el sistema operativo en un extremo de la memoria,
normalmente en la parte baja. Las restantes N-1 particiones estarn disponibles para cargar
procesos.
El nmero de particiones define el grado de multiprogramacin del sistema.
El sistema operativo mantiene una tabla de descripcin de particiones que contiene la direccin
fsica de comienzo (direccin base), el tamao y el estado (libre o no) de cada particin.
Particiones de igual tamao
La asignacin de memoria con particionamiento fijo y particiones de igual tamao es bastante

simple, ya que no importa qu particin libre se asigne a un proceso, pero:
Limita el tamao mximo de los procesos que se pueden cargar en memoria principal. Si un
proceso tiene un espacio de direcciones lgicas mayor que el disponible en la particin no
podr cargarse. Esta limitacin puede soslayarse si el proceso ha sido programado con la
tcnica de overlay o superposicin, mediante la cual slo una parte del proceso precisa que
se encuentre en memoria.
Fragmentacin interna. Si el tamao del espacio de direcciones lgicas es inferior al de la

particin asignada existe un espacio libre no asignable a otros procesos.
Particiones de distinto tamao
Para asignar las particiones a los procesos, el sistema operativo puede mantener una cola de
procesos por particin. Un proceso ingresa a la cola asociada a la particin de menor tamao que
pueda contenerlo. La planificacin de cada cola se realiza de forma independiente.
Este sistema puede provocar que las particiones de mayor tamao nunca se ocupen. Para resolverlo
puede emplearse una nica cola para todas las particiones. En el momento en que una particin
queda libre, se localiza un proceso que pueda ser cargado segn alguno de estos criterios:
Criterio del primer ajuste. Consistente en buscar el proceso ms cercano a la cabecera de la

cola con tamao menor o igual a la particin. Bsquedas rpidas pero no minimiza la
fragmentacin interna.
Criterio del mejor ajuste. Busca en toda la cola el proceso de mayor tamao que entre en la
particin. Minimiza la fragmentacin interna pero enlentece la bsqueda y discrimina a los
procesos ms pequeos. Podra solucionarse imponiendo un nmero mximo de veces que
puede ser discriminado un proceso.
La existencia de fragmentacin interna y la limitacin del tamao mximo del proceso que puede
ser cargado en memoria es menor en el caso de utilizar particiones de distinto tamao.
Configurando una particin lo suficientemente grande tambin es posible cargar procesos de mayor
tamao.
41
Traduccin de direcciones y proteccin
La traduccin de direcciones lgicas a direcciones fsicas en la tcnica de particionamiento fijo

requiere el uso de dos registros: el registro base y el registro lmite.
Cuando un proceso es planificado, el sistema operativo carga en el registro base la direccin fsica
de comienzo de la particin donde se aloja y en el registro lmite la direccin lgica ms alta del
espacio de direcciones lgicas del proceso.
Cuando se referencia una direccin se compara con el registro lmite y si es igual o inferior a este se
suma al registro base. Este mecanismo impide que se accedan a direcciones inferiores o superiores a
las asignadas a su espacio lgico.
Gracias a este mecanismo de traduccin de direcciones es posible cargar el proceso en cualquier
particin de la memoria principal. Se dice entonces que el sistema soporta la reubicacin dinmica
en tiempo de ejecucin.
La principal ventaja es su facilidad de implementacin, nicamente requiere de una tabla de

descripcin de particiones y una o varias colas, lo que produce poca sobrecarga.
Los principales inconvenientes son que provoca fragmentacin interna, el tamao mximo de un
proceso y la limitacin del grado de multiprogramacin en funcin del nmero de particiones.
Particionamiento dinmico
En el particionamiento dinmico el nmero de particiones no es fijo, sino que va variando con el
tiempo. La memoria principal se divide en particiones, una zona contigua de memoria ocupada, y
huecos, una zona contigua de memoria libre. Esta tcnica ha dejado de utilizarse, pero fue usada en
macrocomputadoras como el OS/MVT de IBM.
Cuando un proceso debe ser cargado en memoria el sistema localiza un hueco del mismo tamao o
mayor que el proceso. Ese espacio define una particin y el espacio sobrante define un nuevo
hueco.
Conforme se van cargando procesos se van generando nuevos huecos cada vez ms pequeos, en lo
que se conoce como fragmentacin externa. Una tcnica para solucionar la fragmentacin externa
es la compactacin de memoria, que consiste en agrupar todos los huecos y mover las particiones.
El inconveniente es que se produce alta sobrecarga.
Es comn que se utilice una unidad mnima de asignacin o bloque de memoria mnimo. Esto evita
el tener huecos de pequeo tamao que no pueden ser utilizados. Como contrapartida, se produce
fragmentacin interna, aunque despreciable en comparacin con la tcnica de particionamiento fijo.
El sistema mantiene una o varias estructuras de datos que contengan informacin sobre los huecos y
las particiones. Estas estructuras pueden ser mapas de bits o listas enlazadas simples o dobles.
Manteniendo una lista para huecos y otra para particiones asignadas es posible acelerar el proceso
de bsqueda de hueco disponible.
Asignacin de espacio de memoria principal
Algunos de los algoritmos de bsqueda ms utilizados para realizar la asignacin de espacio a un

proceso con un espacio de direcciones lgicas de tamao S son:
42
Algoritmo del primer ajuste (first fit): Se asigna el primer hueco con un tamao igual o
mayor que S. Rpido, pero produce pequeos huecos al comienzo de la estructura de datos.
Algoritmo del siguiente ajuste (next fit): La bsqueda de un hueco de tamao igual o mayor
que S comienza donde se qued la ltima bsqueda. Aunque se pens para evitar los
problemas del anterior, a la larga produce peores resultados.
Algoritmo del mejor ajuste (best fit): Se busca en toda la estructura de datos un hueco que
sea igual o con el mnimo exceso posible del valor de S. Ms lento, produce pequeos
huecos no utilizables que obliga a compactar.
Algoritmo del peor ajuste (worst fit): Se busca el hueco ms grande posible para intentar que
los huecos que se generen sean aprovechables con posterioridad. Distintas simulaciones han
demostrado que no es muy efectivo.
En resumen, el ms rpido es el de primer ajuste y el de menor aprovechamiento de la memoria es

el de peor ajuste.
Traduccin de direcciones y proteccin
Al igual que en la tcnica de particionamiento fijo, se utilizan dos registros dedicados denominados
registro base y registro lmite.
Cuando se va a ejecutar un proceso el sistema operativo carga en el registro base la direccin fsica
de inicio de la particin de memoria asociada al proceso y en el registro lmite el tamao de la
particin.
Cuando se haga referencia a una direccin lgica dentro del proceso se compara con el valor del
registro lmite. Si se excede, se lanza una excepcin.
Minimiza la fragmentacin interna, que es como mximo cercana a una unidad de

asignacin
Permite ejecutar procesos de mayor tamao.
Permite asignar fcilmente ms espacio a procesos cuya regin de datos o pila aumenta por
encima del tamao inicialmente asignado, reubicando el proceso o asignando un hueco
contguo.
Los inconvenientes son
Estructuras de datos ms complejas, que aumentan la sobrecarga del sistema.
Produce fragmentacin externa, lo que reduce el aprovechamiento de la memoria.
Paginacin simple
La tcnica de paginacin consiste en dividir la memoria principal en bloques del mismo tamao, S P,
denominados marcos de pgina o pginas fsicas. El espacio de direcciones de un proceso tambin
se divide en bloques del mismo tamao SP, denominados pginas o pginas lgicas.
Una pgina de un proceso se carga en un marco de pgina libre de memoria principal.
Si CMP es la capacidad de la memoria principal, el nmero N MP de marcos de pgina de tamao SP en
que se divide es
N MP = floor
( )
C MP
SP
Cada marco de pgina se identifica de forma unvoca mediante un nmero de marco de pgina j. De
esta manera, se har referencia al marco de pgina j o marco j de la memoria principal.
43
De otra parte, si CX es el tamao del espacio de direcciones lgicas de un proceso, el nmero de

pginas NP de tamao SP en que se descompone es:
N P=ceil
CX
SP
( )
Cada pgina de un proceso se identifica por un entero positivo i denominado nmero de pgina.
De los marcos en que se descompone la memoria principal, N MP, un nmero determinado de ellos, V,
estn reservados para el ncleo.
Una direccin fsica consta de dos campos: nmero de marco de pgina de f bits y el
desplazamiento dentro del marco, de d bits.
El tamao del campo de nmero de marco de pgina se obtiene a partir del nmero de marcos de
pgina existentes y el tamao del campo desplazamiento a partir del tamao de una pgina o de un
marco de pgina expresado en unidades direccionables.
Una direccin lgica consta de los campos de nmero de pgina, de p bits, y el desplazamiento
dentro de la pgina, de d bits.
El clculo del tamao de cada uno de estos campos es
min f {N MP 2 f } min d {S P 2 d } min p {N P 2 p }
El tamao de una direccin fsica es n= f + d , y el de una direccin lgica m= p+ d . La longitud
de una direccin lgica es menor o igual que la longitud de la direccin fsica.
Para implementar la paginacin generalmente se usan las siguientes estructuras:
Tablas de pginas. A cada proceso se le asigna una. Cada entrada i de la tabla contiene el
marco j donde se encuentra almacenada la pgina i del proceso y los permisos de acceso.
Tabla de marcos de pgina. Con tantas entradas como marcos de pgina tiene la memoria
principal. Cada entrada j contiene su estado libre u ocupado, punteros para crear una lista de
marcos libres y la ubicacin en memoria secundaria de la copia de la pgina i contenida en
el marco.
Lista de marcos libres. Consultada cuando hay que asignar espacio a los procesos. Cuando
hay que asignar un marco se selecciona el primero de la lista. Los nuevos marcos libres se
aaden por el final.
Para que un proceso pueda ser ejecutado, todas sus pginas deben estar cargadas en memoria,
aunque no necesariamente en marcos contiguos. Cuando un proceso de NP pginas de tamao tiene
que ser cargado, el sistema comprueba que existan NP marcos libres. Si los hay, se eliminan de la
lsita de marcos libres, se marcan como ocupados en la tabla de marcos de pgina y se carga en ellos
las pginas del proceso. A continuacin se crea o actualiza la tabla de pginas del proceso indicando
el nmero de marco donde est cargada cada pgina. Adems, si la tabla de pginas no estaba
creada ya, se almacena en el PCB del proceso un puntero a la direccin fsica de comienzo de la
tabla de pginas.
Traduccin de direcciones
El hardware debe disponer de ciertos componentes donde cargar la informacin necesaria para
realizar la traduccin de instrucciones. Pueden ser:
44
Registro base, donde se almacena la direccin fsica de comienzo de la tabla de pginas.
Banco de registros, para almacenar una copia completa de la tabla de pginas.
Buffer de traduccin de vista lateral (Translation Lookaside Buffer, TLB), una cach de alta
velocidad donde guardar algunas entradas de la tabla de pginas.
En funcin de la utilizacin de uno u otro componente se emplea uno u otro mtodo.

Traduccin de direcciones con registro base
El sistema carga en el registro base la direccin fsica DirF0 de comienzo de la tabla de pginas.
Cuando se referencia a una direccin lgica DirL se suma el campo nmero de pgina i a DirF0 para
obtener la direccin fsica DirF1 de la entrada i de la tabla de pginas.
A continuacin se accede a DirF1 en memoria para obtener el marco de pgina j donde se encuentra
la pgina i. Aadiendo el desplazamiento, se obtiene la direccin requerida.
Este mecanismo solo precisa que se cargue el registro base con cada cambio de proceso, lo que
acelera estos cambios.
En contra, la traduccin requiere de un acceso a memoria para localizar en la tabla de pginas el
marco j donde se encuentra la pgina i, lo que produce un retraso en la ejecucin de la instruccin y
hace que este mecanismo se utilice en raras ocasiones.
Traduccin de direcciones con banco de registros
Cuando se produce un cambio de contexto, el sistema operativo carga en el banco de registros una
copia de la tabla de pginas del proceso que se va a ejecutar.
De esta forma, en vez de localizar el nmero de marco donde se aloja la pgina en la tabla de
pginas en memoria se accede a su copia en el banco de registros.
Esta solucin no precisa de ningn acceso a memoria, por lo que es ms rpida, sin embargo slo
puede utilizarse si el tamao de la tabla de pginas no excede del tamao del banco de registros.
El cambio de proceso se ve ralentizado al tener que cargar toda la tabla de pginas en el banco de
registros desde la memoria.
Traduccin de direcciones con un TLB
Un TLB es una memoria cach especial de alta velocidad con una capacidad de entre 8 y 4096
entradas.
Cuando el procesador hace referencia a una direccin lgica DirL, primero se examina en paralelo
todas las entradas del TLB y se verifica si alguna coincide con el nmero de pgina i a que hace
referencia. Si se produce un acierto, se recupera el nmero de marco j de esa entrada para componer
la direccin fsica DirF junto con el campo desplazamiento d.
Si se produce un fallo, se acude a su bsqueda en la tabla de pginas en memoria como se realiza
con el mtodo de registro base y esa entrada se copia al TLB en una posicin libre o, si est lleno,
mediante algn algoritmo de reemplazo.
Cuando se produce un cambio de proceso se carga en el registro base la direccin de la tabla de
pginas y se limpia el TLB, que se ir cargando a medida que se vayan produciendo fallos en la
bsqueda de entradas.
El uso del TLB est a medio camino entre la solucin de registro base y la de banco de registros.
Tablas de pginas paginadas
Para evitar las tablas de pginas de gran tamao estas se pueden descomponer, a su vez, en pginas,
obteniendo una tabla de pginas paginada. De esta forma la tabla de pginas se fragmenta y puede
ubicarse en memoria principal de forma no contigua. Se tienen as dos tipos de pginas:
Pginas ordinarias, que contienen instrucciones y datos del espacio lgico de un proceso.
45
Pginas de tablas de pginas, que contienen entradas de tablas de pginas.
Para localizar en memoria principal a las pginas de una tabla de pginas se utiliza otra tabla de
pginas denominada tabla de pginas de primer nivel o tabla de pginas primaria. A las entradas
de la tabla de pginas original contenidas en una pgina se les denomina tablas de pginas de
segundo nivel o tabla de pginas secundaria.
Para cada proceso existe una tabla primaria y varias de segundo nivel, tantas como pginas ocupe la
tabla de pginas original del proceso.
Existen dos niveles de paginacin: el primero permite localizar el marco de pgina donde se ubican
las pginas de la tabla de pgina original, el segundo permite localizar el marco donde se ubica la
pgina ordinaria i a que hace referencia a que hace referencia la direccin lgica.
El campo nmero de pgina de una direccin lgica se descompone en dos campos:
ndice de tabla primaria, ITP, que contiene el nmero de la tabla de pginas de primer nivel
donde buscar el marco de memoria que contiene a la pgina que ubica la tabla de pginas de
segundo nivel. Si la tabla de pginas de primer nivel tiene N TP1 entradas, el tamao r de ese
campo ser min r {N TP1 2r }
ndice de tabla secundaria, ITS, que contiene el nmero de la entrada de la tabla de pginas
de segundo nivel donde bucar el marco de pgina que contiene a la pgina ordinaria
referenciada. Si la tabla secundaria tiene NTP2 entradas, el tamao s del campo ser
min s {N TP2 2 s }
El nmero de entradas de la tabla de pginas de primer nivel es igual al nmero de pginas

que se necesitan para contener la tabla de pginas original.
El nmero de entradas de la tabla de segundo nivel es igual al nmero de entradas de la tabla
de pginas original contenidas en una pgina.
La traduccin de una direccin lgica a un direccin fsica se realiza
1. Se suma ITP al contenido del registro base DirF0 para construir la direccin fsica DirF1 de la
entrada de la tabla de pginas de primer nivel donde buscar el marco de memoria k que
contiene a la pgina donde se ubica la tabla de segundo nivel.
2. Se accede a DirF1 para leer el nmero de marco k y se le suma al ITS para construir la
direccin fsica DirF2 de la entrada de la tabla de pginas de segundo nivel donde localizar el
marco de memoria j que contiene la pgina i referenciada en la direccin lgica DirL
3. Se accede a memoria principal para leer el nmero de marco j y construir la direccin fsica
DirF3 equivalente a la direccin lgica DirL.
Se requiere de esta forma de dos accesos a memoria para realizar la traduccin.
Si la tabla de pginas de primer nivel an resulta grande, puede descomponerse en otras pginas,
alcanzando paginaciones de 3 nivel (SPARC) o 4 nivel (Motorola 68030).
Tablas de pginas invertidas
Otra posible solucin a las tablas de pginas de gran tamao. Se utiliza una nica tabla de pginas
invertida en vez de una tabla de pginas por proceso.
En la tabla invertida, se asocia una entrada por cada marco j de la memoria principal en vez de por
cada pgina i de un proceso. El nmero de entradas es fijo e igual al nmero de marcos.
Cada entrada j contiene el nmero de pgina i que se aloja en el marco j, identificador del proceso al
que pertenece la pgina (Pid), y bits de control.
46
Para traducir una direccin lgica se compara el campo nmero de pgina de la direccin y el Pid
con los campos homnimos de cada entrada de la tabla. Si se produce una coincidencia en la
entrada j, ese marco j es quien contiene la pgina i referenciada que se requiere para construir la
direccin fsica.
La bsqueda de una entrada en la tabla invertida puede ralentizar el tiempo de traduccin. Puede
acelerarse utilizando una tabla hash y TLB.
Proteccin
En la gestin de memoria mediante paginacin, la proteccin se implementa a nivel de pgina. Cada

entrada i de la tabla de pginas de un proceso contiene un campo de uno o varios bits que permiten
determinar el tipo de acceso permitido sobre dicha pgina: w, rw, x, etc. En caso de intento de
violacin se lanza una excepcin.
Tambin se incorpora un registro lmite donde se carga el nmero de pginas de que consta el
proceso.
Comparticin de pginas
El espacio lgico de un proceso puede dividirse en las regiones de cdigo, datos y pila. En
paginacin simple, todas las pginas deben estar cargadas en memoria.
En sistemas de tiempo compartido, multiples usuarios pueden estar ejecutando el mismo programa
de manera simultanea. Si el programa posee cdigo reentrante, no modificable, se puede ahorrar
espacio en memoria cargando slo una imagen de ese proceso y compartindola entre todos los
usuarios.
Se utiliza un contador de referencias que lleva la cuenta del nmero de instancias activas. Se
elimina de memoria cuando el contador se hace cero.
La paginacin simple presenta varias ventajas
No produce fragmentacin externa.
Produce una sobrecarga pequea, la gestin de las estructuras de datos no requiere de mucho
tiempo de procesador.
No precisa de intervencin humana para la definicin de las particiones.
Permite comparticin de cdigo comn entre varios procesos.
La principal desventaja es que produce fragmentacin interna, de trmino medio, media pgina por
proceso.
La paginacin es invisible al programador, lo que puede ser considerado tanto como una ventaja
como un inconveniente.
Segmentacin simple
La segmentacin simple es una tcnica de gestin de la memoria que soporta los elementos en los
que se descompone el cdigo de un programa. Bsicamente, el compilador divide el programa en
segmentos. Cada segmento es una entidad lgica conocida por el programador y asociada a una
determinada estructura de datos o mdulo.
Cada segmento, cdigo principal, subrutinas, datos, pila... tiene su propio espacio de direcciones
lgicas. Cuando el sistema operativo crea un proceso asociado a un determinado programa, asigna
a cada segmento un identificador numrico positivo h, el nmero del segmento.
47
Una direccin lgica consta de dos campos: el nmero de segmento, de s bits, y el desplazamiento
dentro del segmento, de d bits. En un proceso se pueden tener direcciones lgicas de diferente
tamao, si bien el campo nmero de segmento tendr siempre la misma longitud, el campo
desplazamiento depende del nmero de unidades direccionables que existan en ese segmento en
concreto.
En segmentacin simple, un proceso no puede ser ejecutado si todos sus segmentos no se
encuentran cargados en memoria principal. El sistema operativo debe buscar un hueco para cada
segmento. Si algn segmento no pudiera ser cargado no aborta la carga del proceso.
Adems, en la carga el sistema crea una tabla de segmentos asociados al proceso idexada por
nmero de segmento que contiene la direccin fsica base de cada segmento y su longitud, adems
de otros datos como permisos, ubicacin en memoria secundaria, etc.
Traduccin de direcciones
Si se dispone de un registro base, en cada cambio de contexto el sistema carga en ese registro la
direccin fsica de comienzo de la tabla de segmentos, Dir F0, obtenida del bloque de control del
proceso.
Para llegar a una direccin fsica DirF a partir de una direccin lgica DirL se siguen estos pasos:
Se suman el campo nmero de segmento h de la direccin lgica y Dir F0 para obtener la

direccin DirF1 de la entrada h de la tabla de segmentos.
Se accede a DirF1 y se lee la direccin fsica base y la longitud del segmento h.
Se compara el campo desplazamiento con la longitud del segmento, lanzando una excepcin
si se supera el tamao.
Si el desplazamiento es menor que la longitud se suma la direccin fsica base del segmento
h al desplazamiento indicado en DirL para obtener la direccin fsica DirF equivalente.
El principal inconveniente es que se requiere de un acceso a memoria para leer la tabla de

segmentos, lo que provoca un retardo en la ejecucin de la instruccin en curso.
Para acelerar la ejecucin puede utilizarse un banco de registros o un TLB.
Proteccin
La proteccin del espacio de direcciones se implementa a nivel de segmento. En cada entrada h de

la tabla de segmentos de un proceso se almacenan los permisos de acceso sobre dicho segmento.
Adicionalmente suele haber un registro lmite donde se almacena en cada cambio de contexto el
nmero de segmentos de que consta el proceso que va a ser ejecutado.
Comparticin de segmentos
Esta tcnica permite que un segmento de cdigo o datos sea compartido por ms de un proceso.
Para ello el sistema operativo mantiene una tabla con los segmentos cargados en memoria principal
en la que se contabilizan las referencias que otros procesos realizan a estos segmentos. Cuando el
contador de referencias se haga cero, el segmento puede ser eliminador de memoria principal.
Como ventajas:
48
Produce una fragmentacin interna despreciable, de como mximo cercana a una unidad de
asignacin.
Soporta la visin modular que el programador posse del programa.

Permite manejar con facilidad estructuras de datos que crecen. Si un segmento precisa de
ms espacio, tan solo hay que asignarle un hueco contiguo o reasignarlo a un hueco de
mayor tamao.
Facilita la proteccin y comparticin de las distintas partes de un programa al asignarse un

segmento independiente a cada una de ellas.
Entre los inconvenientes, destacan:
Produce fragmentacin externa, lo que reduce el aprovechamiento de la memoria y requiere

el uso de compactacin, aunque menor que el producido con la tcnica del particionamiento
dinmico.
Aumenta la sobrecarga del sistema debido a que las estructuras de datos y algoritmos son
ms complejos que en particionamiento dinmico.
Segmentacin con paginacin simple

La segmentacin y la paginacin pueden combinarse para aprovechar las ventajas de ambos
mtodos.
Mediante esta tcnica se divide cada segmento de un proceso en un determinado nmero de
pginas. Una direccin lgica se descompone en tres campos: nmero de segmento, de s bits,
nmero de pgina, de p bits y desplazamiento, de d bits.
Con la carga de un proceso en memoria principal, el sistema operativo crea una tabla de segmentos
del proceso y varias tablas de pginas, una por segmento. La entrada de la tabla de segmentos no
contiene la direccin fsica del segemento, sino la de la tabla de pginas asociada al segmento.
Ahora, el campo longitud del segmento viene expresado en nmero de pginas.
Si se dispone de un registro base, el proceso de traduccin de direcciones comienza cargando en el
registro base la direccin fsica DirF0 de comienzo de la tabla de segmentos asociada al proceso.
Cuando se hace referencia a una direccin lgica DirL se traduce a una direccin fsica
1. Se suma el campo de nmero de segmento h de la direccin lgica y DirF0 para obtener la
direccin de comienzo de la entrada h de la tabla de segmentos, DirF1.
2. Se accede a DirF1 para obtener la direccin base de la tabla de pginas y la longitud del
segmento.
3. Se compara el valor desplazamiento de DirL con la longitud del segmento h. Si el
desplazamiento es mayor, se genera una excepcin.
4. Se el desplazamiento es menor, se suma el campo nmero de pgina de DirL y la direccin
fsica base de la tabla de pginas del segmento para obtener la direccin fsica DirF2 de la
entrada i de la tabla de pginas.
5. Se accede a DirF2 para leer el nmero de marco j que contiene la pgina referenciada.
6. Se construye la direccin fsica DirF con el nmero de marco ledo y el campo
desplazamiento de DirL.
El mecanismo precisa de dos accesos a memoria principal, pudiendo acelerarse utilizando un banco
de registros o un TLB.
49
Captulo 7.
Memoria virtual
La tcnica de gestin de memoria conocida como memoria virtual consiste en tener cargadas en
memoria principal solo aquellas partes (pginas o segmentos) del espacio de direcciones lgicas,
ahora tambin llamadas direcciones virtuales, de un proceso que se van necesitando durante su
ejecucin.
La memoria virtual permite ampliar el grado de multiprogramacin, dado que en memoria principal
caben ms procesos si slo se cargan algunas partes de cada proceso.
La implementacin de la memoria virtual requiere que el hardware soporte el reinicio de las
instrucciones de su repertorio. Adems, suele utilizarse un componente denominado unidad de
gestin de memoria (Memory Management Unit, MMU), encargada de realizar la traduccin de la
direccin virtual a la direccin fsica.
La memoria virtual puede implementarse usando paginacin por demanda (UNIX, Linux,
Windows), segmentacin por demanda (OS/2) o segmentacin con paginacin por demanda
(Multics)
Paginacin por demanda

La tcnica de paginacin por demanda divide el espacio de memoria principal en bloques de igual
tamao, marcos de pgina, y el espacio de direcciones del proceso en bloques de igual tamao,
pginas.
Para que un proceso se pueda ejecutar no es necesario que todas sus pginas se encuentren cargadas
en memoria principal. Cuando se referencia una pgina no cargada se produce un fallo de pgina.
Otras tareas a realizar por el Sistema Operativo son:
Reemplazamiento de pginas, en caso de que se produzca un fallo de pgina y no haya

ningn marco libre, es necesario decidir qu marco hay que intercambiar a memoria
secundaria.
Asignacin de marcos de memoria principal. El sistema debe decidir cuntos marcos asignar
inicialmente a cada proceso.
Control de carga, decidir el grado de multiprogramacin del sistema.
Copia en memoria secundaria de pginas modificadas, en qu momento y de qu forma.
Se mantienen las siguentes estructuras de datos: tabla de marcos de pgina, listas de marcos libres
y tablas de pginas.
Cuando un proceso entra en estado preparado para ejecucin se crea una tabla de pginas en
memoria principal en la que cada entrada contiene, al menos, los siguientes campos:
Nmero de marco de pgina.
Validez o presencia, que indica si la pgina es vlida o no.
Proteccin, de uno a tres bits que indican los permisos de R, W y X.
Referenciada, un bit activo cuando la pgina es referenciada por una direccin virtual.
Modificada, un bit que indica si la pgina ha sido modificada y debe ser actualizada en
memoria secundaria.
51
Reinicio de instrucciones
Un fallo de pgina puede producirse tanto en la fase de bsqueda, al intentar traducir la siguiente
instruccin a ejecutar, como de ejecucin, en la bsqueda de operandos.
La arquitectura del computador debe poder reiniciar la instruccin desde su inicio, fase de
bsqueda. Para ello, se suele disponer de un registro donde se almacena el valor del registro
contador de programa CP antes de iniciar la fase de bsqueda.
En caso de que el procesador soporte direccionamiento indexado tambin deber guardarse el valor
del registro ndice por si fuera necesario restaurarlo tras un fallo de pgina.
Localizacin de las pginas en memoria secundaria
Cuando la referencia a una pgina produce un fallo de pgina el sistema operativo debe leer esa
pgina desde la memoria secundaria y copiarla a la memoria principal. De igual modo, si no hay
marcos libres en la memoria principal el sistema operativo debe seleccionar una pgina para ser
reemplazada y, si esta ha sido modificada o no existe en el rea de intercambio, debe ser copiada
all.
El sistema operativo puede buscar en dos posibles localizaciones de memoria secundaria:
Bloque de disco de un archivo ejecutable. Parte de las pginas en que se divide el espacio de
direcciones, cdigo y datos, son creadas por el sistema operativo a partir del archivo
ejecutable del que es instancia el proceso.
Bloque de disco del rea de intercambio, utilizada para el almacenamiento de las pginas de
un proceso cuando se intercambia fuera y para el almacenamiento de las pginas que han
sido seleccionadas para ser reemplazadas tras un fallo de pgina.
Cada bloque del rea de intercambio se identifica por un nmero de bloque o direccin de disco. El
sistema mantiene ciertas estructuras de datos para localizar los bloques donde se encuentran
almacenadas las pginas.
Algunos sistemas copian por adelantado al rea de intercambio todas las pginas de un proceso
cuando es creado con el fin de acelerar el tratamiento de los fallos de pgina. Pero si el espacio de
direcciones del proceso crece es necesario aumentar el tamao en disco por lo que hay que mover
todo el espacio del proceso. Para evitar esto, se copia el proceso por partes, datos, cdigo, etc. de
manera que si slo es preciso crecer la parte de datos el trabajo es menor.
Otros sistemas no copian el espacio de direcciones completo a memoria de intercambio, slo las
pginas que son necesarias. En ese caso, se utiliza una estructura de datos denominada tabla de
disco donde se relaciona cada pgina con el bloque de disco donde se encuentra alojada.
Bloqueo de marcos de pgina
Se dice que un marco de memoria est bloqueado o pinchado (pinning) si su contenido no puede ser
reemplazado. Este bloqueo resulta til si el marco contiene informacin que conviene que no sea
borrada, por ejemplo los marcos reservados para alojar el espacio del ncleo.
Tratamiento de un fallo de pgina
Cuando durante el ciclo de ejecucin de una instruccin se hace referencia a una determinada
posicin de memoria, la direccin de memoria virtual es pasada a la MMU para traducirla a una
direccin fsica. sta comprueba que la direccin est dentro del rango de direcciones permitido.
Si lo est accede a la tabla de pginas y comprueba el bit de validez o presencia. Si est activado, la
pgina se encuentra en memoria principal, con lo que la MMU toma el valor del campo de marco de
pgina para construir la direccin fsica junto al desplazamiento de la direccin virtual.
52
Captulo 7. Memoria virtual
Si el bit de validez est desactivado se produce un fallo de pgina y se guarda en la pila el

contenido del contador del programa y de los registros especiales y pasa el control al sistema
operativo.
El sistema operativo guarda el contexto del proceso cuya ejecucin produjo la excepcin y
comprueba que, en efecto, se debe a un fallo de pgina. A continuacin intenta averiguar la
direccin que produjo el fallo, bien consultado registros internos del procesador o simulando su
ejecucin.
Determinada la direccin se comprueba que sta sea legal, si no lo es se aborta el proceso. Si la
direccin s es legal, se consulta la lista de marcos libres y si no ha y ninguno se invoca a un
algoritmo de reemplado para seleccionar un marco donde cargar la pgina que produjo el fallo.
Si la pgina contenida en el marco elegido ha sido modificada, se planifica para ser copiada a disco
duro y mientras tanto se bloquea el proceso y el marco para evitar que pueda ser seleccionado por
otro proceso. Una vez que el marco est limpio, esto es, que la pgina que contena se ha pasado a
disco, se planifica la pgina a ser copiada de memoria al marco, se actualizan las tablas de pgina y
se restaura el contador de programa y los registros para que una vez que se pase el proceso al estado
preparado para ejecucin se carge su contexto y contine la ejecucin desde el punto en que se
interrumpi.
Conjunto de trabajo de un proceso

Los programas que se ejecutan en un computador cumplen el principio de localidad de referencias,
tambin denominado principio de proximidad, que afirma que durante un determinado intervalo de
tiempo de ejecucin de un proceso ste referencia direcciones virtuales prximas entre s, esto es,
pginas cercanas. Este conjunto de pginas forma una zona de localidad del proceso.
As, el conjunto de trabajo de un proceso en el instante ti de tiempo virtual es el conjunto de pginas
distintas que el proceso ha referenciado en sus ltimas referencias a memoria principal. El tiempo
virtual es el tiempo que un proceso est siendo ejecutado en el procesador.
Si se elige un valor de muy pequeo el conjunto de trabajo no cubrir toda la zona de localidad
actual si se elije muy grande se cubrir ms de una zona de localidad.
En la prctica, para reducir la sobrecarga se construye el conjunto de trabajo periodicamente cada
cierto tiempo virtual . Para ello se revisa el campo referenciada (bit r) de cada entrada de la tabla
de pginas del proceso. El conjunto de trabajo est formado por todas aquellas pginas que tengan
el bit r activado. Una vez construido, se pone r a cero.
As puede definirse el conjunto de trabajo de un proceso como el conjunto de pginas distintas que
el proceso en ejecucin ha referenciado en el intervalo de tiempo virtual.
Dos conclusiones interesantes son:
Una pgina miembro de un conjunto de trabajo no debe ser seleccionada como pgina
vctima para ser reemplazada ya que provocara un nuevo fallo de pgina.
Un proceso debe tener asignados el suficiente nmero de marcos para poder tener cargado
en memoria su conjunto de trabajo. En otro caso estar provocando continuamente fallso de
pgina produciendo el fenmeno de sobrepaginacin o trasiego (thrashing)
Reemplazamiento de pginas
El reemplazamiento de pginas consiste en seleccionar una pgina k cargada en un marco j de
memoria principal para ser reemplezada por la pgina i a la que haca referencia la direccin virtual
que produjo el fallo de pgina. La pgina seleccionada para ser reemplazada se denomina pgina
53
vctima. El conjunto de marcos candidatos hace referencia a los marcos de memoria principal donde
se encuentran almacenadas las pginas candidatas a ser reemplazadas.
Estrategia de reemplazamiento de pginas local, cuando el conjunto de pginas candidatas a

ser reemplazadas pertenecen al mismo proceso que provoc el fallo.
Estrategia de reemplazamiento de pginas global, cuando el conjunto de pginas candidatas

est formado por todas las pginas cargadas en memoria principal en marcos no bloqueados.
La estrategia de reemplazamiento local es ms fcil de analizar, pero su implementacin es ms

complicada y produce mayor sobrecarga.
Es deseable que el algoritmo de reemplazamiento disminuya el nmero de fallos de pgina a
medida que aumenta el nmero de marcos de pgina de la memoria principal. Si esto no sucede se
dice que el algortimo pacede la anomala de Belady. El alogirtmo FIFO sufre de esta anomala.
Algoritmo de reemplazamiento ptimo
Selecciona para ser reemplazada la pgina del conjunto de pginas candidatas a ser reemplazada
que tardar ms en volver a ser referenciada. Esto obliga a conocer con antelacin qu direcciones
virtuales van a ser referenciadas, pero esto no es posible y de ah que este algoritmo no pueda ser
implementador en la prctica pero s sirve como referencia para comparar con otros algoritmos.
Algortimo de reemplazamiento LRU
El algoritmo de reemplazamiento de la pgina usada menos recientemente o algoritmo LRU (Least

Recently Used) selecciona para ser reemplazada la pgina del conjunto de pginas candidatas que
lleva ms tiempo sin ser referenciada.
Este algoritmo es bastante bueno pero de implementacin compleja. Produce bastante sobrecarga.
Suele implementarse mediante una lista en la que cada entrada contiene el nmero de pgina del
conjunto de pginas a ser reemplazada. Cada vez que una pgina es referenciada se coloca al
principio de la lista y al final la pgina menos referenciada, esto es, la candidata a ser sustituida.
Cada vez que se referencia una direccin virtual la lista debe ser reordenada.
Otra implementacin se basa en un contador hardware que se incrementa cada vez que se referencia
una direccin. En la tabla de pginas se aade un campo que almacena ese valor cuando una pgina
es referenciada. De este modo, se selecciona para reemplazar la pgina que contenga el menor valor
en ese campo.
Algoritmo de reemplazamiento mediente envejecimiento
El algoritmo de reemplazamiento mediante envejecimiento (aging) es una aproximacin al

algoritmo LRU pero que introduce menor sobrecarga ya que puede impelmentarse de forma ms
eficiente.
Se utiliza un registro de desplazamiento de n bits, inicialmente a cero. Cada cierto tiempo T el
contenido del registro se desplaza a la derecha y se carga en el bit ms significativo el bit
referenciada, r, despus este bit se pone a cero. De este modo, la pgina a ser reemplazada es la que
tenga un menor valor en el registro.
El tamao del registro determina la edad mxima que puede registrarse, ya que en un registro de 8
bits, todos a cero, no se puede determinar si la pgina no se ha referenciado en un tiempo 8T o se
acaba de cargar.
Algoritmo de reemplazamiento FIFO
El algoritmo de reemplazamiento FIFO selecciona para ser reemplazada aquella pgina del conjunto
de pginas candidatas a ser reemplazadas que lleva ms tiempo cargada en memoria principal.
54
Para ello, el sistema mantiene una lista enlazada o cola FIFO en la que cada entrada contiene el
nmero de pgina de una pgina del conjunto de pginas candidatas a ser reemplazadas. Cuando
una pgina se carga en memoria se coloca al final de la lista. As, la pgina que se encuentre en la
cabeza de la lista indica la pgina que lleva ms tiempo cargada en memoria y ser la elegida para
ser reemplazada.
La gestin de este algoritmo requiere muy poco tiempo de proceso. Es el ms sencillo de programar
y de implementar, pero no tiene una buena tasa de aciertos y adems pacede la anomalua de
Belady.
Algoritmo de reemplazamiento de la segunda oportunidad (algoritmo del reloj)
Es una variante del algortimo FIFO que busca la pgina que lleva ms tiempo cargada en memoria
y no ha sido referenciada recientemente.
Bsicamente se consulta el bit referenciada, r, de la pgina que se encuentra al principio de la cola
FIFO, si r es cero, entonces es seleccionada para ser reemplazada. Si r es 1, se pone a cero y se
enva la pgina al final de la cola.
Se obtiene un mejor rendimiento que con FIFO pero a costa de mayor sobrecarga, ya que hay que
estar moviendo elementos en la cola.
Una forma de disminuir la sobrecarga es utilizar una lista o cola circular, as el puntero ndice de
cola es quien se mueve y no los elementos de la cola.
En este caso el algoritmo recibe el nombre de algoritmo del reloj.
Si adems del bit referenciada se tiene en cuenta el bit modificada, m, se mejora sustancialmente la
efectividad. En este caso nos encontramos con varias posibilidades.
r = 0 y m = 0. Pgina no referenciada recientemente y no modificada, candidata ideal para

ser reemplazada.
r = 0 y m = 1. Pgina no referenciada recientemente pero modificada. De ser elegida es

preciso actualizar la pgina en la memoria de intercambio.
r = 1 y m = 0. Ha sido referenciada recientemente, por lo que no es buena candidata.
r = 1 y m = 1. Ha sido referenciada y modificada recientemente, por lo que es probable que

vuelva a ser referenciada y, adems, es preciso actualizarla en memoria de intercambio.
Con estas premisas, el algoritmo del reloj busca en primer lugar, a partir de la posicin del puntero,
una pgina se busca una pgina con r = 0 y m = 0, si no se encuentra se busca entonces alguna con
r = 0 y m = 1, pero actualiza todos los r = 1 y los pone a cero. Si no encuentra ninguna vuelve a
buscar r = 0 y m = 0, de no encontrarla por cuarta vez busca una pgina con r = 0 y m = 1, con la
seguridad de que ahora s tendr xito ya que en la segunda ronda todos los r se pusieron a cero.
Algoritmo de reemplazamiento del reloj considerando el conjunto de trabajo
El algoritmo del reloj puede ser mejorado si se considera el conjunto de trabao de un proceso. A este
algoritmo resultante se le conoce con el nombre de algoritmo WSClock.
En este caso, cada entrada i de la pgina de un proceso debe tener un campo denominado tiempo de
ltimo uso, que contiene el tiempo virtual de ltimo uso de la pgina. Cuando se produce un fallo de
pgina se examina el bit r y si est a 1, se escribe en ese campo el tiempo virtual del proceso.
La diferencia del tiempo virtual del proceso con el tiempo almacenado nos da la edad del proceso.
Siendo el intervalo del conjunto de trabajo, si la edad de la pgina es mayor que , no pertenece al
conjunto de trabajo.
55
El algoritmo WSClock busca pginas con r = 0 y m = 0 y que no pertenezcan al conjunto de trabajo

del proceso. Si durante una vuelta completa se da la situacin de que todas las pginas pertenecen al
conjunto de trabajo del proceso, entonces seleccionar la primera pgina que encuentre con r = 0 y
m = 0, aunque pertenezca al conjunto de trabajo.
Conclusiones sobre los algoritmos de reemplazamiento
Los algoritmos ms utilizados por los sistemas operativos modernos son el de envejecimiento y el
WSClock.
La estragegia de reemplazo limita los algoritmos de reemplazamiento a utilizar. As, algoritmos
como FIFO, LRU y envejecimiento pueden utilizarse tanto con estrategia de reemplazo global o
local.
El algoritmo WSClock slo puede utilizarse con estrategia de reemplazo local.
Asignacin de memoria principal

Esta tarea consiste bsicamente en decidir cuntos marcos de pgina de la memoria principal se
reserva para un proceso que se tiene que ejecutar.
Se deben reservar como mnimo los marcos suficientes para contener todas las pginas a las que
pueda referenciar cualquier instruccin del repertorio de la mquina.
Como mximo, en teora, se pueden asignar a un proceso todos aquellos que no estuvieran
bloqueados, pero esto anula los beneficios de la multiprogramacin.
Dos estrategias de asignacin son:
Asignacin fija. Consistente en asignar a cada proceso un nmero fijo de marcos. El

principal inconveniente es que si el conjunto de trabajo del proceso crece por encima del
nmero de marcos asignados se producir sobrepaginacin aunque existan marcos libres en
memoria. Si el conjunto de trabajo disminuye, por debajo del nmero de marcos asignados,
se estara desperdiciando memoria. Si el sistema operativo utiliza estrategia de asignacin
fija, es obligado que la estrategia de reemplazo sea local.
Asignacin variable. Modifica a lo largo del tiempo el nmero de marcos que un proceso
tiene asignados. Minimiza la memoria desperdiciada y la sobrepaginacin a costa de
aumentar la sobrecarga ya que el sistema debe decidir continuamente cuntos marcos
reservar a cada proceso.
Para implementar la asignacin variable, que proporciona mejores resultados, se debe utilizar un
algoritmo de asignacin de marcos, siendo los ms conocidos:
Algoritmo de asignacin equitativa. Cada cierto tiempo se comprueba el nmero de

procesos en ejecucin y se asigna a cada uno el mismo nmero de marcos.
Algortimo de asignacin proporcional. Se asigna a cada proceso un nmero de marcos

proporcional a su tamao y/o su prioridad.
Algoritmo de asignacin por la frecuencia de fallos de pgina o algoritmo PFF. Se basa en

que cuanto mayor sea el nmero de marcos asignado a un proceso menor ser su tasa de
fallos, siempre que el algoritmo de reemplazamiento no sufra la anomala de Belady.
Si la tasa de fallos se encuentra por encima de cierto lmite, se asignan ms marcos al
proceso. Si la tasa de fallos cae por debajo de un lmite inferior se le quitan marcos. Si la
tasa de fallos est por encima del lmite pero no existen marcos libres ser necesario
intercambiar algn proceso al rea de intercambio
56
Control de carga
En un sistema multiprogramado con memoria virtual mediante demanda de pgina, el sistema
operativo debe controlar el nmero de procesos que tienen pginas cargadas en memoria principal,
esto es, debe controlar el grado de multiprogramacin GM.
Debe encontrarse un valor ptimo de GM con el fin de que se optimice al mximo el tiempo de
utilizacin del procesador. Si el grado de multiprogramacin es bajo, el procesador se ver
infautilizado por ausencia de procesos; si el G M es alto puede que no se puedan contener en la
memoria principal los conjuntos de trabajo de los procesos, producindose sobrepaginacin y por
tanto infrautilizacin del procesador, que debe esperar a que se realicen los intercambios con la
memoria secundaria.
Si se detecta sobrepaginacin es necesario reducir GM intercambiando algunos procesos a memoria
secundaria y repartir los marcos libres entre los procesos que la estaban provocando.
Copia en memoria secundaria de pginas modificadas

La estrategia seguida para realizar la copia a memoria secundaria de las pginas modificadas,
conocida como poltica de limpieza (cleaning policy) puede ser:
Limpieza por demanda. La pgina no se escribe hasta que es seleccionada para ser
reemplazada. Se aplaza la escritura hasta que no sea estrictamente necesario pero cuando se
produce un fallo de pgina hay que realizar dos operaciones de E/S: una para actualizar la
pgina modificada y otra para leer la nueva pgina.
Limpieza por adelantado. Las pginas modificadas se agrupan en lotes y se planifica su

escritura cada cierto tiempo. Permite atender ms rpidamente los fallos de pgina, al
realizar el volcado de la pgina antes de que se solicite, pero puede darse el caso de que una
pgina haya sido grabada y vuelva a ser modificada, debiendo realizarse de nuevo su copia.
Este problema puede solucionarse grabando solo las candidatas a ser reemplazadas.
Consideraciones adicionales sobre la paginacin por demanda

Aspectos a tener en cuenta al disear la memoria virtual de un sistema con paginacin por demanda
son el tamao de pgina, la paginacin por adelantado y la reserva de marcos libres (buffering).
Tamao de pgina
El tamao de pgina viene determinado por la arquitectura del computador, siempre potencia de
dos. Algunos computadores permiten seleccionar el tamao dentro de un rango de valores. Para
seleccionar el tamao adecuado hay que tener en cuenta:
Fragmentacin interna. De promedio es de media pgina por proceso. Cuanto mayor sea el
tamao de pgina, mayor ser la cantidad de memoria no utilizada.
Tamao de la tabla de pginas. Cuanto menor sea el tamao de pgina en ms pginas se

descompondr el proceso y en consecuencia el tamao de la tabla de pginas ser mayor.
Adems el tiempo de cambio de proceso aumenta al tener que cargar o vaciar ms registros,
con MMU, o banco de registros, si se dispone de TLB.
Nmero de fallos de pgina. Si el tamao de pgina es pequeo el espacio de direcciones

virtual constar de ms pginas, aumentando la probabilidad de que se produzca un fallo de
pgina.
Tiempo de uso de E/S. Se tarda menos tiempo en transferir una pgina de tamao grande que
varias de tamao ms pequeo. Si el espacio de direcciones virtuales se descompone en
57
mayor nmero de pginas aumenta la probabilidad de realizar operaciones de E/S, tiempo

que no puede ser utilizado para la ejecucin de procesos.
El aumento del tamao de la memoria principal de los computadores provoca que se de menos
importancia a la existencia de fragmentacin interna, escogindose tamaos de pgina cada vez
mayores.
Paginacin por adelantado
Cuando comienza la ejecucin de un proceso o se contina con uno que estaba bloqueado se
produce un conjunto de fallos de pgina iniciales hasta que se carga el conjunto de trabajo.
Para evitar esto se puede usar la estrategia de paginacin por adelantado (prepaging), que consiste
en cargar un cierto nmero de pginas N PA antes de iniciar o continuar su ejecucin o cada vez que
se produce un fallo de pgina.
En general, si se cargan NPA pginas se referenciarn NPR pginas y no se referenciarn NPA - NPR.
Cada pgina referenciada cargada por adelantado evita un fallo de pgina. Si el tiempo que se
ahorra en tratar NPR fallos de pgina es superior al empleado en cargar las NPA - NPR que no son
referenciadas s compensa utilizar paginacin por adelantado.
Si se decide utilizarla, la seleccin del conjunto NPA puede hacerse:
Cargar el conjunto de trabajo del proceso, que debe ser mantenido por el sistema operativo.
Opcin empleada cuando se va continuar con la ejecucin de un proceso interrumpido o
bloqueado.
Cargar un conjunto de pginas contiguas en el rea de intercambio, ya que el tiempo es

menor si se traen de una vez que si se recuperan una a una cuando sean referenciadas.
Reserva de marcos libres
Si se dispone de una lista de marcos libres donde cargar una pgina referenciada por una direccin
virtual que ha producido un fallo, el tiempo de tratamiento del fallo se reduce, ya que slo hay que
hacer uso de esa reserva de marcos libres.
Si la reserva de marcos libres cae por debajo de un lmite se utiliza un algoritmo de
reemplazamiento para seleccionar marcos reemplazables.
Mientras una pgina siga cargada en un marco, aunque est entre los marcos libres, podr ser
utilizada. Para ello cuando se produce un fallo de pgina primero se comprueba si est en la lista de
marcos libres antes de acudir a memoria secundaria. De este modo, esta lista de marcos libres se
utiliza como cach software de pginas.
Esta estrategia en ocasiones se denomina buffering de pginas.
58
Captulo 8.
Gestin de la Entrada/Salida
De forma general los dispositivos de E/S se pueden clasificar en dispositivos modo bloque y
dispositivos en modo carcter.
Un dispositivo en modo bloque almacena la informacin en bloques de tamao fijo, 512

bytes normalmente.
Un dispositivo en modo carcter enva o recibe informacin como una secuencia o flujo
lineal de bytes.
Un dispositivo debe ser conectado a un mdulo hardware denominado controlador de E/S para que
pueda ser utilizado por el computador. Un controlador puede manejar uno o varios dispositivos del
mismo tipo.
El sistema operativo se encarga de la gestin del acceso de los procesos a los dispositivos de E/S,
gestiona el buffering o el spooling.
Peticiones de E/S
Una operacin de E/S puede ser solicitada por un proceso o por el propio sistema operativo
mediante una llamada al sistema indicando la direccin lgica del dispositivo, la direccin lgica
del espacio del proceso donde se almacenarn los datos y la cantidad de datos a transferir.
Capas del ncleo de un sistema operativo encargadas de la E/S

El software del ncleo encargado de la gestin de E/S se puede organizar en tres capas: susbsistema
de E/S, drivers de los dispositivos y manejadores de interrupciones.
Cada capa posee una interfaz bien definida para comunicarse con las capas adyacentes y realiza
unos servicios determinados.
Subsistema de E/S
Es el componente que se encarga de efectuar todas las tareas necesarias para la realizacin de las
operaciones de E/S comunies a todos los dispositivos e independiente de estos. Entre sus tareas se
encuentran:
Asignacin y liberacin de dispositivos dedicados. Los dispositivos dedicados son aquellos

que slo pueden ser utilizados por un proceso cada vez, como impresoras o unidades de
cinta. El subsistema de E/S determina si la peticin de un proceso sobre un dispositivo
dedicado puede ser aceptada o rechazada.
Bloqueo de procesos que solicitan una operacin de E/S. El susbistema puede decidir pasar
al estado bloqueado al proceso que realiza la peticin de E/S, dependiendo del tipo de
llamada y del estado del dispositivo.
Planificacin de la E/S. El sistema debe planificar el usao de los dispositivos con el fin de
optimizar su uso, disminuir el tiempo de espera promedio y distribuir equitativamente el uso
de los recursos, atendiendo a las prioridades de las peticiones.
Invocacin del driver de dispositivo apropiado. Para el subsistema de E/S, un dispositivo es

una caja negra que soporta un conjunto estndar de operaciones. Realmente cada dispositivo
implementa estas operaciones de forma diferente y son los drivers los que conocen estas
particularidades.
Almacenamiento temporal de datos o buffering.
59
Proporcionar un tamao uniforme de bloque a los niveles superiores de software.
Gestin de errores producidos en una operacin de E/S. Estos errores pueden ser errores de
dispositivos o errores de programacin
El subsistema de E/S debe proporcionar una interfaz para los drivers de los dispositivos, tanto de
llamadas del subsistema al driver como del driver al susbsistema. En los sistemas operativos
modernos esta interfaz es uniforme.
Drivers de dispositivos de E/S
Un driver de dispositivo contiene el cdigo que permite a un sistema operativo controlar a un

determinado tipo de dispositivo. Se disea teniendo en cuenta las caractersticas del dispositivo y
las especificaciones del interfaz de drivers del subsistema de E/S.
Un driver suministra al subsistema de E/S el conjunto de funciones que se pueden realizar sobre el
dispositivo. Adems puede invocar ciertas rutinas o procedimientos del ncleo, segn estn
definidos en la interfaz.
El driver interacta con el dispositivo cargando las rdenes en sus registros. Un driver debe realizar
un conjunto de acciones cuando el subsistema de E/S invoca una funcin. En general son:
Comprobar que los parmetros son correctos y que la funcin se puede realizar.
Traducir los parmetros de la funcin en parmetros especficos del dispositivo.
Comprobar su el dispositivo est ocupado, encolando la peticin, o libre y preparado o si es

necesario inicializarlo.
Generar un conjunto de rdenes en funcin de la peticin y cargarla en los registros del

controlador.
Si el tiempo de espera de la ejecucin de la rden es elevado, se bloquea utilizando algn

mecanismo de sincronizacin.
Comprobar que no se hayan producido errores en la operacin de E/S, tomando las medidas
para resolverlo o abortar la operacin.
Examinar la cola de peticiones pendientes de E/S y atenderla o quedar a la espera en estado

bloqueado.
El cdigo de los drivers es reentrante, es decir, que no se modifica, por lo que es posible ejecutar
varias instancias del mismo driver simultneamente.
Manejador de las interrupciones
Cuando una operacin de E/S finaliza y el dispositivo se encuentra preparado para gestionar otra, su
controlador genera una interrupcin. Cada interrupcin suministra un nmero denominado nmero
del vector de interrupcin que se utiliza de ndice en una tabla denominada tabla de vectores de
interrupcin, normalmente almacenada en las posiciones ms bajas de memoria y en la que cada
entrada, vector de interrupcin, contiene entre otras informaciones la direccin de comienzo del
manejador, handler, de la interrupcin. Estos forman parte del ncleo y son extremadamente
dependientes del hardware.
Buffering
Si la transferencia de datos desde un dispositivo al proceso que realiza la peticin se realizara de
forma directa a su espacio de direcciones, el proceso debera estar cargado en un marco de memoria
durante todo el tiempo desde la peticin hasta la obtencin de resultados. El marco debe ser
bloqueado para evitar que la pgina del proceso fuera reemplazada. Cuanto mayor sea el nmero de
60
Captulo 8. Gestin de la Entrada/Salida
marcos bloqueados menor ser el nmero de marcos candidatos a ser reemplazados lo que puede
dar lugar a la sobrepaginacin. Adems, el proceso no puede ser intercambiado hasta que no finalice
la operacin de E/S.
Para evitar estos problemas se utilizan los buffers, rea de la memoria principal a la que nicamente
tiene acceso el sistema operativo. El subsistema de E/S asigna buffers para las operaciones de E/S y
los drivers de dispositivo o rutinas de servicio de interrupcin transfieren los datos entre los
dispositivos y buffers o viceversa. Adems, los buffers sirven para adaptar las distintas velocidades
y tamao de unidad de transferencia por parte de los dispositivos.
Estrategias
Buffering con buffer nico. Los datos se transfieren desde el dispositivo hasta el buffer y del
buffer al espacio del proceso en una operacin de lectura. Desde el espacio del proceso al
buffer y del buffer al dispositivo en una operacin de escritura. No se puede volver a utilizar
el buffer hasta que no finalice la operacin completa y se vace el buffer.
Buffering con dos buffers o buffering doble. Cuando se llena un buffer se utiliza el siguiente.
Mientras se llena el segundo se vaca el primero. En esta estrategia se desacopla el productor
del consumidor, ya que mientras uno escribe en un buffer se lee del otro. Adems se reduce
el tiempo de espera de productor o consumidor.
Buffering circular. Cuando un proceso realiza rfagas largas de E/S es ms conveniente el

empleo del bufferfng circular, consistente en disponer de varios bufferes utilizados de forma
consecutiva, volviendo a emplear el primero, si est vaco, finalizado el ciclo.
Cach de buffers de bloques de disco
Para reducir el nmero de operaciones de E/S a disco muchos sistemas operativos implementan va
software un cach de buffers de bloques de disco, un rea de la memoria principal del espacio del
ncleo reservada para buffers y que contiene los bloques de disco recientemente transferidos.
La gestin de la cach es similar a las cach hardware, debiend utilizarse algn algoritmo de
reemplazamiento (FIFO, LRU, etc) para seleccionar los buffers cuyo contenido deba ser
reemplazado.
Spooling
Una tcnica muy utilizada para la asignacin y control de los dispositivos de E/S dedicados, como
una impresora, suele utilizarse la tcnica del spooling. Se implementa mediante un proceso demonio
y un directorio especia, directorio de spool o spooling. El proceso demonio es el nico autorizado
para acceder al dispositivo. Si un proceso quiere hacerlo, enva los archivos deseados al directorio
de spooling desde donde el demonio los ir cogiendo para enviarlos al dispositivo.
Detalles de la gestin de E/S de algunos dispositivos

Relojes
Una forma de generar una seal peridica, reloj, es mediante un chip denominado reloj
programable que, entre otros, contiene un contador, un registro y un cristal de cuarzo.
Un reloj programable dispone de varios modos de operacin, como el de disparo nico o el de onda
cuadrada. En el modo disparo nico cuando el contador alcanza el valor cero se genera una
interrupcin y se detiene hasta que vuelva a ser inicializado.
En modo onda cuadrada el reloj se rearma automticamente volviendo a cargar en el contador el
valor del registro y comenzando de nuevo la cuenta.
61
El tiempo transcurrido entre dos interrupciones de reloj se denomina tic de reloj o, simplemente, tic.
El valor del tic puede ajustarse dependiendo del valor del registro. Se denomina frecuencia de reloj
al nmero de tics por segundo.
Para relojes en tiempo real es til que el contador se incremente, en vez de decrementarse.
Los relojes programables sirven para diversas tareas como:
Planificacin de procesos. Para controlar los cuantos asignados a los procesos en Round
Robin, por ejemplo. En algoritmos basados en prioridades, para adaptarla en funcin del
tiempo de uso del procesador que lleve acumulado.
Mantenimiento del tiempo real. En MS el punto de referencia son las 00:00:00 UTC del 1 de
enero de 1980 y en UNIX la misma hora y da de 1970. Para llevar el conteo de la hora es
necesario un contador de 64 bits. Para facilitar la gestin se utilizan dos contadores de 32
bits, uno con el conteo en segundos y otro para el nmero de tics del segundo actual.
Tambin se utiliza un contador de tics desde el tiempo de arranque, que se suma al valor de
alguna posicin de memoria donde se almacena el valor del tiempo real en el momento del
arranque.
Disparo de alarmas. El sistema puede avisar a los procesos cuando haya transcurrido
determinado intervalo de tiempo. Si ms de un proceso requiere una alarma, sera necesario
tener tantos relojes como procesos. Para evitarlo se utiliza la tcnica de lista de alarmas, en
la que se almacenan las peticiones ordenadas por tiempo de disparo. Cada entrada almacena
la diferencia entre el tiempo de disparo de todas las entradas precedentes y el tiempo de
disparo que requiere. Slo se decrementa un contador que, cuando llega a cero dispara la
alarma del primer proceso de la lista y elimina la entrada.
Invocacin de tareas peridicas del sistema. El sistema operativo mantiene una lista de
tareas peridicas, generalmente de adminstracin, que son lanzadas de forma similar al
disparo de alarmas.
Puesto que a lo largo de un segundo se producen muchas interrupciones de reloj, las tareas que
realiza el driver de reloj deben realizarse lo ms rpidamente posible para que no se resienta. Las
interrupciones de reloj, por ello, tienen una prioridad muy elevada.
Dependiendo del sistema operativo, algunas de las tareas que realiza el driver (decrementar cuantos
de ejecucin, incrementar el tiempo de uso del proceso, incrementar el contador del reloj de tiempo
real, decrementar el contador de alarmas y tareas peridicas..) son delegadas al manipulador de la
interrupcin de reloj.
Discos duros
Estructura fsica
Est formado por varios platos circulares de aleaciones de metal o plstico recubiertas de material
magnetizable que giran en torno a un eje vertical comn a velocidades tpicas de 5400, 7200 o
10800 rpm.
Cada superficie se divide en anillos concntricos llamados pistas. Las pistas se dividen en sectores
donde se almacena la informacin. El sector es la unidad bsica de transferencia de informacin de
un disco.
Sobre cada superfice existe un brazo en cuyo extremo se monta una cabeza de lectura/escritura. El
conjunto formado por las pistas de todas las superficies de todos los platos situadas a la misma
distancia del eje de rotacin se denomina cilindro.
62
Formateo a bajo nivel del disco
El formateo a bajo nivel o formateo fsico es realizado por el fabricante del disco mediante el uso de
un software y el controlador del disco. Consiste en dividir cada superficie de los platos en pistas y
cada pista en sectores. Cada sector consta de:
Cabecera o prembulo. Patrn de bits que permite al controlador reconocer el comienzo del
sector, el nmero del sector y el nmero del cilindro.
rea de datos. Con un tamao tpico de 512 bytes.
Cdigo de correccin de errores, ECC. Suele ocupar 16 bytes.
La capacidad del disco formateado a bajo nivel es inferior a la del disco sin formatear debido a los
huecos entre pistas y sectores y a una reserva de sectores para sustituir a sectores defectuosos.
Dentro de una pista los sectores se numeran desde 0 pero de manera intercalada en funcin de un
factor de intercalado o entrelazado. Del mismo modo, en una determinada zona de cilindros, la
numeracin de los sectores de una pista est desplazada respecto de la pista adyacente, sesgo de
cilindro (cylinder skew), para mejorar el rendimiento y evitar tener que esperar una vuelta completa
para leer el primer sector.
La direccin fsica de un sector queda definida por la tripleta cilindro-cabeza-sector (CHS,
Cylinder-Head-Sector). Los discos ms modernos soportan el mtodo de acceso de
direccionamiento de bloques lgicos, (Logical Block Address, LBA). Cada bloque se hace
corresponder con un sector durante el formateo fsico, haciendo corresponder de forma consecutiva
todos los sectores con bloques comenzado desde 0.
Particionamiento y formateo a alto nivel del disco
El particionamiento del disco consiste en establecer por software una o ms particiones en el disco.
Una particin es un conjunto de cilindros contiguos. Desde un punto de vista lgico, cada particin
se considera como un disco distinto.
En el sector 0 del disco se crea el registro de arranque maestro (Master Boot Record, MBR), y a
continuacin una estructura denominad tabla de particiones, que define el cilindro de comienzo de
cada particin y su tamao.
Una vez particionado se debe realizar un formateo de alto nivel o formateo lgico, que establece el
sector de aranque del sistema operativo, si es una particin activa, y las estructuras de datos del
sistema de archivos.
Es posible no establecer ningn sistema de archivos y trabajar directamente como si fuera un array
de bloques lgicos, E/S en bruto. El rea de intercambio de los sistemas UNIX utilizan este mtodo.
Planificacin del disco
El tiempo de lectura o escritura de un bloque del disco duro depende, entre otros factores, del
tiempo de posicionamiento de la cabeza de lectura/escritura y del tiempo de transferencia del
bloque desde el disco al controlador.
El tiempo de posicionamiento, o tiempo de acceso, es la suma del tiempo de bsqueda, tiempo
requerido para mover las cabezas hasta el cilindro, y la latencia rotacional o retardo rotacional,
tiempo necesario para que el principio del sector se posicione por el giro del disco debajo de la
cabeza.
Si las peticiones a disco se planifican adecuadamente es posible reducir el tiempo de bsqueda
promedio. Algunas estrategias son:
Planificacin de primero el del tiempo de bsqueda ms corto (Shortest Search Time First,
SSTF). Se selecciona la peticin que requiera, desde la posicin actual, el tiempo de
63
bsqueda ms pequeo. Puede producir inanicin de las peticiones de bsqueda ms

alejadas si llegan continuamente peticiones a zonas ms cercanas.
Planificacin LOOK. Las cabezas se desplazan en cierto sentido atendiendo las peticiones
que se encuentran en el camino y retorna hacia el sentido contrario. Si llega una peticin
cercana pero en sentido contrario deber esperar el regreso del cabezal.
En los discos que soportan LBA el algoritmo de planificacin se implementa necesariamente en el

controlador del disco, el nico que conoce los detalles de su organizacin fsica.
Tratamiento de los errores del disco
El error ms frecuente es un error de lectura o escritura de un sector debido a que est daado o
defectuoso. El controlador mantiene una lista de los sectores defectuosos para no utilizarlos. Un
sector defectuoso se identifica comprobando el ECC del sector. El controlador utiliza los sectores de
reserva mediante dos formas posibles:
Sustitucin directa. Si el sector j est daado, se utiliza un sector de reserva como sector j.
Se presenta el problema de alterar la organizacin del entrelazado.
Desplazamiento de sectores. Se desplaza una posicin cada sector situado entre el sector de
reserva y el daado. El sector de reserva se utiliza para contener el primer sector desplazado
y el ltimo sector desplazado alberga el nmero de sector que estaba defectuoso. Mantiene
la organizacin de la pista, pero requiere ms tiempo para realizarla.
Si el controlador no implementa ningn mtodo de reemplazo, debe hacerlo el sistema operativo.

Para resolver los problemas provocados por fallos en los discos se desarrollan soluciones basadas en
mltiples discos, en la que los datos son distribuidos por ms de uno y que, adems, mejoran el
rendimiento al poder atender en paralelo peticiones de E/S independientes. El sistema ms conocido
se denomina array redundante de discos independientes (Redundant Array of Independent Disks,
RAID).
Dispositivos de E/S adaptados al usuario
Gestin de la salida por pantalla
La pantalla de un computador es un dispositivo de salida de grficos de trama (raster graphics) o de

mapa de bits (bitmaps). Cada punto de la pantalla, pixel, tiene asociado un nmero binario que
representa el color con que se representa en la pantalla.
La pantalla se conecta a travs de un adaptador grfico que posee aun memoria de video (VRAM)
en la que se almacenan los pixels de la imagen que se mostrar en pantalla. El tamao de la VRAM
vendr determinado por el nmero de bits necesarios para representar un pixel y por el tamao de la
pantalla.
Las rutinas de manipulacin y creacin de grficos pueden formar parte del sistema operativo y
ejecutarse en modo ncleo, como en Windows, o ser externas al sistema y ejecutarse en modo
usuario, como en UNIX/Linux.
Gestin de la entrada del teclado
Un teclado es un dispositivo modo carcter de entrada. Cada pulsacin y liberacin de tecla envan
un nmero a un registro del controlador E/S que lo supervisa. ste genera una interrupcin que,
atendida por el manejador correspondiente, despierta el driver de teclado.
El driver utiliza un mapa de teclas o mapa de cdigo que resuelve la tecla pulsada en funcin de la
configuracin de idioma y tipo de teclado. El bit ms significativo del byte con que se informa de la
tecla pulsada indica si la tecla ha sido presionada o liberada. Tambin lleva la cuenta de las teclas
que han sido pulsadas y no liberadas con el fin de poder capturar combinaciones de ms de una
64
tecla. El driver almacena la informacin en un pequeo buffer para que sea leda por el proceso
adecuado.
Gestin de la entrada del ratn
Un ratn es un dispositivo modo carcter de entrada. El desplazamiento del ratn provoca la

transmisin de un mesaje al registro del controlador de E/S, de unos 3 bytes, que contiene el
desplazamiento vertical, eje y, desplazamiento horizontal, eje x y estado de los botones, pulsado o
no pulsado. Los desplazamientos son relativos a la ltima posicin registrada.
El controlador lanza una interrupcin cada vez que recibe un mensaje y el manejador de la
interrupcin despierta al driver, que lee el mensaje y lo coloca en una cola para que sea ledo y
procesado por el proceso adecuado.
65
Captulo 9.
Gestin de archivos
Archivos
Desde el punto de vista de los usuarios de los computadores, la unidad de trabajo es la abstraccin
de almacenamiento en memoria secundaria conocida como archivo o fichero.
Tipos de archivos
Un archivo informticose puede definir como un conjunto de informacin relacionada que se

almacena en memoria secundaria y que se identifica mediante un nombre, como una cadena de
caracteres. En general, un archivo contiene programas o datos.
Dos de los tipos de archivos comunmente soportados por los sistemas operativos son los directorios
y los archivos regulares u ordinarios.
Un directorio es un archivo que almacena una lista de los archivos y otros directorios que contiene.
Un archivo regular puede ser un archivo ASCII o un archivo binario.
Un archivo binario contiene informacin de cualquier tipo codificado en binario con una
estructura determinada que solo puede ser interpretada por los programas que los utilizan.
Un archivo ASCII est compuesto de lneas de caracteres ASCII codificados en binario que
no requiere de un programa que las interprete.
El nombre de un archivo es una cadena de caracteres. Cada sistema de archivos soportado por el
sistema operativo especifica la longitud mxima y el tipo de caracteres que puede tener. La
extensin del archivo proporciona informacin sobre el tipo de archivo. Sistemas como UNIX
ignoran las extensiones y otros como Windows las reconoce e interpretan asocindolas con el
programa que los genera.
Atributos de un archivo
La lista de atributos vara en funcin del sistema de archivos pero en general se tiene:
Tipo de archivo.
Tamao, en bytes, palabras o bloques.
Localizacin, ubicacin en memoria secundaria.
Creador y propietario. Identifica al usuario que lo cre y su actual propietario.
Permisos de acceso. Para determinar quin puede acceder y qu puede hacer con el archivo.
Informacin asociada al tiempo. Como fecha y hora de creacin, modificacin, ltimo

acceso, etc.
Estructura interna de un archivo
La informacin contenida en un archivo se puede estructurar de tres formas posibles:
Secuencia de bytes. Las operaciones de lectura y escrituras se realizan a nivel de byte. El

sistema operativo no tiene que interpretar la informacin contenida en cada byte; esa
responsabilidad recae en los programas de aplicacin que se ejecutan a nivel de usuario.
Secuencia de registros. Cada registro, de igual longitud, posee su propia estructura interna.
Las operaciones de lectura y escritura tambin se realizan a nivel de registros.
67
Registros indexados. Cada registro, de longitud variable, contiene un campo ndice que
permite identificarlo. Se organiza en funcin de la clave de los registros que lo componen.
En una operacin de lectura o escritura debe especificarse la clave de registro que se desea
leer o escribir. Al aadir un nuevo registro es necesario indicar su clave.
De forma general, un archivo est formado por bloques lgicos o registros de igual o distinto
tamao. En el caso de secuencia de bytes el tamao del bloque es de un byte.
Idependientemente de la estructura, las operaciones de E/S en memoria secundaria se realizan en
unidades de bloques fsicos de igual tamao. Un bloque fsico, que comprende varios sectores, tiene
asignada una direccin fsica BF o nmero de bloque. Un archivo ocupar N bloques lgicos,
exisitendo fragmentacin interna ya que el ltimo bloque probablemente no sea ocupado al
completo.
Mtodos de acceso a un archivo
Acceso secuencial. Los bytes o registros se leen o escriben en orden comenzando desde el
principio. El sistema mantiene un puntero de lectura/escritura que indica la posicin donde
debe comenzar la siguiente operacin. Compiladores y procesadores de texto la utilizan.
Acceso aleatorio. Tambin llamado acceso directo. Los bytes o registros pueden ser leidos
en cualquier orden. Las operaciones de lectura/escritura pueden implementarse
especificando el nmero de byte o registro al que se desea acceder en la misma instruccin o
bien realizando primero una bsqueda y posteriormente realizar la operacin de manera
secuencial.
Operaciones sobre archivos
68
Crear archivo. Crea un archivo sin datos, vaco, en la estructura de directorios y crea las
entradas necesarias en el directorio correspondiente.
Abrir archivo. Se busca en un directorio la entrada asociada al archivo y se carga en

memoria principal toda la informacin que necesite sobre el archivo: atributos, posiciones
de memoria secundaria donde se aloja, etc. Si la operacin se realiza con xito se devuelve
un entero positivo denominado identificador de archivo, que lo identifica en el conjunto de
archivos abiertos por el proceso o por el conjunto de procesos.
Posicionamiento o bsqueda, seek. Permite configurar el puntero de lectura/escritura para

que apunte al comienzo del byte o registro donde se desea leer o escribir.
Leer archivo. Permite la lectura del archivo desde la posicin actual del puntero. La llamada
al sistema incluye como argumentos el identificador del archivo, el nmero de bytes o
registros que se desean leer y la direccin de memoria del espacio de usuario del proceso
donde colocar los datos ledos.
Escribir archivo. Permite la escritura del archivo desde la posicin actual del puntero.La
llamada debe incluir el identificador de archivo, el nmero de bytes o registros a escribir y la
direccin de memoria del espacio de usuario del proceso desde el que tomar los datos. Si los
datos se escriben al final del archivo se provoca su aumento de tamao.
Renombrar archivo. Cambia el nombre del arhivo.
Cerrar archivo. La informacin que se mantiene en memoria principal asociada al archivo

se descarta. Si el archivo ha sido abierto por varios procesos no se cierrra hasta que lo hace
el ltimo de los procesos.
Borrar archivo. Libera el espacio en memoria secundaria y elimina su entrada en el

directorio.
Captulo 9. Gestin de archivos
Directorios
Estructura de los directorios
Un directorio almacena una lista de archivos y subdirectorios. En cada entrada se almacena el

nombre y otras informaciones. Las estructuras de directorios ms comunes son:
Estructura de directorios de un nico nivel. Consta de un nico directorio donde se

almacena una lista con todos los archivos existentes, tanto de usuario como del sistema.
Todos los archivos deben tener nombres distintos.
Estructura de directorios de dos niveles. Consiste en un directorio raz, o directorio de

archivos maestro, que almacena una lista de directorios, uno por usuario. En su
implementacin ms sencilla, un usuario slo tiene acceso al contenido de su directorio.
Para poder utilizar archivos de otros usuarios, adems de que el usuario posea los permisos
necesarios, el sistema debe manejar nombres de ruta. As, un archivo queda definido por la
ruta del directorio donde se encuentra y su propio nombre.
Este mtodo tambin permite evitar la duplicidad de los archivos del sistema y de
aplicacin. El sistema crea un usuario ficticio especial y en su directorio almacena todos
esos archivos. Cuando un usuario invoca un archivo primero se busca en su directorio de
usuario y si no se encuentra se acude al directorio especial.
Estructura de rbol de directorios. La lista almacenada en cada directorio puede contener

entradas de otros directorios y archivos, pudiendo crearse mltiples niveles de directorios.
Para acceder a un determinado archivo debe especificarse su ruta completa.
La ruta puede ser absoluta, indicando el camino desde el directorio raz, o relativa, desde el
directorio actual o directorio de trabajo.
Los sistemas que soportan una estructura de rbol crean dos entradas de directorio
especiales: la entrada punto ., que hace referencia al directorio actual, y la entrada dos
puntos .., que hace referencia al directorio padre.
Estructura de directorios de grfica acclica. Con el fin de implementar la comparticin de

archivos y directorios se emplea la estructura de directorios de grfica acclica, que permite
que el mismo directorio o archivo pueda ser referenciado por dos o ms directorios
diferentes, siempre que no se produzcan ciclos.
Normalmente se realiza mediante el uso de enlaces, links. Un enlace puede implementarse
creando en el directorio origen una entrada que sea copia de la entrada del directorio destino
asociada al archivo compartido. Esta nueva entrada tendr un atributo especial que indique
que es un enlace. Este tipo de implementacin se conoce como enlace duro. Si la entrada
original se modifica, todas las entradas copia deben ser modificadas; el sistema debe
mantener una lista con los enlaces de cada archivo. Para evitar esto algunos sistemas utilizan
un nodo ndice, o nodo-i, para almacenar las estructuras de datos con los atributos del
archivo y en la entrada del directorio se hace referencia a este nodo-i.
Otra forma de implementar un enlace es con un tipo especial de archivo que contiene la ruta
absoluta o relativa del archivo o subdirectorio compartido. Estos enlaces se denominan
enlaces simblicos. Los enlaces simblicos permiten enlazar con cualquier archivo de la
estructura de directorios local o remota. El uso de enlaces simblicos consumen ms espacio
que los enlaces duros, ya que ocupan una entrada de datos. Su utilizacin aumenta el
nmero de operaciones de E/S y la sobrecarga del sistema ya que es necesario buscar la
entrada del enlace en el directorio correspondiente para conocer su ubicacin en disco, leer
del disoc el archivo del enlace para conocer la ruta del elemento compartido y despus
69
seguir esa ruta para encontrar la entrada del directorio que le permita conocer la ubicacin
del elemento compartido.
Operaciones sobre directorios
Crear directorio. Cuando se crea no contiene ninguna entrada, salvo . y .., si el sistema
operativo las soporta.
Borrar directorio. En algunos casos slo se permite si el directorio se encuentra vaco. Si se

permite, se eliminan tambin todos los elementos que contiene.
Abrir directorio. Consiste en encontrar en el directorio padre la entrada que se desea abrir y
cargarla en memoria principal.
Cerrar directorio. Se libera la memoria principal que almacenaba la informacin del

directorio.
Leer directorio. Permite leer el contenido de una entrada del directorio, necesario para
operaciones de bsqueda y listado de contenido del directorio.
Renombrar directorio. Permite modificar su nombre.
Enlazar. Permite crear una entrada para enlace duro o simblico.
Desenlazar. Permite eliminar un enlace.
Sistemas de archivos
Estructura de un sistema de archivos
Un sistema de archivos define un esquema de almacenamiento de la informacin relativa a los

archivos en un dispositivo de almacenamiento secundario. En un disco puede haber tantos sistemas
de archivos distintos como particiones tenga.
De forma general se pueden distinguir las siguientes reas:
Bloque de arranque. Se sita al comienzo de la particin y puede contener el cdigo

necesario para arrancar el sistema operativo.
Estructura de datos con metadatos del sistema de archivos. Contiene informacin

administrativa y estadstica del sistema de archivos, como por ejemplo el identificador del
tipo de sistema de archivos, nmero de bloques, nmero de bloques libres, etc. En algunos
sistemas se denomina superbloque. Es copiado a memoria principal cuando se accede por
vez primera al sistema de archivos.
Estructura de datos con informacin sobre los bloques libres en el sistema de archivos.
Generalmente denominada lista de bloques libres. Puede implementarse como mapa de bits
o como lista enlazada.
Estructura de datos con informacin sobre bloques asignados a los archivos. Algunas de las
ms utilizadas son:
Lista de nodos ndice. O nodo-i, estructura de datos utilizada para almacenar los
atributos de un archivo y su ubicacin en disco. Una entrada del nodo-i contiene la
direccin fsica o el nmero de bloque donde se encuentra el nodo-i asociado a un
determinado archivo.
Tabla de asignacin de archivos. (File Allocation Table, FAT). Tiene una entrada por
cada bloque fsico existente en la particin del sistema de archivos. La entrada j de la
tabla hace referencia al bloque fsico j. Si el bloque fsico j est asignado a un archivo, la
70
entrada j en la FAT contiene la direccin fsica del siguiente bloque del archivo. En este
caso no es necesario mantener informacin sobre bloques libres.
rea de datos. Contiene los bloques libres y bloques asignados a los archivos y directorios.
Montaje de un sistema de archivos
Para poder acceder a los contenidos de un determinado sistema de archivos ubicado en memoria
secundaria este debe ser montado en algn punto dentro de la estructura de directorios. A dicho
punto se le denomina punto de montaje. El sistema operativo realiza el montaje de los sistemas de
archivos en el arranque o cuando se detecta un nuevo dispositivo de memoria secundaria conectado
al computador.
En sistemas Windows se trata cada sistema de archivos como un volmen o unidad lgica, cada una
de las cuales tiene su propia estructura de directorios. Se asigna una letra a cada unidad.
En sistemas Linux cada sistema de archivos se monta como un directorio del sistema de archivos
principal, luego todos los sistemas de archivos quedan integrados dentro de la misma estructura de
directorios.
Asignacin de espacio
Un aspecto importante es la forma en que se asignan los bloques fsicos del rea de datos del
sistema. Los mtodos ms utilizados son la asignacin contigua, la asignacin enlazada y la
asignacin indexada.
Asignacin contigua
Se asigna a un archivo un conjunto de bloques fsicos contiguos. As, si un archivo consta de N

bloques y el primer bloque se almacena en BF0, el segundo lo har en BF0 + 1, y el ltimo ocupar el
bloque fsico BF0 + N - 1.
Este mtodo minimiza las operaciones de bsqueda en disco y soporta tanto archivos de acceso
secuencial como aleatorio.
Presenta la desventaja de producir fragmentacin externa. Sucesicos procesos de creacin y borrado
de archivos provocar la aparicin de huecos cada vez ms pequeos, siendo necesario compactar
el disco, esto es, trasladar todos los archivos a un lado de la particin y todos los huecos al otro.
Otro inconveniente es que el sistema operativo debe conocer de antemano el espacio que va a
ocupar el archivo. Si se le asigna un hueco de tamao superior al necesario se producir
fragmentacin interna. Si se le asigna un espacio inferior al que podra alcanzar tendr que
recurrirse a alguna estrategia cuando necesite ms espacio.
Asignacin enlazada
El mtodo de asignacin enlazada consiste en almacenar al principio de cada bloque fsico asignado
a un archivo la direccin fsica del siguiente bloque fsico del archivo. As, se organiza como una
lista enlazada de bloques fsicos.
Permite usar cualquier bloque, por lo que no produce fragmentacin externa y evita conocer por
adelantado el tamao del archivo.
Resulta muy lento para su utilizacin con archivos de acceso aleatorio ya que para localizar un
bloque hay que pasar por todos los anteriores.
Adems, la utilizacin de algunos bytes del bloque para almacenar la direccin del bloque siguiente
provoca que haya menos espacio disponible para datos y que este espacio no sea potencia de dos,
dificultando el procesamiento y la eficiencia.
71
Una solucin bastante utilizada es asignar el espacio en agrupamientos (clusters) de bloques fsicos
contguos, almacenndose al comienzo la direccin del siguiente agrupamiento. Esta solucin
aumenta la fragmentacin interna y produce fragmentacin externa, dado que huecos de tamao
inferior al del cluster no pueden ser asignados.
Otra desventaja es que si se daa o pierde uno de los punteros de la cadena el resto de los bloques
no estaran accesibles.
Para eliminar todas las desventajas del mtido de asignacin enlazada se puede utilizar una FAT,
ubicada en sectores contiguos despus del sector de arranque. La FAT tiene una entrada por cada
bloque fsico de la particicin. La entrada j de la tabla hace referencia al bloque j del disco. Si el
bloque fsico j est asignado a un archivo, la entrada j de la FAT contiene la direccin del siguiente
bloque. Si el bloque es el ltimo del archivo, la entrada de la FAT contendr un valor especial para
indicarlo. Lo mismo ocurre en caso de que el bloque est libre.
Una copia de la FAT debe estar en memoria principal para optimizar su uso. Este espacio puede
llegar a ser muy grande si la particin del disco tambin lo es.
Asignacin indexada
En este mtodo se almacena en un nodo-i los atributos de un archivo y las direcciones fsicas de los
primeros ocho o diez bloques de un archivo. Tambin se almacenan las direcciones fsicas de uno o
varios bloques de indicreccin simple, doble o triple.
Un bloque de indireccin simple almacena direcciones fsicas de bloques de archivo.
Un bloque de indireccin doble almacena direcciones fsicas de bloques de indireccin simple.
Un bloque de indireccin triple almacena direcciones fsicas de bloques de indireccin doble.
Cada archivo tiene asociado un nmero entero positivo denominado nmero de nodo- i. Al principio
de la particin se mantiene una lista con todos los nodos-i existentes. El nmero de nodo-i asociado
a un archivo se almacena en la entrada de directorio que contiene al archivo.
Este mtodo se puede usar tanto para archivos de acceso secuencial como aleatorio. No produce
fragmentacin externa y permite que el espacio de los bloques fsicos que contienen datos puedan
ser utilizados totalmente. Su implementacin requiere de menos memoria principal que la FAT, ya
que solo es necesario mantener en memoria los nodos-i de los archivos abiertos.
La principal desventaja es que el tiempode acceso a un bloque de archivo depende de la estructura
interna del nodo-i. En el mejor de los casos y suponiendo que el nodo-i del archivo ya ha sido
cargado en memoria principal, si se desea acceder a uno de los primeros bloques del disco slo hay
que hacer una lectura para acceder a dicho bloque, pero si se trata de bloques a los que se accede a
travs de bloques de indireccin simple, doble o triple, habr que hacer una, dos o tres lecturas
adicionales en disco.
Gestin del espacio libre
Para esta funcin se suele utilizar una estructura de datos denominada lista de bloques libres,
aunque a veces no se implementa como una lista.
Mapa de bits
Cada bloque de disco tiene asignado un bit. Si el bloque est ocupado se marca con un 0 y si est
libre con un 1 (o viceversa). Si la particin ocupa N bloques, sern necesarios N bits.
Su principal ventaja es la sencillez para encontrar el primer bloque libre o el primer conjunto de k
bloques libres consecutivos. El principal inconveniente es que se precisa tener el mapa completo en
memoria principal.
72
Lista enlazada
Si un bloque de disco puede almacenar ND direcciones de bloque, en cada bloque de la lista

contendr la direccin del siguiente bloque y ND - 1 direcciones de bloques libres.
La principal ventaja es que slo es necesario mantener en memoria un bloque de la lista enlazada.
Implementacin de directorios
Un directorio es un archivo que almacena una lista de los archivos y subdirectorios que contiene.
Algunos sistemas, como FAT-32, almacena en cada entrada de un directorio el nombre del archivo o
subdirectorio y sus atributos, entre los que se encuentra la informacin para localizar los bloques de
datos que lo contiene.
En UFS (UNIX) o ext2 de Linux, se almacena en cada entrada el nombre del archivo o
subdirectorio y un puntero (nmero de nodo-i) a la estructura de datos (nodo-i) donde se almacenan
los atributos del archivo. Esta organizacin precisa de un acceso ms a disco para copiar el nodo-i a
memoria principal.
Entre las implementaciones ms comunes de directorios se encuentran:
Directorios con entradas de igual tamao. En cada entrada se almacenan las informaciones
asociadas al archivo y a continuacin el nombre del archivo. Es sencilla de gestionar pero
para dar soporte de nombres largos cada entrada debe tener ese mximo, lo que supone un
derroche de espacio.
Directorios con entradas de tamao variable. Primero se almacena el tamao que ocupa la
entrada, a continuacin la informacin asociada a la entrada (atributos o nodo-i y finalmente
el nombre de archivo (hasta un cierto tamao) al que se le aade un carcter especial para
marcar el final del nombre. Cada entrada se rellena para que coincida con un entero positivo
de palabras de memoria principal. Como mximo se despercicia casi una palabra. Cuando se
eliminan entradas quedan huecos de longitud variable, generando fragmentacin externa que
puede precisar de una compactacin del directorio.
Directorios con entradas de igual tamao y montculo (heap) para almacenar los nombres
de los archivos. Se almacena un puntero al comienzo del nombre de archivo dentro de l
montculo y sus atributos o nodo-i. Elimina la fragmentacin externa y no es necesario
incluir caracteres de relleno, pero es de administracin ms complicada al tener que
gestionarse el montculo.
Otro aspecto a considerar est relacionado con la forma en que se realiza la bsqueda de un archivo
en un directorio, por ejemplo, buscando las entradas una a una.
Para ahorrar tiempo se puede mantener una cache de directorios con las entradas recientemente
accedidas o implementar cada directorio con una tabla hash y su lista de archvos y subdirectorios.
Cuando se desea realizar una bsqueda se introduce el nombre en la funcin hash que devolver qu
entrada de la tabla hay que leer. Si la entrada est vaca, el archivo no existe. Para evitar las
colisiones cada entrada se puede implementar como una lista enlazada.
Consistencia
Para verificar la consistencia del sistema de archivos se suele incluir en los sistemas operativos un
verificador de consistencia. las inconsistencias ms frecuentes que pueden presentarse en el sistema
de archivos son:
Un bloque no aparece en la lista de bloques libres ni est asignado a ningn archivo. Se

soluciona aadiendo el bloque a la lista de bloques libres.
73
Un bloque figura en la lista de bloques libres y tambin est asignado a un archivo. Se

elimina el bloque de la lista de bloques libres.
Un bloque figura varias veces en la lista de bloques libres. Solo aparece si se implementa
mediante lista enlazada de bloques libres y se soluciona reconstruyendo la lista.
Un bloque est asignado a N archivos, siendo N > 1. Es la peor situacin y puede

solucionarse copiado ese bloque a N - 1 bloques libres. Se recupera la consistencia, pero
probablemente despus existan N - 1 archivos con errores.
Para evitar el uso de verificadores los sistemas de archivos modernos (NTFS, ext4, HFS+)
implementan la tcnica del registro diario o journaling, que consiste en almacenar un informe de las
operaciones a realizar antes de hacerlas y eliminar el informe una vez realizadas con xito. Si al
reiniciar el sistema el informe sigue exisistendo significa que ha exisitido un error y vuelve a
repetirse las operaciones pendientes para dejar el sistema de archivos en un estado consistente.
Recuperacin de archivos
Copias de seguridad
Existen dos tipos de copias de seguridad:
Copia de seguridad lgica. nicamente contiene los directorios y archivos que el

administrador o el usuario desea copiar al medio de respaldo. Permite acceder a los
contenidos de forma individualizada. Estas copias pueden ser de tres tipos:
Copia completa, con todos los archivos seleccionados.
Copia diferencial, nicamente los archivos nuevos o modificados desde la ltima
completa determinada.
Copia incremental, nicamente los archivos creados o modificados desde la ltima
completa o incremental.
Copia de seguridad fsica. Tambin conocida como imagen de disco. Consiste en copiar
bloque a bloque la particin de disco. Son ms simples de realizar pero requieren montar la
imagen para iniciar la recuperacin.
Instantneas
ZFS, de Solaris, utiliza la tcnica de copiar al escribir, copy-on-write. En esta tcnica si el sistema
operativo precisa modificar el contenido de un bloque en el disco se localiza un bloque libre y se
copia el contenido modificado en ese bloque, modificando los punteros para que apunten a ese
nuevo bloque.
El sistema agrupa las modificaciones y las realiza cada cierto tiempo (valor tpico 30 segundos).
Cada modificacin se etiqueta con un nmero de versin diferente. La versn actual coexiste con
versiones anteriores del sistema de archivos. Cada nueva versin se denomina instantnea
(snapshot). Cada instantanea puede montarse como un archivo de solo lectura para reacuperar datos
individualmente o en modo de escritura para restaurar el sistema completo a un estado anterior.
Las instantneas no son una copia de seguridad. Las diferencias fundamentales son:
74
Las instantneas se toman de forma prcticamente inmediata y no ocupan espacio en el

momento de su creacin. Slo se requiere cambiar el nmero de versin actual.
Las instantneas pueden ser restauradas con gran rapidez. Tan solo es necesario volver a
montar el sistema de archivos a partir de la versin anterior.
Las instantneas residen en el mismo disco fsico que los datos que respaldan, por lo que no
son eficaces frente a daos fsicos en el disco y deben complementarse con algn mtodo de
copia de seguridad.
Eficiencia
La eficiencia del sistema aumenta notablemente si se reduce al mnimo imprescindible el nmero de
accesos de E/S a disco. Para lograr ese objetivo algunos sistemas operativos implementan en
memoria principal una cach de bloques de disco.
Para mejorar la tasa de aciertos de cach se utiliza la estrategia de lectura por adelantado de
bloques, que consiste en copiar en la cach no solo el bloque que ha dado el fallo sino varios
bloques contguos a ste.
Tambin puede intentarse que los accesos a disco consuman poco tiempo, por ejemplo almacenando
en el mismo cilindro los bloques a los que se espera acceder de forma secuencial.
En sistemas con nodo-i sera conveniente que stos estuvieran lo ms cerca posible de los bloques
de datos del archivo, por lo que el mejor sitio para almacenarlos sera la zona central del disco.
Otro aspecto a considerar es el tamao de bloque de disco, en un compromiso entre un bloque
pequeo que reduce la fragmentacin interna pero aumenta el nmero de accesos o un bloque
grande que desaprovecha espacio pero con menor nmero de accesos. Distintas pruebas demuestran
que un tamao ptimo de bloque est en unos pocos KiB.
75

Apuntes Fundamentos Basicos de Los Sistemas Operativos

Hochgeladen von

Dokumentinformationen

Originalbeschreibung:

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Apuntes Fundamentos Basicos de Los Sistemas Operativos

Hochgeladen von

Copyright:

Verfügbare Formate

Fundamentos bsicos de

los Sistemas Operativos

Consideraciones generales de los sistemas

Tiempo de procesador a los programas de usuario: planificador.

Ocupacin/gestin de memoria principal

Gestin de memoria secundaria: rea de intercambio (zona donde se almacenan los

Ncleo (kernel), proporciona un conjunto de instrucciones como llamadas al sistema.

Utilidades del SO (intrpretes de comandos, sistemas de ventanas, compiladores, etc).

Servicios de un sistema operativo

Acceso a los dispositivos de E/S.

Manipulacin del sistema de archivos

Deteccin y respuesta a errores

Procesamiento por lotes (batch)

Multiprogramacin (multitarea). Aprovechamiento de operaciones de E/S de un proceso

Multiprogramacin por tiempo compartido. Debe gestionar los recursos asignndolos de

Apuntes por Demetrio Quirs Fundamentos bsicos de los Sistemas Operativos

Tipos de sistemas operativos

Segn el nmero de programas cargados en memoria principal:

Se denomina grado de multiprogramacin el nmero de programas cargados en memoria

En funcin de los requisitos temporales de los programas a ejecutar:

Sistemas de tiempo compartido o sistemas interactivos. Sistemas multiusuario con

En funcin de la finalidad del computador.

Sistemas para macrocomputadores.

Sistemas operativos para servidores de red.

Sistemas operativos para computadoras personales.

Sistemas para computadoras de mano.

Otros tipos importantes de SO

Sistemas distribuidos. Se ejecutan en sistemas informticos distribuidos implementados

Captulo 1. Consideraciones generales de los sistemas operativos

Sistemas operativos de red. Posibilita el acceso a contenido y recursos entre computadoras

Mediante el uso de libreras de llamadas al sistema, de forma similar a como se invoca

De forma directa, mediante programas en lenguaje ensamblador.

Almacenamiento en un bloque o tabla de memoria. Slo es necesario conocer la direccin

Almacenamiento en una pila.

Las llamadas al sistema, atendiendo a su funcionalidad, se pueden agrupar en:

Control de programas en ejecucin (procesos).

Administracin de archivos y directorios.

Gestin de informacin del sistema.

Estructura del ncleo de un sistema operativo

Subsistema de control de procesos.

Subsistema de control de la memoria principal.

Subsistema de gestin de archivos.

El ncleo de un sistema operativo se puede considerar como un conjunto lgico de mdulos

capas: capa 0, controladores hardware; capa 1, control, sincronizacin y comunicacin de

Estructura extensible. Puede considerarse como un caso particular de la estructura modular.

Captulo 1. Consideraciones generales de los sistemas operativos

Descripcin y control de procesos

Espacio de direcciones de memoria lgica o virtual de un proceso.

Procesos de usuario. Pueden ejecutarse en primer o segundo plano. Se ejecutan en modo

Procesos demonio. Procesos no asociados a ningn usuario. Realizan tareas relacionadas

Procesos del sistema operativo. Realizan tareas de administracin (como el intercambio de

Apuntes por Demetrio Quirs Fundamentos bsicos de los Sistemas Operativos

Preparado en memoria secundaria.

Bloqueado en memoria secundaria.

Control de los procesos

Tablas de memoria, con informacin sobre espacio libre y asignado.

Tablas de E/S, con informacin sobre disponibilidad de dispositivos y quien lo usa.

Comprobar si el proceso puede ser creado.

Asignar una nueva entrada de la tabla de procesos para el nuevo proceso.

Reservar espacio en memoria para el proceso.

Inicializar el bloque de control del proceso.

Establecer los enlaces adecuados.

Las causas que originan la creacin de un proceso pueden ser: