Gso01

Traducción libre de Jorge Morris A.
OPERATING SYSTEM CONCEPTS

James L. Peterson.
Abraham Silberschatz.
SISTEMA OPERATIVO
Un Sistema Operativo es un programa que sirve de interfaz entre el usuario y el hardware, el propósito
de éste es proporcionar un medio ambiente para ejecutar programas, y su principal objetivo es hacer
que el Sistema Computacional sea conveniente de usar, y un objetivo secundario es el uso del
hardware en forma eficiente.
Un Sistema computacional esta formado por:
HARDWARE
SIST. OPERATIVO
PROGRAMAS DE APLIC.
USUARIOS
1º Definición: Se define como un gobierno, proporciona medios y políticas de usos, tales como el
hardware, software y datos.
2º Definición: Administrador de recursos tales como: Memoria, CPU, dispositivos e información.
Un sistema operativo como un administrador de recursos debe cumplir cuatro funciones:
1.- Llevar el control de los recursos.

2.- Hacer cumplir las políticas de asignamiento.
3.- Asignar un recurso.
4.- Recuperar el recurso.
Un sistema operativo como un programa de control, controlará todos los programas de los usuarios
para prevenir los errores y el uso impropio del computador (sobretodo en los dispositivos de E/S).
El objetivo básico y fundamental de un sistema computacional, es ejecutar programas de los usuarios y

resolverles los problemas, el hardware es construido pensando en esto, pero debido a que es difícil usar
el hardware solo, se desarrollan programas de aplicaciones para facilitar su uso. Estos programas de
aplicación requieren de ciertas operaciones comunes, por ejemplo, controlar los dispositivos de E/S.
1
______________________________
Sistemas Operativos I - Jorge Morris
James L. Peterson.
SISTEMAS PRIMITIVOS
Los primeros sistemas contaban solamente con hardware, eran computadores grandes manejados
completamente por consola, existía una sola persona que cumplía las funciones de programador y
operador; operaban directamente los programas desde la consola; estos programas eran cargados
directamente en memoria, a través de tarjetas perforadas, cintas de papel, la dirección inicial de cada
programa se cargaba mediante botones.
Si se detectaba un error en la ejecución, el programador-operador examinada los contenidos de

memoria y registros. Existía una interacción manual completa, y para trabajar con estos computadores
se usaba el esquema de reserva.
Luego, surgen las lectoras de tarjetas, impresoras de líneas y cintas magnéticas, se desarrollaron
ensambladores, cargadores y enlazadores, también surgen las primeras bibliotecas con funciones
comunes, las que podían ser copiadas sin necesidad de ser escritas por el programador, estaban en
assembler y las más importantes fueron las rutinas que manejaban E/S y fueron llamadas
“Manejadores de Dispositivos” (Device Drivers).
También aparecen los compiladores de Fortran, Cobol y de otros lenguajes, los que se encontraban
disponibles en cintas magnéticas.
Los pasos para ejecutar un programa bajo estos compiladores eran:
1. Cargar programa } Correr compilador

2. Montar cinta con compilador
3. Desmontar cinta del compilador } Correr assembler

4. Montar cinta con assembler
5 Desmontar cinta con assembler } Correr programa
Programa Fuente Compilador Programa Objeto
SISTEMAS BATCH SIMPLES
La finalidad de estos sistemas era disminuir el tiempo ocioso y para ello se dan dos soluciones:
1. Contratar a un programador, lo que implica disminuir el tiempo de montar y desmontar cintas, este
no operaba el computador.
2
______________________________
James L. Peterson.
- El operador debía saber que S.O. ocupar, cuantas cintas necesitaba, etc.
- El usuario debía proveer la información básica por ejemplo: información fuente, flujo de
Ejecución, etc.
- Cuando ocurrían errores, el operador tenía que hacer un vaciado de la memoria y los
registros correspondientes, por lo tanto se complica la labor del operador, debía estar
pendiente de lo que estaba sucediendo.
2. Contar los jobs que tenían necesidad común y eran tratados como un lote, significaba juntar los
programas de igual lenguaje y estos se ejecutaban; aún la cpu estaba ociosa al cambiar las cintas
correspondientes al termino de la ejecución de programas iguales, el operador debe comprobar la
ejecución correcta de cada programa.
Para esto se introduce un Secuenciador Automático de Jobs, que sería el primer S.O. muy
rudimentario. Este automáticamente transferiría el control desde un programa a otro, para
este efecto un pequeño programa fue creado y se llamo Monitor Residente.
Vectores de Interrupción y Traps

Manejadores de Dispositivos
Interprete de tarjetas de Control
Área de programas Usuarios
Diagrama de Memoria de un Monitor residente.
(Traps: interrupción interna al encontrar un error de programa.)
Inicialmente, el control reside en el monitor, luego este lo transfiere al programa, cuando el programa
finaliza, el control retorna al monitor, que lo devolverá al siguiente programa.
Previamente el operador debe dar una descripción de qué programas se ejecutaran y sobre que datos.
Para dar esta información directamente al monitor se introducen las Tarjetas de Control.
Por ejemplo: para ejecutar un programa en fortran bastaba introducir las siguientes tarjetas de control
especificando la secuencia.
$FTN --- Ejecuta el compilador fortran.

$ASM--- Ejecuta el assembler.
$RUN--- Ejecuta el programa.
Se usan dos tarjetas adicionales para definir los limites de cada Job.
$JOB--- Primera tarjeta de un Job.

$END--- Ultima tarjeta de un Job.
Para diferenciar las tarjetas de control con las de los programas o datos, se le antepuso un signo “$”,
IBM creó un lenguaje de control llamado JCL (Job Control Language).
MODO MONITOR USUARIO
3
______________________________
James L. Peterson.
El monitor residente provee de una secuenciación automática de trabajos que es indicada por las
tarjetas de control. Cuando la tarjeta de control indica que un programa debe ser corrido, el monitor lo
carga en la memoria y le transfiere el control. Cuando un programa es completado, éste transfiere el
control al monitor para que continúe con la próxima tarjeta de control. Esto se repite hasta que todas
las tarjetas de control son interpretadas para ese trabajo en particular, entonces el monitor
automáticamente continua con el próximo trabajo.
Los errores también pueden ser manejados por el monitor, si el programa de un usuario falla en algún
momento, tal como una instrucción ilegal o un mal Direccionamiento a memoria, el hardware
interrumpirá al monitor residente.
Cuando un error causa un trap, el monitor residente automáticamente realiza un vaciado de memoria y
registros, antes de ejecutar el próximo Job.
Sin embargo, otros tipos de programas que fracasan pueden causar muchos problemas, suponga un
programa que entre en un loop cuando lee las tarjetas, el programa leerá todos estos datos y a menos
que algo lo detenga, continuara leyendo las tarjetas del próximo trabajo y del próximo, etc.
Cómo detener un programa?
Una aproximación es ir a una Subrutinas común de I/O que fue mencionada antes: Device Drivers.
El manejador de dispositivos para la lectora de tarjetas tuvo que ser modificado para detectar un
intento de leer una tarjeta de control, cada tarjeta que es leída, será examinada para ver si es una
tarjeta de control, si no lo es, el control del programa será retornado al programa usuario como normal.
Sin embargo si un intento es hecho para leer una tarjeta de control, el manejador de la lectora de
tarjetas transferirá el control directamente al monitor residente. El monitor residente tratará esta
situación como un error, vaciando la memoria y luego ira al próximo trabajo.
Para esto se definen todas las instrucciones de I/O como instrucciones privilegiadas y se determinan
dos modos separados de operación: Modo usuario y Modo monitor (también llamado modo
supervisor o modo sistema). Para tal caso, un bit es agregado al hardware del computador, para indicar
en que modo se esta: modo monitor 0, o modo usuario 1. Así, el hardware permitirá instrucciones
privilegiadas para ser ejecutadas sólo en modo monitor.
Si se intenta ejecutar una instrucción privilegiada en modo usuario, el hardware no la ejecuta, pero la
tratara como una instrucción ilegal, y ocurrirá un trap en el monitor residente, este modo de operación
dual, permite asegurar solo a los manipuladores de dispositivos (que son parte del monitor residente) la
lectura de las tarjetas. Un programa usuario, por esto, nunca puede leer una tarjeta de control, como
dato.
LLAMADAS AL SISTEMA
Como el programa usuario no puede ejecutar E/S, debe recurrir al monitor para poder realizar la I/O -
se logra mediante una instrucción especial que se denomina “Llamada al Sistema” -. Cuando ocurre
una llamada al sistema, se produce una interrupción en el monitor. El monitor examina el trap para
determinar qué llamada al sistema a ocurrido, un parámetro indica lo que el programa usuario esta
4
______________________________
James L. Peterson.
requiriendo, el monitor ejecuta este requerimiento y retorna a la siguiente instrucción de la llamada al

sistema.
Uso de una llamada al sistema para ejecutar I/O.
Case n
(1)
(3)
Read
1. Trap para el monitor. (2)

2. Ejecuta E/S.
3. Retorna al usuario.
CALL x
Si se requiere más información adicional, el monitor cuenta con registros especiales, las instrucciones
privilegiadas que ejecutará el monitor son:
-E/S
-HALT, tiene el control sobre el interruptor del sistema, para colocarlo en On- Off, además, del
cambio de modo usuario a modo monitor.
-Protección de Memoria, la memoria es separada en dos, usuario y monitor, para evitar que el usuario
ocupe posiciones de memoria del monitor, si esto ocurre se esta perdiendo el control del sistema.
-TIMER, es como el reloj del sistema, esta formado por:
i) Un reloj como tal.

ii) Un contador.
Su función es evitar que un programa entre en un loop infinito ( si entra en loop el monitor queda sin
control).
El timer interrumpe el programa en un período de tiempo que puede ser fijo o variable, el contador es
inicializado en cero o en un valor por el S.O.; en cada tic del reloj se va decrementando o
incrementando según corresponda y cuando el contador es igual a 0 o igual al valor, ocurre una
interrupción.
Con lo anterior se llega a una arquitectura resultante de los sistemas batch simple, cuyas características
son:
5
______________________________
James L. Peterson.
- Las tarjetas de control gobiernan el Sistema.

- El control será mantenido por el monitor y el programa usuario estará confinado.
- Existirá una ejecución dual: modo usuario y modo monitor.
- Existirá un conjunto de instrucciones privilegiadas.
- Contará con un mecanismo de protección de memoria.
- Cuenta con un timer.
- Cuenta con un halt.
Con las características anteriores se asegura el correcto funcionamiento del Sistema, pero falta resolver
la optimas utilización (performance).
BATCH SOFISTICADO
Una de las primeras pretensiones para la performance fue la secuenciación de Jobs, pero existía un
problema mayor, debido a que las velocidades de la CPU con respecto a las unidades de E/S, - la cpu
es más veloz-, esto provoca que la CPU estuviera mucho tiempo ociosa.
La CPU lenta trabajaba en el rango de los microsegundos y la lectora de tarjetas rápida leía alrededor
de 1.000 tarjetas por minuto, lo que implica que mientras la CPU estaba trabajando, los dispositivos
estaban ociosos y viceversa.
BUFFERING
Esto tiende a mantener ocupados los dispositivos de E/S y la CPU, mientras los dispositivos de E/S
enviaban registros a la CPU y se procesaban se podían leer otros registros.
Se tenía que saber cuando la CPU no estaba ocupada y se avisaba mediante una interrupción, esto
ayuda a la velocidad de procesamiento de los datos, pero aún se produce perdida de tiempo, por los
Jobs que requieren mayor velocidad, el tiempo de proceso se limita con la velocidad de los dispositivos
de E/S, aunque la CPU sea muy rápida.
Cuando existe una interrupción de E/S, la CPU verifica si el dispositivo tiene aún capacidad, de ser así,
ordena ejecutar otra E/S para compensar la diferencia de velocidad.
OPERACIONES FUERA DE LÍNEA
A pesar que los dispositivos son veloces, también la CPU se agiliza, las entradas se hacen por tarjetas
y las salidas por medio de impresoras, para minimizar este tiempo fuera de línea se propuso el traspaso
de tarjetas a cintas y de cintas a impresora en E/S respectivamente.
6
______________________________
James L. Peterson.
A) Operación en línea de dispositivos de E/S.
Lectora Impresora
B) Operación fuera de línea de dispositivos de E/S.
Lectora Impresora
Dispositivo de Cinta Dispositivo de Cinta
Para realizar lo anterior surgen dos métodos:
a) Consiste en el desarrollo de unos dispositivos especiales que permiten Entradas desde

cintas y otros que permiten Entradas directamente a cintas.
b) Fue dedicar un computador pequeño, por ejemplo el IBM 1401, que ejecutaba estas tareas,
esta forma se denominó procesamiento satélite y fue uno de los primeros casos de Salida en
que varios computadores trabajaron juntos para lograr la performance.
La principal ventaja de realizar estas operaciones fuera de línea, es que el computador principal no esta
atado o restringido a las bajas velocidades de los dispositivos de E/S.
Es necesario, por lo tanto, que exista un cambio en el S.O., porque cuando se producen peticiones de
E/S de tarjetas, hay una llamada al Sistema, que ahora no invoca al manejador de lectoras, sino que a
las cintas. Esta habilidad se denomina Independencia de Dispositivos, ya que los programas son
escritos usando dispositivos lógicos equivalentes a los físicos, pero aún existen problemas de montar y
desmontar las cintas.
SPOOLING
Uno de los mayores problemas con las cintas es que la CPU no puede leerlas mientras se están
escribiendo con la lectora de tarjetas, esto se soluciona con los discos magnéticos, ya que ellos al
mover la cabeza lecto-grabadora de un área a otra pueden cambiar rápidamente de receptores a
emisores y viceversa.
En el disco se almacenan los Jobs completos, los que eran leídos desde tarjetas y la ubicación de la
imagen de la tarjeta era manejada por el S.O, a través de tablas, lo mismo ocurre con la salida, la que
7
______________________________
James L. Peterson.
era guardada en disco para después enviarla a impresión.
Spooling: Simultáneas Peripheral Operation On-Line.
Disco
Lectora Impresora
El spool funciona como un gran buffer, es una gran ventaja, mientras la CPU esta
ejecutando un Job con spooling, puede estar imprimiendo otro Job o lo puede estar leyendo, el
spooling traslada Jobs y el buffer traslada registros de un mismo Jobs.
El spooling actualmente existe en la mayoría de los sistemas y tiene directa implicancia en la
performance, casi siempre va a mantener ocupada a la CPU y a los dispositivos; proporciona una
importante estructura de datos que sería el spool de trabajo, el cual es un grupo o varios Jobs, leídos
desde disco que están listos para ser ejecutados, y el S.O. puede escoger cual de ellos va ha ser
ejecutado. - Aumenta la productividad del Sistema; antes, todos los jobs debían ser ejecutados
secuencialmente- este es el inicio de la Multiprogramación.
MULTIPROGRAMACIÓN
Nace en el intento de mantener ocupada la CPU, significa que se tienen varios programas, los cuales
están residentes en memoria simultáneamente, por lo tanto se necesita una administración de memoria
y se necesita un scheduling de CPU, el cual elegirá a un Jobs para que sea ejecutado por la CPU,
manipulación del deadlock, control de concurrencia y protección de memoria.
TIEMPO COMPARTIDO
Se tiene varios programas en memoria y le serán entregados a cada uno un tiempo especifico de CPU,
en los S/. Batch un Job era preparado y después de un tiempo se ejecutaba y después de ser ejecutado
se devolvía la salida al programador, ese tiempo de espera se denomina Time Araund. En los sistemas
batch no existe interacción con el usuario y Job, mientras se ejecuta.
En los sistemas interactivos se proporciona una comunicación en línea entre Job y usuario.
- La E/ es realizada por teclado y la S/ por vídeo.

- El S.O. espera el próximo comando a ejecutar por teclado (el batch lo hace por medio de tarjetas de
control).
- Los S/. batch son apropiados para ejecutar grandes programas con poca necesidad de interacción.
- Para que exista tiempo compartido se necesita la conciliación de multiprogramación y la interacción.
8
______________________________
James L. Peterson.
Cada usuario tiene un programa en memoria y la CPU se cambia rápidamente de uno a otro y como
cada transacción es corta se necesita un pequeño tiempo de CPU para cada usuario.
Los usuarios tienen la intuición de estar trabajando en un computador propio.
En todos los computadores se puede trabajar en batch como en tiempo compartido.
SISTEMA DE TIEMPO REAL

