Texto Oficial Sistemas Operativos

Faculta de Tecnologa
Carrera de Ingeniera de Sistemas
Tema I. Conceptos Fundamentales..................................................................................................................................3

Captulo. 1.- Funciones principales y evolucin histrica...........................................................................................3
Sistemas de operacin y funciones principales........................................................................................................3
Evolucin Histrica.................................................................................................................................................4
Generaciones de los sistemas operativos.................................................................................................................8
Captulo. 2- : Servicios del Sistema Operativo..........................................................................................................10
Proteccin..............................................................................................................................................................10
Procesos Tablas de procesos..................................................................................................................................13
Servicios del Sistema Operativo............................................................................................................................13
Interprete de comandos..........................................................................................................................................15
Estructura de un Sistema Operativo.......................................................................................................................16
Tema II : Procesos..........................................................................................................................................................19
Captulo. 3.- Procesos................................................................................................................................................19
Modelo de procesos. Estados de los procesos.......................................................................................................19
Programacin Concurrente. Grafos de precedencia..............................................................................................21
Condiciones de concurrencia y especificacin......................................................................................................22
Jerarqua entre procesos.........................................................................................................................................26
Captulo . 5.- Seccin crtica......................................................................................................................................28
Sincronizacin entre procesos...............................................................................................................................28
Condiciones de competencia. Seccin crtica........................................................................................................29
Exclusin mutua con espera ocupada....................................................................................................................30
Captulo. 6.- Semforos.............................................................................................................................................33
Exclusin mutua con bloqueo. Semforos.............................................................................................................33
Problemas clsicos de la sincronizacin de procesos..........................................................................................34
Captulo 7.- Comunicacin entre procesos...............................................................................................................38
Comunicacin entre procesos................................................................................................................................38
Comunicacin directa............................................................................................................................................40
Comunicacin indirecta.-.......................................................................................................................................40
Conf. 8.- Planificacin de Procesos...........................................................................................................................42
Planificacin de procesos.......................................................................................................................................42
Algoritmos de planificacin...................................................................................................................................45
Administracin de procesos en SO actuales..........................................................................................................48
Tema III. Entrada Salida................................................................................................................................................51
Captulo. #9.- Entrada Salida.....................................................................................................................................51
Dispositivos de Entrada/Salida. Controladores.....................................................................................................51
Acceso directo a Memoria.....................................................................................................................................52
Software de Entrada/Salida....................................................................................................................................53
Manejadores de interrupcin. (Handlers)..............................................................................................................55
Manejadores de dispositivos (Device Drivers)......................................................................................................55
Software independiente del dispositivo.................................................................................................................57
Software para el uso de los usuarios......................................................................................................................57
Captulo #10.- Algoritmos de Planificacin..............................................................................................................59
Ejemplos de manejadores de dispositivos.............................................................................................................59
Reloj.......................................................................................................................................................................60
Discos RAM..........................................................................................................................................................62
Discos. Caractersticas fsicas................................................................................................................................63
Algoritmos de planificacin...................................................................................................................................65
Tema IV.- Abrazo Fatal.................................................................................................................................................67
Captulo. 11.- Abrazo Fatal........................................................................................................................................67
Recursos. Modelado del abrazo fatal.....................................................................................................................67
Grafo de asignacin de recursos............................................................................................................................69
Prevenir el abrazo fatal..........................................................................................................................................70
Evitar el abrazo fatal..............................................................................................................................................72
Detectar y recuperar...............................................................................................................................................74
Tema V. Administracin de Memoria............................................................................................................................75
Captulo. 12.- Particiones fijas y variables................................................................................................................75
Pag - 1
Aspectos Introductorios.........................................................................................................................................75
Uso de la memoria en monoprogramacin............................................................................................................75
Proteccin y relocalizacin....................................................................................................................................76
Intercambio de trabajos. Solapamiento..................................................................................................................77
Multiprogramacin con particiones fijas. Fragmentacin interna.........................................................................78
Multiprogramacin con particiones variables. Fragmentacin externa.................................................................80
Captulo 13.- Paginado y segmentado...................................................................................................................82
Tcnicas de asignacin de memoria......................................................................................................................82
Paginado.................................................................................................................................................................85
Segmentado............................................................................................................................................................87
Esquemas combinados...........................................................................................................................................89
Captulo 14.- Memoria virtual................................................................................................................................90
Memoria virtual.....................................................................................................................................................90
Demanda de pgina y prepaginado........................................................................................................................90
Algoritmos de reemplazamiento de pginas..........................................................................................................92
Sobreposicin (Overlays)......................................................................................................................................94
Administracin de memoria en sistemas operativos actuales................................................................................94
Pag - 2
Sistemas de Operacin.
Tema I. Conceptos Fundamentales.
Captulo. 1.- Funciones principales y evolucin histrica.
Sistemas de operacin y funciones principales.

Evolucin histrica.
Primera etapa.
Monitores simples.
Multiprogramacin.
Tiempo compartido.
Tiempo real.
Generaciones de los sistemas operativos.
Sistemas multiprocesadores.
Sistemas de operacin y funciones principales
Todo sistema de cmputo se puede dividir, en forma general, en dos partes: hardware
(aseguramiento tcnico) y software (aseguramiento de programas).
El software hace til al hardware y puede dividirse en dos clase: los programas del sistema
(software de base) que manejan la operacin de la computadora, y el software de aplicacin que
realiza acciones tiles a los usuarios.
Entre los programas del sistema se pueden mencionar: sistemas de operacin (los ms
importantes de todo el conjunto), compiladores, intrpretes, editores, etc.
El sistema operativo es la primera capa de software que se coloca sobre el crudo hardware,
separando a los usuarios de ste.
Intentar dar una definicin formal del concepto de sistema de operacin no resulta una tarea
sencilla y resulta ms conveniente hacerlo despus de ver las funciones que cumplimenta. Todo
sistema operativo cumple dos funciones principales:
1. Como mquina ampliada o virtual.
2. Como administrador de recursos.
La funcin de mquina ampliada o virtual consiste en dar facilidades a los usuarios separndolos
de tener que conocer las obscuras y complejas interioridades del Hardware. Por ejemplo, un
usuario que opera una maquina con ficheros que se abren, leen, escriben, y cierran en lugar de
tener que operar con un nmero de registros, tiempos de posicionamiento, motor apagado o
encendido, etc.
Pag - 3
La funcin de administrador de recursos consiste en proporcionar una va para asignar, en forma

ordenada y controlada, los distintos recursos de que dispone el sistema de cmputo entre varios
programas que compiten por ellos. Esta vista de los sistemas operativos presupone el uso del
hardware de la computadora en una forma eficiente.
La primera funcin antes indicada es la razn primaria de la existencia de los sistemas operativos
y esto resulta ms evidente cuando se trata de las computadoras de uso personal.
La meta de la eficiencia es importante para sistemas de cmputo grandes y sistemas compartidos

de mltiples usuarios (Shared Multi-Users Systems). En este caso no se quiere decir que la vista
de maquina ampliada no siga constituyendo una funcin fundamental.
En el pasado, las consideraciones de eficiencia fueron frecuentemente ms importantes que las de

facilidades de uso y por ello la teora de los sistemas operativos se concentro en el uso ptimo de
los recursos. Hoy, con la gran difusin de computadoras personales existe un mayor nfasis en la
satisfaccin del usuario y a ello se debe el desarrollo de los ambientes GUI (Graphic User
Interface).
Aun cuando no existe una definicin absoluta de que es un sistema operativo y resulta ms claro
llegar a su entendimiento por la va de comprender que hacen, ensayaremos una muy simple.
Un sistema operativo es una interfase entre los usuarios y el hardware que brinda a estos un
ambiente donde se ejecutan con facilidad y conveniencia sus programas y al mismo tiempo se
logra un uso eficiente de los recursos disponibles.
Los sistemas operativos se diferencian de los restantes programas del sistema que no forman
parte de el (compiladores, editores, interprete de comandos, etc.) en que estos corren en modo
usuario mientras que el primero lo hace en modo protegido o kernel (tambin llamado supervisor,
sistema, protegido, etc.).
Lo antes sealado ser aclarado ms adelante, pero se debe puntualizar que tal afirmacin no es
valida para aquellos sistemas operativos que fueron diseados para algunos microprocesadores
antiguos (8086, 8088). Este es el caso del DOS y de ah sus bloqueos y la fcil penetracin de
los virus.
Evolucin Histrica
No es posible analizar la evolucin o desarrollo histrico de los sistemas operativos sin tener en
cuenta el avance de la arquitectura de computadoras. Los sistemas operativos fueron creados para
facilitar y ampliar las posibilidades de uso del hardware, pero estos a su vez pusieron en
evidencia la necesidad de cambios en los equipos para facilitar su actividad y brindar mayores
posibilidades.
Pag - 4
Primera etapa
Se caracteriza por la no existencia de sistema operativo alguno. Solo exista el hardware.

El programador era a su vez el operador y el uso se realizaba por reservacin de tiempo de
maquina. Esta etapa se caracteriz por una explotacin no eficiente de los equipos y la no
existencia de facilidades para el trabajo.
Con el paso del tiempo aparecen desarrollos en el Hardware y el Software. Se incluyen los
lectores de tarjetas, las impresoras de lnea y las bandas magnticas. Se crean ensambladores,
cargadores y enlazadores.
Surgen las bibliotecas conteniendo funciones comunes. Dentro de estas resultan importantes los
manejadores de dispositivos (Device driver) que liberaban al programador de los tediosos detalles
de los dispositivos. Estas funciones se pueden considerar embriones de los futuros sistemas
operativos.
El surgimiento de los compiladores complico la operacin y puso en evidencia la necesidad de ir

a formas de procesamiento ms eficientes.
Monitores simples
La solucin a la dificultad antes indicada tuvo dos vas o caminos. La primera consisti de
disponer de operadores profesionales y la segunda en procesar los trabajos en forma de lotes
(Batch).
Lo antes indicado implico un mejoramiento de la eficiencia (aunque el programador perdi la

posibilidad de eliminar los errores en lnea) pero no obstante exista una perdida de tiempo en el
cambio de un trabajo a otro (terminara en forma normal o anormal).
La solucin a esta perdida de tiempo consisti en delegar en el propio equipo el cambio

automtico, de los trabajos y con esto surgieron los primeros y ms rudimentarios sistemas de
operacin.
Estos pequeos programas que permitan transferir el control de un trabajo a otro, recibieron el
nombre de monitor residente. Permanecan en memoria todo el tiempo.
El monitor residente le entregaba el control de ejecucin a un programa y cuando ste terminaba

se lo devolva, estando en condiciones de volver a repetir la operacin en forma automtica. Es
decir, el monitor residente transfera el control de un programa a otro y de un trabajo a otro.
Para el logro de este secuenciamiento se requera informar al monitor residente las acciones que
se deban realizar. Esta informacin se suministraba mediante tarjetas perforadas que se llamaban
Tarjetas de Control.
Pag - 5
En los monitores residentes se identificaban claramente cuatro partes componentes:
Vectores de interrupcin y trampas.

Manejadores de dispositivos.
Cargador.
Interprete de las tarjetas de control.
Con las soluciones antes explicadas se daba respuesta a las perdidas de tiempo provocadas en el
secuenciamiento entre los trabajos, pero permanecan las existentes a consecuencia de las
diferencias de velocidades entre el procesador central y los dispositivos de E/S (dado su carcter
mecnico).
Lo antes indicado implicaba que el CPU frecuentemente se encontraba inactivo esperando por
una lenta E/S. Por otro lado, cuando el CPU trabajaba, los equipos de E/S estaban desocupados.
Una solucin a la dificultad antes indicada consisti en sustituir las lectoras de tarjetas y las
impresoras de lneas por bandas magnticas, las que brindaban entradas y salidas a una mayor
velocidad, mejorando la proporcin de uso del CPU.
Las bandas que soportaban las entradas eran creadas a partir de lectoras de tarjetas, pero fuera de
lnea. De igual forma las bandas magnticas que reciban las salidas de la computadora eran
impresas tambin fuera de lnea.
Otra solucin a la lentitud de los dispositivos de entrada salida consisti en el uso de buffers. El
uso de estos almacenes temporales es un intento por mantener al CPU y los perifricos ocupados
simultneamente.
La idea es simple. Por ejemplo en la entrada, cuando un conjunto de datos ha sido ledo se le
ordena al dispositivo de lectura proceda con la siguiente y la vaya almacenando en un rea de la
memoria (Buffer), mientras el CPU va procesando la anterior.
Si se logra (lo que es muy difcil) que en el momento que el CPU quede libre ya el dispositivo
de entrada haya ledo los prximos datos, entonces el CPU comienza a procesarlos mientras el
perifrico inicia la prxima transferencia.
En la prctica, rara vez el uso de la tcnica de buffers, logra que el CPU y los dispositivos de
entrada salida se mantengan ocupados todo el tiempo.
El surgimiento de los discos elimin rpidamente la preparacin de lotes de trabajo fuera de

lnea, pasndose a sistemas basados en discos. Este dispositivo permita se pudiera realizar
lecturas y escrituras simultneas en diferentes zonas del soporte (simplemente moviendo el
cabezal).
La forma de procesamiento utilizada en los sistemas basados en discos fue la conocida como
SPOOLING (Simultaneus Peripheral Operation On-Line).
Pag - 6
En este tipo de procesamiento, de forma continua se van leyendo directamente del lector de
tarjetas los diferentes trabajos que se almacenan en el disco. Cada vez que uno de ellos es
introducido, se anota en una tabla (y el rea donde se encuentra). Cuando el trabajo es ejecutado,
sus solicitudes de entrada se satisfacen leyendo en el disco. De forma similar, cuando el trabajo
solicita la impresora para imprimir, la accin se realizar en un rea del disco y la impresin
realmente se har con posterioridad.
El sistema de operacin se encargar, mediante la tabla antes indicada, de llevar el control de las
entradas y las salidas pertenecientes a cada trabajo.
Mientras el uso de buffers solapa la entrada/salida de un trabajo con sus propios clculos, el
SPOOLING permite igual accin con la entrada, salida y clculos de trabajos diferentes.
La tcnica del SPOOLING constituye un elemento consustancial de los sistemas operativos que
funcionan en computadoras grandes (mainframes) y que realizan procesamientos en lotes.
La tcnica del SPOOLING brinda adicionalmente una importante estructura de datos, la piscina
de trabajos (Job Pool). Es decir, en un momento dado existen varios trabajos ledos y listos para
ser ejecutados. Esta caracterstica brinda la posibilidad al sistema operativo de seleccionar cul
es el trabajo ms conveniente a procesar en cada momento con vistas a elevar el uso del CPU
(hasta ese momento se corran en el orden, primero que llega es el primero que se sirve).
La posibilidad de seleccionar para su ejecucin a un trabajo entre varios almacenados en un

dispositivo de acceso directo se le conoce como planificacin de trabajos (Job Scheduling).
Multiprogramacin
El aspecto ms importante que ofrece el Job Scheduling es la posibilidad de la

multiprogramacin (tambin nombrada como procesamiento multitarea).
La multiprogramacin, es un intento de incrementar la utilizacin del CPU, tratando de que

siempre tenga algo que hacer. La idea consiste en mantener varios trabajos en memoria
simultneamente y cuando el que est activo (utilizando el procesador) va a provocar una espera
(por ejemplo, al tener que esperar por una entrada/salida), entonces se le quita el CPU y se le
asigna a otro que est listo para ejecutar.
A un trabajo que se le quit el CPU (bloqueado), eventualmente se le volver a entregar siempre

y cuando ya haya ocurrido el evento que provoc la primera accin.
Los trabajos que se mantienen en memoria se toman de la piscina y la cantidad que en un

momento puedan recibir y competir por el CPU depender del diseo de la administracin de
memoria (Memory Management).
Los sistemas de operacin que permiten la multiprogramacin son algo complejos y este
concepto ha sido el motor impulsor del desarrollo de la teora alrededor de esta materia. La
multiprogramacin es el aspecto central de los sistemas de operacin modernos.
Pag - 7
Tiempo compartido
El desarrollo de la multiprogramacin brind la posibilidad de que los sistemas operativos

pudieran soportar en forma eficiente la posibilidad de atender en forma interactiva a varios
usuarios, trabajando cada uno en una terminal y compartiendo entre todos el tiempo del
procesador y los restantes recursos existentes.
A los sistemas de operacin que brindan la posibilidad antes indicada se les conoce como
Sistemas de Tiempo Compartido.
Cada usuario tiene un programa separado en memoria. Cuando a uno de ellos se le asigna el
procesador, ste ejecutar solamente por un perodo breve de tiempo (en un medio interactivo los
procesamiento son generalmente cortos) antes de terminar o realizar una entrada/salida. Debido a
que el hombre que trabaja en la terminal es lento con respecto al CPU, al producirse la
entrada/salida se le retirar el CPU y se comenzar la atencin de otro usuario.
En muchos esquemas de tiempo compartido se establece adicionalmente que un usuario en

posesin del CPU solo lo retendr durante una ranura o quantun de tiempo, transcurrido ste lo
perder.
Debido a que el sistema cambia de un usuario a otro rpidamente da a todos la impresin de estar
trabajando con una computadora propia.
Tiempo Real
Los sistemas operativos de tiempo real tambin hacen uso de la multiprogramacin y atienden
varios puntos de accin, pero en su trabajo existen restricciones de tiempo y el procesamiento se
tiene que hacer dentro de estas restricciones.
Este tipo de sistemas es generalmente utilizado para controlar procesos fsicos (experimentos
cientficos, equipos industriales, equipos mdicos, etc.).
Generaciones de los sistemas operativos
Algunos autores (por ejemplo Tanembaun) para analizar la evolucin histrica de los sistemas
operativos lo hacen asociando estos a las distintas generaciones de los sistemas de cmputo. Por
supuesto, esta estructuracin no se aleja de los aspectos antes estudiados.
La primera generacin (1945-1955) corresponde a los primeros equipos, construidos con

vlvulas de vaco. En esta etapa no existieron sistemas operativos.
La segunda generacin (1955-1965) corresponde a la etapa a los equipos que estaban basados en
el uso de los transistores. Eran ms confiables y ms duraderos. Desde el punto de vista de los
sistemas operativos se tiene el uso de monitores simples (lo que implica procesamiento en lote).
Pag - 8
Sistemas de Operacin de esta etapa son el FMS (Fortran Monitor System) y el IBSYS de la
7094.
La tercera generacin (1965-1980) se caracteriz por la utilizacin de circuitos integrados. Los

sistemas operativos vinculados a esta etapa introdujeron los conceptos de SPOOLING y en
especial el uso de la multiprogramacin. Tambin corresponde a esta etapa la aparicin del
tiempo compartido.
En esta etapa no pueden dejar de mencionarse los sistemas de operacin OS/360 y Multics. Aqu
surgen las primeras versiones del Unix.
La cuarta generacin (1980-1990) surge con los circuitos integrados de alta integracin y por ello
aparecen en el mercado las computadoras personales.
Esta etapa la dominan sistemas operativos MS-DOS y el Unix (y en un inicio el CP/M).
El actual desarrollo de los sistemas operativos basados en GUI (Graphic User Interface) y la
incorporacin de orientacin a objetos as como el soporte de la multimedia, es suficientemente
fuerte para hablar de la quinta generacin de los sistemas operativos.
En esta etapa la competencia se centra entre el Unix/Linux, el Windows, Macintoch, y el OS/2

(al menos en las microcomputadoras).
Sistemas multiprocesadores
La mayora de los sistemas de cmputo existentes son monoprocesadores, es decir disponen de

un solo procesador central. El trmino multiprocesamiento est referido a la existencia en un
sistema de cmputo de 2 ms CPU que comparten la memoria y los perifricos.
La principal ventaja de este tipo de estructuracin es el incremento de la potencia de

computacin y la posibilidad de una programacin paralela real.
Los sistemas de cmputo ms comunes con esta organizacin disponen de un procesador maestro
que controla a otros (esclavos) que realizan tareas especficas.
Los sistemas operativos que operan en estas condiciones reciben el nombre de sistemas
operativos de multiprocesador. La imagen de estos sistemas se corresponde con la de los
uniprocesadores, es decir, la de un nico sistema y por ello su diseo e instrumentacin son
similares a la de estos, excepto que se tienen que tener en cuenta consideraciones especiales en el
uso de los componentes que pueden ser accedidos simultneamente por ms de un procesador.
Pag - 9
Sistemas de Operacin
Tema I: Conceptos fundamentales.
Captulo. 2- : Servicios del Sistema Operativo.
Proteccin.
Procesos. Tabla de Procesos.
Servicios del Sistema Operativo.
Programas del sistema
Llamadas al sistema
Interprete de comandos (Shell).
Estructura de un sistema Operativo
Bibliografa:
Operating System Concepts, Peterson y Silberchatz, pag. 39 a la 54
Operating system Design and Implementation, Tanenbaum, pp. 14 a la 42.
Proteccin.
En los primeros sistemas de cmputo que se utilizaron no fue necesario tener en cuenta la
problemtica de la proteccin debido a la forma en que se operaban, es decir se ejecutaba un solo
programa y este estaba en posesin de todos los recursos existentes (en caso de error, solo se
afectaba l).
Al desarrollarse los sistemas operativos an cuando se mantuviera un nico programa en

memoria (monoprogramacin), se comenzaba a compartir recursos. En este caso, el programa y
el sistema operativo comparten la memoria. Si ocurriera un funcionamiento errneo del programa
y este sobrescribe el rea de memoria del sistema operativo, resulta evidente que existir un
crash de este.
Otro ejemplo simple se puede notar en el caso de procesamiento en lote. Suponga que un
programa cae en un lazo infinito de lectura de tarjetas. Es evidente que tomar todas las que le
pertenecan y las que le siguen.
El compartir recursos aumenta la utilizacin eficiente de estos, pero a la vez incrementa las
dificultades. Un error en un programa puede afectar a otros trabajos.
Pag - 10
En los sistemas operativos que instrumentan la multiprogramacin, Pueden ocurrir muchas otras
situaciones no tan evidentes como las indicadas, por esto este se debe proteger y a la vez brindar
proteccin a todos los programas que se ejecutan.
Todo recurso compartido debe ser protegido, pero al menos deben disponer de esta caracterstica
las entradas y salidas, la memoria y la CPU.
La proteccin de entradasalida se logra al no permitir que los programas acten directamente

sobre los dispositivos, sino a travs de llamadas a los manejadores de dispositivos que forman
parte del sistema de operacin. De esta forma se puede chequear si la solicitud es correcta o no y
evitar que algo vaya mal.
Para evitar que un programa intente operar directamente con la entrada salida, las instrucciones
correspondientes se declaran como privilegiadas (esto tiene que estar instrumentado en el
Hardware) y por ello solo podrn ser utilizadas por parte del Sistema Operativo.
Lo antes indicado quiere decir que el Hardware deber brindar dualidad en dos modos en que los
programas se ejecuten. El primero es el modo kernel (o monitor, supervisor, sistema, protegido) y
el segundo es el modo usuario. El SO correr en modo protegido (con derecho a usar
instrucciones privilegiadas) y todos los dems en modo usuario.
Por supuesto que en la CPU existir un bit que en todo momento indicar el modo en que se est
ejecutando. Este se pondr a 1 o 0 cada vez que se produzca un cambio entre el SO y otro
programa. Es de suponer que las instrucciones que permiten variar este bit son privilegiadas.
Da la impresin que con los aspectos antes indicados ya se tiene garantizada la proteccin de las
entradas salidas, pero antes de dar tal afirmacin se hace necesario estar seguro que ningn
programa usuario pueda ejecutar en modo supervisor. Qu pasara si a un programa usuario se le
permite direccionar el rea de memoria del sistema operativo y modificar un vector de
interrupcin?
Al ocurrir la interrupcin, el Hardware pasar la ejecucin al modo privilegiado (ya que va a

operar el sistema operativo) pero como se cambi el vector de interrupcin, nos encontramos que
el programa usuario se hace dueo del sistema de cmputo con total impunidad.
Para evitar esta situacin y otras similares se impone disponer de un mecanismo de proteccin de
memoria. Es decir, evitar que un programa usuario pueda acceder el rea de trabajo del Sistema
de Operacin. En los sistemas multiprogramados tambin se tiene que impedir tal accin en el
rea de otro programa.
Pag - 11
La solucin a esta problemtica requiere que el Hardware brinde su ayuda. En un ambiente de