Se refiere a que el tiempo de respuesta es corto. Los Sistemas de tiempo real son utilizados como
dispositivos de control en una aplicación delicada, generalmente la Entrada es emitida por un sensor, el
computador analiza los datos y según ellos modifica los controles que actúan en la máquina, este tipo
de S.O. se define como ligado a un tiempo fijo.
El proceso debe ser realizado dentro de ese limite de tiempo, de lo contrario el sistema falla.
BATCH.
Lectora Impresora
INTERACTIVO MODO USUARIO
TIEMPO REAL
Sensor
Control
TIEMPO COMPARTIDO
TTY
9
______________________________
James L. Peterson.
CRT
CCT
10
______________________________
James L. Peterson.
SISTEMA MULTIPROCESADORES
En estos sistemas existen mas de una CPU y se ocupa memoria compartida y existen 2 técnicas:
1.- Técnica Maestro-Esclavo.

Se tiene varios procesadores y uno de ellos actúa como maestro, el resto ha sido diseñado para cumplir
tareas especificas y muchos de estos esclavos son verdaderos terminales de E/S y se denominan
Remoter Job Entry.
2.- La red de computadores que se denomina NETWORK, en este se tiene varios S/ computacionales
independientes que se comunican para enviarse archivos e información, cada uno de ellos tiene su
propio S.O. y operan en forma independiente.
La mayoría de los S.O. fueron para los computadores grandes, los minis fueron creados alrededor de
los años 60 y los micros alrededor de los 70.
Los S.O. de los computadores grandes fueron adecuados para los pequeños como microcomputadores
y minicomputadores.
Estos, los minis y micros tuvieron que ser capaces de adaptar rápidamente la tecnología desarrollada
para los computadores, sin tener que pasar por todos los errores de habían pasado los otros

James L. Peterson.
11
______________________________
James L. Peterson.
SERVICIOS DE SISTEMAS OPERATIVOS

Tipos de Servicios: Un S.O. proporciona un ambiente para la ejecución de programas y proporciona
ciertos servicios a los programas, como, también a los usuarios de los mismos. Estos servicios
lógicamente difieren entre los distintos S.O., pero algunos servicios son básicos y comunes.
- Ejecución de programas: Los usuarios necesitan correr programas. El sistema debe ser capaz de
finalizar su ejecución ya sea normal o anormalmente.
- Operación de E/S: Un programa ejecutándose puede solicitar E/S. Esta E/S puede involucrar
archivos o un dispositivo específico, (desde que los programas usuarios no pueden ejecutar E/S
directamente, el S.O. debe proporcionar los medios necesarios para hacerlo).
- Manipulación del Sistema de Archivos: Parece obvio que se desea leer y grabar información sobre
un archivo, como también es necesario crear y borrar archivos.
- Detección de Errores: El S.O. debe estar continuamente vigilando posibles errores, estos pueden
ocurrir en la CPU y en la memoria; en dispositivos de E/S, programas usuarios etc. Por lo tanto, para
cada tipo de error el S.O. debe tomar la acción apropiada para asegurar la computación correcta y
consistente. Además aquellos sistemas con múltiples usuarios pueden ganar eficiencia compartiendo
los recursos computacionales entre usuarios.
- Distribución de Recursos: Los recursos deben ser distribuidos entre numerosos trabajos que se
encuentran ejecutándose. Diferentes tipos de recursos son administrados por el S.O., algunos como
los ciclos de CPU, memoria principal y almacenamiento de archivos pueden tener una clave especial
de distribución, mientras que otros, tales como: dispositivos de E/S, pueden tener peticiones mucho
más generales.
- Contabilización: Siempre es necesario saber que usuarios utilizaron que recursos y de que forma,
Esta estadística puede ser para el cobro de proceso o simplemente como estadística de uso, para
posteriormente reconfigurar el sistema con el objeto de mejorar el servicio computacional.
- Protección: Los propietarios de la información almacenada en un sistema computacional

multiusuario, pueden querer controlar su uso, ante demandas conflictivas por algunos recursos es
necesario asegurarla adecuadamente.
El punto de vista del Usuario.
Existen dos métodos básicos con que el S.O. proporciona servicios. Cada uno de ellos tiene ventajas,
estas son llamadas al sistema y programas del sistema.
Llamadas al Sistema:
El nivel más fundamental de servicios es manejado mediante la llamada al sistema, lo que

proporciona una interfaces entre el programa que esta corriendo y el S.O.. Esas llamadas son
generalmente utilizables como instrucciones en lenguaje assembler y son usualmente listadas en los
manuales usados por los programadores en lenguaje ensamblador. Estas llamadas podrían ser, en un
primer intento agrupadas en tres grandes categorías:
12
______________________________
James L. Peterson.
a) CONTROL DE TRABAJOS O PROCESOS:
Un programa que esta corriendo necesita ser capaz de pasar su ejecución ya sea normalmente
(termino) o anormalmente (aborto). Muchos errores distintos pueden ser indicados utilizando un
parámetro de nivel de error. También es posible combinar terminación normal con terminación
anormal definiendo la primera como "anormal de nivel 0". Un proceso o Job ejecutándose puede
querer "cargar" y ejecutar otro programa, por lo tanto es necesario saber que pasa con el control una
vez finalizada la ejecución del programa llamado.
Otro conjunto de llamadas al sistema proporciona ayuda en la depuración de programas (DEBUG), es
así como algunos sistemas operativos incorporan utilitarios de este tipo por ejemplo DUMP, TRACE,
etc.
b) MANIPULACIÓN DE ARCHIVOS:
En un sistema es necesario crear y borrar archivos, una vez creados se necesita abrirlos y usarlos, como
también leerlos, etc. También es necesario utilizar directorios y protegerlos, generalmente GET FILE
ATTRIBUTE y SET FILE ATTRIBUTE son requeridos para ello.
c) ADMINISTRACIÓN DE DISPOSITIVOS:
Algunas de las llamadas para los archivos, también pueden ser necesarias para los dispositivos. Si
existen muchos usuarios, se debe primero Solicitar el dispositivo para asegurar su uso, después de
usarlo se debe liberar; estas funciones son similares al OPEN/CLOSE de los archivos.
d) MANUTENCIÓN DE INFORMACIÓN.
Muchas de las llamadas al sistema existen simplemente para la transferencia de información entre el
programa usuario y el S.O., por ejemplo TIME y DATE. También el S.O. almacena información
acerca de todos sus trabajos y procesos y con llamadas al sistema permite accesar esa información.
TIPOS DE LLAMADAS AL SISTEMA.
PROCESS CONTROL - End, abort

- Load, Execute
- Create Process, Terminate Process
- Get Process attributes, Set Process attributes
- Wait for time
- Wait Event, Signal Event
FILE MANIPULATION - Create File, Delete File

- Open, Close
- Read, Write, Reposition
- Get File Attributes, Set File Attributes
13
______________________________
James L. Peterson.
DEVICE MANIPULATION - Request Device, Release Device

- Read, Write, Reposition
- Get Device Attributes, Set Device Attributes
INFORMATION MAINTENANCE - Get Time or Date, Set Time or Date
- Get System Data, Set System Data
- Get Process, File or Device Attributes, Set Process, File or
Device Attributes.
IMPLEMENTACION DE LLAMADAS AL SISTEMA.
Las llamadas al sistema ocurren de distintas formas según el computador, por ejemplo, en un IBM
360/370 los menores ocho bits de la llamada al sistema, especifican un número que indica la llamada
que esta siendo hecha, CPM corriendo en un INTEL 8080, como no tiene una instrucción especial de
llamada al sistema, la llamada es hecha colocando el número de la función en el registro C y saltando
directamente a la ubicación S de memoria. A veces es necesario enviar información adicional a la
llamada la que debe ser enviada como parámetro.
Existen dos formas de enviar los parámetros, una de ellas es por medio de REGISTROS, sin embargo
algunas veces hay más parámetros que registros, en este caso los parámetros son almacenados en una
tabla o bloque de memoria y la dirección de este es enviada a un registro. Generalmente las llamadas
al sistema están disponibles en assembler, en algunos sistemas se puede hacer en lenguaje de alto nivel
y el sistema se encarga de tener una rutina que ejecute las funciones predefinidas.
Algunos lenguajes, tales como C, Bliss, PL1, han sido diseñados para reemplazar al assembler para
la programación de sistemas, Pascal también da la facilidad de efectuar llamadas directamente en este
lenguaje.
Muchas veces las llamadas al sistema son transparentes al usuario, quien no sabe que se ejecutan al
efectuar un simple read o write.
Programas del Sistema: El sistema también proporciona un gran conjunto de programas para resolver
problemas comunes. Vale la pena notar que algunos de ellos se venden aparte. Estos programas
pueden ser divididos en varias categorías:
. Manipulación de Archivos: Programas que crean, borran, copian, renombran, imprimen y

generalmente manipulan directorios.
. Información de estados: Algunos programas simplemente preguntan al S.O. por el día, hora,
monto de memoria disponible o espacio en el disco, número de usuarios o alguna otra
información de estado. Esta información es entonces formateada e impresa en un terminal u
otro dispositivo o grabada en archivo.
. Modificación de archivos: Varios editores de texto pueden ser proporcionados para crear o
modificar el contenido de archivos guardados en cinta o disco.
14
______________________________
James L. Peterson.
. Soporte de lenguajes de Programación: Compiladores, ensambladores e interpretes para

lenguajes de programación común son también provistos con el S.O.
. Ejecutores y Cargadores de Programas: Una vez que un programa es ensamblado o

compilado, debe ser cargado en memoria para ser ejecutado. El sistema puede proveer
cargadores absolutos, cargadores relativos, linkage editores y cargadores de overlays. Sistemas
depuradores (DEBUG) para lenguajes de alto nivel o máquina son también necesarios.
. Programas de Aplicación: Algunos sistemas también proporcionan algunos programas de uso

común, tales como: compiladores, formateadores de texto, sistemas de bases de datos, paquetes
de análisis estadísticos y otros.
Tal vez el programa más importante del sistema para un S.O. es el Interprete de comandos, este
programa comienza a correr cuando un trabajo empieza o un usuario da un comando login en
un sistema operativo de tiempo compartido.
Muchos comandos son dados al S.O. por tarjetas de control (la tarjeta de control, son
comandos en un S.O. batch; comandos son tarjetas de control en un medio interactivo).
Cuando un usuario va ha comenzar a trabajar en un medio interactivo o cuando se comienza a
ejecutar un trabajo en batch, comienza automáticamente a ser ejecutado un programa que lee e
interpreta los comandos, este programa es llamado de diferentes formas: 1. Interprete de
control, 2. Interprete de líneas de comandos, 3. Procesador de comando de consola, 4. Shell en
Unix y varios más. Su función es bastante simple: buscar el próximo comando y ejecutarlo.
LA VISIÓN DEL SISTEMA OPERATIVO:

La perspectiva de un S.O., visto por un usuario es definida principalmente por los programas del
sistema, particularmente por el interprete de comandos. El programador de S.O. por otra parte, tiene
una perspectiva muy diferente, el usuario ve que facilidades le otorga el S.O., el programador de S.O.
mira únicamente los recursos físicos y debe convertirlos en facilidades lógicas a ser usadas por los
usuarios. Al considerar entonces que un sistema operativo esta compuesto de programas que son
Manejadores de Eventos. Si no existen trabajos en ejecución, no existen servicios de E/S, y no
existen usuarios a quienes responder, un sistema operativo debe permanecer quieto, esperando que
algo ocurra. Los eventos son casi siempre señalados por la ocurrencia de una interrupción o trap. De
este modo un S.O. es un Manejador de Interrupciones. Esta naturaleza de un S.O. define su
estructura general, cuando ocurre una interrupción el hardware transfiere el control al S.O., primero el
S.O. preserva el estado de la CPU, guardando registros y el contador de programas, entonces determina
cual tipo de interrupciones ha ocurrido. Esta determinación puede requerir una búsqueda , es decir, el
resultado natural de un vector de interrupción del sistema. Varios tipos de interrupciones pueden
ocurrir: una llamada al sistema, una interrupción de E/S o un error de programa. Para cada tipo de
interrupción, existen segmentos separados de programas en el sistema operativo, que determinan la
acción que se debe seguir.
-Llamada al Sistema: También existen diversos programas para su atención dependiendo de su

clasificación:
Terminación Normal: Si es hecha una llamada al sistema por término normal del programa en
15
______________________________
James L. Peterson.
ejecución actualmente, el S.O. debe enviar el control al interprete de comandos, el cual lee la próxima
tarjeta de control o comando para determinar el próximo paso.
Terminación Anormal: Un programa al detectar un error en alguna instrucción o dato puede requerir
un mensaje de error y un vaciado de memoria y terminar anormalmente. Entonces es llamado el
interprete de comandos, si el S.O. es del tipo interactivo, el interprete de comandos simplemente
continuará con el próximo comando, ya que asume que el usuario va a introducir un comando correcto
al ver su error. En un sistemas Batch el interprete de comandos usualmente termina todo el trabajo
y continua con el próximo. Algunos sistemas permiten que tarjetas de control puedan indicar una
acción especial en caso de ocurrencia de un error.
Petición de Estados: Simplemente consulta al S.O. por información, estas solicitudes son computadas
y el control es devuelto al programa que esta corriendo.
Peticiones de Recursos: Un programa al estar corriendo puede necesitar de recursos adicionales para
poder proseguir, como por ejemplo más memoria, manejadores de cintas, acceso a los archivos y otros.
Si los recursos están disponibles son asignados y el control devuelto al programa usuario, en caso
contrario, el programa debe esperar hasta que los recursos estén disponibles.
Petición de E/S: La mayoría de las solicitudes son de este tipo ya sea por dispositivos o archivos.
INTERRUPCIONES DE DISPOSITIVOS DE E/S

Un dispositivo de E/S puede interrumpir cuando ha finalizado una petición de E/S. Cuando ha habido
una petición de E/S del usuario para una llamada al sistema y esta ha sido comenzada, pueden ocurrir
dos cosas: comenzar la solicitud y esperar que haya sido completada antes de devolver el control al
programa usuario y la otra es devolver el control sin la completación de la E/S. La espera de la
completación puede ser de dos maneras, algunos computadores tienen una instrucción WAIT que hace
que la CPU permanezca ociosa hasta la próxima interrupción, la máquina que no lo tiene puede
simularlo con un LOOP: JMP LOOP el que es roto cuando ocurre una interrupción, transfiriendo el
control a otra parte del S.O.; sin duda es mejor el WAIT, ya que la otra hace que se generen una serie
de búsquedas de instrucciones.
Una ventaja de esta alternativa es que se sabe exactamente que dispositivo esta interrumpiendo, por
otra parte se limita mucho el monto de E/S simultáneas.
La alternativa es comenzar la E/S y devolver inmediatamente el control al programa usuario. Una

nueva llamada al sistema es necesaria para permitir al usuario esperar la completación de la E/S. De
aquí, que es necesario que permanezca inmóvil antes que el código de espera. También es necesario
guardar la pista de las diversas peticiones de E/S hechas a un tiempo. Para este propósito el S.O. usa
una tabla conteniendo una entrada para cada dispositivo de E/S: Tabla de Estados de Dispositivos.
Cada entrada indica tipo de dispositivo, su dirección y su estado. Si el dispositivo esta ocupado con
una solicitud, el tipo de solicitud y otros parámetros pueden ser guardados en la entrada de la tabla para
ese dispositivo. Como es posible que un programa emita varias solicitudes para el mismo dispositivo
se puede tener una lista encadenada de solicitudes en espera. De este modo además de la tabla de los
dispositivos de E/S un S.O. puede tener una lista de peticiones por cada dispositivo.
Un dispositivo de E/S interrumpe cuando necesita servicio, primero se debe determinar que
dispositivo causa la interrupción, entonces se debe buscar en la entrada de la tabla correspondiente el
16
______________________________
James L. Peterson.
estado del mismo, y modificar la entrada para que refleje lo que ocurre; para la mayoría de los
dispositivos una interrupción señala la completitud de una solicitud de E/S, si existen solicitudes
esperando para ese dispositivo, entonces se pueden atender, finalmente debe ser devuelto el control, si
un programa estaba esperando por la completación de una E/S (lo que se verifica en la tabla) se le
devuelve el control, si no, se le devuelve donde quiera que estuviese antes de la interrupción.
TABLA DE ESTADO DE DISPOSITIVOS
Dispositivo Unidad Disco 1 Solic.Disco 1

Estado Ocupado Oper :Lect.
Dir : 12331
Dispositivo Impresora 3
Estado Ociosa
Dispositivo Unidad Disco 2 Solic.Disco 2 Solic.Disco 2