monoprogramacin es suficiente con la existencia de un registro (tope o lmite) que separe el rea
de trabajo del sistema operativo de la del programa usuario.
En este caso, generalmente el sistema operativo se ubica en la

parte baja de la memoria y a continuacin comenzara el rea
Programa del programa usuario (figura 1.1). Cada vez que dicho programa
Usuario realiza un acceso a memoria, el hardware chequea que la
Registro direccin referida no sea menor que la contenida en el registro a
tope o los efectos de permitirlo. Si se detecta el intento de penetrar en
lmite el rea no autorizada ocurrir una trampa invocndose al SO
para que decida la situacin (generalmente se elimina al que
provoca la ofensa)
Sistema El SO conserva la posibilidad de acceder cualquier
Operativo posicin de memoria (al correr en modo privilegiado
el hardware no lo controla).Por supuesto la carga del
registro indicado solo se puede hacer en modo kernel.
Figura 1.1
Si el ambiente de trabajo es multiprogramado, un

A Lmite
solo registro no basta. En este caso, se requieren dos
superior
registros, almacenndose en ellos el lmite superior e
inferior de memoria que le es permitido acceder al
B programa que est en ejecucin en cada instante de
tiempo (su rea de trabajo, figura 1.2)
Lmite inferior
C
Sistema
Operativo
Figura 1.2
Lo antes indicado presupone que cada vez que pasa el control del CPU de un programa a otro, el
sistema de operacin actualice los registros indicados con los nuevos valores requeridos.
La proteccin del procesador tiene como objetivo evitar que un programa usuario caiga en un
lazo de procesamiento infinito aduendose de este por tiempo indefinido. Esto se logra por
Pag - 12
medio de un reloj (timer) de Hardware que permite detener el procesamiento y regresar el

control, va una interrupcin, al sistema operativo.
Generalmente se instrumenta un reloj variable por medio de uno fijo y un contador. Dicho
contador recibe un valor por parte del sistema operativo y se decrementa con cada golpe del reloj
de intervalo fijo, cuando alcanza el valor cero se emite la interrupcin y el sistema operativo
decide la accin a ejecutar. Por supuesto, las instrucciones que permiten modificar el valor del
reloj son privilegiadas.
Procesos Tablas de procesos.
Antes de continuar estudiando otros aspectos relacionados con los Sistemas Operativos resulta
conveniente puntualizar el concepto de proceso que constituye uno de los ms esenciales en esta
materia.
Un proceso es, bsicamente, un programa en ejecucin y precisamente por esa razn existe la
tendencia a confundir ambos trminos. La diferencia consiste en que un proceso incluye adems
del programa (secuencia de cdigo ejecutable) los datos, la pila, el contador de programa, los
valores almacenados en los registros y todo aquello que refleja el estado de la ejecucin en un
instante.
La importancia de este concepto radica en que un programa por si solo no refleja su estado de
ejecucin lo que resulta esencial a los efectos de continuar su procesamiento futuro si en un
determinado momento se le retira el control del procesador (lo que constituye la base de la
multiprogramacin).
Para guardar la informacin de los procesos que en cada instante estn siendo atendidos por el
sistema de operacin se utiliza la Tabla de Procesos. Esta no es ms que un arreglo o lista de
estructuras donde cada una de ellas contiene los datos que definen el estado del proceso
determinado.
Las informaciones de un proceso se actualizan en numerosos momentos, pero por lo menos cada
vez que se le va a quitar el uso del procesador.
Los campos que componen cada entrada en la Tabla de Procesos varan de un sistema operativo
a otro y generalmente son numerosos. Resultan tpicos algunos como: estado del proceso, valores
de los registros, contador de programa, identificador, rea de memoria utilizada, tabla de ficheros
abiertos, directorio actual, etc.
Todo proceso presente en un sistema operativo se identifica por un nmero entero que se conoce
por el identificador del proceso (PID)
Generalmente un proceso puede crear uno o mas procesos (procesos hijos) que a su vez pueden
crear otros, llegndose a una estructura arbrea.
Servicios del Sistema Operativo
Como ya se indic una de las dos funciones principales de un Sistema Operativo es servir de
Mquina Ampliada o Virtual, brindando facilidades a los programas de los usuarios y a estos.
Pag - 13
Para lograr este objetivo, los Sistemas Operativos se encargan de programar el trabajo con los
diferentes dispositivos existentes en el Sistema de Cmputo, separando a los usuarios y
programas de esta tarea compleja y tediosa.
Los servicios a usuarios se brindan bsicamente por medio de los llamados Programas del
Sistema, mientras que a los programas se les brindan a travs de las Llamadas al Sistema.
Los programas del sistema, constituyen una coleccin ms o menos grande de programas (no
funciones o subrutinas) desarrollados por el fabricante (u otra empresa) que permite realizar
operaciones que son comunes a diferentes usuarios, brindando un ambiente ms adecuado para el
desarrollo y explotacin de aplicaciones.
Los programas del sistema pueden ser divididos en varias categoras, aunque esto tambin
depende de cada sistema operativo. Algunos posibles grupos serian: Manipulacin de ficheros
(crear, eliminar, renombrar, imprimir, etc.), obtencin de informacin de estado (fecha, hora,
memoria disponible, espacio en disco, etc.), editores de texto, etc.
En resumen, los programas del sistema son aquellos que ejecutan las acciones descritas en los
comandos de ste o que aparecen en los menes en el caso de las interfaces de este tipo.
Las llamadas al sistema, constituyen la interfase entre el sistema de operacin y los procesos.
Estas llamadas generalmente se hacen por medio de instrucciones en lenguaje ensamblador,
aunque en algunos casos existen facilidades que permiten se realicen desde lenguajes de alto
nivel.
En el segundo caso antes indicado, se dan las variantes de que existan funciones o
procedimientos predefinidos en biblioteca que realicen las llamadas al sistema como tal (UNIX,
WINDOWS) o el compilar genera directamente las instrucciones necesarias para esto.
Los mecanismos que ponen en ejecucin las llamadas al sistema operativo difieren de uno a otro
En el OS/360 existe una instruccin especial (SVC) que provoca una trampa hacia el sistema.
El nmero de la llamada se da en la instruccin.
En el CP/M no existe una instruccin especial y por ello el nmero de la llamada se pone en
el registro C y se salta a la direccin 5 de la memoria.
En MS-DOS se utiliza la instruccin INT seguida de un nmero de interrupcin (21H).
En todos los casos antes indicados se requiere de la transferencia de parmetros desde o haca el
procedimiento que instrumenta la llamada. Este pase de parmetros se ejecuta a travs de los
registros del procesador o por medio de un bloque o tabla de memoria (la direccin del cual se
pasa en un registro).
El nmero de llamadas, la forma y tipo de cada una y los posibles agrupamientos de estas
dependen de cada sistema de operacin en especfico, aunque en forma general se pudieran
catalogar en 4 grupos:
Pag - 14
Control de procesos.
Incluyen operaciones con los procesos tales como: crear, eliminar, finalizar, abortar,
ejecutar, enviar seal, esperar por seal, etc.
Manipulacin de ficheros.
Incluyen operaciones con los ficheros tales como: crear, eliminar, abrir, cerrar, renombrar,
leer, escribir, etc.
Manipulacin de dispositivos.
Incluyen operaciones con los dispositivos tales como: solicitar, liberar, leer, escribir, etc.
Intercambio de informacin.
Incluyen operaciones tales como: Conocer la fecha, conocer la hora, conocer atributos de
ficheros, fijar atributos de ficheros, fijar la fecha, etc.
Adems de los grupos antes indicados podra haber otros u otras OPERACIONES dentro de
estos. Otros conjuntos podran ser:
Manipulacin de directorios y sistemas de ficheros.

Proteccin.
Sealizacin.
La mejor manera de entender la esencia de las llamadas al sistema consiste en hacer una revisin
detallada de las que estn presentes en uno o varios sistemas operativos y por ello se recomienda
revisar las pginas de la 23 a la 36 del libro de Tanenbaum, donde se presenta la explicacin de
una de las ms importantes presentes en la versin 7 del UNIX.
Interprete de comandos
Uno de los ms importantes programas del sistema es el intrprete de comandos. Es el programa

que sirve de interfase entre el sistema operativo y los usuarios de ste. An cuando algunos
autores no lo consideran parte del sistema de operacin (dado que cada usuario podra crear el
suyo), no hay duda que guarda una estrecha relacin con ste.
El interprete de comandos toma el control una vez que el sistema operativo ha sido cargado o el
control de una terminal una vez que un usuario se ha identificado en un sistema de tiempo
Pag - 15
compartido.
Los intrpretes de comandos han recibido distintos nombres en diferentes sistemas operativos:
interprete de tarjetas de control, intrprete de lnea de comando, procesador de comandos de
consola (CPM), Shell (UNIX), etc.
La funcin del intrprete de comandos es en general bastante simple y consiste en tomar la tarjeta
de control o comando, validar si es correcto o no y en el primer caso realizar la ejecucin
correspondiente. El cdigo que ejecuta el comando puede formar parte del propio intrprete o
constituye otro programa del sistema.
Los intrpretes de comandos que presentan interfaces con usuarios ms amigables, incluyendo las
hoy reconocidas interfaces grficas, tienen una mayor complejidad dada el uso de mens, botones
mouse y otros recursos.
An cuando en la mayora de los sistemas operativos el interprete de comandos pierde el control

de ejecucin tan pronto se inicia un comando y no lo recupera hasta que ste finalice, hay algunos
donde el comando se ejecuta en paralelo (como un proceso hijo del interprete). Un ejemplo de
esto est en el UNIX con el uso del smbolo &.
Estructura de un Sistema Operativo.
La estructura de un Sistema Operativo se puede analizar desde el punto de vista funcional y desde
el punto de vista organizativo de los programas que lo componen.
Desde el punto de vista funcional hay que tener en cuenta que los sistemas operativos son
programas manejados por eventos. Si no hay programa que ejecutar, dispositivo que brindar
servicio o usuario que atender entonces no har nada.
Los eventos (mensajes o seales) que lo ponen en accin sern las interrupciones o las trampas.
Por lo tanto los sistemas de operacin son programas manejados por interrupcin.
La naturaleza de los sistemas operativos de ser manejados por interrupcin determina su

estructura desde el punto de vista funcional.
Cuando una interrupcin (o trampa) ocurre, de inmediato el hardware transfiere el control al

sistema operativo. Este preserva el estado del proceso que se ejecutaba y a continuacin realiza el
tratamiento correspondiente.
Pag - 16
Pueden ocurrir tipos diferentes de interrupciones, pero pueden agruparse en tres tipos:
1. Llamadas al Sistema.
2. Interrupcin de un dispositivo.
3. Un error de programa (detectado por hardware).
Las llamadas al sistema, a estos efectos, pueden dividirse en
Solicitud de terminacin normal (realizada por un proceso cuando va a terminar su ejecucin).

Solicitud de terminacin anormal (realizada por un proceso al detectar la existencia de un error).
Solicitud de recursos (si no estn disponibles, entonces el proceso deber esperar).
Solicitud de informacin de estado (La informacin es transferida).
Solicitud de entrada/salida.
A los efectos de la accin del sistema operativo los casos 3 y 4 se pueden considerar como
iguales.
De aqu que un sistema operativo estar compuesto por al menos de: manejadores de dispositivos,
atencin a interrupciones (handlers), un conjunto de subrutinas de llamadas al sistema y el
intrprete de comandos o tarjetas de control. Como es lgico, el sistema de ficheros tambin
estar presente.
La mayora de los sistemas operativos brindan funciones adicionales y por ello habr
complejidades an mayores.
Desde el punto de vista de la organizacin de los programas, la estructura de un sistema operativo

puede tomar distintas formas. Estas podran ser:
Sistemas Monolticos.
Se caracterizan por la no existencia de estructura. Se escriben como una coleccin de

procedimientos donde cada uno de ellos puede llamar a cualquier otro que le brinde un servicio
que necesite. En este caso los procedimientos necesitan tener una interfase bien definida en
trminos de parmetros y resultados.
An en esta variante puede existir una pequea estructura en lo que se refiere a los servicios
brindados por las llamadas al sistema.
Sistemas de Capas.
Se caracterizan por estar organizados como una jerarqua de capas, cada una construida sobre la
anterior.
El primer sistema construido en esta forma fue el THE a cargo de E. W. Dijkstra y sus alumnos
(en 1968). En dicho sistema se consider la existencia de 6 capas:
Pag - 17
0.- Asignacin del procesador y multiprogramacin.

1.- Administracin de memoria y tambor magntico.
2.- Comunicacin operador - procesos.
3.- Administracin de entrada/salida.
4.- Programas usuarios.
5.- El operador.
Una generalizacin de este concepto fue aplicado en el sistema operativo MULTICS. Se organiz
como una serie de anillos concntricos, siendo los ms internos los de mayor prioridad. Para que
un procedimiento de un nivel pueda llamar a otro ms interno lo tiene que hacer a travs de una
llamada del sistema.
Mquinas Virtuales.
En este esquema, el centro del sistema operativo se ejecuta directamente en el hardware existente
y permite el logro de la multiprogramacin. Esta, en lugar de ejecutar varios procesos, crea
varias mquinas virtuales en una segunda capa. Estas mquinas virtuales son copias exactas del
hardware original y por ello cada una de ellas puede ejecutar cualquier sistema operativo que
pueda operar en la mquina original.
Este formato es conocido hace tiempo (desde la IBM/360), pero hoy se utiliza para crear
mquinas virtuales que permitan ejecutar en un sistema operativo programas preparados en otro
(WINDOWS).
Modelo cliente - servidor.
Es una tendencia de los actuales sistemas de operacin que consiste en instrumentar la mayora
de las funciones en procesos usuarios, construyendo un kernel mnimo.
Para solicitar un servicio, un proceso usuario (llamado cliente) enva la solicitud al proceso
servidor, el cual realiza el trabajo y le regresa la respuesta. En este modelo la funcin principal
del kernel consiste en manejar la comunicacin entre clientes y servidores (y lgicamente la
atencin a las interrupciones de los dispositivos).
La divisin del sistema operativo en partes, cada una de las cuales atiende una faceta de este,
ejecutndose la mayora de ellas (los servidores) en modo usuario permite, dar ventajas
importantes.
La primera consiste en que la aparicin de un error en una parte no implica necesariamente que
todo el sistema se carga (crash). La segunda consiste en la fcil adaptacin de un sistema de este
tipo para su utilizacin en un medio distribuido.
Pag - 18
Tema II : Procesos
Captulo. 3.- Procesos
Modelo de procesos. Estados de los procesos.

Programacin concurrente. Grafos de procedencia.
Condiciones de concurrencia. Especificaciones.
Jerarqua entre procesos.
Bibliografa:
Operating System Concepts, Peterson y Silberschatz, pag 103 - 110, pag 307-325.
Oprating Systems: Design and implementation, Tanembaum, pag 45-51.
Modelo de procesos. Estados de los procesos
Como ya se indic, el concepto de proceso juega un rol fundamental en la teora y prctica de los
sistemas operativos.
Se seal que un proceso era simplemente un programa en ejecucin, lo que implicaba la

tenencia de reas de memoria, valores de registros, contador de programa, puntero de la pila, etc.
La informacin acerca de los procesos presentes en un instante de tiempo se conserva en la tabla

de procesos, la que permite restaurar un proceso que perdi antes el control de ejecucin.
Cada entrada de esta tabla se corresponde con un proceso en el sistema y recibe el nombre de
bloque de control del proceso (PCB). Este contiene diferentes grupos de informacin para un
proceso en especfico.
Estado del proceso.

Contador de programa.
Registros del CPU (acumuladores, ndice, propsito general, estado).
Uso de memoria (Direccin, Inicio y longitud de los segmentos, tablas de pginas, etc.).
Informacin de contabilidad (Cantidad de tiempo real y del CPU utilizado, lmites de tiempo,
nmero del proceso, etc.).
Informacin del estado de E/S (dispositivos asignados, lista de ficheros abiertos, solicitud de
E/S, etc.).
Informacin de planificacin del CPU (prioridad, punteros a las colas de planificacin, etc.).
En el modelo de procesos todo el Software ejecutable, a menudo incluyendo el propio sistema de

operacin, se organiza como procesos secuenciales. Aparentemente cada proceso tiene su propio
procesador central, pero en realidad este cambia de uno a otro de acuerdo con el concepto de
multiprogramacin (seudoparalelismo).
Pag - 19
Los procesos son totalmente aleatorios en el tiempo y el comportamiento de un conjunto de ellos

depender de las condiciones en un instante dado. Esto implica que los programas no pueden ser
elaborados asumiendo lo que pasar en el futuro cuando se estn procesando.
Un proceso puede tener diferentes estados durante su existencia. El nmero de estados depender
del diseo del sistema operativo, pero al menos hay tres que siempre estarn presentes:
En ejecucin: El proceso est en posesin del CPU en ese instante.

Bloqueado: El proceso est esperando hasta que ocurra un evento externo (por ejemplo, una
E/S).
Listo: El proceso est en condiciones de ejecutar, pero est detenido temporalmente para
permitir a otro proceso la ejecucin.
Si a estos tres estados le agregamos las transiciones entre ellos se obtendra el siguiente grafo.
En ejecucin
1 2
3
Bloqueado Listo
4
Las cuatro transiciones que aparecen en el grafo dirigido se explican en la forma siguiente:
La transicin 1 implica que el proceso estaba en ejecucin y se bloquea debido a que necesita
esperar la ocurrencia de un evento externo. Esta transicin se logra con la propia ejecucin
de una llamada al sistema con este fin o forzado por el sistema operativo (se realiz una
solicitud que no puede ser satisfecha en ese instante).
La transicin 2 ocurre cuando el planificador del procesador (Scheduler, una parte del sistema
operativo) decide que se debe entregar el control del CPU a un proceso, an cuando el actual
estara en condiciones de continuar. Esta decisin puede estar motivada por el hecho de que
el proceso ya consumi el quantum de tiempo asignado o est listo otro que tiene mayor
prioridad que el actual.
La transicin 3 tambin es realizada por el planificador del procesador y consiste en entregar

el control de este a un proceso que est listo (debido a que el actual termin, se bloque o se
le quit).
La transicin 4 ocurre cuando el evento externo que el proceso estaba esperando tiene lugar.
Si en ese instante no hay otro proceso ejecutando o su prioridad es superior al que est, de
inmediato ocurrir tambin la transicin 3, en caso contrario tendr que esperar en el estado
de listo.
Pag - 20
Haciendo uso del modelo de procesos resulta ms fcil comprender como puede ser un sistema
operativo por dentro. Algunos de los procesos constituyen programas mandados a ejecutar por los
usuarios en sus comandos, pero otros son parte del sistema (sistema de ficheros, administrador de
memoria y manejadores de dispositivos). Todos estos procesos se bloquean cuando necesitan
esperar por algo y al ocurrir el evento pasan al estado de listo y son ilegibles para ejecutarse (por
supuesto el evento que espera un manejador de dispositivo es la interrupcin correspondiente).
La vista antes dada permite llegar a un modelo del sistema operativo donde el nivel ms bajo es
el planificador y el siguiente lo forman una variedad de procesos (creados por los usuarios o
partes del sistema operativo).
0 1 N -2 N -1
Planificador
En el planificador no solo se considera el planificador de procesos sino tambin los manejadores

de interrupcin y la comunicacin entre los procesos.
La instrumentacin efectiva del modelo de procesos se logra mediante el uso de la tabla de

procesos antes explicada. Para tener una idea ms precisa an de las informaciones contenidas en
esta estructura se debe recurrir a la bibliografa propuesta (Fig2-4, pag. 50, Tanembaun).
Programacin Concurrente. Grafos de precedencia.
El trmino programacin concurrente o simplemente concurrencia se refiere a la ejecucin

paralela de instrucciones o procesos (aunque sea seudoparalela se debern tener en cuanta las
mismas consideraciones). Resulta conveniente revisar primero lo referente a las instrucciones.
Suponga que se dispone de un procesador con varias unidades funcionales para realizar las
instrucciones o simplemente se tienen mltiples CPU y se desean ejecutar en grupo de
instrucciones pertenecientes a un programa.
S1: a = x + y;
S2: b = z + 1;
S3: c = a - b;
S4: w = c + 1;
Lgicamente la instruccin c = a - b no puede ser ejecutada hasta que no hayan sido realizadas la
S1 y la S2 de forma tal que los valores de a y b hayan sido calculados. Lo mismo ocurre con S4
Pag - 21
con respecto a S3. En cambio las instrucciones a = x + y, y b = z + 1 se pueden ejecutar

concurrentemente debido a que una no depende de la otra.
Lo importante de notar en este ejemplo es que dentro de un proceso existen restricciones de
precedencia entre las distintas instrucciones. Para esquematizar estas situaciones se hace uso de
los llamados grafos de precedencia.
Un grafo de precedencia es un grafo dirigido y sin ciclos donde los nodos corresponden a
instrucciones. Un arco desde un nodo Si a un nodo Sj significa que la instruccin Sj solo puede
ser ejecutada despus que se realice la Si.
Por ejemplo, en las instrucciones antes indicadas se tendra:
S1 S2
S3
S4
Otro ejemplo de grafo de precedencia podra ser:
S1
S2 S3 S4
S5
S6
Condiciones de concurrencia y especificacin.
Pag - 22
Para que dos instrucciones puedan ejecutarse concurrentemente debern cumplir ciertas
condiciones. A estas se le llaman condiciones de concurrencia.
Definamos el conjunto
R(Si) = {a1, a2, , an} como el conjunto de lectura para Si, este est formado por todas las
variables cuyos valores son referenciados en las instruccin Si durante su ejecucin.
Definamos el conjunto
W(Si) = {b1, b2, , bm} como el conjunto de escritura para Si, es decir todas las variables que
cambian de valor (se escriben) como resultado de la ejecucin de la instruccin Si.
Considerando la ecuacin a = x + y se tendr:
R(Si) = {x, y} W(Si) = {a}
Si se toma la ecuacin c = a - b
R(S3) = {a, b} W{S3) = {c}
Para que dos instrucciones sucesivas Sa y Sb puedan ser ejecutadas concurrentemente y producir
el mismo resultado se tienen que cumplir las siguientes condiciones:
1.- R(Sa) ^ W(Sb) = {}

2.- R(Sb) ^ W(Sa) = {}
3.- W(Sa) ^ W(Sb) = {}
Si aplicamos estas condiciones a S1: a = x + y, y a S3: c = a - b veremos que efectivamente ellas

no pueden ejecutarse concurrentemente ya que:
R(S3) ^ W(S1) = {a}
El grafo de precedencia es un medio til para ver las restricciones de precedencia que puedan
existir en un conjunto de instrucciones pertenecientes a un proceso, pero no permiten presentar
clculos concurrentes en un lenguaje de programacin.
Las instrucciones fork and join fueron unas de las primeras notaciones que se utilizaron para
especificar en un programa la ejecucin concurrente de instrucciones.
La instruccin fork L produce en un programa dos hilos de ejecucin concurrentes. Uno

comienza en la etiqueta L y el otro en la instruccin siguiente al fork
Pag - 23
S1;
S1 fork L;
S2;
.
.
fork .
L: S3;
.
S3
.
S2 .
La instruccin join permite unir o recombinar varios hilos de ejecucin en uno solo. Cada una de
las computaciones deben solicitar ser unidas con las otras. Dado que cada hilo de ejecucin debe
ejecutar el join y lo realiza en momentos diferentes, todos terminarn menos el ltimo. Debido a
que el join necesita saber cuantos hilos se debern unir para poder terminar a todos menos el
ltimo, la instruccin tiene un parmetro con esta informacin.
count=2;
.
.
S1 S2
.
S1;
go to L1;
join .
.
.
S3 S2;
L1:join count;
S3;
El efecto de la instruccin join es como sigue:
count = count - 1;
if (count ! = 0) quit;
donde quit es una instruccin que resulta en la terminacin de la ejecucin. Ambas instrucciones
se ejecutan en forma indivisible.
Pag - 24
A manera de ejemplos veamos los dos que se han utilizado anteriormente .
count = 2; count1 = 2;
fork L1; count2 = 2;
a = x + y; S1;
go to L2; fork L1;
L1: b = z + 1; fork l2;
L2: join count; S2;
c = a - b; go to L3;
w = c + 1; L2:S3;
L3:join count2;
S5;
go to L4;
L1:S4;
L4:join count1;
S6;
La construccin fork-join tiene la desventaja de no ser estructurada y por ello le son inherentes
todas las crticas que ha recibido el go to.
Una construccin estructurada para especificar concurrencia es la parbegin / parend. Su forma es:
parbegin S1; S2 ; ; Sn parend;
Todas la instrucciones encerradas entre parbegin y parend se ejecutarn concurrentemente.
A manera de ejemplo veamos los dos anteriormente utilizados con el fork y el join :
parbegin S1;
a = x + y; parbegin
b = z + 1; S4;
parend; {
c = a - b; parbegin
w = c + 1; S2;
S3;
parend;
S5;
}
parend;
S6;
Esta construccin estructurada tiene la desventaja de que no puede especificar todos los grafos de
precedencia. No obstante, esta herramienta, unida con otros mecanismos, si da una respuesta
totalmente satisfactoria.
Pag - 25
Ahora es necesario extender los aspectos antes tratados, en cuanto al uso de grafos de
precedencia y las especificaciones de programacin, de instrucciones dentro de un proceso a la
relacin entre procesos.
En este caso, cada nodo de un grafo de precedencia ser visto como un proceso secuencial. En tal
ambiente los procesos aparecen y desaparecen dinmicamente durante el tiempo de duracin de
una ejecucin.
Cuando un proceso Pi ejecuta una instruccin fork L, se crea un proceso nuevo Pj. Al arribarse a
la instruccin join count, el contador es decrementado por uno y si el resultado es cero, el proceso
continua su ejecucin y en caso contrario terminar .
Jerarqua entre procesos.
Como ya se indic con anterioridad un proceso puede crear otros procesos. De igual forma los
nuevos pueden crear otros y as sucesivamente.
Para representar grficamente este proceso de creacin sucesiva de procesos se utiliza el llamado
grafo de procesos que no es ms que un rbol dirigido con raz . Un arco del nodo Pi al nodo Pj.
En este caso se dice que Pi es el padre de Pj o que Pj es hijo de Pi. Cada proceso tiene un solo
padre, pero tantos hijos como sean necesarios.
P1
P3
P2
P5
P4
Existen diversas formas en que un proceso puede crear uno al hacer uso de una operacin con
este objetivo (como la fork). Para ello se debe tener en cuenta como contina la ejecucin y
como se compartirn los recursos.
Desde el punto de vista de como contina la ejecucin se pueden instrumentar dos casos:
El padre contina la ejecucin concurrentemente con el hijo (construccin fork/join).

El padre espera hasta que el hijo termina (construccin parbegin/parend).
Desde el punto de vista de cmo se compartirn los recursos se pueden instrumentar tambin dos
casos:
El padre y el hijo comparten todas las variables (construccin forK/join).

El hijo solo tiene acceso a un subconjunto de las variables del padre (esquema del Unix).
Pag - 26
Un proceso termina cuando ejecuta su ltima instruccin, sin embargo existen circunstancias en
que se requiere terminarlo en forma forzada. Un proceso termina a otro mediante una instruccin
del tipo Kill Id.
La operacin kill es usualmente invocada solamente por un proceso padre para culminar la
ejecucin de un hijo. Como la instruccin requiere la identificacin del proceso a ser terminado,
la instruccin fork da como retorno esta informacin (Id = fork L). Existen numerosas razones
por las cuales un padre puede detener la ejecucin de un hijo.
En muchos sistemas operativos se establece la condicin de que los procesos hijos no pueden
continuar la ejecucin si el padre ha sido finalizado.
Un proceso que no termina su ejecucin durante todo el tiempo en que el sistema operativo est
funcionando se dice que es esttico. Un proceso que finaliza se dice que es dinmico.
Si un sistema operativo consiste de solo un nmero limitado de procesos estticos entonces su

correspondiente grafo de procesos ser tambin esttico (es decir nunca cambia). En caso
diferente ser dinmico. La estructura esttica solo est presente en sistemas operativos muy
simples.
La jerarqua de procesos antes discutida est presente en la mayora de los sistemas operativos
que soportan el modelo de procesos.
Pag - 27
Tema II.- Procesos.
Captulo . 5.- Seccin crtica
Sincronizacin entre procesos.

Condiciones de competencia. Seccin crtica.
Exclusin mutua con espera ocupada.
Bibliografa
Operating Systems Concepts, Peterson and Silberschatz, Pag 326-344

Operating Systems: Design and Implementation, Tanembaum, pag 51-67.
Sincronizacin entre procesos
En el caso en el cual dos procesos se encuentran en espera por condiciones extremas (buffers
llenos y vacos, respectivamente), uno de los mecanismos utilizados para la espera consista en
ejecutar en forma sucesiva un lazo donde no se haca nada, es decir una espera ocupada.
La espera ocupada puede no ser un mecanismo adecuado. Suponga que cada proceso en un
procesador diferente. En ese caso el que est en espera consume tiempo del CPU de forma
improductiva, ese tiempo podra ser utilizado por otro proceso en una actividad til.
En el caso de un solo procesador las dificultades pueden ser aun mayores, pues si el CPU est
siendo utilizado por el proceso que est en espera, entonces el otro no podr tomarlo y no se
saldr de esa situacin (el consumidor espera debido a que no hay buffers llenos y el productor no
puede generar ya que el procesador lo tiene el consumidor) y lo estudiaremos en detalles ms
adelantes.
Una solucin a la anterior dificultad consistira en que a cada proceso se le asigna un quantum de
tiempo para ejecutar, cuando dicho tiempo expira se le retira el procesador y se le entrega a otro.
De todas formas el proceso que est en espera consumira tiempo en forma no productiva.
La solucin a la dificultad antes enunciada consiste en establecer que cuando un proceso necesita
esperar se deber bloquear, es decir se le debe retirar el CPU y ponerlo en una cola de espera
hasta que ocurra el evento (estado de bloqueado).
Supongamos que disponemos de dos funciones (que llamaremos primitivas) con las siguientes
caractersticas. La primitiva sleep() (pudiera ser block()) implica que el proceso que la ejecuta
pasa al estado de bloqueado. La primitiva wake_up(Proceso) pasa el proceso, que se indique en el
argumento, del estado de bloqueado al estado de listo.
Pag - 28
Condiciones de competencia. Seccin crtica.
Las situaciones en las cuales dos o ms procesos accesan en forma simultnea datos compartidos
y el resultado del procesamiento depende del orden en que las instrucciones se ejecuten reciben el
nombre de condiciones de competencia o concurso (race condition).
No es posible hablar de que varios procesos estn adecuadamente sincronizados si no se ha

evitado la ocurrencia de condiciones de concurso.
Se define como seccin crtica de un proceso al segmento de cdigo que accede a variables,
tablas, ficheros y otros elementos que son comunes o globales con otros procesos.
Entonces el problema consiste en que al estar un proceso ejecutando en su seccin crtica no se le

permite a otro entrar en la suya. Por lo tanto la ejecucin por los procesos de las secciones crticas
se debe realizar en base a una exclusin mutua.
La exclusin mutua consiste en disear un protocolo que sea utilizado por los procesos para
ejecutar en forma cooperativa. Cada proceso debe pedir permiso para entrar en su seccin crtica,
la parte de cdigo que realiza esta solicitud es la seccin de entrada. La seccin crtica es seguida
por un grupo de cdigos llamada seccin de salida, que en general habilita las condiciones para
que otro proceso pueda entrar en la suya. Por ltimo todo el cdigo restante que no tiene relacin
con la seccin crtica se puede agrupar en la seccin restante.
De acuerdo con lo anterior un proceso se podra esquematizar en la forma siguiente:
#define TRUE 1
while (TRUE) {
seccin de entrada
seccin crtica
seccin de salida
seccin restante
}
Para que un mtodo garantice la exclusin mutua y logre un procesamiento paralelo correcto y
eficiente deben cumplirse cuatro condiciones:
Exclusin mutua: No pueden haber simultneamente dos procesos en sus respectivas

secciones crticas.
Suposiciones: La solucin no puede estar basada en suposiciones acerca de las velocidades

relativas de los procesos ni sobre la cantidad de procesadores.
Progreso: Ningn proceso que se encuentre fuera de sus seccin crtica (est en la seccin
restante) puede impedir que otro entre en sta. La seleccin de quien entra no se puede
posponer indefinidamente.
Pag - 29
Lmite de tiempo: Ningn proceso deber esperar un tiempo arbitrariamente largo para
entrar en su seccin crtica (evitar que padezca de inanicin, starvation).
Si los procesos que se ejecutan hacen uso de un solo procesador (seudoparalelismo) entonces una
idea sencilla para lograr la exclusin mutua consiste en que la seccin de entrada de cada proceso
desactive las interrupciones y la de salida las habiliten de nuevo. La racionalidad de esta solucin
se basa en el hecho de que planificador de procesos aprovecha las interrupciones (dispositivos o
reloj) para decir que proceso obtiene la ejecucin, lo que pudiera implicar que el proceso en la
seccin crtica pierda el procesador.
Esta alternativa solo es vlida si la seccin crtica es pequea (unas pocas instrucciones de
mquina), lo que en general no es cierto. Adems, implica que el usuario inhiba las
interrupciones.
Si existen varios procesadores (multiprocesamiento) esta alternativa no tiene sentido ya que la

desactivacin de las interrupciones en uno de ellos no afecta para nada a los restantes.
Exclusin mutua con espera ocupada.
Numerosos mtodos y tcnicas se han desarrollado con el objetivo de lograr la exclusin mutua.
En muchos no se logra responder adecuadamente a los 4 requisitos antes indicados, en otros si.
Hagamos una breve revisin de algunos de ellos, considerando que un proceso debe esperar lo
hace en forma ocupada y no bloqueado.
Primero se restringir la atencin a algoritmos que son solamente aplicables a solamente dos
procesos que identificaremos como P0 y P1. Se presentarn las variables comunes y la
representacin de Pi, se asume que el otro proceso es Pj, donde j = 1 - i.
El proceso de alternacin estricta se basa en el uso de una variable entera comn (short) que
recibe inicialmente el valor de 0 ( 1). Si turn = 1 entonces el proceso Pi tiene derecho a ejecutar
su seccin crtica.
short int turn;

while (TRUE) {
while (turn!=i) skip /* Seccin entrada */
seccin_crtica();
turn=i; /* Seccin salida */
seccin_restante();
}
Este algoritmo asegura que solo uno de los procesos pueda estar en su seccin crtica en cada
instante, pero no satisface la condicin de progreso, ya que obliga a una alternacin estricta de los
procesos.
Pag - 30
El algoritmo anterior falla debido a que no recuerda el estado de cada proceso, sino solamente a
cual le ser permitido entrar en su seccin crtica.
Un segundo algoritmo trata de resolver el problema antes indicado conservando el estado de cada
proceso, para esto utiliza un arreglo de dos enteros (short). Inicialmente ambas entradas del
arreglo se ponen a cero.
#define TRUE 1
#define FALSE 0
short int flag[2];
while (true) {
while (flag[j]) skip; /* Seccin entrada */
flag[i]=TRUE;
seccin_crtica();
flag[i]=FALSE; /* Seccin salida */
seccin_restante();
}
Aqu el proceso Pi chequea si el otro est en su seccin crtica y si es a s espera. En caso