Estado Ocupado Oper : Write Oper : R/W
Dir :788433 Dir 455003
.
.
.
.
.
.
ERRORES DE PROGRAMACIÓN:
Esta es la tercera clase de interrupciones, donde quiera que un error ocurra en un programa el S.O.
debe terminarlo anormalmente. Un mensaje de error apropiado es dado y la memoria del programa es
vaciada.
FLUJO GENERAL.
Se puede identificar un S.O. como un manipulador de interrupciones, manejador de dispositivos, un

conjunto de rutinas de llamadas al sistema y un interprete de comandos de control, como también un
administrador de archivos, estos elementos son suficientes para definir un S.O. , muchos de éstos
proporcionan funciones adicionales y es por eso que son mucho más complejos, cabe destacar que un
17
______________________________
James L. Peterson.
S.O. mono-usuario y uniprogramado es menos complejo que un S.O. multi-usuario y

multiprogramado.
FLUJO GENERAL DE UN SISTEMA OPERATIVO
INTERRUPCION
Almacena Registros
de qué tipo ?
END ERROR ASIGNACIÓN SERV. SOLIC. E/S COMPLETA E/S
Vaciado Señala ejecución
Próximo Job Asigna Comienza Petición
Comando Espera vuelve
vuelve al usuario
18
______________________________
James L. Peterson.
ITERACIÓN DE C.P.U. (Scheduling)
Elemento básico de los S.O. multiprogramables, esto implica que al haber varios programas en
memoria, el tiempo de C.P.U. puede ser compartido entre ellos.
La idea de la multiprogramación es bastante simple: un JOB es ejecutado hasta que tenga que esperar,
típicamente para la completación de una ejecución de E/S. En un computador monoprogramado, la
C.P.U. debería permanecer ociosa, lo que avalaría el desperdicio de mucho tiempo. En un sistema
multiprogramado. la C.P.U. en vez de permanecer ociosa, continuaría trabajando con otros procesos.
Los beneficios de la multiprogramación es el incremento de utilización de la C.P.U. y el
"THROUGHPUT" de un JOB.
THROUGHPUT : Cantidad de JOB que son terminados en un intervalo de tiempo.

Por ejemplo: 17 JOB por hora.
Como un caso extremo, asuma que tiene dos JOBs A y B para ser ejecutados, cada JOB se ejecuta por
un segundo y espera otro segundo.
Este esquema se repite 60 veces, si se ejecuta primero el JOB A y luego el JOB B, uno después del
otro, tomaría 4 minutos ejecutar ambos JOB, cada uno necesitaría 2 minutos, pero el JOB B debería
esperar 2 minutos para ser ejecutado, la utilización de C.P.U. sería del 50%.
JOB A
|----|....|----|....|-| |-|.....|------|
START INPUT INPUT INPUT STOP JOB A
| .
19
______________________________
James L. Peterson.
| .
| JOB B .
| .
|-------------------------------------|----|.....|----|.....|-| |-|....|----|
WAITING START INPUT INPUT INPUT STOP
JOB B
EJECUCIÓN DE JOB A Y B SIN MULTIPROGRAMACIÓN
20
______________________________
James L. Peterson.
Si multiprogramamos A y B se puede subir enormemente la eficiencia, se puede ejecutar A por un

segundo y luego cuando espera por E/S, se ejecuta B por un segundo y así sucesivamente, de esta
forma sube el porcentaje de utilización de C.P.U. a un 100%.
Se debe notar que el JOB A no finalizaría antes, pero el JOB B finalizaría en casi la mitad del tiempo.
JOB A
|----|...../|\-----|...../|\-| |--|...../|\----|
STAR | E/S | | E/S | | E/S | STOP
| | | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
JOB B\ | / - - - - | . . . . . . \ | / - - - - | . . . . . . . \ | / - | | - | . . . . . \ | / - - - - - |
START E/S E/S E/S STOP
EJECUCIÓN DE LOS JOBS A Y B CON

MULTIPROGRAMACIÓN
Uno de los problemas tecnológico ha sido colocar un nombre a las actividades que cumple la C.P.U.
tipicamente un JOB BATCH es un proceso, y un proceso es un programa en ejecución, un programa
usuario en tiempo compartido es un proceso, una tarea del sistema, por ejemplo un spooling, es
llamado también un proceso.
En distintos S.O., los procesos pueden ser denominados JOBS, USUARIOS; PROGRAMAS,
TAREAS o ACTIVIDADES. Hoy en día, se ha generalizado el término proceso.
CICLOS RÁFAGAS DE C.P.U. - E/S

Los procesos de C.P.U. se ejecutan mediante un ciclo de ejecución de C.P.U. y espera de E/S.
Los procesos están alternados siempre entre estos estados , la ejecución de un proceso comienza
siempre con una ráfaga de C.P.U. y termina de la misma forma y entre ellas, pueden existir sucesivas
ráfagas de C.P.U. y de espera de E/S.
21
______________________________
James L. Peterson.
Por ejemplo:
LOAD
STORE
ADD > RÁFAGA DE C.P.U. (C.P.U. BURST)
STORE
READ FROM FILE
WAIT FOR I/O -------> RÁFAGA DE E/S (I/O BURST)
STORE
INCREMENT INDEX > RÁFAGA DE C.P.U. (C.P.U. BURST)
WRITE TO FILE
WAIT FOR I/O RÁFAGA DE E/S (I/O BURST)
LOAD
STORE
ADD RÁFAGA DE C.P.U. (C.P.U. BURST)
STORE
READ FROM FILE
WAIT FOR I/O RÁFAGA DE E/S (I/O BURST)
La duración de las ráfagas C.P.U. - E/S varían de proceso a proceso y de computador a computador,
pero tienden en general a tener una curva de frecuencia caracterizada por una exponencial.
160-
140-
120-
Frecuencia
40-
20-
0 | | | | |
8 16 24 32 40
Duración de Ráfaga
Se nota un gran número de pequeñas ráfagas de C.P.U. y un pequeños número de largas ráfagas.
22
______________________________
James L. Peterson.
Un programa limitado por E/S va a tener típicamente cortas ráfagas de C.P.U. y un programa limitado
por C.P.U., puede tener sólo algunas largas ráfagas de C.P.U., la distribución puede ser bastante
importante al seleccionar un algoritmo de iteración de C.P.U.
PROCESO: Es un programa en ejecución, cuando se ejecuta un programa, este pasa por varios
estados, el estado de un proceso va a estar definido por su actividad actual, como un proceso esta
alternativamente en frecuencias de ráfagas de C.P.U. y esperas de E/S; comenzando y terminando
con la ráfaga C.P.U. puede estar en uno de los siguientes estados:
- NUEVO. (NEW)
- ACTIVO. (ACTIVE)
- ESPERANDO. (WAITING)
- PARADO. (HALTED)
DIAGRAMA DE ESTADO DE PROCESO

NEW ACTIVE HALTED
COMPLETANDO E/S
WAITING
De hecho, estos estados pueden ser refinados a futuro, ya que la C.P.U. puede ser compartida por
varios procesos, un proceso activo puede estar esperando por la C.P.U. o ejecutandose, entonces un
proceso que está esperando por la C.P.U., se encuentra en un estado de Listo (REAADY), un proceso
que se está ejecutando se encuentra en un estado corriendo (RUN).
DIAGRAMAS DE ESTADOS DE PROCESOS REDEFINIDOS
NEW READY RUNNING HALTED
WAITING
BLOQUE DE CONTROL DE PROCESOS

23
______________________________
James L. Peterson.
Cada proceso es representado en el S. O. por su propio bloque de proceso (PCB), el que también es
llamado bloque de control de tareas o bloque de control de JOBS, este bloque es un bloque de datos o
registros conteniendo varias piezas de información asociadas con un proceso específico incluyendo:
- El estado del proceso (new, ready, running, waiting, halted)

- El program counter (PC), que indica la dirección de la próxima instrucción a ser ejecutado por este
proceso.
- Los registros de C.P.U., los cuales varían en número y tipo dependiendo de la arquitectura del
computador, incluyen acumuladores, registros, índices y registros de propósito general y cualquier
otra condición de proceso.
Cuando ocurre una interrupción debe ser salvada la información de estado para que posteriormente
pueda continuarse la ejecución del proceso sin dificultades.
- Cualquier información de administración de memoria, incluyendo registros bases, limites o tablas de

páginas.
- Cualquier información de cuenta, incluyendo el monto de C.P.U. y tiempo real usado, tiempos
límites, números de cuenta, número de JOB, o proceso y estadísticas generales.
- Información de iteración de C.P.U., incluyendo prioridades del proceso, punteros o colas de iteración
de C.P.U. y otros.
- información de estado de E/S, incluyendo peticiones de E/S, dispositivos E/S proporcionados a ese
proceso, lista de archivos abiertos etc.
El PCB debe ser almacenado en el área de memoria del S.O.
POINTER PROCESS STATE

PROCESS NUMBER
PROGRAM COUNTER BLOQUE DE CONTROL
REGISTERS DE PROCESOS
MEMORY LIMITS (PROCESS CONTROL BLOCK)
LIST OF OPEN FILES
. .
. .
. .
Los PCB deben ser almacenados en la memoria del monitor, esta memoria puede ser administrada de
varias formas, se puede tener como una aproximación al predeclarar el número máximo de procesos y
precolocarlos en forma estática para todos los PCBs.
Generalmente el número de PCB varía durante el tiempo, entonces la "POLÍTICA DE
ADMINISTRACIÓN DINÁMICA DE MEMORIA" podría ser la mejor.
El diseñador de sistema, debe considerar la flexibilidad extra y la posibilidad de la alta utilización de
memoria, con los algoritmos más complejos y el potencial de error y la sobre ubicación de memoria.
24
______________________________
James L. Peterson.
USER PROGRAM A OPERATING USER PROGRAM B

SYSTEM
EXECUTING INTERRUPT O SVC
SAVE REGISTERS
RELOAD REGISTERS _
|
EXECUTING
INTERRUPT O 2 SVC
SAVE REGISTERS __
RELOAD REGISTERS
EXECUTING
COLAS DE ITERACIÓN (SCHEDULING QUEUES)
El objetivo de la multiprogramación es tener procesos ejecutándose durante todo el tiempo, para

maximizar la utilización de la C.P.U. Para un sistema mono-procesador no habrá nunca más que la
ejecución de un solo proceso a la vez, si existen más procesos esperando ser ejecutados, deben esperar
hasta que la C.P.U. este lista y pueda ser entregada a otro proceso.
Los procesos que están listos y que esperan para ser ejecutados, se guardan en una lista llamada "Cola
de listos" (ready queue), ésta lista está generalmente unida mediante punteros, un elemento "cabeza de
la lista", contendrá punteros al primer y último PCB en la lista. Cada PCB tiene un campo puntero que
apunta al próximo proceso en la cola de listos.
QUEUE HEADER PCB7 PCB 2

HEAD REGISTERS REGISTERS
TAIL
25
______________________________
James L. Peterson.
Se debe notar que la cola de Listos no es necesariamente una cola FIFO (FIRST-IN.FIRST-OUT),
como las usadas en los textos de estructuras de datos, los algoritmos de iteración pueden ser aplicados
a la cola de Listos como una cola FIFO; una cola de prioridades, una fila o simplemente como una lista
no ordenada unida por punteros.
Sin embargo conceptualmente todos los procesos en la cola de listos están esperando una oportunidad
para ser ejecutados por la C.P.U.
QUEUE HEADER PCB 8 PCB 3
READY
QUEUE HEAD REGISTERS REGISTERS
TAIL
DISK
UNIT HEAD
TAIL
PCB 4
MAG. HEAD REGISTERS

TAPE TAIL
UNIT
26
______________________________
James L. Peterson.
COLA DE LISTOS Y VARIAS COLAS DE DISPOSITIVOS DE I/O

Cuando un proceso es colocado en C.P.U., ejecuta durante un tiempo y eventualmente se le quita el
control o espera por un requerimiento de E/S, este requerimiento puede ser a un terminal dedicado o a
un dispositivo compartido, por ejemplo: el disco; debido a que se encuentran varios procesos en el
sistema, el disco puede estar ocupado por los requerimientos de algún otro proceso, así el proceso
puede tener que esperar por el disco.
La lista de procesos esperando por un dispositivo particular se denomina COLA DE DISPOSITIVOS y
cada dispositivo tiene su propia cola, si el dispositivo es un dispositivo dedicado como un terminal de
tiempo compartido, entonces la cola de dispositivos correspondiente no tendrá más que un proceso en
él, si el dispositivo es compartible, entonces existe más de un proceso en la cola de dispositivo.
Una representación común para la iteración de colas es un diagrama de colas:
READY QUEUE
READY QUEUE C.P.U.
I/O QUEUE
I/O REPRESENTACIÓN DEL
DIAGRAMA DE COLAS DE
I/O E
I/O QUEUE ITERACIÓN DE C.P.U.
: :
I/O QUEUE
Cada rectángulo representa una cola y se presentan dos tipos de colas: de listos y un conjunto de colas
de dispositivos, los círculos representan los recursos que sirven las colas y las flechas indican el flujo
del proceso en el sistema, un proceso entra al sistema desde el exterior y es puesto en la cola de listos y
espera en esa cola hasta que es seleccionado por la C.P.U., después de correr o ejecutarse en la
C.P.U., espera por una E/S, siendo movido a la cola de E/S correspondiente, eventualmente es servido
por el dispositivo de E/S y retorna a la cola de listos, un proceso continua por este ciclo de E/S, C.P.U.
hasta que termina y sale del sistema.
Debido a que la principal preocupación del momento es la iteración de la C.P.U., los detalles de los
dispositivos de E/S serán reemplazados por una cola de E/S y servidores de E/S.
LONG-TERM SHORT-TERM END

COLA DE LISTOS
C.P.U
COLAS DE
E/S DISPOSITIVOS
ITINERADORES (SCHEDULERS)
27
______________________________
James L. Peterson.
Permite seleccionar un JOB de la cola de espera o cola de dispositivos. Un S.O. tiene muchos
ITINERADORES, existen dos itineradores principales de C.P.U.
1.- Schedulers de LONG-TERM o Schedulers de JOB, determina que JOBS son admitidos en el
sistema para ser procesados, en un sistema BATCH a menudo existen más JOBS o procesos
submitidos (submit) que pueden ser ejecutados inmediatamente, estos JOBS son spooleados
(almacenados en un dispositivo, normalmente un disco, donde son guardados para su ejecución
más tarde).
El Schedulers de Long-Term, selecciona procesos desde el spool de procesos y los carga en
memoria para su ejecución.
2.- Schedulers de SHORT-TERM. (Schedulers de C.P.U.)

Selecciona de entre los procesos en memoria, los que están listos para ser ejecutados y entrega la
C.P.U. a uno de ellos.
La diferencia principal entre estos dos itineradores es la frecuencia de su ejecución.
El Schedulers Short-Term, selecciona un nuevo proceso para la C.P.U., a menudo un proceso puede
ejecutarse sólo unos milísegundos antes de esperar por un requerimiento de E/S. A menudo el Short-
Term ejecuta cada 10 milísegundos, debido a la corta duración entre ejecuciones, el Schedulers Short-
Term debe ser muy rápido, si toma un milísegundo para decidir que proceso se va a ejecutar por 10
milísegundos, entonces 1/(10 + 1) = 9% de la C.P.U. está siendo usada o malgastada para la
itineración de los JOBS.
El Schedulers Short-Term, por otra parte, se ejecuta menos frecuentemente, pueden pasar minutos
entre las llegadas de nuevos JOBS en el sistema.
El Schedulers controla el grado de la multiprogramación, (números de procesos en memoria). Si el