contrario, pone la bandera en 1 y entra en su seccin crtica. Cuando abandona la seccin crtica
pone la bandera a 0 para permitir al otro entrar en esta si estaba esperando.
Suponga que los dos procesos realizan el while concurrentemente, entonces ambos entrarn en
sus secciones crticas y por ello no se garantiza la exclusin mutua.
Una variacin del algoritmo anterior consiste en intercambiar la asignacin del valor de la
bandera con el while, de forma tal que ahora significa el deseo de entrar en la seccin crtica. De
esta forma se garantiza la exclusin mutua, pero se puede caer en un abrazo fatal.
Da la expresin que el problema no tiene solucin, pero con el conocido algoritmo de Peterson se
garantiza totalmente todas las condiciones exigidas.
Este algoritmo es una combinacin del algoritmo de alternacin estricta y el antes mencionado.
Se utiliza una variable entera (short) turn y el arreglo de banderas. Inicialmente estas estarn a 0 y
el valor de turn puede ser cualquiera.
#define TRUE 1
#define FALSE 0
short int turn, flag[2];
while (true) {
flag[i]=TRUE; /* Seccin entrada */
turn = j;
while (flag[j]&& turn==j) skip;
seccin_crtica();
flag[i]=FALSE; /* seccin salida/
Pag - 31
seccin_restante();
}
Notar que un proceso entra en su seccin crtica cuando se cumple alguna de las siguientes
condiciones:
El turno le corresponde.
El turno es del otro proceso pero ste no est interesado.
Ambas.
Si ambos procesos tratan de entrar concurrentemente en su seccin crtica, solo podr hacerlo uno
(al que le corresponde el turno).
Muchas computadoras brindan por hardware instrucciones que permiten facilidad en la

instrumentacin de la exclusin mutua.
Pag - 32
Tema II.- Procesos.
Captulo. 6.- Semforos.
Exclusin mutua con bloqueo. Semforos.

Problemas clsicos de sincronizacin de procesos.
Bibliografa
Operating Systems Concepts, Peterson and Silberschatz, Pag 326-344

Operating Systems: Design and Implementation, Tanembaum, pag 51-67.
Exclusin mutua con bloqueo. Semforos.
Los algoritmos que hemos tratado hasta aqu se han presentado con espera ocupada, es decir,
cuando un proceso necesita entrar en su seccin crtica y no puede, hace la espera en un lazo
malgastando el tiempo del procesador.
Si consideramos una computadora con dos procesos A de tipo prioritario y B que no lo es. Las
reglas de planificacin establece que siempre A se ejecuta si esta listo. Ahora veamos el problema
debido a que B esta en su seccin critica y se le termina su tiempo sale del procesador, por lo que
A que esta listo para entrar al procesador ingresa y debido a que B, esta en seccin critica A no
puede entrar en la suya, el problema radica debido a las prioridades, B no puede entrar mientras A
no termine, por tanto A nunca terminara, debido a que B se quedo en seccin critica. Por lo tanto
A solamente dar vueltas en un ciclo infinito.
Una alternativa a lo anterior consiste en bloquear el proceso hasta que pueda operar en su seccin
crtica en la misma forma que se hace cuando espera por una E/S u otro evento.
Para programar las esperas no ocupadas se hace uso de operaciones atmicas (indivisibles)
conocidas como primitivas. Uno de los mecanismos ms conocidos son los semforos y las
primitivas P y V (en el libro de Tanembaun, Down y Up). Estas ideas fueron desarrolladas por
Dijkstra.
La operacin down aplicada a un semforo determina si su valor es mayor que 0. En tal caso,
decrementa el valor y simplemente continua. Si el valor es 0, el proceso se desactiva sin terminar
la operacin Down por el momento. Verificar el valor, modificarlo y desactivarse (en su caso) se
ejecutan como una sola accin atmica (es decir indivisible).
Esto se garantiza evitando que otro proceso tenga acceso a este hasta que la operacin haya
terminado o se haya bloqueado.
Pag - 33
Esta atomicidad es indispensable para resolver problemas de sincronizacin y evitar condiciones

de competencia.
La operacin UP incrementa el valor del semforo indicado. Si uno o mas procesos estaban
inactivos en espera de un semforo, sin haber podido terminar una operacin down previa, el
sistema escoge a uno de ellos (quizs al azar) y le permite terminar dicha operacin. As, despus
de un up un semforo con procesos inactivos, el semforo seguir siendo 0, pero habr un
proceso menos esperndolo.
Es necesario considerar dos primitivas de comunicacin de procesos que permite el bloqueo en

lugar de desperdiciar el CPU, en su forma ms sencilla son Sleep y WakeUp. La primera llamada
al sistema, permite que un proceso quede bloqueado hasta que otro lo active a travs de WakeUp,
ambas llamadas al sistema requieren de un parmetro que es el nombre del proceso.
Para estudiar la aplicacin de semforos, realizaremos el estudio del problema del productor-
consumidor.
Problemas clsicos de la sincronizacin de procesos.

El problema del productor-consumidor.
El problema describe la relacin de dos procesos que comparten el mismo buffer, el procesos
productor que coloca elementos en el buffer y el otro el consumidor que los saca.
El problema surge en el momento en el que el productor desea colocar un elemento pero el buffer
esta lleno, en este caso lo deseable es que se desactive hasta que el consumidor saque uno o mas
elementos, la situacin inversa se da en el momento en el que el consumidor trata de sacar
elementos del buffer pero este se encuentra vaco.
El proceso parece sencillo sin embargo da lugar a la presencia de condiciones de competencia,

que pueden ser perjudiciales.
Para determinar el numero de elementos en el buffer necesitaremos de una variable cuenta, si el

buffer puede contener N elementos como mximo, el cdigo del productor debera terminar el
instante en que N=cuenta, caso contrario aadir un elemento e incrementara cuenta.
En el caso del consumidor, este debera detenerse en el instante en que cuenta=0, si no lo es
debera sacar un elemento y decrementar cuenta.
Pag - 34
Cdigo del productor, consumidor.
#define N 100 /* Ranuras en el buffer

#define cuenta=0; /* Elementos en el buffer
Void productor (void)

{
Int elem;
While (True) { /* Se repite indefinidamente
elem=producir_elem(); /* Produce elementos
if (cuenta==N) sleep(); /* Si el buffer esta lleno se desactiva
insertar_elem(elem); /* inserta el elemento en el buffer
cuenta=cuenta+1; /* incrementa cuenta
if (cuenta==1) wakeup (consumidor)/* El buffer estaba vaco??
}
}
Void consumidor (void)

{
Int elem;
While (True) { /* Se repite indefinidamente
if (cuenta==0) sleep(); /* Si el buffer esta vacio se desactiva
elem=sacar_elem(); /* Saca elementos
cuenta=cuenta-1; /* decrementa cuenta
if (cuenta==N-1) wakeup (productor)/* El buffer estaba lleno??
Consumir_elem(elem); /*consume elemento
}
}
En el problema presentado veamos las condiciones de competencia. Puede presentarse la

situacin de que el consumidor lee el valor de cuenta que esta en cero, en ese momento es
llamado el productor, quien coloca un elemento y al ver que cuenta es =1, entonces enva el
correspondiente WakeUp, que se pierde debido a que consumidor aun no estaba dormido, cuando
vuelve a ingresar el consumidor y continua con su cdigo, al ver que cuenta =0, se desactiva,
tarde o temprano el productor llenara el buffer y quedara tambin dormido, por tanto tendremos a
ambos procesos inactivos por siempre.
Una solucin sencilla es la adicin de un bit de espera para de tal forma que en el momento de
enviar el WakeUP se cambie al valor de 1, cuando el proceso productor quiera desactivarse
primero verificara el bit de espera, si este esta en 1 lo pondr en cero, y continuara su ejecucin,
sin embargo esta solucin requerira de una cantidad elevada de bits.
Pag - 35
Resolucin del problema Productor-consumidor empleando semforos
Los semforos resuelven el anterior problema. El procedimiento normal es implementar Up

Down como llamadas al sistema y que el sistema inhabilite de manera temporal todas las
interrupciones.
La solucin se basa en el uso de tres semforos: llenas para contar el numero de ranuras
ocupadas, vacas para el numero de ranuras desocupadas y el ultimo llamado mutex, para
garantizar que el productor o el consumidor no tengan acceso al buffer al mismo tiempo.
#define n 100 /*ranuras en el buffer

typedef int semforo; /* los semforos son int especiales
semaforo mutex=1; /* controla acceso a la regin critica
semaforo vacias=n; /* cuenta ranuras de buffer vacas
semforo llenas=0; /* cuenta ranuras de buffer ocupadas
void productor (void)

{
int elem;
while (true) {
elem= producir_elem();
down(&vacias);
down(&mutex);
insertar_elem(elem);
up(&mutex);
up(&llenas);
}
}
void consumidor(void)
{
int elem;
while (true) {
down(&llenas);
down(&mutex);
elem=sacar_elem();
up(&mutex);
up(&vacias);
consumir_elem(elem);
}
}
Pag - 36
En el ejemplo usamos el semforo mutex para garantizar la exclusin mutua, garantizando que
solo un proceso lea o escriba en el buffer, el otro uso de los semforos es para la sincronizacin,
en este caso llenas y vacas, que cuidan que en productor deje de ejecutarse cuando el buffer este
lleno o el consumidor se detenga cuado el buffer este vaco.
Cuando no existe la necesidad de contar por el semforo es comn recurrir al uso de semforos
simplificados, los llamados mutex (abreviatura de exclusin mutua). Esto como se menciono
solo sirven para administrar la exclusin, mutua respecto a algn recurso o fragmento de cdigo
compartido.
Este semforo Mutex puede estar en uno de dos estados bloqueado o desbloqueado y solo
necesita de un bit para representarlo, a pesar de que en la practica se utilice un entero (0 o 1).
Cuando un subproceso requiere ingresar a su seccin critica, invoca a mutex_lock, si el mutex

esta libre, o sea la seccin critica esta libre, la solicitud procede y el proceso accede en su seccin
critica.
En cambio si el mutex se encuentra ya bloqueado, el proceso invocador se bloqueara hasta que el

proceso que esta en su seccin critica termine esta e invoque al mutex_unlock. Si existen varios
procesos bloqueados esperando por el mutex, se escoge uno de ellos al azar y se le permite
adquirir el bloqueo.
Por su sencillez, es fcil implementar lo mutexes en espacio de usuario, si se cuenta con una
instruccin TSL.
TSL son las siglas de TEST AND SET LOCK, una instruccin hardware, utilizada por ciertos
procesadores para facilitar la creacin de semforos y otras herramientas necesarias para la
programacin concurrente en computadores. TSL es una instruccin mquina que provoca la
lectura del contenido de una palabra de la memoria en un registro, y el almacenamiento de un
valor distinto de cero en dicha palabra de memoria. Al tratarse de una instruccin mquina, el
procesador nos garantiza que la instruccin TSL es realizada sin ningn tipo de interrupcin por
parte de otro proceso, es decir las operaciones de lectura y escritura de la palabra tienen la
garanta de ser indivisibles. Adems si nos encontramos en un sistema multiprocesador, ninguno
de los dems procesadores tendr acceso a la palabra hasta que termine de ejecutarse la
instruccin. El procesador que ejecuta la instruccin TSL cierra el bus de la memoria para
prohibir a los dems el acceso a la memoria hasta el trmino de la instruccin
Pag - 37
Tema II.- Procesos
Captulo 7.- Comunicacin entre procesos.
Comunicacin entre procesos.

Comunicacin directa.
Comunicacin indirecta.
Bibliografa:
Operating System Concepts, Peterson and Silberschats, pginas 344 a la 361.

Operating Systems: Design and Implementation, Tanenbaum pginas 67 a la 79.
Comunicacin entre procesos.
Los procesos que se ejecutan concurrentemente con frecuencia necesitan comunicarse entre si a
los efectos de mantener una adecuada cooperacin. La sincronizacin entre procesos no, es ms,
que un caso particular de esta otra problemtica ms general.
Existen dos formas en que los procesos pueden comunicar: la primera es que por medio de
memoria compartida y la segunda a travs de sistemas de mensajes (intercambio de mensajes).
Mientras que el uso de memoria compartida queda a la accin de los programadores, los sistemas
de intercambio de mensajes son responsabilidad del sistema de operacin y por ello dedicaremos
un rato a este respecto.
La funcin de un sistema de mensajes es el permitir a los procesos comunicarse unos con otros
sin la necesidad de recurrir a memoria compartida (lo cual no quiere decir que no se pueda).
Un sistema de comunicacin entre procesos o sistema de mensajes brinda bsicamente dos

operaciones que se instrumentan como llamadas al sistema:
send - Para enviar un mensaje.
receive - Para indicar que se quiere recibir un mensaje (si el mensaje no existe entonces el
proceso se bloquear).
Si dos procesos desean comunicarse, debern enviarse y recibir mensajes entre ellos. Para esto se
requiere que exista un enlace de comunicacin. La implantacin de este enlace puede ser a travs
de memoria, un bus, lneas de comunicacin entre mquinas, etc.
Un enlace de comunicacin puede ser unidireccional o bidireccional. Se dice que es

unidireccional slo si cada proceso conectado a este puede solamente enviar o recibir, pero no
ambos, y al menos uno de ellos recibe. En otro caso se dice que es bidireccional.
Pag - 38
Uno de los aspectos a considerar en un enlace es lo referente al aporte o no de buffers implcitos

por parte del sistema operativo para colocar los mensajes pertenecientes a un enlace. A esto se
llama capacidad del enlace.
La capacidad de un enlace es la cantidad de mensajes que temporalmente pueden residir en l. Se

instrumenta como una cola de mensajes. Existen tres casos:
. Cero capacidad.- El enlace no puede tener ningn mensaje esperando. El emisor del
mensaje deber esperar hasta que el receptor lo pueda recibir. A esta situacin se le llama
una cita (rendezvous) y se instrumenta bloqueando al emisor.
. Capacidad limitada.- La cola tendr una longitud finita n. Si la cola no est llena y se enva
un mensaje entonces este es colocado en ella (por copia del mensaje o manteniendo un
puntero al mensaje) y el emisor continua la ejecucin sin esperar. Si la cola esta llena, el
emisor ser detenido hasta que haya espacio.
. Capacidad ilimitada.- La cola tiene una longitud infinita. El emisor nunca es detenido.
El envo de mensajes, en cuanto a las propiedades de estos, puede ser de tres tipos:
. Longitud fija.
. Longitud variable.
. Con tipo. Se aplica en la comunicacin directa que se mencionar ms adelante.
Es posible encontrar instrumentaciones de sistemas de mensajes donde nunca el emisor es

detenido. En este caso, si el receptor no ha recibido un mensaje y le envan otro, entonces el
primero se pierde. Esta variante se utiliza cuando en lugar de copiar el mensaje, se enva su
direccin. En este caso los procesos necesitan, ser sincronizados explcitamente para asegurar la
no prdida de mensajes.
Otra variante tambin usada en algunos sistemas operativos consiste en detener al emisor hasta
que se recibe una replica del receptor. Como es de suponer la sincronizacin est garantizada
implcitamente.
Los sistemas de mensajes son de gran utilidad en los ambientes distribuidos, donde los procesos
operan en diferentes lugares. En tales medios la probabilidad de ocurrencia de un error durante la
comunicacin es mucho mayor que en una mquina simple.
Algunas de las situaciones que se pueden presentar en un sistema de mensaje y que requieren de
una manipulacin adecuada son:
. El emisor o el receptor termin.
. Se perdi el mensaje.
. Se da el mensaje.
Pag - 39
Tema de investigacin.
En la bibliografa sugerida y otras fuentes, existen soluciones que se pueden adoptar, sobre la
problemtica planteada.
Comunicacin directa.
En la comunicacin directa cada proceso que desea enviar o recibir un mensaje debe
explcitamente indicar el nombre del receptor o emisor de la comunicacin.
En este esquema las primitivas send y receive se definen de la forma siguiente:
send(P ,mensaje) Enviar un mensaje al proceso P.
receive(Q , &mensaje) Recibir un mensaje de Q.
Un enlace de comunicacin con este esquema tiene las propiedades siguientes:
. Automticamente se establece un enlace entre cada par de procesos que desean

comunicar. El proceso slo necesita conocer la identidad del otro.
. Un enlace est asociado solamente con dos procesos.
. Entre cada par de procesos que estn en comunicacin existe exactamente un enlace.
. El enlace es bidireccional.
El esquema antes indicado tiene una total simetra en cuanto al direccionamiento, es decir, tanto
el emisor como el receptor tienen que dar la identificacin del otro para poder comunicar.
Una variante consiste en utilizar asimetra en el direccionamiento. Slo el emisor nombra al

receptor, este no necesita referirse al emisor. En este caso las primitivas de comunicacin tienen
la forma
send(P, mensaje) Enviar un mensaje a P.
receive(&id, &mensaje) Recibe un mensaje. En id se obtiene el identificador del

proceso que envi el mensaje.
Comunicacin indirecta.-
La desventaja de la comunicacin directa consiste en que al cambiar el nombre de un proceso se

hace necesario buscar todas las referencias al viejo nombre para cambiarlas al actual, incluso en
los restantes procesos.
En la comunicacin indirecta los mensajes se envan y reciben de buzones y no directamente de

los procesos. Un buzn es un lugar donde se pueden colocar y recoger los mensajes
Pag - 40
(generalmente un rea de memoria).
Cada buzn tiene una identificacin nica para distinguirlo. En este esquema, un proceso puede
comunicarse con otros por un nmero cualquiera de buzones.
En este caso las primitivas de comunicacin adoptan la forma
send(A, mensaje) Enviar un mensaje al buzn A.
receive(B, &mensaje) Recibir un mensaje del buzn B.
En este esquema un enlace de comunicacin tiene las siguientes propiedades:
. Se establece un enlace entre dos procesos solamente si ellos tienen un buzn compartido.
. Un enlace puede ser asociado con ms de dos procesos.
. Entre cada par de procesos que comunican puede haber una cantidad cualquiera de
enlaces, cada uno correspondiendo a un buzn.
. El enlace puede ser unidireccional o bidireccional.
En este contexto, el sistema operativo brinda los mecanismos para permitir a los procesos las
siguientes operaciones:
. Crear un buzn.
. Enviar y recibir mensajes de un buzn.
. Destruir un buzn.
Un buzn puede ser propiedad de un proceso o del sistema operativo. Si pertenece a un proceso
(ya que el lo defini o se lo ataron), entonces slo l podr recibir mensajes a travs de ste. En
este caso, los usuarios slo podrn mandar mensajes a este buzn.
Hay varias formas de designar el dueo y los usuarios de un determinado buzn. Algunas de las
vas para sealar el dueo son:
. El buzn fue definido o creado por el proceso.
. Recibi de otro proceso la propiedad y el privilegio de recibir mensajes a travs de dicho

buzn.
. Lo hered del padre cuando ste lo cre.
Pag - 41
Tema II. Procesos.
Conf. 8.- Planificacin de Procesos.
- Planificacin de procesos.
- Algoritmos de planificacin.
- Administracin de procesos en sistemas operativos actuales.
Bibliografia:
- Operating system concepts, Peterson y Silberschatz, pp 103-137.

- Operating Systems: Design and implementation, Tenembaum, pp 80-87
Planificacin de procesos
La planificacin del uso de los recursos del sistema de cmputo constituye una de las funciones
fundamentales de los sistemas operativos.
El procesador central constituye el recurso primario de toda computadora y por ello su

planificacin es esencial. La parte del sistema de operacin que realiza esta accin se identifica
como planificador de procesos (Process Scheduler) y a los posibles procedimientos que este
podra utilizar se identifican como algoritmos de planificacin.
En los primeros tiempos de los sistemas operativos la planificacin de los procesos era muy
sencilla, pues simplemente cuando un trabajo culminaba se entregaba el CPU al siguiente en el
batch (estuviera en tarjetas o bandas magnticas).
Con la existencia hoy de diversos sistemas de operacin que operan en ambientes tales como:
Multiusuarios en tiempo compartido.

Multiusuarios en tiempo compartido, pero con procesamiento en lote como tarea de
fondo (Background).
Simples usuarios ejecutando varios programas a la vez, un proceso en superficie
(Foreground) y los restantes de fondo (Background). Estos ltimos denominados
multitarea.
La elaboracin de algoritmos de planificacin resulta ser ms compleja para estos nuevos

escenarios.
La planificacin de procesos es la base de la multiprogramacin. Cuando ms de un proceso est

listo para ejecutar, el sistema de operacin debe decidir a cual se le entregar el procesador.
Pag - 42
Como es de suponer, el planificador de procesos acta sobre los procesos que estn listos. Todos
los procesos que estn en este estado se mantienen en una estructura llamada la cola de listos.
Generalmente esta lista es enlazada.
La cabeza de la lista antes indicada contendr dos punteros dirigidos al primer y ltimo proceso
en la lista. Normalmente los elementos que se colocan en la cola son las ltimas entradas de la
tabla de procesos (PCB).
PCB# i PCB# j
Cabeza de la cola . .
. .
. .
Cola de
Registros Registros
listos
. .
. .
. .
La cola de listos pudiera tambin instrumentarse como un rbol, una pila, etc.
En realidad en un sistema de operacin existen varios planificadores. De ellos hay dos

relacionados con el procesador central.
El planificador de trabajos (job scheduler o long-term scheduler ) determina que trabajos, de

todos los que estn preparados en un dispositivo, son admitidos en la memoria con vistas al
procesamiento. Es decir, selecciona los trabajos que se incorporarn a la cola de listos desde el
exterior.
El planificador del procesador (short-term o CPU scheduler) selecciona de los que estn listos
en memoria al que se le entrega el CPU.
Una primera diferencia entre estos planificadores es la frecuencia de ejecucin de cada uno. El
planificador del procesador se ejecutar con una alta frecuencia (cada vez que un proceso solicita
entrada - salida, cuando un proceso se bloquea, al terminar un proceso y al ocurrir una
interrupcin). Debido a esta caracterstica, este debe ser rpido.
El planificador de trabajos se ejecuta con menos frecuencia y por ello su cdigo puede ser ms
largo con el objetivo de decidir cual es el trabajo que ms conviene entrar a la lista de listos.
El planificador de trabajos es responsable por el grado de multiprogramacin, o sea, el nmero de

procesos en memoria. Si este es fijo, entonces ser invocado cada vez que un proceso termina.
Pag - 43
Tambin es responsable por garantizar un adecuado balance en memoria de trabajos que hagan un
alto uso del CPU con otros que realicen una gran cantidad de entrada / salida.
En algunos sistemas operativos, debido a su naturaleza, no existe el planificador de trabajo, o si

est presente su accin es mnima, tal es el caso en los ambientes de tiempo compartido.
En determinados sistemas de operacin se utiliza la tcnica de intercambio de trabajos

(swapping) que consiste en remover de la memoria procesos que estn listos y trasladarlos de
nuevo hacia un medio de almacenamiento, para con posterioridad introducirlos en el equipo y
continuar su procesamiento a partir de donde se encontraba ejecutando. Esta accin se realiza con
vistas a mejorar el balance de los trabajos que se estn ejecutando en un momento dado o debido
a que los requerimientos de memoria existentes sobrepasan las disponibilidades.
El programa encargado de realizar los intercambios antes indicados se les nombra como
planificador de nivel medio (medium term scheduler). Este elemento est presente en los
sistemas de memoria virtual y en instrumentaciones de tiempo compartido.
Planificador Planificador
de nivel medio Procesos parcialmente
de nivel medio
ejecutados
Planificador de
procesos
Cola de listos CPU
Planificador de
trabajos
Otro componente involucrado en la actividad de planificacin del procesador es el despachador

(dispatcher). Este mdulo es el que realmente le da el control de la CPU al proceso que fue
seleccionado por el planificador. Esta funcin incluye cargar los registros, cambiar a modo
usuario y saltar a la direccin donde se debe iniciar la ejecucin.
Un aspecto interesante es la planificacin de procesos en presencia de mltiples procesadores

(multiprocesamiento). En este caso se pueden dar dos situaciones: los procesadores son diferentes
(heterogneos) o iguales (homogneos) .
En el primer caso existir una cola de listos por cada procesador y cada una de ellas funcionar
independiente de la otra.
Si los procesadores son homogneos tambin podr haber una cola independiente para cada uno,
pero esto podra implicar que un procesador est parado por falta de procesos mientras que otro
puede estar muy ocupado.
Una variante a lo antes indicado podra ser el uso de una cola comn. En este caso podran existir
dos alternativas en la operacin. La primera consistira en que cada procesador accedera a la cola
Pag - 44
comn para seleccionar un proceso a ejecutar, aunque en este caso se requerira garantizar la
exclusin mutua en el uso del recurso compartido (la lista). La segunda alternativa consiste en
designar un procesador como planificador para los otros, estableciendo una estructura de
maestro / esclavo (master / slave).
Algoritmos de planificacin.
Existen numerosos algoritmos para la planificacin del procesador. Cada uno de ellos tiene
diferentes caractersticas y pueden favorecer un tipo de proceso sobre otros. Es ms, el privilegiar
a unos siempre implica ir en detrimento de los otros.
Existen varios criterios para comparar los diferentes algoritmos. En dependencia de cuales se
utilicen se puede llegar a diferentes conclusiones acerca de cual es el mejor.
Los criterios que bsicamente se utilizan son:
Eficiencia o utilizacin del CPU: Mantener el CPU ocupado tanto como sea posible, con un
objetivo terico del 100% (en la realidad puede ir de un 40 a 90 %).
Throughput: (rendimiento) Ser el nmero de trabajos que se completan por unidad de

tiempo. La meta es maximizar este indicador y para ello se puede dar mayor prioridad a los
trabajos ms cortos.
Turnaround: (tiempo de retorno) Es el tiempo que transcurre desde que un trabajo se

somete al sistema hasta que este termina, es la suma de los tiempos esperando para entrar en
memoria, esperando en la cola de listo, ejecutando en el CPU y haciendo E/S. Como es de
suponer, la meta es minimizar este indicador. Normalmente se usa el turnaround promedio.
Tiempo de espera: Es la cantidad de tiempo que un trabajo gasta esperando en la cola de

listos. Este es una medida ms ilustrativa del efecto del algoritmo de planificacin. Se indica
que debe haber equidad o imparcialidad, es decir, que cada proceso debe tener su parte
razonable en el uso del CPU.
Tiempo de respuesta: En los sistemas interactivos el turnaround puede no ser un buen

criterio para medir la respuesta a los usuarios. En este caso se acostumbra a medir el tiempo
que media entre la solicitud de una accin y el comienzo de la respuesta (no incluye el tiempo
que demora la respuesta en s). Lgicamente, el objetivo es minimizar este indicador.
No resulta fcil notar que todos estos indicadores no apuntan en el mismo sentido e inclusive
algunos pueden ser contradictorios. El arte consiste en dar prioridad a aquellos ms convenientes
y necesarios en un medio ambiente, sin provocar que los otros se deterioren en exceso.
Las tcnicas o algoritmos de planificacin se dividen en dos grupos: planificacin con derecho de
prioridad (preemptive scheduling) y planificacin sin derechos de prioridad (non preemptive
scheduling).
Pag - 45
El primer grupo est referido a tcnicas que le quitan el CPU a los procesos una vez que ha
transcurrido un tiempo de ejecucin, es decir, se le retira an cuando estara en condiciones de
continuar. El segundo grupo tiene una base cooperativa, es decir, el proceso entrega el procesador
cuando termina o se bloquea.
Las tcnicas con derecho de prioridad son una fuente de condiciones de concurso o competencia
que los procesos debern tener en cuenta. Por otro lado, las sin derecho de prioridad pueden
implicar que un proceso se aduee del procesador por un tiempo indefinido en perjuicio de los
restantes.
El algoritmo de planificacin ms simple es Primero en llegar, primero en ser atendido FCFS

(First come - First served) o sea, la atencin se brinda de acuerdo al orden de llegada a la cola
de listos. Esta tcnica es por naturaleza sin derecho de prioridad.
La instrumentacin del FCFS es muy simple y solo se requiere que la cola de listos se opere
realmente como una cola. Cada proceso que llega a ella se coloca al final y siempre se le asigna
el CPU al proceso que est en la cabeza, eliminndose de la lista.
Los resultados que se obtienen con este algoritmo son pobres debido a que no tiene en cuenta las
caractersticas de los procesos.
Otra tcnica de planificacin es el Trabajo mas corto primero SJF (Shortest job first) o sea,
la atencin se brinda al que requiere menos tiempo de trabajo en cada instante. Este algoritmo
puede ser con o sin derecho de prioridad.
Este algoritmo es probablemente ptimo y resulta apropiado en los sistemas de lotes (batch),
usndose fundamentalmente en la planificacin de trabajos. Se requiere conocer en adelanto el
tiempo de ejecucin. Es ptimo desde el punto de vista del turnaround promedio, el throughput y
el tiempo de espera.
No resulta fcil hacer uso de esta tcnica en la planificacin del procesador (short - term
scheduling) y para utilizarla se requiere hacer continuamente un pronstico del tiempo de CPU
que requerir cada proceso en cada intervalo de ejecucin. Este algoritmo es ptimo si todos los
trabajos estn disponibles simultneamente. Pero puede provocar inanicin en los trabajos largos
(starvation).
Otra variante de planificacin es el uso de prioridades. En este caso cada trabajo o proceso tiene
asociada una prioridad y el CPU se asigna al que tiene el mayor valor. Este algoritmo puede ser
con o sin derecho de prioridad.
Una primera dificultad con este algoritmo consiste en que un proceso de alta prioridad y con
mucho tiempo de uso del CPU se puede apropiar de l indefinidamente. Una solucin podra ser
que la prioridad vaya disminuyendo con el tiempo.
Pag - 46
Una segunda dificultad se presenta cuando existe un gran flujo de trabajos de alta prioridad, esto
provocar que los de baja prioridad padecern de inanicin (starvation). La solucin a este
problema se conoce como envejecimiento (aging) y consiste en gradualmente ir incrementando la
prioridad de los procesos que han estado esperando por mucho tiempo.
La asignacin de prioridades a los procesos puede ser externa (esttica) o interna (dinmica). En
el primer caso se usan criterios de costos o importancia del trabajo para definir la prioridad. En el
segundo caso, el sistema operativo utiliza determinadas magnitudes (lmites de tiempo,
requerimientos de memoria, razn entre el tiempo de entrada/salida y el tiempo de uso del CPU,
etc.) para calcular la prioridad.
La tcnica utilizada en los sistemas de tiempo compartido, es el algoritmo RR (Round - Robin).

(En la bibliografa Tanembaum se denomina torneo). En este caso, la cola de listos es tratada
como una cola circular (lo que no implica que tenga que ser instrumentada en esta forma) y el
planificador gira alrededor de la cola, asignando el CPU a cada proceso.
El proceso que recibe el CPU lo puede utilizar durante un quantum o ranura de tiempo,
transcurrido este lo pierde hasta que le toca de nuevo. Por supuesto, si por alguna razn se tiene
que bloquear o termina, tambin pierde el procesador. Es evidente que en este algoritmo existe
derecho de prioridad.
Un aspecto clave en la aplicacin de esta tcnica consiste en la determinacin de la longitud del

quantum o ranura de tiempo. Para esto se debe tener en cuenta que cada vez que el quantum se
termina (avisado por la interrupcin de un reloj programable) se procede a un cambio de proceso,
conocido como cambio de contexto (context switch), lo que implica el uso de un tiempo del CPU
a este fin (overhead time).
Si la longitud del quantum es muy pequea entonces existir ineficiencia en el uso del CPU ya
que una parte considerable del tiempo se gastar en el cambio de contexto. El uso de un quantum
muy grande deriva en una respuesta pobre al trabajo interactivo.
Una forma interesante de organizar la planificacin de procesos consiste en particionar la cola de

listos en varias colas y asociar a cada una de ellas a una clase de procesos. Cada clase tiene sus
propios requerimientos y por ello se puede tener un algoritmo de planificacin diferente para
cada cola.
Los procesos son asignados a una cola en base a ciertas propiedades, tales como requerimientos
de memoria o tipo de trabajo.
En este contexto se estar en presencia de un algoritmo de planificacin de colas mltiples. En

estos casos, resulta comn tener que cada cola tiene una prioridad diferente y que se aplica una
poltica de derecho de prioridad (preemptive scheduling).
Como ejemplo de lo antes indicado se tiene el clsico agrupamiento de los trabajos en aquellos
que se ejecutan en superficie (foreground) y los que se procesan en el fondo (background). Los
procesos en superficie tienen prioridad sobre los de fondo.
Pag - 47
Para que a un proceso se le pueda asignar el procesador se requiere que todas las colas de mayor
prioridad estn vacas. Si un proceso est ejecutando y en una cola de mayor prioridad arriba un
proceso, entonces se le quita al que estaba y se le asigna al nuevo.
La dificultad fundamental de esta tcnica consiste en que las colas con baja prioridad pueden
padecer de inanicin (starvation).
Otra posibilidad en las colas mltiples consiste en asignar a cada una parte del tiempo de uso del
CPU, siendo este distribuido entre los procesos que se encuentran en cada una.
La planificacin de colas mltiples tiene una generalizacin que consiste en retroalimentacin.

En este caso se realizan movimientos de los procesos entre las diferentes colas.
Los procesos con la mas alta prioridad se les da un quantum, si lo consumen se pasan a la cola
siguiente, que tiene menos prioridad, donde recibirn el equivalente a dos quantums. Si lo
consumen se repite el proceso y as sucesivamente. La idea es que los trabajos que tienen mucho
uso del CPU van perdiendo prioridad, pero se les aumenta la magnitud de tiempo con la
esperanza de que terminen.
El algoritmo antes explicado tiene como objetivo brindar la mayor prioridad a los trabajos
interactivos y a los que realizan muchas E/S. Similarmente, un proceso que lleva esperando
mucho tiempo en una cola de baja prioridad podra ser movido a una de mayor prioridad.
En el diseo de un planificador lo primero que se hace es definir los criterios acerca de las metas
que se desean lograr en su uso y con posterioridad se trata de medir en que magnitud estas se
logran con los diferentes algoritmos. Para realizar estas mediciones se pueden usar varias
tcnicas:
Evaluacin analtica por medio de modelos determinsticos o de colas (estadsticos).

Simulacin
Instrumentndolos en el sistema operativo y probndolos durante un tiempo.
Administracin de procesos en SO actuales
Windows
Como se conoce del desarrollo de Microsoft. Hasta la versin 3.1 eran realmente ambientes de
trabajo con interfaces de usuarios grficas. An cuando administraba todos los recursos, se
soportaba en MS-DOS y utilizaba su sistema de ficheros. Con el surgimiento de Windows NT se
puede hablar propiamente de un sistema operativo.
Es un sistema con multiprogramacin, la que aqu recibe el nombre de multitarea. Hasta la

versin 3.1 no exista el modo multiusuario, en el Windows NT aparece alguna posibilidad en
este sentido. Est preparado para trabajar en un ambiente de multiprocesamiento.
Pag - 48
Cada tarea puede crear subtareas que se ejecutan en paralelo y reciben el nombre de hilos
(threads) y por ello se habla del procesamiento multihilos (multithreads).
La planificacin de procesos hasta la versin 95 (de 16 bits) tiene un carcter cooperativo, es

decir, una tarea o subtarea tomaba el CPU y otros recursos y los liberaba voluntariamente
mediante su finalizacin o por bloqueo.
En el Windows NT y los de 32 bits (95 y 98) existe un algoritmo de prioridades con asignacin
de quantum de tiempo a los procesos y por ello se trabaja con derecho de prioridad (preemption
scheduling).
En Windows 2000 no se tiene un subproceso planificador central, En vez de eso, cuando un

subproceso ya no puede seguir ejecutndose, ingresa en modo kernel y ejecuta el mismo el
planificador para ver a cual subproceso cambiar.
Su planificador funciona en base a prioridades estableciendo 32 de estas cada una de las cuales
apunta a su propia lista de sub-procesos listos.
UNIX - LINUX
La primera versin fue desarrollada en 1969 por Ken Thompson en los laboratorios Bell para una
mquina PDP-7 . Con posterioridad fueron apareciendo numerosas versiones para otros equipos y
se crearon otros grupos que desarrollaron sus propias ideas.
Hoy en da se encuentra disponible en una gran cantidad de hardware diferente desde

supercomputadoras (main frames) hasta las microcomputadoras. Este sistema fue y contina
siendo parte importante de la teora y prctica de los sistemas operativos.
El UNIX es un sistema interactivo de tiempo compartido y basado en la multiprogramacin. Todo

proceso puede crear procesos hijos, siendo ambos idnticos (copias idnticas en memoria, iguales
valores de los registros, etc.). El padre y el hijo pueden continuar ejecutando despus de la
instruccin FORK que cre al segundo. El proceso hijo hereda los ficheros abiertos por el padre y
las modificaciones que ocurran sern visibles a ambos.
Otra posibilidad consiste en que un proceso modifique su imagen mediante la llamada a

ejecucin de un programa.
La planificacin de procesos en UNIX est concebida para beneficiar a los trabajos ms

interactivos. Los procesos tienen prioridades y estas se calculan dinmicamente cada segundo
sobre la base del tiempo de uso del CPU consumido. A medida que el valor es mayor son menos
prioritarios.
De lo anterior se deriva el hecho de que en la medida que un proceso acumula tiempo de CPU
consumido va perdiendo prioridad. En algunas instrumentaciones se emplea la tcnica de
envejecimiento para evitar inanicin (starvation) en los procesos con baja prioridad.
Pag - 49
La prioridad de un proceso listo puede ser positiva o negativa. Esta ltima la reciben despus de
haber salido de la condicin de bloqueado a consecuencia de una llamada al sistema.
Los procesos listos se mantienen en una estructura consistente en colas de varios niveles. Cada
cola se corresponde con una prioridad.
Cuando un proceso recibe el CPU se le asigna un pequeo quantum de tiempo (aprox. 100 ms) y
culminar ste al menos que finalice u ocurra un bloqueo. Cuando se termina el tiempo, se coloca
al final de la cola de su prioridad.
Se usa el intercambio de trabajos (swapping) y por ello existe un planificador de nivel medio
(medium-term). Por este motivo, en la tabla de procesos se almacenan solamente las
informaciones que tienen sentido tanto si el proceso est en memoria o no. Aquellas que solo
tienen uso cuando el proceso est en memoria se mantienen en una tabla llamada estructura del
usuario que tambin es intercambiada.
La planificacin de Linux es una de las pocas reas que usa un algoritmo distinto al de UNIX.
Inicialmente observemos que los subprocesos de LINUX son subprocesos en kernel, as que la
planificacin se basa en subprocesos, al igual que en Windows 2000.
Para efectos de planificacin Linux distingue tres clases de subprocesos.
. FIFO en tiempo real.- estos tienen la prioridad mas alta y solo pueden ser expropiados
por otros FIFO.
. Turno circular en tiempo real. Esto iguales que los anteriores con la diferencia de que
peden ser expropiados por el reloj.
. Tiempo compartido: Ninguna de las dos anteriores clases son realmente en tiempo real,
debido a que no es posible establecer plazos y menos aun garanta, por lo que son
solamente clases que tienen mayor prioridad que las estndar de tiempo compartido.
Cada subproceso tienen una prioridad por defecto 20 pudiendo tomar valores de -20 a 20
formando 40 prioridades, brindando mayor calidad de servicios a aquellos que tengan prioridad
ms alta.
Pag - 50
Tema III. Entrada Salida.
Captulo. #9.- Entrada Salida.
Dispositivos de Entrada/Salida. Controladores.

Acceso Directo a Memoria.
Software de Entrada/Salida.
Manejadores de interrupcin (Handlers).
Manejadores de dispositivos (Device driver).
Software independiente del dispositivo.
Software para el uso de los usuarios.
Bibliografia
Operating Systems: Design and Implementation, Tanenbaum, pag. 110 a la 122.
Dispositivos de Entrada/Salida. Controladores.
Una de las funciones principales de todo sistema operativo es la administracin de los recursos y
dentro de estos los dispositivos de entrada/salida ocupan un lugar importante.
El sistema de operacin enviar rdenes a los dispositivos, captar las interrupciones enviadas
por el hardware para indicar el final de una operacin y manejar los errores. Tambin debe
brindar una interfase con el dispositivo que sea simple y fcil de usar.
En todo sistema operativo la parte correspondiente a entrada/salida representa una funcin

significativa.
Los dispositivos de entrada/salida se dividen en forma gruesa en los de bloques y los de

caracteres.
Los dispositivos de bloques almacenan la informacin en bloques (normalmente de longitud fija)

y cada uno de ellos tiene una direccin de forma tal que la informacin puede ser accesada
aleatoriamente (se puede leer o escribir un bloque independientemente de los otros). Ejemplos de
ellos son los discos y tambores magnticos.
Los dispositivos de caracteres brindan o reciben una cadena de caracteres, sin que ellos tengan
estructura de bloques. No son direccionables y no se puede realizar ninguna operacin de
bsqueda en ellos. Ejemplos de ellos seran las terminales (o teclados), interfaces de redes,
ratones, etc.
Un dispositivo que no clasifica en la divisin anterior son los relojes, ellos simplemente causan
interrupciones a intervalos bien definidos.
Pag - 51
Los dispositivos de entrada/salida constan de dos partes generalmente separadas: la componente

mecnica y la componente electrnica. La parte mecnica es el dispositivo en si.
La componente electrnica recibe el nombre de controlador (controler) o adaptador (adapter) del

dispositivo y tiene la funcin de controlar la parte mecnica. En las minicomputadoras y en las
microcomputadoras frecuentemente toman la forma de una tarjeta de circuito impreso que se
inserta en el equipo.
Los sistemas operativos se relacionan con la componente electrnica del dispositivo y no

directamente con el dispositivo en si.
En las minicomputadoras y microcomputadoras la comunicacin entre el CPU y los

controladores se lleva acabo a travs de una trayectoria (bus) simple. En las grandes
computadoras (main frames) se usan trayectorias mltiples y procesadores especializados en
entrada/salida (I/O Channels).
Para comprender bien la funcin de un controlador veamos el caso del disco. Cuando se realiza
una lectura, el controlador recibe del dispositivo un flujo de bits en serie. Lo primero es el
prembulo, despus vendrn los bits que componen el sector y finalmente una suma de chequeo
(checksum) que permite detectar si hubo error (una de las variantes es el conocido CRC). El
prembulo se escribi cuando el disco recibi formato y especifica la cara, la pista (o cilindro), el
nmero del sector y el tamao de ste.
La funcin del controlador consiste en ensamblar, bit a bit, el flujo recibido y convertido en un
bloque que se crea en un buffer interno de ste. Despus se verifica la suma de chequeo. Si no
hay error, entonces el sector puede ser copiado a la memoria.
Cada controlador dispone de algunos registros para comunicarse con la CPU. En algunas
computadoras estos registros forman parte del espacio de memoria normal (PDP-II). En otras
existe un rea de memoria especial con este fin, donde a cada una de las especializaciones se le
conoce como un puerto de E/S.
El sistema operativo realiza las operaciones de entrada/salida escribiendo comandos e

informacin en los registros. Cuando el comando ha sido establecido, la CPU deja al controlador
solo y puede dedicarse a otra actividad.
Cuando la accin ha sido realizada, el controlador emite una interrupcin para que el sistema
operativo tome el control del CPU. Este chequear los registros de estado del dispositivo para
verificar si la operacin se efectu correctamente. En caso de una lectura correcta se copiar la
informacin de los registros a la memoria.
Acceso directo a Memoria.
Algunos controladores, especialmente aquellos que se utilizan en los dispositivos de bloques,

utilizan esta variante de trabajo que se conoce como DMA (Direct Memory Acces).
Pag - 52
De acuerdo con lo antes explicado, cuando un dispositivo de entrada produce una interrupcin y
como consecuencia el dispositivo toma el control del CPU, este deber tomar de los registros la
informacin leda y trasladarla a memoria. El traspaso se tendr que realizar byte a byte y por ello
se requiere un tiempo considerable del CPU en esta tarea de bajo nivel. En caso de una escritura,
la situacin es la misma pero el traslado se realiza antes de la escritura y es de memoria a los
registros.
El DMA libera a la CPU de realizar esta actividad. En este caso cuando se solicita una
transferencia se especifica la direccin de memoria y la cantidad de bytes a transferir. El
controlador, una vez que ha conformado el bloque en su buffer interno y lo ha chequeado contra
la suma de control, lo transfiere a la posicin de memoria ms indicada, (el caso de escritura lo
tom de dicha posicin). El sistema de operacin no necesita realizar transferencia alguna.
Otro aspecto interesante en lo referido a las transferencias de discos es la llamada intercalacin

(interleaving). Esta se deriva del hecho de que cuando el controlador (o el sistema operativo si no
hay DMA) est transfiriendo un sector hacia otro desde memoria, otro est pasando por debajo de
la cabeza de lectura/escritura.
Si hiciera falta realizar transferencias en dos sectores consecutivos, entonces la mayora de los
adaptadores se ven obligados a esperar una nueva rotacin del disco para operar con el segundo
sector.
La solucin a esta dificultad consiste en numerar los sectores del disco en forma intercalada, es
decir con saltos de 1, 2 ms sectores.
7 0 7 0 5 0
1 3 4 2 3
6
5 2 6 1 7 6
4 3 5 4 1
2
Normal Intercalacin Simple Intercalacin Doble
Software de Entrada/Salida
El software de entrada/salida se organiza en diferentes capas, donde las ms bajas tratan de

ocultar las peculiaridades de los dispositivos a las ms altas y estas a su vez tienen el objetivo de
presentar a los usuarios un fcil y claro aspecto.
Un aspecto importante del software de entrada/salida es que cumpla con las metas en este mbito:
independencia de los dispositivos, nominacin uniforme, tratamiento de errores, imagen
sincrnica y garanta de operacin.
Pag - 53
La independencia de los dispositivos est referida a que todo programa que realice
entrada/salida pueda hacer uso de un equipo u otro sin tener en cuenta sus caractersticas y sin
necesidad de ser modificados y compilados.
En MS-DOS resulta normal escribir:
sort <input> output
donde input y output puede ser un fichero en disco, una impresora, etc.
En el UNIX existe una total independencia de los dispositivos.
La nominacin uniforme est referida a que los nombres de los dispositivos y ficheros utilicen
un mismo convenio y que ste no dependa de los equipos en ninguna forma.
En MS-DOS no se cumple esta condicin, cada torre de disco tiene una identificacin particular.
En el UNIX se garantiza debido a la existencia de un solo sistema de ficheros que cubre a todos
los dispositivos.
El tratamiento de los errores de entrada/salida debe ser manejado tan cerca del hardware
como sea posible. Cuando el controlador detecta un error debe tratar de resolverlo por si mismo.
Si no es posible, entonces le toca al manejador del dispositivo enfrentar la situacin
(probablemente repitiendo la operacin). Slo cuando no se ha logrado la recuperacin es que se
informa a las capas ms altas del sistema.
La mayora de las operaciones de entrada/salida se realizan en forma asincrnica, es decir el

CPU inicia la transferencia despus para realizar otras tareas hasta que ocurre la interrupcin. Los
programas de los usuarios son ms fciles de elaborar si se realizan en forma sincrnica, es decir
despus de un comando de lectura; se espera hasta que la informacin est disponible en el
buffer. Le corresponde al sistema operativo hacer que las operaciones asincrnicas parezcan
sincrnicas a los programas de los usuarios.
Algunos dispositivos tienen la caracterstica de ser compartidos (tales como los discos) mientras
que otros son dedicados (tales como las impresoras). En general no existen dificultades en el
funcionamiento de un dispositivo compartido, pero la existencia de dispositivos dedicados
introduce una variedad de problemas. El sistema operativo debe operar con los dispositivos de
forma tal que se eviten las dificultades.
Para satisfacer estas metas, el software de entrada/salida se estructura en 4 capas:
Manejadores de interrupcin (Handlers).

Manejadores de dispositivos (Device Handlers).
Pag - 54
Manejadores de interrupcin. (Handlers).
Como ya se ha indicado, cuando un controlador finaliza una transferencia de informacin emite

una interrupcin. Por hardware se deposita en la pila la direccin donde deber continuar y
posiblemente uno o ms registros.
A continuacin se toma el vector de interrupcin asociado con el dispositivo, que precisamente

contiene la direccin del manejador de interrupcin. Al colocarse, por parte del hardware, esta
direccin en los registros, dicho procedimiento comienza a ejecutarse automticamente.
La funcin fundamental del manejador de interrupcin es avisar al manejador del dispositivo que
la transferencia fue ejecutada o al menos intentada (en caso de error). El manejador del
dispositivo estar esperando que tal aviso ocurra.
En un sistema monoprogramado el manejador del dispositivo har una espera ocupada. En caso
de existir multiprogramacin la espera ser bloqueada, ya sea el manejador un simple
procedimiento del rea del sistema (estructura monoltica) o un proceso usuario.
La forma de activar al manejador del dispositivo tiene diferentes formas, entre ellas: un indicador
en una bandera, una operacin V en un semforo, el envo de un mensaje, etc.
En un esquema multiprogramado con derecho de prioridad, el manejador de interrupcin incluir

la llamada al planificador de procesos.
Un resumen, con carcter general de las operaciones del manejador de interrupcin sern:
Salvar los registros del proceso que fue interrumpido en la tabla de procesos o el stack.
Eliminar del stack la informacin colocada por el hardware y fijar el Stack del manejador del
dispositivo.
Activar el manejador del dispositivo.
Llamar al planificador de procesos.
Poner en ejecucin al proceso seleccionado o restaurar al que estaba.
En realidad algunos manejadores de interrupcin tienen algunas complejidades adicionales, como

ocurre con los encargados de las terminales (teclados).
Manejadores de dispositivos (Device Drivers)
Todo el cdigo de entrada/salida que se relaciona con las caractersticas del dispositivo se incluye
en este software. Normalmente cada manejador de dispositivo atiende un tipo de elemento o
dispositivos diferentes, pero similar en su uso.
El manejador de dispositivo enva las rdenes a los registros del controlador y chequea si los
comandos fueron ejecutados en forma apropiada. En el caso del disco, por ejemplo, debe
encargarse de encender el motor, mover el brazo, considerar el intercalamiento, esperar el tiempo
de posicionamiento, etc.
Pag - 55
En trminos generales, el manipulador del dispositivo recibe solicitudes abstractas provenientes

de las capas superiores y las convierte en rdenes concretas a los controladores.
Si al recibirse una solicitud resultara que otra est en proceso, es decir, el manejador del
dispositivo est esperando la interrupcin de una transferencia anterior, entonces dicha solicitud
es colocada en una cola de pendientes, que sern atendidas tan pronto como sea posible. Por
supuesto que si la situacin no es la antes indicada, la solicitud ser atendida de inmediato.
De lo antes planteado, tendremos entonces que cada dispositivo dispondr de una cola de
procesos que esperan para ser atendidos, de forma similar a como ocurre con el CPU. Lo anterior
sugiere que deber existir un planificador por cada cola, con mayor o menor medida de
complejidad.
De lo antes sealado se tendr que el esquema de las colas en un sistema operativo tendr la
forma:
Planificador de Planificador de
trabajos procesos
Cola de CPU
listos
(En monoprogramacin (No se incluyen las colas
no existen las colas, ni derivadas del uso de
tampoco en el mecanismo primitivas de bloqueo)
de cita.)
E/S Cola de
E/S
.
.
.
E/S Cola de
E/S
Las colas de entrada/salida se organizan a partir de una estructura llamada Tabla de estado de los
dispositivos.
En cada entrada de esta tabla se encuentra informaciones acerca del dispositivo (su tipo, sus
direcciones, su estado, etc.) y los punteros para formar las colas. En las colas se colocarn
directamente los PCB de los procesos u otro tipo de estructura que contengan la informacin
referente a una solicitud (operacin, direccin, cantidad, etc.).
Como ya se indic con anterioridad, generalmente el manejador de dispositivo, una vez solicitada
una operacin al controlador, tiene que esperar a que esta se realice. Sin embargo existen
situaciones en que esto no es necesario. Tambin hay manejadores, como el caso de los discos
RAM, que nunca realizan esa accin.
Pag - 56
Un resumen con carcter general, de las operaciones del manejador de un dispositivo sern:
Decidir las operaciones que debe realizar el controlador y en que orden.

Escribir las rdenes e informaciones en los registros del dispositivo.
Si es necesario, esperar a que el controlador realice su trabajo (ocupada o por bloqueo).
Realizar el chequeo de error correspondiente (por supuesto, si hay, tratar de recuperarlo,
normalmente por repeticin de la operacin).
Si hubo error y persiste reportarlo a las capas (estratos) superiores.
Si no hubo error y hay que enviar informacin a las capas superiores, pasarlas juntas con
informacin de estado.
Si hay otra solicitud pendiente repetir las operaciones para la seleccionada. Si no, terminar la
ejecucin o bloquearse a esperar.
A pesar de que en general la entrada/salida es dependiente del dispositivo, una gran parte de las
operaciones a realizar no tienen esta caracterstica. Ellas son las que constituyen esta capa o
estrato.
La frontera exacta entre los manejadores de dispositivos y el software independiente del

dispositivo depende del sistema operativo. Algunas funciones que podran estar en este nivel a
veces se ubican en el manejador en aras de eficiencia u otra razn.
La funcin bsica de esta capa es realizar las funciones de entrada/salida que son comunes a
todos los dispositivos y brindar una interfaz uniforme al software del nivel de usuario.
Un resumen con carcter general de las funciones de este software sern:
Brindar una interface comn y uniforme para el uso de todos los dispositivos.
Convertir el nombre simblico del dispositivo en la direccin del manejador.
Prevenir el uso de un dispositivo por un usuario no autorizado.
Brindar un tamao de bloque uniforme (aunque los dispositivos fsicamente usen diferentes).
Instrumentar uso de buffers para la entrada/salida de forma tal que el usuario pueda leer la
informacin en las unidades que sea su deseo.
Asignar el espacio en los dispositivos para el almacenamiento de la informacin.
Asignar y liberar dispositivos dedicados.
Tratar los errores y reportarlos.
Las funciones antes indicadas son generalmente brindadas por el sistema o servidor de ficheros.
Aun cuando el software de entrada/salida est dentro del sistema de operacin, una pequea parte
de este se encuentra en bibliotecas y son enlazados con los programas de los usuarios. Los
Pag - 57
procedimientos de esta parte consisten de los cdigos que realizan las llamadas al sistema para la
entrada/salida. Es evidente que formarn parte del sistema de entrada/salida como un todo.
Estos procedimientos tendrn diferentes grados de complejidad. Algunos simplemente ponen

parmetros en los lugares debidos y realizan llamadas al sistema, en cambio otros tienen que dar
determinados formatos a la entrada o la salida.
Un ejemplo de lo antes indicado es la funcin printf del C que toma una cadena del formato y
algunas variables teniendo que construir una cadena ASCII y despus llamar a WRITE para
lograr la salida.
No todo el software a este nivel est constituido por procedimientos de bibliotecas. Aqu se
incluyen tambin los programas que instrumentan la tcnica conocida como SPOOLING.
Resulta frecuente encontrar en los sistemas multiprogramados un proceso que se encarga de

realizar las impresiones para todos los dems. A este proceso se le conoce como un demonio de
impresin. Los procesos escriben en un directorio especial los nombres de los ficheros a imprimir
y el demonio (nico autorizado a usar el printer) ir imprimiendo los ficheros.
Otro ejemplo de lo antes indicado sera la existencia de un demonio de RED para la transmisin
de ficheros en este ambiente.
La creacin de estos SPOOLING evita determinadas dificultades en el uso de algunos
dispositivos.
Como resumen de todo lo tratado se muestra un esquema con las diferentes capas del sistema de
entrada/salida y las comunicaciones entre ellas.
Capa o estrato
Solicitud de Software para el uso de los usuarios

Respuesta a la
entrada/salida entrada/salida
Software independiente del dispositivo
Manejadores de dispositivos
Manejadores de interrupcin
Hardware
Pag - 58
Tema III. Entrada y Salida.
Captulo #10.- Algoritmos de Planificacin.
Ejemplos de manejadores de dispositivos.

Reloj.
Discos RAM.
Discos. Caractersticas fsicas.
Algoritmos de planificacin.
Bibliografa:
Operating System Concepts, Peterson y Silberchats, pag 257 a la 268.

Operating systems: Design and implementation, Tanenbaum, pag. 135 a la 186.
Ejemplos de manejadores de dispositivos.
Como ya se ha indicado, la mayora de los controladores de dispositivos inician una

entrada/salida y despus se ponen a esperar un mensaje (propiamente o algo parecido) indicativo
de que la transferencia se ejecut o se intent sin resultados (en caso de error).
En los sistemas monoprogramados la espera ser ocupada, mientras que en los

multiprogramados ser bloqueado.
Puede ocurrir que algn manejador no necesite realizar la espera antes indicada (por ejemplo los
referentes a los discos RAM o al uso de memoria expandida). Tambin puede ocurrir que algunos
tengan que esperar para unas funciones y para otras no.
A continuacin se presentarn algunos ejemplos de manejadores de dispositivos. Se asumir que

estos son procesos independientes y que la comunicacin entre procesos se realiza a travs de
citas. Esta organizacin es ms modular, pero menos eficiente que llamadas directas entre
procedimientos.
Un esquema general para cualquier gestor, bajo las consideraciones antes indicadas, podra ser la
siguiente:
El proceso pide un mensaje conteniendo una solicitud (si no la hay se bloquea en espera).
Cuando llega el mensaje se llama a un procedimiento para realizar la accin solicitada.
Si la accin implica la operacin del hardware, entonces se solicita un mensaje de ste (lo
enviar el manejador de interrupcin).
Se enva un mensaje al proceso que solicit la operacin (especificar el resultado de la
accin).
Pag - 59
De acuerdo con lo anterior se tendra:
message mensaje;
io_task();
{
int r, quien;
initialize(); /* solo se hace una vez */
while (true) {
receive (any, &mensaje);
quien = mensaje.m_proceso;
switch (mensaje.m_tipo){
case READ : r = do_read();breack;
case WRITE : r = do_write();breack;
case OTHER : r = do_other();breack;
default : r = ERROR;
}
mensaje.m_tipo = TASK_REPLY;
mensaje.m:estado = r;
send(quien, &mensaje);
}
}
Cada uno de los procedimientos do_XXX realiza una de las operaciones de que es capaz el
gestor. En ellos aparecera la solicitud de mensajes al manipulador de interrupcin, si es necesario
esperar.
En la replica del mensaje, el campo m_estado contendr el nmero de bytes realmente o un

cdigo de error (digamos negativo).
Reloj
El reloj es un elemento esencial en todo sistema operativo ya que permite mantener la hora y
sobre todo poder controlar determinados eventos en el tiempo, por ejemplo el uso del quantum de
tiempo en sistema de tiempo compartido.
El reloj tiene una determinada instrumentacin fsica, pero lo ms importante es que permite una
interrupcin del CPU cada cierto intervalo fijado. El intervalo entre una y otra interrupcin puede
ser fijada por el software.
Lo antes indicado es lo que hace el reloj, todo lo dems que implique operaciones con el tiempo
tiene que ser hecho por el manipulador del reloj.
Las tareas desarrolladas por el manejador del reloj varan de un sistema operativo a otro, pero
usualmente habr:
Pag - 60
Conocer la hora.
Fijar la hora.
Atencin al pulso del reloj.
Resulta frecuente tambin que los procesos puedan fijar el recibir una alarma dentro de un
intervalo de tiempo (un mensaje para esperar un tiempo).
De lo anterior, nuestra tarea de entrada/salida quedara como:
clock_task();
{
int codigo;
init_clock();
while (true) {
receive(any, &mensaje);
quien = mensaje.m_proceso;
codigo= mensaje.m_tipo;
switch (codigo) {
case SET_ALARM : do_set_alarm(&mensaje);break;
case GET_TIME : do_get_time();break;
case SET_TIME : do_set_time(&mensaje);break;
case clock_tick : do_clocktick();
default : panic(mensaje equivocado);
}
mensaje.m_tipo = ok;
if (codigo!=clock_tick) send(quien, &mensaje);
}
}
Dentro de estos procedimientos resulta interesante el do_clocktick() que se ejecuta cada vez que
se produce una interrupcin del reloj (un tick) y por ello veremos una instrumentacin
aproximada.
do_clocktick;
{
PCB *PP;
int t;
t = lost_ticks;
realtime+= t+1;
lost_tick-= t;
if (next_alarm <= realtime) {
buscar_proceso(&PP);
cause_sig(PP, SIGALRM);
find_next_alarm(&next_alarm);
}
accounting();
Pag - 61
sched_ticks--;
if (sched_ticks==0) {
planificador();
sched_ticks = SCHED_RATE;
}
}
A parte de las funciones implicadas en el algoritmo pudieran existir otras, ente ellas la conocida
como perro de guardia (watchdog). Esta es igual que una alarma, pero en lugar de enviarse un
mensaje, se ejecuta un procedimiento que se estableci al fijar la solicitud. Una variante de esto
existe en el MS-DOS por medio de la interrupcin 1CH.
Discos RAM.
La idea de los discos RAM es bastante simple. Consiste en un rea de memoria reasignada con la
idea de simular un dispositivo de bloque, normalmente un disco. Este dispositivo tiene la ventaja
de un acceso instantneo y por ello resulta conveniente para el almacenamiento de programas y
datos de uso frecuente.
Las operaciones involucradas son la lectura y escritura de bloques.
El disco RAM se divide en n bloques y cada uno ellos tiene la misma longitud que la utilizada en
los discos reales.
Cuando el manejador del dispositivo recibe la indicacin para leer o escribir un bloque, este
simplemente calcula donde se encuentra y procede a realizar la lectura o la escritura.
Un manejador de disco RAM puede soportar varias reas de memoria usadas como diferentes
discos, cada una identificada por un nmero de dispositivo diferente.
Cada disco RAM dispondr de dos lmites, uno para indicar la posicin de inicio y el otro su
longitud.
Una visin aproximada del manejador de dispositivo correspondiente sera:
mem_task();
{
int r, quien, codigo;
ram_origen = ORIGEN;
ram_limite = LIMITE;
while (true) {
receive(any, &mensaje);
quien = mensaje.proceso;
codigo = mensaje.m_tipo;
switch (codigo) {
Pag - 62
case DISK_READ : r = do_mem(&mensaje); break;

case DISK_WRITE : r = do_mem(&mensaje); break;
case DI_SETUP : r = do_setup(&mensaje); break;
default : r = ERROR;
}
mensaje.m_tipo = TASK_REPLY;
mensaje.REP_STATUS = r;
send(quien, &mensaje);
}
}
Un aproximado de la funcin do_mem sera:
int do_mem(M_ptr)
message *m_ptr;
{
int count;
if (m_ptr->POSICION < 0) return (ERROR);

mem_phys = ram_origen-origen+m_ptr->posicion;
if (mem_phys>ram_limite) return(0);
count = m_ptr->count;
if (mem_phys + count > ram_limite) count = ram_limite-mem_phys;
if (mem_ptr->m_tipo=DISK_READ) copy(mem_phys, user_phys, count);
else copy(user.phys, mem_phys, count);
return(count);
}
Discos. Caractersticas fsicas.
Los manejadores antes vistos en forma simplificada no resultan de una gran complejidad, en
cambio lo referente a otros dispositivos si tienen numerosos aspectos que atender, en especial los
de discos.
Debido a lo antes indicado se requera un tiempo considerable hacer un anlisis de ellos y por
este motivo se dejarn como tema de lectura adicional de la bibliografa. Tanembaun pginas 479
a la 524.
En la clase anterior se mostr que en un ambiente de multiprogramacin existan para cada