grado de multiprogramación "es estable", entonces la velocidad de llegada promedio de entradas de
JOBS al sistema debe ser igual a la velocidad de partida promedio de salidas de JOBS del sistema,
entonces el itinerador Long-Term puede sólo ser necesitado o invocado cuando un JOB deja el
sistema.
Debido a los largos intervalos entre ejecuciones, el Schedulers Long-Term puede tomar más tiempo
para decidir que JOB debe ser seleccionado para su ejecución, también debe ser importante que el
itinerador Long-Term realice una selección cuidadosa, en general los JOBS pueden ser descritos como
ráfagas de E/S o ráfagas de C.P.U.
Si todos los JOBS o procesos son ráfagas de E/S la cola de listos estará casi siempre vacía y el
Schedulers de Short-Term tendrá poco que hacer.
Si todos los JOBS o procesos son del tipo ráfagas de C.P.U., la cola de espera por E/S estará casi
siempre vacía y nuevamente se tendría desvalanciado al sistema.
El sistema con la mejor performance, tendrá una combinación de procesos de tipo ráfagas de C.P.U. y
de tipo de ráfagas de E/S, en algunos sistemas el Schedulers Long-Term puede estar ausente o ser
mínimo, por ejemplo:
En un sistema de tiempo compartido a menudo no existe itinerador Long-Term, porque cada nuevo
proceso será puesto en memoria por el itinerador Short-Term.
28
______________________________
James L. Peterson.
La estabilidad de estos sistemas depende tanto de una limitación física, tales como un número limitado
de terminales disponibles o la naturaleza de auto-ajuste de los usuarios, si la performance es también
mala, algunos usuarios abandonan el sistema y buscan algo diferente, algunos sistemas, especialmente
los con memoria virtual o tiempo compartido pueden introducir un nivel intermedio adicional de
itineración, éste itinerador se denomina MEDIUM-TERM.
La idea clave de la conducta de un itinerador MEDIUM-TERM, es que puede algunas veces ser
ventajoso remover procesos desde la memoria y así reducir el grado de multiprogramación, en algunos
casos, el proceso se encuentra re-introducido en memoria y continúa desde el punto en que se
encontraba cuando le fue quitado el control.
Este esquema es llamado Swapping, el proceso es Swap-Out y Swap-in, es decir, es sacado de la

memoria y luego introducido mediante el itinerador MEDIUM-TERM. El Swapping puede ser
necesario para lograr la mezcla apropiada de JOBS o porque un cambio en los requerimientos de
memoria la a ocupado totalmente, requiriendo memoria libre rápidamente.
Otro componente involucrado es el despachador en la función de Schedulers de la C.P.U. El

despachador es el módulo que actualmente da u otorga el control de la C.P.U. al proceso seleccionado
por el itinerador Short-Term.
Esta función involucra la carga de los registros del proceso cambiando a modo usuario y saltando a la
ubicación apropiada en el programa usuario para su ejecución, obviamente el despachador debe ser tan
rápido como sea posible.
SWAP IN MEDIUM-TERM SWAP OUT

PARTIALLY EXECUTED
SWAPPED OUT PROCESSES
LONG-TERM SHORT-TERM END

READY QUEUE
I/O WAITING
QUEUES
29
______________________________
James L. Peterson.
ALGORITMOS DE SCHEDULING
La itineración de la C.P.U. tiene relación con el problema de decidir cual de los procesos en la
READY QUEUE va a ser ubicado en la C.P.U.
CRITERIOS DE PERFORMANCE
Diferentes algoritmos tienen diferentes prioridades y pueden favorecer una clase de procesos sobre
otros. Al elegir un algoritmo para una situación en particular, deben ser consideradas las propiedades
de los algoritmos, los criterios básicos que se han sugerido para comparar los algoritmos de itineración
de C.P.U. son:
- UTILIZACIÓN DE C.P.U.: Cuando la C.P.U. es cara, se desea mantenerla tan ocupada como
sea posible. La utilización de la C.P.U. puede promediarse de un 0% a un 100%, en un sistema
real debería promediarse en un 40% (cargado levemente) y un 90% (cargado completamente).
- THROUGHPUT: Si la C.P.U. está ocupada, entonces el trabajo está siendo realizado. Una
medida de trabajo es el número de JOBS, que están terminados en una unidad de tiempo específica,
llamado Throughput.
Para JOBS largos, esta medida puede ser un JOB por hora, para transacciones cortas, el Throughput
sería de 10 JOBs por segundo.
- TURNAROUND TIME: Desde el punto de vista de un JOB en particular, el criterio importante

es cuanto tiempo toma ejecutar ese JOB, el intervalo desde que es submitido hasta el tiempo de
término es llamado Turnaround Time. Esto es, la suma de los períodos gastados en cargar en la
memoria, espera en la Ready Queue, ejecución por la C.P.U. y E/S.
- WAITING TIME: El tiempo que gasta el algoritmo de itineración de C.P.U. en seleccionar un

proceso desde la ready queue, no afecta a la cantidad de tiempo total de ejecución de un JOB, así
más que mirar el Turnaround Time, se observa el tiempo de espera que tiene cada JOB antes de ser
seleccionado para ejecutarse.
- RESPONSE TIME: En un sistema interactivo, el Turnaround Time no es el mejor criterio para

medir el tiempo de respuesta. A menudo un proceso puede producir algunas salidas correctas al
comienzo y puede continuar calculando nuevos resultados, mientras que los resultados previos
están siendo mostrados en el terminal.
Así, otra medida es el tiempo de la submisión de un requerimiento hasta que la primera respuesta
es producida, esta medida, llamada tiempo de respuesta es la cantidad de tiempo en que comienza
a responder, y no el tiempo en que demora en responder.
El Turnaround Time es generalmente limitado por la velocidad de salida del dispositivo.
30
______________________________
James L. Peterson.
FIRST-COME-FIRST-SERVED
Este es el más simple de los algoritmos de itineración de C.P.U. Esto es, el primer proceso que espera
por la C.P.U. es el primero en ejecutarse, la implementación de F.C.F.S. es fácilmente manejada con
una cola FIFO. Cuando un proceso ingresa a la Ready Queue, el PCB es anexado al final de la lista.
Cuando la C.P.U. está libre, es utilizada por el proceso ubicado en la cabeza de la Ready Queue. El
proceso ejecutado es entonces removido desde la Ready Queue. La codificación para implementar el
itinerador F.C.F.S. es simple tanto para escribirlo como para entenderlo.
La performance del F.C.F.S., es a menudo muy mala. Considere los siguientes tres JOBS.
Para cada JOB, asuma que conoce el largo de la ráfaga de C.P.U. entonces puede calcular el promedio
del Turnaround Time con estas tres ráfagas de C.P.U.
JOB BURST TIME

1 24
2 3
3 3
A) Si el orden de llegada es: 1, 2, 3
JOB1 JOB2 JOB3

0 24 27 30
El Turnaround Time para el JOB1 es 24, para el JOB2 es 27, y para el JOB3 es 30, y el promedio del
Turnaround Time es (24 + 27 + 30)/3 = 27.
El Waiting Time para el JOB1 es 0, para el JOB2 es 24, y para el JOB3 es 27, y el promedio
del Waiting Time es (0 + 24 + 27)/3 =17
B) Si el orden de llegada es: 2, 3, 1
JOB2 JOB3 JOB1

0 3 6 30
El promedio del Turnaround Time es (30 + 3 + 6)/3 = 13 (una reducción sustancial). Y el promedio
del Waiting Time es (0 + 3 + 6)/3 = 3.
Así el promedio del Turnaround Time para F.C.F.S. generalmente no es mínimo y puede variar
sustancialmente dependiendo del orden de llegada de los procesos y de sus ráfagas
En conclusión, considere la performance del F.C.F.S. en una situación dinámica. Asuma que tiene un
JOB para la C.P.U. y muchos JOB para I/O, así como los JOBs giran alrededor del sistema, el
siguiente escenario puede resultar, el JOB que está en la C.P.U. se ejecutará, durante todo este tiempo
y todos los otros JOBS terminaran su I/O y se moverán dentro de la Ready Queue, esperando por la
C.P.U. Mientras ellos esperan, los dispositivos de I/O están ociosos. Eventualmente el JOB en la
C.P.U. finalizará su ráfaga de C.P.U. y comenzará su ráfaga de I/O. Todos los JOBs que están en la
Ready Queue, los cuales tienen muy cortas ráfagas de C.P.U, se ejecutan rápidamente y van
31
______________________________
James L. Peterson.
nuevamente a las colas de dispositivos.

En este punto la C.P.U. está ociosa, el JOB de la C.P.U. volverá a la Ready Queue otra vez, todos los
procesos que están en I/O terminaran y ahora se encuentran esperando en la Ready Queue hasta que la
C.P.U. este desocupada. Hay un efecto Convoy (CONVOY EFFECT) para todos los otros procesos
que esperan que la C.P.U. se libere del otro proceso.
SHORTEST-JOB-FIRST
Un enfoque diferente aplica el itinerador SHORTEST-JOB-FIRST (S.J.F.), asocia con cada JOB el
largo de la próxima ráfaga de C.P.U. y cuando la C.P.U. está disponible, ésta es asignada al JOB con
la próxima ráfaga más pequeña Ejemplo:
JOB BURST TIME

1 6
2 3
3 8
4 7
Usando S.J.F. los JOBs se ejecutarán de la siguiente forma:
JOB2 JOB1 JOB4 JOB3

0 3 9 16 24
El promedio Turnaround Time es 13.
La real dificultad con S.F.J. es conocer el largo de la próxima ráfaga de C.P.U. El itinerador de JOB
en un sistema BATCH puede usar el tiempo límite del JOB, para el itinerador de C.P.U., éste
algoritmo es imposible de implementar.
PRIORIDAD
El itinerador S.J.F. es un caso especial del itinerador de prioridad. Una prioridad está asociada con
cada proceso, y la C.P.U. es asignado al JOB que tiene mayor prioridad, los JOBs con igual prioridad
son itinerados por F.C.F.S.
Un itinerador S.J.F. es simplemente un algoritmo de itineración de prioridad donde la prioridad (P) es

el inverso de la próxima ráfaga (T) de C.P.U. (predecida), por lo tanto P = 1/T.
32
______________________________
James L. Peterson.
La próxima ráfaga de C.P.U. es generalmente predecida basándose en un promedio exponencial de las

longitudes medidas de las ráfagas de C.P.U. anteriores.
Sea tn el largo de las n ráfagas de C.P.U. y Tn será el valor predecido para las n ráfagas de C.P.U. y
sea L, 0 < = L < = 1, entonces:
Tn - 1 = Ltn + (1 - L)Tn
Esta fórmula define un promedio exponencial. El valor de tn contiene la más reciente información; Tn
contiene el historial. El parámetro L controla el peso relativo de la reciente e histórica predicción.
Si L = 0 entonces Tn + 1 = Tn y la historia reciente no es afectada; si L = 1, entonces Tn + 1 = tn y
sólo mantiene la más reciente ráfaga de C.P.U.
Las prioridades son generalmente un rango de números, tal como de 0 hasta 7 ó 0 a 4095, sin embargo
no existe una asignación general, el 0 puede ser una alta o baja prioridad dependiendo del sistema.
Las prioridades pueden ser definidas en forma interna o externa. Internamente las prioridades derivan
de medidas cuantitativas para definir la prioridad de un proceso. Por ejemplo: Límites de tiempo,
requerimientos de memoria, números de archivos abiertos, velocidad promedio de ráfagas I/O para el
promedio de ráfagas de C.P.U. que han sido usadas en el cálculo de prioridades.
Externamente las prioridades son definidas por criterios que son externos al sistema operativo,
ejemplo: políticas empresariales, uso del computador, etc.
Un problema del itinerador de prioridades es el bloqueo infinito o "STARVATION", un proceso que

está listo para ejecutarse no puede por su prioridad, y la C.P.U. puede ser considerada bloqueada al
esperar por ésta, es decir, el itinerador puede mantener algunos procesos esperando infinitamente por
la C.P.U., por sus bajas prioridades.
Una solución al problema del starvation de los procesos de baja prioridad en la técnica "AGING", que
gradualmente incrementa la prioridad de los procesos que están en el sistema por mucho tiempo, por
ejemplo:
Si el rango de prioridades va de 0 (baja) a 127 (alta) la prioridad de un proceso podría incrementarse en

1 cada 15 minutos. Por lo tanto, un proceso de prioridad 0 no demoraría más que 32 horas
aproximadamente en ejecutarse.
PREEMPTIVE (PREVACIADO)
F.C.F.S., S.J.F. y prioridad son itineradores no-preemptive, cuando la C.P.U. ha sido asignada a algún
proceso, puede ocuparla hasta que desee liberarla por término del proceso o por solicitud de
requerimientos de I/O; F.C.F.S. es netamente no-preemptive, pero los otros dos pueden ser
modificados para ser itineradores preemptives.
S.J.F. puede ser preemptive o no preemptive, la idea radica cuando un nuevo JOB entra en la Ready
Queue, mientras que un JOB previo está ejecutándose y el nuevo JOB podría ser más corto del que se
está ejecutándose, un itinerador preemptive S.J.F. removerá el JOB que se está ejecutándose, mientras
que un itinerador no preemptive S.J.F. seguirá ejecutando el JOB hasta que finalice la ráfaga de
C.P.U. El itinerador prioridad también puede ser preemptive o no preemptive.
33
______________________________
James L. Peterson.
Cuando un proceso entra a la Ready Queue (como resultado de un previo requerimiento de I/O) la
prioridad es comparada con el del JOB que esta siendo ejecutado.
Un itinerador preemptive de prioridad removerá el JOB que se está ejecutándose, si la prioridad del
nuevo JOB (en la Ready Queue) es mayor.
Un itinerador no preemptive (especialmente FCFS) está particularmente hecho para sistemas de tiempo
compartido, en estos sistemas es muy importante que cada usuario obtenga o comparta la C.P.U. a
intervalos regulares.
Ejemplo: SJF
JOB ARRIVAL TIME BURST TIME

1 0 8
2 1 4
3 2 9
4 3 5
Preemption
JOB 1 JOB 2 JOB 4 JOB 1 JOB 3

0 1 5 10 17 26
El JOB 1 comenzó en el tiempo 0, es el único en la Ready Queue, el JOB 2 llega en el tiempo 1, y el

tiempo remanente para el JOB 1 es más largo que el tiempo requerido por el JOB 2 (7 unidades tiempo
v/s 4 unidades de tiempo) por lo tanto el JOB 1 es preempted y el JOB 2 es ejecutado.
El promedio del Turnaround Time es 52/4 = 13 y en un no-preemptive S.J.F. resultará un promedio

de 14,25.
ROUND-ROBIN
El itinerador Round-Robin está diseñado especialmente para sistemas de tiempo compartido. Una
pequeña unidad de tiempo llamada "QUANTUM" o tiempo de movimiento se define. El tiempo del
Quantum es generalmente de 10 a 100 milisegundos. La Ready Queue es tratada como una cola
circular. La itineración de la C.P.U. va en torno a la Ready Queue, asignando la C.P.U. a cada
proceso por un intervalo de tiempo definido por el largo del Quantum.
Para implementar el itinerador Round-Robin la Ready Queue es manejada como una cola FIFO, los
procesos nuevos son agregados al final de Ready Queue. El Schedulers de la C.P.U. toma el primer
JOB desde la Ready Queue, setea el Timer para interrumpir la ejecución del JOB en el tiempo definido
por el Quantum y despacha el proceso, una de dos cosas entonces ocurrirá.
34
______________________________
James L. Peterson.
a) El proceso puede tener la ráfaga de C.P.U. menor que el tiempo de Quantum, en este caso, el
proceso liberará a la C.P.U. en forma voluntaria al emitir un requerimiento de I/O o de
finalización, entonces será reemplazado por el próximo JOB de la Ready Queue.
b) Si la ráfaga de C.P.U. es mayor que el tiempo de Quantum, el Timer causará la interrupción al

sistema operativo. Los registros del proceso interrumpido serán grabados en el PCB
correspondiente y el proceso o JOB será puesto al final de la Ready Queue.
Por ejemplo:
JOB BURST TIME

1 24
2 3
3 3
Si el Quantum es de 4 el resultado del itinerador Round-Robin es:
JOB 1 JOB 2 JOB 3 JOB 1 JOB 1 JOB 1 JOB 1 JOB 1