dispositivo una cola de solicitudes de entrada/salida pendientes y que esto permita pensar en la
existencia de un planificador que decidiera cul era la ms conveniente a atender en cada
instante.
El uso de dispositivos de bloques, en especial de discos, constituye hoy en da un elemento

obligado de todo sistema de cmputo y por ello la eficiencia que se logre en su utilizacin
repercute significativamente en el comportamiento general.
Pag - 63
Debido a lo antes indicado, resulta frecuente la existencia de un planificador para este tipo de
dispositivo. Antes de entrar a considerar los diferentes algoritmos de planificacin posibles a ser
utilizados se debe hacer una breve revisin de las caractersticas fsicas de estos dispositivos.
Como es conocido, en los discos magnticos la informacin se almacena por ambos lados y por
ello una primera direccin para localizar una informacin ser la superficie o cara.
La informacin se almacena en anillos concntricos con el llamado agujero de giro. A cada uno
de estos anillos se le llama pista y constituye la segunda coordenada de la direccin.
Dado que es posible tener varios discos unos sobre otros, entonces al conjunto de pistas que
quedan en la misma posicin se les llama cilindro (no porta ninguna nueva direccin, es la misma
de las pistas involucradas).
Por ltimo, el espacio direccionable en una pista se divide en bloques o sectores. La

identificacin de cada uno de ellos aporta el tercer elemento de la direccin.
Normalmente existe una cabeza de lectura/escritura por cada superficie magnetizada, la que
permite la transferencia de informacin con cualquiera de los sectores existentes en ella. En este
caso la cabeza de lectura/escritura se deber mover hacia adentro y hacia afuera con vistas a
ubicarse en cualquier pista.
La descripcin anterior corresponde al esquema de un dispositivo de bloque con cabeza mvil

(tpicamente los discos). Si existen varias superficies, entonces todas las cabezas se movern al
unsono, pues estarn montadas en un brazo comn.
La velocidad de acceso a un bloque o sector est compuesta de tres partes. Primero se requiere
mover la cabeza de lectura/escritura a la pista apropiada, a esto se llama la bsqueda y a la
demora correspondiente tiempo de bsqueda. A continuacin se debe esperar a que el sector
deseado pase por debajo de la cabeza, a esta demora se le llama tiempo de estado latente. Por
ultimo se realizar es traspaso de la informacin entre el disco y la memoria, la demora se
llamar tiempo de transferencia.
El tiempo total ser la suma del tiempo de bsqueda (Seek Time),el tiempo de estado latente
(Latency Time) y el tiempo de transferencia (Transfer Time).
De los tres factores antes indicados, el nico a considerar desde el punto de vista de optimizar el
tiempo promedio de servicio a las solicitudes es el tiempo de bsqueda y por ello los algoritmos
de planificacin tienen como objetivo disminuir esta componente (bastante significativa).
Antes de estudiar los diferentes algoritmos de planificacin existentes es conveniente sealar que
algunos casos en lugar de usarse la cola de solicitudes antes indicada, se hace uso de otra
estructura de datos.
Pag - 64
La estructura consiste en tener un arreglo de apuntadores por cada disco, dicho arreglo est
indizado por el nmero de la pista. Cada entrada del arreglo es un puntero a todas las solicitudes
pendientes en la pista correspondiente.
Sea cual sea la estructura, cada solicitud contiene las siguientes informaciones:
Tipo de operacin (entrada o salida).

Direccin en el disco (cilindro, superficie y sector).
Direccin en memoria.
Cantidad de memoria a transferir.
Algoritmos de planificacin
El algoritmo ms simple de planificacin en disco es el FCFS (First Come First Served). Este
consiste en atender las solicitudes en el orden de llegada. Es un algoritmo equitativo, pero no es
el ms eficiente.
Suponga que en un momento dado se tienen solicitudes de transferencia a las siguientes pistas: 1,
36, 16, 34, 9, 12 y que el cabezal se encontraba en la pista 11. Entonces la cantidad de pistas
recorridas en las bsquedas ser: 10, 35, 20, 18, 25, 3 para un total de 111.
Este algoritmo tiende a ir en forma consecutiva de un extremo a otro del disco.
Un algoritmo muy eficiente es el SSF (Shortest_Seek_First) o SSTF (Shortest_Seek_Time_First).

Este algoritmo consiste en atender la solicitud cuya pista est ms cerca de la actual posicin de
la cabeza de lectura/escritura.
En nuestro ejemplo se tendra entonces la siguiente secuencia de atencin: 12, 9, 16, 1, 34, 36.
Entonces la cantidad de pistas recorridas en las bsquedas sern: 1, 3, 17, 15, 33, 2 para un total
de 61.
Este algoritmo tiene la dificultad de crear inanicin (starvation) para las solicitudes ms alejadas
de la posicin inicial del brazo. Para comprender esta situacin slo hay que pensar en que existe
un flujo continuo de nuevas solicitudes, muchas de ellas cercanas a la posicin actual.
La problemtica de la planificacin de los accesos a un disco es similar a la de un elevador

instalado en un edificio. Se usa este algoritmo?.
El reconocimiento del carcter dinmico de la cola lleva al algoritmo conocido como SCAN o del
elevador. En este, las cabezas de lectura/escritura comienzan en una de las pistas extremas (la
inicial o la ltima) y se mueven hacia la otra, brindando servicio a todas las solicitudes que
existan. Al llegar al otro extremo, invierte el sentido del movimiento y se repite toda la operacin.
Para la instrumentacin de este algoritmo se requiere tener un bit que indique el sentido del
movimiento, hacia arriba (up) o hacia abajo (down).
Pag - 65
Una variacin del SCAN se conoce como C-SCAN (scan circular) y siempre presta servicio en el
mismo sentido, es decir se mueve el cabezal de un extremo al otro y despus se regresa al inicio
para repetir la operacin.
El C-SCAN parte de la lgica de que las nuevas solicitudes en el extremo inicial deben ser las
que ms tiempo deben llevar esperando y adems de que en esta rea es donde debe haber una
mayor concentracin de solicitudes pendientes.
En la descripcin de ambos algoritmos, SCAN y C-SCAN, se plante que las cabezas van desde
un extremo (digamos pista cero) hasta el otro (digamos pista n). En la prctica estos algoritmos
no son instrumentados en esta forma.
Comnmente la cabeza es movida en un sentido hasta la ltima solicitud en dicho sentido. Tan
pronto como no hay otra, se invierte el sentido del movimiento o se reinicia en la primera de las
solicitudes. A estos algoritmos se conocen como LOOK y C-LOOK.
Si aplicamos el algoritmos LOOK a nuestro ejemplo se tendra entonces la siguiente secuencia de

atencin: 12, 16, 34, 36, 9, 1. Entonces la cantidad de pistas recorridas en las bsquedas sern: 1,
4, 18, 2, 27, 8 para un total de 60.
Todas las variantes del algoritmo del elevador combinan eficiencia y equidad.
Pag - 66
Tema IV.- Abrazo Fatal
Captulo. 11.- Abrazo Fatal
Recursos. Modelado del abrazo fatal.

Grafo de asignacin de recursos.
Prevenir del abrazo fatal.
Evitar. Algoritmo del banquero.
Detectar y recuperar.
Bibliografa:
- Operating System Concepts, Peterson y Silberschatz, pag. 271 a la 301.

- Operating Systems: Design and Implementation, Tanembaum , pag. 122 a la 135.
Recursos. Modelado del abrazo fatal.
En varias ocasiones se ha visto que en un sistema de operacin puede ocurrir que un proceso est
en espera de un evento que debe ser provocado por otro, proceso que est en similar situacin con
respecto a l, esta es la situacin que se presenta en el problema del productor/consumidor si se
intercambian las llamadas a las primitivas P.
A la situacin antes indicada se le conoce como abrazo fatal (deadlock) y constituye uno de los
aspectos a tener en cuenta en el diseo e instrumentacin de un sistema operativo.
Pueden existir diversas situaciones que conduzcan al abrazo fatal, pero este se presenta
fundamentalmente en el uso de los recursos del sistema de cmputo.
El concepto de recurso no slo se refiere a los dispositivos de entrada/salida, sino que tambin
incluye ficheros, tablas, etc. No obstante, los dispositivos de entrada/salida son recursos
importantes y fuente de muchas dificultades.
Los recursos se pueden usar en forma compartida o excluyente, en el primer caso varios procesos
pueden hacer uso del recurso simultneamente y en el segundo caso no.
Hay recursos que por sus propias caractersticas pueden tener un uso compartido (por ejemplo,
los discos) mientras que otros son indiscutiblemente de uso exclusivo (por ejemplo, una
impresora).
Existen recursos que en dependencia de su uso podrn considerarse de un tipo o de otro. Por
ejemplo, un fichero puede ser abierto en lectura por varios procesos a la vez, pero la situacin no
es la misma si alguno lo abre en escritura.
Pag - 67
El uso de los recursos compartidos no conduce a abrazo fatal, la dificultad se presenta con los de
uso exclusivo.
En condiciones de operacin normal para que un proceso utilice un recurso deber ocurrir la
siguiente secuencia:
. Solicitud
. Uso
. Liberacin
Los recursos se dividen, de acuerdo a sus caractersticas, en clases o tipos. Cada clase puede
estar conformada por una sola instancia o por varias. Todas las instancias de una clase tienen que
ser iguales.
Cuando un proceso solicita un recurso se le asigna una instancia de la clase si la hay disponible.
En caso contrario debe esperar hasta que otro proceso la libere. La solicitud y liberacin de los
recursos se realiza a travs de llamadas al sistema.
Un ejemplo de abrazo fatal podra ser el siguiente: Un sistema de cmputo dispone de una
impresora y un ploteador digital. En un momento dado un proceso tiene asignada la impresora y
otro el ploteador. Si ahora ambos solicitan el otro recurso resulta evidente que se presenta un
bloqueo mutuo.
Otro ejemplo podra consistir en dos procesos que tengan abiertos con escritura dos ficheros. A
continuacin los procesos tratan de abrir los ficheros en forma intercambiada.
Un tercer ejemplo interesante sera: La tabla de procesos tiene capacidad para n procesos y en un
momento dado todas las entradas estn ocupadas. En esa situacin los n procesos tratan de crear
procesos hijos.
Una definicin formal del concepto de abrazo fatal sera: Un conjunto de procesos est en estado
de abrazo fatal cuando cada uno de ellos est esperando por un evento que slo puede ser causado
por otro proceso del mismo conjunto.
Resulta evidente que el abrazo fatal resulta indeseable, ya que los procesos involucrados nunca
terminarn su ejecucin. Por otro lado, estn reteniendo recursos que otros necesitan para
comenzar.
Antes de comenzar el anlisis de los mtodos existentes para el tratamiento del abrazo fatal
resulta conveniente revisar las condiciones necesarias y suficientes para que se presente.
El abrazo fatal ocurre si y solo si se presentan simultneamente las siguientes cuatro condiciones:
. Exclusin mutua.- Los recursos involucrados se utilizan en forma no compartida, es decir slo
un proceso puede estar usando cada recurso en cada instante. Si est en uso y otro lo solicita,
entonces deber esperar a que se libere.
Pag - 68
. Retencin y espera (hold and wait).- Deben existir procesos que teniendo al menos un
recurso asignado con anterioridad, estn
esperando por otros asignados a otros procesos.
. No priorizacin.- Ningn proceso tiene la prioridad de quitar un recurso asignado a otro, es

decir, los recursos son liberados voluntariamente despus de completarse la tarea.
. Espera circular.- Deben existir n procesos P1, P2, Pn tal que P1 espera por un recurso
asignado a P2 . P2 est en igual situacin, con respecto a P 3 y as
sucesivamente y por ltimo Pn est esperando por un recurso que tiene
asignado P1.
Grafo de asignacin de recursos.
Para modelar la asignacin de recursos y describir los abrazos fatales se hace uso de un grafo
dirigido que se identifica como grafo de asignacin de recursos.
Los nodos o vrtices del grafo estn formados por dos subconjuntos : P = { P 1, P2, .. Pn } que
constituyen todos los procesos en el sistema y R = { r 1 , r2 , .. , rm } formado por los tipos de
recursos.
Los arcos siempre unen nodos de tipos diferentes. Un arco del proceso P i al recurso r j significa
que el proceso pi esta solicitando el recurso r j y est esperando por l. Un arco del recurso r j al
proceso Pi significa que este tiene asignado el recurso.
Para realizar la representacin grfica se acostumbra, utilizar un crculo para los procesos y un
cuadrado para los recursos.
R1
P r
P1 P2
r
P
R3 R2
Asignado Solicitado
y
Esperando P3
deadlock
El grafo antes mostrado supone que de los recursos r 1, r2, y r3 slo existe una instancia. En este
caso, la ocurrencia de un ciclo en el grafo es condicin necesaria y suficiente para la existencia de
un abrazo fatal.
Pag - 69
Cuando los recursos tienen varias instancias entonces para la representacin se coloca un punto
dentro del cuadrado por cada una de ellas y las reas de asignacin parten de los puntos.
r1
P1 P2
r2
P3
En este caso, la presencia de un ciclo en el grafo no necesariamente implica la existencia de un

abrazo fatal. Aqu la aparicin de un ciclo es una condicin necesaria pero no suficiente. Por
supuesto, en cualquier caso, la ausencia de un ciclo es garanta de no encontrarse en un estado de
abrazo fatal.
Las estrategias que se han seguido para el trabajo con los abrazos fatales son:
. Ignorar.
. Prevenir.
. Evitar.
. Detectar y recuperar.
El primer caso no significa ignorar por ignorar, sino que tiene su basamento en el hecho de que
la posibilidad de ocurrencia del abrazo fatal no implica necesariamente que ocurra. Puede pasar
tiempo y no ocurrir. Algunos piensan que es mejor no tenerlo en cuenta que complicar el sistema
operativo y restarle efectividad (esta es la aproximacin del UNIX, al menos de sus versiones
originales).
Prevenir el abrazo fatal.
Para prevenir el abrazo fatal es necesario asegurar que al menos una de las condiciones
necesarias no ocurra, por lo que se requiere analizar cada una para ver las posibilidades.
En general no es posible evitar el abrazo fatal negando la condicin de exclusin mutua. Muchos
recursos son intrinsicamentes no compartibles.
Para negar la condicin de retencin y espera se pueden seguir dos protocolos. El primero
consiste en que cada proceso solicite todos los recursos antes de comenzar la ejecucin y que
Pag - 70
sta no puede proceder hasta que todo haya sido asignado, incluyendo temas de cintas
magnticas, printer, etc.
Esta solucin tiene dos dificultades: La primera consiste en que no siempre los procesos utilizan
todos los recursos que necesitan. La segunda es mas breve, es que esta podra ser ineficiente
pues un proceso tendra que solicitar y recibir un recurso que liberar despus de un largo
tiempo de procesamiento (por ejemplo una impresora).
El segundo protocolo slo permite que el proceso solo puede solicitar recursos cuando no tiene
ninguno. Dicho de otra forma mas clara, para que un proceso pueda solicitar recursos
adicionales deber liberar todos los que tiene asignados.
Resulta evidente que esta alternativa tiene para aplicabilidad pues resultar frecuente que un
proceso necesite al mismo tiempo ms de un recurso.
Para negar la no priorizacin implica el permitir que un proceso pueda directa o indirectamente
quitar un recurso a otro.
Una primera instrumentacin de esta alternativa consiste en que si un proceso solicita un recurso
que no se le puede asignar y por ello debe esperar, entonces implcitamente se le retiran todos
los recursos que ya tena asignados. Lgicamente, entonces se le pondr que espera por los que
tena y el que solicit.
Una segunda instrumentacin no quita los recursos al proceso que hizo la solicitud, sino que
busca entre los restantes que estn esperando debido a otras solicitudes y si alguno tiene lo
reclamado se lo quitan. Si no aparece solucin, entonces quedar en espera y slo perder los
recursos que tenga asignados si otro proceso los solicita.
La dificultad de ambas soluciones consiste en que un proceso slo podr ser restaurado cuando
reciba el recurso nuevo que provoc la espera y los que perdi durante sta.
Estas alternativas se aplican con recursos cuyos estados pueden ser fcilmente salvados y
restaurados posteriormente, tales como los registros del CPU y la memoria.
Por ltimo queda la espera o encadenamiento circular. Para evitar que esta condicin se cumpla
se asocia con cada tipo de recurso un nmero nico, lo que permite establecer un ordenamiento
entre ellos.
A partir de lo anterior, el protocolo a usar consiste en establecer que un proceso slo podr
esperar por recursos en orden creciente de numeracin y adems si requiere varias instancias de
un mismo tipo, las deber reclamar en una sola solicitud.
Como consecuencia de lo anterior se deriva que si un proceso deber esperar por un recurso con
un nmero de orden determinado, entonces deber liberar previamente todos los ya asignados
que tengan asociado un nmero mayor que el deseado.
Pag - 71
Como ejemplo se puede suponer que la impresora tiene asociado el nmero 2 y el ploteador el 5
y se tiene el grafo de asignacin de recursos que se muestra a continuacin:
A B
2 5
Entonces el proceso A puede solicitar el ploteador, pero B tiene que liberarlo para poder esperar
por la Impresora.
Evitar el abrazo fatal
Algoritmo del banquero.
Los mtodos de prevencin del abrazo fatal tienden a un efecto secundario consistente en una
baja utilizacin de los dispositivos y un reducido throughput.
Otra alternativa para enfrentar el abrazo fatal consiste en evitar. Esta tendencia requiere
informacin adicional acerca de cmo los recursos van a ser solicitados con vistas a realizar las
asignaciones en forma cuidadosa y as evitar crear las condiciones propicias para un abrazo fatal.
En estos algoritmos se requiere que el sistema operativo, ante cada solicitud, considere los
recursos disponibles, los recursos asignados a cada proceso y las futuras solicitudes y
liberaciones de cada proceso. Con todos estos elementos decide si la solicitud puede ser
satisfecha o si debe esperar para evitar un futuro abrazo fatal.
Existen varios algoritmos con este enfoque y ellos difieren en la cantidad y tipo de informacin
que se requiere.
Se define como estado a la lista de procesos, la lista de recursos ya asignados, la lista de los
recursos que cada proceso an necesita y la lista de los que quedan disponibles (el total de las
necesidades es la suma de los ya asignados y los an faltantes).
La asignacin de recursos a un proceso provocar la transicin de un estado a otro.
Se define como un estado seguro aquel en el cual se puede garantizar una secuencia segura de
terminacin de los procesos. Es decir con los recursos disponibles que quedan se garantiza que
un primer proceso podr terminar. Despus con los disponibles y las que libere el que termin se
asegura la culminacin de otro y as sucesivamente. Un estado que no cumpla con lo antes
indicado se dice que no es seguro.
Pag - 72
Los algoritmos de evitar el abrazo fatal son ejecutados en cada solicitud de un recurso y analizan
si el estado a que se llega como resultado de la asignacin ser seguro o no. Si es seguro se
realiza la asignacin, si no el proceso deber esperar.
En el libro de texto aparece un algoritmo eficiente para el caso de que cada recurso tenga
solamente una instancia. Est basado en el uso del grafo de asignacin de recursos.
Un mtodo de carcter general que tiene gran uso es el conocido algoritmo del banquero. Su
nombre se deriva de que podra ser utilizado en el sistema bancario.
El mtodo requiere que cada proceso, al incorporarse al sistema, declare la cantidad mxima de
recursos de cada tipo que necesitar. Por supuesto, se asume que se conocen las cantidades de
cada tipo de recurso de que se disponen en el sistema de cmputo.
Para mostrar la operatoria consideremos la existencia de un solo tipo de recurso y supongamos

que su estado inicial es el siguiente:
Procesos Asignados Necesita Mximo

P1 0 6 6
P2 0 5 5
P3 0 4 4
P4 0 7 7
Disponibles: 10
Supongamos que en un momento dado se llega al siguiente estado:
Procesos Asignados Necesita Mximo