0 4 7 10 14 18 22 26 30
El JOB 1 obtiene las cuatro primeras unidades de tiempo, ya que este requiere otros 20, es removido
después del primer Quantum y la C.P.U. es dada al próximo JOB en la cola (JOB 2), éste no necesita
las 4 unidades de tiempo del Quantum y termina antes que termine el Quantum; la C.P.U. es dada
entonces al próximo proceso (JOB 3). .... El promedio del Turnaround Time es 47/3 = 16.
El itinerador Round-Robin es un itinerador preemptive.
Si hay n procesos en la Ready Queue y el tiempo del Quantum es q, entonces cada proceso obtiene 1/n
del tiempo de la C.P.U. en trozos de a lo más q unidades de tiempo. Cada proceso debe esperar no
más que (n - 1) *q unidades de tiempo hasta el próximo Quantum.
Ejemplo : Si existen 5 procesos, con un Quantum de 20 milisegundos, entonces cada proceso
obtendría hasta 20 milisegundos cada cien milisegundos.
La performance del itinerador Round-Robin dependerá del tiempo del Quantum.
Como caso extremo, si el tiempo del Quantum es muy grande (infinito), el Round-Robin es igual al
FCFS, si el tiempo del Quantum es muy pequeño (por decir un microsegundo) el Round-Robin es
llamado procesador compartido y aparece (en teoría) como si de cada n procesos tuviesen su propio
procesador ejecutándose a una velocidad de 1/n del proceso real.
35
______________________________
James L. Peterson.
MULTI-LEVEL QUEUES
Otra clase de itineradores han sido creados para situaciones en que los JOBs son clasificados en
diferentes grupos, por ejemplo una división común es hecha entre JOBs foreground (interactivos) y
JOBs background (batch).
Estos dos tipos de JOBs tienen diferentes tiempos de respuestas y podrían tener diferentes itineradores,
generalmente basado sobre las propiedades del JOB, como largo de memoria o tipo de JOB. Cada cola
tiene su propio itinerador.
Por ejemplo, colas separadas podrían ser usadas para JOBs foreground y JOBs background.
La queue foreground podría ser itinerada por Round-Robin, mientras que la cola background podría ser
itinerada por FCFS.
Alta prioridad.
TAREAS DEL SISTEMA
INTERACTIVOS
EDICION
BATCH
Baja prioridad.
MULTI -LEVEL FEEDBACK QUEUE
Normalmente en una multi-queue los JOBs son permanentemente asignados a una cola específica del
sistema y no se mueven entre colas.
El itinerador Multi-Level Feedback Queue, mueve los JOBs entre colas; la idea es separar los JOBs
con diferentes características de ráfagas de C.P.U.. Si un JOB usa demasiado tiempo la C.P.U.,
entonces se moverá a una cola de baja prioridad, similarmente un JOB que espera demasiado tiempo
en una cola de baja prioridad será movido a una cola de alta prioridad.
36
______________________________
James L. Peterson.
Por ejemplo, considere una Multi-Level Feedback Queue con tres colas numeradas de 0 a 2, el
itinerador, primero ejecutará todos los JOB en la cola 0, sólo cuando la cola 0 esté vacía ejecutará los
JOBs en la cola 1, similarmente, los JOBs de la cola 2 sólo se ejecutaran sí la cola 0 y la cola 1 están
vacías. Un JOB que llega para la cola 1 será ejecutado y el JOB de la cola 2 será removido desde la
C.P.U..
Un JOB al ingresar al sistema es puesto en la ready queue, desde allí es puesto en la cola 0, un JOB en
la cola 0 tiene un quantum de 8 milisegundos, si no ha finalizado entre éste tiempo, es movido al final
de la cola 1. Si la cola 0 esta vacía, el JOB que está en la cabeza de la cola 1 le es dado un quantum de
16 milisegundos,, si este no es completado entonces es removido y puesto en la cola 2.
Los JOBs en la cola 2 son ejecutados por FCFS sólo y cuando las colas 0 y 1 estén vacías.
QUANTUM = 8
QUANTUM = 16
FCFS
En general una MQF, esta definida por los siguientes parámetros:
- El número de colas.
- El itinerador para cada Queue.
- Un método para determinar cuando cambiar un JOB a una Queue más alta.
- Un método para determinar cuando cambiar un JOB a una Queue más baja.
- Un método para determinar a que Queue un JOB ingresará cuando necesite servicio.
37
______________________________
James L. Peterson.
EVALUACIÓN DE ALGORITMOS
¿Cómo seleccionar un algoritmo de itineración de C.P.U. en particular?
Existen muchos algoritmos donde cada uno posee sus propios parámetros, por lo tanto la elección
puede ser muy difícil.
El primer problema es definir el criterio a usar en esta selección, los criterios son definidos a menudo
en términos de utilización de C.P.U., tiempo de respuestas, Throughput, etc.
Para seleccionar un algoritmo primero debe ser definido:
- La importancia relativa de éstas medidas, por ejemplo:
* Maximizar la utilización de C.P.U., considerando que el tiempo máximo de respuesta es

de 4 segundos.
* Maximizar el Throughput tal que el tiempo de permanencia en promedio sea linealmente

proporcional al tiempo total de ejecución.
Una vez que el criterio de selección ha sido definido, se debe evaluar los diferentes algoritmos.
EVALUACIÓN ANALÍTICA
Este método toma el algoritmo y el sistema funcionando para producir una fórmula o un valor que
permita evaluar el algoritmo para un JOB específico.
EVALUACIÓN DETERMINISTICA
Un tipo de evaluación analítica es la modelación determinística de la performance de cada algoritmo,

por ejemplo:
Asuma que se tiene los siguientes JOBs:
5 procesos que llegan en tiempo 0 y en un orden dado
PROCESOS TIEMPO DE RÁFAGAS

1 10
2 29
3 03
4 07
5 12
38
______________________________
James L. Peterson.
Considerando los itineradores FCFS, SJF, y R_R (Quantum = 10), para este conjunto de procesos,
¿Cuál algoritmo dará el mínimo tiempo de espera?
Ejercicios:
1. Asuma que tiene los siguientes procesos para ejecución y que llegan en el orden dado:
PROCESO RÁFAGA PRIORIDAD

1 10 3
2 1 1
3 2 3
4 1 4
5 5 2
Desarrolle una carta gantt ilustrando la ejecución de estos procesos, usando los algoritmos FCFS, R-R
(Q=1), SJF y un algoritmo de prioridad no preemptive.
a) ¿Cuál es el tiempo de permanencia de cada uno de los procesos para cada algoritmo?
b) ¿Cuál es el tiempo de espera para cada proceso con cada uno de los algoritmos?
c) ¿Cuál es el itinerador con el menor tiempo promedio de espera y permanencia?
39
______________________________
James L. Peterson.
ADMINISTRADORES DE MEMORIA
En este capitulo se discutirán diversos administradores de memoria comenzando por los más
primitivos, máquina desnuda hasta llegar a la estrategia de paginación y segmentación. Cada
administrador tiene sus propias ventajas y desventajas.
INTRODUCCIÓN
La memoria es central en la operación de un moderno sistema computacional. Según se muestra en la

fig. 1, C.P.U. y sistema de E/S interactuan con la memoria. La Memoria es un gran arreglo de
palabras o bytes c/u con su propia dirección. La interrelación se logra mediante una secuencia de
lectura y escritura en direcciones específicas de ésta. La C.P.U. busca y trae desde y hacia la
memoria. Una típica ejecución de un ciclo de instrucción, por ej., primero busca y trae una instrucción
desde memoria y entonces computa una dirección efectiva a accesar. Este ciclo se repite para próxima
instrucción.
MEMORIA SISTEMA
E/S
Fig. 1 Naturaleza central de la memoria en un sistema computacional
Un programa debe ser cargado en memoria para ser ejecutado, el procedimiento normal es cargar un
programa en memoria, tal vez reubicar direcciones de programa o enlazar referencias externas si es
necesario. Cuando el programa se ejecuta se accesan sus instrucciones y datos desde memoria.
La selección de un administrador de memoria para un sistema específico depende de muchos factores,

pero especialmente del diseño de hardware del sistema. Como se verá cada algoritmo requiere su
propio soporte de hardware.
MÁQUINA DESNUDA (BARE MACHINE)
Por supuesto que el más simple esquema de administrador de memoria es ninguno. Se proporciona al
usuario la máquina vacía y tiene el completo control sobre todo el espacio de memoria. (Fig.2).
Este esquema tiene ventajas, provee la máxima flexibilidad para el usuario el cual puede controlar el
uso de la memoria de la forma que desee. Es de máxima simplicidad y de costo mínimo, no necesita
hardware especial.
Sus limitaciones son también definidas: no proporciona servicios, no hay S.O. que maneje
interrupciones, no hay monitor que maneje llamadas al sistema o errores y no hay secuenciación de
trabajos. Este esquema es generalmente usado sólo en sistemas dedicados.
0
USUARIO
40
______________________________
James L. Peterson.
32K Fig. 2 Máquina desnuda.

MONITOR RESIDENTE.
El esquema que sigue en simplicidad es dividir la memoria en dos secciones: una para el usuario y
otra para el monitor en la parte más baja o más alta de la memoria. El factor que afecta esta decisión
es la ubicación de los vectores de interrupción y traps. Lo más común es colocarlo en las posiciones
menores, es el esquema más usado en microcomputadores hoy en día.
Hardware de Protección.
Se necesita proteger el área del monitor de cambios (ya sea accidentales o maliciosos), por parte del
programa usuario. Esta protección debe ser proporcionada por el hardware y puede ser lograda de
distintas formas, lo más gral. (Fig. 4) es que cada dirección (de instrucción o dato) generada por el
programa usuario es comparada con la dirección Defensa. Si la dirección generada es mayor o igual a
la defensa entonces es legítima y se envía a memoria. Si la dirección generada es menor que la
defensa es una referencia ilegal, la cual se intercepta y envía un traps al S.O. el que toma la acción
adecuada (aborta el programa con un mensaje de error apropiado y un vaciado de memoria). Note que
cada referencia a memoria debe ser chequeada lo que hace muy lento el acceso a memoria, cada
referencia puede tomar por ejemplo 995 nanosegundos en vez de 980. Cuidadosos diseños de circuitos
pueden a menudo traslapar esta comparación con otras actividades para reducir el tiempo efectivo de
acceso. Generalmente el S.O. tiene acceso permitido a toda la memoria lo que le permite cargar
programas usuarios, sacar vaciados, etc. La mayor diferencia en los sistemas computacionales es la
manera en que se especifica la defensa.
0
REG. DEFENSA MONITOR
USUARIO
Desperdiciada.
32K
Fig.3 Monitor Residente.
Dirección Defensa
Direcciòn Dir Verdadero

>= Memoria
Defensa
Falso
Trap, final de direccionamiento
41
______________________________
James L. Peterson.
Fig. 4 . Protección de direcciones de hardware para un monitor residente.
En HP 2116B el cargador básico binario fue almacenado en ubicaciones 77700 a 77777 (lo más alto
en una máquina de 32K). Durante la ejecución del programa usuario no es posible accesar una
ubicación sobre la 77700, el valor de defensa fue construido en el hardware.
Este valor construido en el hardware tiene una gran desventaja y es que, al efectuar cambios en el
monitor este puede ampliarse y quedará desprotegido y si se comprimiese habría memoria desocupada
inutilizable por el usuario, es decir, el valor correcto ahora, podría no serlo mañana. Para resolver este
problema se usa comúnmente un "registro defensa" el que contiene la dirección de la defensa, el que
puede ser cargado por el S.O. usando una instrucción privilegiada. El registro defensa puede
solamente ser cargado por un programa ejecutado en modo monitor.
Reubicación.
Otro problema a considerar es la carga del programa usuario. Aunque el espacio de dirección del
computador comienza en 00000, la primera dirección del usuario no es 00000 sino la primera
dirección después de la defensa.
Este arreglo afecta las direcciones que el programa usuario puede usar. En la mayoría de los casos un
programa usuario puede ser dividido en varios pasos a medida que va siendo ejecutado.
Programa Módulo Módulo de

Fuente Objeto Carga En
Compilador Linkage Cargador Memoria:
o Ensambl. Editor Imagen
Tiempo de Compilación Tiempo de carga
Tiempo de Ejecución
Fig. 5. Múltiples pasos de procesamiento para un programa usuario.
Clásicamente la "faja" de instrucciones y datos pueden tener direcciones de memoria en cualquier

paso. Si la dirección de defensa es conocida al tiempo de compilación, puede ser generado un código
"absoluto", éste código comienza desde la defensa y desde allí se extiende. Si el valor de la defensa
cambia con posterioridad, será necesario recompilar con ese código. Como una alternativa el
compilador puede generar un código "reubicable". En este caso la faja es detenida hasta el tiempo de
carga. Si el valor de la dirección de defensa cambia, el código del usuario necesita ser solamente
recargado incorporando este cambio de valor.
En ambos casos, sin embargo, la defensa debe ser estática durante la ejecución de un programa. Hay
casos donde es deseable cambiar el tamaño del monitor durante la ejecución de un programa. Por
ejemplo, el monitor contiene programa y espacio de buffer para manejadores de dispositivos. Si un
manejador de dispositivos (u otros programas del servicio de S.O.) no es comúnmente usado, es mejor
tener ese espacio para uso del usuario. Estos programas son llamados transientes. Esto hace que
cambie el tamaño del monitor durante la ejecución de un programa.
Hay dos formas de modificar el esquema básico para permitir que el tamaño del monitor cambie
dinámicamente. Un S.O. primitivo PDP 11 (fig. 6) cargaba el programa usuario en las posiciones más
42
______________________________
James L. Peterson.
altas de memoria y el monitor en las más bajas. Al centro quedaba un espacio sin uso, el cual podía
ser utilizado por el monitor o por el usuario.
0
Monitor Fig. 6 Cargando al usuario en memoria superior
Defensa
Usuario 64K.
Una forma más general es la utilizada en CDC 6600 (fig. 7) el cual detenía el direccionamiento de la
faja hasta el tiempo de ejecución. Esta reubicación dinámica requiere de un soporte extra de hardware.
El registro de la defensa es llamado ahora "registro de reubicación". El valor del registro base es
sumado a cada dirección generada por el proceso usuario al tiempo de ser enviado a memoria. Por
ejemplo, si la defensa vale 1400 entonces un intento de ubicar la dirección 0 es dinámicamente
reubicada en la dirección 1400, un acceso a la dirección 346 es ubicada en la 1746.
Registro Base
1400
Dir. Lógica Dir. Fisica Memoria

0346 + 1746
Fig. 7. Reubicación dinámica usando un registro de reubicación.
Note que el usuario no percibe la dirección física "real". El programa usuario trabaja con direcciones
"lógicas". El "hardware de mapeo de memoria" convierte direcciones lógicas a físicas.
Para este hardware, un cambio en la defensa requiere sólo cambiar el registro base y "mover" toda la
memoria del usuario a la ubicación relativa correcta según el nuevo valor de defensa. Este esquema
puede significar un monto significativo de memoria a ser copiado pero permite que la defensa sea
cambiada en cualquier momento.
Ahora se tiene dos tipos diferentes de direcciones: "lógicas" (en el rango 0 a máx) y "físicas" (rango
R + 0 a R + máx, donde R = valor defensa). El usuario genera sólo ubicaciones lógicas, toda
información pasada del programa usuario al S.O. (tal como la dirección de buffer en una llamada al
sistema) debe ser explícitamente reubicada por el S.O. Es necesario que las direcciones lógicas
entregadas por el usuario sean mapeadas en direcciones físicas antes de ser usada.
SWAPPING
43
______________________________
James L. Peterson.
El esquema anteriormente visto puede parecer de uso muy reducido, ya que aparece como mono-
usuario. Sin embargo, es el esquema básico utilizado en dos sistemas primitivos de tiempo
compartido: CTSS y Q-32, estos sistemas usaban un monitor residente, y el resto de la memoria era
utilizada por programas usuarios ejecutándose. Cuando se cambiaba al próximo usuario, el contenido
actual de la memoria era escrito en una memoria de refuerzo y la memoria es leída entonces, para el
próximo usuario. Este esquema es llamado "Swapping".
Defensa Monitor Usuario

Swap out
1 Usuario
Espacio Swap in
2
Usuario
Memoria Principal Memoria de Refuerzo
Fig. 8. Swapping de dos usuarios usando un disco como memoria Secundaria o Refuerzo.
Almacenamiento Secundario.
Swapping requiere de almacenamiento secundario el que comúnmente es un disco. Debe ser

suficientemente grande para almacenar copias de todas las imágenes de memoria para todos los
usuarios y debe proporcionar acceso directo a esas imágenes de memoria. La cola de listos está
compuesta de todos los procesos cuyas imágenes de memoria están en el almacenamiento secundario
y estén listos para ejecutarse. Una variable del sistema indicará que proceso está actualmente en
memoria.
Cuando el itinerador de C.P.U. decide ejecutar un proceso, llama al despachador, el cual verifica si el
proceso esta en memoria, si no es así, saca el trabajo que está actualmente en memoria y carga el
deseado. Entonces vuelve a cargar los registros y transfiere el control al proceso seleccionado.
Tiempo de Swap.
El tiempo de cambio de contexto debe ser mínimo, por ejemplo:
Se tiene un programa usuario de 20K y el almacenamiento secundario es un disco con un promedio de

acceso de 8 mls, (tiempo de búsqueda 5 mls y tiempo latencia de 3 mls), y una tasa de transferencia de
250.000 palabras por segundo, entonces una transferencia desde o hacia la memoria tomaría:
8 mls + (20 Kpal/250.000 pal/seg.) = 8 + (2/25) seg.