P1 1 5 6
P2 1 4 5
P3 2 2 4
P4 4 3 7
Disponibles: 2
Si ahora P1 , P2 o P4 solicita al menos una unidad de recurso y si asigna se llegara a un estado no

seguro. A P3 se le puede hacer asignaciones pues podra terminar y a continuacin ocurrira lo
mismo con P2 , P4 y por ltimo P1.
Por supuesto que al considerar la existencia de varias clases de dispositivos el algoritmo resulta
ms complejo y no tan fcil de verificar. Para ver un ejemplo y el algoritmo propiamente
remitirse de la bibliografa al libro de Peterson.
Pag - 73
Detectar y recuperar.
Otra lnea de accin en el tratamiento del abrazo fatal consiste en dejar que ocurra. En ese caso,
el sistema invoca peridicamente un algoritmo para detectar si ha ocurrido y en ese caso se trata
de lograr la recuperacin.
Al efecto de lo antes indicado, el sistema de operacin mantiene informacin acerca de las

asignaciones de recursos realizadas y de las solicitudes realizadas. Una alternativa es mantener el
grafo de asignacin de recursos.
La llamada al algoritmo de chequeo puede realizarse cada vez que se solicita un recurso, lo que
puede ser muy costoso en tiempo del cpu, o en momentos arbitrarios.
Cuando un algoritmo de deteccin determina que existe un abrazo fatal entonces se debe pasar a
la recuperacin de ste.
Para la recuperacin existen dos tendencias: La primera opcin consiste simplemente en cancelar
uno o ms de los procesos (y as romper la lista circular). La segunda opcin implica quitar a los
procesos bloqueados algunos recursos.
En el caso de la primera opcin se puede decidir el eliminar todos los procesos participantes del
abrazo fatal o simplemente irlos cancelando uno a uno hasta que la dificultad desaparezca.
En la bibliografa adicional Peterson, se puede realizar una ampliacin con dos algoritmos para
la deteccin del abrazo fatal, uno de ellos es muy parecido al del banquero.
Pag - 74
Tema V. Administracin de Memoria.
Captulo. 12.- Particiones fijas y variables.
Aspectos introductorios.
Uso de la memoria en monoprogramacin.
Proteccin y relocalizacin.
Intercambio de trabajos. Solapamiento.
Multiprogramacin con particiones fijas. Fragmentacin interna.
Multiprogramacin con particiones variables. Fragmentacin externa.
Bibliografa:
Operating System Concepts, Peterson, Silberschatz, pag 143-171.
Operating System: Design and Implementation, Tenenbaum, pag 191-206.
Aspectos Introductorios.
La memoria es uno de los recursos ms importantes de la computadora y por ello debe ser
asignada y utilizada en forma cuidadosa.
La parte del sistema operativo que se encarga de la asignacin de este recurso se nombra
administrador de memoria.
Como es conocido, la memoria est compuesta por un arreglo de bytes o palabras, donde cada
uno de ellos consta de una direccin.
Existen diferentes esquemas para la administracin de memoria y ellos dependen en gran medida
de las posibilidades que brinde el hardware.
La forma ms simple de administracin de memoria es que no haya. Los programas son cargados
completos a la memoria y utilizan todos los recursos del sistema de cmputo. Fue el mtodo
utilizado hasta aproximadamente 1960.
Uso de la memoria en monoprogramacin.
El esquema siguiente est referido al uso de la memoria en los sistemas monoprogramados.
Este esquema consiste en dividir la memoria en dos partes, una para el programa del usuario y la
otra para la parte residente del sistema operativo.
Generalmente la parte residente del sistema operativo se almacena en la parte baja de la memoria
y el programa usuario en la parte alta.
Pag - 75
Programa
usuario
Sistema de
operacin
Esta estructura fue la utilizada en las primeras microcomputadoras y de ah que los sistemas
operativos CP/M y MS-DOS quedaron condicionados a ella.
Proteccin y relocalizacin.
El hecho de residir dos programas en memoria simultneamente introduce de inmediato dos

aspectos a tener en cuenta: la proteccin y la relocalizacin.
La proteccin se lograba a travs de un registro lmite tal y como ya fue explicado con
anterioridad.
La existencia de ms de un programa en memoria implica que no siempre puedan ser cargados o

ubicados a partir de la misma direccin de memoria.
Cuando un programa es ensamblado o compilado todos los nombres de variables y direcciones

simblicas son convertidas a direcciones de memoria. Esta conversin puede generar direcciones
absolutas o relativas.
Si las direcciones generadas son absolutas, entonces el programa tendra que cargarse siempre en
la misma posicin de memoria. Este esquema es poco conveniente y no se utiliza en la
actualidad.
Cuando se generan direcciones relativas se asume que el programa comenzar a partir de la

direccin cero de la memoria y todas las referencias sern relativas a esta posicin.
En el momento de cargarse el programa en memoria se decide a partir de que posicin se ubicar

y todos los direccionamientos son modificados agregndoles dicho valor a los efectos de
convertirlos en absolutos. El programa encargado de introducir los restantes en memoria y
realizar las modificaciones pertinentes se llama cargador relocalizante.
La relocalizacin antes indicada se conoce como esttica ya que se ejecuta en el momento de la

carga.
Otra alternativa de relocalizacin requiere la ayuda del hardware mediante un registro llamado
base o de relocalizacin. En este caso, el programa es colocado en cualquier lugar de la memoria
Pag - 76
sin modificarlo, la direccin inicial se coloca en el registro. Ahora cada vez que se hace un
direccionamiento se suma la direccin contenida en la instruccin con el valor en el registro (esto
lo hace el hardware) y de esta forma se genera la direccin fsica.
A la relocalizacin antes indicada se le conoce como dinmica. Ntese que con este esquema se
puede, en cualquier momento, mover un programa de una posicin de memoria a otra.
Lgicamente, cada vez que el programa le brinde al sistema operativo una direccin, este la
deber relocalizar antes de utilizarla.
Intercambio de trabajos. Solapamiento.
An con monoprogramacin es posible instrumentar un sistema operativo de tiempo compartido

y por ende multiusuario. A este fin se hace uso de otra tcnica conocida como intercambio de
trabajos (swapping).
La tcnica consiste en tener los trabajos almacenados en un medio de almacenamiento y uno slo
en memoria ejecutndose. Cuando este finaliza, se va a bloquear o se le acab su tiempo,
entonces su imagen en memoria es trasladada al dispositivo y se carga la correspondiente al
prximo.
El intercambio de trabajos requiere del uso de dispositivos de acceso rpido y con alta velocidad
de transferencia.
Dado que el cambio de contexto puede ser algo largo se podra afectar el tiempo de espera de los
usuarios o la eficiencia del sistema. Una solucin consistira en utilizar el solapamiento.
En este caso se dividira la memoria en 3 reas: en la primera estara el trabajo que ya termin y
se est transfiriendo al dispositivo, en la segunda el que se est ejecutando y hacia la tercera se
estar transfiriendo el prximo a atender.
Sistema de
operacin
An cuando se explic el intercambio de trabajos en un sistema operativo de monoprogramacin,

esta tcnica se contina utilizando en las instrumentaciones de multiprogramacin.
Pag - 77
Multiprogramacin con particiones fijas. Fragmentacin interna.
Como ya se conoce, la multiprogramacin presupone la existencia en memoria de varios procesos

que comparten el tiempo del procesador.
Una primera alternativa de administracin de la memoria en este caso, es particionarla en varias

reas llamadas particiones o regiones. Cada programa se almacenar en una de estas particiones.
Debido a lo antes indicado, el grado de la multiprogramacin vendr dado por el nmero de

particiones existentes. Cuando se libera una particin, el planificador de trabajos selecciona uno
de la cola de entrada existente en el dispositivo.
Por supuesto que en este esquema, con varios procesos en memoria, requiere tambin de un
mecanismo de proteccin. Una alternativa es el uso de dos registros, uno indicando la direccin
inicial y otro la direccin final del proceso que se est ejecutando en cada momento.
A
Lmite
superior
B
Lmite
C inferior
Sistema de
operacin
Otra alternativa es tener igualmente dos registros, uno que indique la direccin inicial del proceso
corriente (el que se est ejecutando) y el otro la longitud del espacio asignado.
Una tercera alternativa fue la usada por la IBM/360. Aqu se dividi la memoria en bloques de
2K y a cada uno se le asociaban 4 bits de proteccin. Cuando un programa se cargaba en
memoria a todos sus bloques se les daba el mismo cdigo. Un programa slo poda acceder los
bloques que tenan su cdigo.
El nmero de particiones existentes y la longitud de estas puede ser fija, definidas estticamente
en el momento de la carga del sistema. En este caso se habla de multiprogramacin con
particiones fijas o MFT (Multi Fixed Tasks).
Generalmente cada particin tiene asociada una cola de entrada y una planificacin por separado,
es decir mltiples colas de entrada. Cada vez que termina el programa que se ejecuta en una
Pag - 78
particin se toma el prximo de la cola correspondiente. Los programas van a una cola o a la otra
en dependencia de sus requerimientos de memoria.
Sistema de
operacin
La desventaja fundamental de la instrumentacin anterior consiste en que puede haber una

particin cuya cola est vaca, mientras hay varios trabajos esperando en otras.
Una alternativa consiste en colocar todos los trabajos en una sola cola de entrada, entonces,
siempre que una particin est libre se escoge uno de la cola que quepa en el espacio de memoria.
En este caso se pueden utilizar numerosas polticas de planificacin para la cola las que estn
explicadas en detalles en el libro de la bibliografa propuesta Tanembaum
Sistema de
operacin
El sistema OS/MFT combinaba las dos alternativas antes explicadas. Es decir, una particin poda
tener asociadas varias colas de entrada y tambin una cola de entrada podra estar asociada a ms
de una particin.
Una situacin crtica en la multiprogramacin con particiones fijas es la decisin de los tamaos.
Si se dan tamaos pequeos, los programas grandes puede que no quepan en ninguna. Por otra
parte, si se les dan tamaos grandes, entonces los programas pequeos malgastan memoria. Al
gasto de memoria antes indicado se le llama fragmentacin interna.
Pag - 79
Multiprogramacin con particiones variables. Fragmentacin externa.
Si en el esquema de administracin de memoria no existe un nmero predeterminado de

particiones ni las longitudes son fijas, sino que dependen de las necesidades planteadas por cada
trabajo, estamos en presencia de la multiprogramacin con particiones variables o MVT (Multi
Variable Tasks).
Como es de suponer en esta asignacin dinmica de la memoria no existir fragmentacin interna

debido a que cada proceso recibe justamente la cantidad de memoria que necesita.
En ese esquema, un trabajo se carga en memoria siempre que haya un espacio libre contiguo. A
cada espacio libre se le llama un hueco (hole).
El sistema de operacin mantiene una estructura de datos indicando que espacios estn libres (los
huecos).
Si el espacio aparece, entonces se le asigna la cantidad que necesita. Si existiera sobrante, ste se
mantiene como un hueco.
Lgicamente, al inicio de la operacin toda la memoria dedicada a los procesos usuarios

constituir un gran hueco.
Cuando un proceso termina, libera el bloque de memoria que ocupaba y este se coloca como
libre. Si este hueco nuevo es adyacente a otro, entonces se unen para formar una de mayor
longitud. Ntese que la adyacencia puede ser por cualquiera de los extremos.
En ese momento se chequea si hay trabajos esperando por memoria y si el espacio liberado o
recombinado satisface los requerimientos.
Es evidente que a medida que avanza el tiempo la memoria pudiera quedar fragmentada en varias
particiones y varios huecos pequeos que no pueden ser usados por los trabajos que estn
esperando, ya que sus requerimientos son superiores. A esta situacin se le llama fragmentacin
externa.
Una solucin a la fragmentacin externa es mover todos los procesos a un extremo de la memoria
cada vez que se realiza una liberacin de espacio. Es evidente que en este caso siempre la
memoria libre estar constituida por un solo hueco.
Al procedimiento antes indicado se le llama compactacin de memoria. Lgicamente, para que

esto sea posible deber existir relocalizacin dinmica. Generalmente esta tcnica no se utiliza ya
que consume mucho tiempo de uso del CPU.
En general la utilizacin de la memoria en el modo MVT es superior al MFT y de aqu que el

esquema que se utiliza en la actualidad es el primero.
Pag - 80
En los aspectos discutidos anteriormente sobre el uso de memoria se ha sealado que los trabajos
debern indicar la cantidad de este recurso que requieren. En este caso se deber tener en cuenta
el posible crecimiento del rea de memoria de un proceso debido al uso de la pila o de la
asignacin dinmica (HEAP).
Dicha memoria adicional podr estar incluida en la solicitud o adicionada por el propio sistema
operativo.
El rea de memoria de un proceso generalmente tiene el esquema siguiente:
Datos dinmicos
Pila
Programa A
Pag - 81
Tema V. Administracin de memoria.
Captulo 13.- Paginado y segmentado.
Tcnicas de asignacin de memoria.

Paginado.
Segmentado.
Sistemas combinados.
Tcnicas de asignacin de memoria.
Un problema cardinal en la administracin de memoria, consiste en que estructura de datos

utilizar para conservar la informacin sobre el espacio ocupado y el libre (los huecos) a los
efectos de las asignaciones.
En general se utilizan tres formas fundamentales con este objetivo:

Mapa de Bits (Bit Map).
Listas enlazadas.
Sistema camarada (Buddy Method).
En los mapas de bits, la memoria se divide en unidades asignables. A cada una de estas unidades
le corresponde un bit en el mapa. Si el bit est en cero significa que la unidad o bloque est libre,
en caso contrario estar en 1. Si es necesario asignar una longitud de K unidades, entonces se
busca en el mapa K bits consecutivos que se encuentren en 0.
Un aspecto a tener en cuenta es la longitud de las unidades. Si se toman muy pequeas, entonces
el mapa de bits crece demasiado. Si se toman muy grandes, entonces existir una fragmentacin
importante en el ltimo bloque de cada asignacin. La operacin de bsqueda en un mapa de bits
resulta por lo general lenta y por ello sta tcnica no es muy usada.
Una variante que se utiliza frecuentemente es mantener los bloques de memoria, en uso o libres,
enlazados en una lista ordenada en forma ascendente por direcciones.
Lista
Tipo (R o H) Direccin Longitud Enlace

inicial
Bloques o direcciones fsicas
Pag - 82
Cuando un proceso termina se libera el bloque que ocupaba. Como la lista est ordenada
ascendentemente por direcciones es fcil conocer si algunos de los bloques vecinos (el anterior, el
posterior o ambos) es un hueco. Si esto ocurriera, entonces deben unirse en un solo bloque libre.
Para aumentar la velocidad de bsqueda de los huecos se pueden tener dos listas separadas, una
de bloques en uso y otra de huecos. Sin embargo esta tcnica es ms lenta cuando se va a liberar
un bloque.
Tambin, en lugar de tener una estructura especial para construir la lista de huecos, se puede
hacer uso de los propios bloques de memoria para enlazarse entre si. En este caso la primera
palabra del bloque ser su longitud y la segunda contendr la direccin del prximo.
Un aspecto importante en la administracin de memoria es que disciplina o algoritmo utilizar en

la asignacin de memoria a un proceso.
El algoritmo ms simple consiste en buscar el primer hueco que tenga una longitud igual o mayor
que el bloque necesario. Si el bloque libre es mayor que el necesario entonces es dividido en dos,
uno para ser ocupado y otro que permanecer libre. El algoritmo antes escrito se conoce como
primer acceso (First Fit o First Access). Esta tcnica tiende a reducir el tamao de los bloques al
inicio de la lista y por ello con el tiempo demorar las bsquedas.
Una ligera variacin se puede lograr utilizando el algoritmo del Prximo acceso (Next Fit o Next
Access), que comienza la bsqueda en el lugar donde se qued la vez anterior y no por el
principio. De todas formas, ambas tcnicas tienden a reducir los tamaos de los bloques grandes.
Otro algoritmo bien conocido es el del mejor acceso (Best Fit o Best Access). Este recorre toda la
lista buscando el ms pequeo de todos los que puedan utilizarse. Esta tcnica es ms lenta
(revisa toda la lista) y est demostrado que tiende a generar huecos muy pequeos que despus no
pueden ser utilizados. Cuando se utiliza este algoritmo resulta ms conveniente tener ordenada la
lista de huecos por longitud que por direcciones.
Para solventar la dificultad antes indicada se puede hacer uso del peor acceso (Worse Fit o Worse
Access) que consiste en buscar el hueco mayor. Simulaciones realizadas demuestran que no es
una buena idea.
Una ltima e importante variante a utilizar para la administracin de la memoria es el conocido

sistema camarada (Buddy System). Esta tcnica trata de resolver las dificultades que se presentan
al liberarse un bloque de memoria usando una e incluso varias listas de huecos libres. La
dificultad se presenta en la bsqueda de los vecinos del bloque que se libera.
Su funcionamiento consiste en mantener listas de bloques libres con longitudes de 1, 2, 4, 8, 16,

32, 64, 128, 256, 512..., etc., hasta el tamao de la memoria. Por ejemplo, con una memoria de
1MB se necesitan 21 listas. Inicialmente toda la memoria est libre y por ello todas las listas
estarn vacas, excepto la de 1MB que tendr un bloque.
Pag - 83
Los bloque se asignan en longitudes que son potencias de 2. Por ello, cuando un proceso solicita
una cantidad dada de memoria se busca la primera potencia de 2 que da un valor mayor o igual
que la cantidad solicitada.
La potencia obtenida indicar la cola donde se deber buscar. Si existe un bloque se asigna. Si no
lo hay se ir a la lista inmediata superior, si hay un bloque se pica en dos parte iguales
entregndose la primera mitad al proceso y la otra mitad se coloca en la lista que le corresponde
de acuerdo con su longitud. Si en la lista siguiente no hay bloques libres se contina a la prxima
y as sucesivamente.
Los dos bloques que se obtienen como resultado de un corte se dice que son camaradas. Al
liberarse un bloque de una longitud determinada se coloca en su lista correspondiente, pero si su
camarada est libre entonces se unen y pasan como un solo bloque a la lista correspondiente. El
proceso de unin antes indicado se contina mientras se van encontrando camaradas en forma
sucesiva.
Veamos el ejemplo que aparece en el Tanembaun en la pgina 204.

0 128 256 384 512 640 768 896 1024
Inicio 1024 K
Solic. A 128 256 512

70
Solic. A B 64 256 512

35
Solic. A B 64 C 128 512

80
Lib. A 128 B 64 C 128 512
Solic. 128 B D C 128 512

60
Lib. B 128 64 D C 128 512
Lib. D 256 C 128 512
Lib. C 1024
Pag - 84
La mayor dificultad del sistema camarada es que produce fragmentacin interna, pues las
asignaciones siempre se hacen en bloques potencias de 2 (para 33K se asignan 64K).
Se han visto algunos mtodos de asignacin de espacio de memoria. Si se est utilizando

intercambio de trabajo entonces se usarn algoritmos similares para la asignacin del espacio en
disco
Paginado.
Existen ventajas en buscar un mecanismo que permita a los procesos tener la memoria a utilizar
distribuida por distintas partes dentro de la existente. Esto permitira que el proceso utilice huecos
que en otras condiciones no tendran uso. Un primer esquema en el sentido indicado lo constituye
el llamado paginado.
Cuando se utiliza el paginado los programas se dividen en unidades de tamao fijo. A estas
unidades se les llama pginas. Es decir, un programa esta compuesto por un conjunto de estas
pginas (probablemente la ultima no este completa).
Por otro lado, la memoria de la maquina se divide en bloques de igual longitud coincidiendo sta
con la que tienen las pginas. A estos bloques se les llaman marcos de pginas (frames). En cada
marco de pgina se puede almacenar justamente una pgina.
En un sistema paginado toda direccin generada esta compuesta por dos partes: un nmero de
pgina y el desplazamiento dentro de sta. Es decir un grupo de bits codificarn la primera
informacin y otros la segunda. Ahora nuestro objetivo es poder colocar cada pgina en cualquier
marco que se encuentre disponible. Para lograr este objetivo se requiere mantener la
correspondencia (mapping) entre las pginas y los bloques donde se encuentran almacenadas.
A los efectos de lo antes indicado, se mantiene, para cada proceso, una tabla (un arreglo) indizada
por el nmero de pagina donde cada entrada contendr la direccin base del marco de pgina.
Como es lgico, si a esta direccin se le suma el desplazamiento arribaremos a la posicin fsica
en memoria donde esta la informacin.
A las direcciones existentes en los programas se les identifica como direcciones lgicas y a las
que se obtienen como resultado de la transformacin se les identifica como direcciones fsicas.
Pag - 85
Todo lo antes sealado se puede resumir en el siguiente esquema grfico:

Direccin lgica Memoria
fsica
p d
Tabla de pginas
. Marco de
. +
. pgina
.
.
.
Como es de suponer esta conversin se tiene que realizar con cada direccionamiento y por ello no
puede ser funcin del software hacerlo, sino del hardware. Es decir, que para poder instrumentar
el paginado se requiere que el sistema de computo brinde la posibilidad.
La parte del hardware que se encarga de convertir las direcciones lgicas en direcciones fsicas se
llama unidad de administracin de memoria (MMU).
Al software le corresponde, en el momento de la carga de un trabajo, localizar la cantidad de

marcos de pgina libres que sean necesarios, construir la tabla de pginas y colocar en un registro
base la direccin de sta si el trabajo va a ser ejecutado de inmediato. Normalmente la tabla de
paginas es conservada en el PCB del proceso.
Los marcos de pginas libres se conservan mediante una lista o tabla.
Es de notar que el paginado presupone la relocalizacin dinmica de los procesos. O mejor dicho,
el paginado en si es una relocalizacin dinmica.
En el paginado no existe la fragmentacin externa, pero si se presenta la interna en el ltimo

marco de pgina, pues normalmente tendr una parte de su espacio sin uso. La solucin parece
ser utilizar pginas pequeas. Normalmente se usan espacios entre 1 y 4 Kbytes.
Una ventaja derivado del paginado es la posibilidad de que en un instante de tiempo dos o mas
proceso estn haciendo uso de un cdigo comn, o sea exista una sola copia del cdigo
(programa). Lo antes indicado se logra con facilidad si en las tablas de paginas aparecen entradas
que apuntan a los mismos marcos de pginas.
Para que un programa pueda ser compartido en la forma antes indicada tiene que ser reentrante o
cdigo puro, lo que implica que no se puede automodificar como resultado de su ejecucin.
Pag - 86
En los sistemas paginados la proteccin se establece a travs de la existencia en cada entrada de

la tabla de pginas de un conjunto de bits que codifican si en esa pgina se puede leer, escribir o
ejecutar.
Como un proceso puede hacer referencia a tantas pginas, como lo permita la parte
correspondiente de la direccin, pero pudiera ocurrir que en realidad disponga de menos,
entonces en cada entrada de la tabla de pginas existir un bit que codificara si esta existe
realmente o no. El hardware har uso de este bit para provocar una trampa en caso de una
referencia ilegal.
Segmentado.
La tcnica de administracin de memoria conocida como segmentacin es similar al paginado

con la diferencia de que los bloques no tienen que ser todos de la misma longitud, de hecho un
proceso puede estar conformado por varios segmentos todos de diferentes longitudes.
Esta forma de actuar se acerca ms al punto de vista del programador o usuario que piensa en su
aplicacin como varias partes, por ejemplo un segmento de cdigo, un segmento de datos, una
pila, etc.
Cada segmento se almacena en una parte diferente de la memoria. Todos los segmentos que
forman una aplicacin constituyen su espacio lgico. Cada elemento de este espacio lgico esta
caracterizado por un nombre y una longitud.
En un sistema segmentado toda direccin lgica esta compuesta por dos partes: el nombre del
segmento y el desplazamiento dentro de ste. Normalmente el nombre del segmento se toma
como un nmero para facilitar la instrumentacin.
Mientras que el paginado es una organizacin de la cual el programador no tiene conciencia, en la