= 8 + (2000/25) mls
= 88 mls.
44
______________________________
James L. Peterson.
Si se piensa en llevada y traída, se tiene alrededor de 176 mls. En un caso como el ejemplo anterior el
quantum de tiempo proporcionado por la C.P.U. debe ser sustancialmente mayor que 0.176 segundos.
El tiempo total de transferencia es directamente proporcional a la cantidad de memoria intercambiada.
En un sistema de 32K con un monitor de 12K podría haber un programa de 20K o tal vez 5 de 4K. El
intercambio de 4K sólo toma 24 mls. Podría incrementarse la efectividad del sistema si se supiera que
parte del programa usuario es la realmente necesaria y efectuar el intercambio de esa parte solamente.
Otra forma de incrementar la eficiencia es contar con rápidas memorias secundarias, por ejemplo:
LCS (Large Core Image) de IBM tiene un tiempo de acceso de 8 microsegundos y una trasferencia de
400.000 pal/seg. Se puede intercambiar 20K en 50 mls.
Otra forma de reducción de este tiempo, es intentar traslapar el intercambio con la ejecución del
programa (fig. 9). El objetivo es traslapar el intercambio de un proceso con la ejecución de otro, esto
es, que la C.P.U. no este ociosa mientras ocurra el intercambio. Mientras un programa usuario es
ejecutado, el anterior se envía fuera desde el buffer 1 y el próximo se trae al buffer 2.
Se debe notar que una vez que la C.P.U. vaya a trabajar con el próximo proceso, debería cambiar el
programa que está en el buffer 2 al área de usuario o tal vez se podría cambiar la defensa (fig. 10), pero
se tendría al usuario anterior expuesto a modificaciones impropias por parte del programa usuario
actualmente en ejecución, por lo tanto es necesario efectuar un intercambio de memoria a memoria.
Espacio Monitor Monitor Usuario

1
Buffer 1
Usuario
Defensa Buffer 2
2
Usuario Ejecutando
Fig. 9. Intercambio traslapado.
Monitor
Buffer 1 Defensa
Buffer 2
Usuario Anterior
Fig. 10. Intento de ejecutar un programa moviendo la defensa.
Este método no siempre es bueno, por ejemplo al usar un sistema específico podría llegarse a que el
tiempo de transferencia es prácticamente igual a la velocidad de memoria y por lo tanto no es posible
45
______________________________
James L. Peterson.
el traslape entre C.P.U. y Swapping.
Existen otras restricciones que se deben considerar para el Swapping, antes de efectuarlo es necesario
que el trabajo en memoria este completamente ocioso, porque: ¿Qué pasaría si es intercambiado y
existe pendiente una operación de E/S?. Es posible que se pueda hacer si las ejecuciones de E/S se
hicieran solamente en los buffers del S.O.
PARTICIONES FIJAS.
La situación mostrada en la fig. 10 no es posible, porque no se podría proteger un programa de otro.

Para esto es necesario proteger la memoria antes y después del programa en ejecución. Esta
protección puede ser proporcionada usando dos registros.
Monitor
Usuario 1
Límite inferior
Usuario 2
Límite superior
Usuario 3
Fig. 11. Usuario 4
Dos registros límites definen un espacio lógico de dirección.
Protección de Hardware.
Esos registros proporcionan los límites superior e inferior de las direcciones que pueden ser
legalmente generadas por un programa usuario. Pueden ser definidas de cualquiera de estas dos
formas:
- Registros Límites: Los valores de las direcciones físicas inferior y superior (por ejemplo; límite
inferior = 100.040 y límite superior = 174.640).
- Registros Límites y Base: El valor de la dirección física inferior y el rango de la dirección lógica.
(Por ejemplo: base = 100.040 y límite =174.600)
Como se muestra en la fig. 12 el hardware para el uso de las dos formas difiere ligeramente. Los
registros límites requieren una reubicación estática, ya sea al ensamblarse o al tiempo de cargar. Cada
dirección lógica debe ser mayor o igual al límite inferior y menor que el límite superior. Con los
registros Base y Límite, cada dirección lógica debe ser menor que el registro límite y entonces es
reubicado dinámicamente sumando el valor del registro Base, entonces la dirección reubicada se envía
a memoria.
46
______________________________
James L. Peterson.
Límite Límite
Inferior Superior
Dirección si si
>=
> < Memoria
no no
Fig. 12. A) Registros Límites Trap,error
Límite
Base
Dirección si
<> + Memoria
No
Fig. 12. B) Registros Base/Límites Trap,error
Itinerario de Trabajos.
El contar con dos registros límites de memoria, permite que múltiples usuarios residan en memoria
simultáneamente. Por lo tanto dos administradores de memoria son posibles, donde cada uno de ellos
divide la memoria en "regiones" o "particiones"; La diferencia mayor entre éstos, es que uno cuenta
con regiones estáticas y el otro con regiones dinámicas. Estos esquemas son llamados Ubicación de
Múltiples Particiones Fijas Contiguas y Ubicación de Múltiples Particiones Variables Contiguas. Los
dos ejemplos más conocidos so MFT (Multiprogramación con un número fijo de tareas) y MVT
(Multiprogramación con un número variable de tareas).
En MFT los tamaños son fijos y no cambian cuando el sistema esta funcionando, por ejemplo: una
memoria de 32K palabras puede ser dividida en regiones de los siguientes tamaños:
Monitor Residente : 10K

Trabajos muy pequeños : 4K
Trabajos medianos : 6K
Trabajos grandes :12K
Cuando un trabajo entra al sistema, es puesto en una cola de trabajos, el itinerador toma en cuenta los
requerimientos de memoria de cada trabajo y las regiones utilizables para determinar que trabajos
serán ubicados en memoria. Debe notarse que el número máximo de multiprogramación es limitado
por el número de regiones de memoria. Cuando un trabajo termina, su región queda libre y el
itinerador de puede cargar otro desde la cola de trabajos.
Existen diversas formas de clasificar los trabajos para su ingreso, una de ellas es clasificar todos los
trabajos de acuerdo a sus requerimientos de memoria, esto puede hacerse según los requerimientos que
el usuario ha especificado. Alternativamente el sistema puede intentar determinar los requerimientos
de memoria automáticamente. Cada región de memoria tiene su propia cola de trabajos. Fig. 13
47
______________________________
James L. Peterson.
Por ejemplo: si se tiene tres regiones de memoria, una de 2k, otra de 6K y 12K, se necesitan tres colas
Q2,Q6 y Q12, cada cola tendría su propia itineración de trabajos y su propia región de memoria.
Monitor
Fig. 13 MFT Con cola separada
para cada región.
2K
2 1 2 Q2
6K
3 4 Q6
12K
7 11 8 Q12
Monitor
Q MFT Con cola unificada.

2K
4 1 7 7 3 2 5
6K
12K
Fig. 14.
Otra forma (fig. 14) es colocar todos los trabajos en una sola cola, el itinerador de trabajos selecciona
el próximo trabajo a ejecutarse y espera que la región del tamaño determinado este desocupada.
Suponga que se tiene regiones de 2K, 6K y 12 K y los trabajos de la fig. 14 y que nuestro itinerador de
trabajos funciona con un algoritmo PEPS (FIFI o FCFS). Se podría asignar el T1 a la región de 6K,
T2 a de 2K, como el próximo trabajo necesita 3K se le asigna la región de 6K, pero esta está ocupada,
por lo tanto debe esperar que termine T1 y el T4 (7K) podría haber entrado a la de 12K.
Una variante que se determina inmediatamente es: al quedar una región libre saltar en la cola hasta
alcanzar un trabajo que vaya bien en esa región y acomodarlo allí, efectuando un corrimiento de todos
los otros trabajos.
Otra variante sería pensar en lo siguiente: porqué tendría que esperar T3 y no lo cargamos en la
región de 12K ya que siempre estaría desocupada por las características de los trabajos en la cola?
Aquí, se presenta claramente dos políticas de ubicación de trabajos en memoria: Solamente mejor
acomodado (Best fit only) o Mejor disponible acomodado (Best available fit).
Otra variante de MFT es creada adicionando Swapping, esto es, intercambiando trabajos que puedan
acomodarse en una región dada con el objeto de tener a la C.P.U. menos ociosa.
También existe el llamado Roll-out/Roll-in que trabaja con Swapping y con prioridades; Si llega un
trabajo con prioridad más alta del que está corriendo, éste se saca intercambiándolo por el que llego y
una vez que éste termine, se carga nuevamente el que estaba primero. Normalmente al efectuar un
Swapping el trabajo vuelve a la misma región desde donde salió.
48
______________________________
James L. Peterson.
Qué pasa con MFT si un trabajo requiere más memoria de la inicialmente pedida?, en este caso se
presentan tres posibilidades:
- Abortar el trabajo.
- Devolver el control al programa usuario con un indicador de estado que indique que no existe más
memoria. El programa usuario puede modificar su operación para trabajar en el espacio que tiene.
- Se podría dejar afuera el trabajo y hacerlo esperar por una región más grande, esto es posible
solamente si el hardware soporta una reubicación dinámica.
Se debe recordar que el S.O. está siempre informado por medio de un programa de aplicación, del
actual requerimiento de memoria de un programa, lo que permite efectuar los intercambios necesarios.
Selección de los tamaños de las regiones.
Otro problema del diseño de MFT, involucra la determinación del tamaño de las regiones, suponga que
se tiene un sistema de 32K y que el monitor ocupa 10K, por lo tanto quedan disponibles 22K.
Generalmente el tamaño y el número de particiones se hace basándose en conjeturas de los trabajos
que se ejecutarán.
Suponga también, que se tiene ( en un sistema batch) pequeños utilitarios de E/S que ocupan de 1K a
3K, un compilador Fortran de 8K y un ensamblador de 4K, podemos pensar entonces, en una región
de 10K para compilaciones y otros programas grandes, dos regiones de 4K para E/S y ensamblaje,
quedan 4K, aún se puede subir la de 10K a 14K o cada una de 4K a 6K etc.
Cuando ya se tiene operado el sistema, es más fácil de acuerdo a las estadísticas de uso, hacer
particiones más exactas.
Generalmente la mayor efectividad de un sistema computacional se mide por el nivel de

multiprogramación y éste es directamente afectado por una buena administración de memoria.
FRAGMENTACION DE MEMORIA.
Un trabajo que necesita m palabras de memoria para ser ejecutado puede ser corrido en una región de n
palabras donde n > m.
La diferencia entre n - m es la Fragmentación Interna, (memoria no ocupada internamente en una
región). La Fragmentación Externa ocurre cuando una región utilizable no puede serlo, porque los
trabajos que esperan son más grandes que ella. Ambas fragmentaciones son fuente de memoria mal
gastada en MFT.
Por ejemplo: Si se cuenta con una región de 10K y tres de 4K y llegan los trabajos de 7K, 3K, 6K y
6K, se tendrá 4K de fragmentación interna y 8K de fragmentación externa. Si las regiones son de
10K, 8K y 4K, se puede asignar el de 7K en la región de 8K (1K de fragmentación interna), el de 3K
en la región de 4K (1K de fragmentación interna) y dependiendo del esquema, el de 6K esperaría
(fragmentación externa de 10K) o se le asignaría el de 10K ( 0K de fragmentación externa y 4K más
de fragmentación interna). Si las regiones fueran de otros tamaños probablemente no existiría la
fragmentación de ningún tipo para este grupo de procesos.
49
______________________________
James L. Peterson.
PARTICIONES VARIABLES.
El mayor problema de MFT es determinar el mejor tamaño de las regiones, de tal modo de minimizar
la fragmentación interna y externa. Pero que pasa por ejemplo, si existe 120K de memoria disponible
para los programas de los usuarios de aproximadamente de 20K cada uno y uno de 80K que corre una
vez al día.
La solución a este problema es permitir que los tamaños de las regiones varíe dinámicamente. Esto es
llamado Ubicación de Múltiples Particiones Variables Contiguas.
El S.O. guarda en una tabla indicaciones de qué regiones están disponibles y cuales ocupadas. Al
principio toda la memoria es considerada como un gran bloque disponible para los programas de los
usuarios. Cuando llega un trabajo se busca un bloque suficientemente grande y se le asigna, y el resto
que queda disponible se usa para satisfacer futuras peticiones.
Si se tiene 256K de memoria y un monitor de 40K, quedan 216K disponibles para usuarios. Fig. 15
0
Monitor
40
216k
256
Cola de Jobs.
Job Memoria Tiempo

1 60K 10
2 100K 5
3 30K 20
4 70K 8
5 50K 15
Fig. 15. Ejemplo de itinerador MVT.
Dada la cola de trabajos en la fig. 15, se pueden ubicar inmediatamente los trabajos T1,T2 y T3
quedando 26K de fragmentación externa. Si se determina que la C.P.U. reparte equitativamente su
tiempo uno a uno, al terminar la unidad de tiempo 14 finaliza el T2 dejando libre esta ubicación de
memoria entonces se carga el T4 y a las 28 unidades de tiempo finaliza T1 y es cargado, entonces, el
T5. (Fig. 16).
50
______________________________
James L. Peterson.
0 0 0 0 0
40K Monitor 40K Monitor 40K Monitor 40K Monitor 40K Monitor
Entra
100K Job 1 100K Job 1 100K Job1 End 100K 90K Job 5
Entra 100K
Job 2 End 170K Job 4 170K Job 4
Job 4
200K 200K 200K 200K 170K
200K
Job 3 Job 3 Job 3 Job 3
230K 230K 230K 230K 230K Job3
256K 256K 256K 256K 256K
(a) (b) (c) (d) (e)
Fig. 16. Ejemplo de ubicación de memoria en itineración de MVT.

Con este esquema se demuestra perfectamente este administrador, el que va produciendo particiones a
medida que estas van siendo necesarias. Hasta aquí, se ha trabajado con el esquema PEPS, pero las
estrategias más comunes para seleccionar uno de los bloques libres del conjunto de los utilizados son:
- Primero Acomodado (First-fit): La búsqueda finaliza al encontrar el primer bloque libre, mayor o
igual a que se necesita. Este algoritmo es el más rápido.
- Mejor Acomodado (Best-fit) : Se debe buscar en toda la lista, ordenada por tamaños hasta que se
encuentre la menor partición capaz de albergar el trabajo.
- Peor Acomodado (Worst-fit ) : Se debe buscar en la lista ordenada aquella partición mayor.
Simulaciones de estos tres algoritmos han demostrado que el Primer Acomodado puede ser mejor que
el Mejor Acomodado, pero que ambos son definitivamente mejores que el Peor Acomodado.
El hardware mínimo necesario es el mismo que en MFT: dos registros conteniendo la menor y
mayor ubicación de memoria utilizadas. Cuando el itinerador de C.P.U. selecciona un proceso, el
despachador carga esos registros límites con los valores correctos. Cada una de las direcciones del
programa usuario deben ser verificadas entre estos dos límites para proteger a los otros programas
usuarios.
Se debe notar que el software hace la diferencia, ya que en el hardware son totalmente idénticos ambos
administradores.
Itineración de Trabajos.
Como se aprecia existe una interacción total de MVT o MFT con los itineradores de trabajos. El
itinerador de trabajo puede ordenar la cola de trabajos de acuerdo al algoritmo de itineración, cuando
existe espacio disponible, el itinerador de trabajos puede esperar a que llegue un trabajo que se
acomode mejor o saltar de trabajo en trabajo hasta encontrar uno que se acomode mejor o que tenga
una prioridad mayor.
51
______________________________
James L. Peterson.
La utilización de memoria es mejor generalmente en MVT que en MFT. En MVT no existe o es

muy pequeña la fragmentación interna, puesto que las regiones son creadas del tamaño solicitado por
el trabajo. Observando la figura 16. se puede apreciar las siguientes fragmentaciones externas a) 26K;
c) 56K con lo cual podría correr el T5 si estuviesen contiguos
Este problema de fragmentación puede ser bastante severo, en el peor de los casos se puede tener
bloques entre cada trabajo. La selección del algoritmo Primero Acomodado o Mejor Acomodado
puede afectar la cantidad de fragmentación.
Compactación.
Una solución a este problema es la compactación, el objetivo es empujar los contenidos de memoria de
tal modo que la memoria libre quede en un solo bloque.
La compactación no siempre es posible, para que lo sea, es necesario que la reubicación sea dinámica
en el tiempo de ejecución, usando registro base y límite. Si la reubicación es estática y dada al tiempo
de ensamblaje o de carga, la compactación no puede ser efectuada. Si las direcciones son reubicadas
dinámicamente, la reubicación requiere solamente mover el programa y datos, entonces cambiar el
registro base para reflejar la nueva dirección base.
Cuando la compactación es posible se debe determinar el costo ya que el esquema puede ser bastante
caro.
Es bastante difícil seleccionar una optima estrategia de compactación, ya que, a menudo no es lo