segmentacin si, pues deber decidir en su aplicacin cuales sern los segmentos y que elementos
formaran parte de cada uno.
Para convertir una direccin lgica en la direccin fsica donde la informacin se encuentra se
hace uso de una estructura de datos conocida como tabla de segmentos. Cada una de sus entradas
contendr la direccin base del segmento y su longitud.
La transformacin consiste en sumar a la direccin base del segmento el desplazamiento, que a su

vez no puede ser mayor que la longitud.
Pag - 87
Lo indicado se resume en el siguiente esquema:
Trap
Direccin lgica si Memoria

no fsica
s d >longitud
Tabla de segmentos
.
. + Segmento
.
long. base
.
.
.
Al igual que en el paginado, esta conversin se tiene que realizar con cada direccionamiento y
por ello se requiere tambin que el sistema de computo brinde el hardware necesario para su
operacin.
En el momento de la carga de un trabajo le corresponde al software localizar los huecos libres

existentes con las capacidades requeridas para los segmentos, construir la tabla de segmentos y
colocar en un registro base la direccin de esta si el trabajo va a ser ejecutado de inmediato.
Normalmente la tabla de segmentos es conservada en el PCB del proceso.
Para la administracin del espacio libre se utilizara una cualquiera de las tcnicas ya estudiadas:
Mapa de bits, listas enlazadas o sistema camarada.
Dado el carcter dinmico de los bloques de memoria libre, el segmentado adolece del fenmeno
de fragmentacin externa que ya fue analizado para la tcnica de MVT. Ntese que la analoga es
evidente ya que MVT es el segmentado cuando todos los trabajos ocupan un solo segmento.
Los mismos mecanismos de proteccin indicados en el caso del paginado se instrumentan con el
segmentado, es decir bits con los atributos e inclusive derechos de pertenencia.
Con algunas dificultades adicionales con respecto al paginado, pero aqu tambin es posible
compartir segmentos entre diferentes procesos.
Pag - 88
Esquemas combinados.
Se puede y de hecho se ha realizado con frecuencia la combinacin de las tcnicas antes

estudiadas de paginado y segmentacin.
Un primer esquema es la paginacin segmentada que consiste en un sistema paginado donde los
procesos tienen varias tablas de pginas que se guardan como un segmento a los efectos de
ahorrar espacio y memoria.
De uso frecuente es el esquema de segmentacin paginada. En este caso la memoria esta dividida
en segmentos y a su vez, cada segmento internamente se divide en pginas. Como es lgico
suponer cada segmento tendr una tabla de pginas.
Todos los segmentos que pertenecen a un proceso estarn controlados en una tabla de segmentos.
Cada uno de ellos tendr una longitud que ser mltiplo de la longitud de una pgina.
Como es de suponer la conversin de una direccin lgica en una fsica presupone buscar la tabla
de pginas en la de segmentos y despus buscar la direccin del marco de pgina
correspondiente. Por ltimo adicionar el desplazamiento.
En el libro de Peterson se presentan grficos y explicaciones que hace ver en forma clara estos
conceptos. Los microprocesadores de Intel del 80286 en adelante brindan todo el hardware
necesario para instrumentar la segmentacin, mientras que del 386 en adelante permite combinar
ambas tcnicas (segmentacin paginada).
Pag - 89
Tema V. Administracin de memoria.
Captulo 14.- Memoria virtual.
Memoria virtual.
Demanda de pgina y prepaginado.
Algoritmos de reemplazamiento de pginas.
Sobreposicin (Overlays).
Administracin de memoria en sistemas operativos actuales.
Bibliografa:
Operating system Concepts, Peterson, Silberschatz, pag. 172-246.

Operating Systems: Design and implementation, Tanembaum pag. 206-226.
Memoria virtual.
En ocasiones se pueden elaborar programas que sobrepasen la capacidad de memoria disponible

y la interrogante es que hacer en este caso.
Por otro lado, se ha dicho que la eficiencia en el uso del CPU se incrementa con el grado de la
multiprogramacin. Pero a su vez dicho grado esta limitado por la memoria disponible para
almacenar los procesos.
La solucin a las dos dificultades antes indicadas se encuentra en el uso de la llamada memoria
virtual. Esta tcnica consiste en permitir la ejecucin de procesos que puedan no estar
completamente en memoria. Dicho de otra forma, ejecutar programas que son ms largos que el
espacio de memoria disponible para su almacenamiento.
La forma mas comn de instrumentar la memoria virtual es por medio del paginado. Es tal la
relacin que a veces se pierde la nocin de que el uso de pginas de memoria no necesariamente
implica un espacio virtual.
Demanda de pgina y prepaginado.
Al usar el paginado para instrumentar la memoria virtual se tendr que una parte de las pginas
estarn en memoria y otras, lgicamente, se encontrarn almacenadas en un dispositivo de acceso
directo (tpicamente un disco).
Pag - 90
Durante la ejecucin, si se hace referencia a una pgina que est en memoria se procede como se
explic con anterioridad y no existe dificultad alguna.
La complicacin se presenta cuando la referencia se realiza a una direccin que se encuentra en

una pgina que no est en memoria. En este caso, al ir el hardware a la tabla de pginas a tomar la
direccin base del marco de pgina y detectar la situacin, provoca una trampa por fallo o
demanda de pgina.
El manejador de interrupcin de esta trampa har un intercambio de la pgina hacia memoria y

actualizar la entrada de la tabla de pginas. A continuacin el hardware repetir la instruccin
que provoc la situacin.
Como es de suponer en cada entrada de la tabla de pginas estar la informacin indicando si la

pgina correspondiente se encuentra o no en memoria. A estos efectos habr un bit que indicar
tal informacin (acceso vlido o no vlido).
Las acciones implicadas detrs de una demanda de pgina provocan un incremento sustancial del
tiempo de acceso a una posicin de memoria, afectando por ello la utilizacin eficiente del
procesador. La demanda de pgina, aunque inevitable, es indeseable y por ello en el diseo de un
sistema operativo con memoria virtual basado en paginado se deben analizar bien todos los
factores que tienen incidencia en este sentido.
Un aspecto a considerar es la longitud de las pginas. Si estas se toman muy pequeas, entonces
es de esperar una alta frecuencia de ocurrencia de la demanda de pginas. Por otro lado, si fuera
muy grande entonces habra una fragmentacin interna significativa en la ltima.
Al producirse una demanda de pgina, como ya se explic, habr que trasladar a memoria la que
hace falta. Si el sistema operativo an conserva marcos de pginas libres, entonces se tomar uno
de ellos y se almacenar la informacin implicando la operacin un solo acceso al medio de
almacenamiento.
Lo normal ser que al producirse la demanda de pgina no hayan marcos libres. En este caso
habr que sustituir o reemplazar una de las pginas que estaba residiendo en memoria. Si dicha
pgina se ha modificado, entonces deber reescribirse en el medio de almacenamiento,
implicando dos accesos a ste.
Para sustituir una pgina residente en memoria se utilizan diferentes tcnicas conocidas como
tcnicas o algoritmos de reemplazamiento de pginas. En algunos sistemas operativos se le
permite al algoritmo escoger la vctima solamente entre los marcos de pginas que tiene asignado
el proceso (local) o entre todos los existentes (global).
Para conocer si una pgina de memoria ha sido modificada (dirty) o no, se dispondr de un bit en
cada marco de pgina.
Cuando el grado de multiprogramacin es muy alto, el nmero de marcos de pgina que tendr
asignado cada proceso ser bajo y ello puede provocar que un proceso cause una demanda de
Pag - 91
pgina y se sustituya una que de inmediato haga falta y as sucesivamente. A este fenmeno se le
llama THRASHING.
Se dice que un proceso est en THRASHING si esta gastando ms tiempo del CPU en
transferencia de pginas que en realizar computaciones tiles.
Si todos los procesos residentes en el sistema estn en la situacin antes indicada, entonces se
dice que el sistema de cmputo est en THRASHING. Como es de suponer, esta situacin es
totalmente indeseable.
Una alternativa a la demanda de pgina consiste en el llamado prepaginado. En este caso se traen
a memoria determinadas pginas que se asumen sern utilizadas en el futuro inmediato. Si lo
asumido fue lo correcto todo ir bien, en caso contrario se producir la demanda de pgina.
La memoria virtual se puede instrumentar tambin por medio de demanda de segmentos. La

dificultad radica en el tamao variable de los segmentos.
Algoritmos de reemplazamiento de pginas.
Para sustituir una pgina de la memoria lo mejor sera conocer cual es la que ms tiempo
demorar en ser usada de nuevo (o quizs ya no vuelva a ser usada). Este algoritmo es ptimo y
se le conoce como OPT o MIN. Su dificultad consiste en que es imposible de instrumentar, pues
es difcil conocer el futuro. Se utiliza como referencia o comparacin terica.
El algoritmo de reemplazamiento mas simple es el FIFO (First Come - First Out). Consiste en
seleccionar como vctima a la pgina que lleva ms tiempo en la memoria. Para la
instrumentacin se puede hacer uso de una cola en el orden de llegada.
En general no es un buen algoritmo, tiene la dificultad de que se puede sustituir una pgina que
todava se este usando.
Si se usa el pasado reciente como una aproximacin del futuro cercano se llega a todo un
conjunto de tcnicas o algoritmos de reemplazamiento.
El primero en este sentido es el LRU (Least Recently Used). En este caso se sustituye la pgina
menos recientemente usada, es decir la que hace ms tiempo no se usa. Este algoritmo es bastante
bueno, pero se requiere disponer de hardware para su instrumentacin.
Una instrumentacin por software consistira en mantener las pginas en una lista doblemente
enlazada. Cuando se hace referencia a una pgina en la lista, sta se traslada a la cola.
Evidentemente, la pgina en la cabeza de la lista ser la vctima a sustituir (pudiera ser al revs,
como est en el Peterson). Estainstrumentacin es muy costosa en tiempo del CPU.
An cuando casi ningn sistema de computo brinda el hardware necesario para una
instrumentacin del LRU puro, si contienen elementos que permiten una aproximacin. Esta
Pag - 92
consiste en tener por cada pgina en memoria un bit que se pondr en 1 si la pgina es
referenciada, lgicamente al ser trada a memoria se pondr en 0. A este bit se le llama bit de
referencia.
Con lo antes indicado, se adiciona a cada pgina en memoria un byte o palabra que se usar como
un registro de desplazamiento. A intervalos fijos (digamos con la interrupcin del reloj) el sistema
operativo introduce el bit de referencia (bit R) en la posicin ms alta del registro, desplazando a
la derecha (el ms bajo se pierde). Como es de esperar al reemplazar una pgina se escoger una
entre aquellas que tenga un valor menor en el registro.
El uso del bit de referencia se puede combinar con el algoritmo FIFO para crear el llamado
Segundo Chance, que consiste en aplicar el algoritmo mencionado, pero si a la que le toca ser
reemplazada tiene el bit de referencia en 1, entonces se le pone en 0 y se le coloca en el final de la
cola. La seleccionada ser la primera que tenga el bit de referencia en 0.
Otro instrumentacin de reemplazamiento es el algoritmo LFU (Least frequently Used) aqu se

selecciona la pgina que menos ha sido referenciada en un intervalo. Para su instrumentacin se
tendr, por cada pgina en memoria un contador. Cada vez que se produce una interrupcin del
reloj se le adiciona a los contadores el valor del bit de referencia. Como es de suponer se
selecciona la pgina con menor valor.
Este algoritmo tiene la deficiencia de que una pgina que tuvo un alto uso en un momento dado
tendr un valor alto en su contador y permanecer en memoria an cuando ya no se utilice. Una
solucin a esta dificultad consiste en el uso del envejecimiento, que consiste en el algoritmo
aproximado del LRU que ya se explic.
La filosofa contraria a la anterior es el algoritmo MFU (Most Frequently Used). La

instrumentacin es igual, pero se selecciona la pgina con el valor mayor en el contador. Su
basamento es que la pgina menos utilizada en el pasado tendr ms uso en el futuro.
Las dos tcnicas antes sealadas resultan costosas en tiempo de ejecucin.
An cuando quedaran muchos otros algoritmos, por ltimo se har referencia a la tcnica
llamada Clases de Pginas o NRU (Not Recently Used).
Para su instrumentacin se requiere del bit de referencia R y uno (M) que indica si la pgina fue
modificada o no (El dirty antes mencionado).
Cada cierto tiempo el sistema de operacin limpia el bit R de todas las pginas que estn a 1. El
hardware lo pondr en esta forma cada vez que se produzca una referencia (lectura o escritura) y
al M cada vez que sea escritura. Entonces se tendr:
Pag - 93
R M
Clase 0 0 0 (no referido, no modificado)
Clase 1 0 1 (no referido, modificado)
Clase 2 1 0 (referido, no modificado)
Clase 3 1 1 (referido, modificado)
Cuando se produce una falla o demanda de pgina se seleccionar para reemplazar una de clase 0,
si no hay se toma una de clase 1 y as sucesivamente.
Sobreposicin (Overlays).
La instrumentacin de la memoria virtual a travs del paginado es transparente al usuario y este

no tiene conciencia de su existencia.
El overlays es otra variante de memoria virtual donde el usuario tiene que participar en forma
determinante y su logro depende de la planificacin previa que realice en sus programas. Se basa
en la carga dinmica.
La idea del overlay consiste en tener en memoria slo la parte del programa y los datos que son
necesarios en cada instante. Cuando otras partes se vuelven necesarias, se cargan, almacenndose
donde estaban las anteriores.
En un programa preparado para overlay se incluye un manejador que se encargar de ir cargando

cada una de las partes a medida que son necesarias.
La dificultad del overlay consiste en que el programador deber decidir y disear las distintas
partes o mdulos que componen la aplicacin considerando cuales debern estar
concurrentemente en memoria y cuales podrn sobrescribirse.
Dada la consideracin anterior es que esta tcnica ha sido sustituida por el uso del paginado.
Administracin de memoria en sistemas operativos actuales.
Windows.
Histricamente el Windows ha utilizado tres modos de administrar la memoria: modo real, modo
standard y el modo protegido (en consecuencia con los modos de la familia de microprocesadores
Intel). En modo real se administraba menos de un megabyte de memoria, en modo standard al
menos uno y hasta 16 megabytes (con un 80286) o menos de dos megabytes (con un 80386 o
superior) y en modo protegido al menos dos megabytes (con un 80386 o superior).
Hasta el windows 3.0 se utilizaban los tres modos, en el Windows 3.1 se hacia uso del standard y
el protegido y a partir del Windows 95 slo se utiliza el modo protegido (incluyendo las versiones
de Windows NT). En los casos en que la versin hacia uso de ms de un modo, ste era
Pag - 94
seleccionado automticamente a partir del microprocesador que exista y la capacidad de

memoria instalada, excepto que el usuario indicara lo contrario.
Los dos primeros modos, o sea el real y el standard, trabajaban sobre la base del segmentado. En
el segundo caso, se haca uso del mecanismo de segmentado brindado por el hardware a partir del
microprocesador 80286. En modo real, como se asuma que el hardware no brindaba las
facilidades requeridas, se simulaba por software.
En Windows se definan dos tipos de segmentos: fijos (se mantenan en memoria todo el tiempo y
en una posicin determinada) y movibles. Los segundos, a su vez, se dividan en descartables (su
rea de memoria se poda tomar con otro fin, tpicamente programas y recursos) y no descartables
(slo se podan mover de la posicin que tenan en memoria, tpicamente datos).
De aqu la importancia de que los segmentos se declararn como descartables y si no era posible,
al menos como movibles. Solo se indicaba como fijos aquellos en que no quedaba otra alternativa
(por ejemplo, para la caja de mensajes y el icono stop).
Para la simulacin del segmentado en el modo real se hacia uso de una estructura de datos que
recibi el nombre de Burgermaster, donde se llevaba a cabo el control de los movibles. En la
grfica que sigue a continuacin se muestra como se distribua la memoria y el uso de la
estructura de datos antes mencionada
handler Longitud Dir.

Descartables Movibles
0
1
2
Area libre
.
.
. .
.
.
Movibles
Fijos
Burgermaster Fijos
Memoria fsica
Cuando se requera espacio para un segmento fijo, se desplazaban hacia arriba los movibles en la
magnitud requerida. En caso de que los requerimientos no se pudieran cumplimentar, entonces se
Pag - 95
comenzaban a eliminar los descartables y se continuaba con el desplazamiento hasta lograr el

espacio requerido.
Cuando se requera espacio para un segmento movible, se tomaba del rea libre y en caso de no
poderse satisfacer la demanda, entonces se comenzaban a descartar los que tienen esta condicin.
Cuando se requera espacio para un segmento descartable se aplicaban los mismos pasos que en
el caso anterior.
En todos los casos, slo se consideraba la no existencia de disponibidad de memoria si

eliminando todos los descartables, no se poda dar respuesta a la solicitad planteada.
Cuando se devolva el espacio correspondiente a un segmento no se hacen compactaciones, sino

que queda como un hueco, esto slo se lleva a cabo cuando se hacen solicitudes. De lo anterior se
desprende la existencia de algn mecanismo para la conservacin de estos huecos, probablemente
una lista.
Como ya se indic, en el modo standard se utiliza el mecanismo de segmentado existente en los

microprocesadores de la familia Intel y por ello no se utilizan los aspectos antes explicados.
En el modo protegido se administra la memoria opr segmentado paginado. Se utiliza una longitud
de pgina de 4k y el algoritmo LRU para el reemplamiento.
UNIX.
Las primeras versiones del UNIX manejaban la memoria con el esquema de particiones variables.
El espacio libre se mantena por medio de una lista de huecos. Para la bsqueda de un hueco se
aplicaba el algoritmo del primer acceso o ajuste.
Para dar respuesta a la situacin de que se requiera un bloque de memoria y no lo haya, se

instrumenta el intercambio de trabajos. Esto implicaba la existencia de un planificador de nivel
medio que en el UNIX se llam el intercambiador.
La eleccin de la victima (es decir el proceso a pasar al medio de almacenamiento) se realizaba

primero entre los procesos bloqueados en base al tiempo de residencia en la memoria y al gastado
utilizando el CPU. Si no hay procesos bloqueados, entonces se selecciona de la lista de listos.
Cada pocos segundos, el intercambiador revisa la lista de procesos llevados al disco para ver si
hay algunos listos para la ejecucin. En caso de existir, procede a realizar los intercambios hacia
la memoria utilizando como criterio el tiempo de permanencia en el dispositivo. Este
procedimiento se continua hasta que:
a) Ningn proceso en el disco est listo.

b) Los procesos que estn en memoria llevan menos de 2 segundos de permanencia en ella.
Pag - 96
A partir de determinadas versiones (4BSD, Sistema V, etc.) se comienza a utilizar la

administracin de memoria por medio del concepto de memoria virtual, instrumentada con el
paginado. Se utiliza la demanda de pgina.
Los marcos de pgina libres se mantienen en una lista doblemente enlazada. Cuando un proceso
provoca una demanda de pgina y no existen marcos libres, entonces se bloquea.
Para garantizar la existencia de marcos de pgina libres existe un proceso con alta prioridad cuya
tarea consiste en eliminar pginas de la memoria y liberar marcos en base a un algoritmo
conocido como reloj de una o dos manecillas. Este algoritmo tiene en cuenta que las pginas
eliminadas no sean las que han tenido un uso reciente. El objetivo es tener siempre un porcentaje
de los marcos como libres o disponer de una cantidad entre un mnimo y un mximo.
El algoritmo antes mencionado se aplica con un criterio global (es decir la pgina se le quita a
cualquiera).
Pag - 97

Texto Oficial Sistemas Operativos

Hochgeladen von

Dokumentinformationen

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

Texto Oficial Sistemas Operativos

Hochgeladen von

Copyright:

Verfügbare Formate

Faculta de Tecnologa

Carrera de Ingeniera de Sistemas

Tema I. Conceptos Fundamentales..................................................................................................................................3

Tema I. Conceptos Fundamentales.

Captulo. 1.- Funciones principales y evolucin histrica.

Sistemas de operacin y funciones principales.

Sistemas de operacin y funciones principales

1. Como mquina ampliada o virtual.

2. Como administrador de recursos.

La funcin de administrador de recursos consiste en proporcionar una va para asignar, en forma

La meta de la eficiencia es importante para sistemas de cmputo grandes y sistemas compartidos

En el pasado, las consideraciones de eficiencia fueron frecuentemente ms importantes que las de

Se caracteriza por la no existencia de sistema operativo alguno. Solo exista el hardware.

El surgimiento de los compiladores complico la operacin y puso en evidencia la necesidad de ir

Lo antes indicado implico un mejoramiento de la eficiencia (aunque el programador perdi la

La solucin a esta perdida de tiempo consisti en delegar en el propio equipo el cambio

El monitor residente le entregaba el control de ejecucin a un programa y cuando ste terminaba

En los monitores residentes se identificaban claramente cuatro partes componentes:

Vectores de interrupcin y trampas.

El surgimiento de los discos elimin rpidamente la preparacin de lotes de trabajo fuera de

La posibilidad de seleccionar para su ejecucin a un trabajo entre varios almacenados en un

El aspecto ms importante que ofrece el Job Scheduling es la posibilidad de la

La multiprogramacin, es un intento de incrementar la utilizacin del CPU, tratando de que

A un trabajo que se le quit el CPU (bloqueado), eventualmente se le volver a entregar siempre

Los trabajos que se mantienen en memoria se toman de la piscina y la cantidad que en un

El desarrollo de la multiprogramacin brind la posibilidad de que los sistemas operativos

En muchos esquemas de tiempo compartido se establece adicionalmente que un usuario en

Generaciones de los sistemas operativos

La primera generacin (1945-1955) corresponde a los primeros equipos, construidos con

La tercera generacin (1965-1980) se caracteriz por la utilizacin de circuitos integrados. Los

Esta etapa la dominan sistemas operativos MS-DOS y el Unix (y en un inicio el CP/M).

En esta etapa la competencia se centra entre el Unix/Linux, el Windows, Macintoch, y el OS/2

La mayora de los sistemas de cmputo existentes son monoprocesadores, es decir disponen de

La principal ventaja de este tipo de estructuracin es el incremento de la potencia de

Tema I: Conceptos fundamentales.

Captulo. 2- : Servicios del Sistema Operativo.

Al desarrollarse los sistemas operativos an cuando se mantuviera un nico programa en

La proteccin de entradasalida se logra al no permitir que los programas acten directamente

Al ocurrir la interrupcin, el Hardware pasar la ejecucin al modo privilegiado (ya que va a

La solucin a esta problemtica requiere que el Hardware brinde su ayuda. En un ambiente de

En este caso, generalmente el sistema operativo se ubica en la

Si el ambiente de trabajo es multiprogramado, un

medio de un reloj (timer) de Hardware que permite detener el procesamiento y regresar el

Procesos Tablas de procesos.

Servicios del Sistema Operativo

Manipulacin de directorios y sistemas de ficheros.

Uno de los ms importantes programas del sistema es el intrprete de comandos. Es el programa

An cuando en la mayora de los sistemas operativos el interprete de comandos pierde el control

Estructura de un Sistema Operativo.

La naturaleza de los sistemas operativos de ser manejados por interrupcin determina su

Cuando una interrupcin (o trampa) ocurre, de inmediato el hardware transfiere el control al

Las llamadas al sistema, a estos efectos, pueden dividirse en

Solicitud de terminacin normal (realizada por un proceso cuando va a terminar su ejecucin).

Desde el punto de vista de la organizacin de los programas, la estructura de un sistema operativo

Se caracterizan por la no existencia de estructura. Se escriben como una coleccin de

0.- Asignacin del procesador y multiprogramacin.

Modelo cliente - servidor.

Captulo. 3.- Procesos

Modelo de procesos. Estados de los procesos.

Modelo de procesos. Estados de los procesos

Se seal que un proceso era simplemente un programa en ejecucin, lo que implicaba la

La informacin acerca de los procesos presentes en un instante de tiempo se conserva en la tabla

Estado del proceso.

En el modelo de procesos todo el Software ejecutable, a menudo incluyendo el propio sistema de