mejor dejar todo el espacio libre al final, porque puede haber significado mover una gran cantidad de
memoria, que si se hubiera dejado el área libre al medio. Otras veces sería suficiente mover un solo
trabajo para lograr la cantidad de memoria que ha sido requerida.
0 0
40K Monitor 40K Monitor
Job 5 Job 5
90K Compactada 90K
100K 10K Job 4
160K
170K Job 4 Job 3
190K
30K
200K
Job 3
230K 66K
256K 26K 256K
Fig. 18. Compactación
0 0 0 0
Monitor Monitor Monitor Monitor
300 300 300 300
52
______________________________
James L. Peterson.
500 500 500 500

600 600 600 600
400K Job 3
800 Job 4
1000 1000
Job 3 900K
Job 4 Job 3
1200
300K 1200 1200
1500
1500 Job 4
Job 4
900K 900K 1900
1900 Job 3
200K
2100 2100 2100 2100
Ubicación Original Se mueven 600K Se mueven 400K Se mueven 200K
Fig. 19. Comparación de diferentes formas de compactar memoria.

En otros sistemas puede combinarse MVT con Swapping, un trabajo puede ser sacado a memoria
secundaria y devuelto después. Cuando ese trabajo se saca, su área de memoria puede ser reutilizada
por otro trabajo, pero cuando es devuelto se pueden encontrar algunos problemas:
- Si es utilizada reubicación estática, el trabajo puede ser reintegrado a la misma área de memoria que
ocupaba anteriormente, lo que podría significar desalojar a otros trabajos que la estén ocupando.
- Si la reubicación es dinámica (tal como registro base/límite) entonces, un trabajo puede ser cargado
en diferente ubicación, en ese caso debe encontrar memoria libre haciendo uso de la compactación si
fuese necesario.
53
______________________________
James L. Peterson.
PAGINACIÓN.
MVT tiene un problema de fragmentación externa, generalmente esta situación ocurre cuando la
memoria disponible no es continua, en tal caso se plantean dos soluciones:
- Compactación: Cambia la distribución de memoria para convertir todas las áreas libres en un
espacio contiguo.
- Paginación : Permite que la memoria necesitada por un programa sea no contigua, es decir,
permite que un programa sea ubicado en memoria física donde quiera que ella esté
disponible.
Hardware.
Debe existir un soporte de hardware para que pueda existir paginación.
Dirección Lógica Dirección Física
p d p d
MEMORIA
FISICA
Tabla de Páginas.
Fig. 20. Hardware de Paginación.
Cada dirección generada para la C.P.U. es dividida en dos partes: Un "número de página (p)" y una
"Página equivalente (d)".
El número de página se usa como índice en una tabla de páginas, la que contiene la dirección base de
cada página en memoria física. Esta dirección base se combina con las páginas equivalentes para
definir la dirección física de memoria que se envía a la dirección de memoria.
Memoria Física
Página 0 0 1 0
Página 1 1 4 1 Página 0
Página 2 2 3 2
Página 3 3 7 3 Página 2
Memoria Lógica Tabla de Páginas 4 Página 1
5
54
______________________________ Página 3
James L. Peterson.
6
La memoria física (fig. 21) es separada en bloques de tamaño fijo llamadas "bloques" (frames), la
memoria lógica también es separada en bloques del mismo tamaño llamados "páginas". Cuando un
programa se va a ejecutar, sus páginas son cargadas en bloques disponibles y la tabla de páginas es
definida al trasladar desde el disco páginas de usuarios a bloques de memoria.
El tamaño de página como también el del bloque es definido por el hardware, pero típicamente es una
potencia de 2, por ejemplo: Vax-750 usa 512 palabras por página.
Se puede ver como la memoria es mapeada (Fig. 22) usando un tamaño de página de cuatro palabras y
una memoria física de 32 palabras (8 pág.). La dirección lógica 0 está en la página 0, equivalente 0,
indexando en la tabla de páginas se encuentra la página 0 en el bloque 5; así la dirección lógica 3
(página 0,equicalente 3) mapea la dirección física 23 (5*4+3). La dirección lógica 4 esta en la página
1, equivalente 0; de acuerdo a la tabla de página, la página 1 es mapeada en el bloque 6; así la
dirección lógica 4 mapea a dirección física 24 (6*4 + 0); la dirección lógica 13 mapea a dirección
física 9.
Es importante notar que la paginación es una forma de reubicación dinámica. Cada dirección lógica es
mapeada por el hardware de paginación a alguna dirección física.
0 a 0 5 0
0 1 b
2 c 1 6 4 i
3 d j
4 e 2 1 k
1 5 f l
6 g 3 2
7 h Tabla de Páginas 8 m
n
8 i o
2 9 j p
10 k
11 l. 12
12 m
3 13 n 16
14 o
15 p
20 a
Memoria Lógica b
c
d
24 e
f
g
h
28 55
______________________________
James L. Peterson.
Memoria Física
Fig. 22. Ejemplo de paginación para una memoria de 32 palabras con páginas de 4 palabras.
Itineración de trabajos.
El esquema de administrador de memoria influye en la itineración de trabajos, cuando un trabajo llega

para ser ejecutado, es examinado por el itinerador con relación a su tamaño, el tamaño de un trabajo se
expresa en páginas, luego el itinerador de trabajos observa la memoria disponible, la cual se guarda en
una lista de bloques no asignados. Cada página de usuario requiere de un bloque, es decir, si un
programa usuario tiene n páginas, deben haber n bloques disponibles en memoria, para que el
itinerador de trabajos pueda colocar allí ese trabajo. La primera página del trabajo se carga en un
bloque y su número es puesto en la tabla de páginas de ese trabajo y así sucesivamente.
Paginación
Bloques Libres 13
New Job 14
a) 14
15
Page 0 13
18 16
Page 1
Page 2 20 17
Page 3 15 18
19
20
21
Bloques Libres Paginación
New Job 15 Page 1 (13)

b) Page 0 (14)
Page 0
15
Page 1
Page 2 16
Page 3 17
Page 2 (18)
19
0 14 Page 3 (20)
21
1 13
Nuevos Jobs en la
Tabla de Páginas 2 18
3 20
56
______________________________
James L. Peterson.
Fig. 23. Distribución de bloques libres a) antes y b) después.
Al utilizar un esquema de paginación no se tiene fragmentación externa: cualquier bloque libre puede
ser proporcionado a un trabajo que lo necesite.
Sin embargo puede existir fragmentación interna, ya que los bloques se asignan como unidades, así
que el último no puede estar completo.
Por ejemplo, si las páginas son de 512 palabras, un programa de 8.629 palabras necesita de 16 páginas
más 437 palabras, pero se ubica en 17 páginas, con lo cual existe una fragmentación interna de 75
palabras (512 - 437). En el peor de los casos un programa puede necesitar n páginas, más 1 palabra
por lo cual debemos darle n+1 bloques. Esta consideración sugiere que es deseable que existan
páginas pequeñas. Cada trabajo tiene su propia tabla de páginas, la cual se almacena con los otros
registros de valores en el Bloque de Control de Procesos. Cuando el despachador se llama para
comenzar un trabajo debe volver a cargar los registros usuarios y definir los valores de páginas
correctamente.
Implementación de una Tabla de Páginas.
En el caso más simple, se implementa como el conjunto de registros dedicados, los cuales son vueltos
a cargar por el despachador en el momento de volver a cargar el resto de los registros de programas.
Las instrucciones que permiten cargar y modificar estos registros son privilegiadas; Como el acceso a
una dirección a memoria requiere una traslación desde la tabla de páginas, es necesario que los
registros sean de alta velocidad para lograr eficiencia. En el caso de un número relativamente pequeño
de páginas, no existe problema al trabajar con registros para almacenar la tabla de páginas, sin
embargo en algunos equipos la tabla de páginas necesariamente se almacena en memoria principal y
un registro base de tablas de páginas apunta a la tabla de páginas (PTBR), el cambio en la tabla de
páginas requiere cambiar sólo este registro, reduciendo sustancialmente el tiempo de búsqueda.
El problema que se presenta es el tiempo de acceso, si se requiere accesar la dirección i se debe
primero incursionar dentro de la tabla de páginas, usando el valor del registro base equivalente para el
número de página por i. Esta tarea requiere un acceso a memoria que es proporcionado mediante el
número de bloque combinado con la página equivalente para producir la dirección actual. Con este
esquema es necesario dos accesos a memoria para obtener una palabra (una para la tabla de páginas y
la otra para la palabra), lo que implica que la velocidad de acceso es dividida en dos.
La solución estándar es la utilización de una pequeña memoria especial, llamada Registros

Asociativos o Cache o Memoria de Contenido Direccionable, la cual es un conjunto de registros
asociados construidos en memoria de alta velocidad. Cada registro se compone de dos partes: una
clave y un valor.
Cuando ocurre una comparación de un ítem con los registros asociativos, se permite una comparación
con todas las claves simultáneamente; si el ítem es encontrado, el correspondiente valor del campo es
sacado.
Los registros asociativos sólo contienen unas pocas entradas (depende del tamaño) de la tabla de
páginas, cuando se genera una dirección lógica el número de páginas es comparado con el conjunto de
57
______________________________
James L. Peterson.
registros asociativos que contienen números de páginas y los correspondientes números de bloques. Si
se encuentra el número de página, el número de bloque queda inmediatamente disponible y se usa para
accesar la memoria.
Este acceso puede tomar un máximo del 10% del tiempo que tomaría una referencia que no se
encuentra en los registros asociativos.
Si el número de páginas no se encuentra en los registros asociativos, debe ser hecha una referencia a la
tabla de páginas y luego de obtener el número de bloque se accesa la memoria, además debe anexar
éste número de página y bloque a los registros asociativos para encontrarlo rápidamente en la próxima
referencia.
La probabilidad de encontrar un número de páginas en los registros asociativos esta directamente

relacionada con el número existente de éstos, por ejemplo, con ocho o dieciséis registros asociativos,
se puede obtener el número de página deseado entre un 80% a 90%.
Si el tiempo necesario para buscar en los registros asociativos fuera de 50 nanosegundos y 750
nanosegundos para accesar la memoria, entonces un acceso a memoria que ya está mapeada en
registros asociativos tomaría 800 nanosegundos.
S no fuera así, se tendría 50 nanosegundos en los registros asociativos más 750 nanosegundos del
primer acceso a la memoria para la tabla de páginas-bloques, y 750 nanosegundos más para accesar
el registro deseado en memoria, por lo tanto se necesitarían 1550 nanosegundos, en vez de los 800
nanosegundos.
PÁGINA COMPARTIDA.
Otra ventaja de la paginación es la posibilidad de compartir códigos comunes, tema importante en un

medio de tiempo compartido, así por ejemplo, en un sistema que soporta 40 usuarios, si existe un
editor de texto con 30K de código y 5K de espacio de datos, se podría llegar a necesitar 1400K para los
40 usuarios (40* 30K + 40*5K). Sin embargo, si el código es re-entrante podría ser compartido por
varios usuarios, siendo necesario para cada uno de ellos sólo el propio espacio de datos.
JOB 1 JOB 2 JOB 3

EDIT 1 3 EDIT 1 3 EDIT 1 3

DATOS 1 DATOS 2 DATOS 3
1 7 2
Códigos compartidos en un ambiente de paginación.
DATOS 1 1
DATOS 3
2
58
______________________________
James L. Peterson.
EDIT 1
3
EDIT 2
4
5
EDIT 3
6
DATOS 2
7
El código re-entrante (código duro) no debe ser modificado, de este modo dos o más procesos pueden
ejecutar un mismo código a un mismo tiempo.
Cada proceso tiene su propia copia de registros y de almacenamiento de datos para retener los datos
para su utilización, estos datos pueden variar según el proceso.
Dentro de los códigos que se pueden compartir, se tienen por ejemplo: Compiladores, Ensambladores,
Sistemas de bases de datos, etc.
Protección.
La protección del código está basada en bits de protección, asociada con cada página, normalmente
son almacenados en la Tabla de Páginas. Un bit puede definir una página para ser leída-escrita o
solamente leída.
En cada referencia a memoria, primero se accesa la tabla de páginas para encontrar el número del
bloque correcto, al mismo tiempo que se está computando la dirección física, son chequeados los bits
de protección para verificar que no se efectúe una escritura en una página de sólo lectura; si existe una
intención de este tipo se produce un traps.
Existe el hardware necesario que provee protección de sólo lectura, sólo escritura o sólo de ejecución.
Generalmente se proporciona además, otro bit de válido/no válido; la arquitectura de una máquina
define el rango de direccionamiento máximo. Cada Job en particular es ubicado en un pequeño
espacio de dirección, dependiendo del programa. Los direccionamientos ilegales son atrapados al usar
el bit de válido/no válido, el S.O. lo coloca para cada página para permitir el acceso a ella.
SEGMENTACIÓN.
La segmentación es un esquema de administración de memoria que representa la idea de función de

programación, por ejemplo, se supone que un programa principal cuenta con un conjunto de rutinas,
procedimientos, funciones o módulos, también varias estructuras de datos: arreglos, Stacks, variables
y otros, por lo tanto cada componente de un programa principal es un segmento de largo variable, el
largo es definido por el propósito del segmento de programa.
Stacks
Subrutinas 59
______________________________
Espacio de direcciones lógicas

James L. Peterson.
Tabla de
Símbolos
SQR Programa
Principal
La visión del usuario.
Un espacio de dirección lógica es un conjunto de segmentos. Cada segmento tiene un nombre y un

tamaño definido. Para simplificar su implantación, los segmentos son numerados, normalmente el
programa usuario es compilado y en este proceso automáticamente se construyen los segmentos.
Un compilador de Pascal crea segmentos separados para:
1. Variables Globales.
2. Procedimientos de llamadas al stack, para almacenar parámetros y retornar direcciones.
3. Código de cada procedimiento y función.
4. Variables locales de cada procedimiento y función.
Hardware.
Una dirección lógica consiste en: Número de segmento (s) y un equivalente al segmento (d). El
número de segmento es usado como un índice dentro de la tabla de segmentos, cada entrada de la
tabla de segmento tiene una base de segmento y un límite de segmento. El equivalente (d) de la
dirección lógica podría estar entre 0 y el límite del segmento. Si no es así, entonces ocurriría un trap
(una dirección lógica intenta accesar fuera del segmento). Si el equivalente es legal, entonces es
sumado a la base del segmento para producir la dirección física requerida y así accesar la palabra
correspondiente, la tabla de segmentos está formada por un arreglo de pares de registros base/límite.
Por ejemplo: Considere que se tienen cinco segmentos numerados desde cero hasta cuatro, los
segmentos están actualmente almacenados en memoria física , la tabla de segmentos tiene separada la
entrada por cada segmento, conteniendo la dirección de comienzo del segmento en la memoria física
(base) y el largo de cada segmento (límite). Así el segmento 2 tiene 400 palabras de largo,
comenzando en la dirección 4.300, al hacer una referencia a la palabra 53 del segmento 2, es mapeada
a la dirección física 4.300 + 53 = 4.353, una referencia al segmento 3 palabra 852, es mapeada a 3.200
+ 852 = 4.052, una referencia a la palabra 1.222 del segmento 0 resultará un trap para el sistema
operativo, ya que el segmento 0 sólo posee 1.000 palabras.
Ejemplo de Segmentación.
Tabla de Segmentos
Subrutina Stack, Límite Base
Segmento 0. Segemnto 3
1.000 1.400
0
SQR,
Segmento 1 400 6.300
60
______________________________
Espacio de direcciones lógicas

James L. Peterson.
1
Tabla de
Símbolos, 400 4.300
Programa 2
Principal, Segmento 4.
1.100 3.200
Segmento 2. 3
1.000 4.700
4
1400 0
Segmento
2400
3200
Segmento 3 4300 Memoria Física.
Segmento 2 4700
Segmento 4
5700
6300
Segmento 1 6700
Implementación de una Tabla de Segmento.
La Tabla de Segmentos puede ser implementada sobre registros rápidos o en memoria y así, podría ser
eficientemente referenciada, pero cuando existen muchos segmentos no es posible implementarla
sobre registros rápidos y entonces debería hacerse en memoria.
En este caso se usan:
a) La Tabla de Segmento de registro base (STBR) que apunta a la tabla de segmentos, ya que el
número de segmentos usados en un programa varía considerablemente.
b) La Tabla de Segmento registro límite (STLR), que también apuntará a la tabla de segmento.
Para una dirección lógica (s,d) revisará primero que el número de segmento sea legal (s ∈ STLR),
entonces concatenará el límite (contenido apuntado por s en STLR) con la base correspondiente
(contenido apuntado por s en STBR) y lo agregará a la tabla de segmento, luego procederá
normalmente.
Como en la paginación, este mapeo requiere de dos referencias a memoria por dirección lógica. La
mejor solución es usar un conjunto de registros asociativos conteniendo los segmentos más usados
recientemente.
Un conjunto de 8 a 16 registros asociativos puede reducir el acceso a memoria en no más de 10% hasta
un 15%.
Tabla de Segmento
s
Límite Base
61
Memoria
______________________________
James L. Peterson.
(s,d)
Si
<
No Trap, error de direccionamiento.
Implementación de una Tabla de Segmento. Trap, error de direccionamiento.
Implementación de una Tabla de Segmento.
Protección.
La particular ventaja de la segmentación es la asociación de la protección con los segmentos, los

segmentos representan por definición semántica, una porción de un programa y pueden contener
instrucciones, mientras que otros contienen datos; en una arquitectura moderna las instrucciones no
son modificadas por sí mismas, aún más, los segmentos de instrucciones pueden ser definidos como de
sólo lectura. El mapeo de la memoria revisará la protección asociada con cada tabla de segmento
para prevenir un acceso ilegal a la memoria o como intentar grabar en un segmento de sólo lectura o
de usar un segmento de sólo ejecución como segmento de dato.
Una ventaja de la segmentación involucra el compartir los códigos o los datos, cada Job tiene su tabla
de segmento asociada a través del PCB y que el despachador usará para cuando al Job le sea asignada
la C.P.U.
La idea de compartir, ocurre al nivel de segmento, más de alguna información puede ser compartida
por definición al estar en un segmento, como también muchos segmentos pueden ser compartidos, es
decir, un programa compuesto de muchos segmentos puede ser compartido.
Considere el uso de un editor de texto en un ambiente de tiempo compartido, los segmentos pueden ser
compartidos por varios usuarios, limitado por la memoria física necesitada para soportar las tareas de
edición. Más que necesitar n copias del editor sólo será necesitada una, para cada usuario sólo se
necesita en forma separada los segmentos que almacenaran las variables locales, estos segmentos no
serán compartidos. También es posible compartir sólo partes de programas, por ejemplo: rutinas
comunes pueden ser compartidas por muchos usuarios y sólo en modo lectura.
FRAGMENTACIÓN.
El itinerador de trabajos debe encontrar y asignar memoria para todos los segmentos de un programa
usuario. Esta situación es similar a la de la paginación, exceptuando el hecho de que los segmentos
son de largo variable y las páginas son todas del mismo tamaño, de este modo, tal como MVT, la
ubicación de memoria es de almacenamiento dinámico, probablemente utilizando un algoritmo de
mejor acomodado a primer acomodado.
La segmentación puede causar fragmentación externa cuando los bloques de memoria disponible son
muy pequeños para almacenar segmentos. En este caso el trabajo debe esperar hasta que exista más
62
______________________________
James L. Peterson.
memoria disponible o también puede ser utilizada la compactación para lograr áreas disponibles de
mayor tamaño, ya que, la segmentación es por naturaleza un algoritmo de reubicación dinámica, por
lo tanto se puede compactar la memoria cuando se desee.
Si en un momento determinado no es posible almacenar un trabajo en memoria por falta de espacio

disponible, el itinerador de Job puede dejarlo para ubicar uno más pequeño.
¿La fragmentación interna es un esquema de segmentación?

¿Puede el itinerador de trabajos al saltar trabajos ayudar a la compactación?
La respuesta a estas interrogantes depende principalmente del tamaño promedio de los segmentos. Por
una parte se puede definir cada trabajo como un solo segmento, este esquema es MVT. Por otro lado,
cada palabra podría constituir un segmento y reubicarlo separadamente, lo cual eliminaría totalmente
la fragmentación externa. Mientras menores son los tamaños de los segmentos, la fragmentación
externa es menor.
x,j jh da TRentaja visible de este sistema, es que los programas usuarios pueden usar mayor cantidad
de memoria que la principal, es importante recordar que no siempre todo el programa usuario es
ejecutado (por ejemplo: rutinas de error, opciones de menú, posiciones de arreglos, etc.), y esa es la
premisa principal que se ha usado para el uso de memoria virtual.
El esquema de Memoria Virtual, se denomina Paginación Solicitada o Paginación Ordenada, el cual

es similar a un sistema de paginación con uso de Swapping. Todo programa usuario reside en
memoria secundaria, y sólo se carga una página de él cuando puede comenzar a ser ejecutado, la
posterior carga de páginas del programa sólo se efectúa, si el programa usuario así lo requiere, sin
duda, este esquema permite el mayor grado de multiprogramación.
Cuando se intenta accesar una dirección que no esta en memoria, ocurre una falla de página, estar en
un esquema de Administración de Memoria sin Memoria Virtual implicaría un error, pero en este caso
el S.O. debe accesar su tabla de páginas para comprobar si la dirección mencionada es parte del
programa usuario, si es así, debe encontrarse un bloque libre para cargar la página solicitada, y en este
caso pueden ocurrir dos cosas:
1. Que exista un bloque libre, con lo cual se cargaría la página necesitada.

2. Que no exista un bloque libre, con lo cual se buscaría una página víctima para dejarla en memoria
secundaria y ubicar en el bloque libre la página necesitada.
Es importante destacar la importancia de actualizar las tablas en cada movimiento y almacenar los
registros correctos en los PCB.
Algoritmos de Reemplazo de Páginas.
Algoritmos de Ubicación.
El caso más simple de memoria virtual, es el sistema mono-usuario, en el cual se permite que el
63
______________________________
James L. Peterson.
programa usuario puede ser superior a la memoria principal del equipo (utilizando herramientas y
metodologías de compilación y linker especiales que lo permiten). Por supuesto que los bloques sólo
se encuentran disponibles para ese programa específico.
Distinto es el caso, cuando se piensa en multiprogramación, cuando existe más de un programa

usuario, ya que se debe decidir a cual de ellos se le asigna algún bloque disponible. Debe tenerse
claramente establecido que existe un número finito de bloques en memoria a asignar y que es
indudable de que al establecer el número de bloques asignado a cada Job, el número de fallas de
páginas debe aumentar. También es necesario acotar que debe existir un número mínimo de bloques a
asignar a cada Job, dependiendo de la arquitectura del set de instrucciones.
El mínimo número de bloques para un proceso esta dado por la arquitectura del computador y el
máximo es definido por la máxima cantidad de memoria disponible (depende de los algoritmos de
performance del sistema).
Ubicación Global v/s Local.
Los algoritmos de reemplazo pueden clasificarse en dos grandes grupos:
1. Reemplazo Global: Al seleccionar una página víctima, puede seleccionarse cualquiera, incluso la
de otro proceso.
2. Reemplazo Local: La página seleccionada debe ser sólo una del conjunto asignado a ese Job
(nunca va a cambiar el número de bloques asignados a un Job).
La forma más fácil de dividir m bloques entre n procesos, es asignar a cada uno una cantidad de m/n
bloques, esto se denomina ubicación equitativa.
Otra alternativa es reconocer que distintos tipos de procesos puedan requerir distintos montos de
memoria. Sería justo por ejemplo que con una cantidad de 100 bloques disponibles, se asignará 50
bloques a cada proceso (sólo existen dos), si uno requiere 10K y otro 180K, (cada bloque de 1K), se
puede pensar entonces en una ubicación proporcional.
Si el número total de bloques disponibles es m, asignaremos ai bloques al proceso Pi donde:
ai = (Si / S) * m S: La suma de los Si, que es el tamaño en páginas del proceso Pi.
Es necesario ajustar ai a un entero superior, a la cantidad mínima de bloques necesarios por

arquitectura y debe verificarse que la suma de los ai sea menor o igual a m.
Ejemplo:
a) Número de bloques: 93
Procesos : 5
Ubicación Equitativa = m / n = 93 / 5 = 18 Bloques para cada proceso.
b) Número de bloques: 62
Proceso 1: 10K
Proceso 2: 127K
64
______________________________
James L. Peterson.
Ubicación Proporcional:
Sí S1= 10K y S2= 127K, entonces S= 137K
a1 = (S1 / S) * m = (10 / 137) * 62 = 5
a2 = (S2 / S) * m = (127 / 137) * 62 = 57
(a1 + a2) <= m, (5 + 57) <= 62
Algoritmos.
Suponga un esquema de memoria con tres bloques disponibles para usuarios y una secuencia de
utilización de página como sigue:
7, 0, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0, 1, 7, 0, 1.
FIFO: Es el más simple y es “el primero que entra es el primero en salir”. Este algoritmo asocia a
cada página el tiempo que ha estado en memoria. Así cuando se quiere reemplazar una página,
la elegida será la “más vieja”, es decir, la que lleva más tiempo en memoria. Como se ve a
continuación no es necesario guardar el tiempo de cada página en memoria, ya que se puede
crear una cola FIFO para almacenarlas y de este modo bastará con reemplazar la página que se
encuentre en el comienzo de la cola.
CADENA REFERENCIAL.
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7 7 2 2 2 2 4 4 4 0 0 0 0 0 0 0 7 7 7
0 0 0 0 3 3 3 2 2 2 2 2 1 1 1 1 1 0 0
1 1 1 1 0 0 0 3 3 3 3 3 2 2 2 2 2 1
* * * * * * * * * * * * * * *
• 15 Fallas de página o reemplazos (*).

• 5 referencias de páginas que ya estaban en memoria.
• La más utilizada fue la página 0, 6 veces.
• La menos utilizada fue la página 4, 1 vez.
Este algoritmo es fácil de entender y programar, sin embargo no siempre es bueno ya que, la página
reemplazada podría ser el comienzo de un módulo que no ha sido reemplazado o sacado por mucho
tiempo y además no es muy requerido caso página 7.
Como así también, podría tratarse de una página que contiene una variable muy usada la cual a pesar
de ser inicializada temporalmente se utiliza mucho (0).
65
______________________________
James L. Peterson.
REEMPLAZO ÓPTIMO: Es aquel que proporciona la menor razón de fallas de páginas, en

términos más simple es: “reemplace aquella página que no será usada por
un largo tiempo".
Con este algoritmo se garantiza que se obtiene la menor cantidad de fallas
de páginas para una cantidad fija de bloques.
CADENA REFERENCIAL.
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7 7 2 2 2 2 2 2 2 2 2 2 2 2 2 2 7 7 7
0 0 0 0 0 0 4 4 4 0 0 0 0 0 0 0 0 0 0
1 1 1 3 3 3 3 3 3 3 3 1 1 1 1 1 1 1
* * * * * * * * *
• 9 Fallas de página o reemplazos (*).

Con este algoritmo se obtiene no más de 9 fallas de páginas, siendo que para el mismo ejemplo con el
algoritmo tipo FIFO se obtuvieron 15 fallas de páginas.
Desgraciadamente el algoritmo de reemplazo óptimo es difícil de implementar ya que, contiene o

requiere del conocimiento futuro de la cadena referencial.
Como resultado, el algoritmo de reemplazo óptimo se usa sólo para estudios comparativos.
LRU: ( Least Recently Used) Ya que el algoritmo anterior no es practicable, quizá una aproximación
si lo sea. Aquí se usa el pasado reciente como una aproximación del futuro próximo y se
reemplaza la página que no ha sido usada por un largo tiempo.
Se asocia a cada página el tiempo de su último uso, cuando la página debe ser reemplazada, se
elige entre aquellas que no han sido usadas por un largo período de tiempo. Como se ve, éste es
el mismo algoritmo de reemplazo óptimo que en vez de mirar hacia adelante en el tiempo
mira hacia atrás.
LRU es siempre usado como un algoritmo de reemplazo de páginas y es considerado absolutamente

como el mejor, el mayor problema es como implementarlo.
CADENA REFERENCIAL
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
7 7 7 2 2 2 2 4 4 4 0 0 0 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 3 3 3 3 3 3 0 0 0 0 0
1 1 1 3 3 3 2 2 2 2 2 2 2 2 2 7 7 7
* * * * * * * * * * * *
66
______________________________
James L. Peterson.
• 12 fallas de páginas o reemplazos (*).

Ejercicios:
Desarrolle la cadena referencial utilizando los tres algoritmos y con 3, 4 y 5 bloques de memoria,
concluya.
La secuencia de utilización de páginas es:
1, 1, 2, 5, 1, 2, 7, 8, 3, 4, 6, 9, 5, 8, 7, 4, 1, 6, 6, 4, 3
67
______________________________

Gso01

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Gso01

Transféré par

Droits d'auteur :

Formats disponibles

Traducción libre de Jorge Morris A.

OPERATING SYSTEM CONCEPTS

Un Sistema computacional esta formado por:

2º Definición: Administrador de recursos tales como: Memoria, CPU, dispositivos e información.

Un sistema operativo como un administrador de recursos debe cumplir cuatro funciones:

1.- Llevar el control de los recursos.

El objetivo básico y fundamental de un sistema computacional, es ejecutar programas de los usuarios y

Si se detectaba un error en la ejecución, el programador-operador examinada los contenidos de

Los pasos para ejecutar un programa bajo estos compiladores eran:

1. Cargar programa } Correr compilador

3. Desmontar cinta del compilador } Correr assembler

5 Desmontar cinta con assembler } Correr programa

Programa Fuente Compilador Programa Objeto

SISTEMAS BATCH SIMPLES

Vectores de Interrupción y Traps

Diagrama de Memoria de un Monitor residente.

(Traps: interrupción interna al encontrar un error de programa.)

$FTN --- Ejecuta el compilador fortran.

$JOB--- Primera tarjeta de un Job.

MODO MONITOR USUARIO

Cómo detener un programa?

requiriendo, el monitor ejecuta este requerimiento y retorna a la siguiente instrucción de la llamada al

Uso de una llamada al sistema para ejecutar I/O.

1. Trap para el monitor. (2)

i) Un reloj como tal.

- Las tarjetas de control gobiernan el Sistema.

OPERACIONES FUERA DE LÍNEA

A) Operación en línea de dispositivos de E/S.

B) Operación fuera de línea de dispositivos de E/S.

Dispositivo de Cinta Dispositivo de Cinta

Para realizar lo anterior surgen dos métodos:

a) Consiste en el desarrollo de unos dispositivos especiales que permiten Entradas desde

era guardada en disco para después enviarla a impresión.

Spooling: Simultáneas Peripheral Operation On-Line.

- La E/ es realizada por teclado y la S/ por vídeo.

SISTEMA DE TIEMPO REAL

INTERACTIVO MODO USUARIO

1.- Técnica Maestro-Esclavo.

Traducción libre de Jorge Morris A.

SERVICIOS DE SISTEMAS OPERATIVOS

- Protección: Los propietarios de la información almacenada en un sistema computacional

El punto de vista del Usuario.

El nivel más fundamental de servicios es manejado mediante la llamada al sistema, lo que

a) CONTROL DE TRABAJOS O PROCESOS:

TIPOS DE LLAMADAS AL SISTEMA.

PROCESS CONTROL - End, abort

FILE MANIPULATION - Create File, Delete File

DEVICE MANIPULATION - Request Device, Release Device

IMPLEMENTACION DE LLAMADAS AL SISTEMA.

. Manipulación de Archivos: Programas que crean, borran, copian, renombran, imprimen y

. Soporte de lenguajes de Programación: Compiladores, ensambladores e interpretes para

. Ejecutores y Cargadores de Programas: Una vez que un programa es ensamblado o

. Programas de Aplicación: Algunos sistemas también proporcionan algunos programas de uso

LA VISIÓN DEL SISTEMA OPERATIVO:

-Llamada al Sistema: También existen diversos programas para su atención dependiendo de su

INTERRUPCIONES DE DISPOSITIVOS DE E/S

La alternativa es comenzar la E/S y devolver inmediatamente el control al programa usuario. Una

TABLA DE ESTADO DE DISPOSITIVOS

Dispositivo Unidad Disco 1 Solic.Disco 1

Dispositivo Unidad Disco 2 Solic.Disco 2 Solic.Disco 2

Se puede identificar un S.O. como un manipulador de interrupciones, manejador de dispositivos, un

S.O. mono-usuario y uniprogramado es menos complejo que un S.O. multi-usuario y

FLUJO GENERAL DE UN SISTEMA OPERATIVO