INACAP - Manual de Sistemas Operativos I

M ANUAL DE SISTEM AS OPERATIVOS I
Dirección de Área Infor mática

w ww .inform a tica.ina ca p.cl
Colaboraron en el presente manual:
Carlos Covarrubias Astudillo

Jefe de Programa de Estudios
Ingeniería en Gestión Informática
INACAP La Serena
Derechos Reservados
Titular del Derecho: INACAP
N° de inscripción en el Registro de Propiedad Intelectual # 130.357 de fecha 02-01-2003.
© INACAP 2003.
Página 1 de 164
DESC R IPC IÓ N DEL C O NTE NID O
El presente documento contiene una síntesis ordenada de los tópicos más relevantes de la asignatura de
Sistemas Operativos I, correspondientes al programa de estudios de Ingeniería en Gestión Informática.
El documento pretende ser una fuente de información que complemente la labor docente y a la vez sirva
como guía de estudio para el alumno.
Este manual se organiza en nueve capítulos ordenados según los contenidos establecidos en el
programa de la asignatura (plan 790-5). Además, contiene un completo conjunto de preguntas y
ejercicios resueltos que facilitarán el proceso de autoevaluación de aprendizajes y avances de parte del
alumno.
Sugerencia de distribución de tiempo de lectura y estudio.
Tiempo sugerido
CAPÍTULO I : INTRODUCCIÓN 1 hrs.

CAPÍTULO II : SERVICIOS DE LOS SISTEMAS OPERATIVOS 1 hrs.
CAPÍTULO III : ELEMENTOS BÁSICOS 4 hrs.
CAPÍTULO IV : ADMINISTRACIÓN DE CPU 3 hrs.
CAPÍTULO V : ADMINISTRACIÓN DE MEMORIA 3 hrs.
CAPÍTULO VI : CONCURRENCIA 4 hrs.
CAPÍTULO VII : ASPECTOS DE SEGURIDAD 2 hrs.
CAPÍTULO VIII : ELEMENTOS DE CONFIGURACIÓN 2 hrs.
CAPÍTULO IX : ALGUNOS SISTEMAS OPERATIVOS 4 hrs.
RESOLUCIÓN DE PREGUNTAS Y PROBLEMAS 12 hrs.
TIEMPO TOTAL DE LECTURA Y ESTUDIO 36 hrs.
NOTA: Lea todo el manual, al menos una vez, antes de comenzar su estudio detallado.
Página 2 de 164
ÍNDICE
INTRODUCCIÓN ............................................................................................7
¿Qué Es Un Sistema Operativo? ............................................................................................... 8
El Sistema Operativo Como Máquina Virtual...........................................................................................................8
El Sistema Operativo Como Administrador De Recursos......................................................................................9
Resumen Histórico................................................................................................................. 10
Sistemas De Procesamiento Por Lotes (Batch)....................................................................................................10
SERVICIOS DE LOS SISTEMAS OPERATIVOS........................................11

Monoprogramación................................................................................................................ 11
Multiprogramación ................................................................................................................ 11
Tiempo Compartido................................................................................................................ 12
Sistemas De Tiempo Real........................................................................................................ 12
Multiproceso.......................................................................................................................... 13
Sistemas Multiprocesadores.....................................................................................................................................13
Sistemas Distribuidos.................................................................................................................................................14
ELEMENTOS BÁSICOS ...............................................................................15

Llamadas Al Sistema .............................................................................................................. 15
Programas Del Sistema .......................................................................................................... 16
Procesamiento Concurrente.................................................................................................... 16
Procesos ......................................................................................................................................................................17
Relación Entre Los Procesos ...................................................................................................................................17
Especificación De Los Procesos ..............................................................................................................................18
Estados De Los Procesos .........................................................................................................................................18
Transiciones entre los estados.................................................................................................................................19
El Bloque De Control De Procesos (PCB, Process Control Block )...................................................................24
Procesos y Hebras .....................................................................................................................................................25
Operaciones ................................................................................................................................................................25
El Planificador De Procesos .....................................................................................................................................25
Criterios De Performance..........................................................................................................................................26
Conceptos Básicos De Un Sistema Operativo........................................................................... 26
Modelo Sencillo De Un Sistema Operativo ............................................................................................................27
Interrupciones: La Base De Los Sistemas Operativos Modernos ......................................................................29
Administración De Datos........................................................................................................ 33
Archivos........................................................................................................................................................................34
Tipos Y Estructuras De Archivos .............................................................................................................................34
Operaciones Con Los Archivos................................................................................................................................34
Directorios De Archivos .............................................................................................................................................35
Operaciones Con Los Directorios ............................................................................................................................36
Acceso Secuencial .....................................................................................................................................................38
Acceso Directo............................................................................................................................................................38
Otros Métodos De Acceso........................................................................................................................................38
Realización Del Sistema De Archivos.....................................................................................................................38
Administración De Dispositivos De Almacenamiento Rotacional............................................. 40
Estructura De Un Disco .............................................................................................................................................41
Estructura Física.........................................................................................................................................................41
Estructura Lógica........................................................................................................................................................42
Planificación De Discos .............................................................................................................................................43
Evaluación De Desempeño.......................................................................................................................................45
Página 3 de 164
ADMINISTRACIÓN DE CPU .......................................................................48
Algoritmo FCFS..................................................................................................................... 49
Algoritmos SJF & SRT........................................................................................................... 49
Planificación Por Prioridades................................................................................................. 50
Algoritmo Round Robin.......................................................................................................... 50
Colas Multinivel..................................................................................................................... 50
Algoritmo Round Robin Virtual.............................................................................................. 51
Evaluación De Las Políticas................................................................................................... 51
ADMINISTRACIÓN DE MEMORIA............................................................52
La memoria dedicada. ............................................................................................................ 52
División De Memoria: El Monitor Residente........................................................................... 52
Protección de la memoria ....................................................................................................... 52
Reasignación de direcciones................................................................................................... 53
Memoria Virtual..................................................................................................................... 53
Swapping ............................................................................................................................... 54
Segmentación......................................................................................................................... 55
Paginación............................................................................................................................. 56
Paginación De Múltiples Niveles............................................................................................. 59
Segmentación/Paginación ...................................................................................................... 60
Fragmentación....................................................................................................................... 60
Estrategias De Localidad ........................................................................................................ 60
Concepto De Localidad.............................................................................................................................................60
Conjunto De Trabajo..................................................................................................................................................61
Algoritmos De Reemplazo....................................................................................................... 62
Algoritmo De Bits Adicionales De Referencia........................................................................................................63
Algoritmo De Segunda Oportunidad........................................................................................................................63
Algoritmo LFU .............................................................................................................................................................63
Algoritmo MFU ............................................................................................................................................................64
Algoritmos Adicionales...............................................................................................................................................64
Algoritmos Basados En Ajuste .................................................................................................................................64
CONCURRENCIA .........................................................................................65
Secciones Críticas................................................................................................................... 66
Operaciones Lock/Unlock.........................................................................................................................................67
Bloqueo Mediante El Uso De Variables Compartidas ..........................................................................................67
Sincronización De Ejecución....................................................................................................................................68
Algoritmo de Peterson...............................................................................................................................................69
Algoritmo De Dekker..................................................................................................................................................70
Sincronización Con Instrucciones De Hardware...................................................................................................71
Semáforos....................................................................................................................................................................72
Operaciones Wait/Signal...........................................................................................................................................72
Versión Más General De Los Semáforos ...............................................................................................................74
Buffers Múltiples .........................................................................................................................................................74
Comunicación Entre Procesos ................................................................................................ 75
Técnicas De Comunicación......................................................................................................................................75
Sistema Maestro-Sirviente........................................................................................................................................76
Sistema De Diálogo....................................................................................................................................................76
Sistema De Correo.....................................................................................................................................................76
Transmisión Entre Mensajes, Comunicación Directa...........................................................................................77
Transmisión Entre Mensajes, Comunicación Indirecta ........................................................................................77
Utilización De Buffers.................................................................................................................................................78
Monitores .....................................................................................................................................................................79
Propietarios..................................................................................................................................................................81
Página 4 de 164
Deadlocks (Interbloqueos)...................................................................................................... 83
Prevención De Interbloqueos ...................................................................................................................................83
Evitación De Los Interbloqueos................................................................................................................................84
Detección De Los Interbloqueos ..............................................................................................................................85
Recuperación De Interbloqueos...............................................................................................................................86
ASPECTOS DE SEGURIDAD .......................................................................88

Técnicas De Protección .......................................................................................................... 88
Nominación..................................................................................................................................................................88
Contraseñas ................................................................................................................................................................89
Dominios de Protección.............................................................................................................................................89
Matriz De Acceso........................................................................................................................................................89
Listas De Acceso........................................................................................................................................................90
Usuarios y Grupos De Acceso.................................................................................................................................90
Seguridad De Los Sistemas Operativos.................................................................................... 91
Concepto De Seguridad............................................................................................................................................91
Métodos De Verificación............................................................................................................................................92
Estrategia De Total Seguridad.................................................................................................................................92
Seguridad Externa......................................................................................................................................................93
Seguridad De Operación...........................................................................................................................................93
Vigilancia......................................................................................................................................................................93
Supervisión De Amenazas ........................................................................................................................................94
Protección Por Contraseña (Llave/Cerradura)......................................................................................................94
Auditoría .......................................................................................................................................................................95
Criptografía ..................................................................................................................................................................95
ELEMENTOS DE CONFIGURACIÓN.........................................................97
Estructuras De Sistemas Operativos (Diseños) ........................................................................ 97
Sistemas Monolíticos (DOS, MAC)..........................................................................................................................97
Sistemas Con Capas (Unix / OS2) ..........................................................................................................................97
Máquinas Virtuales (VM/370 CMS (Conversational Monitor System))..............................................................97
Sistemas De Microkernel...........................................................................................................................................97
Organizaciones Más Comunes De Multiprocesadores.............................................................. 98
Tiempo Compartido O Bus Común (Conductor Común).....................................................................................98
Matriz De Barras Cruzadas E Interruptores ...........................................................................................................99
Almacenamiento De Interconexión Múltiple...........................................................................................................99
Conexiones Hipercubo............................................................................................................................................ 100
Organización De Los Sistemas Operativos De Multiprocesadores .......................................... 100
Sistemas Ligeramente Acoplados v/s Sistemas Rígidamente Acoplados ..................................................... 100
Maestro/Satélite....................................................................................................................................................... 101
Ejecutivos Separados ............................................................................................................................................. 101
Simétrico................................................................................................................................................................... 101
Consideraciones finales........................................................................................................ 101
ALGUNOS SISTEMAS OPERATIVOS ......................................................102

Sistema Operativo Unix ........................................................................................................ 102
Control Y Sincronización De Procesos ................................................................................................................ 102
Creación De Procesos ............................................................................................................................................ 104
Comunicación Entre Procesos .............................................................................................................................. 104
Gestión De La Memoria.......................................................................................................................................... 105
Sistema De Archivos............................................................................................................................................... 106
Subsistema De Entrada/Salida............................................................................................................................. 106
Sistema Operativo Novell Netware ........................................................................................ 108
Netware 4.X.............................................................................................................................................................. 108
Protocolo Básico De Netware................................................................................................................................ 108
Niveles Internos De Netware................................................................................................................................. 109
Página 5 de 164
Características De Rendimiento............................................................................................................................ 110
Características De Protección De Datos ............................................................................................................. 111
Otras Prestaciones .................................................................................................................................................. 112
Sistema Operativo Windows NT............................................................................................ 113
Otras Características .............................................................................................................................................. 113
Control Y Sincronización De Procesos ................................................................................................................ 114
Gestión De Memoria............................................................................................................................................... 114
Sistema Operativo Windows 2000 ......................................................................................... 116
Instalación Más Sencilla......................................................................................................................................... 116
La Evolución Plug & Play....................................................................................................................................... 117
Lo Mejor De Versiones De Las Anteriores.......................................................................................................... 117
Seguridad Basada En Elevados Estándares De Desempeño ......................................................................... 118
Sistema Operativo Linux ...................................................................................................... 121
¿Por Qué Utilizar Linux? ........................................................................................................................................ 121
Descripción De Las Funciones De Linux............................................................................................................. 122
¿Qué Se Puede Hacer Con Linux? ...................................................................................................................... 124
Distribuciones ........................................................................................................................................................... 124
PREGUNTAS Y PROBLEMAS RESUELTOS............................................126

Unidades I, II, III & IV: ....................................................................................................... 126
Preguntas De Selección Múltiple.......................................................................................................................... 126
Preguntas De Términos Pareados ....................................................................................................................... 133
Preguntas De Desarrollo ........................................................................................................................................ 134
Problemas ................................................................................................................................................................. 135
Unidades V & VI:................................................................................................................. 137
Preguntas de términos pareados .......................................................................................................................... 141
Problemas ................................................................................................................................................................. 143
Unidades VII, VIII & IX: ..................................................................................................... 145
Respuestas y Soluciones:...................................................................................................... 150
Preguntas de desarrollo.......................................................................................................................................... 154
Problemas ................................................................................................................................................................. 157
BIBLIOGRAFÍA ..........................................................................................162
ÍNDICE ALFABÉTICO...............................................................................163
Página 6 de 164
CAP ÍT UL O I
INT RODUCCIÓN
Todo el hardware de un sistema computacional a cualquier nivel se compone de una serie de recursos
físicos que van desde periféricos en general hasta la misma CPU. Los software de aplicación son los
encargados de dar un uso adecuado a todo este conjunto de recursos.
Un sistema operativo es un conjunto de programas que supervisan la ejecución de todos los programas
de aplicación y controlan la utilización de todos los recursos de hardware que estén disponibles al
momento de su ejecución.
En los años sesenta, un sistema operativo se podría haber definido como el software que controla al
hardware. Sin embargo, actualmente existe una tendencia significativa a la transferencia de las
(*)
funciones del software al firmware , es decir, microcódigo. Dicha tendencia se ha pronunciado tanto que
es probable que en algunos sistemas las funciones codificadas en firmware sobrepasen pronto a
aquellas codificadas en software.
Es evidente que se necesita una nueva definición de sistema operativo. Se puede imaginar un sistema
operativo como los programas, instalados en el software o el firmware, que hacen utilizable el hardware.
El hardware proporciona la "capacidad bruta de cómputo"; los sistemas operativos ponen dicha
capacidad de cómputo al alcance de los usuarios y administran cuidadosamente el hardware para lograr
un buen rendimiento.
El estudio de los sistemas operativos ha llegado ha ser un tópico importante en las ciencias de la
computación después de la introducción del concepto time sharing, multiprogramación y multitarea,
características que hasta hoy en día aún siguen revolucionando el ambiente computacional.
La actual es una etapa muy interesante en la evolución de los sistemas operativos. La capacidad de los
computadores continúa aumentando a una velocidad vertiginosa, mientras que su costo se reduce
asombrosamente. En esta década son muy comunes las estaciones de trabajo de escritorio con
velocidades de procesamiento muy elevadas y ya se habla de máquinas de escritorio capaces de
manejar velocidades de más de mil millones de instrucciones por segundo. Como el costo de los
procesadores se está reduciendo tanto, las arquitecturas de los procesadores múltiples y en red están
creando un sin número de oportunidades para investigar y desarrollar nuevas estrategias de hardware y
software. Los lenguajes de programación secuenciales han sido desplazados por lenguajes de
programación concurrentes que permitan especificar actividades de cómputo en paralelo. El enfoque de
sistemas abiertos, en el cual los proveedores de hardware, software y dispositivos de comunicación
producen sistemas que se ajustan a estándares aceptados internacionalmente, presenta nuevos retos a
los fabricantes que antes se concentraban en sus propias arquitecturas. Los nuevos estándares
internacionales que rigen la comunicación abierta, OSI (Open System Interconnection) e ISDN
(Integrated Services Digital Network) ya permiten que los computadores de todo el mundo se
comuniquen fácilmente entre sí, lo cual representa un paso gigante hacia el establecimiento de la
computación distribuida a escala mundial.
(*)
EI concepto de microprogramación (firmware) se atribuye por lo general al profesor Maurice Wilkes quien, en
1951, presentó conceptos que forman la base de las técnicas actuales de microprogramación. Sin embargo, no fue
sino hasta mediados de los años sesenta, cuando se generalizó la microprogramación. La microprogramación
introduce una capa de programación debajo del lenguaje de máquina del computador. Como tal, hace posible la
definición de instrucciones en lenguaje de máquina. La microprogramación, que se ejecuta en una memoria de
control de alta velocidad, es parte integral de las arquitecturas de computador modernas y es importante para los
aspectos de rendimiento y seguridad de los sistemas operativos.
Página 7 de 164
¿Qué Es Un Sistema O pera tivo?
El sistema operativo es el ente intermedio entre las aplicaciones

y la máquina; es el encargado de interpretar las instrucciones de
las aplicaciones y traducir los códigos de respuesta de la
máquina, así como también es el encargado de asignar en forma
racional y eficiente los recursos que precisen los software de
aplicación.
A pesar de que todo el mundo utiliza sistemas operativos casi a

diario, es difícil definir qué es un sistema operativo. En parte,
esto se debe a que los sistemas operativos realizan dos
funciones diferentes:
• Proveer una máquina virtual, es decir, un ambiente en el cual el

usuario pueda ejecutar programas de manera conveniente,
protegiéndolo de los detalles y complejidades del hardware.
• Administrar eficientemente los recursos del computador.
El Sistema Operativo Como Máquina Virtual
Un computador se compone de uno o más procesadores o CPUs, memoria principal o RAM, memoria
secundaria (discos), tarjetas de expansión (tarjetas de red, módems y otros), monitor, teclado, mouse y
otros dispositivos. O sea, es un sistema complejo. Escribir programas que hagan uso correcto de todos
estos componentes no es una tarea trivial (peor aún si se habla del uso óptimo). Si cada programador
tuviera que preocuparse, por ejemplo, de cómo funciona el disco duro del computador, teniendo además
siempre presentes todas las posibles cosas que podrían fallar, entonces a la fecha se habría escrito una
cantidad bastante reducida de programas.
Es mucho más fácil decir “escriba lo apuntado por este puntero al final del archivo datos”, que decir:
1. Poner en determinados registros del controlador de disco la dirección que se quiere escribir, el
número de bytes que se desea escribir, la posición de memoria donde está la información a escribir,
el sentido de la operación (lectura o escritura), amén de otros parámetros;
2. Decir al controlador que efectué la operación;
3. Esperar. Decidir qué hacer si el controlador se demora más de lo esperado (¿cuánto es "lo
esperado"?);
4. Interpretar el resultado de la operación (una serie de bits);
5. Reintentar si algo anduvo mal, etc.
Además, habría que rescribir el programa si se instala un disco diferente o se desea ejecutar el
programa en otra máquina.
Hace muchos años que quedó claro que era necesario encontrar algún medio para aislar a los
programadores de las complejidades del hardware. Esa es precisamente una de las tareas del sistema
operativo, que puede ser visto como una capa de software que maneja todas las partes del sistema y
hace de intermediario entre el hardware y los programas del usuario. De esta manera, el sistema
operativo presenta una interfaz o máquina virtual que es más fácil de entender y de programar que la
máquina "pura". Además, para una misma familia de máquinas, aunque tengan componentes diferentes
(por ejemplo, monitores de distinta resolución o discos duros de diversos fabricantes), la máquina virtual
puede ser idéntica: el programador ve exactamente la misma interfaz.
Página 8 de 164
El Sistema Operativo Como Administrador De Recursos
La otra tarea del sistema operativo consiste en administrar los recursos del computador cuando hay dos
o más programas que se ejecutan simultáneamente y además requieren usar el mismo recurso (como
tiempo de CPU, memoria o impresora).
Además, en un sistema multiusuario, suele ser necesario (o conveniente) compartir información (además
de dispositivos físicos). Al mismo tiempo, deben tenerse en cuenta una serie de consideraciones de
seguridad; Por ejemplo: la información confidencial sólo debe ser accedida por usuarios autorizados, un
usuario cualquiera no debiera ser capaz de sobrescribir áreas críticas del sistema, etc. (En este caso, un
usuario puede ser una persona, un programa, u otro computador). En resumen, el sistema operativo
debe llevar la cuenta acerca de quién está usando qué recursos; otorgar recursos a quienes lo solicitan
(siempre que el solicitante tenga derechos adecuados sobre el recurso); y arbitrar en caso de solicitudes
conflictivas.
En síntesis, se puede afirmar que las principales tareas que realiza un sistema operativo son:
a. Administración de memoria
• Mantiene el estado de los programas y datos residentes en memoria, esperando el uso de la

CPU, algún dispositivo de E/S o la utilización de algún otro recurso.
• Contiene tablas de asignación de direcciones que indican qué programas y datos están en
memoria, cuanto espacio ocupan en forma independiente y dónde están ubicados.
• Asigna o quita espacio en memoria a programas según sea posible o requerido.
b. Administración de CPU
• Decide qué programa hace uso del recurso de la unidad central de procesamiento, en que
momento y por cuánto tiempo.
• Crea una lista de espera con los programas que están solicitando utilizar este recurso a fin de
poder asignar posteriormente el recurso bajo alguna política de prioridad.
c. Manejo de dispositivos de E/S
• Controla el flujo de datos desde y hacia cualquier dispositivo de entrada y salida.

• Controla la comunicación con los dispositivos de E/S y para dispositivos particulares existen
programas especiales de control de periféricos (drivers).
d. Administración de archivos en disco
• Crea, elimina, copia y controla el acceso a los archivos. Mantiene directorios de los archivos
existentes en el disco y administra el espacio libre.
e. Comunicación con el usuario
• Permite que el operador controle el computador.

• Indica y, si es posible, controla los errores ocurridos en el sistema. Por ejemplo el término
anormal de alguna aplicación debido a fallas de la aplicación misma o problemas de hardware.
• Indica el número de usuarios que están utilizando el sistema computacional.
• Permite la utilización de dispositivos generales o particulares; cuando no se encuentran
disponibles envía un correspondiente mensaje de información al usuario o la aplicación que lo
solicita.
Página 9 de 164
Resumen Histórico
En un principio sólo existía el hardware del computador. Los primeros computadores eran voluminosas
máquinas que se operaban directamente desde una consola. Pero con el transcurso del tiempo se hizo
evidente la necesidad de simplificar la tarea de los programadores, quienes progresivamente se veían
ante la necesidad de crear programas de aplicación cada vez más grandes y consecuentemente el
proceso de detección y corrección de fallas en interacción directa con la máquina se hacía cada vez más
lento y complejo. Así fue como aparecieron los compiladores FORTRAN y COBOL que hacían en su
tiempo las veces de lo que hoy se conoce como sistema operativo. Posteriormente aparecieron los
sistemas operativos propiamente tales.
A fin de evitar mayores extensiones en cuanto a los detalles de evolución de los sistemas operativos y
en general de los sistemas computacionales, se puede observar la siguiente tabla:
Generación de
Año(s) Características
computadores
• Tubos de vacío y tableros de cómputo.
1° 1945 - 1955 • No existe sistema operativo; se manejan por medio de
hardware y secuencias de comandos directos.
• Transistores y sistemas batch.
2° 1955 - 1965
• Fortran y Assembler en tarjetas perforadas.
• IBM/360 sistema operativo OS/360.
3° 1965 - 1980
• Sistemas operativos de propósito general multimodo.
• Circuitos integrados de gran escala; aparición del PC.
4° 1980 - ...
• Ms-DOS, UNIX, etc.
• Superconductores, Microchips, Pentium, etc.
5° 1990 - ...
• Versiones mejoradas de diversos sistemas operativos.
Sistemas De Procesamiento Por Lotes (Batch)
Para comprender conceptos más específicos, como la diferencia entre el tiempo compartido y la
multiprogramación, primero se ha de conocer el método de procesamiento por lotes. Cuando se
desarrollaron por primera vez los sistemas por lotes, estaban caracterizados por la "agrupación en lotes"
de trabajos similares. Los sistemas basados en tarjetas y cintas sólo permitían el acceso secuencial a los
programas y datos, por lo que únicamente podía usarse un paquete de aplicación en cada ocasión (por
ejemplo, el compilador, ligador y cargador de FORTRAN, o sus equivalentes de COBOL). Al hacerse
factible el almacenamiento en línea en disco fue posible ofrecer un acceso inmediato a todo el paquete
de aplicación. Los sistemas por lotes, hace ya tiempo que dejaron de ser definidos por la agrupación de
trabajos similares; ahora se utilizan otras características.
Un sistema operativo por lotes lee un flujo separado de datos, cada uno con banderas de control que
definen qué hace cada trabajo. Cuando éste termina, generalmente se imprime el resultado a través de
algún dispositivo de salida. La característica que delata un sistema por lotes en forma definitiva es la
ausencia de interconexión entre el usuario y el trabajo mientras se ejecuta. El trabajo se prepara, se
(*)
envía y más tarde se obtiene algún resultado. El tiempo de retorno puede ser el resultado de la
cantidad de procesos que se realizan en forma necesaria, o las demoras, antes de que el sistema
operativo comience a procesar un nuevo lote (o trabajo).
Los sistemas por lotes se caracterizan por ser secuenciales y por el hecho de que la CPU tiene el control
total de la ejecución del proceso. Estos sistemas son muy útiles cuando se trata de la realización de
procesos masivos; sin embargo, el tiempo de proceso es alto y la CPU pasa la mayor parte de ese
tiempo ociosa, debido a la considerable lentitud de los procesos de carga y descarga de paquetes de
información (antiguamente tarjetas). Los sistemas por lotes se pueden clasificar en monoprogramables y
multiprogramables.
(*)
El tiempo de retorno es el tiempo transcurrido desde que se envía el trabajo hasta obtener la salida.
Página 10 de 164
CAP ÍT UL O II
SERVICIOS DE LOS SISTEM AS OPERAT IVOS
M onoprogramación
Se atiende un trabajo a la vez. Cuando el programa entra en proceso se apodera de la CPU y de los
dispositivos de E/S, hasta que termina. La monoprogramación es el modo de trabajo en el que
solamente un programa utiliza el procesador, siendo además el único existente en la memoria principal,
de tal forma que hasta que éste no termine su trabajo no cederá el control al siguiente programa que
será cargado en memoria, sustituyendo al anterior. En el Capítulo N° 5 se detalla el cómo se gestiona la
memoria en aquellos sistemas que utilizan este modo de trabajo.
Los sistemas monoprogramables Los sistemas monoprogramables Los sistemas monoprogramables con
lineales son la expresión más con prioridades se caracterizan por prioridades y tiempo de salida se
simple del sistema operativo y se tener una cola de atención con caracterizan por tener una cola de
caracterizan por tener una cola prioridades y un proceso no atención con prioridades y un proceso
de atención sin prioridades y un termina hasta haber completado su puede terminar al haber completado
proceso no termina hasta haber ejecución. su ejecución o después de haber
completado su ejecución. transcurrido un intervalo de tiempo de
atención prefijado. En el último caso
es devuelto a la cola de atención.
M ultipro grama ción
En un procesamiento por lotes puede ocurrir que en cierto instante ocupe la CPU un proceso que
demande una tarea de impresión; así, él seguirá ocupando la CPU mientras espera que el proceso de
impresión termine, dejando la CPU ociosa. La multiprogramación aumenta la utilización de la CPU
organizando los trabajos de manera que ésta siempre tenga algo que ejecutar.
El concepto es el siguiente: El sistema operativo escoge uno de los trabajos del depósito y lo comienza a
ejecutar. En algún momento, el trabajo tendrá que esperar que se efectúe cierta tarea como montar una
cinta, que se introduzca un mandato mediante el teclado, o que termine una operación de E/S. En un
sistema no multiprogramado, la CPU estaría inactiva. En un sistema multiprogramado, el sistema
operativo cambia a otro trabajo y lo ejecuta; cuando ese trabajo tiene que esperar, la CPU cambia a otro,
y así sucesivamente. Eventualmente el primer trabajo deja de esperar y recupera la CPU; mientras haya
otro trabajo por ejecutar, la CPU nunca estará inactiva. Los sistemas operativos multiprogramados son
bastante complejos. Para que pueda haber varios programas listos para ejecutarse, el sistema debe
conservarlos todos en la memoria al mismo tiempo. Cuando se consigue esto, se necesita alguna forma
de administración de memoria. Además, si al mismo tiempo existen varios programas listos para
ejecutarse, el sistema debe elegir uno de ellos. Esta decisión se denomina planificación de la CPU.
Por otra parte, existen dos formas habituales de organizar la diferencia de velocidades de ejecución
(*) (**)
entre la CPU y los dispositivos: Polling e Interrupciones .
(*)
El polling consiste en que la CPU está constantemente preguntando a cada periférico si tiene algo que hacer.
Página N° 11 de 151
Finalmente, si varios programas se ejecutan concurrentemente, es necesario limitar la posibilidad de que
se interfieran unos a otros en todas las fases del sistema operativo, incluyendo la planificación de
procesos, el almacenamiento en disco y la administración de memoria.
Los sistemas multiprogramables con partición fija disponen de espacios de almacenamiento fijo para los
procesos que se encuentran en la cola; así, un proceso debe esperar hasta que este disponible un
bloque (o más) de memoria lo suficientemente grande para ser atendido. En los sistemas
multiprogramables de partición variable la memoria disponible es dividida en secciones variables de
acuerdo a la demanda de cada uno de los procesos que sean almacenados en ella.
Tiempo Com part ido
El tiempo compartido (o sistemas en línea) es una extensión lógica de la multiprogramación. La CPU

ejecuta las diversas tareas alternando entre ellas, pero estos cambios son tan frecuentes que los
usuarios pueden interactuar con cada programa mientras se ejecuta.
Un sistema operativo de tiempo compartido permite a los diversos usuarios compartir al mismo tiempo el
computador. Puesto que en un sistema de tiempo compartido cada acción o mandato suele ser breve,
sólo se requiere un corto tiempo de la CPU para cada proceso. Como el sistema pasa rápidamente de
un usuario al siguiente, cada uno de ellos tiene la impresión de que cuenta con su propio computador,
cuando en realidad todos comparten sólo uno.
En 1960 se expuso el concepto de tiempo compartido, pero como los sistemas de este tipo eran más
difíciles y costosos de construir; no fueron comunes sino hasta principios de los años setenta. Al crecer
la popularidad del tiempo compartido, los investigadores han tratado de combinar los sistemas por lotes
y de tiempo compartido en uno solo. Diversos sistemas de computación diseñados inicialmente como
sistemas por lotes se han modificado para crear un subsistema de tiempo compartido. Hoy en día, la
mayoría de los sistemas ofrecen tanto el procesamiento por lotes como el tiempo compartido, aunque
siempre su diseño básico se inclina hacia uno u otro tipo.
Los sistemas operativos de tiempo compartido son complejos y ofrecen algún mecanismo para la
ejecución concurrente. Además, como en la multiprogramación, hay que conservar simultáneamente
varios programas en la memoria, lo que requiere algún tipo de administración de memoria, protección y
planificación de la CPU. Para lograr un tiempo de respuesta razonable hay que intercambiar los trabajos
entre la memoria principal y el disco que funciona como almacenamiento de respaldo para la memoria
principal. Por tanto, también es necesario proporcionar administración del disco. Los sistemas de tiempo
compartido deben ofrecer, además, un sistema de archivos en línea. La multiprogramación y el tiempo
compartido son los aspectos centrales de los sistemas operativos modernos.
Sistemas De Tiem po Real
Se utilizan cuando hay requerimientos de tiempo muy rígidos en las operaciones o en el flujo de datos,
generalmente se utilizan como sistemas de control en una aplicación dedicada. Por ejemplo: sistemas de
control industrial, experimentos científicos y sistemas médicos. Los sistemas de tiempo real se pueden
clasificar en:
• Los sistemas de tiempo real por hard: que garantizan que las tareas críticas se ejecutan a tiempo. Los datos son
almacenados en memorias no volátiles (ROM), no utilizan técnicas de memoria virtual ni tiempo compartido, ambas técnicas
no pueden ser implementadas por hardware.
• Los sistemas de tiempo real por soft: que ejecutan tareas menos críticas y manejan técnicas de prioridades para la
asignación de tareas. Estos sistemas tienen menos utilidades que los implementados por hard, por ejemplo no pueden
utilizarse para control industrial ni en robótica. Pero sí para multimedia, supervisión de controles industriales y realidad virtual.
(**)
Las interrupciones permiten que la CPU se concentre en la atención de procesos; luego, cuando un dispositivo
requiere de la atención de la CPU, le enviará una solicitud de interrupción. Es decir es el procedimiento inverso al
polling.
Página 12 de 164
M ultipro ceso
Una nueva tendencia de los sistemas de computación es distribuir los cálculos entre varios
procesadores. Existen dos esquemas básicos para la construcción de estos sistemas de multiproceso (o
distribuidos). En un sistema fuertemente acoplado los procesadores comparten la memoria y un reloj, y
por lo general la comunicación se lleva a cabo a través de una memoria compartida.
En un sistema débilmente acoplado los procesadores no comparten ni memoria ni reloj, pues cada uno
cuenta con su propia memoria local. Los procesadores se comunican a través de distintas líneas de
comunicación, como canales de alta velocidad o líneas telefónicas. A estos sistemas generalmente se
les conoce como sistemas distribuidos y en ellos los procesadores pueden variar en cuanto a tamaño y
función; pueden incluir pequeños microprocesadores, estaciones de trabajo, minicomputadores y
grandes sistemas de computación de propósito general.
Algunas de las razones para construir sistemas distribuidos son las siguientes:
a. Compartimiento de recursos
Si varias instalaciones (con distintas capacidades) están conectadas entre sí, entonces un usuario puede
utilizar desde una instalación los recursos disponibles en otra. Por ejemplo, en la instalación A se puede
utilizar una impresora láser sólo disponible en la instalación B. Al mismo tiempo, en B es posible tener
acceso a un archivo que reside en A. En general, el compartimiento de recursos en un sistema
distribuido ofrece los mecanismos para compartir archivos en instalaciones remotas, procesar
información en una base de datos distribuida, imprimir archivos en instalaciones remotas, utilizar
dispositivos remotos de hardware especializado y llevar a cabo otras operaciones.
b. Aceleración de los cálculos
Si un cálculo determinado puede dividirse en varios subcálculos que se ejecuten concurrentemente, un

sistema distribuido permitiría distribuir los cálculos entre las diversas instalaciones y también ejecutarlos
concurrentemente. Además, si en un momento dado una instalación esta sobrecargada con trabajos,
algunos de ellos pueden pasarse a otras instalaciones con poca carga. A este movimiento de trabajos se
le llama compartimiento de cargas.
c. Confiabilidad
Si falla una instalación de un sistema distribuido, las restantes pueden, potencialmente, continuar
operando. Si el sistema se compone de varias instalaciones autónomas de gran tamaño, la avería de
una no debe afectar a las demás. Si, por otra parte, el sistema esta compuesto por varias máquinas
pequeñas, cada una responsable de alguna función indispensable del sistema, entonces un solo error
puede detener el funcionamiento de todo el sistema. En general, si hay suficiente redundancia en el
sistema (tanto en hardware como en datos), el sistema puede continuar su operación, incluso cuando
fallen algunas de las instalaciones.
d. Comunicación
Existen varias situaciones más donde los programas de un sistema necesitan intercambiar datos entre
sí. Un ejemplo son los sistemas de ventanas, ya que con frecuencia se comparten datos o se transfieren
entre ventanas. Cuando varias instalaciones están conectadas entre sí por una red de comunicaciones,
los procesos en las distintas instalaciones tienen la oportunidad de intercambiar información.
Sistemas Multiprocesadores
Un sistema multiprocesador tiene más de una CPU compartiendo memoria y periféricos. Las ventajas
más evidentes son mayor potencia de computación y fiabilidad.
Estos sistemas asignan una tarea específica a cada procesador. Un procesador maestro controla el
sistema, los otros esperan al maestro o tienen tareas predefinidas. Este esquema define una relación
Página 13 de 164
maestro/esclavo. Pueden usarse pequeños ordenadores situados a cierta distancia de la CPU principal,
trabajando en lectoras de tarjetas e impresoras en línea y transfiriendo estos trabajos hacia y desde la
CPU principal. Los sistemas de tiempo compartido se componen generalmente de un ordenador grande
(principal) y un ordenador más pequeño que sólo es responsable de las entradas y salidas sobre
terminales.
Otra forma son las redes de ordenadores, donde se comunican muchos sistemas informáticos
independientes, transfiriéndose información. Sin embargo, cada sistema tiene su propio sistema
operativo y trabaja independientemente.
Estos esquemas se pueden clasificar en sistemas multiprocesadores simétricos, en el cual cada

procesador corre una copia idéntica del sistema operativo y se comunica con los demás procesadores
según sus necesidades; o multiprocesadores asimétricos, en los cuales cada procesador tiene asignado
una tarea predefinida. Un procesador maestro controla el sistema. (Para mayor información véase capítulo
VIII)
Sistemas Distribuidos
La principal diferencia entre los sistemas de multiprocesadores y distribuidos, es que estos últimos no
comparten memoria ni periféricos. Cada procesador tiene su propia memoria local. Los procesadores se
comunican entre si a través de varias líneas de comunicación, tales como líneas telefónicas o buses de
alta velocidad. Dicho de otra forma, se trata de redes de computadores donde los procesadores pueden
variar en tamaño y función.
Página 14 de 164
CAP ÍT UL O III
ELEMENT OS BÁSICOS
Recordando lo señalado en el primer capítulo, los tipos de servicios de los sistemas operativos son:
• Ejecución de programas. El sistema tiene que ser capaz de cargar un programa en memoria y
ejecutarlo.
• Operaciones de entrada/salida. Como un programa no puede acceder directamente a un

dispositivo de E/S el sistema operativo debe facilitarle algunos medios para realizarlo.
• Manipulación del sistema de archivos. El sistema operativo debe facilitar las herramientas
necesarias para que los programas puedan leer, escribir y eliminar archivos.
• Detección de errores. El sistema operativo necesita constantemente detectar posibles errores. Los
errores pueden producirse en la CPU y en el hardware de la memoria, en los dispositivos de E/S o
bien en el programa de usuario. Para cada tipo de error, el sistema operativo debe adoptar la
iniciativa apropiada que garantice una computación (u operación) correcta y consistente.
Los sistemas operativos con usuarios múltiples pueden mejorar su eficiencia compartiendo entre ellos
los recursos del computador. Esto implica:
• Asignación de recursos. Cuando hay múltiples usuarios o múltiples trabajos ejecutándose al

mismo tiempo, hay que asignar recursos a cada uno de ellos. El sistema operativo gestiona muchos
tipos de recursos diferentes.
• Contabilidad. Se desea controlar los pasos de los usuarios que utilizan el computador, en qué
medida lo hacen y qué tipo de recursos emplean.
• Protección. Cuando hay muchos trabajos ejecutándose al mismo tiempo no debe ser posible que un
trabajo interfiera sobre otro.
Los sistemas operativos prestan sus servicios de muchas maneras. Dos métodos básicos de prestación
de servicios son las llamadas al sistema y los programas de sistemas.
Llamadas Al Sistema
Constituyen una interfaz entre los programas que se están ejecutando y el sistema operativo. Estas
llamadas se implementan generalmente por instrucciones en lenguaje de máquina.
Se pueden agrupar en tres categorías: control de procesos o de trabajos, manipulación de dispositivos y

archivos, y mantenimiento de información.
Control de procesos y de trabajos:

• Finalización (normal o anormal).
• Cargar o ejecutar otro programa.
• Crear nuevos procesos, terminar procesos.
• Obtener atributos de un proceso y establecer atributos de un proceso.
• Esperar un tiempo.
• Esperar un suceso.
Manipulación de archivos:
• Crear y borrar un archivo.
• Abrir y cerrar un archivo.
• Leer, escribir y reposicionar un archivo.
• Obtener atributos de un archivo y establecer atributos de un archivo.
Página 15 de 164
Manipulación de dispositivos:
• Solicitar dispositivo y liberar dispositivo.

• Leer, escribir y reposicionar.
• Obtener atributos de dispositivos y establecer atributos de dispositivos.
Mantenimiento de información:
• Obtener y/o establecer hora o fecha.

• Obtener y/o modificar datos del sistema.
• Obtener y/o establecer atributos de proceso, archivos o dispositivos.
Programas Del S istema
Son un grupo de programas que resuelven problemas corrientes y ofrecen un entorno más adecuado
para el desarrollo y la ejecución de programas.
Se pueden dividir en las siguientes categorías:
• Manipulación de archivos: Estos programas crean, borran, copian, renombran, imprimen, listan y
generalmente manejan archivos y directorios.
• Información de estados: Usados para pedir la fecha, la hora, la cantidad de memoria disponible o
el espacio en disco.
• Modificación de archivos: Editores de texto usados para crear y modificar el contenido de un

archivo.
• Soporte al lenguaje de programación: Compiladores, intérpretes y ensambladores que dan

soporte a lenguajes de alto nivel.
• Programas de aplicación: Programas que son útiles para resolver problemas corrientes, como
editores de texto, programas gráficos (o de diseño), calculadoras, etc.
Uno de los programas más importantes en un sistema operativo es el intérprete de comandos, éste se
ejecuta al iniciar el sistema operativo, su función es sencilla: captar un comando dictado por el usuario,
interpretarlo y ejecutarlo. Por ejemplo el comando Delete archivo utilizado por DOS; Para que este
comando se pueda ejecutar el intérprete de comandos debe contener el programa adecuado que elimine
el archivo del disco rígido.
Procesamiento Concurrente
La CPU ejecuta una elevada cantidad de programas y su principal ocupación es la ejecución de los
programas de usuario. Este proceso de ejecución de procesos se realiza a través de procesos. Un
proceso es la unidad de trabajo dentro de un sistema, el cual consiste en un conjunto de procesos: los
procesos del sistema operativo ejecutan código del sistema y los procesos de los usuarios ejecutan
código de los usuarios.
En potencia, todos estos procesos se pueden ejecutar concurrentemente y la CPU o varias de ellas se
multiplexan entre ellos. Al conmutar la CPU entre procesos, el sistema operativo puede hacer más
productivo al computador.
Página 16 de 164
Procesos
Un proceso es cualquier tipo de actividad que demande de la atención de utilización de la CPU de una
máquina. Quedan contenidos en este concepto los trabajos de ejecución por lotes, los programas de
usuario o tareas y el apoyo de actividades internas propias del sistema.
Distinción entre programas y procesos: Cada invocación a un programa genera un proceso distinto e
independiente. Los procesos compiten por el uso de los recursos del sistema, de manera que se
necesitan herramientas que permitan la sincronización y la comunicación entre los mismos. A veces,
dos o más procesos cooperan para alguna operación común. En cualquier instante, sólo un proceso
estará en ejecución mientras que los otros estarán suspendidos, preparados o esperando a que ocurra
algún evento.
“La diferencia entre un programa (conjunto de instrucciones) y un proceso (instrucciones ejecutándose)

es obvia, pero crucial para atender el funcionamiento de los sistemas operativos.”
Imagínese un mecánico de automóviles en un taller donde se reparan vehículos con averías complejas
en las que se hace necesario consultar el manual de reparaciones de cada modelo, que contiene
instrucciones para todas las posibles averías. Además, se permiten reparaciones rápidas a las que se
les da mayor prioridad que a las mencionadas anteriormente. Existe en el taller un almacén de repuestos
de todo tipo y herramientas suficientes para las reparaciones.
Comparando esta situación con una computadora, se pueden establecer las siguientes analogías:
• El mecánico sería el procesador que va a realizar el trabajo.

• El manual de cada reparación sería el programa.
• Las herramientas serían los recursos disponibles.
• Las piezas de recambio serían los datos.
• La actividad de utilizar las herramientas para desmontar las piezas defectuosas sustituyéndolas por otras nuevas siguiendo
las instrucciones del manual equivaldría al proceso.
Supóngase que en un determinado momento el mecánico está realizando un reparación compleja (de las
que llevan tiempo) y aparece un vehículo que solicita una reparación de las rápidas (ha aparecido una
interrupción). El mecánico suspende momentáneamente la reparación compleja anotando en qué
situación se queda dicha reparación y qué operación estaba realizando es este momento (guarda el
estado del proceso). Asimismo, sustituye el manual que estaba utilizando por el de la reparación rápida
que se dispone a realizar (cambio de programa). Comienza la nueva reparación (cambio de proceso), en
la que las herramientas no serán las mismas que antes (distintos recursos); las indicaciones de usuario,
las piezas de repuesto (datos) y las indicaciones del manual (programa) llevarán a feliz término la
reparación para que el mecánico vuelva a continuación a la reparación inicial.
Con este ejemplo se desea resaltar que un proceso es una actividad que se apoya en datos, recursos,
un estado en cada momento y un programa.
Relación Entre Los Procesos
El sistema operativo debe suministrar los servicios necesarios que permitan:
a) Ejecución concurrente de los procesos.

b) Sincronización entre procesos.
c) Comunicación entre procesos.
Además, debe disponer de algoritmos de gestión y planificación de procesos que se encarguen de:
a) Decidir qué proceso se ejecutará o tomará el procesador.

b) Llevar cuenta de los estados de los procesos, sus prioridades y toda la información relevante
acerca de ellos.
Dependiendo de la interacción entre los procesos, estos se clasifican en:

Página 17 de 164
a) Independientes: No se comunican o sincronizan entre ellos. En un sistema con un sólo
procesador, los procesos independientes no existen (en sentido estricto).
b) Cooperativos: Se comunican y sincronizan sus actividades para realizar una labor común.
c) Competitivos: Todos compiten por los recursos del computador. El acceso ordenado a estos
necesita de la sincronización y, a veces, también de la comunicación entre los procesos.
Especificación De Los Procesos
• Implícitos: Procesos generados y eliminados por el SO.

• Explícitos: Definidos por el usuario realizando llamadas al sistema.
• Proceso padre: Que crea otro proceso. Puede tener varios hijos.
• Proceso hijo: Procesos creados por otro. Sólo pueden tener un padre.
El sistema operativo hace que los argumentos y variables locales del procedimiento o función que da
lugar al proceso se asocien a éste y no al código en el que aparecen. El sistema crea para cada proceso
un conjunto independiente de variables locales, parámetros formales y llamadas a los procedimientos y a
las funciones.
Estados De Los Procesos
Todo proceso, desde que se crea hasta que se destruye, pasa a través de una serie de estados
discretos. En forma general, los estados de un proceso se pueden clasificar en:
a) Activo: Proceso que está ejecutándose en un instante dado.

b) Preparado: Listo para ejecutarse, esperando a que el procesador quede libre.
c) Bloqueado o suspendido: Esperando a que se cumpla alguna condición (E/S, señal, etc.).
d) Muerto: Ha terminado su ejecución o el sistema operativo ha detectado un error fatal.
e) Nonato: Existe, pero todavía no es conocido por el sistema operativo
f) Estado global del sistema: Conjunto de recursos y procesos existentes con sus estados
correspondientes en un instante determinado. El sistema operativo lo cambia en respuesta a
eventos externos o internos.
El sistema operativo dispone de algoritmos de planificación y de gestión de los procesos y de los

recursos de modo que, considerando como entradas los eventos y el estado global del sistema, genera
un nuevo estado global.
Un gran número de autores, considera que los estados más importantes son:
a. Estados activos. Un proceso que esté en un estado activo puede competir por recursos.
b. Estados inactivos o suspendidos. El sistema no les permite (de manera momentánea) que
compitan por recursos.
c. Estados externos o intermedios. Son estados especiales que se dan durante la creación y
destrucción de los procesos.
Estados Activos
Estado RUNNING o EN EJECUCIÓN
Se dice que un proceso está en estado RUNNING (en ejecución) cuando tiene el control de la CPU (es
decir, cuando la CPU está ejecutando el programa correspondiente a ese proceso). Se dice entonces
que ese proceso es el proceso en curso del procesador.
Página 18 de 164
Estado READY o EJECUTABLE
Se dice que un proceso está en estado READY (ejecutable) cuando lo único que necesita para estar en
ejecución es que se le conceda tiempo de CPU.
Estado BLOCKED o EN ESPERA
Un proceso está en estado BLOCKED (bloqueado) cuando está a la espera de que se produzca una
determinada circunstancia (evento); por ejemplo, un proceso está bloqueado cuando está a la espera de
que se complete la operación de Entrada/Salida que ha solicitado.
Estados Suspendidos
Tanto si un proceso está ejecutándose (RUNNING) y es suspendido a petición suya, o a petición de otro
proceso, como si el proceso está en estado ejecutable (READY), al ser suspendido se provoca una
transición de estado que lo deja en suspendido ejecutable o suspended-ready. Sin embargo, si el
proceso estaba previamente bloqueado (BLOCKED), la transición de estado hará que el proceso pase a
estar en un nuevo estado, que se llama suspendido bloqueado o suspended-blocked.
Estados Intermedios, Externos o Especiales
En algunos sistemas existen otros estados que se denominan externos y que se dan cuando el proceso
se crea antes de que el programa correspondiente se cargue en memoria; o, por otro lado, cuando el
proceso se destruye después de que el programa se haya sacado de memoria. Estos estados son:
WAIT (o ESPERA, o INICIAL, ...)

END (o FIN, o FINAL)
El estado de espera (WAIT) es aquél en el que está el proceso cuando se crea (es decir, se le asignan
dispositivos, se prepara su entorno...), pero aún no está físicamente en memoria. Cuando el proceso
termina, ocurre la situación contraria: el proceso queda en estado END hasta que se ha eliminado
cualquier rastro del proceso (y de sus descendientes, si los hubiera).
Transiciones entre los estados
Distribuidor (dispatcher): Módulo del sistema operativo que se encarga de activar los procesos que
están en el estado preparado.
Interrupción: Hace que la tarea que está activa deje de ejecutarse en favor del sistema operativo que
decidirá cuál de los procesos preparados pasarán a estado activo.
Planificador (scheduler): Hace que el proceso activo vuelva a preparado sin que medie una llamada al
sistema (por fin de tiempo asignado o proceso con mayor prioridad preparado).
Transiciones:
DE A MOTIVOS
preparado
nonato Al crearse
activo
preparado activo Activado por el distribuidor o por el planificador
Activo preparado Interrupción
activo Solicita un recurso necesario para continuar (ej.: E/S)
bloqueado
nonato Necesita que tenga lugar un evento
Acción determinada, como una llamada al sistema del
preparado bloqueado
proceso activo
bloqueado preparado Tiene lugar un evento que estaba esperando
Activo Finaliza
preparado muerto Eliminado por otro proceso
bloqueado
Página 19 de 164
Los sistemas de gestión de procesos deben tener la capacidad de realizar ciertas operaciones más o
menos complejas sobre procesos, como son: conmutación de contexto, bloqueo, desbloqueo,
suspensión, reanudación, creación, destrucción, cambio de prioridad, etc. Estas operaciones son las que
provocan los cambios o transiciones de estado en los procesos.
Es posible representar nuevamente estos estados y las transiciones entre ellos con el siguiente gráfico:
A continuación se explicarán detalladamente estas últimas transiciones de estados:
Terminate (terminar)
(*)
La destrucción de un proceso implica su eliminación del sistema. Los recursos que tenía asignados se
liberan, devolviéndose al sistema, su PCB se borra y se elimina cualquier rastro suyo de las tablas y las
listas del sistema. Por esta transición el proceso queda fuera de memoria, pero todavía esperando una
desactivación total, es decir, todavía sin desprenderse de todas sus referencias, asignaciones, entorno,
etc. En este caso la transición que se provoca en el proceso se denota como sigue:
Terminate (id-proceso): RUNNING ß END
Activate (activar)
Cualquier proceso de los existentes puede generar uno o varios procesos nuevos. El proceso generador
se llama padre y los generados procesos hijo, siendo necesario un único proceso para crear otro. Esto
(*)
Se puede destruir un proceso en cualquier estado. Lo explicado aquí sería la destrucción de un proceso en
ejecución.
Página 20 de 164
conduce a una estructura de procesos jerárquica. Cuando la creación del descriptor del proceso se
realiza antes de la carga del programa correspondiente, dicho proceso se encuentra en estado inicial.
Tras la carga del programa, dado que lo único que necesita dicho proceso para ejecutarse es el control
del procesador, su descriptor pasará a la lista-ready y se realizará sobre él la operación de activación,
que provocará en él una transición de estado por la cual quedará en estado ejecutable. Esta transición
se puede denotar de la forma:
Activate (id-proceso): WAIT ß READY
Dispatch (despachar)
Cuando el proceso en ejecución, por alguna causa, deja de estarlo, la CPU quedará libre y, lógicamente,
debe ser asignada a otro proceso, que será aquel cuyo descriptor esté a la cabecera de la lista-ready.
El encargado de realizar esta operación es el dispatcher, o planificador de bajo nivel, y es una operación
de "conmutación de contexto" (o dispatching, o cesión del control de CPU) que provocará que dicho
proceso, en estado READY, pase a estado RUNNING, mediante una transición de estado que se
denomina dispatch y que se formula:
Dispatch (id-proceso): READY ß URNG
Time run out (tiempo excedido)
Para evitar que un proceso monopolice el procesador, bien de forma accidental o malintencionadamente,
el sistema operativo utiliza un temporizador para controlar que cada proceso use la CPU durante un
intervalo de tiempo o quantum dado. Así, si el proceso en curso no cede voluntariamente el control de la
CPU antes de expira dicho tiempo, cuando el temporizador queda a cero se genera una interrupción
hardware que se suele denominar interrupción de reloj, por la cual toma el control el sistema operativo
y provoca una transición de estado sobre el proceso en ejecución (RUNNING), dejándolo en estado
ejecutable (READY). Esta transición de estado se puede denotar de la forma siguiente:
Time-run-out (id-proceso): RUNNING ß READY
Después de ésta transición de estado, la CPU queda libre, y vuelve a repetirse el ciclo, tomando el
control del dispatcher y realizando, si es posible, una transición dispatch.
Block (bloquear)
Si antes de que se le termine el tiempo concedido a un proceso que esté en ejecución (RUNNING)
necesita que se cumplan "ciertas condiciones" para poder proseguir (por ejemplo, necesita realizar una
operación de Entrada/Salida para obtener datos), el propio proceso provoca una interrupción (por
ejemplo, de llamada al Supervisor) y cede el control de la CPU, quedando pendiente de que se complete
el servicio requerido. Esta interrupción provoca en el proceso una transición de estado por la cual el
proceso pasará de estar en ejecución (RUNNING) a estado bloqueado (BLOCKED). Esta transición se
denomina block y se formula del modo siguiente:
Block (id-proceso): RUNNING ß BLOCKED
La CPU, entonces, queda libre y pasará el control al dispatcher.
Wake-up (despertar)
Cuando se den las condiciones que está esperando un proceso bloqueado (por ejemplo, que se
complete la operación de E/S por la cual ha quedado en espera), se producirá una nueva interrupción
(esta vez, de E/S) por la cual el sistema operativo tomará el control y provocará en el proceso
correspondiente una transición de estado por la cual pasará de estar bloqueado a estar nuevamente
ejecutable (READY). Esta transición se llama wake-up y se representa como:
Wake-up (id-proceso): BLOCKED ß READY
Página 21 de 164
Observaciones
• El único elemento que puede hacer que un proceso quede en estado RUNNING es el
dispatcher.
• Como se ha podido ver, la única transición de estado que se provoca a petición del propio
proceso es la block; las demás las provocan agentes externos al proceso.
• Normalmente, la operación de cambio de prioridad de un proceso no implica más que el

cambio del valor de la prioridad en su descriptor o PCB, y si la lista de ejecutables está
ordenada por dicho criterio, su reorganización. Sin embargo, si la planificación de la CPU se
(*)
hace por prioridad con requisamiento también habrá que estudiar si el proceso en curso
sigue siendo el más adecuado para su ejecución.
Dos operaciones importantes son las de suspensión y reanudación:
Un proceso suspendido sólo puede recontinuar (reactivarse) cuando otro realiza una operación de
reactivación sobre él; esta operación consiste sólo en relanzar el proceso suspendido desde el punto en
que se suspendió. La suspensión es un estado que suele durar breves instantes de tiempo y es una
operación que realiza el sistema, a petición del propio proceso o de otros procesos (si se está en un
sistema multiprogramado). Básicamente, la suspensión tiene tres aplicaciones:
1. Si se sospecha una deficiencia en el sistema, en lugar de abortar los procesos, se puede proceder a
su suspensión, hasta que:
• Se subsanen los fallos del sistema

• Se tenga que "tirar" el sistema abajo
2. Un proceso puede ser suspendido hasta que se comprueben los resultados intermedios, de modo
que:
• Si son correctos, se reactiva el proceso

• Si no lo son, se aborta
3. La aplicación más extendida e importante es que la suspensión es una forma de alivio de

(**)
fluctuaciones de carga del sistema .
La suspensión de un proceso implica la liberación de los recursos asignados, pero siempre dependiendo
de su naturaleza. Es decir, el recurso de memoria es básico para el sistema y es liberado
inmediatamente, pero recursos como unidades de cinta o periféricos poco usados no tienen que ser
liberados instantáneamente si la suspensión es prolongada, pero esto no es lo normal, ya que suele
durar breves instantes. La operación de suspensión también provoca transiciones de estado, que se
analizan a continuación:
Si un proceso en ejecución es suspendido a petición de él mismo o de otro, se producirá la transición:
Suspend (id-proceso): RUNNING ß SUSPENDED-READY
(*)
Se produce un cambio de prioridad en la lista-ready, y si la del proceso que se está ejecutando es menor que la del
proceso que ahora se encuentra en la cabeza de la lista, se le requisa la CPU y se le asigna al de más prioridad.
(**)
Hay situaciones de thrashing (o hiperpaginación) en las que la tasa de paginación sube mucho y puede causar una
ralentización muy grande del sistema. Un modo de solucionar este problema es suspendiendo los procesos menos
prioritarios (de menor a mayor prioridad), hasta que la paginación vuelva a ser normal, y luego reactivándolas
progresivamente (de mayor a menor prioridad).
Página 22 de 164
Cuando el proceso suspendido está en estado ejecutable, la transición provocada se denota:
Suspend (id-proceso): READY ß SUSPENDED-READY
Si se suspende un proceso bloqueado se dará en él la transición que se puede formalizar así:
Suspend (id-proceso): BLOCKED ß SUSPENDED-BLOCKED.
Se podría argumentar que en lugar de suspender un proceso bloqueado es mejor esperar hasta que se
complete la operación de E/S o se dé la circunstancia por la que estaba esperando y que el proceso
pase a ejecutable para, inmediatamente, suspenderlo. Desafortunadamente, puede que nunca tenga
lugar ésta consumación o que se retrase mucho, y la suspensión es una operación prioritaria.
Lógicamente, puede ocurrir que, mientras un proceso está en estado SUSPENDED-BLOCKED, se
cumplan las condiciones que estaba esperando, por las que estaba en estado BLOCKED. Cuando
ocurre esto, el proceso pasa al estado SUSPENDED-READY (lógicamente, ya que si no estuviera
suspendido debería estar READY). La transición que realiza este cambio es la completion (realización ó
completación) y se denota como:
Completion (id-proceso): SUSPENDED-BLOCKED ß SUSPENDED-READY
En cuanto a la reactivación, si se realiza una operación de activación sobre un proceso en estado

suspendido ejecutable (SUSPENDED-READY), se provoca una transición de estado, resume
(continuar), por la que pasará a estado ejecutable (READY).
Resume (id-proceso): SUSPENDED-READY ß READY
Si la transición se encuentra suspendida bloqueada, resume la dejará en estado BLOCK.
Resume (id-proceso): SUSPENDED-BLOCKED ß BLOCKED
Con estos nuevos estados, la representación anterior se podría dejar finalmente como:
Página 23 de 164
El Bloque De Control De Procesos (PCB, Process Control Block )
Cuando se somete un determinado trabajo para su ejecución y es aceptado, se carga el programa

correspondiente en memoria y, además, se crea el descriptor de proceso correspondiente (PCB) que
contiene:
• El estado actual (status): READY, RUNNING...

• El entorno volátil, que es el subconjunto de elementos compartidos en el sistema susceptibles de
cambios con la ejecución de los procesos y que son accesibles desde ellos.
La información que contienen estos elementos se llama

información de rearranque y también se define como el bloque de
contexto o estado del procesador para el proceso. La información
de rearranque contiene:
• Identificador único de proceso (pid).

• Estado del proceso (activo, preparado, bloqueado).
• Prioridad.
• Estado hardware (contador de programa, códigos de
condición, punteros de pila, etc.).
• Información para gestionar la memoria (punteros, tablas,
registros, etc.).
• Información de contabilidad y planificación.
• Etc.
El sistema operativo mantiene listas de PCB para cada uno de los estados del sistema (preparado,
activo, etc.). Cada proceso pertenece a una única lista. El planificador se encarga de gestionar el paso
de los procesos de una lista a otra. Puede haber una lista de estados suspendidos ligada en exclusiva a
un dispositivo o evento.
De igual forma existe un Bloque de Control de Sistema (SCB;

System Control Block), con unos objetivos globales similares al
anterior y entre los que se encuentra el enlazado de los bloques
de control de los procesos existentes en el sistema.
A continuación se verá cómo se realiza el cambio de un proceso

a otro, para lo cual se supondrá una computadora con un solo
procesador (sólo un proceso puede estar ejecutándose en cada
momento), y existen varios procesos activos compitiendo por el
acceso al procesador (se está ejecutando un proceso A y el
núcleo del sistema operativo decide que debe ejecutarse en un
instante dado otro proceso B). Se supondrá que los programas
de los procesos A y B están ambos en memoria principal.
Las acciones que realiza el sistema operativo para cambiar el proceso A por el B se denominan cambio
de proceso, y son las siguientes:
• Deja de ejecutar el proceso en curso (A), cediéndose el control al núcleo del sistema operativo, y aparece lo que se
denomina un cambio de contexto pasando del modo usuario al modo supervisor. Antes de realizarse el cambio de contexto
se salva el estado del proceso A para su posterior vuelta al punto donde fue interrumpido.
• El núcleo estudia si el proceso B está preparado para su ejecución y, si es así, realiza el cambio de contexto
correspondiente pasando del modo supervisor al modo usuario. A continuación repone el estado del proceso B ( en caso de
haber sido interrumpido con anterioridad) y, por último, pone en ejecución el proceso B.
El cambio de contexto se producirá en caso de ejecución de una instrucción privilegiada, una llamada al
sistema operativo o una interrupción, es decir, siempre que se requiera la atención de algún servicio del
sistema operativo. En el cambio de contexto, el núcleo salva el estado del proceso que se estaba
Página 24 de 164
ejecutando en su bloque de control y restaura el proceso de va a ejecutarse a partir de los datos
almacenados en su bloque de control.
Procesos y Hebras
Es posible concebir el proceso como una entidad formada por una o más unidades de ejecución
denominadas hebras (threads) o procesos primitivos y un conjunto de recursos asociados.
Cada hebra posee su propio vector de estado. No pueden existir fuera de un proceso y sólo pueden
pertenecer a uno de ellos. Los recursos no están asociados a las hebras, sino al proceso.
Operaciones
Todos los procesos tienen una serie de operaciones asociadas a ellos, las cuales se indican en la
siguiente tabla junto a sus características o tareas asociadas.
OPERACIÓN TAREA
Definir nombre del proceso.
Insertarlo en la lista de procesos del sistema.
Creación de un proceso Determinar la prioridad inicial del proceso.
Crear el bloque de control del proceso.
Asignar recursos iniciales al proceso.
Eliminarlo de la lista de procesos.
Destrucción de un proceso
Quitar la asignación de recursos.
Suspensión/Reanudación Sacar momentáneamente al proceso de la CPU.
de un Proceso Reactivar la ejecución del proceso.
Dejar "parado" el proceso hasta que ocurra algún
Bloqueo de un proceso
evento.
Cada vez que se crea un proceso el sistema operativo debe considerar

algún mecanismo de jerarquía para determinar la prioridad inicial del
proceso. Así, un modelo jerárquico de prioridades se ilustra a la derecha y
en él se muestra un número indicando el orden de creación; las prioridades
de atención van de la cúspide hacia abajo y, para niveles iguales, va de
izquierda a derecha.
Esta forma de creación de procesos produce una estructura jerárquica de

procesos, en la cual cada nodo tiene un solo padre, pero cada padre puede
tener varios hijos; por lo tanto se trata de un árbol n-ario.
En general los procesos pueden clasificarse en determinísticos, cuando la secuencia de instrucciones

ejecutadas depende de la entrada; no determinísticos, cuando la salida del proceso esta determinada
por la entrada; secuenciales, cuando las instrucciones se ejecutan una después de otra; y paralelos,
cuando pueden ejecutarse más de una instrucción al mismo tiempo.
El Planificador De Procesos
Software del sistema operativo asigna los recursos de un sistema entre los procesos que los solicitan.
Planificador a largo plazo (PLP): O planificador de trabajos, determina qué trabajos se admiten en el
sistema para su procesamiento y son cargados en la memoria disponible. Debe realizar una mezcla
adecuada de trabajos destinados al procesador y trabajos destinados al sistema de E/S. Lo más usual
es definir una función de prioridad y asignarle a cada programa un valor para la misma que se actualiza
en instantes determinados por el PLP.
Existen sistemas que no tienen algoritmo PLP o este es mínimo, como algunos sistemas de tiempo
compartido que se limitan a poner en el estado de preparado cualquier proceso nuevo. En general, el
PLP sólo existe en sistemas que admiten procesamiento por lotes.
Página 25 de 164
Planificador a corto plazo (PCP): O planificador del procesador, gestiona los procesos entre dos
instantes de gestión del PLP. Selecciona al proceso que pasará al estado activo de entre todos los
preparados. Su elevada frecuencia de uso hace que el algoritmo suela ser sencillo (no calcula
prioridades). Es invocado siempre que se origina un cambio de estado del sistema por un evento:
a) Señales del reloj del sistema.

b) Interrupciones.
c) Finalización de operaciones de E/S.
d) Llamadas al sistema operativo
e) Envío y recepción de señales.
f) Activación de programas interactivos.
Distribuidor (dispatcher): Parte del PCP encargada en exclusiva de realizar las gestiones oportunas
para pasar el procesador a la tarea seleccionada para su ejecución (en algunos sistemas se denomina
distribuidor al PCP).
Planificador a medio plazo (PMP): (En algunos sistemas) se encarga del intercambio (swapping) o
proceso de salvar una tarea suspendida en la memoria secundaria para:
a) Liberar memoria principal.

b) Separar los procesos destinados al procesador de los destinados al sistema de E/S.
Finalmente, también se puede definir la planificación de la CPU como un ciclo de ráfagas de CPU y E/S. La
ejecución de un proceso consiste en un ciclo de ejecución de CPU y espera de E/S. La ejecución de un
proceso comienza con una ráfaga de CPU, a ésta el siguen ráfagas de CPU y E/S. La última ráfaga de
CPU terminará con solicitud al sistema de terminación ejecución.
• Un programa limitado por E/S tendrá muc has ráfagas de CPU breves.
• Un programa limitado por la CPU tendrá pocas ráfagas de CPU muy largas.
Criterios De Performance
En general se utilizan varios criterios para medir el rendimiento de los algoritmos de planificación, entre
los cuales se pueden encontrar:
a) Eficacia: Porcentaje del tiempo medio de utilización.

b) Rendimiento (throughput): Número de procesos completados por unidad de tiempo.
c) Tiempo de regreso (turnaround): Intervalo de tiempo que transcurre desde que un proceso se
crea o presenta hasta que se completa por el sistema.
d) Tiempo de espera: Tiempo que el proceso espera hasta que se le concede el procesador. Puede
resultar la medida más adecuada de la eficiencia del sistema.
e) Tiempo de respuesta a un evento: Intervalo de tiempo que transcurre desde que se señala un
evento hasta que se ejecuta la primera instrucción.
Entre los objetivos de la planificación se puede encontrar: Minimizar el tiempo medio de espera o de
retorno, maximizar el uso de la CPU, mantener el tiempo de espera por debajo de un cierto valor
máximo, etc. En cualquiera de los casos, se pueden considerar las madias, valores extremos o varianzas
de esas magnitudes. En próximo capítulo se abordarán algunas planificaciones con mayor detalle.
Conceptos Bási cos De Un Sistema O perat ivo
Los sistemas operativos desde sus inicios han sido capaces (o, al menos, eso es lo que se ha intentado)
de realizar más de un proceso en forma simultánea. Es muy importante para la comprensión real del
mecanismo de funcionamiento de un sistema operativo el tener siempre presente que es posible realizar
dos o más procesos a la vez o en una secuencia de atención extremadamente veloz; tanto así, que una
atención de varios procesos en forma secuencial se hace transparente al usuario. Por ejemplo: En una
red de computadores parece que todos estuviesen trabajando en forma independiente, a un mismo
Página 26 de 164
tiempo y en distintas máquinas; sin embargo, para el computador servidor de la red es imposible atender
dos servicios de escritura en disco a un mismo tiempo, aún cuando eso es algo muy difícil de notar.
Para la ejecución un programa es necesario realizar una serie de pasos:
1. Buscar la instrucción que se va a ejecutar.

2. Contabilizar la instrucción para determinar en que momento se ejecuta.
3. Ejecutar la instrucción.
La secuencia de pasos dada se conoce como ciclo Buscar-Ejecutar (fetch-execute), el cual se muestra
a continuación.
Repeat {
IR ← Mem(PC)
PC ← PC + 1
Ejecutar(IR)
} Until (IR = Instrucción de alto)
Por otra parte, el manejo de la unidad de entrada y salida (E/S) es importante puesto que es a través de
ella que el computador comunica, envía y recibe información.
Existen varios tipos de dispositivos de E/S, los cuales poseen una velocidad generalmente inferior a la
CPU y que deben ser administrados por ella. Además, debido a la diversidad de dichos dispositivos se
hace necesario ejecutar diversas acciones, dependiendo del dispositivo, para lograr realizar algún
proceso de E/S. Pero en términos generales, los procesos que se realizan (en forma simultánea) son los
siguientes:
CPU { DISPOSITIVOS {
Wait(Ready = 1) Wait(Busy = 1)
Ready ← 0 Busy ← 0
Copiar comando a CB, //CB = Command Buffer. Ejecutar comando
Busy ← 1 Indicador en CB
} Ready ← 1
}
Modelo Sencillo De Un Sistema Operativo
Supuestos:
1. Se trata de un microsistema conformado por una CPU, una impresora (PR) y un lector de archivos
(RF).
2. Existen tres estados posibles:
Ocupado, la CPU tiene un trabajo en proceso.

Listo, la CPU esta lista para recepcionar un proceso.
Ocioso, la CPU esta esperando la ocurrencia de algún evento.
3. Sólo puede existir un proceso en ejecución a la vez.
4. PR y RF dependen además de si existe un comando pendiente (COM).
5. RF depende también de existe al menos un archivo para leer (OKF).
6. Los periféricos PR y RF tienen botones inicio/término; cuando inicio esta apagado el dispositivo se
encuentra en estado ocioso.
Página 27 de 164
De esta forma la estrategia de proceso del programa administrativo ejecutado por la CPU es:
Repeat
Leer Archivo
Interpretar archivo
Cargar en memoria
Ejecutar
Imprimir resultados
Until (se apaga la máquina)
Las tablas de estados posibles para PR y RF son:
PR Inicio COM Estado RF Inicio OkFile COM Estado

0 0 0 Ocioso 0 0 0 0 Ocioso
1 0 1 Ocioso 1 0 0 1 Ocioso
2 1 0 Listo 2 0 1 0 Ocioso
3 1 1 Ocupado 3 0 1 1 Ocioso
4 1 0 0 Ocioso
5 1 0 1 Ocioso
6 1 1 0 Listo
7 1 1 1 Ocupado
Los diagramas de transición de estados de los dispositivos son:
Diagrama de transiciones Diagrama de transiciones

de la impresora del lector de archivos
Finalmente, los algoritmos de control de PR y RF son:
PR_Control (Salida_Inicial, lc) { RF_Control (Entrada_Inicial, fc) {

Salida ← Salida_Inicial Entrada ← Entrada_Inicial
While (lc <> 0) { fc ← 0
Wait (PR=Lista) Wait (RF=Lista)
Enviar comando de impresión-línea Repeat
lc ← lc - 1 Enviar comando de lectura-archivo
Salida ← Proxima(Salida) fc ← fc + 1
} Entrada ← Proxima(Entrada)
} Wait (RF <> Ocupada)
Until (RF=Ociosa)
}
Página 28 de 164
Interrupciones: La Base De Los Sistemas Operativos Modernos
Para que las operaciones de la CPU y de E/S puedan superponerse deben contar con un mecanismo
que permita la desincronización y la resincronización de la operación. Puede usarse cualquiera de los
métodos siguientes (algunos sistemas emplean ambos):
• Transferencia de datos dirigida por interrupciones.

• Transferencia de datos por acceso directo a memoria (DMA, Direct Memory Access).
En contraste con los sistemas más antiguos, la transferencia de datos se efectuaba bajo el control de la
CPU. Esta tenía que ejecutar, o por lo menos supervisar, la transferencia de datos, lo que no permitía
hacer simultáneas las operaciones de la CPU y de E/S. Como ejemplo, considere los siguientes pasos
como necesarios para imprimir datos de la memoria:
1. Verificar si la impresora esta lista para recibir el siguiente carácter.

2. Si la impresora no esta lista, volver al paso 1.
3. Si la impresora esta lista, verificar si hay otro carácter por imprimir.
4. Si hay otro carácter, volver al paso 1.
5. Si no hay más caracteres, la impresión ha terminado.
A este método de superposición se le conoce como espera activa, ya que la CPU necesita realizar un
seguimiento del estado de la E/S y, por consiguiente, esta activa mientras espera que termine la E/S.
Aunque en teoría es cierto que la CPU podría efectuar algún otro procesamiento y regresar más tarde a
imprimir el siguiente carácter, en la práctica esto no siempre es posible. Considere que aunque se
emplea un dispositivo de entrada de alta velocidad, la CPU seguirá siendo más rápida, y por tanto,
deberá esperar entre una y otra entrada. No obstante, si la CPU cambia a otra tarea para evitar esta
pérdida de tiempo, se presenta el riesgo de omitir parte de la entrada, ya que durante ese lapso se
pueden recibir dos entradas. La E/S basada en interrupciones es la solución perfecta para esta situación.
En un sistema basado en interrupciones, cada uno de los controladores de dispositivos se encarga de un

tipo específico de dispositivo. Un cont rolador de dispositivo cuenta con almacenamiento local en buffer y
un conjunto de registros de propósito especial. El controlador del dispositivo es el responsable de
transferir los datos entre el periférico que controla y su buffer local.
Para iniciar una operación de E/S, la CPU carga los registros apropiados del controlador del dispositivo y
luego continúa con su operación normal. A su vez, el controlador del dispositivo examina el contenido de
estos registros para determinar que acción emprenderá. Por ejemplo, si encuentra una solicitud de
lectura, el controlador comenzará la transferencia de datos del dispositivo a su buffer local. Una vez
concluida la transferencia de datos, el controlador del dispositivo informa a la CPU que su operación ha
terminado. Esta comunicación se logra causando una interrupción. Cuando se interrumpe a la CPU, ésta
suspende lo que estaba haciendo y transfiere de inmediato la ejecución a una posición fija, la cual
generalmente contiene la dirección de inicio donde se encuentra la rutina de procesamiento de la
interrupción. La rutina de procesamiento de la interrupción transfiere los datos del buffer local del
controlador del dispositivo a la memoria principal. Una vez lograda esta transferencia, la CPU puede
continuar con los cálculos interrumpidos; así, los dispositivos de E/S y la CPU pueden funcionar
concurrentemente.
Las interrupciones son una parte importante de la arquitectura del computador. Cada diseño cuenta con
su propio mecanismo de interrupción, pero hay varias funciones comunes para todos. La interrupción
debe transferir el control a la rutina de procesamiento de la interrupción. Por lo general, esto se logra
reservando un conjunto de posiciones en a parte baja de la memoria para que almacenen las direcciones
de las rutinas de procesamiento de la interrupción para los distintos dispositivos. Este vector de
direcciones, se indexa usando un número de dispositivo único que se da junto con la solicitud de
interrupción para así proporcionar la dirección de la rutina de procesamiento de la interrupción para el
dispositivo que la emite.
La arquitectura de interrupciones también debe guardar la dirección de la instrucción interrumpida. Las

arquitecturas más recientes almacenan la dirección de retorno en la pila del sistema. Quizá la rutina de
Página 29 de 164
procesamiento de la interrupción tenga que guardar explícitamente otros registros, como acumuladores o
registros de índices, y luego recuperarlos. Después de procesar la interrupción, con un salto a la
dirección de retorno almacenada, la ejecución continuará como si no hubiese ocurrido nada. Usualmente
las interrupciones se desactivan mientras una de ellas se procesa, demorando la interrupción que entra
hasta que el sistema operativo termine con la actual y las interrupciones que se hayan activado. Si no se
desactivaran, el procesamiento de la segunda interrupción mientras se da servicio a la anterior escribiría
sobre los datos de la primera; y la primera sería una interrupción perdida. Las arquitecturas complejas de
interrupciones permiten procesar una interrupción mientras se atiende otra, por lo general siguiendo un
esquema donde se asignan prioridades a los tipos de solicitud de acuerdo con su importancia relativa y
se almacena por separado la información de procesamiento de la interrupción para cada prioridad. Se
aceptará una interrupción de prioridad más alta aun si está activa una interrupción de menor prioridad,
pero las interrupciones de igual o menor prioridad se enmascaran, o desactivan selectivamente, para
evitar interrupciones perdidas o innecesarias.
Para resolver el problema de la velocidad de atención y procesamiento de interrupciones por parte de la

CPU se utiliza el acceso directo a memoria (DMA) para los dispositivos de E/S de alta velocidad.
Después de fijar los buffers, apuntadores y contadores para el dispositivo de E/S, el controlador del
dispositivo transfiere directamente todo un bloque de datos de su almacenamiento en buffer a la
memoria, o viceversa, sin que intervenga la CPU.
La operación básica de la CPU sigue siendo la misma. Un programa de usuario, o el mismo sistema
operativo, puede solicitar una transferencia de datos. El sistema operativo localiza un buffer (vacío para
la entrada o lleno para la salida) de una cola de buffers para la transferencia. Entonces el controlador del
DMA tiene sus registros con las direcciones apropiadas fuente y destino así como la longitud de la
transferencia. En general, esto lo lleva a cabo un manejador de dispositivo, que sabe exactamente cómo
proporcionar esta información al controlador. Luego se ordena al controlador del DMA que comience la
operación de E/S. El controlador del DMA interrumpe a la CPU cuando termina la transferencia.
Ejemplo: multiprogramación (timesharing)
1. El sistema operativo inicializa el timer o reloj en una tajada de tiempo, y lo echa a andar.
2. El sistema operativo entrega el control a un proceso.
3. El proceso se ejecuta.
4. Concluido el tiempo prefijado, el timer provoca una interrupción.
5. El manejador de interrupciones del timer (que es parte del sistema operativo) guarda la
información del proceso interrumpido necesaria para poder reanudarlo después.
6. Se repite el ciclo, escogiendo ahora otro proceso.
Otro ejemplo: manejo de dispositivos de I/O (Input / Output)
Para comenzar una operación de I/O, el sistema operativo escribe los registros del caso en el
controlador del dispositivo. A su vez, el controlador determina qué hacer mirando el contenido de esos
registros. Por ejemplo, si se trata de una solicitud de lectura, inicia la transferencia de datos desde el
dispositivo hacia la memoria. Cuando finaliza la transferencia, el controlador le avisa a la CPU a través
de una interrupción. Esto permite que la CPU, en vez de esperar que la transferencia termine (lo que
sería I/O sincrónico), en el intertanto puede realizar otra tarea (I/O asincrónico). Una secuencia típica
sería:
1. El proceso que está ejecutando en la CPU solicita una operación de I/O, mediante una llamada al
sistema.
2. El sistema operativo suspende el proceso, poniéndolo en la cola de procesos suspendidos, y

comienza la operación de I/O.
3. El sistema operativo escoge otro proceso para que siga ejecutando en la CPU.
Página 30 de 164
4. Cuando la operación de I/O se completa, el control vuelve al sistema operativo gracias a que el
controlador del dispositivo provocó una interrupción.
5. El sistema operativo, determina, según la interrupción y sus tablas internas, que el proceso que
había sido suspendido ahora puede reanudarse, por lo tanto lo pone en la cola de procesos listos
para ejecutar.
6. El sistema operativo reanuda ese (o tal vez otro) proceso de la cola de procesos listos.
Por norma general, las interrupciones pueden clasificarse en dos tipos de acuerdo al carácter de
su ejecución:
Interrupciones No Enmascarables
Corresponden a aquellas interrupciones que deben ser ejecutadas inmediatamente cada vez que el
periférico lo solicite. Estas se refieren principalmente a las tareas del sistema, como la atención de las
rutinas de bajadas del sistema, chequeo de integridad de la memoria, actualización del tiempo, etc.
Interrupciones Enmascarables
Se ejecutan a solicitud del periférico correspondiente, siempre y cuando el registro de estado de
interrupciones este indicando que la interrupción puede ser atendida, en caso contrario la interrupción es
ignorada y la CPU sigue efectuando sus tareas.
Una forma de hacer que la CPU pueda identificar el evento asincrónico y reaccionar ante él es
modificando adecuadamente el ciclo Buscar-Ejecutar. En forma simplificada, esto es:
Repeat
If (INTERRUPT = 1) {
AUX ← PC
PC ← @[Rutina de atención de Interrupciones]
INTERRUPT ← 0
PC ← AUX
}
IR ← Mem(PC)
PC ← PC + 1
Ejecutar(IR)
Until (IR = Instrucción de alto)
La rutina de atención de interrupciones debería realizar las siguientes tareas.
1. Guardar todos los acumuladores, registros, etc.

2. Atender al dispositivo e indicárselo, para que se detenga y no siga interrumpiendo.
3. Restaurar todos los acumuladores, registros, etc.
4. Continuar con la ejecución del programa interrumpido.
Es común que las interrupciones provengan de diversos dispositivos; por lo tanto, es importante que
estas interrupciones sean atendidas rápidamente y bajo alguna política de prioridad donde habría que
considerar:
1. Cambiar las prioridades de las interrupciones que ya han sido atendidas.

2. Poder deshabilitar prioridades colectivamente.
3. Poder soltar una rutina de atención de interrupciones para ejecutar otra.
Existen distintos tipos de interrupciones de acuerdo al tipo de servicio que es solicitado y el dispositivo
que lo solicita.
Página 31 de 164
Interrupciones De SVC (Supervisor Call; Llamadas Al Supervisor)
Son efectuadas por un proceso en estado de ejecución, el cual solicita un servicio en particular del
sistema. Su objetivo es conmutar el estado de la máquina y ayuda a mantener el sistema operativo
seguro de los usuarios "intrusos".
Interrupciones De E/S
Son indicadas por algún dispositivo de E/S a través del envío de señales a la CPU, indicando el estado
de un canal de comunicación.
En el caso de varios pedidos simultáneos, las interrupciones son atendidas bajo una política de
prioridades prefijada y además se va formando una cola de solicitudes por interrupción.
Interrupciones Externas
Provee de un medio a través del cual la CPU responde las señales causadas por varios eventos. Por
ejemplo, término de un lapso de reloj de una interrupción o la presión de una tecla de interrupción. Estas
señales pueden ser provocadas por distintos entes, pueden ser emitidas en cualquier momento y puede
haber varias simultáneamente.
Interrupciones De Servicio
Ocurren cuando el usuario presiona la tecla Restart (u otra similar) en la consola del sistema o desde
otro procesador en un sistema multiprocesador.
Interrupciones Por Programa

Proveen de la especificación de acciones incorrectas o mal uso de instrucciones y datos, causando un
error al ejecutar un proceso.
Sólo puede haber un tipo de interrupción para cada instrucción; los distintos tipos de interrupciones que
pueden ocurrir son:
1. Excepción de operación: código de operación inválido.

2. Excepción de operación privilegiada: operación denegada.
3. Excepción de protección: acceso a zona denegado.
4. Excepción de direccionamiento: dirección fuera de rango de memoria.
5. Excepción de datos: incompatibilidad, inexistencia, etc.
6. Excepción de overflow: la variable se llenó e intenta almacenar más aún.
7. Excepción de división: división por cero.
Interrupciones Por Error De Máquina

Son causadas por mal funcionamiento de hardware. Proveen un medio para reanudar la operación,
después de producido un evento en mal funcionamiento de la máquina, automáticamente bifurca a una
rutina de diagnóstico.
Durante la ejecución de una instrucción puede ocurrir que se presenten simultáneamente varias
situaciones que generen una interrupción. Algunas de las prioridades de atención son:
Error de máquina, prioridad 1.

Interrupciones de E/S, prioridad 4.
Interrupciones externas, prioridad 5.
El orden de atención de interrupciones es inverso al orden de prioridad fijado, excepto en el caso de la

interrupción por error de máquina, la cual es atendida de inmediato.
Página 32 de 164
Una forma de sincronizar los comandos que la CPU envía a los periféricos es a través de la utilización de
cierto tipo de interrupción conocida como interrupción de reloj. Esta interrupción puede ser fácilmente
implementada mediante una leve modificación al ciclo Buscar-Ejecutar:
Repeat
If (Reloj > 0) {
IR ← Mem(PC)
PC ← PC + 1
} else {
IR ← Mem(X)
}
Reloj ← Reloj - 1
Ejecutar(IR)
Donde Mem(X) es un apuntador a la siguiente primitiva:
Interrupción_Reloj() {
Guardar estado del programa interrumpido
Reloj ← Algún nuevo valor
Restaurar estado del programa interrumpido
}
Una desventaja de la interrupción de reloj es que interrumpe aún cuando el dispositivo pueda no estar
listo. Por otra parte, si un dispositivo queda listo podría llegar a tener que esperar que se complete todo
el ciclo del reloj para ser atendido.
Una solución a esta deficiencia se conoce como interrupción de dispositivo. Esta consiste en que el
dispositivo produce una interrupción sólo cuando necesita utilizar la CPU.
Supóngase que existen n dispositivos y cada uno de ellos tiene un bit asignado a un vector de
interrupción (VEC). De este modo cuando un dispositivo quiera provocar una interrupción coloca un "1"
en el bit n del vector de interrupción, es decir VEC[n].
El ciclo Buscar-Ejecutar y la rutina de atención de interrupción serán entonces:
Repeat Interrupción_Dispositivo() {
If (VEC == 0) { Guardar estado del programa interrumpido
IR ← Mem(PC) Índice ← Índice del bit con "1" en VEC
PC ← PC + 1 VEC[Índice] ← "0"
} Rutina_de_Dispositivo(Índice)
else { Restaurar estado del programa interrumpido
IR ← Mem(X) // Apuntador a la rutina de atención }
}
Ejecutar(IR)
Para el caso dado, se ha de suponer que existe algún medio a través del cual se puedan inhibir, si es
necesario, las demás interrupciones mientras una se está ejecutando (prioridades).
Administ ra ción De Datos
El sistema de archivos es el aspecto más visible de un sistema operativo. Los archivos almacenan datos
y programas, y el sistema operativo implanta el concepto abstracto de archivo administrando dispositivos
de almacenamiento masivo, como cintas y discos. Además, los archivos normalmente se organizan en
directorios para facilitar su uso, por lo que se verán diversas estructuras de directorios. Por último,
cuando varios usuarios tienen acceso a los archivos, puede ser deseable controlar quién y cómo puede
tener acceso a ellos. A este control se le conoce como protección de archivos.
Página 33 de 164
Archivos
El sistema operativo da una visión uniforme para todos los sistemas de almacenamiento, definiendo una
unidad lógica de almacenamiento denominada archivo.
Se considera como archivo a un conjunto de información relacionada definida por su creador.

Corresponden a los programas y a los datos de cualquier tipo. En general, un archivo es una serie de
bits, bytes o registros. Los archivos son nombrados y referenciados por su nombre. Además, tienen otras
propiedades o atributos, como su tipo, fecha y hora de creación, nombre o identificador del creador,
longitud, etc.
Tipos Y Estructuras De Archivos

Los archivos pueden contener distintos tipos de información y, dependiendo de su uso, tendrán una
determinada estructura.
Casos posibles:
a) El sistema operativo puede tener conocimiento de estas distintas estructuras lógicas y considerar
diferentes tipos de archivos. Des ventajas:
1) Mayor tamaño del sistema operativo.
2) Gran rigidez, ya que sólo se pueden considerar los tipos de archivos definidos por el
sistema.
b) En algunos sistemas operativos como Unix no se definen los tipos de archivos, con lo que se tiene
una gran flexibilidad, pero con un soporte mínimo, de forma que los programas de aplicación
tienen que incluir el código que interprete la estructura adecuada de los archivos. El sistema
operativo sólo empaqueta y desempaqueta los bytes cuando los escribe y los lee del disco de
acuerdo a los bloques físicos del mismo.
c) Considerar un archivo como una secuencia de registros lógicos (en desuso), cada uno con su
propia estructura interna (la visión de Unix y MS-DOS es una particularización de ésta,
reduciéndose el registro lógico a un byte).
d) Estructuras de árbol (restringido a grandes computadores corporativos). Los registros tienen una
clave y la operación básica no es obtener el siguiente registro, sino obtener el registro con la clave
especificada.
El acceso original a los archivos (heredado de las cintas magnéticas) era secuencial. Una operación de
lectura leía el registro actual y automáticamente avanzaba al siguiente registro del archivo. La operación
de escritura añadía el registro al final y avanzaba al nuevo final del archivo.
Con la aparición de los discos se pudo acceder directamente a cualquier registro del archivo, dando
lugar al acceso arbitrario (acceso directo). Las operaciones de lectura y escritura deben incluir el número
de registro como parámetro. En la actualidad todos los archivos se consideran de acceso directo.
Operaciones Con Los Archivos
CREATE (crear), realiza las siguientes acciones:
1) Buscar si ya existe ese archivo.

2) Asignarle una entrada en el directorio.
3) Asignarle espacio en disco.
4) Registrar sus atributos en el directorio.
Página 34 de 164
En algunos sistemas, la propia función de crear el archivo lleva implícita la apertura del mismo, haciendo
una llamada a OPEN.
OPEN (abrir), establece un enlace entre el programa y el archivo, trasladando los atributos y la lista de
direcciones desde el disco a la memoria principal.
SEEK (buscar), se cambia la posición del apuntador para señalar al byte o registro cuya dirección lógica
se suministra en la llamada.
READ (leer), la lectura se hace en la posición actual y en la llamada se tiene que especificar la cantidad
de datos necesarios y proporcionar un buffer para su transmisión. El resultado de la operación se indica
mediante el valor que se devuelve en status.
WRITE (escribir), escribe en un archivo nuevo o los añade a uno existente. En este caso, el sistema de
archivos llama al módulo de asignación de espacio para proporcionar el número requerido de bloques
libres. Los bloques del directorio y los índices de los archivos serán modificados en consecuencia.
Algunos sistemas tienen una forma restringida de WRITE, con la que sólo pueden añadir datos al final
del archivo (APPEND).
Los sistemas con las funciones OPEN y CLOSE requieren generalmente que los archivos sean abiertos
antes de poderlos leer o escribir. Pero muchos sistemas abren implícitamente el archivo cuando se
realiza cualquier referencia a ellos.
CLOSE (cerrar), se libera la tabla con la lista de atributos y direcciones que se mantenía en memoria,
actualizándola en disco si se ha modificado. En muchos sistemas, la terminación obligada o voluntaria de
procesos incluye el cierre de todos los archivos abiertos (incluyendo en las rutinas EXIT o ABORT una
llamada a CLOSE)
DELETE (borrar), elimina un archivo y libera el espacio que ocupa, borrando del directorio la entrada al
archivo y liberando el espacio asignado al mismo. Hay sistemas operativos que, como medida de
seguridad, mantienen una copia de los archivos borrados hasta que reciben la orden expresa de liberar
este espacio.
RENAME (renombrar), cambia el nombre del archivo en la tabla del directorio correspondiente. Se puede
suplir copiando el archivo original en otro con el nuevo nombre y borrando el original.
COPYFILE (copiar), lleva implícita la creación de un nuevo archivo, aunque en algunas versiones se
permite copiar en un archivo ya existente grabando sobre la información del mismo.
Lectura y modificación de atributos, muchos sistemas permiten la lectura y, en algunos casos,

modificación de algunos atributos.
Directorios De Archivos
Son tablas simbólicas de archivos. Una entrada típica puede contener:
a) Nombre, tipo y número de versión del archivo.

b) Puntero de acceso al archivo, dirección de comienzo en el disco.
c) Lista de atributos.
En muchos sistemas, la tabla del directorio está dividida en dos. En una se mantienen los nombres de
los archivos con un número de identificación, el cual da acceso a otra donde se tiene el puntero de
acceso al archivo y la lista de atributos. Esto agiliza la gestión de los enlaces, la generación de alias y los
homónimos. Casos:
a) Directorio de nivel único: sistema usado en los primeros microcomputadores.

b) Un directorio por usuario.
Página 35 de 164
c) Árbol de directorios: las entradas del directorio correspondiente tienen un atributo más que indica
si corresponde a un archivo o a un subdirectorio.
Normalmente, cada usuario tiene su directorio inicial indicado en un

archivo de cuentas. Cuando se hace referencia a un archivo o
directorio, se busca en el directorio actual. Si no se encuentra, el
usuario debe cambiar de directorio o indicar el camino completo.
Los nombres de los caminos pueden ser completos o relativos.

Normalmente, los sistemas operativos tienen dos entradas especiales
para cada directorio: “.” para el propio directorio (con un puntero a sí
mismo) y “..” para el directorio padre. Estas pueden ser usadas en los
caminos relativos.
Como los directorios pueden ser muy grandes, se suelen guardar en disco. Esto facilita montar y
desmontar dispositivos. Es habitual considerar los directorios como archivos que tienen una lista de
todos los archivos. Para localizar el directorio raíz al arrancar el sistema, éste se sitúa en una dirección
conocida por el volumen desde el que se arranca el sistema.
Operaciones Con Los Directorios
MAKEDIR (crear directorio), en el directorio actual, se crea una entrada para un nuevo subdirectorio
vacío, salvo las entradas “.” y “..”.
REMOVEDIR (borrar directorio), elimina un directorio vacío. Si no lo está, se pueden hacer dos cosas:
1) No permitir el borrado.
2) Suponer que se quiere borrar todos los archivos y subdirectorios que contiene.
OPENDIR (abrir directorio) y CLOSEDIR (cerrar directorio), al abrirlo, se copian sus tablas en memoria.
Cuando se cierra, se actualizan en el disco.
READDIR (leer directorio), devuelve en un formato estándar la entrada actual del directorio. (por defecto,
el actual).
RENAMEDIR (cambiar el nombre), cambia el nombre de un directorio.
LINK (enlazar), forma de hacer que un archivo o subdirectorio aparezca en varios directorios. En la
llamada se especifica el nombre del archivo y el camino de acceso, creándose un enlace entre este
camino y el archivo ya existente. La estructura de directorios es, en este caso, un grafo dirigido acíclico.
UNLINK (desenlazar), eliminación del enlace y borrado de la correspondiente entrada en el directorio.
La información específica que se conserva para cada archivo en el directorio varía de un sistema
operativo a otro. En una entrada del directorio se puede conservar la siguiente información, aunque no
sea la misma para todos los sistemas:
• Nombre del archivo. El nombre simbólico del archivo es la única información que se mantiene en
forma legible para el hombre.
• Tipo de archivo. Esta información es necesaria para aquellos sistemas que apoyan diferentes
tipos de archivos.
• Ubicación. Este es un apuntador al dispositivo y a la ubicación física del archivo en ese

dispositivo.
• Tamaño. El tamaño actual del archivo (en bytes, palabras o bloques) y, posiblemente, el tamaño
máximo permitido.
Página 36 de 164
• Posición actual. Este es un apuntador a la posición actual de lectura o escritura en el archivo.
• Protección. Información de control de acceso para establecer quién puede leer, escribir, ejecutar,
etc.
• Recuento de uso. Este valor indica el número de procesos que actualmente están usando (han
abierto) el archivo.
• Hora, fecha e identificación de proceso. Esta información puede conservarse para la creación,
última modificación y último acceso. Estos datos pueden servir para la protección y la supervisión
de la utilización.
Para almacenar esta información se puede necesitar desde 16 hasta más de 1000 bytes por archivo. En
un sistema con gran cantidad de archivos, el tamaño del directorio puede ser de varios cientos o miles
de bytes, por lo que es probable que el directorio tenga que almacenarse en su dispositivo y traerse a
memoria por partes, según se necesite.
Una lista lineal de entradas del directorio requiere una búsqueda secuencial para encontrar una entrada
determinada. Esto es fácil de programar, pero la ejecución tarda mucho. Por ejemplo, para crear un
nuevo archivo, primero se debe buscar en el directorio para asegurar que no haya un archivo con el
mismo nombre; luego, se añade una nueva entrada al final del directorio. Para eliminar un archivo, se
busca en el directorio hasta encontrar su nombre y después se libera el espacio que se le había
asignado. Para reutilizar la entrada del directorio, existen varias alternativas: se puede marcar la entrada
como no utilizada o se puede añadir a una lista de entradas libres para el directorio. Una tercera
alternativa consiste en copiar la última entrada en la localidad liberada y reducir el tamaño del directorio.
También puede emplearse una lista ligada para disminuir el tiempo necesario para eliminar un archivo.
La gran desventaja de una lista lineal de entradas de directorio es la búsqueda secuencial necesaria
para encontrar un archivo. Una lista ordenada permite una búsqueda binaria que reduce el tiempo
promedio de búsqueda, aunque la programación del algoritmo de búsqueda es más compleja y, además,
siempre hay que mantener ordenada la lista. Este requisito puede complicar la creación y eliminación de
archivos ya que se tendrán que mover grandes cantidades de información del directorio para mantener el
orden. En este caso puede servir de ayuda un árbol binario enlazado.
Otra estructura de datos que se ha utilizado para directorios de archivos es la tabla de dispersión (una
estructura de datos que puede mejorar considerablemente el tiempo de búsqueda). La inserción y
eliminación son bastante directas, aunque hay que tomar medidas para evitar colisiones, situaciones
donde dos nombres de archivos se traducen a la misma localidad. Las principales dificultades con una
tabla de dispersión son el tamaño generalmente fijo de la tabla y la dependencia de la función de
dispersión respecto al tamaño de la tabla.
Por ejemplo, suponga que se establece una tabla de dispersión de 64 entradas. La función de dispersión
convierte los nombres de archivos en números enteros del 0 al 63, probablemente con una operación
final que emplee el residuo de una división entre 64. Si después se intenta crear el archivo 65, se debe
ampliar la tabla de dispersión del directorio, quizá a 100 entradas. Por tanto, se necesita una nueva
función de dispersión que haga corresponder los nombres de archivos al intervalo 0 a 99 y reorganizar
las entradas existentes en el directorio para reflejar los nuevos valores de la función de dispersión
(hassing).
Los archivos almacenan información. Cuando ésta es utilizada, es necesario obtenerla y cargarla en la
memoria del computador. Existen varias modalidades para acceder a la información en un archivo. Unos
sistemas sólo ofrecen un método de acceso y otros permiten varios métodos de acceso y la elección del
más adecuado para una aplicación específica representa un serio problema de diseño.
Página 37 de 164
Acceso Secuencial
La información en el archivo se procesa en orden, un registro tras otro. Este es el modo de acceso a
archivos más común que hay. Los programas de edición por lo general acceden de esta manera a los
archivos.
La mayor parte de las operaciones con archivos son lecturas y escrituras. Una operación de lectura lee
la siguiente porción del archivo y el apuntador avanza automáticamente. De manera parecida, una
escritura añade al final del archivo y luego avanza al final de lo que se acaba de escribir. Puede
reposicionarse el archivo para apuntar al inicio o, en algunos sistemas, un programa puede avanzar o
retroceder n registros, siendo n un número entero. A este esquema se le conoce como acceso
secuencial al archivo y esta basado en un archivo que se comporta como una unidad de cinta.
Acceso Directo
Otro método de acceso es el acceso directo, que se basa en el disco como modelo de archivo. Para el
acceso directo se considera que el archivo es una secuencia numerada de bloques o registros. Un
archivo de acceso directo permite leer o escribir cualquier bloque. Así, se puede leer el bloque 14, luego
el bloque 53 y después escribir el 7. No existen restricciones en cuanto al orden de lectura o escritura
para un archivo de acceso directo. Los archivos de acceso directo son muy útiles para obtener acceso
inmediato a grandes cantidades de información, y las bases de datos frecuentemente son de este tipo.
Cuando llega una consulta sobre un tema determinado, se calcula el bloque que contiene la respuesta y
luego se lee ese bloque directamente para proporcionar la información deseada.
No todos los sistemas operativos permiten ambos métodos de acceso a archivos. Algunos sólo permiten
el acceso secuencial y otros sólo el directo. Algunos sistemas requieren que un archivo se defina como
directo o secuencial al momento de crearlo, y sólo se permitirá el acceso de manera consistente con la
declaración inicial. Obsérvese, sin embargo, que es fácil simular el acceso secuencial en un archivo de
acceso directo si se mantiene una variable contadora.
Otros Métodos De Acceso

Es posible construir otros métodos de acceso a partir del acceso directo. Estos métodos adicionales
generalmente implican la construcción de un índice para el archivo. Este índice contiene apuntadores a
los distintos bloques. Para encontrar una entrada en el archivo, se busca primero en el índice y luego se
usa el apuntador para acceder directamente al archivo y encontrar la entrada deseada.
Realización Del Sistema De Archivos
Gestión del espacio libre

Para mantener una lista del espacio libre en disco se usan dos métodos:
1) Tener un mapa de bits de los bloques libres.

2) Usar una lista enlazada de bloques libres, manteniendo un puntero al primer bloque libre.
El segundo método no es muy eficiente, puesto que para leer la lista hay que leer todos los bloques.
Como mejora, se puede utilizar una lista enlazada de bloques en la que cada bloque contiene números
de bloques libres.
El mapa de bits ocupa menos espacio, ya que sólo usa 1 bit por cada bloque, en vez de los 19 que
necesita el método de lista enlazada. Si existe espacio suficiente en memoria para mantener el mapa de
bits, este método es preferible. Aunque cuando el disco está casi lleno podría ser más rentable el
método de las listas enlazadas.
Página 38 de 164
La elección del tamaño de los bloques requiere hacer un estudio previo de cuan grandes en promedio
van a ser los archivos en ese sistema (lo habitual es 512 bytes, 1 Kb o 2 Kb).
Método de asignación contigua

Requiere que cada archivo ocupe un conjunto de direcciones contiguas en el disco. Las entradas en los
directorios indicarán el bloque de comienzo y la longitud.
La dificultad está en asignarle el espacio correcto cuando se crea el archivo. Las soluciones son del tipo
primero en ajustarse o mejor en ajustarse. Ventaja: buen rendimiento cuando se quiere leer un archivo
completo. Inconvenientes:
a) Debe conocerse el tamaño máximo del archivo en el momento de su creación.

b) Si, al crecer, el espacio asignado no es suficiente, se tiene que reubicar.
c) Produce fragmentación externa. Puede solucionarse con compactación, pero es una operación
muy costosa.
Método de asignación mediante listas enlazadas

Algunos bytes iniciales de los bloques se usan como puntero al siguiente bloque. Las entradas en el
directorio sólo tienen que guardar un puntero al primer bloque del disco asignado al archivo.
Escribir en el archivo supone tomar uno de los bloques libres y añadirlo al final de la lista. Para facilitar
esta operación, también suele haber un puntero al último bloque del archivo. Para leer un archivo sólo
hay que seguir los punteros de bloque a bloque. Ventajas:
a) No causa fragmentación externa.

b) No se tiene que declarar el tamaño del archivo cuando se crea.
c) Los archivos pueden crecer sin ningún problema mientras haya bloques libres.
Inconveniente: El acceso aleatorio a un archivo es muy lento, puesto que hay que seguir los punteros
hasta llegar al archivo deseado.
Método de asignación mediante indexación

Se crea una tabla de índices en la que se colocan los índices a los bloques de los archivos. El directorio
contiene la dirección del bloque donde están los índices a los bloques de datos (concepto análogo a las
tablas de páginas de memoria). Ventajas:
a) Todo el bloque está disponibles para los datos.

b) Se soporta con la misma eficacia el acceso aleatorio que el secuencial.
c) No sufre fragmentación externa.
Inconveniente: pérdida de espacio en el bloque de índices para índices pequeños. Para archivos
grandes, se necesitaría asignar más bloques a la tabla de índices, pudiéndose utilizar sistemas de
indexación de varios niveles (Unix).
Algunos aspectos de diseño

a) Problemas de diseño:
1) Definir cómo verá el usuario el sistema de archivos (la estructura de directorios, los archivos
y sus atributos).
2) Crear los algoritmos y las estructuras de datos que relacionan el sistema de archivos lógicos
con el dispositivo físico de almacenamiento.
Página 39 de 164
b) Niveles: El sistema de archivos se puede considerar compuesto por varios niveles o capas. Cada
nivel en el diseño usa las posibilidades de los niveles inferiores para crear nuevas características
que usarán los niveles superiores. Estos niveles son:
(0) Dispositivos físicos de control de las transferencias de información entre la memoria y el

disco.
(1) Sistema básico de archivos, el cual usa las características del nivel anterior para leer y
escribir bloques en el disco. La indicación de los bloques que tiene que leer o escribir la hace
un módulo de organización de archivos que conoce el tipo de ubicación usado por los
archivos y la situación de los mismos.
(2) Sistema de archivos lógicos, que conoce la estructura de directorios. Estos se pueden tratar
como archivos de forma que el módulo de organización puede leer y escribir los directorios
cuando se producen peticiones del sistema de archivos lógicos.
(3) Programas de aplicaciones.
c) Control de acceso, que deberá verificar los permisos y los bloqueos de lectura y escritura.
Compartición de archivos
Se puede realizar de distintas formas (operación LINK). En Unix existe una pequeña estructura de datos,
el i-nodo, asociada al propio archivo, de forma que los directorios apuntarían al i-nodo correspondiente.
La creación de un enlace aumenta el contador de enlaces del i-nodo, de forma que el sistema conoce el
número de entradas de directorio que apuntan al archivo.
Cuando se intenta eliminar el archivo original, si se eliminase el archivo y su i-nodo sin más, el directorio
tendría una entrada que apuntaría a un i-nodo no válido. La solución es dejar intacto el i-nodo con su
contador en 1.
Enlaces simbólicos: Consiste en crear un nuevo archivo que contiene solamente la ruta de acceso al
archivo al que se quiere enlazar. Sólo el propietario del archivo tiene un apuntador al i-nodo. Ventaja: Se
pueden utilizar para enlazar archivos a otras máquinas. Inconvenientes:
a) Su alto coste. Hay que leer el archivo que contiene la ruta de acceso, analizarla y seguirla hasta
alcanzar el i-nodo. Se necesita incluir un i-nodo para cada enlace simbólico, así como un bloque
más en disco para almacenar la ruta de acceso, aunque ésta se podría almacenar en el propio i-
nodo.
b) Al restaurar un backup podrían crearse dos copias del mismo archivo.
Administ ra ción De Dis positivos De Almacenam iento Rotacional
En los sistemas de cómputo multiprogramados, la ineficiencia se debe muchas veces al uso inapropiado
de recursos de almacenamiento rotacional como discos y tambor. En esta sección se darán a conocer
algunos de los conceptos más importantes sobre administración de dispositivos de almacenamiento
rotacional.
En los sistemas de computación multiprogramados, muchos procesos pueden estar generando

solicitudes de lectura y escritura de registros en discos. Como a veces dichos procesos realizan
peticiones más rápido de lo que pueden ser atendidas por los discos de cabeza móvil, se forman colas
de espera para cada dispositivo. Algunos sistemas de cómputo se limitan a atender las peticiones según
un esquema de primero que llega, primero que se atiende (FCFS, first-come-first-served). FCFS es un
método justo para asignar servicio, pero cuando la tasa de solicitud (es decir, la carga) llega a ser
pesada, FCFS puede dar lugar a tiempos de espera muy largos.
FCFS exhibe un patrón de búsqueda aleatorio en el cual peticiones sucesivas pueden provocar
búsquedas de los cilindros más internos a los más externos, cosa que consume mucho tiempo. Para
reducir al mínimo el tiempo de búsqueda de registros, parece razonable ordenar la cola de solicitudes en
Página 40 de 164
una forma diferente a FCFS. Este proceso se conoce como planificación de disco. La planificación de
disco implica un examen cuidadoso de las peticiones pendientes para determinar la forma más eficiente
de atenderlas. Un planificador de disco examina las relaciones de posición entre las peticiones en
espera. La cola de espera se reordena para que las peticiones puedan atenderse con un mínimo de
movimiento mecánico. Los dos tipos más comunes de planificación son la optimización de búsqueda y la
optimización rotacional (o de latencia). Como los tiempos de búsqueda son un orden de magnitud más
grandes que los tiempos de latencia, la mayor parte de los algoritmos de planificación se concentran en
reducir al mínimo los tiempos de búsqueda para un conjunto de peticiones. La reducción de la latencia
por lo general tiene poco efecto sobre el rendimiento global del sistema, excepto bajo cargas pesadas.
Estructura De Un Disco
Antes de proseguir con las políticas de planificación de discos, es necesario mostrar, al menos, una
visión global de la estructura física de un disco. Además es conveniente hacer notar que prácticamente
todas las características asociadas a la forma de administración de un disco, también son válidas para
los tambores.
Físicamente, los discos son bastante sencillos. Cada disco tiene una forma circular plana, como un disco
de audio. Sus dos superficies están cubiertas con un material magnético, similar al de las cintas
magnéticas. La información se graba en dichas superficies.
Estructura Física
Cuando el disco está en uso, un motor lo hace girar a alta velocidad (por ejemplo, 60 revoluciones por
segundo). Tiene una cabeza de lectura y escritura ubicada justo encima de su superficie, la cual se
divide lógicamente en pistas. Se almacena la información grabándola magnéticamente en las pistas que
están debajo de la cabeza de lectura y escritura. En la superficie de un disco puede haber cientos de
pistas.
Un disco de cabeza fija tiene una cabeza para cada pista. Esta
disposición permite que el computador cambie rápidamente de una
pista a otra, pero requiere un gran número de cabezas, lo que hace
que el dispositivo sea muy costoso. Lo habitual es que haya una sola
cabeza, la cual se desplaza hacia adentro y hacia afuera para
acceder a las distintas pistas (ver figura).
Un disco de cabeza móvil requiere hardware para mover la cabeza.

En aquellas situaciones que requieren alto rendimiento, puede usarse
un disco de alta velocidad o un gran dispositivo de memoria (disco de
memoria de acceso directo (RAM Random Access Memory)), para así
obtener una mayor velocidad de acceso y transferencia que la que
puede ofrecer un disco convencional con una sola cabeza móvil.
Los discos se diseñaron originalmente para el almacenamiento de

archivos, por lo que los principales criterios de diseño fueron costo,
tamaño y velocidad.
Para ofrecer mayor capacidad de almacenamiento, los diseñadores siguieron varias estrategias,
obteniéndose la mayor ganancia al mejorar la densidad de grabación, permitiendo que se colocaran más
bits en una superficie. La densidad se refleja en el número de pistas por pulgada y, por consiguiente, en
el total de pistas de una superficie. Además, al colocar cabezas a cada lado del plato, la capacidad del
disco puede duplicarse con un costo mínimo. Se puede extender esta estrategia apilando varios discos,
cada uno con dos superficies de grabación, sobre un eje. Como todos los discos giran juntos, sólo se
necesita un motor, aunque cada superficie aún requiere su propia cabeza de lectura y escritura.
Los choques de la cabeza, debido a la distancia mínima existente entre cabeza y plato, pueden ser un
problema. Si la cabeza hace contacto con la superficie del disco (debido, por ejemplo, a un corte de
energía), la cabeza raspará el medio de grabación del disco, destruyendo los datos que allí se
Página 41 de 164
encuentren. En muchas ocasiones, cuando la cabeza toca la superficie se desprende el material
magnético y se introduce entre las otras cabezas y sus platos, ocasionado más choques. Antiguamente
en circunstancias normales, si se producía un choque de la cabeza había que cambiar todo el disco; en
la actualidad, gracias a las poderosas tecnologías de software, este riesgo es muy bajo.
El hardware para un sistema de disco puede dividirse en dos partes. La parte mecánica es la unidad de
disco, que incluye el motor del dispositivo, las cabezas de lectura y escritura y la lógica relacionada. La
otra parte, llamada controlador de disco, determina la interacción lógica con el computador. El
controlador recibe instrucciones de la CPU y ordena a la unidad de disco que ejecute la instrucción. Esta
división de tareas permite que varias unidades de disco se conecten al mismo controlador.
Para hacer referencia a la información en disco se emplea una dirección compuesta por varias partes,
que incluye el número de la unidad, la superficie y la pista. Al conjunto de pistas a las que se puede
acceder sin mover las cabezas (básicamente, las pistas en superficies distintas) en una misma unidad se
le denomina cilindro.
Dentro de una pista la información se escribe en bloques, los cuales pueden ser de tamaño fijo,
especificado por el hardware, y se llaman sectores; cada sector puede leerse o escribirse por separado.
Por otra parte, la información en un pista puede componerse de bloques de longitud variable, separados
por marcas de terminación. Este segundo esquema es más flexible, pero a la vez más difícil de usar.
Incluso, muchos sistemas, aunque por hardware tengan bloques variables en disco, por software
definirán un tamaño fijo.
Las transferencias de E/S entre la memoria y el disco se realizan en unidades de uno o más sectores.
Para direccionar un sector específico se necesitan un número de pista (o de cilindro), un número de
superficie y un número de sector. De esta manera, un disco se puede considerar como un arreglo
tridimensional de sectores, el cual comúnmente es tratado por el sistema operativo como un arreglo
unidimensional de bloques de disco, donde cada bloque es un sector. Por lo general, las direcciones de
los bloques aumentan al recorrer los sectores de una pista, después al pasar por todas las pistas de un
cilindro, y finalmente desde el cilindro cero hasta el último en el disco. Si se utiliza s para representar el
número de sectores por pista y p para el número de pistas por cilindro se puede convertir una dirección
en disco del cilindro i, superficie j, sector k, a un número de bloque unidimensional b, por ejemplo
calculando: b = k + s * [ j + (i*p) ]
Obsérvese que, al usar esta correspondencia, cuando el último bloque al que se accedió fue b, el acceso
al bloque b+1 requerirá un posicionamiento sólo cuando b sea el último bloque de un cilindro y b+1, el
primero del siguiente cilindro. lncluso en este caso, la cabeza sólo se desplazará una pista.
Un tambor es, de hecho, un disco de un solo cilindro. Como cada pista tiene su propia cabeza de lectura
y escritura, no hay tiempo de posicionamiento. Las principales diferencias entre discos y tambores están
relacionadas con el rendimiento, el costo y la capacidad de almacenamiento, pero no con su estructura
lógica.
Los discos presentan dos características importantes que los convierten en un medio adecuado para el
almacenamiento de múltiples archivos:
• Pueden rescribirse en el mismo lugar; en otras palabras, es posible leer un bloque del disco,
modificarlo y volver a escribirlo sin cambiar la ubicación.
• Se puede acceder directamente a cualquier bloque de información en el disco. De esta manera

es sencillo acceder aleatoria o secuencialmente a cualquier archivo, y para cambiar de un
archivo a otro sólo hay que mover las cabezas de lectura y escritura y esperar que gire el disco.
Estructura Lógica
Un disco generalmente cuenta con un directorio del dispositivo que indica cuáles son los archivos que se
encuentran en él. El directorio es la lista de los nombres de los archivos e incluye información como la
ubicación del archivo en el disco, su longitud, tipo, dueño, hora de creación, hora del último acceso,
Página 42 de 164
protecciones, etc. Como los bloques de un disco pueden rescribirse en su lugar, se puede leer, actualizar
y rescribir el directorio cada vez que sea necesario, sin tener que copiar el resto del disco.
Cada unidad de disco física, sea un paquete de discos o un disco flexible, tiene su propio directorio del
dispositivo, almacenado en el mismo dispositivo, generalmente en una dirección fija del disco, como la
00001 (la dirección 00000 es casi siempre es un cargador para el arranque del sistema). Esta
disposición es especialmente deseable en dispositivos removibles, como las unidades de discos flexibles
o paquetes. Si el medio se desmonta, se almacena y luego se vuelve a montar, quizá en una unidad de
disco diferente y aún se deseará poder localizar los archivos en ese dispositivo.
Planificación De Discos
Tal como se mencionó anteriormente, FCFS es un método relativamente justo para atender solicitudes.
Algunos otros criterios para clasificar las políticas de planificación son: la productividad, el tiempo
promedio de respuesta y la varianza de los tiempos de respuesta (predecibilidad).
Los criterios recién señalados tratan de mejorar el rendimiento global, cada vez a expensas de las
peticiones individuales. La planificación mejora a menudo el rendimiento global pero reduce el nivel de
atención para ciertas peticiones.
Una medida importante de este fenómeno es la varianza de los tiempos de respuesta. La varianza es
una medida matemática de cuánto se desvían elementos individuales del promedio de los elementos.
Como tal, se utiliza la varianza para indicar la predecibilidad: a menor varianza mayor predecibilidad.
En general, se desea una política de planificación que reduzca al

mínimo la varianza. De otra forma, ciertas peticiones recibirían niveles
de servicio erráticos, lo que podría ser intolerable. Si una política de
planificación sólo trata de aumentar la producción sin reducir al
mínimo la varianza, podría procesar nada más las peticiones fáciles y
hacer caso omiso de las difíciles.
Planificación FCFS (First Come First Served)

En planificación FCFS (primero que llega, primero que se atiende), la primera solicitud que llega es la
primera que se atiende. FCFS es justa en el sentido de que al llegar una solicitud, su lugar en la
planificación es fijo. Una petición no puede ser desplazada por la llegada de otra con mayor prioridad; en
efecto FCFS realizará una búsqueda larga para atender una petición en espera aunque llegue una
solicitud para el mismo cilindro donde esta colocada la cabeza de lectura-escritura.
Cuando las peticiones están distribuidas uniformemente en la superficie del disco, la planificación FCFS
da como resultado un patrón de búsqueda aleatorio. Hace caso omiso de las relaciones de posición
entre las solicitudes pendientes. No hace ningún intento por optimizar el patrón de búsqueda.
FCFS es aceptable cuando la carga del disco es ligera. Pero conforme crece la carga, FCFS tiende a
saturar el dispositivo y aumenta los tiempos de respuesta. FCFS sí ofrece una varianza pequeña, pero
esto no es mucho consuelo para la petición que espera al final de la cola mientras el brazo móvil se
desplaza de un lado a otro.
Planificación SSTF (Shortest Seek Time First)

En la planificación SSTF (primero el de menor tiempo de búsqueda), la petición que implica la menor
búsqueda es la siguiente en atenderse, aun cuando esta solicitud no sea la primera de la cola. SSTF es
un esquema orientado hacia los cilindros.
SSTF tiende a favorecer mucho ciertas solicitudes. Los patrones de búsqueda SSTF tienden a estar muy
localizados y, en consecuencia, las pistas más exteriores e interiores pueden recibir una atención
deficiente en comparación con la que reciben las pistas de la parte media.
Página 43 de 164
SSTF ofrece mejores tasas de productividad que FCFS, y los tiempos de respuesta tienden a ser más
bajos cuando la carga es moderada. Una desventaja importante es que aumenta la varianza de los
tiempos de respuesta debido a la discriminación contra las pistas exteriores e interiores. En un caso
extremo, podría hacer inanición de las solicitudes alejadas de las cabezas de lectura-escritura. Si se
consideran las importantes mejoras en la productividad y en los tiempos promedio de respuesta, el
aumento en la varianza puede parecer tolerable. SSTF resulta útil en sistemas de procesamiento por
lotes, donde la productividad es la consideración más importante. Pero la elevada varianza de los
tiempos de respuesta lo hace inaceptable en sistemas interactivos.
Planificación SCAN
Denning desarrolló la estrategia de planificación SCAN para evitar la discriminación y la alta variación en
los tiempos de respuesta de SSTF.
SCAN elige la solicitud que implica la menor distancia de búsqueda en una dirección preferida. Si la
dirección preferida en un momento dado es hacia afuera, la estrategia SCAN elige la distancia de
búsqueda más corta en esa dirección. SCAN no cambia de dirección hasta que llega al cilindro más
exterior o hasta que ya no hay solicitudes pendientes en la dirección preferida. En este sentido, se
denomina a veces algoritmo del ascensor. SCAN ha sido la base de la mayor parte de las estrategias de
planificación de disco implantadas hasta ahora.
A causa del movimiento oscilante de las cabezas de lectura-escritura en SCAN, las pistas más exteriores
se visitan con menos frecuencia que las de la parte media, pero ello no es tan grave como la
discriminación de SSTF.
Planificación SCAN De N Pasos (ó SCAN-N)

Una modificación interesante de la estrategia SCAN básica se denomina SCAN de N pasos. En esta
estrategia, el brazo del disco se mueve en una y otra dirección como en SCAN, excepto que sólo atiende
las solicitudes que ya estaban esperando cuando se inició un barrido específico. Las solicitudes que
llegan durante un barrido se agrupan y ordenan para darles una atención óptima durante el barrido de
regreso. En cada barrido se atienden las primeras n peticiones en secuencia óptima de acuerdo con la
dirección de la cabeza de lectura-escritura.
SCAN-N ofrece un buen desempeño en cuanto a productividad y tiempo promedio de respuesta. Su

característica más importante es la menor variación de los tiempos de respuesta que en la planificación
SSTF o en la SCAN convencional. SCAN de N pasos elimina la posibilidad de que ocurra un
aplazamiento indefinido si llega un gran número de peticiones para el cilindro actual.
Planificación C-SCAN
Otra modificación de la estrategia SCAN básica se denomina C-SCAN (SCAN circular). C-SCAN elimina
la discriminación de las estrategias anteriores contra los cilindros más interiores y exteriores.
En la estrategia C-SCAN el brazo se mueve del cilindro exterior hacia el interior, atendiendo solicitudes
según un criterio de la búsqueda más corta. Cuando el brazo ha completado su barrido hacia adentro,
salta inmediatamente a la solicitud más cercana al cilindro más exterior y luego reinicia su barrido hacia
adentro procesando solicitudes. C-SCAN presenta una varianza muy pequeña de los tiempos de
respuesta.
Algunos resultados de simulaciones indican que la mejor política de planificación de disco podría operar
en dos etapas. Cuando la carga es ligera, política SCAN es la mejor. Cuando la carga es mediana o
pesada, C-SCAN produce los mejores resultados. C-SCAN con optimización rotacional maneja en forma
activa las situaciones de carga pesada.
Página 44 de 164
Planificación LOOK
La planificación Look es una planificación que opera igual a SCAN, pero si hay peticiones sólo llega
hasta la última pista que tiene petición sin necesidad de llegar al final (lo que mejora significativamente el
desempeño).
Planificación C-LOOK
En la planificación C-Look (Look circular) es una combinación de C-SCAN y LOOK. Al igual que en C-
SCAN, C-LOOK mueve el brazo del cilindro exterior hacia el interior, atendiendo solicitudes según un
criterio de la búsqueda más corta. El brazo completa su barrido hacia adentro cuando llega hasta la
última pista que tiene petición sin necesidad de llegar al final, luego salta a la solicitud más cercana al
cilindro más exterior y luego reinicia su barrido hacia adentro.
Esquema De Eschenbach
Esta estrategia se desarrolló originalmente para un sistema de reservaciones de una línea aérea
diseñado para manejar cargas en extremo pesadas. El esquema fue uno de los primeros en tratar de
(*)
optimizar no sólo el tiempo de búsqueda, sino también el retraso rotacional . Sin embargo, la estrategia
C-SCAN con optimización rotacional ha demostrado ser mejor que el esquema de Eschenbach, sean
cuales sean las condiciones de carga.
Evaluación De Desempeño
Como un sistema operativo es en primer término un administrador de recursos, es importante que los
diseñadores, administradores y usuarios de los sistemas operativos sean capaces de averiguar cuán
efectivo es un sistema específico para manejar sus recursos.
En los primeros años del desarrollo de los sistemas de cómputo, el equipo representaba el costo
dominante, de manera que los estudios sobre desempeño se concentraban ante todo en aspectos del
equipo. Ahora los equipos son relativamente económicos y su costo baja cada vez más. Sin embargo,
los costos de la mano de obra han seguido creciendo constantemente. En consecuencia, se debe
comenzar a medir el desempeño con técnicas más acordes con la productividad humana. La
complejidad de los programas va en aumento con la generalización del empleo de sistemas operativos
de multiprogramación, multiprocesamiento, sistemas distribuidos, sistemas administrativos de bases de
datos, interfaces con el usuario orientadas a los gráficos y diversos sistemas de apoyo a aplicaciones.
Los programas ocultan a menudo el equipo al usuario, con lo que crean una máquina virtual definida por
las características de operación de los programas. Con frecuencia, los programas de difícil manejo
provocan un desempeño pobre, aun en sistemas con equipo poderoso, por lo que es importante
examinar el desempeño de los programas de un sistema además del desempeño del equipo.
La evaluación y predicción del desempeño se necesitan desde los primeros momentos de la concepción
de un sistema nuevo, en la operación cotidiana del sistema y después de la instalación, y cuando se
estudia su modificación o posible sustitución por un sistema mejor.
(*)
En condiciones de carga pesada aumenta la probabilidad de múltiples referencias a un cilindro específico, por lo
que resulta útil tener en cuenta la optimización rotacional además de la optimización de búsqueda. La optimización
rotacional se ha utilizado durante muchos años con dispositivos de cabeza fija. La estrategia de primero el tiempo
de latencia más corto (SLTF, shortest-latency-time-first) para la optimización rotacional es análoga a la estrategia
SSTF para la optimización de búsqueda. Una vez que el brazo del disco llega a un cilindro determinado, puede
haber muchas solicitudes pendientes para las diversas pistas de dicho cilindro. La estrategia SLTF examina todas
estas solicitudes y atiende primero la que tiene el retraso rotacional más corto. Se ha demostrado que esta
estrategia llega cerca del rendimiento óptimo teórico y su realización es relativamente sencilla. La optimización
rotacional se denomina a veces puesta en cola de sectores; los sectores se colocan en una cola según su posición
alrededor del disco y se atienden primero los sectores más cercanos.
Página 45 de 164
El desempeño (o rendimiento) se refiere al modo en el que un sistema de cómputo cumple con sus
objetivos, o la eficiencia con la que lo hace. Por tanto, el desempeño es una cantidad relativa más que
absoluta, aunque muchas veces se hablará de medidas absolutas de desempeño tales como el número
de trabajos por hora que puede atender un sistema de cómputo dado. No obstante, siempre que se
estima una medida del desempeño, lo normal es que sirva como base para comparaciones.
Algunas medidas del desempeño, tales como la facilidad de uso, son difíciles de cuantificar. Lo contrario
sucede con otras, tales como el número de accesos a disco por minuto. El evaluador del rendimiento
debe asegurarse de tomar en cuenta los dos tipos de mediciones, aunque quizá sólo sea posible
proporcionar datos estadísticos precisos en el segundo caso.
Se dice que algunas medidas del desempeño, tales como el tiempo de respuesta están orientadas al
usuario. Otras, como el porcentaje de utilización del procesador, se dice que están orientadas al sistema.
Algunas de las medidas más comunes del desempeño son:
• Tiempo de retorno (turnaround time): En un sistema de procesamiento por lotes, se define como
el tiempo transcurrido desde la entrega de un trabajo hasta su devolución al usuario.
• Tiempo de respuesta: Es el tiempo de retorno en un sistema interactivo, y a menudo se le define

como el tiempo transcurrido desde que el usuario presiona una tecla Enter (Intro) u oprime el botón
de un ratón hasta que el sistema comienza a imprimir o exhibir una respuesta.
• Tiempo de reacción del sistema: En un sistema interactivo, se define a menudo como el tiempo
transcurrido desde que el usuario presiona una tecla Enter (Intro) u oprime el botón de un ratón
hasta que se otorga la primera tajada de tiempo de servicio a esa solicitud del usuario.
Estas son cantidades probabilísticas, y en los estudios de simulación y modelado de sistemas se

consideran como variables aleatorias.
Cuando se habla del valor esperado de una variable aleatoria, se esta haciendo referencia a su valor
promedio. Pero los promedios muchas veces pueden ser engañosos porque un valor medio dado se
puede producir promediando una serie de valores idénticos o casi idénticos, o bien promediando una
amplia variedad de valores, algunos mucho más grandes y algunos mucho más pequeños que el
promedio calculado. Es por ello es que a menudo se utilizan otras medidas de desempeño, como por
ejemplo:
• Varianza de los tiempos de respuesta: La varianza de los tiempos de respuesta es una medida
de la dispersión. Una varianza pequeña indica que los tiempos de respuesta que perciben los
usuarios están en general cerca de la media. Una varianza considerable indica que algunos
usuarios pueden estar recibiendo tiempos de respuesta muy distintos de la media.
• Producción: Es la medida de rendimiento de trabajos por unidad de tiempo.
• Carga de trabajo: Es la medida de la cantidad de trabajo que se ha introducido en el sistema,

cantidad que el sistema debe procesar en condiciones normales para que su funcionamiento se
considere aceptable.
• Capacidad: Es una medida de la producción máxima que puede tener un sistema, si se supone
que cada vez que el sistema está preparado para aceptar más trabajos, hay otro trabajo
inmediatamente disponible.
• Utilización: Es la fracción de tiempo que está en uso algún recurso. La utilización puede ser una
medida engañosa. Aunque al parecer lo mejor es tener un porcentaje de utilización alto, esto
puede ser el resultado de un aprovechamiento ineficiente. Una forma de lograr un alto porcentaje
de utilización del procesador, por ejemplo, es ejecutar una serie de procesos, cada uno de los
cuales esta en un ciclo infinito. Otro punto de vista sobre la utilización del procesador ofrece
también observaciones interesantes. Se puede considerar que el procesador en un momento dado
está ocioso, en estado de programa o en estado de supervisión. Cuando un procesador está en
Página 46 de 164
estado de programa realiza labores en beneficio de un usuario y lo más probable es que el costo
se cobre a dicho usuario. Sin embargo, cuando el procesador esta en el estado de supervisión, se
encuentra dentro del sistema operativo. Parte de este tiempo se puede cobrar directamente a los
usuarios, pero una parte, como el tiempo ocupado en conmutar entre diversos procesos en los
sistemas de programación, no es sino un gasto general. Este componente de gasto general puede
ser considerable en algunos sistemas. Así, cuando se mide la utilización del procesador, debe
interesar cuánto de este uso es trabajo productivo en beneficio de los usuarios y cuánto es un
gasto general del sistema.
Página 47 de 164
CAP ÍT UL O IV
ADM INIST RACIÓN DE CPU
Retomando del concepto de procesos y la necesidad de planificar su utilización de la CPU, es necesario
tener presente que la planificación se hace teniendo en cuenta determinados criterios:
• Tiempo de respuesta. En un sistema interactivo puede que el mejor criterio no sea el tiempo de
retorno, por eso se utiliza esta otra medida: El tiempo que transcurre desde que se emite solicitud
hasta que se recibe la primera respuesta.
• Tiempo de retorno. Desde el punto de vista de un único proceso el criterio más importante es el
tiempo que tarda en ejecutarse. El intervalo de tiempo transcurrido desde la entrada de un proceso
en el sistema hasta su finalización.
• Plazos. Si se especifica un plazo de terminación de un proceso la planificación debe planificar

otras metas a la maximización de plazos cumplidos.
• Previsibilidad. Una tarea que se ejecute reiteradamente se deberá ejecutar en el mismo tiempo y
con el mismo coste.
• Productividad. Número de procesos finalizados por unidad de tiempo.
• Utilización de procesador. Porcentaje de tiempo que procesador esta ocupado.
• Equidad. Todos los procesos deben ser tratados de igual forma impidiendo inanición de un
proceso.
• Prioridades. Se debe favorecer a los procesos con mayor prioridad.
• Recursos equilibrados. En lo posible, se deben mantener todos los recursos del sistema
ocupados.
• Tiempo de espera. Total de tiempo que un proceso espera por su ejecución completa. Se obtiene
sumando los tiempos de espera de todas las ráfagas con el tiempo de espera de la primera ráfaga.
Además existen otras políticas de planificación. Por ejemplo, hay sistemas cuya política de planificación
se basa en prioridades de dos tipos: Estáticas (se mantienen durante la ejecución) y dinámicas (que
pueden variar durante ejecución). El resto de las políticas pueden ser de tipo apropiativas y no
apropiativas:
• No apropiativas (no explusivas). Una vez que el proceso obtiene CPU no le puede ser requisada
hasta que acaba la ráfaga. Tiene como inconveniente el acaparamiento injusto de la CPU.
• Apropiativas (explusivas). Permiten que un proceso con mayor prioridad requise de CPU al
proceso que la tenia asignada sin finalizar su ejecución. Para implementar un tiempo compartido y
tiempo real es necesaria una planificación apropiativa.
En general, existen varios algoritmos de planificación. Por ejemplo:
• FCFS (First Come First Serviced).

• SJF (Smallest Job First).
• SRT (ó SJF apropiativo).
• RR (Round Robin).
• Colas multinivel.
• Colas multinivel realimentadas.
Página 48 de 164
Algori tmo FCFS
En FCFS, el proceso que primero solicita la CPU es el primero al que se le asigna. Esta política se
implementa fácilmente utilizando una cola FIFO.
Cuando un proceso entra el PCB apunta al último proceso en la cola FIFO. Cuando la CPU está libre se
asigna al proceso que está situado primero en la cola. En la política FCFS el tiempo promedio de espera
es bastante largo.
El algoritmo FCFS es no apropiativo, una vez que se ha asignado la CP U a un proceso, éste la conserva
hasta que desee liberarla ya sea por terminación o por E/S lo cual puede llegar a ser especialmente
problemático. Por ejemplo:
Si P1 hubiese llegado al final, los tiempos

hubiesen mejorado bastante, logrando un
tempo de espera media de sólo 3.3
Algori tmos SJF & SRT
En el algoritmo SJF (tiempo restante más corto) se asocia a cada proceso la longitud de su siguiente
ráfaga de CPU. Cuando la CPU está disponible es asignada al proceso que tiene la siguiente ráfaga de
CPU menor. Si dos procesos tienen la misma longitud para la siguiente ráfaga de CPU se utiliza la
planificación FCFS para romper el empate.
Puede comprobarse que el algoritmo SJF es óptimo, ya que ofrece el menor tiempo promedio para un
conjunto de procesos dados.
El problema principal del algoritmo es el conocimiento de la longitud de la siguiente ráfaga de CPU por
tanto no puede implantarse a nivel de la planificación de la CPU, aunque se utilizan aproximaciones.
Aunque no se conocen los valores de las siguientes ráfagas de la CPU se puede predecir su valor
esperando que sea más o menos del mismo tamaño que las anteriores (por ello se elige el proceso con
ráfaga previa de CPU más breve)
El algoritmo SJF puede ser apropiativo (SRT) o no apropiativo. La alternativa se plantea cuando un
nuevo proceso llega a la cola de procesos listos mientras se está ejecutando otro proceso. El nuevo
proceso puede tener una ráfaga de CPU menor que lo que resta del proceso que se ejecuta en ese
momento. Un algoritmo SRT desplazará al proceso que se ejecuta. Por ejemplo:
Página 49 de 164
Planifi ca ción Por Pr iori da des
Bajo este concepto, el procedimiento se basa en que cada proceso tiene una prioridad; luego, entrará a
la CPU aquel proceso que tenga mayor prioridad. En este caso, la política puede ser explusiva o no
explusiva y las prioridades de los procesos las puede asignar en forma interna el propio sistema
operativo o pueden asignarse en forma externa por el usuario.
El algoritmo SJF es un caso de planificación por prioridades. En este caso prioridad será proporcional a
la duración estimada. El mayor riesgo que presenta la asignación de prioridad de este modo es la
posibilidad de postergar demasiado a los procesos con menos prioridad; como solución, se suele
aumentar progresivamente la prioridad de los procesos en espera (envejecimiento).
Algori tmo Round Robin
Round Robin (algoritmo de planificación circular) fue diseñado especialmente para sistemas de tiempo
compartido. Se define una pequeña cantidad de tiempo o cuanto de tiempo, que generalmente varía
entre los 10 y 100 milisegundos. La cola de procesos listos se trata como una cola circular, el
planificador de CPU la recorre asignando a cada proceso un cuanto de tiempo.
Se mantiene la cola de listos en una cola FIFO. Los nuevos procesos se agregan al final de la cola. El
planificador toma el primer proceso de la cola de listos y programa el cronómetro para que provoque
una interrupción y despacha el proceso. Pueden suceder una de estas dos cosas.
• Que el proceso tenga una ráfaga de CPU menor que el cuanto, el proceso se libera
voluntariamente.
• Si la ráfaga es más grande que el cuanto, el cronómetro se activará y provocará una interrupción
para el sistema operativo. Se ejecuta cambio de contexto y el proceso se colocará al final de la
cola de listos.
El rendimiento del RR depende en gran medida del cuanto de tiempo. Si el cuanto es muy grande la
política es la misma que la del FCFS. Si es muy pequeño, el enfoque se llama compartir el procesador, y
para los usuarios parece que cada proceso tiene su propio procesador; pero si llega a ser demasiado
pequeño, entonces, ocurrirán demasiados cambios de contexto y el rendimiento caerá.
Colas M ultinivel
Se han creado otros algoritmos de planificación

en aquellos sistemas donde los procesos pueden
clasificarse fácilmente en diferentes grupos.
Un algoritmo de planificación de colas de

múltiples niveles divide la cola en varios niveles.
Los procesos se asignan de forma permanente a
una cola, generalmente dependiendo de una
prioridad. Cada cola tiene su propio algoritmo de
planificación. Debe existir además una
planificación entre colas la cual es generalmente
una planificación apropiativa de prioridad fija. Se
gestiona la cola de más prioridad hasta que está
vacía y se pasa a la siguiente.
La planificación de colas multinivel (con realimentación) permiten al proceso moverse de una cola a otra.
La idea es separar a los procesos con diferentes características en cuanto a ráfagas de CPU. Si n
procesos utilizan demasiado tiempo la CPU, pasarán a una cola de menor prioridad. Este esquema deja
a los procesos interactivos y a los limitados por E/S en las colas de mayor prioridad.
Página 50 de 164
Por lo general un planificador de colas multinivel se define por los siguientes parámetros:
• Número de colas.
• Algoritmo de planificación para cada cola.
• El método utilizado para promover un proceso a colas de mayor prioridad.
• El método utilizado para degradar un proceso en colas de menor prioridad.
• Método utilizado para determinar a cual cola entrará un proceso cuando necesite un servicio.
• Tiempo umbral, definido como el tiempo en que una tarea puede finalizar si con esto finaliza su
ejecución completa mejorando así el rendimiento medio del sistema.
• Tiempo de refresco, que es el tiempo máximo que una tarea puede estar en una cola sin ser
ejecutado; transcurrido ese tiempo sube de nivel.
Algori tmo Round Robin Vir tual
El algoritmo RR Virtual se aplica a sistemas con muchas operaciones de E/S y ráfagas de CPU cortas.
Cuando se va a seleccionar una tarea, se da prioridad a las que han finalizado su operación de E/S
frente a las que vienen de la cola de listos. Con las tareas que vienen de E/S se crea una cola de
prioridad, pero el cuanto asignado queda disminuido en el tiempo de CPU ejecutado. Su finalidad es la
utilización de los dispositivos de E/S.
Evaluación De Las Polí ti cas
En la realidad es difícil determinar que algoritmo es mejor o peor; pues el rendimiento de cualquiera de
ellos variará en función de las cargas de trabajo. Por esta razón, es necesario aplicar algún criterio que
permita determinar la eficiencia de cada uno de ellos para finalmente implementar el que mejor se ajuste
a un sistema operativo en particular. Entre las estrategias utilizadas para evaluar la eficiencia de un
algoritmo se pueden encontrar:
• El modelo determinista. El cual consiste en someter a las políticas a una carga de trabajo
representativa.
• Los modelos de colas (estadísticos). Se trabaja con modelos estadísticos para evaluar
matemáticamente las cargas de trabajo.
• Las simulaciones. Se construye un modelo informático de la máquina y se le inyecta una carga de

procesos simulada.
• La implementación. En este caso simplemente se modifica el sistema operativo y se prueba en

condiciones reales.
Página 51 de 164
CAP ÍT UL O V
ADM INIST RACIÓN DE MEMORIA
En un sentido amplio los programas del sistema se encargan de controlar las operaciones propias del
computador, mientras que los programas de aplicación son los que resuelven problemas específicos a
los usuarios. De los programas del sistema el más importante es el sistema operativo cuyo objetivo es
que el computador se pueda utilizar de una manera cómoda y eficiente, proporcionando un caparazón a
la máquina desnuda que permite dar la visión de una máquina virtual, con la que es factible
comunicarse al crearse un interfaz entre el usuario y la máquina y gestionar los recursos de la misma.
Para mejorar la utilización de la CPU y su velocidad de respuesta a los usuarios, el sistema operativo
debe mantener varios procesos en memoria. Es posible hallar muchos esquemas para la administración
de la memoria, los cuales reflejan distintas estrategias para realizar una misma tarea, y la mejor o peor
eficiencia de los distintos algoritmos depende situaciones muy concretas.
Como ya se ha indicado en el Capítulo N° 2, la monoprogramación es el modo de trabajo en el que

solamente un programa utiliza el procesador. A continuación se mostrará cómo se ha gestionando y
cómo se gestiona la memoria en aquellos sistemas que utilizan este modo de trabajo:
La memoria de di ca da.
Las primeras computadoras utilizaban lo que sé denomina régimen dedicado, consistente en que el
programador accedía directamente al hardware y gestionaba la memoria en sus programas. En estos
primeros equipos se programaba en lenguaje máquina, sin existir sistema operativo y consiguientemente
tampoco gestor de memoria. De esta forma, la utilización de la memoria es ineficaz y se obliga a un
conocimiento profundo del hardware utilizado. El programador dedicaba gran parte de su tiempo y
esfuerzo a gestionar el propio hardware, desviándolo de su principal objetivo que era el proceso de la
información.
División De M emoria: El M onitor Resi dente

(*)
La introducción de los sistemas operativos para utilizar mejor el hardware dividió la memoria en dos
zonas, una utilizable por el usuario y otra reservada para la parte residente del propio sistema operativo
denominada comúnmente monitor.
Este reparto de la memoria introduce nuevos problemas que es necesario resolver, estos problemas son:
• Cómo asegurar la independencia de ambas zonas (Protección).
• Cómo asegurar que los programas de usuario no se vean afectados por esta división de la memoria.
Protección de la memor ia
Debido a que el programa monitor y el programa de usuario van a compartir la memoria, se hace
necesario proteger la zona del sistema operativo contra cualquier intento de acceso a dicha zona por
parte del programa. Se establece, por tanto, una dirección frontera que limita la zona del sistema
(*)
En general, se habla de particiones fijas (cuando la memoria es segmentada en porciones de tamaño fijo e
invariable durante el funcionamiento de la máquina) y de particiones variables (cuando la memoria es dividida
dinámicamente de acuerdo a las necesidades).
Página 52 de 164
operativo. Cualquier dirección de memoria que pida o solicite el programa de usuario se compara con
dicha dirección frontera, permitiendo el acceso o no, según corresponda. Este control se realiza
directamente por el hardware a través de uno de sus registros.
Evidentemente, este control provoca un cierto aumento de tiempo en el acceso a la memoria, pero éste
queda compensado con la mejora en rendimiento que permite el sistema operativo. La dirección frontera,
en general, suele ser variable para permitir que un sistema pueda ir evolucionando en prestaciones y
versiones de su propio sistema operativo, en definitiva que pueda variar su tamaño, obligando por tanto
a variar la dirección frontera.
Reasignación de dire cciones
Una vez inicializado el sistema operativo, el contenido del registro frontera indicará el punto a partir del
cual puede cargarse el programa de usuario. Para ello, es necesario reasignar las direcciones del
programa en función de la frontera. Existen dos formas de realizar la reasignación, una estática y otra
dinámica.
La reasignación estática se realiza durante la compilación, o bien durante la carga del programa en
memoria. De esta manera, cualquier variación de tamaño en el sistema operativo exige una nueva
compilación o carga del programa. Es una técnica fácil de realizar, pero demasiado rígida.
La reasignación dinámica se realiza durante la ejecución del programa. Un dispositivo especial del
hardware interceptará cada dirección lógica generada por el programa y le sumará el contenido del
registro frontera para obtener la dirección real correspondiente.
Cualquiera que sea la técnica utilizada, el usuario no manejará direcciones reales en su programa.
Utilizará direcciones relativas que podrán variar entre 0 y el máximo permitido por el sistema operativo.
Este es el denominado espacio lógico de direcciones. Posteriormente, el sistema operativo, con la ayuda
del hardware, establecerá la correspondencia adecuada entre las direcciones relativas y las direcciones
reales que configuran lo que se denomina espacio físico de direcciones (memoria real). Esta separación
entre la visión del usuario (espacio lógico) y la memoria real (espacio físico) permite gestionar ésta con
mayor eficacia.
M emoria Virtual
En la actualidad es muy corriente oír hablar de memoria virtual en el ambiente computacional. Como su
nombre lo indica, la memoria virtual es una memoria que en realidad no existe físicamente. Si bien se
entiende que la memoria es cualquier forma de almacenamiento, permanente o no, la memoria virtual es
un tipo de memoria equivalente a la memoria RAM, es decir es volátil y limitada. Pero es un tipo de
memoria con capacidades de almacenamiento generalmente mucho mayores que la capacidad de una
memoria RAM ordinaria, pero paga esta virtud en velocidad; es decir, la memoria virtual es mucho más
lenta que la memoria RAM.
La memoria virtual puede ser generada a partir de una combinación de capacidades de hardware y
sistema operativo. Su tamaño es inversamente proporcional a su velocidad de acceso y generalmente se
trata de una forma de almacenamiento en disco el cual es administrado de una forma muy especial a fin
de acelerar al máximo las velocidades de acceso y traspaso de información a la memoria RAM para su
utilización verdadera. La memoria virtual más allá de cumplir una función similar a la memoria RAM es
algo así como un soporte para guardar momentáneamente toda la información que es de vital
importancia para la correcta funcionalidad de los procesos pero que por limitaciones de hardware no
pueden ser almacenada en RAM. La idea fundamental detrás de la memoria virtual es que el tamaño
combinado del programa, los datos y la pila de ejecución puede exceder la cantidad de memoria real
disponible para él. El sistema operativo mantiene aquellas partes del programa que se están utilizando
en cada momento en la memoria principal y el resto permanece en el disco. En la medida en que se
vayan necesitando nuevas partes estas se intercambian con las residentes en la memoria principal.
En los sistemas que utilizan memoria virtual, todas las direcciones son virtuales y el conjunto de todas
ellas conforman el espacio de direcciones virtuales. En los computadores donde no hay memoria virtual,
Página 53 de 164
la dirección se coloca directamente sobre el bus de la memoria, lo que permite que se pueda acceder al
contenido de la memoria física que tenga tal dirección. Al utilizar memoria virtual, las direcciones no
pasan directamente al bus de memoria, sino que van a una unidad de administración de la memoria
(MMU, Memory Manager Unit), un conjunto de chips, que asocian las direcciones virtuales con las
direcciones de memoria física.
La idea central de la memoria vi rtual es que dirección es diferente de localización física, por ello se hace
necesario tomar las direcciones virtuales y convertirlas a reales para poder tener acceso a la posición de
memoria correspondiente.
Sw appin g
Como se mencionó anteriormente una de las principales preocupaciones administrativas del sistema
operativo, en cuanto a memoria virtual se refiere, es la optimización del proceso de intercambio de
información entre la memoria RAM y la memoria virtual. Este proceso es conocido como swapping.
Los tiempos de E/S son considerablemente superiores a los tiempos de procesamiento de la CPU, por lo
que la memoria que el programa no está verdaderamente utilizando, perfectamente podría ser despejada
para dejar lugar para ser utilizada por otro programa que sí la requiera.
Una forma de realizar el intercambio es utilizando el swapping. La idea básica es que cada programa
que está en memoria principal (RAM) tiene una copia en memoria secundaria (memoria virtual) y esa
copia se traspasa a memoria principal cada vez que se requiera.
Una forma de economizar tiempo puede obtenerse si se tiene presente que en la memoria virtual sólo
son dinámicos los datos y los resultados de los procesos, pero el código de los programas (procesos de
instrucción) siempre son fijos. Así, si existe una copia de ellos en memoria secundaria, no es necesario
rescribirlos en memoria secundaria, sólo se requiere eliminarlos de memoria principal.
Además, es posible compartir código de programas o bibliotecas de datos muy utilizados. Por ejemplo,
en un sistema de tiempo compartido donde todos los usuarios están trabajando en la creación de
documentos de un mismo editor, entonces se podría tener en memoria principal sólo una copia del
editor, la cual puede ser compartida por todos los usuarios.
De esta forma sería recomendable dividir la memoria principal en

tres áreas.
• Una de almacenamiento de datos. Los que implican

intercambio de entrada y salida.
• Una de almacenamiento de programas. Los que implican sólo
intercambio de salida.
• Una de almacenamiento compartido. Lo cual no implica
ningún tipo de intercambio.
Página 54 de 164
Segmentación
Es posible generalizar la idea de separar la parte de programa y datos, y dividir la memoria en tantos
trozos de longitud variable como sea posible y necesario. Este procedimiento es conocido como
segmentación. Así, por ejemplo, cada rutina podría pertenecer a un trozo separado.
La segmentación tiene considerables ventajas desde el punto de vista administrativo de la memoria, ya

que es más fácil encontrar trozos libres pequeños. Además, no es necesario tener todo el programa en
memoria a la vez; basta tener aquellos segmentos, de él, que verdaderamente están participando de la
ejecución.
(*)
Por supuesto, al ser los segmentos de longitud variable, se producen overhead , por lo que es
conveniente minimizar las transacciones de estas secciones. Esto puede lograrse haciendo que las
palabras que son referenciadas en forma cercana pertenezcan a un mismo segmento.
Típicamente una rutina correspondería a un mismo segmento; un arreglo, una estructura como una lista
sería también conveniente que fuesen almacenadas ordenadamente en un mismo segmento.
Los programas y los datos son almacenados arbitrariamente en memoria principal. Un segmento es
descrito por un descriptor de segmento que, entre otras cosas, apunta a la base del segmento en
memoria. Todos los descriptores de segmentos se almacenan en una tabla de segmentos.
Hay una tabla de segmentos para cada proceso y la base y el tamaño de cada segmento se anotan en el
descriptor mismo de cada segmento.
Una dirección virtual es un par ordenado (s,d), donde s es el índice dentro de la tabla de segmentos (no
es directamente el apuntador al bloque) y d es un desplazamiento hacia el segmento (celda inicial dentro
del segmento, no del bloque). Por lo tanto:
Direccion_Real ß Tabla_segmento[s].base + d; ∀ 0 ≤ d ≤Tabla_segmento[s].limite

Direccion_Virtual ß (s,d)
Algunos de los problemas típicos que se pueden producir, son:
1. s esta fuera del rango máximo de la tabla de segmentos.

2. d es mayor que el desplazamiento máximo permitido.
3. El segmento referenciado por la tabla de segmentos no existe en memoria principal.
Estos podrían considerarse como un error. Pero, si se recuerda que se está tratando de un medio
compuesto por una memoria principal y una virtual, se corrige inmediatamente realizando el intercambio
correspondiente, del segmento referenciado, desde memoria virtual a memoria principal.
Al costado derecho se puede ver gráficamente el concepto de

traducción de direcciones de memoria.
Dentro de cada entrada de la tabla de segmentos se encuentra un

campo (Long) que indica la longitud del segmento. Este se utiliza
para verificar que no se hagan referencias fuera del segmento. Si
esto llegase a ocurrir se generaría una interrupción.
(*)
Si bien se afirma que un segmento puede ser de longitud variable, se entiende que la memoria virtual se compone
de bloques de longitud fija, los que a su vez se componen de celdas. Idealmente un segmento debería estar
cuantizado en bloques y no en celdas pero esto haría perder espacio de almacenamiento disponible. Por lo tanto los
segmentos se cuantifican en celdas. Por lo tanto, la responsabilidad del sistema operativo es asignar la información
de los segmentos de tal modo que estos ajusten lo más perfectamente posible a los bloques. Cuando un bloque es
utilizado por dos o más segmentos a la vez se dice que existe un overhead.
Página 55 de 164
Un descriptor de segmentos se compone de tres campos de
atributos y tres campos de datos.
donde :
Index :Es el índice del descriptor dentro de la tabla de segmentos.
Type :Programa, dato ó descriptor compartido.
State :En memoria principal, secundaria o en intercambio.
Length :Largo del segmento.
base :Dirección.
limit :Dirección máxima.
El mecanismo de traducción de una dirección sería:
If (s > Tabla_Segmento[s].limit) {
Error("Tabla de segmento fuera de rango")
}
else {
X ß Tabla_Segmento[s]
If (d > X.length) {
Error("Segmento fuera de rango")
}
else {
If (x.state = accesible) { // en memoria principal
Dir ß X.base + d
}
else {
SegFault() // Intercambiar de memoria secundaria a principal
}
}
}
Este algoritmo debe ser invocado por el hardware para cada operación fetch (buscar) de una instrucción
y también por cada referencia a una palabra de memoria.
En síntesis, las ventajas de la segmentación es que evita la fragmentación interna, ya que los segmentos
se definen del tamaño que se requiera y que facilita la protección de la memoria. Por otra parte, la
principal desventaja es que conduce a fragmentación externa, que es un fenómeno que presenta cuando
se manejan bloques de longitud variable.
Paginación
Cuando los trozos de memoria son de tamaño fijo se denominan páginas. El almacenamiento real es
(*)
particionado en marcos del mismo tamaño que las páginas. De este modo una página puede y debe
ser almacenada sólo en un marco y viceversa.
En forma análoga al mecanismo de direccionamiento de segmentos, para la paginación se tiene:
Direccion_Virtual ß (p,d), donde p es el indicador de la página y d el desplazamiento en ella.
(*)
Entiéndase como partición a las secciones en las que puede ser fraccionada la memoria principal. Así, es
conveniente tener presente que en el caso de la segmentación las particiones son variables y en el caso de la
paginación las particiones son fijas. También, según el esquema más sencillo de administración de memoria, lo
menos complejo es tener una sola partición
Página 56 de 164
Se utiliza también una tabla de páginas en la cual serán almacenadas
todas las referencias a la página. Así mismo, el descriptor de páginas
es similar al descriptor de segmentos, pero sin el campo de longitud de
página.
Si se supone que es el hardware el encargado de verificar que una

dirección base sea válida, el algoritmo para la traducción de una
dirección por paginación del sistema operativo es:
X ß Tabla_Pagina[p]
If (d > Tamaño_Marco_Página) {
Error("Desplazamiento fuera de rango de página")
}
else {
If (x.state = accesible) { // en memoria principal
Dir ß X.base + d
}
else {
PageFault() // Intercambiar de memoria secundaria a principal
}
}
Como ejemplo, suponga que un computador puede generar direcciones

virtuales de 16 bits que van desde 0 hasta 640K. Suponga además que
la máquina sólo tiene 32K de memoria real. El espacio de direcciones
virtuales se divide en unidades denominadas páginas y las unidades
correspondientes en memoria real, marcos de página. Las páginas y
los marcos siempre tienen el mismo tamaño. En el ejemplo son de 4K.
Las transferencias entre la memoria real y el disco son siempre
unidades de página.
Por ejemplo, si el programa referencia la dirección 0 virtual, esta se

envía a la MMU. La MMU ve que esta dirección cae en la página 0 (0-
4095), la cual de acuerdo a la tabla de páginas está en el marco 2
(8192-12287). Transforma entonces la dirección en 8192 y manda esta
al bus. La memoria no sabe de la existencia de la MMU y sólo ve una
solicitud de acceso a la posición 8192, la que atiende.
La dirección virtual 21500, que está a 20 bytes del inicio de la página virtual 5 (20480-24575) está
asociada a la dirección real 12288+20=12308.
Dado que la memoria virtual tiene 16 páginas y la memoria real 8 marcos de página, en un momento
dado sólo se podrán albergar en ésta última 8 páginas. Es por ello que 8 entradas en la tabla de páginas
están marcadas con x, indicando que ellas no residen en la memoria real.
Si se referencia la dirección virtual 32780 que está en la página 8 (12 bytes abajo de 32768). Como se
ve en el gráfico, la entrada correspondiente está marcada con x, lo que indica que ella no reside en la
memoria real. En este caso se presenta una interrupción denominada defecto o fallo de página, entonces
el sistema operativo toma el control, elige un marco de página y lo "baja" de la memoria real. Después
trae la página correspondiente a la dirección referenciada y la ubica en el marco liberado, modifica las
entradas correspondientes en la tabla de páginas y reinicia el proceso.
Si en el ejemplo, el sistema operativo decidió liberar el marco 1, carga la página virtual 8 en la dirección
física 4K y hará dos modificaciones a la tabla de página. En la entrada 1 quedará una x, indicando que
está página ya no reside en la memoria real y en la entrada 8 quedará un 1 indicando que está página
reside en tal marco. De esta forma la dirección virtual 32780, será traducida como 4108 real.
Página 57 de 164
En un régimen permanente, todos los marcos van a tender a estar ocupados, luego será necesario ir
desalojando marcos no utilizados para almacenar allí las páginas faltantes de otro proceso que sea
demandado.
El método de paginación permite tener páginas compartidas entre varios programas. Normalmente
también existe un bit que indica si una determinada página ha sido modificada o no, lo cual es utilizado
para determinar si el contenido de una página almacenada en un marco debe ser copiado a memoria
secundaria o no.
Resulta conveniente tener información, asociada a cada marco, que

permita decidir que página desalojar y cual traer a memoria principal.
Esta información es almacenada en una tabla de marcos y los distintos
procesos (esquemas) de decisión de paginación se llaman algoritmos de
reemplazo. A la derecha se muestra la entrada típica en una tabla de
páginas.
• La dirección del marco de página, guarda la dirección en memoria real donde se encuentra la
página.
• El bit presente/ausente, indica si la página reside en la memoria real o no. Si la página no está
presente (0) y se referencia, se producirá un defecto de página.
• Los bits de protección indican el tipo de acceso permitido. Estos generalmente se conocen como
rwx y dependiendo de si están encendidos, la página se podrá leer (r), escribir (w) o ejecutar (x).
• El bit de modificación se enciende cada que la página sufre algún cambio en memoria real. Se
utiliza cuando la página es seleccionada para salir de la memoria real, cuando se presenta un
defecto de página. Si el bit está encendido, entonces la página se escribirá sobre el disco. En caso
contrario sólo se desecha pues la imagen en disco es igual a la existente en la memoria real.
• El bit de referencia como su nombre lo indica se enciende cada vez que la página es
referenciada, bien sea para lectura o escritura. Sirve para apoyar al sistema operativo, para
seleccionar la página a salir cuando se presenta un defecto de página. Las páginas no
referenciadas son unas muy buenas candidatas a salir. Ver algoritmos de reemplazo.
• El bit de caching. Si esté esta desactivado, cuando se produzca una operación de E/S, el sistema
(*)
operativo busca la información en el hardware y no una copia antigua en el caché .
Existe un gran número de algoritmos de reemplazo de entre los cuales se hará mención a cuatro:
• Randómico. Es el método más sencillo; supone que es imposible adivinar que página será
requerida en el futuro. Cuando es necesario traer alguna página a memoria principal selecciona
aleatoriamente un marco y lo desaloja para dejar el espacio requerido.
• Cíclico. Es un método bastante simple, el cual consiste en ir trayendo páginas, no necesariamente

en orden, a memoria principal y cada vez que sea requerido un espacio se desaloja el marco
siguiente al último utilizado. Es decir, se va buscando cíclicamente en la tabla de marcos, de modo
que una página debe esperar todo un ciclo para ser desalojada. Este método supone que el
tiempo de utilización de una página es muy cercano al tiempo promedio de utilización.
• FIFO. Supone que la probabilidad de la utilización de una determinada página es una función
decreciente en el tiempo. Requiere de una cola FIFO, en la que se van anotando las páginas a
(*)
La memoria caché agiliza el proceso y amortigua la diferencia de velocidad
entre la memoria principal y los registros máquina. Estos últimos, son registros
de almacenamiento implementados en hardware, siendo su velocidad de acceso
elevada y su tamaño muy limitado.
Página 58 de 164
medida que van siendo traídas a memoria principal. De este modo, cuando se requiere un marco
de página, se retira la página que lleva más tiempo en memoria.
• LRU (Last Recently Used). El método del último recientemente usado, se basa en el hecho de
que algunas páginas son mucho más utilizadas que otras. La suposición es que la probabilidad de
que una página sea utilizada depende del intervalo de tiempo transcurrido desde su última
utilización. A menor intervalo mayor probabilidad de seguir utilizando la página. Por lo tanto se
desalojan las de mayor intervalo de tiempo transcurrido (las que menos se han usado).
Los métodos mencionados anteriormente son sólo de desalojo de marcos. El ideal de todos estos
métodos es nunca llegar a desalojar una página que será referenciada muy próximamente.
Así mismo, existen técnicas de paginación para realizar el intercambio desde memoria secundaria a
principal. El más simple de ellos es paginar sólo cuando sea necesario. Una forma más eficiente y más
compleja es utilizar algún medio de paginación anticipada, el cual consiste en adivinar que página del
almacenamiento secundario será requerida en el futuro próximo y cuando la CPU disponga de un
quantum de tiempo ocioso calcular que página es posible desalojar y, entonces, realizar la paginación
anticipada.
Si el número de marcos asignados a un proceso de baja prioridad desciende por debajo del número
mínimo requerido por la arquitectura del computador, se debe suspender la ejecución de ese proceso.
Luego, se deben descargar sus páginas restantes, liberando todos los marcos asignados.
Si un proceso no posee suficientes marcos asignados, provocará pagefoults frecuentes; sin embargo
como todas sus páginas están activas, deberá descargar una página que muy probablemente se volverá
utilizar dentro de un breve lapso de tiempo. Por consiguiente vuelve a efectuar un pagefoult una y otra
vez. A esta altísima actividad de paginación se le conoce como hiperpaginación; análogamente existe la
hipersegmentación. Se dice que un proceso se encuentra en fase de hiperpaginación cuando emplea más
tiempo paginando que procesando (ejecutando).
Paginación De M últi ples Niveles
Para evitar el problema de tener unas tablas de páginas

muy grandes en la memoria todo el tiempo, algunos
sistemas utilizan tablas con varios niveles o
(*)
hiperpaginación .
La idea central de las tablas de páginas de varios niveles

consiste en evitar mantener todas las tablas en la
memoria todo el tiempo. Aquellas que no sean
necesarias no deben mantenerse allí.
La dirección virtual ahora se compone de tres campos: dos direcciones de páginas y un desplazamiento.
Cuando una dirección virtual llega a la MMU, esta extrae primero el componente p1 y lo utiliza como
índice en la tabla de páginas de nivel 1. Allí ubica la dirección donde se encuentra la dirección de inicio
de otra página en la tabla de páginas de nivel y con la componente p2 de la dirección encuentra la
dirección del marco que contiene la página respectiva. Luego con la tercera componente de la dirección,
el desplazamiento d, encuentra la dirección real.
El sistema de dos tablas, puede aumentarse a tres o más, pero ello implica que la complejidad del
sistema se eleve de manera considerable, por lo que no se acostumbra más de tres niveles.
(*)
Así como el concepto de paginación, dependiendo del contexto, puede ser entendido como (1) una estrategia de
administración de memoria o como (2) el proceso de intercambio de páginas desde memoria virtual a memoria
real. La hiperpaginación puede ser entendida como (1) una estrategia de paginación de múltiples niveles o como
(2) el intercambio excesivo de páginas entre memoria real y memoria virtual.
Página 59 de 164
Segmentación/Paginación
En este método las direcciones virtuales se componen de
tres partes: un segmento, una página y un desplazamiento
(offset). La primera sirve para encontrar la entrada en la
tabla de segmentos en donde se encuentra la dirección
donde comienza la página, con la segunda componente se
encuentra la entrada correspondiente a la página y allí la
dirección del marco de página que junto con el
desplazamiento dan la dirección real.
Una ventaja de este método es que permite mantener una estructura de segmentación sin conducir a
fragmentación externa. Además permite mantener las tablas de páginas en memoria auxiliar.
Fragmenta ción
Tanto para el caso de la paginación, para el de segmentación y en general en todos los sistemas de cómputo (sea
cual sea la organización de su almacenamiento), se presenta la fragmentación del almacenamiento.
En los sistemas de multiprogramación y particiones fijas, la fragmentación se presenta porque los trabajos de los
usuarios (páginas) no llenan por completo las particiones designadas (marcos) o porque una partición se queda sin
utilizar por ser demasiado pequeña para almacenar una tarea en espera.
La fragmentación se presenta en todas las formas de almacenamiento y a todo nivel de información. En el caso de
la paginación, cuanto menor sea el tamaño de las páginas, más páginas y marcos de página habrá y mayores
tendrán que ser las tablas de marcos. El desperdicio de almacenamiento primario debido a tablas excesivamente
grandes se denomina fragmentación de tablas.
Para el caso de particiones variables y fijas, también existe una forma de fragmentación de la información en el
sentido que, a pesar de estar ocupadas todas las particiones, la información correspondiente a una misma tarea se
encuentra dispersa en una serie de particiones no contiguas y nisiquiera en un orden ascendente o descendente.
Fragmentación por Fragmentación por

perdida de espacios división de código de procesos
Los sistemas operativos modernos y las nuevas técnicas de programación y generación de códigos (por ejemplo la
programación orientada al objeto) minimizan el nivel de fragmentación de la información de tal forma que, al menos
para el caso de los códigos de ejecución de programas, se puede afirmar que la fragmentación es casi nula.
Estrategias De Local i dad
El concepto de localidad es fundamental en la mayor parte de las estrategias administrativas de memoria, e indica
que los procesos tienden a hacer referencia a la memoria en patrones no uniformes y altamente localizados.
Concepto De Localidad
La localidad se manifiesta tanto en el tiempo como en el espacio. La localidad temporal es la localidad en el tiempo(*)
y la localidad espacial significa que los elementos cercanos a una localidad tienden a ser similares a los contenidos
en dicha localidad(**).
(*)
Si en La Serena se sabe que son las 3:00 P.M. y está lloviendo intensamente, entonces es muy probable, aunque no
seguro, que el clima haya estado así hace 15 minutos y en 15 minutos más continúe igual.
Página 60 de 164
La localidad es una propiedad empírica que se observa, en los sistemas operativos, particularmente en
el área de la administración del almacenamiento. Nunca esta garantizada, pero generalmente es
altamente probable.
De hecho, si se toma en consideración la forma en que se escriben los programas y se organizan los
datos y códigos, el concepto de localidad es bastante razonable en los sistemas computacionales.
Tal vez una de las consecuencias más significativas de la localidad de las referencias a memoria es que
un programa puede ejecutarse más rápida y eficientemente mientras su subconjunto de páginas
favorecido se encuentre en el almacenamiento primario.
Se han realizado muchísimos estudios que ilustran el concepto de localidad. Gracias a estos estudios
nació la teoría de conjunto de trabajo en el comportamiento de un programa.
Localidad temporal Localidad espacial
• Ciclos, • Recorridos de arreglos,

• Subrutinas, • Ejecución secuencial de código,
• Pilas, • Tendencia de los programadores a ubicar,
• Variables de cuenta y totalización. próximas unas de otras, las definiciones de
variables afines
Conjunto De Trabajo
En términos informales, un conjunto de trabajo es un conjunto de páginas a las que se hace referencia
activamente en un proceso. Se ha afirmado que para ejecutar en forma eficiente un programa se debe
mantener en memoria principal su conjunto de trabajo; de otra forma, podría surgir una situación de
hiperpaginación, debido a las frecuentes solicitudes de páginas contenidas en memoria virtual.
Lamentablemente, este tipo de deducciones a menudo dirigen el accionar hacia políticas de
administración de memoria virtual en exceso conservadoras, lo cual limita en última instancia el número
real de procesos que pueden disponer de marcos para compartir el almacenamiento primario.
Una política administrativa del almacenamiento virtual mediante conjuntos de trabajo intenta mantener
en memoria principal todos los conjuntos de trabajo de cada uno de los procesos activos. La decisión de
añadir o no un nuevo proceso al conjunto de procesos activos se basa en el hecho de si existe suficiente
espacio de almacenamiento principal como para contener todo el conjunto de trabajo del nuevo proceso.
Debido a que, en la situación inicial, es imposible determinar el tamaño exacto del conjunto de trabajo de
un proceso determinado, el cálculo de dimensiones de los grupos de trabajo, generalmente, se realiza a
través de heurísticas.
Se define el conjunto de trabajo como una función sobre un

par ordenado: W(t,w), donde W representa el número de
páginas a las que el proceso ha hecho referencia en el
intervalo de tiempo t-w.
El tiempo de proceso es el tiempo durante el cual un

proceso tiene la CPU. A la variable w se le conoce como
tamaño de ventana del conjunto de trabajo.
La determinación de la magnitud adecuada de w es fundamental para la adecuada operación de alguna
estrategia de administración del almacenamiento con conjuntos de trabajo. Es claro que a medida que el
tamaño de w aumenta también lo hace el conjunto de trabajo del proceso asociado.
Cuando el sistema operativo destruye proporcionalmente la memoria significa que recoge la información
de los conjuntos de trabajos y asigna memoria según la demanda en forma proporcional a las
necesidades de cada aplicación. Cuando la distribución de memoria se efectúa en partes iguales sin
importar las necesidades reales de cada aplicación, se haba de una distribución equitativa.
(**)
Si en La Serena se sabe que son las 3:00 P.M. y está lloviendo intensamente, entonces es muy probable, aunque no
seguro, que en los pueblos cercanos el clima esté en las mismas condiciones.
Página 61 de 164
Los conjuntos de trabajo varían durante el transcurso de ejecución de un
proceso. En ocasiones se añaden o quitan páginas, a veces el cambio es
drástico y el proceso requiere de un cambio total del grupo de trabajo.
Así, las suposiciones acerca del contenido y tamaño del grupo de trabajo
inicial no son necesariamente válidas para la posteridad del proceso. Esta
situación complica un poco las cosas para la política de administración
con conjuntos de trabajo.
En la figura anterior, Tr representa una transacción de páginas y Ci representa un conjunto de trabajo en

algún momento. Primero, a medida que el proceso solicita la paginación de su conjunto de trabajo inicial
recibe gradualmente suficiente almacenamiento para contener su conjunto de trabajo. En ese instante y
por algún tiempo su utilización del almacenamiento primario se estabiliza mientras hace sólo referencias
a las páginas activas de su conjunto de trabajo. Después de un tiempo, el proceso realizará una
transición al siguiente grupo de trabajo, como lo muestra la cercha que une el primer grupo de trabajo y
el segundo. Inicialmente, la curva sobrepasa el número de páginas del primer conjunto de trabajo debido
a que el proceso demanda una paginación rápida de su nuevo conjunto de trabajo. El sistema no tiene
forma de determinar si se trata de una paginación que agrega más páginas al conjunto de trabajo previo
o si se esta renovando por completo el conjunto de trabajo. Cada vez que ocurre una transacción entre
conjuntos de trabajo, la curva asciende y desciende haciendo notar la forma en que el sistema se adapta
a la transición.
Algori tmos De Reempla zo
Existen muchos y variados algoritmos para el reemplazo de páginas. Quizá cada sistema operativo
cuente con su propio esquema de reemplazo. En general, se requiere de la selección de un algoritmo de
reemplazo en particular el que presente la menor tasa de fallas de página.
Se evalúa un algoritmo ejecutándolo para una serie determinada de referencias a memoria y calculando
el número de fallas de página. A la serie de referencias a memoria se le Ilama serie de referencias. Se
pueden generar artificialmente las series de referencias (utilizando, por ejemplo, un generador de
números aleatorios) o rastreando un sistema y anotando la dirección de cada referencia a memoria. La
segunda opción produce un gran número de datos (alrededor de un millón de direcciones por segundo).
Para reducir el número de datos, se observan dos aspectos.
En primer lugar, para un tamaño de página dado se necesita considerar sólo el número de página, no
toda la dirección. Segundo, si se tiene una referencia a una página p, entonces ninguna referencia a la
página p que se presente inmediatamente después provocará una falla de página; la página p ya se
encontrará en memoria después de la primera referencia y las referencias siguientes no provocarán
fallas. Por ejemplo, si se rastrease un proceso determinado, se puede anotar la siguiente secuencia de
direcciones:
0100, 0432, 0101, 0612, 0102, 0103, 0104, 0101, 0611, 0102, 0103,
0104, 0101, 0610, 0102, 0103, 0104, 0101, 0609, 0102, 0105,
lo cual, a 100 bytes por página, se reduce a la siguiente serie de referencias
1, 4, 1, 6, 1, 6, 1, 6, 1, 6, 1.
Para determinar el número de fallas de página para una serie de referencias y un algoritmo de
reemplazo de páginas concreto, se necesita conocer también el número de marcos de página
disponibles. Evidentemente, si aumenta el número de marcos, se reducirá el número de fallas de página.
Por ejemplo, para la serie de referencias antes mencionada, si se dispusiese de tres o más marcos, se
tendrían sólo tres fallas, una para la primera referencia a cada página. Por otra parte, si hubiera sólo un
marco disponible, se tendría un reemplazo con cada referencia, generando 11 fallas. Por lo general, se
espera una curva decreciente. Al aumentar el número de marcos, el número de fallas de página se
reduce hasta un nivel mínimo.
Además de los algoritmos de reemplazo mencionados anteriormente en este texto, se pueden destacar:
Página 62 de 164
Algoritmo De Bits Adicionales De Referencia
Se puede obtener información adicional de la ordenación anotando los bits de referencia a intervalos
regulares. En una tabla en memoria se pude conservar un byte de ocho bits para cada página. A
intervalos regulares (supóngase cada 100 milisegundos), una interrupción del cronómetro transfiere el
control al sistema operativo. El sistema operativo desplaza el bit de referencia de cada página al bit de
orden superior de su byte de ocho bits, desplazando los otros bits una posición a la derecha y
descartando el bit de orden inferior. Estos registros de desplazamiento de ocho bits contienen la historia
de la utilización de la página durante los últimos ocho periodos. Si el registro de desplazamiento contiene
00000000, entonces la página no ha sido utilizada en ocho periodos; una página que se utiliza por lo
menos una vez cada periodo tendría un valor 11111111 en su registro de desplazamiento.
Una página con un valor 11000100 en su registro histórico ha sido utilizada más recientemente que una
con valor 01110111. Si de interpretan estos bytes de ocho bits como enteros sin signo, la página con el
menor número es la página menos recientemente utilizada y puede reemplazarse. No obstante,
obsérvese que no se garantiza que los números sean únicos. Se puede reemplazar todas las páginas
con el menor valor o utilizar una selección FIFO entre ellas.
Por supuesto, el número de bits históricos puede variar, y esa cantidad se seleccionaría para acelerar las
actualizaciones todo lo posible. En el caso extremo, el número puede reducirse a cero, dejando
únicamente el bit de referencia. Esta versión se denomina algoritmo de reemplazo de páginas de
segunda oportunidad.
Algoritmo De Segunda Oportunidad
El algoritmo básico para el reemplazo de segunda oportunidad es un algoritmo FIFO. Sin embargo,
cuando se selecciona una página, se examina su bit de referencia; si es igual a 0, se reemplaza la
página. Sin embargo, si el bit de referencia es 1, se da a la página una segunda oportunidad y se pasa a
seleccionar la siguiente página en el orden FIFO. Cuando a una página se le brinda una segunda
oportunidad, se borra su bit de referencia y se establece como su instante de Ilegada el momento actual.
De esta manera, una página a la que se le brinda una segunda oportunidad no será reemplazada hasta
que todas las demás páginas se reemplacen (o se les otorgue una segunda oportunidad). Además, si
una página se usa con la frecuencia suficiente para mantener en 1 su bit de referencia, nunca será
reemplazada.
Una forma de implantar el algoritmo de segunda oportunidad (en ocasiones mencionado como reloj)
consiste en usar una cola circular. Un apuntador indica cuál es la siguiente página que se reemplazará.
Cuando se requiere un marco, el apuntador avanza hasta encontrar una página con bit de referencia a 0;
conforme avanza, borra los bits de referencia. En el peor de los casos, cuando todos los bits están a 1, el
apuntador recorre toda la cola, dando a cada página una segunda oportunidad; además, borra todos los
bits de referencia antes de seleccionar la siguiente página para el reemplazo.
Si todos los bits están activos, el reemplazo de segunda oportunidad se convierte en un reemplazo FIFO.
Algoritmo LFU
Un algoritmo de reemplazo de página menos frecuentemente usada (LFU, least frequently used)
mantiene un contador del número de referencias que se han hecho para cada página. Se reemplaza la
página con el menor recuento. La razón para esta selección es que una página que se usa activamente
debe tener un alto número de referencias. Este algoritmo tiene problemas cuando una página se usa
mucho en la fase inicial de un proceso, pero después ya no se utiliza. Como se usó bastantes veces,
tiene un recuento alto y permanece en memoria aunque ya no se necesite. Una solución consiste en
desplazar los recuentos un bit a la derecha a intervalos regulares, formando un recuento promedio de
utilización que disminuye exponencialmente.
Página 63 de 164
Algoritmo MFU
Otro algoritmo para el reemplazo de páginas es el reemplazo más frecuentemente usado (MFU, most
frequently used), que se basa en el argumento de que la página con el menor recuento probablemente
acaba de llegar y aún tiene que usarse. Como se podría esperar, no es común ni el reemplazo MFU ni el
LFU. La implantación de estos algoritmos, es bastante costosa y estos no se aproximan mucho al
reemplazo óptimo.
Algoritmos Adicionales
Existen muchos otros algoritmos que pueden usarse para el reemplazo de páginas. Por ejemplo, si se
considera tanto el bit de referencia como el bit de modificación como un par ordenado, se tienen las
cuatro clases siguientes:
(0,0) : Ni usada ni modificada.

(0,1) : No usada (recientemente), pero modificada.
(1,0) : Usada pero limpia (no modificada).
(1,1) : Usada y modificada.
Cuando es necesario un reemplazo de página, cada página se encuentra en una de estas cuatro clases.
Se reemplaza la página en la clase inferior no vacía. Si hay varias páginas en la clase inferior, se utiliza
el reemplazo FIFO o se elige al azar una entre ellas.
Algoritmos Basados En Ajuste
Cuando los procesos y los espacios se mantienen en una lista ordenada por direcciones, se pueden
utilizar diversos algoritmos para asignar la memoria para un proceso de reciente creación. Se supone
que el administrador de memoria conoce la cantidad de memoria a asignar. Entre ellos están:
First Fit (Primero en Ajustarse): El administrador de memoria revisa toda la lista de segmentos hasta
encontrar un espacio lo suficientemente grande. El espacio se divide entonces en dos partes, una para el
proceso y otro para la memoria no utilizada. Este algoritmo es rápido, puesto que busca lo menos
posible.
Siguiente en Ajustarse : Funciona de la misma forma que el anterior, con la diferencia que mantiene un
registro del lugar dónde se encuentra un espacio adecuado. La siguiente vez que se le llama, comienza
a buscar desde el punto donde se detuvo, en lugar de comenzar a buscar siempre desde el inicio.
Best Fit (Mejor en Ajustarse): Busca en toda la lista y toma el mínimo espacio adecuado. En lugar de
asignar un espacio grande, intenta encontrar un espacio lo más cercano al tamaño necesario.
El peor ajuste: Toma siempre el espacio más grande disponible, de forma que el espacio resultante sea
lo suficientemente grande para ser útil.
Estos cuatro algoritmos pueden agilizarse si se tienen dos listas independientes, una para los procesos y
otra para los espacios. De esta forma todos ellos, pueden limitarse a inspeccionar la lista de espacios y
no la de los procesos. Sin embargo, el aumentar la velocidad implica que la complejidad se aumenta y la
velocidad al liberar la memoria se aumenta, ya que un segmento liberado, debe ser liberado de la lista de
procesos y adicionado a la lista de espacios libes.
Otro algoritmo de asignación es el de ajuste rápido, que consiste en tener listas independientes para
algunos de los tamaños que se solicitan con mayor frecuencia. Si se solicita un espacio de tamaño típico
(de los más frecuentes) se busca primero en tales listas. Igual sucede si se libera, se adiciona a una de
ellas. Esto facilita la administración de la memoria puesto que se van a tener espacios libres de tamaños
comunes en una lista, lo que facilita su búsqueda. Sin embargo el mantenimiento de las listas también es
costoso en tiempo.
Página 64 de 164
CAP ÍT UL O VI
CONCURRENCIA
Para fines prácticos, los términos paralelo y concurrente, desde el punto de vista computacional, son
equivalentes. En estricto rigor, se dice que los procesos son concurrentes si existen en un mismo
intervalo de tiempo (dt>0). Por otra parte, se dice que los procesos son paralelos si existen en un mismo
instante t. (dt=0). Los procesos concurrentes pueden funcionar en total independencia, o bien, pueden
(*)
ser asíncronos .
Dos (o más) procesos son paralelos si existen un mismo instante de tiempo, lo que implica que deben
ser ejecutados en procesadores separados (para mayor información véase capítulo VIII).
Por otra parte, se dice que dos (o más) procesos son concurrentes si están activos simultáneamente.
Gráficamente, se tiene:
Los procesos P1 y P2, así como P2 y P3 son concurrentes, en cambio P3 y P1 no lo son. Generalizando
se puede decir que cuando hay multiprogramación hay una alta probabilidad de tener concurrencia. Los
procesos no concurrentes no presentan problemas de coordinación, pues se ejecutan en períodos
diferentes de tiempo y por lo general no hay comunicación entre ellos. Los procesos concurrentes
pueden ser independientes si no hay interacción directa entre ellos o dependientes si la hay. Para los
procesos concurrentes dependientes deben crearse mecanismos de comunicación y coordinación entre
ellos.
Para efectos de análisis, se supondrá que las INSTRUCCIÓN PASOS

instrucciones son entes indivisibles. Por ejemplo, en
Load X
la realidad un simple incremento de contador se X← X+1 Add 1
ejecuta en tres pasos, aún cuando la instrucción es
Store X
sólo una.
Del mismo modo, es conveniente considerar a los procesos como un conjunto de instrucciones. Por
ejemplo, se supondrá un sistema que administre bloques de memoria y una pila para anotar las
direcciones de los bloques de memoria. El acceso a esta pila se hace mediante las operaciones:
dirección ← Get_Bloque(), para pedir un dato de memoria (liberar memoria).

Set_Bloque(dirección), para poner un dato en memoria (pedir memoria).
Se supondrá la existencia de tres programas que comparten el uso de la memoria principal bajo el
control del sistema operativo (ver figura).
El sistema operativo mantiene la pista de los bloques de

memoria libres en una pila S. Cuando un bloque libre es
requerido, el elemento del tope de la pila es retirado.
Cuando un bloque se libera es colocado en la pila S.
Además, se hará el fantasioso supuesto de que el
sistema nunca ejecutará la instrucción Get_Bloque()
cuando la pila S esté vacía.
(*)
Un proceso asincrónico requiere de sincronización y cooperación con otros procesos.
Página 65 de 164
Se definen las rutinas para la administración de memoria:
Get_Bloque() { Set_Bloque(dirección) {
Dirección ← Pila[Tope] Tope ← Tope + 1
Tope ← Tope - 1 Pila[Tope] ← Dirección
Return(Dirección) }
}
Si se sabe que ambas operaciones se ejecutan concurrentemente y si se imagina que las rutinas pueden
dividirse y entremezclarse, podría ocurrir la siguiente ejecución de instrucciones:
t0 : Tope ← Tope + 1
t1 : Dirección ← Pila[Tope]
t2 : Tope ← Tope - 1
t3 : Pila[Tope] ← Dirección
se obtiene como resultado que la operación Get_Bloque() recibe una dirección inválida y la operación
Set_Bloque() destruye una dirección buena. Por lo tanto debe hallarse la forma de que las operaciones
puedan ser ejecutadas en instantes de tiempo no entremezclados y en forma estrictamente secuencial;
como si se tratase de instrucciones indivisibles. A tales bloques de ejecución indivisible se conocen con
el nombre de secciones críticas, y la modificación adecuada de estas operaciones será vista a
continuación.
Secciones Crít i cas
Considere un sistema compuesto por n procesos {P0, P1, ..., Pn-1}. Cada proceso tiene un segmento de
código, llamado sección crítica, en el cual el proceso puede estar modificando variables comunes,
actualizando una tabla, escribiendo en un archivo, etc. La característica importante del sistema es que,
cuando un proceso se ejecuta en su sección crítica, no se permite que ningún otro proceso se ejecute en
su sección. De esta manera, la ejecución de las secciones críticas de los procesos es mutuamente
excluyente en el tiempo. El problema de la sección crítica consiste en diseñar un protocolo que los
procesos puedan usar para cooperar. Cada proceso debe solicitar permiso para entrar en su sección
crítica; la sección de código que implanta esta solicitud es la sección de entrada. A la sección crítica
puede seguir una sección de salida y el código que queda es la sección restante. Una solución para el
problema de la sección crítica debe cumplir los tres requisitos siguientes:
1. Exclusión mutua. Si un proceso P1 se está ejecutando en su sección crítica, entonces ningún

otro proceso se puede estar ejecutando en la suya.
2. Progreso. Si ningún proceso se está ejecutando en su sección crítica y hay otros procesos que
desean entrar en las suyas, entonces sólo aquellos procesos que no se están ejecutando en su
sección restante pueden participar en la decisión de cuál será el siguiente ítem que ingresará en la
sección crítica (y esta selección no puede postergarse indefinidamente).
3. Espera limitada. Debe haber un límite en el número de veces que se permite que los demás
procesos entren en su sección crítica después de que un proceso haya efectuado una solicitud
para entrar en la suya y antes de que se conceda esa solicitud.
Es importante no olvidar que aunque se supone que cada proceso se ejecuta a una velocidad no nula,
no puede hacerse ninguna suposición acerca de la velocidad relativa de los n procesos. Cuando un
proceso está accesando datos compartidos, se dice que el proceso se encuentra en una sección crítica.
Por lo tanto, las secciones críticas tienen que ejecutarse lo más rápidamente posible, un programa no
debe bloquearse dentro de una sección crítica y se deben evitar los ciclos infinitos.
Las secciones críticas pueden ser fácilmente restringidas asociándoles un nombre único. Por ejemplo si
el nombre de una sección crítica fuese Nom_Bloque, se tiene que:
Página 66 de 164
Get_Bloque(Num_Bloque) { Set_Bloque(Num_Bloque , Dirección) {
When (Num_Bloque) { When (Num_Bloque) {
Dirección ← Pila[Tope] Tope ← Tope + 1
Tope ← Tope - 1 Pila[Tope] ← Dirección
Return(Dirección) }
} }
}
La forma correcta de implementar el mecanismo de seguridad administrativo de las secciones críticas

puede realizarse a través de diversos mecanismos: Operaciones Lock/Unlock, operaciones P y V ,
operaciones Wait/Signal, etc.
Operaciones Lock/Unlock
La operación Lock tiene por objetivo el bloquear la entrada a cierta área a los demás procesos; la
operación Unlock anula el efecto de Lock.
Supóngase que el acceso de memoria se hace en forma indivisible. Lock(Llave[S]) {

Siendo S el nombre de una región crítica que solamente puede ser < Sección Crítica >
accesada por un proceso a la vez. Asumiendo que si S es asociado a una }
celda de memoria Llave[S], se tiene que la estructura de programación Unlock(Llave[S])
sería la señalado a la derecha:
Ahora, si Llave[S]=1 entonces el acceso a dicha sección está permitido, en caso contrario el acceso es
denegado. De esta forma las primitivas Lock() y Unlock() quedarían como:
Lock(Llave[S]) { Unlock(Llave[S])
Repeat {
V ← Llave[S] Llave[S] ← 1
Until ( V = 1) }
Llave[S] ← 0
}
Las secciones críticas se pueden agrupar en clases, siendo mutuamente exclusivas las secciones
críticas de cada una. Para conseguir dicha exclusión, se deben implementar protocolos de software que
impidan o bloqueen el acceso a una sección crítica mientras está siendo utilizada por un proceso. Los
protocolos son la parte de código dedicada a asegurar que la sección crítica se ejecuta de forma
exclusiva. Resulta adecuado que tanto la sección crítica como los protocolos sean lo más breves posible.
Bloqueo Mediante El Uso De Variables Compartidas
Supóngase que se asocia a cada recurso que se comparte un flag que podrá tomas dos valores:
• True: Indicará que el recurso está siendo utilizado

• Fase: Indicará que el recurso está disponible
La ejecución concurrente de los procesos se iniciará mediante la estructura cobegin/coend.
Para evitar que se entrelace el uso del recurso por ambos procesos, se asocia un indicador a cada uno
de los procesos. Ambos procesos pueden leer los dos indicadores, pero sólo pueden modificar el que
tienen asociado. Esto evita el problema de que los dos procesos actualicen de forma simultánea el
mismo indicador. Antes de acceder al recurso, un proceso debe activar su indicador y comprobar que el
otro no tiene su indicador activado.
Si ambos procesos realizasen la llamada al bloqueo de forma simultánea, ambos verían los indicadores
contrarios como ocupados y permanecerían a la espera de que el recurso quede liberado. Esta acción se
conoce como interbloqueo (deadlock ). Se puede intentar resolver el problema haciendo que el proceso
Página 67 de 164
desactive su propio indicador durante la fase de bloqueo siempre que encuentre que el indicador del otro
proceso está activado. Esto permitiría que, en caso de interbloqueo, se pueda proseguir, siempre que no
exista una completa sincronización entre los procesos.
Otro posible problema sería que podría permitir que un proceso deje su sección crítica y vuelva a entrar
mientras que el otro proceso desactiva su indicador en la sección de bloqueo. El que un proceso no
pueda progresar porque se lo impida otro se denomina cierre (lockout o starvation).
Sincronización De Ejecución
Un Grafo de Precedencia es un grafo acíclico orientado cuyos nodos

corresponden a sentencias individuales. Un arco de un nodo Si al nodo Sj
significa que la sentencia Sj puede ejecutarse sólo cuando ha acabado Si.
Los grafos no se pueden utilizar en programación; por lo tanto se

requieren otras herramientas: La ejecución concurrente de los procesos
se iniciará mediante la estructura cobegin/coend (también conocida como
parbegin/parend). En estricto rigor, la ejecución concurrente de procesos
puede efectuarse en dos niveles:
A nivel de lenguajes ensambladores se utiliza FORK (bifurcar)

para crear exactamente dos procesos concurrentes a partir de
sólo uno y JOIN (unir) para provocar la confluencia de
exactamente dos procesos en uno solo.
A nivel de lenguajes de compilador de alto nivel se utiliza PARBEGIN para

indicar el inicio de una secuencia de dos (o más) procesos que se ejecutarán
concurrentemente y PAREND para indicar su término.
Por ejemplo, dado el siguiente segmento de código:

1.- aß(x+y)
2.- bß(z+1)
3.- c ß ( a - b)
4.- wß(c+1)
Es posible observar que las líneas N° 1 y N° 2 son independientes y por lo tanto es posible su ejecución
simultánea. Gráficamente, esto es:
Luego, su implementación en ambos con ambas estructuras sería:
Utilizando FORK y JOIN Utilizando PARBEGIN y PAREND

FORK L1 PARGEGIN
aß(x+y) aß(x+y)
GOTO L2 bß(z+1)
L1: b ß ( z + 1 ) PAREND
L2: JOIN c ß ( a - b)
c ß ( a - b) wß(c+1)
wß(c+1)
Página 68 de 164
Algoritmo de Peterson
Se introduce una variable adicional (turno) que solamente resultará útil cuando se produzca un
problema de petición simultánea de acceso a la región crítica (para mayor información véase monitores,
página número 77).
module Exclusion_Mutua_P;
var flag1, flag2: boolean; turno: integer;
procedure bloqueo (var mi_flag, su_flag: boolean; su_turno: integer);

begin
mi_flag := true;
turno := su_turno;
while su_flag and (turno = su_turno) do ; end
end bloqueo;
procedure desbloqueo (var mi_flag: boolean);

begin
mi_flag := false;
end desbloqueo;
process P1
begin
loop
bloqueo (flag1, flag2,2);
(* Uso del recurso Sección Crítica *)
desbloqueo (flag1);
(* resto del proceso *)
end
end P1;
process P2
begin
loop
bloqueo (flag2, flag1,1);
desbloqueo (flag2);
end
end P2;
begin (* Exclusion_Mutua_P *)
flag1 := false;
flag2 := false;
cobegin
P1;
P2;
coend
end Exclusion_Mutua_P.
Si ambos procesos intentan entrar a la vez, el valor de turno se pondrá a 1 y 2, pero sólo uno de los
valores permanecerá al escribirse sobre el otro.
El algoritmo permite resolver el problema de la exclusión mutua y garantiza que ambos procesos usarán
de forma consecutiva el recurso.
Página 69 de 164
Algoritmo De Dekker
La variable turno sirve ahora para establecer la prioridad relativa de los dos procesos (para mayor
información véase monitores, página número 77).
module Exclusion_Mutua_D;
var flag1, flag2: boolean; turno: integer;
procedure bloqueo ( var mi_flag, su_flag: boolean; su_turno: integer );

begin
mi_flag := true;
while su_flag do (* otro proceso en la sección crítica *)
if turno = su_turno then
mi_flag := false;
while turno = su_turno do; (* espera a que el otro acabe *)
end;
mi_flag := true;
end;
end;
end bloqueo;
procedure desbloqueo ( var mi_flag: boolean; su_turno: integer );

begin
turno := su_turno;
mi_flag := false
end desbloqueo;
process P1
begin
loop
bloqueo (flag1, fgal2, 2);
desbloqueo (flag1);
end
end P1;
process P2
begin
loop
bloqueo (flag2, flag2, 1);
desbloqueo (flag2);
end
end P2;
begin (* Exlusion_Mutua_P *)
flag1 := false;
flag2 := false;
turno := 1;
cobegin
P1;
P2;
coend
end Exlusion_Mutua_D.
Página 70 de 164
Los algoritmos de Peterson y Dekker se pueden extender al caso más general en el que haya n
procesos en ejecución concurrente; pero no son soluciones adecuadas, ya que la espera de acceso a un
recurso siempre se realiza de forma ocupada: el proceso se queda permanentemente comprobando una
variable.
Sincronización Con Instrucciones De Hardware
Para el sistema operativo, el problema de administración se dificulta en forma evidente al considerar

seriamente el problema de las secciones críticas. El problema de la sección crítica puede solucionarse
simplemente evitando que ocurran interrupciones mientras se modifica una variable compartida, pero por
desgracia no siempre es factible esta solución. Por esto, muchas máquinas ofrecen instrucciones de
hardware especiales que permiten evaluar y modificar el contenido de una palabra o intercambiar
atómicamente el contenido de dos palabras. Estas instrucciones especiales pueden usarse para resolver
el problema de la sección crítica de una manera bastante sencilla, por ejemplo:
Evaluar_y_asignar (objetivo) {
Evaluar_y_asignar ← objetivo;
objetivo ← verdadero;
}
La característica importante es que la instrucción se ejecuta atómicamente, es decir, como una unidad
ininterrumpible, de modo que si dos instrucciones Evaluar_y_asignar se ejecutan simultáneamente
(cada una en una en la misma CPU), lo harán secuencialmente siguiendo algún orden arbitrario.
Repeat
while Evaluar-y-asignar(cerradura) do Esperar
< Sección Crítica >
cerradura ← falso
< Sección Restante >
Until (falso);
Si la máquina permite la instrucción Evaluar_y_asignar, entonces se puede implantar la exclusión

mutua declarando una variable booleana cerradura con valor inicial falso.
La instrucción Intercambiar, intercambia atómicamente el contenido

de dos palabras y se define como se muestra a la derecha. Intercambiar (a, b) {
temporal ← a
Como en el caso de la instrucción Evaluar_y_asignar, la instrucción a← b
Intercambiar también se ejecuta atómicamente. b ← temporal
}
Si la máquina permite la instrucción Intercambiar, entonces la exclusión mutua puede ofrecerse de la

siguiente manera: Se declara una variable booleana global cerradura y se le asigna un valor inicial falso.
Además, cada proceso tiene una variable local booleana clave.
repeat
clave ← verdadero
repeat
Intercambiar(cerradura,clave)
until (clave =falso) Obsérvese que estos algoritmos no satisfacen
< Sección Crítica > el requisito de la espera limitada.
cerradura ← falso
< Sección Restante >
until (falso)
Página 71 de 164
Semáforos
El sistema de protección a través de las operaciones Lock/Unlock, los procesos deciden quién entra a la
sección crítica. Sin embargo debería ser el sistema operativo el encargado de realizar esta
determinación.
Los semáforos pueden utilizarse para tratar el problema de la sección crítica para n procesos y también
pueden usarse para resolver varios problemas de sincronización.
Un semáforo binario es un indicador de condición S que registra si un recurso está disponible o no:
• Si S=1, entonces el recurso está disponible.

• Si S=0, entonces el recurso no está disponible.
Los semáforos se implementan con una cola de tareas o de condición a la cual se añaden los procesos
que están en espera del recurso.
Las operaciones P y V fueron inventadas en 1965 por E. W. Dijkastra. Dijkastra llamó al argumento de
una operación P y V semáforo en analogía con la luz de tráfico del ferrocarril, el cual indica que si un tren
entra a la línea el semáforo cambia de color la luz para asegurar que ningún otro tren ingrese a la línea.
La operación P(S) produce que el sistema operativo bloquee la entrada a la sección S y permite la
entrada sólo al proceso que ejecutó la operación. La operación V(S) desbloquea la sección para dejar el
acceso disponible para cualquier proceso que lo solicite.
Si A y B son dos procesos concurrentes y se utiliza un indicador de prioridades que apunta al proceso
siguiente cuando el actual termina, se tiene que las primitivas de proceso son:
Proceso A { Proceso B {
Entrada[A] ← 1 Entrada[B] ← 1
While (Entrada[A] = 1) { While (Entrada[B] = 1) {
While (Prioridad <> A) { While (Prioridad <> B) {
} }
<Instrucciones de Sección Crítica> <Instrucciones de Sección Crítica>
Prioridad ← B Prioridad ← A
} }
Por otro lado, se observa que existen otras operaciones a través de las cuales es posible manejar
secciones críticas.
Operaciones Wait/Signal
Si existe un evento E compartido entre, al menos, dos procesos, se definen las operaciones:
Wait(E), en espera de la ocurrencia del evento E.

Signal(E), ocurrencia del evento E.
Si un proceso requiere de la ocurrencia de un evento para terminar su ejecución deberá esperar hasta
que el evento ocurra; cuando el proceso termina deberá señalar que el evento ya ha ocurrido y que está
en espera de otro proceso que lo solicite.
A modo de ejemplo, supóngase un clásico ejemplo de productor y consumidor. Se tienen dos procesos
un productor y un consumidor, además se dispone de un buffer sencillo con capacidad para almacenar
un dato. Para que el productor pueda producir un dato y almacenarlo en el buffer, éste debe estar vacío;
Página 72 de 164
análogamente el consumidor para poder extraer un dato del buffer, debe esperar hasta que éste esté
lleno.
Bajo las condiciones anteriores, las primitivas de control para los procesos productor, consumidor y la
inicialización son:
Productor() { Consumidor() {
Repeat Repeat
X ← Algún dato Wait(Buffer_Lleno)
Wait(Buffer_Vacío) X ←Buffer
Buffer ← X Signal(Buffer_Vacío)
Signal(Buffer_Lleno) Utilización ← X
Until ( término del proceso) Until ( término del proceso)
} }
Inicializacion() {
Signal(Buffer_Vacío)
“Iniciar procesos Productor()
y Consumidor() en paralelo.”
}
Una versión más detallada del problema del productor/consumidor debería contemplar que hay
situaciones en las que existe un conjunto de procesos que producen información que otros procesos
consumen, siendo diferentes las velocidades de producción y consumo. Esto es:
module Productor_Consumidor;
var
BufferComun: buffer;
AccesoBuffer, Nolleno, Novacio: semaforo;
process Productor;
var x: dato;
begin
loop
produce (x);
espera (AccesoBuffer);
if Lleno then
señal (AccessoBuffer);
espera (NoLleno);
espera (AccesoBuffer)
end;
Poner (x);
señal (AccesoBuffer);
señal (Novacio)
end
end Productor;
process Consumidor;
var x: dato;
begin
loop
espera (AccesoBuffer);
if Vacio then
espera (Novacio);
espera (AccesBuffer)
end
Tomar (x);
Página 73 de 164
señal (Nolleno);
consume (x)
end
end Consumidor;
begin
inicializa (AccesoBuffer, 1);
inicializa (Nolleno, 1);
inicializa (Novacio, 0);
cobegin
Productor;
Consumidor;
coend
end Productor_Consumidor;
El acceso al buffer para tomar o poner un dato está protegido por las operaciones espera y señal del
semáforo AccesoBuffer. Antes de ejecutar las operaciones espera (Nolleno) y espera (Novacio) se
libera el semáforo AccesoBuffer para evitar que se bloquee el sistema.
Versión Más General De Los Semáforos
Cuando hay que proteger un conjunto de recursos similares, el semáforo se inicializa con el número total
de recursos disponibles (n) y las operaciones de espera y señal se diseñan de modo que se impida el
acceso al recurso protegido por el semáforo cuando el valor de éste es menor o igual que cero. Cada
vez que se solicita y obtiene un recurso, el semáforo se decrementa y se incrementa cuando se libera
uno de ellos. Si la operación de espera se ejecuta cuando el semáforo tiene un valor menor que 1, el
proceso debe quedar en espera de que la ejecución de una operación señal libere alguno de los
recursos.
Operaciones primitivas sobre un semáforo generalizado:
Operación de inicializar
inicializa (S: SemaforoBinario; v: integer)
poner el valor del semáforo S al valor de V (n)
numero_suspendidos := 0
Operación de espera
espera (S)
if S > 0 then S := S - 1
else
numero_suspendidos := numero_suspendidos + 1
suspender la tarea que hace la llamada y ponerla en la cola de tareas
Operación de señal
señal (S)
if numero_suspendidos > 0 then
numero_suspendidos := numero_suspendidos -1
pasar al estado preparado un proceso suspendido
else S := S + 1
Si el semáforo se asocia a un código concurrente, su valor inicial restringe el número máximo de

ejecuciones concurrentes que se pueden realizar.
Buffers Múltiples
En el ejemplo anterior se hizo el supuesto de la existencia de un buffer simple con capacidad para un
solo elemento. En la realidad un buffer puede contener N datos. Si además se dispone de más de un
Página 74 de 164
buffer (por simplicidad supóngase sólo dos: uno de entrada y otro de salida) las condiciones de
procesamiento serían:
1. El proceso productor debería esperar a que el buffer de entrada tuviese espacio para almacenar al
menos un dato.
2. El proceso consumidor debería esperar a que el buffer de salida tuviese al menos un dato
almacenado.
3. Si el proceso consumidor intenta acceder el buffer de salida y detecta que este está vacío, deberá
marcarlo como buffer de entrada y al de entrada como buffer de salida. Lo cual es válido sólo si al
menos uno de los buffer contiene al menos un dato almacenado.
4. Si el proceso productor intenta almacenar un dato en el buffer de entrada y detecta que éste está
lleno, deberá marcarlo como buffer de salida y al de salida como buffer de entrada. Lo cual es
válido sólo si al menos uno de los buffer contiene al menos un espacio de almacenamiento
disponible.
Las condiciones anteriores son válidas sólo si el orden de recepción no tiene importancia respecto del
orden de emisión. En caso de ser necesario recepcionar los datos en el mismo orden de transmisión, se
deberá esperar a que uno de los buffers este lleno y otro vacío y sólo entonces se realizará el
intercambio de buffers de entrada y salida.
Comunicación Entre Pro cesos
Son muchos los problemas de sincronización que se presentan; Sin embargo, en un sentido más amplio,
son ejemplos sencillos de un problema mayor: permitir la comunicación entre procesos que deseen
cooperar. Principalmente hay dos esquemas complementarios de comunicación: “sistemas de memoria
compartida” y “sistemas de transmisión de mensajes”. Los sistemas de memoria compartida están
orientados básicamente a las aplicaciones y requieren que los procesos comunicantes compartan
algunas variables. Se espera que los procesos intercambien información por medio de estas variables
compartidas. En un sistema de memoria compartida, la responsabilidad de proporcionar la comunicación
recae sobre los programadores de aplicaciones; el sistema operativo sólo tiene que ofrecer la memoria
compartida. El método del sistema de mensajes permite que los procesos intercambien mensajes.
Entonces, la responsabilidad de proporcionar la comunicación corresponde al propio sistema operativo.
Es obvio que estos dos esquemas no son mutuamente exclusivos y que podrían utilizarse
simultáneamente en un sistema operativo.
La función de un sistema de mensajes es permitir que los procesos se comuniquen entre sí sin tener que
recurrir a variables compartidas. Un medio para la comunicación entre procesos facilita básicamente dos
operaciones: enviar(mensaje) y recibir(mensaje).
Los mensajes que envía un proceso pueden ser de tamaño fijo o variable. Si sólo puede enviarse
mensajes de longitud fija, la implantación física es bastante sencilla, pero esta restricción dificulta la
tarea de programación. Por otra parte, los mensajes de tamaño variable requieren una implantación
física un tanto compleja, pero se simplifica la tarea de programación.
Técnicas De Comunicación
Puede decirse que la transmisión de mensajes es controlada por un intercambio de preguntas y

respuestas entre los procesos que se están comunicando. Llámese mensaje a dichas preguntas y
respuestas, debido a que es un concepto más intuitivo que comando o instrucción. De este modo, para
que un mensaje sea completo debe incluir:
1. Una identificación del proceso emisor.

2. Una identificación del proceso receptor.
3. Una descripción de los datos involucrados o mensaje.
Página 75 de 164
Sin embargo, en casos particulares, cualquiera de estas componentes puede estar ausente si la
información requerida puede ser obtenida de otras fuentes.
Existen tres métodos (o técnicas) básicas para implementar la comunicación entre procesos:
1. Sistema Maestro-Sirviente.
2. Sistema de diálogo.
3. Sistema de correo.
Sistema Maestro-Sirviente
El maestro asigna trabajo al sirviente, y será su responsabilidad si lo confunde enviándole más de un

comando a la vez. El sirviente está todo el tiempo disponible, excepto cuando se encuentra ejecutando
alguna tarea.
El sirviente ve cómo se debe modificar al maestro cuando termina su tarea, de modo que pueda aceptar
otro comando (el sirviente). Las principales características de este esquema son:
1. El maestro no requiere de autorización para la utilización de su sirviente.

2. Las actividades del sirvientes están absolutamente controladas por el maestro.
3. La conexión entre emisor y receptor es fija.
Sistema De Diálogo
Un sistema de diálogo es similar a la facilidad del servicio proporcionado por un teléfono.
Los usuarios compiten por el servicio y el número de clientes que pueden ser simultáneamente
atendidos depende de la estructura del servicio. Sin embargo, una vez que la comunicación entre el
usuario y la facilidad ha sido establecida, el usuario puede permanecer conectado todo el tiempo que
estime conveniente (monopolio del recurso).
Las principales características del esquema de comunicación a través del sistema de diálogo son:
1. El proceso debe solicitar autorización para obtener la facilidad del recurso.

2. La actividad de la facilidad es puesta en marcha por la solicitud del usuario, pero controlada por la
facilidad.
3. La conexión entre la facilidad y el usuario es establecida sólo temporalmente.
Sistema De Correo
En un sistema de correos los mensajes son enviados, sean o no sean procesados en forma inmediata
por los receptores. Los mensajes no son enviados directamente desde el origen al destino; en vez de
eso, emisores y receptores se comunican a través de áreas de enlace compartidas, por lo cual se utilizan
los términos de casillas (MailBox) en buffers de comunicación.
El emisor deposita un mensaje en la casilla y el receptor lo retira a su debido tiempo.
Los mailbox son dispositivos virtuales de E/S, que permiten el traspaso de información entre dos o más
procesos. En general, son temporales, debiendo tener privilegios especiales para ser permanentes.
Un sistema de correo permite, entre otras cosas, administrar la interacción en la cual el número de
mensajes varía en el tiempo.
El propósito de tener un mailboxs es evitar la diferencia entre la tasa de intercambio en la cual los
mensajes son enviados y la tasa en la cual estos pueden ser recepcionados. De este modo, los
mensajes que no pueden ser procesados inmediatamente permanecen en el mailbox.
Página 76 de 164
Un sistema de correo se caracteriza por:
1. El tamaño del mailbox permite que el emisor no requiera de autorización para enviar un mensaje.
2. Lo emisores no tienen control sobre los receptores.
3. El tiempo de enlace directo entre el emisor y el receptor es nulo.
4. El mailbox ofrece el servicio de aceptar mensajes enviados a una velocidad mayor a la velocidad
con que estos pueden ser procesados.
Existen dos funciones básicas utilizadas para acceder a un mensaje de un mailbox. Es obvio que las
restricciones del proceso mismo son las mismas que para cualquier grupo de procesos que utilizan un
buffer compartido.
La declaración de las funciones y sus primitivas se dan a continuación:
Depositar(Msg) { Quitar(Msg) {
Wait(Ok_IN_Buffer) Wait(Ok_OUT_Buffer)
X ← < Idx de casillero vacío > X ← < Idx de casillero lleno >
Mailbox[X] ← Msg Msg ← mailbox[X]
Marcar(X, lleno) Marcar(X, vacío)
Signal(Ok_OUT_Buffer) Signal(Ok_IN_Buffer)
} }
La utilización de estas funciones, a través de la utilización de las operaciones wait/signal, aseguran que
el receptor no pueda anticiparse al emisor y el emisor tampoco podrá anticiparse al receptor más allá del
número de casillas del mailbox.
Transmisión Entre Mensajes, Comunicación Directa
Los procesos que desean comunicarse deben tener una manera de referirse unos a otros. Para esto
pueden utilizar la comunicación directa o la comunicación indirecta.
En la disciplina de comunicación directa cada proceso que desea enviar o recibir un mensaje debe
nombrar explícitamente al receptor o emisor de la comunicación. En este esquema, las operaciones
primitivas enviar y recibir se definen de la manera siguiente:
enviar(P, mensaje). Enviar un mensaje al proceso P.

recibir(Q,mensaje). Recibir un mensaje del proceso Q.
Un enlace de comunicación en este esquema posee las siguientes propiedades:
1. Se establece un enlace automáticamente entre cada par de procesos que quieren comunicarse.
Los procesos sólo necesitan conocer la identidad del otro para comunicarse.
2. Un enlace está asociado exactamente a dos procesos.
3. Entre cada par de procesos en comunicación hay exactamente un enlace.
4. El enlace es bidireccional.
Transmisión Entre Mensajes, Comunicación Indirecta
Con la comunicación indirecta los mensajes se envían y reciben usando buzones. Un buzón puede
considerarse de manera abstracta como un objeto en el que los procesos pueden colocar mensajes y del
cual se pueden extraer los mensajes. Cada buzón tiene una identificación única. En este esquema, un
proceso puede comunicarse con otro a través de varios buzones distintos. Dos procesos únicamente
pueden comunicarse si comparten un buzón. Las primitivas enviar y recibir se definen como sigue:
enviar(A, mensaje). Enviar un mensaje al buzón A.

recibir(A, mensaje). Recibir un mensaje del buzón A.
En este esquema, un enlace de comunicación tiene las propiedades siguientes:

Página 77 de 164
1. Se establece un enlace entre un par de procesos sólo si comparten un buzón.
2. Un enlace puede asociarse a más de dos procesos.
3. Entre cada par de procesos en comunicación puede haber varios enlaces diferentes,
correspondiendo cada uno a un buzón.
4. Un enlace puede ser unidireccional o bidireccional.
Suponga ahora que los procesos P1, P2 y P3 comparten el buzón A. El proceso P1 envía un mensaje a
A, mientras P2 y P3 se ejecutan. Para determinar que proceso recibirá el mensaje enviado por P1 se
puede:
• Permitir que un enlace este asociado a dos procesos como máximo.

• Permitir que a lo sumo un proceso ejecute en cada ocasión una operación recibir.
• Permitir que el sistema seleccione arbitrariamente cuál proceso recibirá el mensaje (es decir, P2 ó
P3, pero no ambos). El sistema puede identificar el receptor para el emisor.
Un buzón puede pertenecer a un proceso o al sistema. Si el buzón pertenece a un proceso, entonces se

hace una distinción entre el dueño y el usuario del buzón. Como cada buzón tiene un solo dueño, no
hay confusión sobre quién debe recibir un mensaje enviado al buzón. Cuando termina un proceso dueño
de un buzón, éste desaparece. A cualquier proceso que envíe posteriormente un mensaje a este buzón
se le debe notificar que ya no existe.
Hay varias maneras de designar al dueño y a los usuarios de un buzón en concreto. Una posibilidad es
permitir que un proceso declare variables de tipo buzón. El proceso que declara un buzón es su dueño.
Cualquier otro proceso que conozca el nombre de este buzón podrá utilizarlo.
Por otra parte, un buzón que pertenece al sistema operativo tiene existencia propia, es independiente y
no está unido a un proceso en particular. El sistema operativo proporciona un mecanismo que permite a
cualquier proceso: crear un nuevo buzón, enviar y recibir mensajes mediante el buzón y destruir un
buzón.
EI proceso que crea un nuevo buzón es, por omisión, dueño del mismo. Inicialmente, el dueño es el
único proceso que puede recibir mensajes mediante el buzón. Sin embargo, el privilegio de recibir y la
propiedad del buzón pueden transferirse a otros procesos por medio de las llamadas adecuadas al
sistema.
Por supuesto, esta característica puede representar la existencia de varios receptores para cada buzón.
Los procesos también pueden compartir un buzón mediante la función de creación de procesos. Por
ejemplo, si el proceso P creó el buzón A y luego creó un proceso Q, P y Q pueden compartir el buzón A.
Como todos los procesos con derechos de acceso al buzón pueden terminar, puede ser que tras cierto
tiempo ningún proceso tenga acceso al buzón, en cuyo caso el sistema operativo debe reclamar el
espacio utilizado para el buzón. Para esta tarea se puede necesitar alguna forma de recolección de
basura.
Utilización De Buffers
Un enlace tiene cierta capacidad que determina el número de mensajes que puede contener
temporalmente. Esta propiedad puede considerarse como una cola de mensajes unidos al enlace. Hay
tres maneras básicas de implantar esta cola:
• Capacidad cero. La cola tiene una longitud máxima 0, de modo que el enlace no puede contener
ningún mensaje esperando. En este caso, el emisor debe esperar a que el receptor reciba el
mensaje. Los dos procesos se deben sincronizar para que pueda tener lugar la transferencia de un
mensaje. A esta sincronización se le llama encuentro.
• Capacidad limitada. La cola tiene una longitud finita n; así, como máximo pueden recibir n
mensajes en ella. Si la cola no esta llena al enviar un nuevo mensaje, se guarda en la cola y el
emisor puede continuar su ejecución sin esperar. No obstante, el enlace tiene una capacidad finita.
Si el enlace está lleno, el emisor debe demorarse hasta que haya espacio disponible en la cola.
Página 78 de 164
• Capacidad ilimitada. La cola tiene una longitud potencialmente infinita, por lo que en ella puede
esperar cualquier número de mensajes. El emisor nunca se demora.
El caso de capacidad cero en ocasiones se conoce como sistema de mensajes sin buffer; los otros
casos ofrecen buffers automáticos.
Se observa que, en los casos de capacidad no nula, un proceso no sabe si un mensaje ha llegado a su
destino después de concluir la operación enviar. Si esta información es decisiva para los cálculos, el
emisor deberá comunicarse explícitamente con el receptor para averiguar si éste recibió el mensaje. Por
ejemplo, suponga que el proceso P envía un mensaje al proceso Q y sólo puede continuar su ejecución
tras la recepción del mensaje.
El proceso P ejecuta la secuencia: enviar(Q,mensaje) y luego: recibir(Q,mensaje).
El proceso Q ejecuta: recibir(P,mensaje) y luego: enviar(P, "confirmación ").
Se dice que estos procesos se comunican en forma asíncrona. Existen casos especiales que no encajan
en ninguna de las categorías que se han visto.
El proceso que envía el mensaje nunca se demora. Sin embargo, si el receptor no ha recibido el mensaje
antes de que el proceso emisor envíe otro, el primer mensaje se pierde. La ventaja de este esquema es
que los mensajes de gran tamaño no tienen que copiarse más de una vez. La desventaja principal es
que la tarea de programación se complica. Los procesos se deben sincronizar explícitamente, para
asegurar que los mensajes no se pierdan y que el emisor y el receptor no manipulen simultáneamente el
buffer de mensajes.
El proceso que envía un mensaje se demora hasta que recibe una respuesta. Un proceso P que envía
un mensaje se bloquea hasta que el proceso receptor haya recibido el mensaje y devuelva una
respuesta de ocho palabras a través de la primitiva responder(P, mensaje). El mensaje de respuesta
sobrescribe el buffer usado en el mensaje original. La única diferencia entre las primitivas enviar y
responder consiste en que enviar hace que el proceso emisor se bloquee, mientras que responder
permite que ambos procesos, el receptor y el emisor, prosigan de inmediato su ejecución.
Este método de comunicación se puede ampliar fácilmente para lograr un completo sistema RPC
(Remote Procedure Call). El RPC se basa en que una llamada a un procedimiento o subrutina en un
sistema monoprocesador actúa exactamente como un sistema de mensajes donde el emisor se bloquea
hasta recibir una respuesta. El mensaje es entonces como una llamada a una subrutina y el mensaje de
respuesta contiene el valor calculado por la subrutina. Por tanto, el siguiente paso lógico es que los
procesos concurrentes puedan Ilamar a otros como subrutinas utilizando el RPC.
Monitores
Un monitor es un conjunto de procedimientos que proporciona el acceso con exclusión mutua a un

recurso o conjunto de recursos compartidos por un grupo de procesos. Los procedimientos van
encapsulados dentro de un módulo que tiene la propiedad especial de que sólo un proceso puede estar
activo cada vez para ejecutar un procedimiento del monitor.
Puede tener varios puntos de entrada o procedimientos para el uso del recurso, así como varias
condiciones para proporcionar sincronización entre los procesos que están esperando para usar el
recurso. Para los procesos que desean acceder al monitor se utiliza una única cola de espera.
La exclusión mutua está ahora implícita: la única acción que debe realizar el programador del proceso
que usa un recurso es invocar una entrada del monitor (con los semáforos el programador debía
proporcionar la correcta secuencia de operaciones de espera y señal para no bloquear al sistema).
Los monitores no proporcionan por sí mismos un mecanismo para la sincronización de tareas y, por ello,
su construcción debe completarse permitiendo, por ejemplo, que se puedan usar señales para
sincronizar los procesos. Así, para impedir que se pueda producir un bloqueo, un proceso que gane el
Página 79 de 164
acceso a un procedimiento del monitor que necesite esperar a una señal, se suspende y se coloca fuera
del monitor para permitir que entre otro proceso.
Una variable que se utilice como mecanismo de sincronización en un monitor se conoce como variable
condición. A cada causa diferente por la que un proceso deba esperar se le asocia una variable de
condición. Sobre ellas sólo se puede actuar con dos procedimientos: espera y señal. Cuando un proceso
ejecuta una operación de espera, se suspende y se coloca en una cola asociada a dicha variable de
condición. Si ejecuta una operación de señal, se libera un proceso suspendido en la cola de la variable
de condición utilizada.
El monitor debe usar un sistema de prioridades en la asignación del recurso que impida que un proceso
en espera de lograr entrar se vea postergado indefinidamente por otros procesos nuevos que deseen
utilizarlo.
En síntesis, una construcción de alto nivel para la sincronización es el tipo monitor, el cual se caracteriza
por un conjunto de operadores definidos por el programador. La representación de un tipo monitor
consiste en declaraciones de variables cuyos valores definen el estado de un ejemplar del tipo de
módulo, así como los cuerpos de procedimientos o funciones que implantan las operaciones sobre el tipo
de subrutina. La sintaxis de un monitor es:
nombre_monitor : monitor {
< declaraciones de variables >
Procedure nombre_Proc( < Parámetros > )
begin
...
end
< Inicialización de variables >
}
Los distintos procesos no pueden usar directamente la representación de un tipo monitor por lo que un
procedimiento definido dentro de un monitor sólo puede tener acceso a las variables declaradas
localmente y a los parámetros formales. De manera parecida, sólo los procedimientos locales pueden
tener acceso a las variables locales de un monitor.
La construcción monitor asegura que sólo un proceso a la vez puede estar activo en el monitor. Por
consiguiente, el programador no necesita codificar explícitamente esta situación de sincronización. Hasta
donde se ha definido, es similar en muchos aspectos a la región crítica. Pero como ya se vio, la región
crítica no es suficientemente potente para modelar algunos esquemas de sincronización, por lo que se
ha ampliado a región crítica condicional. En forma similar, se necesitan más mecanismos para la
sincronización con monitores, los que son proporcionados por la construcción condición. Un
programador que necesita escribir su propio esquema de sincronización a la medida, puede definir una o
más variables de tipo condición:
var x,y: condition;
Las únicas operaciones que pueden invocarse para una variable de condición son espera y señal. La
operación x.espera significa que se suspende el proceso que invoca la operación hasta que otro invoque
x.señal. La operación x.señal reanuda exactamente un proceso suspendido; si no hay ninguno,
entonces la operación señal no tiene efecto, es decir, el estado de x es el mismo que tendría si la
operación nunca se hubiese ejecutado.
Ahora suponga que cuando un proceso P invoca la operación x.señal, hay un proceso suspendido Q
asociado a la condición x. Obviamente, si se permite que el proceso suspendido Q reanude su
ejecución, el proceso señalizador P debe esperar. De lo contrario, tanto P como Q estarán activos
simultáneamente dentro del monitor. Observe, sin embargo, que en teoría ambos procesos pueden
continuar con su ejecución. Existen dos posibilidades:
1. P espera a que Q abandone el monitor, o que espere en otra condición.

2. Q espera a que P abandone el monitor, o que espere en otra condición.
Página 80 de 164
Hay argumentos razonables en favor de adoptar las alternativas (1) ó (2). Como P ya se estaba
ejecutando en el monitor, la opción (2) parece más razonable. Sin embargo, si se permite que el proceso
P continúe, es posible que la condición lógica que esperaba Q ya no se mantenga cuando se reanude Q.
Los monitores son una construcción de nivel más elevado que otras primitivas de sincronización de
recursos. Un ejemplo de la estructura de un programa monitor es para el caso del sistema
productor/consumidor:
Productor_Consumidor : monitor {
I : Integer
x : Condition
Procedure Productor
begin
...
end
Procedure Consumidor
begin
...
end
I←0
}
Propietarios
Otra forma de administrar los recursos de un sistema operativo es a través de una estructura llamada
propietario. Un propietario es un proceso que es dueño del recurso y todos los usuarios que deseen
ejecutar alguna operación sobre dicho recurso deberán solicitar al propietario la debida autorización.
Es una estructura de formato muy similar a un monitor, tal como se muestra a continuación:
nombre_propietario {
< Inicialización de variables >
Repeat
Identificacion ← Recibir(Msg)
Case ( Respuesta(Msg) ) {
<Comp_1> : { .... }
<Comp_2> : { .... }
...
<Comp_N> : { .... }
}
Replicar(Msg, Identificacion)
Until ( < El proceso termina >)
}
Cada una de las comparaciones de la estructura case es una sección crítica. El hecho que el proceso
sea sólo uno garantiza que nunca será ejecutado más de una comparación a la vez.
La estructura propuesta no es muy adecuada en el caso que un proceso no pueda ser atendido
inmediatamente. Una posible solución es mantener una lista explícita de procesos pendientes a los que
aun no se les ha enviado un replicar(). Otra solución sería la utilización de colas disjuntas para los
mensajes que recibe el propietario, a través de la utilización de concentradores de mensajes
independientes y sus identificadores son conocidos por el propietario.
Página 81 de 164
A modo de ejemplo considérese el caso del productor y consumidor; los algoritmos administrativos
serían (procesos):
Productor() { Consumidor() {
Repeat Repeat
X ← Algún dato Enviar(Y, Quitar)
Enviar(X, Agregar) Utilización ← Y
} }
Las rutinas de los concentradores serán:
Agregar() { Quitar() {
Repeat Repeat
Identificacion ← Recibir(X) Identificacion ← Recibir(Y)
Enviar(X, Buffer) Enviar(Y, Buffer)
Replicar(X, Identificacion) Replicar(Y, Identificacion)
} }
Finalmente la rutina del propietario (del recurso Buffer) sería:
Buffer() {
Primer_Llenado ← 0
Contador ← 0
Repeat
If (Contador = 0) {
Identificacion ← Recibir(X, Agregar)
}
ElseIf (Contador = Max_Buffer) {
Identificacion ← Recibir(X, Quitar)
}
Else {
Identificacion ← Recibir(X)
}
Case ( Respuesta[Identificacion] ) {
Agregar : { Contador ← Contador + 1
Buffer[ Primer_Llenado + Contador ] ← X }
Quitar : { X ← Buffer [ Primer_Llenado + Contador ]
Contador ← Contador - 1 }
}
Replicar(X, Identificacion)
Until ( término del proceso)
}
Página 82 de 164
Deadlocks (I nterbloqueos)
Deadlock, también conocido como estancamiento o interbloqueo, es un posible estado de un proceso.

Se dice que un proceso está en estado de deadlock si se encuentra esperando la ocurrencia de un
evento que se sabe nunca habrá de ocurrir.
Por ejemplo. Si existen dos procesos A y B y dos

recursos R1 y R2, y suponiendo que la ejecución de
uno de los procesos requiere de los dos recursos. Si
al proceso A se le alcanza a asignar el recurso R1 y
al proceso B el recurso R2, entonces B esperará
eternamente el recurso R1 y A hará lo mismo
respecto del recurso R2. Por lo tanto ambos procesos
están en estado de deadlock.
Si cada proceso requiere de varios recursos, el sistema operativo debe ser cuidadoso de no caer en
estancamientos. Esto ocurre si todos los procesos comienzan a solicitar recursos mientras todos los
recursos están en uso y ninguno de los procesos está dispuesto a retractar su demanda.
Para que se de una situación de interbloqueo se deben de cumplir de forma simultánea las cuatro
condiciones siguientes:
1. Exclusión mutua.
2. Retención y espera. Los procesos retienen los recursos que han adquirido mientras esperan para
adquirir otros.
3. No existencia de expropiación.
4. Espera circular. Cadena circular de procesos en la que cada uno retiene al menos un recurso que
se solicita por el siguiente.
Formas de tratar el problema:
a. Evitar que se llegue al interbloqueo. Métodos:
1. Prevención de los interbloqueos.
2. Evitación de los interbloqueos.
b. Permitir que se pueda entrar. Dos pasos:
1. Detección del interbloqueo.
2. Recuperación del interbloqueo.
Prevención De Interbloqueos
Basta con evitar una de las cuatro condiciones necesarias; pero la condición de exclusión mutua se debe
mantener.
Retención y espera
Para evitarla, basta con garantizar que un proceso que posee un recurso no pueda pedir otro, haciendo
que la petición de todos los recursos que necesita un proceso se realice bajo la premisa de todos o
ninguno.
Página 83 de 164
Problemas:
1. Pobre uso de los recursos, ya que puede haber recursos retenidos que no estén en uso y otros
que, aunque no estén retenidos, no se puedan asignar por ser requeridos junto con otros que sí lo
están.
2. Puede resultar difícil que un conjunto de recursos se encuentren disponibles a la vez, lo que puede
producir una espera indefinida del proceso que los necesita.
No existencia de la expropiación
Se puede permitir la expropiación mediante dos estrategias:
a. Si un proceso que tiene uno o más recursos solicita otro que esté en uso, debe esperar y permite
que los recursos de que dispone se puedan expropiar. El proceso libera, de forma implícita, los
recursos de que dispone y se añaden a la lista de recursos disponibles y, a la vez, a la lista de
recursos solicitados por éste. El proceso sólo se puede volver a activar cuando pueda ganar el
acceso a todos los recursos que necesita.
b. Si un proceso solicita algunos recursos que están asignados a otros procesos, se mira si estos
están esperando, en cuyo caso se expropian. Si hay algún recurso que no está libre o que no
puede ser expropiado, el proceso se suspende y no puede volver a ejecución hasta que no
disponga de todos los recursos.
Inconveniente: Puede llevar a que haya procesos que se vean relegados durante un tiempo
excesivamente grande.
Se suele aplicar con aquellos recursos que pueden ser fácilmente salvados y restaurados, tales como
posiciones de memoria o registros de la CPU.
Espera circular
Para evitarla, se ordenan los recursos asignándoles a cada tipo de ellos un número entero y se impone
que se pidan en orden ascendente. Además, las peticiones de todos los recursos perteneciente a un
mismo tipo deben realizarse con una única petición y no incrementalmente.
Desventaja: Los recursos no se piden en el orden que se necesitan, sino en el que se ha establecido.
Los procesos pueden verse obligados a pedir los recursos antes de necesitarlos , acaparándolos
innecesariamente.
Evitación De Los Interbloqueos
Impone condiciones menos restrictivas que el método de la prevención. En el momento de asignar un

recurso, si se prevé la posibilidad de que se produzca un bloqueo, el recurso no se concede.
El algoritmo del banquero de Dijkstra asegura que el número de recursos asignados a todos los
procesos nunca puede exceder del número de recursos del sistema. Además, nunca se pueden asignar
recursos de modo que no queden suficientes para satisfacer las necesidades de todos los procesos.
Cuando se crean los procesos, se declara que en Posibles Máximos

Proceso Usados
cualquier instante no podrán necesitar más de x necesarios necesarios
recursos. Se construye una tabla para llevar la P1 2 3 5
cuenta de los recursos disponibles y de los P2 1 5 6
P3 3 1 4
necesitados.
Total disponibles 4 (de 10)
Página 84 de 164
Un estado se considera seguro si todos los procesos que ya tienen concedidos recursos tienen la
posibilidad de ser completados en algún orden determinado, incluso con la posibilidad de que cada uno
de los procesos utilizase el máximo de los recursos declarados.
En el algoritmo del banquero:
a. Se permiten las condiciones de exclusión mutua, retención y espera y de no existencia de

expropiación.
b. Los procesos solicitan el uso exclusivo de los recursos que necesitan. Mientras esperan alguno, se
les permite mantener los recursos de que disponen sin que se les puedan expropiar.
c. Los procesos piden los recursos al sistema operativo de uno en uno.
d. El sistema puede conceder o rechazar cada petición.
e. Una petición que no conduce a un estado seguro se rechaza y cada petición que conduce a un
estado seguro se concede.
Inconvenientes:
1. La gestión de los recursos suele ser conservadora, ya que los estados inseguros constituyen un
conjunto grande de estados dentro del cual se encuentra el subconjunto de los estados que
realmente producen interbloqueos.
2. El algoritmo requiere que los procesos conozcan por adelantado sus necesidades máximas.
Detección De Los Interbloqueos
Se utiliza en aquellos sistemas en los que se permite que se produzca el interbloqueo, comprobando
periódicamente si se ha producido el interbloqueo. Inconvenientes:
1. Sobrecarga del sistema operativo para mantener la información necesaria y el algoritmo de

detección.
2. Posibles pérdidas en el intento de recuperar el sistema.
Se suele utilizar un grafo dirigido (grafos de asignación de recursos) que

indica las asignaciones de los recursos a los procesos y las peticiones que
estos realizan. Cada arco conecta el nodo de un proceso con el nodo de un
recurso.
Si sólo hay un elemento por cada tipo de recurso, la existencia de un ciclo es

una condición necesaria y suficiente para que haya un interbloqueo.
Si cada tipo de recurso tiene varios elementos, la condición de existencia de un ciclo es necesaria pero
no suficiente para asegurar que existe un interbloqueo. Una condición suficiente es la existencia de un
ciclo en el que no hay ningún camino que salga de alguno de los nodos que lo forman.
Método de reducción del grafo: Se determinan los procesos a los que se les pueden conceder los
recursos que tienen solicitados y se quitan los arcos. Si el grafo puede reducirse para todos los
procesos, no existe interbloqueo. En caso contrario, los procesos irreducibles constituyen el conjunto de
procesos interbloqueados.
Página 85 de 164
Recuperación De Interbloqueos
Dos opciones:
a. Reiniciar uno o más de los procesos bloqueados. Factores a tener en cuenta con el fin de elegir
aquellos procesos cuya reiniciación resulte menos traumática:
1. Prioridad del proceso.

2. Tiempo de procesamiento utilizado y restante.
3. Tipo y número de recursos que posee.
4. Número de recursos que necesita para finalizar.
5. Número de procesos que se verían involucrados con su reiniciación.
b. Expropiar los recursos de algunos de los procesos bloqueados de forma sucesiva hasta que se
consiga salir del interbloqueo. Además, hay que tener en cuenta el estado al que se pasan los
procesos expropiados. La solución sería volverlos a un estado anterior en el que el bloqueo se
rompa. Para que esto sea posible, se necesita que el sistema disponga de una utilidad que registre
los estados de los distintos procesos en tiempo de ejecución, con la consiguiente carga adicional
sobre el sistema operativo.
En algunos sistemas de tiempo real el interbloqueo puede tener resultados inaceptables, por lo que no
se puede permitir que se presente dicha situación. En otros sistemas se rechaza el interbloqueo, aunque
la situación pudiera ser aceptable, por el costo en tiempo y medios adicionales que conlleva la
recuperación.
Se puede obtener una mayor eficacia combinando los distintos métodos para aprovechar sus ventajas:
a. Agrupar los recursos del sistema en clases disjuntas.

b. Para evitar el interbloqueo entre las clases, se ordenan para evitar la espera circular.
c. Usar en cada clase el método más apropiado de evitar en ella el interbloqueo.
A continuación se presenta un ejemplo para cuatro clases de recursos:
Clase de recurso Métodos más adecuado Motivo
Prevención del interbloqueo por el método

usado para evitar la condición de retención Se conoce de antemano la capacidad
Espacio de y espera. máxima de almacenamiento necesitada
intercambio
por cada proceso.
Evitación del interbloqueo.
Recursos de los Evitación de interbloqueos. Los procesos declaran los recursos de

procesos (impresoras,
una determinada clase que van a
ficheros, discos,
Ordenación de recursos. necesitar.
cintas)
El proceso expropiado se pasa a

Memoria principal Prevención mediante expropiación
memoria secundaria.
No suele ser necesario realizar ninguna

Recursos internos
Prevención por ordenación de recursos elección en tiempo de ejecución entre
(canales E/S, etc.)
las peticiones pendientes.
Algoritmo del banquero
Sistematizando y generalizando para múltiples recursos, se obtiene el algoritmo del banquero (se
supone que los procesos son clientes que piden crédito y los recursos corresponden al dinero del que
dispone el banco). La idea es básicamente la misma, sólo que se deben manejar vectores en vez de
escalares. Por ejemplo, para 5 procesos y 3 recursos, Máximo, Actual y Diferencia, que antes eran
columnas, ahora son matrices de 5x3; y Disponible, que antes era un escalar, ahora es un vector de 3
elementos.
Página 86 de 164
Máximo Actual Diferencia Disponible
Proceso
A B C A B C A B C A B C
P0 7 5 3 0 1 0 7 4 3 3 3 2
P1 3 2 2 2 0 0 1 2 2
P2 9 0 2 3 0 2 6 0 0
P3 2 2 2 2 1 1 0 1 1
P4 4 3 3 0 0 2 4 3 1
Para chequear si un estado, como el anterior, es seguro:
1. Buscar un proceso (cualquiera) cuyos recursos máximos puedan satisfacerse con los disponibles
(más los que ya tiene); o sea, un proceso tal que Diferencia≤Disponible, componente a
componente. Si no existe, el estado es inseguro.
2. Si existe, suponer que el proceso termina y libera todos sus recursos, agregándolos a los
disponibles.
3. Repetir 1 y 2 hasta haber pasado por todos los procesos, en cuyo caso el estado es seguro, o
hasta determinar que el estado es inseguro.
En el ejemplo, se puede escoger primero P1 o P3 (da igual); supóngase P1. Al terminar, los recursos
disponibles quedan en <4,5,4>. Ahora se pude escoger P3 ó P4, y así, hasta determinar que el estado
es seguro.
Supóngase ahora que, en ese estado, P1 pide 1 instancia adicional de A y 2 de C. Los recursos están
disponibles, pero antes de concedérselos a P1, se debe chequear si el nuevo estado sería seguro o no.
Dicho estado sería:
Máximo Actual Diferencia Disponible

Proceso
A B C A B C A B C A B C
P0 7 5 3 0 1 0 7 4 3 2 3 0
P1 3 2 2 3 0 2 0 2 0
P2 9 0 2 3 0 2 6 0 0
P3 2 2 2 2 1 1 0 1 1
P4 4 3 3 0 0 2 4 3 1
y también es seguro, ya que la secuencia <P1,P3,P4,P0,P2> es segura. En consecuencia, se pueden

otorgar los recursos solicitados por P1.
Si en ese nuevo estado, P4 pide ahora 3 unidades de A y 3 de B, entonces P4 debe suspenderse

porque no hay suficientes recursos para satisfacer el pedido. Si P3 pide 2 unidades adicionales de B,
simplemente se aborta el proceso, pues no cumpliría con el máximo declarado. Y si P0 pide 2 unidades
de B, también debe suspenderse, pero en este caso porque si se le otorgan los recursos, el estado
pasaría a ser inseguro. Cada vez que algún proceso libera recursos, debería chequearse cuáles de las
solicitudes pendientes pueden atenderse.
Este algoritmo fue publicado en 1965 y ha sido objeto de innumerables estudios. En teoría funciona muy
bien, pero en la práctica, rara vez se usa, puesto que es muy difícil para los procesos saber a priori sus
necesidades máximas de cada recurso.
En resumen, los algoritmos de prevención son extremadamente restrictivos y los de evitación requieren
información que por lo general no está disponible. Por eso, los métodos de detección y recuperación no
son tan poco usuales ni descabellados. También se usan métodos adecuados a situaciones específicas,
pero no existe ningún método un método de resolución universal que sirva para todo.
Página 87 de 164
CAP ÍT UL O VII
ASPECTOS DE SEGURIDAD
Técni cas De Prote cción
Cuando se almacena información en un sistema de computación, una de las mayores preocupaciones es

protegerla de daños físicos (confiabilidad) y del acceso inadecuado (protección).
La confiabilidad generalmente se obtiene creando copias de los archivos. Muchos computadores tienen
programas de sistema que automáticamente o manualmente copian los archivos de disco a una cinta a
intervalos regulares para conservar una copia en caso de que el sistema de archivos se destruya
accidentalmente. Un sistema de archivos puede ser dañado por problemas de hardware, cortes o
sobrecargas de energía, choques de las cabezas, polvo, temperatura y vandalismo; además, los
archivos pueden eliminarse accidentalmente. Los errores en el software del sistema de archivos también
pueden ocasionar la pérdida del contenido de los archivos. Por otra parte, también se encuentran los
virus informáticos, caballos de troya y los gusanos.
La protección puede ofrecerse de variadas formas. Se puede proteger un pequeño sistema monousuario
quitando los discos flexibles y guardándolos bajo llave en un cajón del escritorio o en un archivero. Sin
embargo, en los sistemas multiusuario se requieren otros mecanismos más complejos y aplicables a la
realidad.
La necesidad de protección surge de la capacidad de acceder a los archivos, y en aquellos sistemas

donde no se permite el acceso a los archivos de otros usuarios, no es necesaria la protección. De esta
manera, un extremo sería ofrecer una protección completa prohibiendo el acceso, mientras que el otro
extremo sería ofrecer acceso ilimitado sin protección. Ambas estrategias son demasiado radicales para
aplicarlas de manera general; lo que se necesita es acceso controlado.
Los mecanismos de protección ofrecen acceso controlado limitando los tipos de accesos que pueden
efectuarse a los archivos. El acceso se permite o niega dependiendo de varios factores, uno de los
cuales es el tipo de acceso solicitado. Es posible controlar varias clases de operaciones como lectura,
escritura, ejecución, modificación y eliminación.
También pueden controlarse los accesos a directorios completos mediante especificaciones que son
inevitablemente aplicables a todos los archivos contenidos en el directorio en cuestión. Las operaciones
con directorios que se deben proteger son algo diferentes. Se quiere controlar la creación y eliminación
de archivos en el directorio y, además, controlar si un usuario puede determinar la existencia de un
archivo en un directorio. En algunos casos, puede que el conocimiento de la existencia y nombre de un
archivo sea significativo por sí mismo, por lo que la visualización del contenido de un directorio debe ser
una operación protegida. Se han propuesto muchos mecanismos de protección. Como siempre, cada
esquema tiene sus ventajas y desventajas y debe seleccionarse el apropiado para la aplicación que se
pretende. Un pequeño sistema de computación utilizado por unos cuantos integrantes de un equipo de
investigación no necesitará los mismos tipos de protección que el computador de una gran corporación
empleado para operaciones financieras, de investigación y de gestión de personal.
La protección puede estar asociada al archivo o a la ruta que se usa para especificarlo. En el esquema
más común se aplica la protección a la ruta; así, si el nombre de la ruta hace referencia a un archivo en
un directorio, el usuario debe contar con acceso al directorio y al archivo. En los sistemas donde los
archivos tienen varios nombres de ruta (como en los grafos acíclicos o generales) el usuario puede tener
diferentes derechos de acceso al archivo dependiendo del nombre de ruta que utilice.
Nominación
Los esquemas de protección de varios sistemas dependen de que el usuario no tenga acceso a un
archivo que no puede nombrar; si no es capas de nombrarlo, entonces no es posible que opere con él.
Este esquema supone que no hay ningún mecanismo para obtener los nombres de los archivos de otros
usuarios y que es difícil adivinarlos. En realidad, como los nombres de archivos se eligen para que sean
mnemónicos, a menudo es fácil adivinarlos.
Contraseñas
Otra estrategia consiste en asociar una contraseña con cada archivo. De la misma manera que el
acceso al computador se controla por medio de una contraseña, también así se puede controlar el
acceso a cada archivo. Si las contraseñas se eligen al azar y se cambian con frecuencia, esta estrategia
puede ser eficaz para restringir el acceso a los usuarios que conozcan la contraseña.
No obstante, existen varias desventajas con este esquema. Si se asocia una contraseña individual con
cada archivo, puede ser muy grande el número de contraseñas que hay que recordar, lo que no resulta
práctico. Si se emplea la misma contraseña para todos los archivos, una vez que esta se descubre todos
los archivos se hacen accesibles. Algunos sistemas permiten que el usuario asocie una contraseña con
un subdirectorio, en vez de con un archivo.
Dominios de Protección
Un dominio de protección es un conjunto de pares (objeto, operaciones); cada par identifica un objeto y
las operaciones permitidas sobre él.
En cada instante, cada proceso se ejecuta dentro de un dominio de protección. Los procesos pueden
cambiar de un dominio a otro en el tiempo; el cómo depende mucho del sistema. En UNIX, se asocia un
dominio a cada usuario/grupo; dado un usuario y el grupo al cual pertenece, se puede construir una lista
de todos los objetos que puede acceder y con qué operaciones. Cuando un usuario ejecuta un programa
almacenado en un archivo de propiedad de otro usuario B, el proceso puede ejecutar dentro del dominio
de protección de A o B, dependiendo del bit de dominio o SETUSERID bit del archivo. Este mecanismo
se usa con algunos utilitarios. Por ejemplo, el programa passwd debe tener privilegios que un usuario
común no tiene, para poder modificar el archivo donde se guardan las claves. Lo que se hace es que el
archivo /bin/passwd que contiene el programa es propiedad del superusuario, y tiene el SETUSERID
encendido. Este esquema es peligroso: un proceso puede pasar de un estado en que tiene poco poder a
otro en que tiene poder absoluto (no hay términos medios). Cualquier error en un programa como
passwd puede significar un gran hoyo en la seguridad del sistema. Cuando se hace una llamada al
sistema también se produce un cambio de dominio, puesto que la llamada se ejecuta en modo protegido.
Matriz De Acceso
Otra Ahora bien, ¿cómo se las arregla el sistema para llevar la cuenta de quién puede acceder a qué
objetos y con qué operaciones? Conceptualmente al menos, se puede ver este modelo de protección
como una gran matriz de acceso.
Los cambios de dominio que un proceso puede hacer también pueden integrarse a la matriz, tratando a
los dominios como otros objetos, con una operación: entrar.
Una política de protección involucra decidir cómo se va a llenar esta matriz. Normalmente el usuario que
crea un objeto es quién decide cómo se va a llenar la columna de la matriz correspondiente a ese objeto.
La matriz de acceso es suficientemente general como para apoyar diversas políticas. Por ejemplo:
• La capacidad para copiar o transferir un derecho de un objeto a otro dominio.
Página 89 de 164
• Capacidad de un dominio para modificar los derechos en otros dominios (todos, o para un recurso
específico).
El problema es cómo almacenar esta matriz. Como es una matriz poco densa (muchos de los elementos
son vacíos), no resulta práctico representarla como matriz propiamente. Podríamos usar una tabla con
triples (dominio, objeto, derechos). Si un proceso dentro de un dominio D intenta efectuar una operación
M sobre un objeto O, se busca (D, O, C), y se verifica si M pertenece a C. De todas maneras, la tabla es
grande, y el esquema no es muy eficiente. Además, si un objeto puede ser, por ejemplo, leído por todo el
mundo, debe tener entradas para cada dominio.
Listas De Acceso
Otra estrategia es hacer que el acceso dependa de la identidad del usuario. Los distintos usuarios
pueden requerir tipos de acceso diferentes para un archivo o un directorio, al cual puede asociarse una
lista de acceso que especifique los nombres de los usuarios y los tipos de acceso permitidos para cada
uno. Cuando un usuario solicita el acceso a un archivo, el sistema operativo comprueba la lista de
acceso correspondiente. Si el usuario aparece en la lista junto con el acceso solicitado, se permite el
acceso; de lo contrario, ocurre una violación de la protección y se niega el acceso.
Alternativamente, se puede guardar la matriz por columnas (descartando las entradas vacías). Es decir,
a cada objeto se le asocia una lista de pares (dominio, derechos). Es lo que se conoce como lista de
acceso. Si se piensa en archivos de Unix, se puede almacenar esta lista en el nodo-i de cada archivo, y
sería algo así como: ((Juan, *, RW), (Pedro, Profes, RW), (*, Profes, R)). Donde R: Read (Leer), W: Write
(Escribir), X: Excecute (Ejecución).
En la práctica, se usa un esquema más simple (y menos poderoso), pero que puede considerarse aún
una lista de accesos, reducida a 9 bits. 3 para el dueño (RWX), 3 para el grupo, y 3 para el resto del
mundo.
Windows NT usa listas de accesos con todo el nivel de detalle que uno quiera: para cualquier usuario o
grupo, se puede especificar cualquier subconjunto de derechos para un archivo
La otra posibilidad es almacenar la matriz por filas. En este caso, a cada proceso se le asocia una lista
de capacidades. Cada capacidad corresponde a un objeto más las operaciones permitidas.
Cuando se usan capacidades, lo usual es que, para efectuar una operación M sobre un objeto O, el
proceso ejecute la operación especificando un puntero a la capacidad correspondiente al objeto, en vez
de un puntero al objeto. La sola posesión de la capacidad por parte del proceso quiere decir que tiene
los derechos que en ella se indican. Por lo tanto, obviamente, se debe evitar que los procesos puedan
"falsificar" capacidades.
Una posibilidad es mantener las listas de capacidades dentro del sistema operativo, y que los procesos
sólo manejen punteros a las capacidades, no las capacidades propiamente. Otra posibilidad es cifrar las
capacidades con una clave conocida por el sistema, pero no por el usuario. Un problema de las
capacidades es que puede ser difícil revocar derechos ya entregados.
Usuarios y Grupos De Acceso
El sistema operativo también provee seguridad a nivel de usuarios. En este caso define para cada
usuario del sistema un conjunto de atributos (perfil) que especifican a que recursos puede acceder.
Por lo general la definición de un perfil para cada usuario resultaría demasiado extenso y complejo de
administrar. Es así, que el sistema operativo crea grupos de usuarios que permiten definir un conjunto de
atributos a un grupo amplio de individuos.
Página 90 de 164
El mayor problema con las listas de acceso puede ser su longitud. Si se quiere que todos puedan leer un
archivo, se debe elaborar una lista de todos los usuarios con acceso de lectura. Esta técnica tiene dos
consecuencias indeseables:
• La construcción de la lista (o matriz de acceso) puede ser una tarea tediosa e infructuosa,
especialmente si no se conoce por adelantado la lista de usuarios del sistema.
• La entrada del directorio, que antes era de tamaño fijo, ahora necesita ser de tamaño variable, lo
que complica la administración del espacio.
Estos problemas pueden resolverse usando una versión condensada de la lista de acceso. Para
condensar el tamaño de la lista de acceso muchos sistemas reconocen tres clasificaciones de los
usuarios en relación con cada archivo:
Dueño. El usuario que creó el archivo es su dueño.
Grupo. Un grupo o grupo de trabajo es un conjunto de usuarios que comparten el archivo y

necesitan acceso similar.
Universo. Todos los demás usuarios en el sistema forman el universo.
Obsérvese que, para que este esquema funcione correctamente, hay que controlar con cuidado la
pertenencia a los grupos. Hay varias maneras para ejercer este control. Por ejemplo, en los sistemas
UNIX los grupos sólo pueden ser creados o modificados por el administrador de la instalación (o por
cualquier superusuario). De esta manera, el control se obtiene por interacción humana.
Seguri dad De Los Sistemas O perativos
Los mecanismos de seguridad son instrumentos de protección contra amenazas a la seguridad. Sucede
con demasiada frecuencia que los proveedores de productos específicos de seguridad presentan sus
productos como la respuesta a todos los problemas de seguridad. El partidario de los dispositivos de
ciframiento dice que la seguridad es un problema de ciframiento, el auditor de seguridad de los datos
opina que la seguridad es una cuestión de auditoria y control, mientras que el especialista en
emanaciones comprometedoras siente que la respuesta reside en el blindaje electrónico que protege el
equipo contra fugas de información.
La elección de soluciones para problemas reales de seguridad es una decisión tanto económica como
técnica. Los criterios económicos surgen del equilibrio entre el costo de pérdidas potenciales y el costo
de instrumentos y procedimientos de protección; este proceso se denomina a veces estimación de
riesgos. Existen guías específicas para agencias que manejan aspectos de seguridad nacional e
información. No todos los niveles de protección son apropiados para todos los ambientes.
EI trabajo de seguridad OSI (Open System Interconnection) considera las amenazas como accidentales o
intencionales, y como activas o pasivas. Las amenazas pasivas se limitan a la obtención de información
confidencial, en tanto que las activas incluyen la alteración de datos, la denegación de servicio o la
reproducción de tráfico legítimo.
Existe la idea errónea de que los sistemas abiertos no son seguros; ello ha provocado retrasos en la
realización de OSI. En la arquitectura de seguridad OSI se identifican tanto los servicios de seguridad
como los mecanismos para ofrecerlos. Entre los servicios proporcionados se pueden mencionar el
control de acceso, la identificación de autenticidad de las entidades iguales, la confidencialidad en los contextos
de los datos, la transferencia de datos orientada a las conexiones y sin conexiones, la seguridad a nivel de
campos, la seguridad del flujo de tráfico y la integridad de los datos.
Concepto De Seguridad
Conforme los sistemas de computación se han vuelto más complejos y sus aplicaciones se han difundido
más, también ha crecido la necesidad de proteger su integridad. En un principio, la protección se
Página 91 de 164
concibió como una añadidura a los sistemas operativos de multiprogramación para que varios usuarios,
en los que no se podía confiar, pudieran compartir con seguridad un mismo espacio lógico, como un
directorio de archivos o un mismo espacio físico, como la memoria. Se ha evolucionado hasta los
modernos conceptos de protección para aumentar la seguridad de cualquier sistema complejo que utilice
recursos compartidos.
La protección se refiere a un mecanismo para controlar el acceso de programas, procesos o usuarios a

los recursos definidos por un sistema de computación. Este mecanismo debe ofrecer un medio para
especificar los controles que se impondrán, así como la manera de aplicarlos. Se debe establecer la
diferencia entre protección y seguridad, la cual representa una medida de la confianza en que se
conservará la integridad del sistema y sus datos. El control de la seguridad es un tema mucho más
amplio que la protección.
Hay varias razones para proporcionar la protección, la más obvia es la necesidad de evitar una violación
mal intencionada de una restricción de acceso. Sin embargo, tiene una importancia más general la
necesidad de asegurar que cada componente de un programa activo utilice los recursos sólo de manera
consistente con las políticas establecidas para su uso. Este es un requisito absoluto para un sistema
seguro.
La protección puede mejorar la seguridad detectando errores latentes en las interfaces entre los
subsistemas componentes. Si en las primeras etapas se detecta un error en las interfaces, muchas
veces se puede evitar la contaminación de un sistema n í tegro debido al mal funcionamiento de un
subsistema. Un recurso desprotegido no puede defenderse del uso, o abuso, no autorizado o de un
usuario incompetente. Un sistema orientado a la protección ofrece un medio para distinguir entre el uso
autorizado y el no autorizado.
El papel de la protección en un sistema de computación consiste en proporcionar un mecanismo para

aplicar las políticas que gobiernan la utilización de los recursos. Estas políticas pueden establecerse de
varias maneras: algunas están determinadas en el diseño del sistema, otras están formuladas por los
administradores de un sistema, y algunas más son definidas por los usuarios para proteger sus propios
archivos y programas. Un sistema de protección debe tener la flexibilidad suficiente para aplicar las
diversas políticas que se le puedan indicar.
Las políticas para la utilización de los recursos pueden variar, dependiendo de la aplicación, y pueden
cambiar con el tiempo. Por estas razones, la protección no puede considerarse como algo que sólo
concierne al diseñador de un sistema operativo; también debe estar a disposición del programador de
aplicaciones para que puedan asegurar los recursos creados y el servicio proporcionando a un
subsistema de aplicaciones contra el mal uso.
Métodos De Verificación
Los requisitos de seguridad de un sistema dado definen qué significa que ese sistema sea seguro. Tales
requisitos sirven como base para determinar si el sistema realizado es seguro: sin un conjunto preciso de
requisitos de seguridad no tiene mucho sentido preguntar si el sistema es seguro. De manera similar, si
los requisitos no están expresados en forma tajante, no dirán mucho acerca de la verdadera seguridad
del sistema.
Para establecer adecuadamente los requisitos de seguridad, es necesario evaluar cuál es el mejor
método de seguridad que se puede aplicar para satisfacer las necesidades del sistema computacional
involucrado. Existen muchas estrategias considerativas de seguridad, de las cuales sólo se hará
mención de algunas.
Estrategia De Total Seguridad
En vista de lo indispensable de una estrategia total respecto a la seguridad de los computadores. La

seguridad externa se ocupa de proteger el recurso de cómputo contra intrusos y desastres como
incendios e inundaciones. Una vez que un usuario obtiene acceso físico a un recurso de cómputo, el
sistema operativo debe lograr su identificación antes de concederle acceso a los programas y datos
Página 92 de 164
almacenados en el sistema. Esto podría llamarse seguridad de la interfaz con el usuario. La seguridad
interna se ocupa de los diversos controles integrados al equipo y al sistema operativo con el fin de
garantizar el funcionamiento confiable y sin corrupción del sistema de cómputo y la integridad de los
programas y los datos.
Seguridad Externa
La seguridad externa consiste en seguridad física y seguridad de operación. La seguridad física incluye la
protección contra desastres y la protección contra intrusos. Los mecanismos de detección son
importantes para la seguridad física. Los detectores de humo y los sensores de calor pueden
proporcionar un aviso temprano en caso de incendio; los detectores de movimiento pueden determinar si
ha entrado un intruso en una instalación de cómputo.
Poner en práctica la protección contra desastres puede resultar costoso y a menudo se trata con
demasiada ligereza, pero es obvio que la necesidad de este tipo de protección depende de las
consecuencias de una pérdida. La mayoría de las organizaciones sencillamente no pueden darse el lujo
de un plan minucioso para protección contra desastres, por lo que las principales labores en cuanto a
seguridad física se encaminan hacia el rechazo de intrusos. Para dicho propósito, las instalaciones
utilizan diversos tipos de sistemas de identificación física, como por ejemplo, las credenciales con firmas,
o fotografías, o bien, las dos cosas. Los sistemas de huellas dactilares o de patrón de voz también gozan
de popularidad.
Seguridad De Operación
La seguridad de operación se compone de las diversas políticas y procedimientos puestos en práctica

por los administradores de una instalación de cómputo. La autorización determina qué acceso se otorga
a qué entidades.
La clasificación fragmenta el problema en subproblemas; los datos del sistema y los usuarios se dividen
en clases a las cuales se conceden diversos derechos de acceso.
La elección y asignación del personal es vital. Es posible confiar en los empleados. Un enfoque común
en este aspecto es la división de responsabilidades; a las personas se les asignan diferentes conjuntos
de deberes, mismos que pueden realizar sin necesidad de conocer la totalidad del sistema, y así los
individuos no pueden percibir el panorama completo. Para poner en peligro al sistema podría ser
necesaria la cooperación entre muchos empleados y ello reduce considerablemente la probabilidad de
violaciones de la seguridad. Por ejemplo, en instalaciones de cómputo grandes sólo se permite el acceso
al sistema de cómputo a los operadores y sólo los programadores pueden escribir programas. Los
operadores no deberían saber programar ni los programadores deberían estar familiarizados con los
detalles de operación del sistema de cómputo. De manera similar, un grupo separado debería controlar
las entradas a los sistemas de producción y un grupo totalmente distinto debería revisar y verificar las
salidas.
Es preciso incluir verificaciones y balances en el sistema de cómputo como una forma de ayuda para la
detección de violaciones de la seguridad; el personal de operación no debe tener conocimiento de la
naturaleza de estos controles, lo cual reduce la posibilidad de esquivarlos, pero debe indicárseles que se
han incluido controles complejos en el sistema porque semejante conocimiento muchas veces basta
para refrenar a las personas que podrían intentar violar la seguridad.
Vigilancia
La vigilancia se ocupa de supervisar el sistema, realizar auditorías de él y de verificar la identidad de los

usuarios. Algunos de los sistemas de verificación de autenticidad usados hoy día son muy complejos; es
cierto que se pueden esquivar, pero hacerlo requiere cada vez de mayor conocimientos y esfuerzo. Un
problema interesante en estos sistemas es la posibilidad de rechazar usuarios legítimos; un sistema de
patrón de voz podría rechazar a un usuario legítimo que esta resfriado; un sistema de huellas digitales
podría rechazar a un usuario legítimo con una cortadura o quemadura.
Página 93 de 164
Supervisión De Amenazas
Una forma de reducir al mínimo los riesgos para la seguridad es hacer que el sistema operativo controle
las operaciones delicadas en vez de entregar el control directamente a un usuario. Si un usuario desea
obtener acceso a un archivo vital, algunos sistemas podrían permitir al usuario un acceso directo al
archivo. El usuario estaría fuera de control y el sistema operativo no podría supervisar los movimientos
realizados con el archivo en el momento en que tienen lugar. Una técnica más segura es la denominada
supervisión de amenazas.
Cuando hay supervisión de amenazas, los usuarios no pueden obtener acceso directo a los recursos;
este acceso directo sólo pueden tenerlo algunas rutinas de los sistemas operativos llamadas programas
de vigilancia. El usuario que desea obtener acceso a un recurso lo solicita al sistema operativo, el cual
puede conceder o denegar el acceso. Si lo concede, un programa de vigilancia se encarga del acceso
real al archivo y pasa los resultados al programa del usuario. Este concepto es similar al de los
monitores. La supervisión de amenazas es una actividad continua; los intentos de penetración se
detectan en el momento en que ocurren y se notifica de inmediato al administrador del sistema.
A veces es preciso conceder a un programa de vigilancia mayores derechos de acceso que los
otorgados a los usuarios para que pueda atender en forma efectiva ciertas solicitudes de los usuarios.
Esto se denomina amplificación. Aun así, los usuarios astutos podrían inferir información realizando
varias consultas diferentes y examinando el traslape en los resultados. Sin embargo, es posible diseñar
programas de vigilancia que detecten tales intentos y lo notifiquen a un administrador del sistema.
Protección Por Contraseña (Llave/Cerradura)
Hay tres clases de elementos para la verificación de autenticidad con los cuales puede establecerse la
identidad de un usuario de un sistema:
• Algo característico de la persona. Esto incluye huellas dactilares, patrones de voz, fotografías y
firmas.
• Algo que posee la persona. Esto incluye credenciales, tarjetas de identificación y claves.
• Algo que sabe la persona. Esto incluye contraseñas y combinaciones de candados.
El esquema más común para la verificación de autenticidad es la simple protección por contraseña
utilizando una matriz de accesos sobre dominios de protección. El usuario escoge una palabra clave, la
memoriza y después la teclea para obtener acceso a un sistema de cómputo. La mayor parte de los
sistemas suprimen la impresión o despliegue de la contraseña mientras se teclea.
La protección por contraseña tiene muchos puntos débiles. Los usuarios eligen por lo regular
contraseñas fáciles de recordar, como por ejemplo el nombre de un amigo o pariente. Alguien que
conoce al usuario podría tratar varias veces de entrar en el sistema usando los nombres de gente
conocida por esta persona; tal cosa podría dar por resultado una violación de seguridad mediante
intentos repetidos. Algunos de los primeros sistemas empleaban contraseñas cortas; dichos sistemas
eran fáciles de penetrar por la simple prueba de todas las contraseñas posibles. La mayor parte de los
sistemas actuales usan contraseñas más largas para frustrar tales intentos de penetración. No obstante,
el empleo de contraseñas largas tiene también sus problemas: si las claves son difíciles de recordar, los
usuarios tenderán a anotarlas en algún lado lo cual facilita la obtención de la contraseña por parte de un
tercero.
La penetración de las defensas de un sistema operativo no resulta por fuerza un peligro significativo para
la seguridad. Por ejemplo, supóngase que alguien logra obtener acceso a la lista maestra de
contraseñas de un sistema. En general, esto significaría que el intruso podría obtener acceso a cualquier
información en el sistema. Para lograr que las contraseñas resulten inútiles para un intruso, se puede
usar el ciframiento. Así, la posesión de las contraseñas servirá de poco a menos que la persona cuente
también con la clave de desciframiento. Se recomienda a los usuarios cambiar sus contraseñas con
frecuencia; de este modo, aunque un intruso obtenga una contraseña, ésta podría haber cambiado antes
de que él logre hacer un verdadero daño.
Página 94 de 164
Una defensa sencilla contra los intentos repetidos es limitar el número de intentos de entrada que
pueden iniciarse en cualquier periodo desde una misma terminal o estación de trabajo (o desde una
misma cuenta). Sin duda, cualquier persona comete errores de tecleo cuando intenta entrar en el
sistema. Pero no es razonable que una persona que conoce la contraseña correcta requiera decenas,
cientos o miles de intentos. Por tanto, un sistema podría permitir tres o cuatro intentos, y después
desconectar automáticamente la terminal durante varios minutos. Después de un periodo de espera, el
terminal se puede volver a conectar. Si ocurre otra serie de intentos inútiles por entrar en el sistema, el
sistema operativo podría desplegar un aviso en la terminal indicando que su intento de violación al
sistema ha sido detectado.
Auditoría
La auditoría se realiza por lo general en sistemas manuales a posteriori. Se convocan auditores

periódicamente para examinar las transacciones recientes de una organización y determinar si se han
realizado actividades fraudulentas. La auditoría en sistemas de cómputo puede implicar un
procesamiento inmediato en el computador para revisar las transacciones que se acaban de realizar.
Una bitácora de auditoria es un registro permanente de eventos importantes que ocurren en el sistema
de cómputo. Se produce automáticamente cada vez que sucede un evento así y se almacena en un área
protegida del sistema; si el sistema se ve comprometido, la bitácora de auditoría deberá permanecer
intacta. La bitácora de auditoría es un mecanismo de detección importante. Aunque logren penetrar las
defensas de un sistema, las personas pueden refrenar sus deseos de hacerlo si temen una detección
posterior. La mayoría de los sistemas operativos poseen este tipo de bitácoras y en ellas se almacena
información como:
• La identificación general del usuario.
• Su clave formal de acceso al sistema y el número de veces que tuvo que repetir la clave antes de poder
ingresar al sistema.
• Toda la información asociada al usuario (nombre, cédula de identidad, etc.) y al evento (eliminación o lectura
de archivos importantes, ingreso a directorios no autorizados, etc.).
• Información acerca de la fecha, hora y número de serie del terminal.
La simple producción de una bitácora de auditoría no garantiza una seguridad adecuada. Es necesario
revisar la bitácora con frecuencia y detenimiento. Estas revisiones pueden realizarse tanto en forma
periódica como al azar. Las auditorías periódicas atienden en forma regular los problemas de seguridad;
las auditorías al azar ayudan a atrapar desprevenidos a los intrusos.
Criptografía
Al ir ganando popularidad las redes de computadores, cada vez se transmite más información
confidencial por canales donde es posible interceptar o escuchar los mensajes sin autorización. Por
ejemplo, las transferencias de cuentas bancarias, fichas médicas e historiales criminales son algo
rutinario en muchos lugares, generalmente en redes aisladas de propósito especial. Para que esta
información confidencial este segura, se necesita de mecanismos que permitan que un usuario proteja
los datos transferidos por la red.
El cifrado es un método común para proteger la información que se transmite por enlaces poco
confiables. El mecanismo básico funciona en la forma siguiente:
• La información se codifica de su formato legible inicial, o texto limpio, a un formato interno, o texto cifrado.
Este formato interno del texto, aunque puede ser legible, no tiene ningún sentido.
• El texto cifrado puede almacenarse en un archivo legible o transmitirse por canales no protegidos.
Página 95 de 164
• Para que el texto cifrado tenga sentido, el receptor debe decodificarlo adecuadamente a fin de
recuperar el texto limpio.
Incluso si la información cifrada cae en manos de una persona no autorizada, no le servirá de nada a
menos que la pueda decodificar. El asunto más importante es el desarrollo de esquemas de cifrado que
sean imposibles, o por lo menos muy difíciles, de romper.
Hay una gran variedad de métodos para lograr esta tarea. Los más comunes proporcionan un algoritmo
de cifrado general E (encryption) un algoritmo de descifrado general D (decryption) y una o varias claves
secretas que se proporcionan para cada aplicación. Sean Ek y Dk la representación de los algoritmos de
cifrado y descifrado, respectivamente, para una aplicación con la clave k. El algoritmo de cifrado debe
satisfacer las siguientes propiedades para cualquier mensaje m:
• Dk (E k (m)) = m.
• Tanto Ek como Dk pueden calcularse eficientemente.
• La seguridad del sistema depende únicamente de lo secreto de la clave y no de lo secreto de los
algoritmos E y D.
Uno de estos esquemas es llamado norma de cifrado de datos. Este esquema presenta el problema de
distribución de Ilaves: antes que se pueda establecer la comunicación, las llaves secretas se deben
enviar de manera segura tanto al emisor como al receptor, tarea que no puede lograrse eficazmente en
un entorno de comunicaciones por red. Una solución para este problema consiste en utilizar una
estrategia de cifrado de llave pública: cada usuario tienen una clave pública y una privada, y dos
usuarios sólo se pueden comunicar si conocen la clave pública del otro.
De este concepto surge un algoritmo que se considera casi inviolable. La clave pública de cifrado es un
par (e,n); la clave privada es un par (d,n), donde e, d y n son enteros positivos. Cada mensaje esta
representado por un entero entre 0 y n-1. Un mensaje de gran tamaño se divide en una serie de
mensajes más pequeños, cada uno de los cuales puede representarse con un entero. Las funciones E y
D se definen como
E(m) = (m e) mod n = C
D(C) = (Cd ) mod n.
El problema principal es la elección de las claves de cifrado y descifrado. El entero n se calcula como el
producto de dos número primos aleatorios (p y q) de gran tamaño (100 o más dígitos) donde n = p * q.
Se escoge d de tal manera que su valor sea un número entero aleatorio de gran tamaño relativamente
primo a (p-1)*(q-1).
Es decir, d cumple con el máximo común divisor [d, (p-1)*(q-1)] =1.
Por último, se calcula el entero e a partir de p, q y d para que sea el inverso multiplicador de d módulo
(p-1)*(q-1). Es decir, e satisface la ecuación: (e*d) mod ((p-1)x(q-1)) = 1.
Se debe señalar que, aunque n es de conocimiento público, no lo son p y q. Esta condición se permite
porque es muy difícil factorizar n y, por tanto, no es fácil adivinar los enteros d y e.
A modo de ejemplo: Sean p=5 y q=7. Entonces, n=35 y (p-1)*(q -1)=4. Como 11 es relativamente primo
de 24, se puede escoger d =11; Luego, como (11*11) mod 24 =121 mod 24 =1, se concluye que e =11.
Supóngase que m =3. Entonces,
C = me mod n = 311 mod 35 =12, y

Cd mod n = 1211 mod 35 = 3 = m.
De esta manera, si se codifica m usando e, se puede decodificar m con d.

Página 96 de 164
CAPÍT ULO VIII
ELEMENT OS DE CONFIGURACIÓN
Estructuras De Sis temas Opera tivos (Diseños)
Sistemas Monolíticos (DOS, MAC)
Esta estructura de 3 niveles es muy utilizada en los sistemas operativos y consiste en una estructura
muy rudimentaria. Básicamente todas las funcionalidades del sistema operativo son proporcionadas a
través de un conjunto de procedimientos, los que pueden ser llamados por otros cada vez que se
requiera.
• Nivel superior: Programas de aplicación que

llaman los procedimientos de servicio.
• Nivel intermedio: Conjunto de procedimientos

de servicio que realizan los llamados a sistema.
• Nivel inferior: Conjunto de procedimientos

utilitarios que ayudan a los procedimientos de
servicio.
Sistemas Con Capas (Unix / OS2)
El enfoque por capas consiste en dividir el sistema operativo en varias capas, cada una de las capas se
construye sobre una capa inferior. La capa 0 (la más baja) es el hardware y la capa N (la más alta) es la
interfaz con el usuario.
La característica más importante de este tipo de estructura es la modularidad. Las capas se seleccionan
de manera que cada una utilice funciones y servicios sólo de las capas inferiores.
Desventaja: Dificultad de definir los niveles.
Máquinas Virtuales (VM/370 CMS (Conversational Monitor System))
Este tipo de sistema consiste en que se ejecuta el núcleo del sistema, que se le llama monitor de la
máquina virtual, sobre el hardware y realiza la multiprogramación, proporcionando al nivel superior varias
máquinas virtuales. Estas máquinas virtuales son simulaciones del hardware, con su modo
núcleo/usuario, E/S, interrupciones y todos los demás aspectos físicos del hardware.
Sistemas De Microkernel
La tendencia en el desarrollo de los sistemas operativos apunta a mover la mayor cantidad posible del
código del sistema operativo a las capas superiores, de manera de minimizar el tamaño del núcleo del
sistema.
Microkernel (cliente/servidor): Los procesos clientes solicitan los servicios a los procesos servidores.
Firmware : Tecnología de instrucciones incluidas en el procesador.
Página 97 de 164
Organizaciones Más Com unes De Multiprocesadores
A continuación se presenta una clasificación para los sistemas con varios procesadores basado en cómo
la máquina relaciona sus instrucciones con los datos que tiene que procesar.
1) SISD (Single Instruction Single Data). Un solo flujo de instrucción, un solo flujo de datos.
Computadores con un único procesador.
2) SIMD (Single Instruction Multiple Data). Un solo flujo de instrucciones, varios flujos de datos.
Procesadores vectoriales y computadores en arreglo en los que una sola instrucción se ejecuta
sobre varios datos.
3) MISD (Multiple Instruction Multiple Data). Flujo de varias instrucciones, un solo flujo de datos.
Ningún computador se ajusta a este tipo.
4) MIMD (Multiple Instruction Multiple Data). Flujo de varias instrucciones, flujo de varios datos. Grupo
de computadores independientes, cada uno con su propio contador de programa, programa y
datos. Según la conexión entre los procesadores, se pueden considerar:
a) Sistemas fuertemente acoplados. Los procesadores comparten la memoria y el reloj. Son

sistemas multiprocesadores y la comunicación generalmente se hace a través de la memoria
compartida.
b) Sistemas débilmente acoplados. Los procesadores no comparten la memoria ni el reloj y

cada uno tiene su propia memoria local. Se comunican mediante redes locales o de área
extensa. Son los sistemas distribuidos. Un sistema distribuido proporciona a los usuarios
acceso a los distintos recursos hardware y software controlado por el sistema operativo Los
esquemas básicos del son:
b.1. Sistemas operativos de red. Los usuarios están enterados de la multiplicidad de

máquinas y para acceder a sus recursos necesitan conectarse al computador
remoto apropiado. Son sistemas débilmente acoplados tanto en hardware como
en software.
b.2. Sistemas operativos distribuidos. Los usuarios no necesitan saber que existe
una multiplicidad de máquinas y pueden acceder a los recursos remotos de la
misma forma que lo hacen a los recursos locales. Son sistemas de hardware
débilmente acoplado, pero de software fuertemente acoplados.
Tiempo Compartido O Bus Común (Conductor Común)
Usa un solo camino de comunicación entre todas las unidades funcionales (procesadores,
almacenamiento y los procesadores de I/O). En ese sencillo esquema, el bus común es en esencia una
unidad pasiva, es decir, las operaciones de transferencia entre las unidades funcionales son controladas
por las interfaces del conductor de las propias unidades.
La principal ventaja es que es una de las formas

más sencillas (usar un bus compartido para
conectar los procesadores y la memoria); el
problema es que el bus o la memoria compartida se
pueden saturar. Para esto se puede recurrir a las
siguientes soluciones:
1) Disponer de una memoria caché:
a) Asociada con la memoria compartida: los procesadores acceden a ella por el bus,
Página 98 de 164
b) Asignar a cada procesador una caché. Presenta problemas de coherencia. Para mantener
esta coherencia, se utilizan protocolos especializados y hardware adicional, como los
“espías” de caché o monitores de caché, que observan el bus y cuando se hace una petición
de escritura en una dirección presente en la caché, se actualiza ésta con el nuevo valor.
Esto hace que aumente el tráfico en el bus.
2) Considerar un bus de más anchura.
3) Soportar protocolos diferentes de petición/respuesta. Las peticiones y las respuestas de memoria

se tratan de forma separada en el bus. Después de que un procesador realiza una petición, el bus
queda liberado para que le puedan utilizar otros usuarios durante el tiempo que tarda la memoria
en acceder y ensamblar la información solicitada.
La escalabilidad de este esquema está limitada por el bus y la memoria compartida. En

implementaciones comerciales se soportan del orden de 64 procesadores. Es un esquema sencillo, por
lo que muchos diseños comerciales están basados en él.
Matriz De Barras Cruzadas E Interruptores
Existe un camino diferente para cada unidad de

almacenamiento. Con este esquema, las referencias a
dos unidades diferentes de almacenamiento pueden
producirse de forma simultánea, una no puede bloquear
a la otra. De hecho, un sistema de matriz de barras
cruzadas e interruptores puede mantener transmisiones
simultáneas para todas las unidades de
almacenamiento. Se disponen de n memorias y n
procesadores conectados mediante conmutadores.
La conmutación en los cruces (punto de unión entre las líneas) es la única fuente de retardo.
La contención en el acceso a la memoria sólo ocurre cuando un procesador intenta acceder a la misma
memoria y al mismo tiempo que otro. Pero con una apropiada situación de los datos se puede evitar, o
por lo menos aliviar. El problema persiste en el caso de variables compartidas (como un semáforo).
Permite un elevado grado de paralelismo entre tareas no relacionadas, pero se presentan problemas de
contención cuando hay procesos con memoria compartida.
2
Para n procesadores y n memorias, se necesitan n conmutadores, lo que hace que el coste sea
elevado.
Almacenamiento De Interconexión Múltiple
En este esquema, cada unidad funcional puede

acceder a cada unidad de almacenamiento, pero sólo
en una conexión de almacenamiento específica. Se
suministra una conexión de almacenamiento por
unidad funcional.
A las conexiones de almacenamiento suelen

asignárselas prioridades permanentes para resolver
los conflictos entre las unidades funcionales que
intentan acceder al almacenamiento al mismo tiempo.
Página 99 de 164
Una posibilidad interesante del esquema de
interconexión múltiple es la capacidad de restringir el
acceso de varias unidades de almacenamiento a
ciertos subconjuntos de procesadores y procesadores
de entrada/salida, creando así ciertas unidades de
almacenamiento privadas.
Una red omega está basada en conmutadores 2x2,

cada uno con dos entradas y dos salidas. Cada
conmutador puede dirigir cualquiera de las entradas a
cualquiera de las salidas y todos los procesadores
pueden acceder a todas las memorias.
Puede conectar simultáneamente todas las entradas a todas las salidas, suponiendo que no haya dos
procesadores que intenten acceder al mismo tiempo al mismo módulo de memoria. En caso contrario, se
puede presentar contención de acceso a la memoria.
Los principales problemas que puede presentar son:
a) Cuando algunos módulos de memoria se referencian con mucha frecuencia, se produce un punto
caliente, que bloquea ciertas rutas de comunicación durante largos períodos de tiempo.
b) Retraso en la conexión. Si hay n memorias y n procesadores, habrá log2n etapas, cada una con
n/2 conmutadores.
Conexiones Hipercubo
Un hipercubo es un cubo n-dimensional que cumple las siguientes condiciones:
a) Está formado por 2*n procesadores.

b) Cada procesador tiene n conexiones directas con otros procesadores.
c) La máxima distancia entre dos nodos cualesquiera (número de enlaces físicos entre nodos) es n.
d) Es una estructura recursiva formada por dos hipercubos de dimensión n-1.
En las figuras se ilustra un hipercubo de dimensión 4 en el que

cada vértice es un procesador con su correspondiente memoria.
Las principales ventajas de este esquema son:
a) La complejidad de los hipercubos crece logarítmicamente con el número de nodos, por lo que son
una buena base para realizar sistemas escalables. Se considera la solución idónea para sistemas
grandes (dimensión 10 a 1.024 procesadores).
b) La comunicación entre nodos adyacentes es directa y el mayor retardo entre dos nodos está
acotado por la dimensión del hipercubo.
Organ i zación De Los Sistemas O perativos De M ult i procesa dores
Sistemas Ligeramente Acoplados v/s Sistemas Rígidamente Acoplados
El multiprocesamiento ligeramente acoplado incluye la conexión de dos o más sistemas de computación

independientes por medio de un enlace de comunicación. Cada sistema tiene su propio sistema
operativo y almacenamiento. Los sistemas pueden funcionar de forma independiente, comunicándose
cuando sea necesario. Los sistemas separados pueden acceder a los archivos de los otros a través del
enlace de comunicación y, en algunos casos, pueden intercambiar tareas a procesadores menos
cargados para lograr un cierto grado de equilibrio de la carga (sistemas RPC; Remote Procedure Call).
Página 100 de 164
El multiprocesamiento rígidamente acoplado utiliza un solo almacenamiento para varios procesadores y
un solo sistema operativo que controla mientras compara todos los procesadores y el hardware del
sistema.
Una de las mayores diferencias entre

los sistemas operativos de
multiprocesadores y uniprocesadores
está en su organización y estructura
en relación con los procesadores
múltiples. Las tres organizaciones
básicas de los sistemas operativos
para multiprocesadores son:
• Maestro/satélite
• Ejecutivo separado para cada procesador
• Tratamiento simétrico (o anónimo) para todos los procesadores.
Maestro/Satélite
La maestro/satélite es la organización más fácil de implementar y suele construirse por extensión directa
de un sistema de multiprogramación existente. En la organización maestro/satélite, sólo un procesador
particular, el maestro, puede ejecutar el sistema operativo. Un procesador satélite tan sólo puede
ejecutar programas del usuario.
Ejecutivos Separados
En la organización de ejecutivos separados, cada procesador tiene su propio sistema operativo y

responde a interrupciones de los usuarios que operan en ese procesador. Algunas tablas contienen
información global de todo el sistema: Por ejemplo, la lista de procesadores conocidos por el sistema y el
acceso a estas tablas debe controlarse con cuidado, usando técnicas de exclusión mutua.
Simétrico
El multiprocesamiento simétrico es la organización más complicada de implementar y la más poderosa.

Todos los procesadores son idénticos. El sistema operativo administra un grupo de procesadores
idénticos, cualquiera de los cuales puede ser utilizado para controlar cualquier dispositivo de
entrada/salida, o hacer referencia a cualquier unidad de almacenamiento.
Consideraciones finales
Al momento de implementar estructuras de hardware de acuerdo a las necesidades del cliente, se habrá
de tener presente una serie de características generales de Hardware como los tipos de discos a
implementar (capacidad, velocidad y confiabilidad) los tipos de monitores (resolución, tamaño) los
dispositivos de comunicación a incorporara (tarjetas de red, modem) los periféricos asociados
(impresoras, escáner, etc.) y, por supuesto, los medios de respaldo a implementar.
Página 101 de 164

CAP ÍT UL O IX
ALGUNOS SISTEM AS OPERAT IVOS
Sistema O perat ivo Unix
El sistema operativo UNIX se compone de las siguientes capas:
1) Núcleo: Primera capa inmediata al hardware. Es el auténtico SO.
2) Librerías: Contiene un procedimiento para cada llamada al sistema. (En el

estándar Posix se especifica el interfaz de la librería y no el de la llamada al
sistema).
3) Utilidades: shell, compiladores, editores y otras para manejo de archivos.
4) Usuario: Desde el terminal el usuario llama directamente a estos programas de utilidades.
Además, sus interfaces son:
a) de llamadas al sistema
b) de librería
c) del usuario, formada por los programas de utilidades estándar.
Diagrama del núcleo:
Interfaz de llamadas al sistema
Control de procesos
Sistema de archivos
Sincronización
Gestión de Caché buffer
Planificador y Carácter
Memoria Bloque
Comunicación
Controladores de periféricos
Control de hardware
HARDWARE
El núcleo es el auténtico sistema operativo interactuando directamente con el hardware hay unas rutinas
primitivas, que corresponden al bloque de control del hardware y en la parte superior está el interfaz de
llamadas al sistema, que permite al software de alto nivel tener acceso a funciones específicas del
núcleo. El resto del núcleo se puede dividir en dos partes principales, que están asociadas al control de
procesos y a la gestión de archivos y de la E/S.
La parte de control de procesos se responsabiliza de la planificación y distribución de los procesos, de la

gestión de memoria y de la sincronización y comunicación entre ellos.
La parte de gestión de archivos intercambia datos entre la memoria y los dispositivos externos, tanto de
caracteres como de bloques, para lo que se disponen de distintos controladores de periféricos. En la
transferencia orientada a bloques, se utiliza un método de caché de disco, que interpone un buffer del
sistema en la memoria principal entre el espacio de direcciones del usuario y el dispositivo externo.
Control Y Sincronización De Procesos
En Unix todos los procesos se crean mediante órdenes del programa de usuario, excepto:
a) El proceso 0, que se crea cuando se arranca el sistema y que corresponde al proceso

intercambiador.
Página 102 de 164

b) El proceso 1, que es creado por el proceso 0. Es el proceso init, antecesor de todos los demás
procesos. Cuando se conecta un usuario al sistema, el proceso 1 crea un proceso de usuario para
él. El programa de usuario puede a su vez crear procesos hijos.
Un proceso puede estar en uno de estos nueve estados:
1) Ejecución en modo usuario.

2) Ejecución en modo núcleo.
3) Preparado para ejecución en memoria principal.
4) Espera en memoria principal, esperando a que ocurra un suceso.
5) Preparado para ejecución en memoria secundaria.
6) Espera en memoria secundaria.
7) Adelantado: se está ejecutando desde el modo núcleo al modo usuario, pero el núcleo lo
adelanta y hace un cambio de contexto para planificar otro proceso (similar al estado 3).
8) Creado o nonato: existe pero aún no está preparado (estado inicial de todo proceso; excepto
el 0).
9) Zombi: el proceso ejecuta una llamada exit al sistema. No existe, pero libera un registro para
unir a su proceso padre conteniendo código de salida y algunas estadísticas. Es el estado
final de un proceso.
La imagen de un proceso se organiza como la unión de tres partes:
1) Contexto a nivel de usuario: Se divide en área de texto (sólo lectura) que contiene las
instrucciones del programa y área de datos. Además dispone de una pila de usuario y de la
memoria compartida que ocupa el espacio de direcciones virtuales del proceso. Hay una sola
copia del área de memoria compartida, pero mediante el uso de la memoria virtual, cada proceso
percibe que dicha región está en su espacio de direcciones.
2) Contexto de registro: Almacena la información del estado de un proceso cuando no se está

ejecutando. Consta de:
a) Contador de programa: Especifica la dirección de la siguiente instrucción que ejecutará el

procesador. Puede ser una dirección virtual en el espacio de memoria del núcleo o del
usuario.
b) Registro de estado del proceso: Contiene el estado hardware de la máquina relacionado

con el proceso.
c) Puntero de pila: Especifica la dirección de la siguiente entrada en la pila del núcleo o del
usuario, dependiendo del modo de operación.
d) Registros de propósito general: Contienen datos generados por el proceso durante su

ejecución.
3) Contexto a nivel de sistema: Contiene el resto de información que el sistema operativo necesita
para gestionarlo. Consiste en una parte estática, cuyo tamaño es fijo y permanece con el proceso
a lo largo de la vida de éste., y una parte dinámica, que varía en tamaño a lo largo de la vida del
proceso. Componentes:
a) Entrada a la tabla del proceso: Define el estado del mismo y contiene información de
control que siempre está accesible al sistema operativo. Es una parte de la tabla del proceso
mantenida por el sistema operativo.
b) Área (o usuario): Contiene información de control del proceso que necesita ser accedida
sólo en el contexto del proceso.
c) Tablas de páginas y de regiones: Definen la correspondencia entre las direcciones

virtuales y las físicas y campos de permisos. Se utilizan por el gestor de memoria.
Página 103 de 164

d) Pila del núcleo: Contiene los marcos de la pila de los procedimientos del núcleo como un
proceso ejecutado en modo núcleo.
e) Parte dinámica del contexto a nivel de sistema de un proceso: Consiste en un conjunto

de capas (pila LIFO). Cada una contiene la información necesaria para recuperar la capa
anterior, incluyendo el contexto de registro.
La distinción entre la entrada a la tabla del proceso y el área refleja el hecho de que el núcleo de Unix
siempre se ejecuta en el contexto de algún proceso. Muchas de las veces se ejecutará según el interés
de este proceso. Pero, algunas veces (por ejemplo, cuando el núcleo realiza un algoritmo de
planificación para distribuir a otro proceso) necesita acceder a la información sobre dicho proceso.
Creación De Procesos
La creación de un proceso en Unix se hace mediante la llamada del sistema fork: “pid fork()”. A la
vuelta de la llamada fork, los dos procesos tienen copias idénticas de sus contextos a nivel de usuario
excepto por el valor pid devuelto. Cuando un proceso hace una petición de fork, el núcleo realiza las
siguientes funciones:
1) En la tabla de procesos se le asigna un espacio.

2) Al proceso hijo se le asigna un identificador (ID).
3) Se hace una copia de la imagen del proceso padre, con excepción de la memoria compartida.
4) Se incrementan los contadores de algunos archivos propiedad del padre, para reflejar que ahora
también pertenecen a otro proceso más.
5) al proceso hijo se le asigna un estado de “preparado para ejecución”.
6) Se devuelve al proceso padre el ID del hijo, y un valor cero al hijo.
Todo este trabajo se realiza en modo núcleo en el proceso padre. Cuando el núcleo termina estas
funciones, el distribuidor puede:
1) Permanecer en el proceso padre.

2) Transferir el control al proceso hijo.
3) Transferir el control a otro proceso.
Tanto el padre como el hijo se ejecutan en el mismo trozo de código. La diferencia está en que cuando
se vuelve de fork se verifica el parámetro devuelto, si el valor es cero, éste es el proceso hijo, en caso
contrario, es el padre.
Comunicación Entre Procesos
1) Tubos. Permiten transferir datos entre procesos y sincronizar la ejecución de los mismos. Usan un
modelo de productor-consumidor, y hay una cola FIFO donde un proceso escribe y el otro lee.
Clase de tubos:
a) No etiquetados: sólo se pueden comunicar procesos relacionados (un proceso con sus
descendientes).
b) Etiquetados: se pueden comunicar procesos no relacionados.
2) Señales. Mecanismo software que informa a un proceso de que ha ocurrido algún suceso
asíncrono (similar a una interrupción hardware). Los procesos pueden enviar señales a los otros
con la llamada al sistema kill, o bien el núcleo las puede enviar internamente.
Cuando se envía una señal a un proceso, el núcleo actualiza un bit en un campo de señales de la
entrada de la tabla del proceso. Hay un bit para cada tipo de señal, sólo se puede atender una
señal de cada tipo y no se puede crear una cola de señales.
3) Mensajes. Permiten a los procesos enviar a cualquier proceso cadenas de datos formateados. En
Unix hay cuatro llamadas al sistema para los mensajes:
Página 104 de 164

a) msgget: Devuelve un descriptor del mensaje.
b) msgctl: Tiene las opciones de poner y devolver parámetros y de eliminar descriptores.
c) msgsnd: Envía un mensaje.
d) msgrcv: Recibe un mensaje.
4) Memoria compartida. Posibilita que los procesos compartan parte de su espacio de direcciones
virtuales. Es la forma más rápida de comunicación. Llamadas al sistema:
a) shmget: Crea una nueva región de memoria compartida o devuelve una existente.
b) shmat: Une una región con el espacio de direcciones virtuales de un proceso.
c) shmdt: Adhiere una región al espacio de direcciones virtuales de un proceso.
d) shmdt: Elimina esta región del espacio de direcciones virtuales del proceso.
e) shmctl: Manipula varios parámetros asociados con la memoria compartida.
5) Semáforos. Pueden sincronizar la ejecución de los procesos. Consta de los siguientes elementos:
a) Valor del semáforo.

b) ID del último proceso que manipulo al semáforo.
c) Número de procesos que esperan que el valor del semáforo aumente.
d) Número de procesos que esperan que el valor del semáforo sea igual a cero.
Se crean en conjuntos y las llamadas al sistema son:
a) semget: Crear y tener acceso a un conjunto de semáforos.

b) semctl: Operaciones de control sobre el conjunto.
c) semop: Manipular los valores de los semáforos. Sintaxis: oldval = semop (id, oplist,
count); donde id es el descriptor devuelto por semget; oplist es un puntero a un arreglo de
operaciones y count es el tamaño del arreglo. El valor devuelto oldval es la última
operación sobre el semáforo.
Gestión De La Memoria
Muchas de las implementaciones Unix hacen uso de memoria virtual paginada. En Unix System V se
usan unas estructuras de datos prácticamente independientes de la máquina:
1) Tabla de páginas. Una para cada proceso, con una entrada para cada una de las páginas de
memoria virtual del proceso y los siguientes campos:
a) Número del marco en la memoria virtual.

b) Edad o tiempo que ha estado la página en la memoria sin referenciarse.
c) Copias para escritura. Si un proceso escribe en una página compartida, se hace primero una
copia para los otros procesos.
d) Bit de página modificada.
e) Bit de referencia, que indica si ha sido referenciada.
f) Bit de validación, que señala que la página está en memoria principal.
g) Bit de protección, que indica si se permiten operaciones de escritura.
2) Descriptor de bloques del disco. Describe la copia en el disco de la página virtual. Campos
principales:
a) Número lógico del dispositivo de intercambio que tiene la página.

b) Número de bloque.
c) tipo de almacenamiento: una unidad de intercambio o un archivo ejecutable.
3) Tabla de datos del marco de página. Se describe cada uno de los marcos de la memoria real. El
índice de la tabla es el número del marco. Hay varios punteros utilizados para crear listas dentro
de la tabla. Los marcos disponibles se enlazan juntos en una lista de marcos libres. Algunos
campos:
Página 105 de 164

a) Estado del marco de página: disponible o no.
b) Contador de referencia: número de procesos que referencia la página.
c) Dispositivo lógico que contiene una copia de la página.
d) Número de bloque.
e) Un puntero a otra entrada de esta tabla, a una lista de páginas libre y a una cola hash de
páginas.
4) Tabla de intercambio. Tiene una entrada por cada página en el dispositivo de intercambio y
existe una por cada dispositivo. Campos:
a) Contador de referencia: número de puntos de entradas de la tabla de páginas a una página

en el dispositivo de intercambio.
b) Identificador de la página en la unidad de almacenamiento.
Sistema De Archivos
Tipos de archivos en Unix:
1) Ordinarios. Contienen la información del usuario y los programas de aplicación o de utilidades del
sistema.
2) Directorio. Contienen listas de nombres de archivos, más los punteros asociados a los i-nodos.
3) Especiales. Corresponden a los periféricos.
4) Etiquetados. Tubos etiquetados.
Todos los tipos de archivos de Unix se gestionan por el sistema operativo mediante los i-nodos. Estos
corresponden a una tabla que contiene los atributos y las direcciones de los bloques del archivo.
Los archivos se ubican dinámicamente, según es necesario, por lo que los bloques de un archivo en el
disco no son necesariamente contiguos.
Los archivos pequeños tienen toda su información en el propio i-nodo. Para archivos más grandes, una
de las direcciones del i-nodo es la dirección de otro bloque del disco en el que hay otra tabla de índices.
Si esto no es suficiente, hay otras dos direcciones para una doble y triple indexación.
Ventajas de los i-nodos: Son relativamente pequeños y de tamaño fijo, de forma que se pueden
mantener en memoria principal, y los archivos que ocupan poco espacio se pueden acceder sin
indexación.
Subsistema De Entrada/Salida
En Unix, todos los periféricos están asociados a un archivo especial, que se gestiona por el sistema de
archivos, pudiéndose leer y escribir como otro archivo más. Los periféricos pueden ser:
a) De bloque: Periféricos de almacenamiento de acceso arbitrario (como discos).
b) Orientados a caracteres: Los otros tipos (impresoras, terminales).
La E/S se puede realizar:
a) Con buffer. Donde los mecanismos de buffer son:
a.1) Caché de buffer: Es esencialmente una caché de disco. La transferencia de datos entre la
caché del buffer y el espacio de E/S del proceso del usuario se realiza mediante DMA, ya
que ambos están localizados en la memoria principal.
Página 106 de 164

a.2) Colas de caracteres: Resulta apropiado para los periféricos orientados a caracteres. El
dispositivo de E/S escribe una cola de caracteres que son leídos por el proceso o
viceversa. En ambos casos se utiliza un modelo de productor-consumidor.
b) Sin buffer. Es simplemente una operación de DMA entre el periférico y el espacio de memoria del
proceso. Este es el método más rápido. Sin embargo, un proceso que esté realizando una
transferencia de E/S sin buffer está bloqueado en la memoria principal y no puede intercambiarse.
Página 107 de 164

Sistema O perat ivo Novell Netw are
Inicialmente, Novell realizó un sistema operativo que se llamaba Netware, y estaba

fabricado para el procesador Motorola MC-68000. En 1983 apareció el XT y el
sistema operativo MS-DOS, y en ese momento, Novell rescribió el sistema operativo.
Conforme ha avanzado la informática ha avanzado el sistema operativo Novell
Netware.
A partir de 1983 se tienen las siguientes versiones de Netware:
1. Advance Netware 2.86 para ordenadores 80286 Intel.

2. Netware 386 para los microprocesadores 80386 y 80486.
3. Netware 4.X para 80486 y Pentium.
4. Versiones mejoradas de Netware con soporte amplio de protocolos TCP/IP.
Se tiene el siguiente cuadro de versiones para el sistema operativo Netware:
VERSIÓN SERVIDOR Nº USUARIOS OBSERVACIÓN
Netware Pequeños grupos. De 2 a

No dedicado. Es punto a punto.
Lite 25.
Puede ser dedicado o

Permite hasta 100 usuarios Esta pensado para empresas de tamaño
Netware no, dependiendo de
con una estrategia medio o pequeños grupos dentro de
2.2 querer mas coste o
multiprotocolo. grandes empresas.
mas potencia.
Netware Limitación en las prestaciones de conexión

Dedicado. Grandes empresas.
3.11 con INTERNET.
Posee todas las prestaciones del 3.11, y

Netware Dedicado y Tiene soporte para redes
además un interfaz gráfico para el usuario
4.X multiprotocolo. de área amplia.
que facilita el manejo del sistema operativo.
Netware 4.X
El sistema operativo Netware está en el servidor.

La forma de compartir información es mediante el
proceso cliente/servidor. Este proceso
cliente/servidor se basa en la estructura ilustrada
en la imagen de la derecha:
Protocolo Básico De Netware
La característica fundamental es que el sistema operativo Netware trabaja con 32 bits. Netware se basa
en que todo esta controlado por el servicio de directorios de Netware (NDS) que va a trabajar con todos
los recursos de la red de modo global. Este servicio de directorios va a tratar a todos los recursos de la
red como objetos. Un objeto puede ser un usuario, un archivo, un terminal, etc. Eso permite que la
gestión de la red sea sencilla y que se puedan enlazar una red con otras gracias al servicio de
directorios.
Página 108 de 164

Dentro de estas características se tiene que hablar del protocolo básico de Netware (NCP). El NCP es el
que define los servicios disponibles a todos los usuarios de la red. Esos servicios se agrupan en distintas
categorías:
1. Acceso a archivos (apertura y cierre de archivos; lectura y escritura).

2. Bloqueo de archivo.
3. Seguridad.
4. Control de la asignación de recursos.
5. Notificación de eventos.
6. NDS (servicio de directorios de Netware).
7. Sincronización entre servidores.
8. Conexión y comunicación.
9. Servicio de impresión.
10. Gestión de la red.
El NCP es transparente al usuario. El cliente pide algo y el servidor se lo da.
Netware es modular y expansible, ya que se le pueden ir añadiendo módulos cargables (NLM) desde el
servidor que pueden aportar nuevos servicios a sistema operativo. Estos módulos son:
1. Soporte para sistemas operativos que no sean MS-DOS.

2. Servicio de comunicaciones.
3. Servicio de base de datos.
4. Servicio de almacenamiento y copias de seguridad.
5. Servicios de administración general de la red.
Niveles Internos De Netware
El soporte para los sistemas operativos MS-DOS, OS/2 y UNIX, así como el interfaz gráfico de
WINDOWS, vienen incluidos en Netware. Para el sistema operativo Macintoch y FTAM no vienen en
Netware, pero puede instalarse como una opción.
El sistema operativo Netware utiliza una interfaz abierta de enlaces de datos (ODI) que elige el protocolo
de comunicación adecuado dependiendo de la placa que tenga conectado. Esta interfaz es la que hace
posible que pueda usar un multiprotocolo.
La IPX es el protocolo que realmente utiliza Novell por convenio, aunque Novell acepta cualquiera.
El soporte de sistema operativo es la que

se encarga de dar servicios al usuario.
El soporte de espacios de nombres quiere

decir que los sistemas operativos no
tienen un convenio entre ellos (por
ejemplo, hay sistemas operativos que
distinguen mayúsculas y minúsculas y
otros no). Netware, por su parte, dejará
usar el sistema operativo que se tenga en
el equipo.
Netware, también soporta una amplia variedad de topologías. Las topologías más usadas y vendidas
como estándares son las señaladas en la próxima página:
Página 109 de 164

NORMA NOMBRE ACCESO TOPOLOGÍA CABLEADO
Coaxial o par
802.3 Ethernet CSMAICD A nivel lógico es un bus lineal.
trenzado.
Par trenzado o
802.5 Token ring Paso de testigo. A nivel lógico es un anillo.
coaxial
A nivel lógico es un bus lineal
802.4 Arcnet Paso de testigo Coaxial.
o estrella
Características De Rendimiento
Una de las características por la que Netware es tan potente es que el rendimiento que ofrece es muy
bueno. Este buen rendimiento está basado en dos factores:
• La gestión de la memoria: Netware permite gestionar sobre cuatro Gibabytes. Netware no tiene
zonas reservadas de memoria como una sola entidad. La versión 3.11 de Netware, tenía una
gestión de memoria que se basaba en dividir la memoria en cinco zonas (o pool), y dependiendo
del tipo de aplicación, la ejecutaba en una de esas zonas. Cuando la tarea terminaba, esa parte de
memoria no podía ser utilizada por otra aplicación. A partir de la versión 4.X, Netware utiliza toda
la memoria con cada aplicación que la necesite y después la elimina y pudiendo ser utilizada por
otra aplicación.
• La gestión de sistemas de archivos: Esta mejor gestión se realiza gracias a:
1. Búsqueda por el método del ascensor: Intenta mejorar el tiempo de acceso al disco. El
método del ascensor prioriza la lectura basándose en la mejor forma de acceder a ella a
partir de la posición actual de la cabeza de lectura. (Ejemplo: ascensor del Corte Inglés:
Aunque lo llame antes el del segundo que el del quinto, si esta en el sexto y va para abajo,
recoge primero al del quinto).
2. Caché de disco: Va a disminuir el número de accesos al disco. La caché de disco consiste

en que los archivos que se utilizan más frecuentemente se retienen en un buffer de memoria
que se llama caché. Para que esto sea eficiente, también tiene que haber un mecanismo
que saque archivos que no se usen para que puedan entrar otros archivos que, en ese
momento, se estén usando más.
3. Turbo FAT: La tabla de asignación de archivos es la FAT de un disco. La FAT sería como el
índice de un libro, donde se ve la posición de todos los archivos. La turbo FAT forma un
índice de la tabla de asignación de archivos (la indexada) para sí lograra acceder a los
archivos mucho mas rápido.
4. Escritura en dos planos: Se basa en que Netware prioriza las lecturas respecto a las
escrituras.
5. Compresión de archivos: Un archivo comprimido es la forma de almacenar archivos en un

disco para que ocupe menos espacio. Aquellos archivos que previamente comunique el
administrador o el usuario, o los archivos que no se usan durante un tiempo determinado,
Netware los comprime. Con esto, se aumenta hasta en un 63% la capacidad del disco.
6. Reserva parcial de bloque: Al instalar Netware se establece un tamaño de disco por

defecto. Este tamaño de disco por defecto es de 8 Kb, de modo que cuando se va a trabajar
con el disco, se toma y almacena la información en bloques de 8 Kb. Si el sistema operativo
encuentra bloques que están parcialmente usados, los subdivide en bloques de 512 bits, que
se utilizan para almacenar archivos pequeños o para fragmentos de otros archivos.
7. Sistema de archivos con recuperación: Netware permite recuperar los archivos que se
han borrado. Con Netware se puede controlar cuanto tiempo puede meterse un archivo
como recuperable, y además, tiene una opción donde se pueden mantener recuperables
todos los archivos borrados hasta que se encuentre sin espacio en el disco.
Página 110 de 164
Características De Protección De Datos
Las características que ofrece Netware en protección de datos son en dos sentidos:
1. Seguridad: Se basa principalmente en el acceso a la red.
• Seguridad a nivel de cuenta/clave de acceso: Si un usuario no tiene asignado un nombre

de usuario para entrar en la red, o bien un usuario no introduce bien la clave de acceso, no
se podrá conectar al sistema operativo de la red.
• Restricciones sobre las cuentas: El administrador restringe los accesos a las diferentes
utilidades de los usuarios.
• Seguridad de objetos y archivos: El administrador puede asignar a los usuarios unos

privilegios o derechos efectivos, llamados trustees. Los trustees determinan el modo en que
se accede a la red. El modo se refiere, por ejemplo, a si se pueden modificar cosas, entrar
en sólo en lectura, etc. Trustees es algo parecido a los atributos de archivos de MS-DOS.
• Seguridad entre redes: Netware permite conexión entre redes. Esto es debido a que los
NDS (árbol de directorios de Netware) son únicos. El NDS es una manera que tiene Netware
de usar todos los archivos de la red de manera única.
2. Fiabilidad: Se basa en la realidad de los datos que están dentro de la red.
• Verificación de lectura tras escritura: Cada vez que se realiza una escritura en disco,
Netware, comprueba mediante una lectura, que los datos se han grabado correctamente. En
caso de que se haya producido un error los datos vuelven a ser escritos desde el caché de
disco.
• Duplicación de directorios: Permite duplicar el directorio raíz de un disco para ofrecer una
copia de seguridad en caso de que el original resulte dañado. Ese daño puede ser tanto un
daño físico como por la destrucción de un virus.
• Duplicación de la FAT: Se mantiene un duplicado de la FAT. En caso de que se pierda la

FAT original, se pasa al duplicado. Esto lo hace Netware sin que el usuario lo note.
• Hot fix: Detecta y corrige errores de disco durante la ejecución.
• Tolerancia a fallos del sistema (STF): Permite tener redundancia en cuanto a hardware del
equipo, es decir, puedes instalar dos discos duros en el servidor duplicando uno en el otro.
Así, en el servidor, tendrás dos discos duros con la misma información.
• Sistema de control de transacciones (TTS): Ante una caída del servidor, Netware
deshace las transacciones incompletas cuando reanuda el servicio.
• Monitorización de la energía: Las UPS son unos módulos que cont rolan el estado del
suministro de energía eléctrica que está conectada al servidor. De manera, que si en un
momento determinado, se detecta que el servidor está trabajando con la alimentación de
reserva, indica los usuarios que se esta trabajando con así. En ese momento se empiezan a
guardar los datos y luego el sistema baja.
Página 111 de 164

Otras Prestaciones
1. Servicios de comunicación: Son básicamente dos los que permiten la comunicación entre
usuarios de una red y usuarios de una red distinta: Mensaje y correo. Esta comunicación se hace
posible gracias a Netware Comunication Service, que son los servicios de comunicación de Netware.
2. Servicio de copia de seguridad: Existe una utilidad que es el sbackup que permite establecer copias
de seguridad en distintos dispositivos físicos.
3. Servicios de impresión: Hace que con esta versión de Netware se puedan compartir hasta 256
impresoras. Además, los servicios de impresión gestionaran las colas de impresión y el modo de
acceso de los usuarios a las impresoras. Los servicios de impresión de Netware se pueden instalar
en la versión 3.11 en el servidor o en una estación de trabajo como tarea dedicada, no obstante en
la 4.12 sólo lo permite en un servidor de archivos.
4. Servicios distribuidos de directorios: El hecho de que existan directorios distribuidos está

controlado gracias a la gestión mediante los NDS. Los NDS ofrecen una visión global de todos los
recursos de la red y todos los recursos se tratan como objetos.
5. Sistemas de facturación: Existen unas utilidades mediante las cuales se pueden realizar
estadísticas y seguimientos del tiempo de uso del servidor y de los distintos recursos de la red.
6. Servicios de administración: Son distintas utilidades que permiten controlar el estado de la red:
• Netadmin (DOS): Funciona en entorno de MS-DOS. No se tiene control sobre directorios y

archivos, y eso es lo único que la diferencia de Netware Administration Service.
• Monitor: Es un módulo cargable que permite la visualización de información sobre el estado

del servidor y de las distintas actividades de la red.
• Servman: Es una utilidad que sólo se puede ejecutar desde el servidor. A esto se le llama
una utilidad de consola. Permite al administrador del sistema modificar las características del
servidor.
• Administración remota: El administrador de la red puede gestionar la red desde una

unidad remota.
• Netware administrator (Windows): Es una utilidad que trabaja en entorno Windows y

permite al administrador, desde una estación de trabajo, gestionar todo el sistema.
Página 112 de 164

Sistema O perat ivo W indow s NT
En Windows NT, al igual que en otros sistemas operativos, se

distingue entre el software orientado a las aplicaciones (que se
ejecuta en modo usuario) y el software del sistema operativo (que se
ejecuta en modo privilegiado o modo núcleo). Este último tiene
acceso a los datos del sistema y al hardware, mientras que le resto
del sistema lo tiene limitado.
El sistema operativo se divide en cuatro capas:
1) Capa de abstracción del hardware (HAL, Hardware Abstraction Layer). El objetivo de esta
capa es que el núcleo vea por igual a todo el hardware, independientemente de la plataforma que
use. Para ello realiza la conversión entre las órdenes y las respuestas del hardware genérico y el
de una plataforma específica.
2) Núcleo (kernel). Parte central del sistema operativo que se encarga de gestionar la planificación y
conmutación de contexto, la sincronización y los manipuladores de excepciones e interrupciones.
3) Subsistemas. Incluye módulos para funciones específicas que hacen uso de los servicios básicos
dados por el núcleo:
a) Gestor de objetos.
b) Gestor de memoria virtual.
c) Gestor de procesos.
d) Monitor de referencia de seguridad.
e) Facilidades de llamada a los procedimientos locales.
El subsistema gestor de E/S incluye el sistema de archivos, el gestor de caché, los manejadores de
dispositivos y de red, etc. y evita que el núcleo interaccione directamente con el hardware.
4) Servicios del sistema. Proporciona un interfaz para el software que se ejecuta en modo usuario.
Por encima de estas capas están los

Aplicaciones
subsistemas protegidos, que se
encargan de la comunicación con el
usuario final. Proporcionan un interfaz Subsistemas protegidos
de usuario gráfico o de línea de órdenes
y el interfaz de programación (API,
Application Programming Interface). Servicios del sistema
Gestor de objetos
Gestor de procesos Gestor
Subsistemas
Gestor de memoria virtual
de E/S
…………
Núcleo
Capa de abstracción del hardware (HAL)
Otras Características Hardware
• Arquitectura cliente/servidor. Cada servidor se implementa como uno o más procesos, de forma
que cada proceso espera que algún cliente (un programa de aplicación u otro módulo del sistema
operativo) realice una petición de alguno de sus servicios. Esta petición se hace enviando un
mensaje al servidor, que realiza la operación pedida y contesta mediante otro mensaje. Esta
arquitectura simplifica mucho el sistema operativo básico, puesto que no proporciona ningún API,
se pueden construir otros API sin ningún conflicto, además de ser una forma natural para el cálculo
distribuido. También se aumenta la fiabilidad, puesto que cada servidor se ejecuta en un proceso
separado con su propia partición de memoria y protegido de otros servidores, de forma que si falla
no corrompe al resto del sistema.
Página 113 de 164

• Soporte de hebras dentro de los procesos. Una hebra es una unidad básica de ejecución que
se puede interrumpir para que el procesador pase a otra hebra. Desde el punto de vista del
planificador y del distribuidor, este concepto es equivalente al de proceso en otros sistemas
operativos. En Windows NT un proceso es un conjunto de una o más hebras junto con los
recursos del sistema asociados. Esto corresponde al concepto de programa en ejecución.
• Utilización de los conceptos de diseño orientado a objetos. Aunque no es un sistema

operativo orientado a objeto puro, ya que no está implementado en un lenguaje orientado a
objetos. Las estructuras de datos que residen completamente dentro de un ejecutable no se
representan como objetos. Y no incorpora la herencia ni el polimorfismo. Sí usa la encapsulación
(los objetos consisten en uno o más ítems de datos, llamados atributos, y uno o más
procedimientos que se pueden ejecutar sobre estos datos, llamados servicios) y las clases e
instancias de objetos (una clase de objetos es una plantilla en la que se guardan los atributos y
servicios de un objeto y se definen ciertas características del mismo).
En NT los objetos se emplean en los casos donde los datos están abiertos para acceso en modo
usuario o cuando el acceso a los datos es compartido o restringido. Entidades representadas por
objetos son procesos, hebras, archivos, semáforos, relojes y ventanas. NT maneja todos los tipos
de objetos mediante un gestor de objetos, cuya responsabilidad es crear y eliminar los objetos
según la petición de las aplicaciones y otorgar acceso a servicios de objetos y datos. Un objeto (un
proceso o una hebra) puede referenciar a otro objeto (un archivo o un semáforo) abriendo un
manejador del mismo.
Los objetos pueden estar etiquetados o no. Cuando un proceso crea un objeto no etiquetado, el
gestor de objetos devuelve un manejador al objeto. La única forma de referenciarlo es mediante su
manejador. Los objetos etiquetados tienen un nombre que puede usarse por otro proceso para
obtener un manejador del objeto. Los objetos etiquetados tienen asociada información de
seguridad en la forma de un testigo de acceso que se puede utilizar para limitar el acceso al
objeto.
Control Y Sincronización De Procesos
El diseño de los procesos en NT está marcado por la necesidad de proporcionar soporte para diferentes
entornos de sistemas operativos, por lo que la estructura de los procesos y los servicios proporcionados
por el núcleo son relativamente sencillos y de propósito general. Esto permite que cada subsistema del
sistema operativo emule una funcionalidad y estructura de procesos particular. Características de los
procesos:
1) Son implementados como objetos.

2) Puede tener una o más hebras.
3) Llevan incorporadas las capacidades de sincronización.
4) El núcleo no mantiene ninguna relación con los procesos que crea (ni de padre-hijo).
La concurrencia entre los procesos se consigue porque hebras de diferentes procesos se pueden
ejecutar concurrentemente. Si se dispone de varias CPUs, se pueden asignar distintos procesadores a
hebras del mismo proceso. Las hebras del mismo proceso pueden intercambiar información entre ellas a
través de la memoria compartida y tener acceso a los recursos compartidos del proceso.
Para implementar los servicios de sincronización entre las hebras, se tiene la familia de objetos de
sincronización, que son: procesos, hebras, archivos, sucesos, semáforos y relojes. Los tres primeros
tienen otros usos, el resto se diseñan específicamente para soportar la sincronización.
Gestión De Memoria
Se adopta el tamaño de página de 4 Kb del 80486 como base de su esquema de memoria virtual. En
estos procesadores de Intel se incluye un hardware especial para soportar la segmentación y la
paginación. Estas funciones pueden desactivarse, pudiéndose elegir entre las opciones de memoria:
Página 114 de 164

1) Ni segmentada ni paginada.
2) Paginada, pero no segmentada.
3) Segmentada, pero no paginada.
4) Segmentada y paginada.
Segmentación
Cuando se emplea segmentación, cada dirección virtual (o lógica) se compone de un campo de

referencia al segmento de 16 bits (dos de ellos destinados a los mecanismos de protección y catorce
para especificar el segmento) y un campo de desplazamiento en el segmento de 32 bits. El espacio de
memoria virtual que puede ver un usuario es de 246=64 Tb. Mientras que el espacio de direcciones
físicas que se puede direccionar con 32 bits es de 4 Gb.
Hay dos formas de protección asociadas con cada segmento:
1) Nivel de privilegio. Hay cuatro niveles de privilegio (del 0 al 3), que cuando se trata de un
segmento de datos corresponde a la clasificación del mismo y si es un segmento de programa
es su acreditación. Un programa sólo puede acceder a segmentos de datos para los que le nivel
de acreditación es menor o igual que el de clasificación. Generalmente los niveles 0 y 1
corresponden al sistema operativo, el nivel 2 a algunos subsistemas y el 3 a las aplicaciones.
2) Los atributos de acceso de un segmento de datos. Indican si el permiso es de

lectura/escritura o de sólo lectura. Para un segmento de programa expresan si es de
lectura/ejecución o de sólo lectura.
Paginación
Cuando no se usa segmentación, los programas emplean direcciones lineales (corresponden a las
direcciones en el espacio de memoria del proceso que utilizan 46 bits) que hay que convertir en una
dirección real de 32 bits. El mecanismo de paginación utilizado para hacer esto consiste en una
operación de búsqueda en una tabla de dos niveles. El primer nivel es un directorio de páginas con 1024
entradas, con lo que se divide el espacio de memoria de 4 Gb en grupos de 1024 páginas, de 4 Mb cada
una con su propia tabla de páginas. Cada tabla de páginas contiene 1024 entradas y cada entrada
corresponde a una página de 4 Kb. El gestor de memoria puede usar un directorio de páginas para todos
los procesos, un directorio para cada proceso o una combinación de ellos. El directorio de páginas de la
tarea actual está en memoria principal, pero las tablas de páginas pueden estar en memoria virtual.
Página 115 de 164

Sistema O perat ivo W indow s 2000
Microsoft Windows 2000 Professional se considera como el sistema

operativo ideal para computadores móviles y de escritorio, diseñado para
sustituir a Windows 95 como el estándar de las empresas. Pues al
agregarle el poder y la seguridad de Windows NT Workstation,
seguridad de Windows NT Workstation, así como la interfaz de Windows 98, se obtiene como resultado
el más sencillo y eficiente sistema operativo de escritorio hasta ahora concebido (según sus propios
fabricantes).
Las funciones mejoradas de Windows 2000 Professional, ayudan a los usuarios a aprovechar
completamente sus capacidades. Este Windows constituye hasta ahora el más sencillo sistema
operativo para configurar o trabajar en un computador o navegar en Internet. Fue desarrollado con base
en el poder de Windows NT Workstation, por lo que ofrece estándares de seguridad, confiabilidad
industrial y un mejor desempeño. Proporciona las mejores características de Windows 98, para estar al
día en apoyo móvil y asegurarle que podrá aprovechar la nueva generación de equipos y provee un
escritorio más manejable y más sencillo de implementar, administrar y dar soporte, lo que traduce en una
disminución del costo total de propiedad.
Instalación Más Sencilla
Una de las mejoras que se experimenta al utilizar Windows 2000 es que su sistema de instalación es
más confiable y simplificado, soporta scripts de instalación que requieren una participación mínima. Los
administradores pueden hacer un script completo del proceso de instalación, de manera que no se
necesita contestar más preguntas que el nombre y contraseña; aun las instalaciones para las que no se
ha preparado un script son más simples y más confiables. Su instalación es sumamente fácil. Además,
Windows 2000 Professional cuenta con soporte para la creación de redes pequeñas.
A continuación se detallan varios ejemplos de lo que hace Windows 2000 Profesional durante una
instalación sin script:
Simplifica la instalación: Pantallas y las preguntas que se presentan durante el proceso de instalación
poseen un lenguaje sencillo y no técnico.
Automatiza más tareas: Windows 2000 Professional tiene más supuestos acerca de la manera en que
se deberían instalar los computadores. Además, proporciona detección de hardware y soporta Plug and
Play, lo que automatiza la instalación y la configuración de los dispositivos de hardware.
Instalación más confiable: Windows 2000 Professional rastrea los problemas durante la instalación, y
en caso de que surja algún problema que no sea crítico (lo que no evitará que el computador arranque),
la instalación continuará. Cuando ésta se haya completado, el sistema operativo genera un reporte de
registro de problemas, para que un administrador los resuelva.
Obliga a validarse: Utilizar CTR+ALT+DEL antes de conectarse, es la manera más segura para que el
usuario se conecte a Windows 2000 Professional; ayuda a proteger el sistema operativo de algún acceso
no autorizado. Para conectarse, primero se ve una pantalla de conexión simplificada que oculta los
nombres de dominio. No es frecuente que necesiten cambiar su dominio; por lo tanto, ocultar esta opción
puede reducir los costos del escritorio de ayuda, al disminuir las posibilidades de que cambien el dominio
en forma inadvertida.
Configuración de pequeñas redes: Con Windows 2000 Professional es posible configurar redes
pequeñas al sólo conectar los computadores configuradas con Windows 2000 Professional en un HUB.
La primera vez que Windows 2000 Professional inicia, se ajusta a una predeterminación que busca un
servidor DHCP (Protocolos de configuración de host dinámico).
Además, Windows 2000 posee un escritorio mucho más poderoso y personalizable que incorpora
cualidades como:
Página 116 de 164

Confiabilidad y soporte mejorado para cambios de configuración: Windows 2000 Professional
soporta aplicaciones autorreparables, Plug and Play y manejo de potencia, que permiten instalar el
hardware y las aplicaciones sin comprometer el sistema ni incurrir en pausas significativas. El soporte
para Plug and Play, la administración de potencia y el bus serial universal (USB) facilitan trabajar con
hardware. Un Panel de control mejorado organiza las herramientas de manera más lógica.
Gestión de aplicaciones: El cuadro de diálogo Agregar/Eliminar Programas de Windows 2000

Professional proporciona mayor información acerca de las aplicaciones, como espacio de disco utilizado,
versión, frecuencia de uso y si está disponible el soporte técnico en línea.
Gestión de hardware: Windows 2000 Professional ha sido mejorado para trabajar con una mayor
variedad de componentes hardware, y específicamente da soporte a Plug and Play, administración de
energía, y bus serial universal (USB). USB es un tipo de bus que facilita aún más la instalación de
diferentes tipos de periféricos compatibles, incluidos teclados, cámaras, escáner y otros dispositivos de
imagen. El asistente Agregar/Quitar Hardware ayuda a resolver problemas de hardware; así cuando
Windows 2000 detecta un hardware nuevo, verifica las configuraciones para el dispositivo e instala el
controlador correcto. Además, cuando Windows 2000 Professional detecta un hardware nuevo, verifica
las configuraciones actuales para el dispositivo e instala el controlador correcto; además el asistente,
muestra una lista del hardware instalado y ayuda a verificar para que esté seguro de que cada
dispositivo está trabajando de manera adecuada.
Herramientas administrativas: En el panel de control mejorado, las herramientas avanzadas están en

el mismo cuadro de diálogo. Estas herramientas incluyen:
a) Servicios de Componentes. Usado para instalar y administrar programas COM+ de una interfaz
gráfica, o para automatizar tareas administrativas utilizando un lenguaje de programación o script.
b) Administración de Sistema. La administración del computador combina varias herramientas

administrativas de Windows 2000 (Herramientas de sistema, almacenamiento, servicios y
aplicaciones) en un solo árbol de consola, que ofrece fácil acceso a propiedades administrativas
del computador.
Visualizador de eventos: Al utilizar los registros de eventos del visualizador de eventos, se puede
compilar información acerca del hardware, software y problemas con el sistema, además de monitorizar
eventos de seguridad de Windows 2000.
La Evolución Plug & Play
Plug and Play es una combinación de soporte de hardware y software que permite al sistema del
computador reconocer y adaptar cambios en la configuración de hardware con poca o nula intervención
del usuario. En Windows 2000, el soporte para Plug and Play fue optimizado para laptops, estaciones de
trabajo y computadores de servicios que incluyen tarjetas de sistema. Plug and Play permite cambiar la
configuración de un computador con la seguridad de que todos los dispositivos trabajarán juntos y que la
máquina iniciará correctamente después de hacer los cambios.
Lo Mejor De Versiones De Las Anteriores
Lo mejor de Windows 98: Windows 2000 Professional incluye y mejora las funciones clave de
Windows 98, con lo que perfecciona el apoyo a sistemas móviles y agrega soporte para los últimos
modelos de equipos. Está diseñado para que las personas que trabajan fuera de línea (desconectados
de una red), tengan la misma experiencia que las que trabajan en línea. Administrar los documentos
fuera de línea y de las páginas de la Red es mucho más automatizado, ya que las mejorías en el sistema
indican y actualizan la administración.
Uno de sus principales objetivos de diseño es crear un ambiente de trabajo consistente para las
personas que usan computadores móviles, ya sea que estén conectadas o desconectadas de la red, lo
que les permite trabajar en forma más productiva. Como resultado, las personas pueden trabajar en los
Página 117 de 164

mismos archivos, carpetas o sitios Web estando conectados o no, y sincronizar con facilidad esos
recursos.
El poder de Windows NT: Microsoft Windows 2000 Professional se basa en la fuerza de Windows NT
para proporcionar confianza, una mayor seguridad, la habilidad de operar de manera integrada con la
red actual, así como un nivel de desempeño bastante efectivo.
En un ambiente Windows 2000, usando el cambio basado en la política de grupo y la administración de

configuración, el administrador puede aprobar ciertas aplicaciones, al especificar que todas las
operaciones de configuración en tales aplicaciones (instalación, remoción y reparación) se ejecuten
como cuenta del sistema local. De esta forma, los administradores pueden asegurar el registro y los
sistemas de archivo, el servicio Windows Installer puede todavía realizar instalaciones para la persona.
Sólo las aplicaciones aprobadas por el administrador se ejecutan con privilegios elevados (en un
ambiente Windows NT 4.0, los administradores pueden especificar que todas las operaciones de
Windows Installer se ejecuten con privilegios del sistema local, pero ciertos productos no pueden
aprobarse en forma granular).
Seguridad Basada En Elevados Estándares De Desempeño
Windows 2000 Professional ofrece una infraestructura segura que permite seleccionar los niveles de
protección para la información y las aplicaciones que se necesitan. Para los computadores que
requieran estar conectadas a UNIX, Microsoft ofrece un complemento llamado Windows NT Servicios
para UNIX que incluye un cliente/servidor NES, un cliente/servidor Telnet, herramientas Scripting y
sincronización de clave.
Algunas de las características que se pueden encontrar en Windows 2000 Professional son:
Sistema de Archivos encriptado: Este nuevo sistema de encriptación EFS permite codificar archivos
en el disco duro, a los que únicamente se puede tener acceso vía autorización de Windows NT. Esta
característica protege archivos en caso de pérdida o robo de laptops, así como en sistemas de cómputo
de oficinas. EFS ofrece la tecnología principal de encriptación de archivos para almacenar los archivos
NTFS encriptados en disco. EFS se dirige particularmente a los problemas de seguridad que surgen por
las herramientas disponibles en otros sistemas operativos, que permiten acceder archivos desde un
volumen NTFS sin una verificación de acceso.
Tecnología de encriptación EFS: Se basa en la encriptación de clave pública, que aprovecha la

arquitectura CryptoAPI en Windows. Cada archivo se encripta utilizando una clave generada de manera
aleatoria, que es independiente del par de clave privada/pública de la persona que lo utiliza, con lo que
se evita varias formas de ataque con base en criptoanálisis. La encriptación de archivos puede utilizar
cualquier algoritmo de encriptación simétrico. El EFS está integrado firmemente con el NTFS. Cuando se
crean archivos temporales, los atributos del archivo original se copian a los archivos temporales, siempre
que los archivos estén en el volumen NTFS. Si encripta un archivo, el EFS también encripta sus copias
temporales. El EFS reside en el kernel del sistema operativo y utiliza una agrupación de no búsqueda
para almacenar las claves de encriptación de archivo, lo que asegura que nunca estén en el archivo de
búsqueda.
Interacción del usuario: La configuración predeterminada del EFS permite que los usuarios inicien la
encriptación de archivos sin esfuerzo administrativo. El EFS genera de manera automática un par de
clave pública para la encriptación de archivos de un usuario, en caso de que no exista. La encriptación y
desencriptación de archivos se soporta sobre una base de directorio completo o por archivos; la
encriptación de directorios se refuerza de manera transparente. Todos los archivos (y subdirectorios)
creados en un directorio marcado para encriptación se encriptan en forma automática. Cada archivo
tiene una clave de encriptación única, lo que lo hace seguro para volver a nombrarlo; si renombra un
archivo desde un directorio encriptado a un directorio no encriptado en el mismo volumen, el archivo
permanece encriptado. Los servicios de encriptación y desencriptación están disponibles en Windows
Explorer.
Página 118 de 164

Sistema de autenticación Kerberos: La implementación del protocolo Kerberos V.5 en Windows 2000
se basa en RFC-1510, que ha pasado a través de una amplia revisión de la industria y es bien conocido
en la comunidad de seguridad. La autenticación Kerberos proporciona varias funciones que soportan los
objetivos de rendimiento y seguridad para las redes empresariales. Windows 2000 integra el protocolo
Kerberos en el modelo de seguridad distribuida de Windows 2000 existente, y utiliza las funciones de
ampliación del protocolo, como lo han hecho otras arquitecturas de seguridad. El protocolo Kerberos es
sólo uno de los protocolos de seguridad soportados en Windows 2000; otros incluyen NTLM para
compatibilidad con versiones anteriores SSL y la Seguridad de nivel de transporte (TLS) estándar de
IETF para autenticación de clave pública, Negociación protegida individual (SPNEGO) de mecanismos
de seguridad y la seguridad IP (IPsec) para la seguridad a nivel de la red utilizando la autenticación de
clave compartida o clave pública. El Kernel de Windows 2000 realiza una verificación de acceso en cada
intento para abrir un controlador de objetos. El control de acceso y la auditoría se administran al
configurar las propiedades de seguridad del objeto para otorgar permisos al usuario, o preferencia a un
grupo. La autorización se administra de manera central, al agregar usuarios a los grupos de Windows
2000 a los que se otorgan los derechos de acceso correspondiente.
Autenticación de claves públicas: Windows 2000 Professional soporta certificados estándar X.509
v3.0. El sistema operativo Microsoft Windows 2000 introduce una infraestructura de claves públicas (PKI)
completa para la plataforma Windows. Esta infraestructura amplía los servicios criptográficos de claves
públicas (PK) basados en Windows que fueron introducidos durante los últimos años, por lo que
proporciona un conjunto integrado de servicios y herramientas administrativas a fin de crear, instalar y
administrar aplicaciones basadas en PK. Esto permite a los desarrolladores aprovechar los mecanismos
de seguridad de confidencialidad compartida o el mecanismo de seguridad basado en PK, según sea
necesario.
Criptografía de claves públicas: La criptografía es la ciencia de proteger datos. Los algoritmos

criptográficos combinan matemáticamente datos de texto simple de entrada y una clave de encriptación
para generar datos encriptados (texto cifrado). Con un buen algoritmo criptográfico, no es posible, desde
el punto de vista computacional, invertir el proceso de encriptación y derivar los datos de texto simple,
empezando sólo con el texto cifrado; algunos datos adicionales, como una clave de desencriptación,
son necesarios para efectuar la transformación.
Funcionalidad de las claves públicas: La separación entre claves públicas y privadas en la

criptografía PK ha permitido la creación de varias nuevas tecnologías. Las más importantes de estas
son las firmas digitales, la autenticación distribuida, convenio de claves secretas a través de claves
públicas y sin claves secretas compartidas anteriores. Las siguientes líneas describen los usos
principales de la criptografía PK.
Firmas Digitales: Crear y validar firmas digitales se basa en una transformación matemática que
combina la clave privada con los datos que se van a firmar, de tal forma que: (1) sólo la persona que
posee la clave privada pudo haber creado la firma digital; (2) quien tenga acceso a la clave pública
correspondiente puede verificar la firma digital y; (3) cualquier modificación de los datos firmados
invalida la firma digital.
Autenticación: La autenticación de entidades garantiza que el transmisor sea la entidad que el receptor
piensa que es. Si una persona recibe datos de otra, y después le envía un intercambio de señales
encriptado con la clave pública de la segunda persona, ésta decodifica el intercambio de señales y lo
envía de nuevo a la primera persona, probando que tiene acceso a la clave privada asociada con la
clave pública que esa persona utilizó para emitir el intercambio de señales.
Convenio de claves secretas a través de clave pública: Otra función de la criptografía PK es que
permite que dos partes acuerden una clave secreta compartida, utilizando redes de comunicaciones
públicas y no seguras.
Encriptación de datos masivos sin claves secretas compartidas anteriores: La cuarta tecnología
principal habilitada por la criptografía PK es la capacidad de encriptar datos masivos, sin establecer
claves secretas compartidas anteriores. Los algoritmos PK existentes tienen un alto nivel computacional
con relación a los algoritmos de claves secretas; esto los hace adecuados para la encriptación de
Página 119 de 164

grandes cantidades de datos. Para obtener las ventajas de la criptografía PK junto con la encriptación
eficaz masiva, normalmente se combinan las tecnologías PK y de claves secretas.
Proteger y confiar claves criptográficas: En la criptografía de claves secretas, los dos usuarios
confían en su clave secreta compartida porque la acordaron mutuamente o la intercambiaron en una
manera segura, y cada uno convino guardarla para evitar el acceso de una tercera parte mal
intencionada. En contraste, al utilizar la criptografía PK, cada persona sólo necesita proteger su propia
clave privada (independientemente).
Confianza y validación: Microsoft Certificate Services, que se incluyen con Windows 2000, proporciona
un medio para que una empresa establezca certificados de autenticidad (CA) con facilidad a fin de
soportar requerimientos empresariales. Los Servicios de certificación incluyen un módulo de políticas
predeterminadas que es adecuado para emitir certificados destinados a entidades empresariales. Esto
incluye identificación de la entidad solicitante y validación de que el certificado solicitado está permitido
bajo la política de seguridad PK de dominio; puede modificarse fácilmente o mejorarse para cubrir otras
consideraciones de políticas o ampliar el soporte CA para varios escenarios de extranet o internet.
Jerarquías de certificación: Windows 2000 PKI supone un modelo CA jerárquico. Éste fue elegido por
su capacidad de escalabilidad, facilidad de administración y consistencia con un creciente número de
productos CA comerciales y de terceros. En su forma más simple, una jerarquía CA consta de una sola
CA, a pesar de que en general una jerarquía contiene múltiples CA con relaciones principales y
secundarias claramente definidas. De hecho puede haber varias jerarquías de interés sin conectar; no
existe un requerimiento de que todas las CA compartan una CA principal común de nivel superior (o
raíz).
En este modelo, los componentes secundarios son avalados por certificados emitidos por una CA
principal, que une una clave pública de CA a su identidad y a otros atributos manejados por políticas. La
CA en la parte superior de una jerarquía se conoce generalmente como una raíz CA. Las CA
subordinadas se conocen a menudo como CAs intermedias o emisoras.
En un mundo ideal, PKI sería una infraestructura. Las CA emitirían un paquete de certificados
completamente interoperables basados en un protocolo estándar de solicitud de certificados. Entonces,
las aplicaciones los evaluarían en una manera consistente (incluso si han sido revocados), y no habría
ambigüedad en la interpretación de sintaxis o gramática en ninguna parte del proceso.
Página 120 de 164

Sistema O perat ivo Linux
Para comprender Linux, se debe primero la pregunta “¿Qué el Unix?”. La razón

es que Linux es un proyecto iniciado para crear una versión de trabajo de Unix en
máquinas basadas en Intel, más conocidas como ordenadores IBM PC o
compatibles.
Lo que realmente se entiende por el término de Linux es el Kernel, el corazón de cualquier sistema
operativo tipo Unix. Pero el Kernel por si solo no forma todavía un sistema operativo. Justamente para
Unix existe una multitud de software libre, lo que significa que estos están también disponibles para
Linux. Son estas utilidades las que realmente forman el sistema operativo. Todo se complementa con
XFREE86tm que es el sistema X Window para sistemas Unix a base de PC. Todos estos componentes,
junto a otros programas o también juegos, forman el sistema que generalmente se denomina Linux.
Por su naturaleza, Linux se distribuye libremente y puede ser obtenido y utilizado sin restricciones por
cualquier persona, organización o empresa que así lo desee, sin necesidad de que tenga que firmar
ningún documento ni inscribirse como usuario. Por todo ello, es muy difícil establecer quiénes son los
principales usuarios de Linux. No obstante, se sabe que actualmente Linux está siendo utilizado
ampliamente en soportar servicios en Internet, lo utilizan Centros de Educación alrededor del todo el
mundo para sus redes y sus clases, lo utilizan empresas productoras de equipamiento industrial para
vender como software de apoyo a su maquinaria, lo utilizan cadenas de supermercados, estaciones de
servicio y muchas instituciones del gobierno y militares de varios países. Obviamente, también es
utilizado por miles de usuarios en sus computadores personales. El apoyo más grande, sin duda, ha sido
Internet ya que a través de ella se ha podido demostrar que se puede crear un sistema operativo para
todos los usuarios sin la necesidad de fines lucrativos.
El sistema Linux es compatible con ciertos estándares de Unix a nivel de código fuente, incluyendo el
IEEE POSIX.1, System V y BSD. Fue desarrollado buscando la portabilidad de las fuentes: todo el software
gratuito desarrollado para Unix se compila en Linux sin problemas. Y todo lo que se hace para Linux
(código del núcleo, drivers, librerías y programas de usuario) es de libre distribución.
En Linux también se implementa el control de trabajos POSIX (que se usa en los shells csh y bash), las
pseudoterminales (dispositivos pty), y teclados nacionales mediante manejadores de teclado cargables
dinámicamente. Además, soporta consolas virtuales, lo que permite tener más de una sesión abierta en
la consola de texto y conmutar entre ellas fácilmente.
Linux soporta diversos sistemas de archivos para guardar los datos. Algunos de ellos, como el ext2fs, han
sido desarrollados específicamente para Linux.
Linux implementa todo lo necesario para trabajar en red con TCP/IP. Desde manejadores para las
tarjetas de red más populares hasta SLIP/PPP, que permiten acceder a una red TCP/IP por el puerto
serie. También se implementan PLIP (para comunicarse por el puerto de la impresora) y NFS (para
acceso remoto a ficheros). Y también se han portado los clientes de TCP/IP, como FTP, telnet, NNTP y
SMTP.
Esta es la mascota oficial de Linux, que fue elegida por el creador de Linux para representar el sistema
operativo que el había creado. Hoy en día todo el mundo asocia a este simpático pingüino con el sistema
operativo.
¿Por Qué Utilizar Linux?
Si se posee un computador, se debe tener un sistema operativo, el cual es un conjunto complejo de

códigos informáticos que proporcionan los protocolos de proceso operativo, o leyes de comportamiento.
Sin un sistema operativo, el ordenador está inactivo, es incapaz de interpretar y actuar sobre los
comandos introducidos o de ejecutar un programa sencillo. Los programas de aplicaciones son paquetes
de software que adquiere para realizar determinadas actividades, como por ejemplo el procesador de
textos. Cada paquete esta escrito para un sistema operativo y una máquina determinada.
Página 121 de 164

Como en el caso de los sistemas operativos, el usuario no tendrá control sobre como efectuar
modificaciones o cuando se efectúan actualizaciones. Se deseará utilizar Linux porque es el único
sistema operativo que en la actualidad está libremente disponible para proporcionar posibilidades
multitarea y multiproceso para múltiples usuarios en plataformas de hardware IBM PC o compatible.
Ningún otro sistema operativo le ofrece las mismas características con la potencia de Linux, a la vez que
le mantiene al margen de los caprichos de marketing de los distintos proveedores comerciales. No esta
obligado a actualizarse cada poco tiempo y a pagar sumas considerables para actualizar todas sus
aplicaciones. Muchas aplicaciones para Linux están disponibles de forma gratuita en Internet, al igual
que el propio código de Linux. Así pues tiene acceso al código fuente para modificar y ampliar el sistema
operativo para adaptarlo a sus necesidades algo que es imposible hacer con otros sistemas operativos.
Un grave inconveniente de Linux que se debe tener en cuenta es que ningún proveedor comercial lo
apoya por lo que la obtención de ayuda no se soluciona mediante una simple llamada telefónica. Linux
puede ser que en algún determinado hardware no se ejecute correctamente o dañe archivos que residan
actualmente en su sistema.
Sin embargo, Linux se comporta de forma muy estable en muchos sistemas, lo que ofrece una
oportunidad económica de aprender y utilizar uno de los sistemas operativos más populares del mundo.
Descripción De Las Funciones De Linux
Las ventajas que se derivan de la utilización de Linux parten de su potencia y flexibilidad. Son el
resultado de muchas funciones incorporadas en el sistema, listo para lo que se pueda utilizar en cuanto
se encienda la máquina.
Multitarea
La palabra multitarea describe la capacidad de ejecutar muchos programas al mismo tiempo sin detener
la ejecución de cada aplicación. Se le denomina multitarea prioritaria porque cada programa tiene
garantizada la oportunidad de ejecutarse, y se ejecuta hasta que el sistema operativo da prioridad a otro
programa para que se ejecute. Linux consigue el proceso de prioridad supervisando los procesos que
esperan para ejecutarse, así como los que están ejecutándose. El sistema programa entonces cada
proceso para que disponga de las mismas oportunidades de acceso al microprocesador.
Otra de las características referentes a este tema es que Linux es multiplataforma. Fue diseñada para
plataforma Intel pero ha sido fácilmente exportado a diversos tipos de sistema.
Multiusuario
La capacidad de Linux para asignar el tiempo de microprocesador simultáneamente a varias
aplicaciones ha derivado en la posibilidad de ofrecer servicios a diversos usuarios a la vez, ejecutando
cada uno de ellos una o más aplicaciones a la vez. Más de una persona puede trabajar con la misma
versión de la misma aplicación al mismo tiempo. No se debe confundir esto con el hecho de que
muchos usuarios puedan actualizar el mismo archivo simultáneamente.
Shells Programables
El shell programable es otra característica que hace que el sistema operativo sea el más flexible de los
existentes. Un shell es como el command.com de MS-DOS, es decir, un intérprete de comandos. Es
básicamente la interfaz, el modo de comunicación, entre el usuario y el sistema.
El shell de Linux explora cada línea de comandos para determinar si su formación y deletreado son
coherentes con sus protocolos. El proceso de exploración del shell se denomina análisis. Un shell
funciona como interprete entre el usuario y el kernel (cerebro o corazón del sistema operativo), la
diferencia entre los diferentes shell que puedan existir radica en la síntesis de la línea de comandos.
Cada usuario de un sistema Linux tiene su propia interfaz de usuario o Shell. Los usuarios pueden
personalizar sus shells adecuándolos a sus propias necesidades específicas. Así, el Shell de un usuario
funciona más como un entorno operativo que el usuario puede controlar.
Página 122 de 164
Linux permite la utilización de distintos tipos de shell programables. Cada shell tiene sus características
propias. La principal diferencia que existe entre los distintos tipos de shell radica en la sintaxis de la línea
de comandos. No es necesario aprender a programar con todos los tipos de shell ya que sabiendo uno
se conocerán todos, así que es mucho más sencillo de lo que parece. Concluyendo se puede decir que
un shell conecta las ordenes de un usuario con el Kernel de Linux y al ser programables se puede
modificar para adaptarlo a tus necesidades.
Independencia De Dispositivos Bajo Unix

A simple vista, quizás no parezca importante que los periféricos de su sistema informático puedan
funcionar de forma autónoma o independiente. Sin embargo, desde el punto de vista del entorno Unix
multiusuario se convierte en un factor decisivo en un lugar de trabajo productivo. Hasta hace poco, los
sistemas informáticos generalmente sólo podían admitir periféricos como impresoras, terminales,
unidades de disco y módems. Poco a poco se han ido añadiendo un número de dispositivos demasiado
elevados. El problema comienza cuando el usuario no puede utilizar un periférico porque un sistema
operativo no puede acceder a él. Unix evita los problemas que supone agregar nuevos dispositivos
contemplando cada periférico como un archivo aparte. Cada vez que se necesitan nuevos dispositivos el
administrador del sistema añade al kernel el enlace necesario denominado controlador de dispositivo, el
cual garantiza que el kernel y el nuevo dispositivo se fusionan del mismo modo cada vez que se solicita
el servicio del dispositivo.
Independencia De Dispositivos Bajo Linux

Linux comparte muchas de las mismas ventajas de Unix en cuanto a independencia de los dispositivos.
Por lo que Linux también posee un kernel adaptable y cuantos más programadores participen en el
proyecto de Linux, más dispositivos de hardware se añadirán a los distintos kernels y distribuciones de
Linux, en última instancia como se dispone del código fuente el usuario puede modificar el kernel para
que trabaje con los nuevos dispositivos.
Comunicaciones Y Redes
Ningún otro sistema operativo incluye unas posibilidades de conexión en red tan amplias y flexibles. Con
Linux ofrece total acceso a Internet ya que el mismo nació y es creado en Internet, permite comunicar
instantáneamente con el mundo y realizar todo tipo de operaciones como hablar con otro usuario,
transferir archivos, mandar e-mail, etc. Linux dispone de varios protocolos como PPP, SLIP, TCP/IP,
PLIP, etc. Posee gran variedad de comandos para comunicación interna entre usuarios que se
encuentren ubicados en plataformas distintas (gracias a utilidades como telnet).
Un universo de posibilidades de comunicación a recopilar las distintas aplicaciones escritas para Linux y
ponerlas en uno u otro formato, con diferentes facilidades de instalación, mantenimiento y configuración.
La licencia garantiza la libre distribución de las aplicaciones, pero las empresas pueden cobrar por el
trabajo de agrupar un determinado conjunto de esas aplicaciones y hacer más sencilla su instalación. Lo
único que no varía para nadie es el núcleo del sistema, que se desarrolla de forma coordinada y con
actualizaciones sistemáticas. Es por ello que antes de instalar Linux se ha de elegir qué distribución
interesa más.
Linux no sacrifica en ningún momento la creatividad, tal y como lo hacen algunas compañías
informáticas. Linux es una ventana abierta por la que es posible huir hacia un mundo donde la verdadera
informática puede ser disfrutada sin límites ni monopolios.
Linux es distribuido mediante una serie de distribuciones (como RedHat, Slackware y Debian) las cuales
se diferencian por su método de instalación y por los paquetes (software) que viene incluido. Todo el
software de Linux está regido por la licencia de GNU, con la cual cualquier persona puede modificar un
programa y venderlo según el desee, con la condición que la persona que compra ese producto puede
realizar la misma acción o simplemente hacer copias para todos aquellos que lo quieran sin tener que
pagar más. Esta licencia es la garantía que afirma la absoluta libertad de este sistema operativo.
Página 123 de 164

Portabilidad De Sistemas Abiertos
El impulso por la estandarización de Unix no ha pasado desapercibido, este impulso se deriva de sus
muchas variaciones disponibles actualmente. Se han dedicado grandes esfuerzos a combinar,
compaginar, y unir todas les versiones de Unix en una única versión del sistema operativo que lo
englobe todo. Aunque estos esfuerzos han caído en saco roto. Sin embargo, la existencia continuada de
variaciones de Unix no es motivo suficiente de alarma, ya que todas son esencialmente superiores a los
restantes sistemas operativos disponibles en la actualidad.
Linux Es Seguro
El concepto de seguridad en redes de ordenadores es siempre relativo. Un sistema puede ser seguro
para un determinado tipo de actividades e inseguro para otras. Por ejemplo, no sería recomendable
guardar secretos de estado en un sistema Linux al que pudiera acceder mucha gente y careciese de un
administrador dedicado absolutamente a la tarea ya que, según los hackers, no hay sistema cuya
seguridad sea perfecta. El sistema de contraseñas que protege el acceso al sistema se basa en el
algoritmo DES, el más probado de los algoritmos de seguridad. Pero claro, por muy bueno que sea el
algoritmo, si después permitimos a sus usuarios poner como contraseña su nombre de usuario, de nada
servirá la contraseña y todos sus esfuerzos.
Si se quiere que el sistema sea seguro, se debe administrar de tal forma que se tengan controlados a los
usuarios en todo momento, para poder aconsejarles e incluso regañarles, en caso de que cometan
alguna imprudencia, todo ello con el fin de mantener la propia seguridad de sus datos y de los nuestros.
Para ayudarse a mantener la seguridad surgen nuevas herramientas constantemente, tanto para
detectar intrusos como para encontrar fallos en el sistema y evitar así ataques desde el exterior.
¿Qué Se Puede Hacer Con Linux?
Las áreas de aplicabilidad de Linux son varias. En sus inicios fue muy utilizado por personas
relacionadas con ciencias de la computación, desde hace algunos años ha sido también adoptado en
instalaciones científicas de diversa índole (física, biología, ciencias espaciales y otras). Son de particular
interés los proyectos en el área de computación de alto rendimiento, donde Linux se está utilizando
intensiva y extensivamente.
Recientemente, también muchas compañías grandes han introducido soporte para Linux en su línea de
productos. Un caso ejemplar es Corel, desarrolladores del popular programa de oficina WordPerfect,
quienes han venido trabajando de cerca con la comunidad de Linux y ofrecen una versión de
WordPerfect en forma gratuita para uso personal. Además de WordPerfect hay otros programas de
oficina disponibles para Linux, pero haciendo honor a la verdad, las aplicaciones de escritorio son un
área con poco desarrollo en este ambiente. Otras compañías internacionales que utilizan y desarrollan
productos para Linux incluyen a IBM, Netscape, Oracle, HP y Dell.
Distribuciones
En sí, Linux es sólo el núcleo del sistema operativo, pero necesita aplicaciones y programas para hacer
algo. Muchos han sido portados a Linux, otros han sido creados específicamente para Linux, todos ellos
se encuentran en Internet dispuestos a que cualquiera los baje y los instale en su sistema.
Como esto es una ardua tarea no tardan en surgir compañías dedicadas a reunir todos esos programas
facilitando la tarea de crear un sistema Linux funcional. En la actualidad existe un sin número de estas
compañías pero sólo se mencionarán las mas importantes dentro del contexto mundial: Slackware,
Debian, SuSe, Caldera, Mandrake, Red Hat.
Slackware
Una de las primeras distribuciones que surgió fue Slackware (http://www.slackware.com), diseñada por
Patrick Volkerding a partir de SLS Linux. Esta tuvo una gran aceptación al principio hasta llegar a ser la
Página 124 de 164

distribución más popular del mercado. Actualmente ha perdido terreno a favor de distribuciones más
modernas, siendo relegada a aplicaciones especializadas. Una de las debilidades de Slackware se
encuentra en el sistema de instalación de paquetes, el cual no tiene control de versiones ni
dependencias. Las nuevas distribuciones han implementado y adoptado dos sistemas de instalación de
archivos RPM (RedHat Package Manager) y DEB (Debian Package Manager). Cada programa
distribuido de esta forma es un archivo comprimido, que se identifica por la extensión rpm o deb y
proporciona una descripción de lo que contiene, la versión del programa, su ubicación en el sistema,
validez de la firma electrónica y las dependencias con otros programas o librerías; por ejemplo, un
determinado paquete puede necesitar de otro para su correcto funcionamiento, por lo que se dice que es
dependiente del otro. De esta forma, se garantiza el éxito del proceso de instalación de una aplicación y
la estabilidad a largo plazo del sistema.
Debian
Debian (http://www.debian.org) es una distribución bastante popular que no está desarrollada por
ninguna compañía comercial sino que es fruto del trabajo de diversos voluntarios en toda la comunidad
de Internet. Es, por lo tanto, una distribución completamente gratis, sin restricción de licencias en donde
todo el software es GNU/GPL y no incluye software comercial. Además, es bastante completa y estable
gracias a su sistema de instalación de paquetes DEB. Sin embargo, tal vez sea algo difícil para alguien
que empieza por primera vez con Linux. Esto no quiere decir que si es la primera vez que se va a
instalar Linux y se tiene una Debian a mano va a ser casi imposible instalarla. Es importante mencionar
que Debian también ofrece una versión de su distribución basado en otro kernel diferente a Linux: GNU
Hurd.
SuSE
SuSE (http://www.suse.de) es una distribución de una compañía alemana la cual combina el sistema de
paquetes de Red Hat (RPM) con una organización derivada de Slackware. Esta distribución es la más
popular en Europa y tiene un gran soporte para diferentes lenguas incluido el español. Es una de las
más fáciles de instalar y configurar, además viene con una gran cantidad de paquetes: 1300 en la
versión 6.2 lo que implica una instalación completa de alrededor de 5.3 Gbytes en disco duro.
Caldera
Una compañía norteamericana llamada Caldera (http://www.calderasystems.com) ha creado su propia

distribución llamada OpenLinux, basada también en el sistema de paquetes de Red Hat, con un sistema
de instalación muy amigable llamada Lizard (Linux Wizard). Es una distribución pensada para entornos
comerciales, la cual incluye paquetes comerciales como las aplicaciones de oficina Aplixware y Corel
WordPerfect. Esta compañía ostenta asociaciones con empresas tan importantes como Novell e IBM.
Mandrake
Mandrake (http://www.linux-mandrake.com) surge originalmente como un clon de Red Hat el cual

incorporaba las bondades del ambiente integrado KDE con la estabilidad e instalación de Red Hat. Hoy
en día es considerada una de las distribuciones más vendidas en el mundo
Red Hat
Red Hat (http://www.redhat.com) es la distribución más popular del mercado hoy en día, siendo emulada
por muchas otras. Muy sencilla de instalar, excelente auto-detección de dispositivos, instalador gráfico
(6.1) y un excelente conjunto de aplicaciones comerciales en su distribución oficial.
Aparte de estas distribuciones existen otras no tan conocidas como: Mcc Interin Linux, Tamu Linux, Lst,
Sls y The Linux Quartely CD-ROM (entre otras).
Página 125 de 164

PREG UNT AS Y P RO BLE MAS RES UELT OS
Unidades I, II, III & IV:
Preguntas De Selección Múltiple
1. En el contexto de la evolución histórica de los sistemas informáticos, los manejadores de dispositivos

aparecieron como una mejora de:
a. Los primeros sistemas.

b. Los sistemas de procesamiento en lotes sencillos.
c. Los sistemas de procesamiento en lote sofisticados.
d. Los sistemas multiprogramados.
2. Los primeros sistemas operativos rudimentarios se crearon para que los ordenadores fueran más:
a. Fáciles de utilizar.
b. Productivos.
c. Seguros.
d. Interactivos.
3. El modo de operación denominado "fuera de línea" permite:
a. Simultanear operaciones de E/S de una tarea con operaciones de CPU de esa misma tarea.
b. Simultanear operaciones de E/S de una tarea con operaciones de CPU de otras en el mismo
sistema.
c. Reducir los tiempos de inactividad de la CPU debido a la lentitud de los dispositivos de E/S.
d. Todas las anteriores son falsas.
4. La técnica de buffering permite:
sistema.
5. La técnica de spooling permite:
sistema.
6. El tiempo de respuesta es un parámetro de especial importancia en un sistema:
a. Sistema de procesamiento en lotes.

b. Sistema multiprogramado.
c. Sistema de tiempo compartido.
d. En todos los sistemas anteriores posee la misma importancia.

7. Para procesar simultáneamente operaciones de CPU con operaciones de E/S se requieren:
a. Dispositivos rápidos de E/S.

b. Un reloj del sistema.
c. Interrupciones.
d. Instrucciones hardware especiales de protección.
8. El modelo "Cliente/Servidor" se utilizó en el diseño del sistema:
a. MSDOS.
b. UNIX
c. VMS.
d. WINDOWS-NT.
9. Un proceso cuando desea solicitar un servicio al sistema operativo lo hace mediante:
a. Una función o procedimiento.

b. Una llamada al sistema.
c. Un comando del sistema.
d. Una interrupción.
10. ¿Cuál de estos recursos es lógico?:
a. La memoria principal.
b. Una impresora.
c. Un archivo.
d. El procesador.
11. La secuenciación automática de tareas nació con:
a. Los primeros sistemas informáticos.

b. Los sistemas de procesamiento por lotes.
c. Los sistemas multiprogramados.
d. Los sistemas distribuidos.
12. El fenómeno de espera activa por operaciones de entrada/salida se puede evitar utilizando:
a. Interrupciones.
b. Instrucciones privilegiadas.
c. Acceso directo a memoria (DMA).
d. Un pareja de registros base y límite.
13. El modo dual de operación consigue que el sistema informático sea:
a. Más veloz.
b. Más fácil de usar.
c. Más seguro.
d. Ninguna de las anteriores.
14. En la planificación de procesos, el módulo que ocasionalmente mueve procesos de memoria hacia el
disco y viceversa se llama:
a. Planificador de alto nivel.

b. Planificador de medio nivel.
c. Planificador de bajo nivel.
d. Planificador de corto plazo.
Página 127 de 164

15. Sobre planificación de procesos, es cierto afirmar que:
a. En general es imposible planificar procesos según el algoritmo SJF.

b. Los métodos multicolas reparten proporcionalmente el tiempo disponible de CPU entre
varias colas de procesos.
c. El algoritmo FCFS perjudica a los procesos intensivos en E/S.
d. Los enunciados a, b y c son todos ciertos.
16. La multiprogramación implica necesariamente:
a. Concurrencia.
b. Paralelismo.
c. Procesamiento por lotes.
d. Tiempo compartido.
17. Respecto del núcleo del sistema operativo, es cierto afirmar que:
a. Es un proceso que se ejecuta en modo privilegiado.

b. Contiene el código del programa de usuario.
c. Contiene el código de los programas del sistema.
d. Reside de forma permanente en memoria principal.
18. Respecto de las llamadas al sistema, es correcto afirmar que:
a. Sólo se pueden ejecutar en modo privilegiado.

b. Ejecutan código perteneciente al núcleo.
c. (a) y (b) son ciertas.
19. El conjunto de datos donde se incluyen el estado de un proceso en cada momento, los recursos
utilizados por el proceso, los recursos y archivos que está utilizando el mismo, etc., se denomina:
a. Bloque de control de sistema.

b. Diagrama de estado de proceso.
c. Bloque de control de proceso.
d. Administrador de archivos.
e. Administrador del procesador.
20. Suponga un sistema que planifica procesos según un Round Robin. Cuando se crea un nuevo
proceso en el sistema, siempre ocurre que:
a. Disminuye el tiempo medio de espera.

b. Aumenta el número de cambios de contexto por unidad de tiempo.
c. Aumenta la utilización de CPU.
d. Se incrementa el tiempo medio de respuesta.
21. ¿Cuál de estos sistemas no puede darse jamás?:
a. Un sistema por lotes multiprogramado.

b. Un sistema multiprogramado y no multiusuario.
c. Un sistema de tiempo compartido no multiprogramado.
d. Un sistema no multiprogramado y multiusuario.
22. En un sistema multihilo, se puede afirmar que:
a. Los hilos de un mismo proceso pesado comparten el mismo código.

b. Los hilos de distintos procesos pesados comparten la misma pila.
c. Los hilos de un mismo proceso pesado comparten el mismo contador de programa.
Página 128 de 164
23. Cuando un proceso en modo usuario intenta ejecutar una instrucción privilegiada, ocurre:
a. Una interrupción.
b. Una excepción.
c. Una llamada al sistema.
d. Un avatar (un cambio).
24. El despachador es responsable de:
a. Decidir a qué proceso se asigna la CPU.

b. Decidir cuándo hay que desalojar al proceso que está en CPU.
c. Realizar los cambios de contexto entre procesos.
d. Mantener una mezcla adecuada de procesos intensivos en CPU y en E/S.
25. El modo dual de operación (dos procesadores) se adoptó para que el sistema informático fuese:
a. Más fácil de usar.

b. Más eficiente.
c. Más rápido.
d. Más seguro.
26. El llamado efecto convoy se produce cuando el procesador se planifica con una política:
a. FCFS.
b. SJF expulsivo.
c. SJF no expulsivo.
d. Round-Robin con un cuanto de tiempo muy pequeño.
27. ¿Cuál de estas transiciones de estados de un proceso jamás se produce en un sistema normal?:
a. De “bloqueado” a “preparado”.
b. De “preparado” a “bloqueado”.
c. De “bloqueado” a “en ejecución”.
d. De “en ejecución” a “bloqueado”.
28. ¿Qué ventaja aporta el uso de interrupciones en las operaciones de E/S frente a no usarlas?:
a. Aumenta la rapidez en las transferencias de datos.

b. Aumenta la fiabilidad en las transferencias de datos.
c. Contribuye a proteger la entrada/salida de accesos maliciosos.
d. Permite comprobar fácilmente la finalización de las operaciones de E/S.
29. El sistema que permite que el computador sea más interactiva disminuyendo el tiempo de respuesta,
se conoce como:
a. Multiproceso.
b. Spooling.
c. Timesharing.
d. Monitor residente.
e. Buffering.
30. El tiempo que los procesos están activos pero sin ser ejecutados se denomina:
a. Tiempo de respuesta.
b. Tiempo de servicio.
c. Tiempo de ejecución.
d. Tiempo de espera.
e. Ninguna de las anteriores.
Página 129 de 164

31. El tiempo consumido cuando un sistema operativo no tiene ningún tipo de carga (colas vacías)
corresponde a:
a. Tiempo medio de servicio.

b. Tiempo de núcleo.
c. Tiempo de inactividad.
d. Tiempo medio de espera.
e. Tiempo de respuesta.
32. El Concepto de Multiprogramación se refiere a que:
a. La CPU ejecuta las diversas tareas alternando entre ellas, optimizándose el uso de la CPU.
b. Los computadores se comunican a través de distintas líneas de comunicación, como líneas
telefónicas.
c. El procesamiento debe llevarse a cabo dentro de límites de tiempo o el sistema fallará.
d. Se tiene un proceso padre que delega funciones a otros procesos.
e. El procesador esta dedicado a mandar respuestas rápidas al usuario, sin importar el
comportamiento de los procesos en su interior.
33. La manipulación de archivos por parte del sistema operativo consiste en:
a. Guardar archivos en un dispositivo una vez que el programa efectúa una llamada para
grabarlo.
b. Leer un archivo desde un dispositivo de almacenamiento.
c. Asignar una ubicación física para el archivo una vez que es llevado a Memoria Virtual.
d. Todas las anteriores.
34. La función de un sistema operativo distribuido es:
a. Poder copiar una base de datos a cada uno de las estaciones de trabajo.
b. Tener un Servidor y Estaciones de trabajo.
c. Poder realizar una conexión en punto geográficos distantes.
d. Presentarse ante sus usuarios como un sistema uniprocesador tradicional, aunque este
compuesto de múltiples procesadores.
e. Todas las anteriores.
35. En la evolución de los sistemas operativos:
a. Aparece primero la Multiprogramación y luego el procesamiento por Lotes.

b. Aparece el concepto de Memoria Virtual y luego Multiprogramación.
c. Aparecen juntos Multiprogramación y Tiempo compartido.
d. Se trabajo siempre con un Multiprogramación.
e. Se trabajo primero con Procesamiento por Lotes (o Batch. hasta llegar a multiprogramación.
36. Una característica del sistema por Lotes es:
a. Acepta todo tipo de trabajos remotos.

b. La falta de interacción entre el usuario y el trabajo mientras este se ejecuta.
c. Los distintos recursos del sistema se aprovechan de manera activa.
d. Cada dispositivo se activa sólo cuando es requerido.
Página 130 de 164

37. La definición: “Conjunto de rutinas cuya misión es gestionar el procesador, la memoria y el resto de
recursos disponibles en la instalación”, corresponde a:
a. Proceso.
b. Sistema operativo.
c. Kernel.
d. Buffer.
38. Una característica fundamental de los sistemas operativos de tiempo real es que:
a. Los procesos sean reales sin importar el tiempo de ejecución de la operación.

b. Son compatibles con los sistemas de tiempo compartido.
c. Tiene restricciones de tiempo fijas bien definidas para ejecutar una operación.
d. Incrementa el rendimiento de la CPU.
e. Sólo a y d son correctas.
39. Las relaciones entre procesos del sistema operativo pueden ser:
a. Competición y expropiación.
b. Competición y cooperación.
c. Expropiación y suspensión.
d. Expropiación y cooperación.
40. La conexión de computadores entre si a través de una gran variedad de dispositivos, compartiendo
el mismo almacenamiento principal, se conoce como:
a. Multiprogramación.
b. Monoprogramación.
c. Proceso Distribuido.
d. Tiempo real.
e. Multiproceso.
41. La anomalía de Belady se produce en la política de asignación:
a. LRU.
b. LFU.
c. Óptimo.
d. FIFO.
42. La planificación por prioridad:
a. Consiste en asignar el procesador a los procesos de mayor prioridad.

b. Consiste en que los procesos tienen todos la misma prioridad.
c. Se usa sólo en los sistemas operativos multiusuarios.
d. Alternativas (a) y (c).
43. En general, una política de administración del procesador no apropiativa:
a. Asigna el procesador a los procesos por periodos fijos de tiempo.

b. Es indispensable para sistemas interactivos.
c. Tiende a que los trabajos cortos deban esperar por los trabajos largos.
d. Usa siempre una cola de procesos listos ordenados en prioridad decreciente.
Página 131 de 164

44. La política de planificación de CPU que toma de la cola de procesos preparados el que necesite
menos tiempo de ejecución para realizar su ejecución es:
a. FCFS (First Come First Served).

b. HRN (High Response Next).
c. SJF (Shortest Job First).
d. RR (Round Robin).
45. Un proceso en tiempo real debe ser ejecutado con:
a. Algoritmo SJF.
b. Algoritmo Round-Robin
c. Algoritmo por prioridad.
d. Algoritmo por prioridad o Algoritmo SJF.
e. Algoritmo por prioridad o Round-Robin.
Página 132 de 164

Preguntas De Términos Pareados
Caso 1
Columna A Columna B
1) Sistemas Batch __ Cambio de estado de un proceso.
2) SJF __ Almacena el estado general de un proceso cuando este no

está activo.
3) Tiempo Compartido
__ Ejecutan un conjunto de tareas sin la intervención de un
4) Transición usuario u operador.
5) PCB __ Planificación adecuada para procesamiento por lotes.
6) Proceso distribuido __ Varios usuarios o procesos compartiendo un Procesador.
7) Memoria RAM __ Medio de almacenamiento primario
8) Gestión de excepciones __ Es la conexión de computadores entre sí a través de una gran

variedad de dispositivos
9) Sistema operativo
__ Tratamiento de errores de un programa en ejecución.
10) Proceso
__ Programa que se instala en la memoria del computador en el
11) Monoprogramación momento de arranque, interpreta y codifica las ordenes del
usuario
12) Editor
__ Programa en ejecución con el entorno asociado (registros,
variables, etc).
Caso 2.
Columna A Columna B
1) Proceso en tiempo real __ Programa de control que reacciona ante cualquier interrupción
de eventos externos y da servicio a los procesos.
2) S.O. no corrige el error
__ Errores de Hardware.
3) Round Robin
__ Se le da un tiempo de ejecución a un proceso y vencido su
4) Cola de Procesos tiempo se le da el turno a otro.
5) Planificador de trabajos __ Existe cuando en estado Ready hay varios procesos en espera
por el Procesador.
6) Núcleo del sistema operativo
__ Requiere una respuesta inmediata. Se le asigna una alta
7) Política no apropiativa prioridad.
8) Interprete de comandos __ Programa que permite escribir o corregir archivos de texto,

generalmente programas fuente.
9) Compilador
__ Programa traductor de un lenguaje de alto nivel a código de
10) Editor maquina; efectúa un control previo de todo el programa.
11) DOS __ Programas encargados de crear el entorno de trabajo de los

usuarios.
12) Multiprogramación
__ Sistema operativo monousuario
__ Decide cual será el próximo trabajo que se va a ejecutar
Página 133 de 164

Preguntas De Desarrollo
1. ¿Tiene sentido un sistema monousuario que sea también multiprogramado?.
2. ¿Por qué el algoritmo FCFS (en orden de llegada) de planificación de procesos no es apropiado para
sistemas multiusuarios e interactivos?.
3. ¿Por qué la manipulación directa de la entrada/salida ha de ejecutarse en modo privilegiado?.
4. ¿Por qué es conveniente que el sistema operativo disponga de dos clases de procesos: procesos
pesados e hilos?.
5. ¿Por qué una duración muy baja del cuanto de tiempo en el algoritmo Round-Robin resulta
perjudicial para el rendimiento del sistema?.
7. Explique en qué es un “Intérprete de Comandos”.
8. Explique qué es la “Gestión de excepciones”.
9. Responda con brevedad y precisión a las siguientes preguntas:
a. ¿Qué ventajas tiene poder declarar hilos dentro de un proceso pesado?.
b. El intérprete de órdenes (command interpreter) puede ser una aplicación independiente (ej.
UNIX), o puede estar implementado dentro del núcleo del sistema operativo (ej. CP/M).
¿Qué ventajas o inconvenientes observa usted en cada alternativa?.
c. ¿Por qué es necesario establecer dos modos de ejecución (modo supervisor y modo
usuario)?.
d. ¿Qué diferencia hay entre las llamadas al sistema y los programas del sistema?.
e. Si un sistema no es multiusuario, ¿tampoco es multitarea?.
10. Se propone una nueva política de planificación de procesos, que consiste en ceder siempre la CPU
al proceso que menos memoria necesita.
a. ¿Esta política ofrece algún beneficio?.
b. ¿Y algún efecto negativo?.
c. ¿Es implementable?.
Página 134 de 164

Problemas
1. Para el conjunto de procesos indicados más abajo calcule el tiempo (de finalización) solicitado
usando las planificaciones FCFS y SJF.
Tiempo de Llegada (ut) Tiempos de CPU(ut)

0.5 16
1.0 8
1.5 14
2.0 12
2.5 4
NOTAS:
1.- Todos los procesos se encuentran inicialmente en cola listos para ser ejecutados.
2.- No existen interrupciones I/O por parte de los procesos.
3.- ut: Unidades de Tiempo
2. (A) Para cada uno de los procesos indicados más abajo calcule: tiempo de finalización, tiempo de
servicio y el índice de servicio.
Con planificación FCFS Con planificación SJF

Tiempo de Tiempo de Tiempo de Tiempo de Índice de Tiempo de Tiempo de Índice de
Llegada ejecución finalización servicio servicio finalización servicio servicio
0 3
2 2
4 4
6 5
8 1
PROMEDIOS
NOTAS:
1.- La atención de procesos comienza en el instante 0 (cero).
2.- No existen interrupciones I/O por parte de los procesos.
3.- Los tiempos están expresados en unidades lineales.
4.- Suponga que los tiempos están en segundos.
(B) Considerando los resultados obtenidos en (A) indique cuál de las planificaciones es más
eficiente (debe fundamentar)
3 Dada la siguiente carga de trabajo, obtener el diagrama de Gantt, el tiempo medio de retorno y el
tiempo medio de espera al aplicar las siguientes políticas de planificación:
a. Primero el más corto (SJF) con expropiación.

b. Round-Robin con cuanto de 3 u.t.
Proceso Tiempo de llegada Duración

P0 0 9
P1 2 5
P2 3 2
P3 5 4
4. Considere la siguiente carga de trabajo para un planificador de procesos. Los tiempos se miden en
unidades arbitrarias.
Proceso Tiempo de llegada Duración

P0 0 7
P1 2 4
P2 4 1
P3 5 3
Página 135 de 164

Para los algoritmos SRTF (primero el más corto expulsivo) y el Round-Robin con cuanto igual a 3
unidades de tiempo, se pide lo siguiente:
a) Confeccione los diagramas de Gantt de ambas políticas.

b) ¿En qué algoritmo se producen más cambios de contexto?
c) ¿Qué algoritmo proporciona un menor tiempo de espera medio?
d) ¿Qué algoritmo considera usted que hace un reparto más justo del procesador? Apoye sus
BFB
argumentos con cifras.
Página 136 de 164

Unidades V & VI:
1. Si en una solución al problema de la sección crítica un proceso puede verse impedido de acceder
a su sección crítica debido a que siempre hay otros procesos que entran antes que él, entonces no
se cumple:
a. La condición de progreso.
b. La condición de espera limitada.
c. La condición de exclusión mutua.
d. La condición de interbloqueo.
2. El concepto de paginación y sus componentes corresponden a:
a. Una técnica que recurre al uso de frame.

b. Una técnica de gestión de memoria de tamaño variable.
c. Un direccionamiento de memoria de forma lineal.
d. Una fragmentación interna de la memoria.
e. Una técnica de gestión de memoria que posee número de página y un desplazamiento de la
página.
3. La segmentación es una técnica que se utiliza para:
a. Solucionar los problemas que provoca la paginación.

b. Eliminar la fragmentación en el almacenamiento principal.
c. Distribuir el almacenamiento principal en segmentos de tamaño variable.
d. Sólo (a) y (c).
e. Sólo (a) y (b).
4. En un sistema con memoria virtual, el tamaño del espacio lógico de un proceso:
a. Debe ser exactamente igual que la memoria real disponible.

b. Debe ser menor que la memoria real disponible.
c. Debe ser mayor que la memoria real disponible.
d. Puede ser mayor que la memoria real disponible.
5. En el contexto del problema del interbloqueo un estado inseguro es:
a. Un estado donde siempre existe al menos una situación de interbloqueo.

b. Un estado donde los procesos esperan por recursos.
c. Un estado a partir del cual se puede llegar a una situación de interbloqueo.
d. Un estado donde no hay disponibilidades de recursos.
6. En el interbloqueo, la estrategia que puede dar lugar a una muy baja utilización de recursos es:
a. Estrategia liberal.
b. Estrategia de prevención.
c. Estrategia de detección y recuperación.
d. Estrategia de evitación.
Página 137 de 164

7. En la administración de memoria, la “estrategia del mejor ajuste” es aquella que:
a. Permita al proceso ubicarse en el hueco en el que quepa mejor en el almacenamiento

principal.
b. Permita al proceso o trabajo ubicarse en el primer hueco disponible lo bastante grande para
contenerlo en el almacenamiento principal.
c. Permita al proceso ubicarse ordenadamente en el almacenamiento principal.
d. Permita al proceso ubicarse en forma contigua en el almacenamiento principal.
8. Intercambiar páginas, segmentos o programas completos entre RAM y disco se conoce como:
a. Memoria real.
b. Particiones fijas.
c. Relocalización de memoria.
d. Particiones variables.
e. Intercambio o swapping.
9. La segmentación es una técnica que se utiliza para:
a. Solucionar los problemas que provoca la paginación.

b. Distribuir el almacenamiento principal en segmentos de tamaño variable.
c. Eliminar la fragmentación en el almacenamiento principal.
d. Sólo (a) y (c).
e. Sólo (a) y (b).
10. El algoritmo LRU es aquel que:
a. Reemplaza la página que no se usará durante más tiempo.

b. Reemplaza la página que tiene más tiempo sin usarse.
c. Asocia a cada página el instante en que se trajo a la memoria.
d. Considera la página más frecuentemente usada.
11. El concepto de paginación y sus componentes corresponden a:
a. Una técnica de gestión de memoria que posee número de página (p) y un desplazamiento
de la página (d).
b. Una técnica de gestión de memoria de tamaño variable.
c. Una técnica que recurre al uso de frame.
d. Un direccionamiento de memoria de forma lineal.
e. Una fragmentación interna de la memoria.
12. Para solucionar el problema de las colas de espera en las particiones contiguas de tamaño fijo,
cual de los siguientes algoritmos son utilizados:
a. Best Fit, SJN, FIFO.

b. FIFO, Worst Fit, First Fit.
c. First Fit, LRU, Best Fit.
d. FIFO, Best Fit, First Fit.
e. Best Fit, LRU.
13. En el contexto de “sistemas combinados”, cual de las siguientes afirmaciones es INCORRECTA:
a. Paginación segmentada y segmentación paginada son sinónimos.

b. Los sistemas combinados aprovechan las ventajas de la paginación y la segmentación.
c. Segmentación implica asignación de espacios variables de memoria.
d. Los sistemas combinados segmentan la tabla de página.
e. Los sistemas combinados paginan los segmentos.
Página 138 de 164
14 ¿Qué tipo de planificador está íntimamente ligado con la gestión de la memoria?:
a. Planificador de bajo nivel.

b. Planificador de medio nivel.
c. Planificador de alto nivel.
15. La compactación es:
a. La eliminación de áreas de memoria desocupadas.

b. La eliminación de algunos jobs en proceso.
c. La reubicación de áreas de memoria desocupadas.
d. La distribución de memoria, para convertir todas las áreas libres en un espacio contiguo.
16. En el interbloqueo, la estrategia que requiere declarar por adelantado los recursos máximos
necesarios es:
b. Estrategia de prevención negando la condición de espera circular.
d. Estrategia de evitación mediante el algoritmo del banquero.
17. Respecto de los semáforos, es correcto afirmar que:
a. Eliminan el problema del interbloqueo.

b. Son más potentes que las regiones críticas condicionales.
c. Tienen dos operaciones públicas (wait y signal).
d. Todas las ant eriores son ciertas.
18. Respecto del algoritmo de reemplazo FIFO, indique cuál de las siguientes afirmaciones es FALSA:
a. Cuando se sustituye una página se elige la que lleva menos tiempo en memoria principal.
b. Cuando se sustituye una página se elige la que lleva más tiempo en memoria principal.
c. Para controlar el tiempo de permanencia, se utiliza una cola de espera.
d. La página que está primera en la cola de espera es la que lleva más tiempo cargada.
19. La anomalía de Belady se produce en la política de asignación:
a. LRU.
b. Óptimo.
c. FIFO.
d. NRU.
20. En la administración de memoria, la “estrategia del mejor ajuste” es aquella que:
a. Permita al proceso o trabajo ubicarse en el primer hueco disponible lo bastante grande para
contenerlo en el almacenamiento principal.
b. Permita al proceso ubicarse en el espacio en el que quepa mejor en el almacenamiento
principal.
c. Permita al proceso ubicarse en forma contigua en el almacenamiento principal.
d. Permita al proceso ubicarse ordenadamente en el almacenamiento principal.
Página 139 de 164

21. ¿Cuál de los siguientes métodos de gestión de memoria no tiene fragmentación externa?:
a. Particiones fijas.
b. Paginación.
c. Particiones variables.
d. Segmentación.
e. Ningún método tiene fragmentación externa.
22. En un sistema de paginación por demanda, ¿cuál de estas operaciones corre a cargo del
hardware?:
a. Traducción de dirección lógica a dirección física.

b. Aplicación de la política de reemplazo de páginas.
c. Confección de la tabla de páginas.
d. Colocar el valor adecuado en el bit de validez.
23. Cuando un proceso obtiene acceso a datos compartidos modificables se dice que se encuentra en:
a. Un semáforo.
b. Un monitor.
c. Un segmento.
d. Una sección crítica.
e. Una página.
24. Para tratar el interbloqueo por el sistema operativo, la estrategia más costosa de ejecutar es:
b. Estrategia de prevención.
d. Estrategia de evitación.
25. La reasignación de direcciones estáticas se realiza durante:
a. El arranque del equipo.

b. La ejecución de un Programa.
c. El arranque del sistema operativo.
d. La compilación o carga del programa en memoria.
Página 140 de 164

Preguntas de términos pareados
Caso N° 1
COLUMNA A COLUMNA B
1.- Partición variable __ Técnica que combina hardware y software permitiendo la

ejecución de programas parcialmente cargados en memoria
2.- Memoria virtual real
3.- Fragmentación externa __ Técnica que asigna dinámicamente la memoria a los trabajos
de acuerdo a su tamaño
4.- Algoritmo del peor ajuste
__ Es una dirección de memoria relocalizable
5.- Sistemas combinados
__ La memoria libre en el sistema que no puede ser asignada a
6.- Partición fija ningún proceso
__ Gestión de memoria con particiones continuas de tamaño fijo
__ Forma de aprovechar los conceptos de la división lógica de los

programas con la granularidad de las páginas
__ Estrategia que permite determinar el tamaño de una página
__ El proceso es asignado a la partición más grande de la

memoria
Caso N° 2
COLUMNA A COLUMNA B
1.- Sistemas combinados __ El proceso es asignado a la partición más grande de la

memoria
2.- Memoria virtual
__ Forma de aprovechar los conceptos de la división lógica de los
3.- Partición fija programas con la granularidad de las páginas
4.- Partición variable __ Consiste en reemplazar la página más vieja
5.- Fragmentación externa __ Gestión de memoria con particiones continuas de tamaño fijo
6.- Algoritmo del peor ajuste __ La memoria libre en el sistema que no puede ser asignada a
ningún proceso
__ Es la traducción de memoria lógica a física
__ Técnica que asigna dinámicamente la memoria a los trabajos

__ Técnica que combina hardware y software permitiendo la

real
Página 141 de 164

1. Explique qué funciones realiza el MONITOR RESIDENTE.
2. Con las particiones variables de memoria se logra un mejor aprovechamiento de la memoria que con
las particiones fijas. ¿Cuál es el inconveniente que genera este sistema (particiones variables)?.
3. Explique en qué consiste el Swapping.
4. Explique que pasa con la ejecución de un programa al encontrar una estructura de control ParBegin /
ParEnd.
5. Explique en qué consiste la anomalía de Belady.
6. Explique qué son los semáforos.
7. Explique qué es un deadlock.
Página 142 de 164

Problemas
1. Dada la siguiente cadena referencial:
1 6 1 2 1 0 4 7 0 3 7 4 5 3 3 5 1 1 6 1
Utilizando el algoritmo LRU determine:
· El número de fallas de páginas.

· El número de referencias a páginas que ya están en memoria.
· La página más utilizada.
· La página menos utilizada.
NOTA: Asuma que dispone de CUATRO marcos de página; todos inicialmente VACIOS.
2. Dada la siguiente cadena referencial:
1 1 1 2 1 0 4 7 0 3 7 4 5 2 3 5 1 0 6 1
Utilizando el algoritmo FIFO determine:
· El número de fallas de páginas.

· El número de referencias a páginas que ya están en memoria.
· La página más utilizada.
· La página menos utilizada.
NOTA: Asuma que dispone de CUATRO marcos de página; todos inicialmente VACIOS.
3. Se tiene un sistema concurrente con una capacidad de memoria de N bytes. Cada proceso del
sistema, para poder ejecutarse, debe reservar previamente un número de bytes. Si no hay cantidad
suficiente de memoria, debe quedarse bloqueado hasta que otros procesos vayan liberando
memoria suficiente. La ejecución del proceso debe estar regulada mediante un monitor, como se
muestra a continuación:
monitor.reserva (nbytes);
… se ejecuta el proceso …
monitor.devuelve (nbytes);
Implemente las operaciones de este monitor. Para escribir su solución, puede usar un monitor
clásico o bien cerrojos y variables condición.
4. A continuación se muestra la implementación de los semáforos en C:
void Semaphore::P() { void Semaphore::V() {

IntStatus oldLevel = interrupt- Thread *thread;
>SetLevel(IntOff); IntStatus oldLevel = interrupt->SetLevel(IntOff);
while (value == 0) { thread = (Thread *)queue->Remove();
queue->Append((void *)currentThread); if (thread != NULL)
currentThread->Sleep(); scheduler->ReadyToRun(thread);
} value++;
value--; (void) interrupt ->SetLevel(oldLevel);
(void) interrupt ->SetLevel(oldLevel); }
}
a) ¿Qué significa el ReadyToRun() de la operación V()?
Página 143 de 164

b) ¿Qué tipo de cola es el atributo queue? ¿FIFO? ¿LIFO? ¿con prioridad?
c) ¿La implementación de los semáforos en Nachos utiliza espera activa?
d) ¿Por qué hace falta un while en la implementación de la operación P()? ¿No puede sustituirse
por un if?
5. El siguiente algoritmo pretende solucionar el problema de la sección crítica para dos procesos, P0 y
P1. Demuestre si el algoritmo es o no es correcto.
El algoritmo usa un vector global “flag”, declarado de la siguiente forma:
flag : array(0..1) of boolean := (false,false);
i y j son dos constantes cuyos valores dependen del proceso que ejecuta el algoritmo, según esta
tabla:
i j
P0 0 1
P1 1 0
Algoritmo:
1 loop
2 flag(i) := true;
3 while flag(j) {
4 flag(i) := false;
5 while flag(j) { NADA; }
6 flag(i) := true;
7 };
8 ... sección crítica ...
9 flag(i) := false;
10 ... sección no crítica ...
11 end loop;
6. Dada la siguiente propuesta de solución al problema de la sección crítica para 2 procesos (proceso 0
y proceso 1). ¿Es correcta?. Justifique su respuesta.
Var Flag: array[0..1] of boolean;
Repeat
While Flag[j] do no-op;
Flag[i] = true;
Sección crítica
Flag[i] = false;
Until false;
Inicialmente Flag[0] = Flag[1] = false.
La variable "i" identifica al proceso que quiere entrar en la sección crítica y la variable "j" al otro
proceso, cumpliéndose j = i – 1.
7. Utilizando sólo regiones críticas condicionales, resolver el problema de los Productores-

Consumidores con buffer finito (también conocido como problema del buffer limitado).
Página 144 de 164

Unidades VII, V III & IX:
1 Linux es un sistema operativo:
a. Por lotes.
b. De tiempo compartido.
c. De tiempo real.
d. Distribuido.
2. En el contexto de los dominios de protección, ¿cuál de las siguientes afirmaciones es falsa?:
a. Un dominio es una colección de derechos de acceso.

b. Los dominios pueden compartir derechos de acceso.
c. Los elementos de un sistema se categorizar como “procesos” y “objetos”.
d. Los procesos pueden compartir derechos de acceso.
e. Un derecho de acceso es un par ordenado [“nombre_de_objeto”, “conjunto_de_derechos"]
3. La función de un sistema operativo distribuido es:
a. Poder copiar una base de datos a cada uno de las estaciones de trabajo.
b. Poder realizar una conexión en punto geográficos distantes.
c. Presentarse como un sistema uniprocesador tradicional, aunque este compuesto de
múltiples procesadores.
d. Tener un Servidor y Estaciones de trabajo.
4. El sistema operativo Windows NT:
a. Puede trabajar con sistemas de archivos FAT.

b. Puede trabajar con sistema NTFS.
c. Es un sistema operativo Multiusuario.
d. Tiene una arquitectura Cliente/Servidor.
5. Un dominio de protección es:
a. Es una matriz que indica las restricciones de un usuario sobre un objeto.

b. Conjunto de pares (usuario, objeto) donde cada par identifica las operaciones permitidas
sobre él.
c. Un conjunto de pares (objeto, operaciones) en el que cada par identifica un objeto y las
operaciones permitidas sobre él.
d. Alternativas (a) y (c)
6. Al hablar de seguridad externa, se hace referencia explicita a:
a. Seguridad de datos.
b. Sistemas de protección
c. Seguridad física o lógica.
d. Seguridad física y de administración.
e. Ninguna de las anteriores
Página 145 de 164

7. La SEGURIDAD se diferencia de la PROTECCIÓN en que:
a. La primera se refiere a seguridad física y la segunda a seguridad lógica.

b. La seguridad comprende la información estratégica y protección los datos de cualquier
usuario.
c. Seguridad esta relacionada con las políticas definidas y la protección con los mecanismos
a implementar para llevar a cabo esas políticas.
d. Alternativas (a) y (b).
8. ¿Cuál de las siguientes afirmaciones NO es correcta?:
a. La seguridad interna considera la seguridad del procesador.

b. La seguridad interna considera la seguridad de la memoria.
c. La seguridad interna considera la seguridad de los archivos.
d. La seguridad interna es controlada por el propio sistema operativo.
e. La seguridad interna considera la integridad de la transmisión de los datos.
9. El proceso al que hay que someter la información para conseguir que sea secreta se denomina:
a. Username.
b. Password.
c. Encapsulado.
d. Compactación.
e. Encriptado.
10. ¿Cuál de las siguientes afirmaciones NO es correcta?:
a. Una estrategia para el acceso a los recursos como, archivos o directorios, es tener
identidades para el usuario.
b. Al conjunto de usuarios que comparten recursos y necesitan acceso similar es llamado
grupo.
c. Por lo general, los usuarios de un grupo sólo son creados y modificados por el
administrador del sistema.
d. Los tipos de usuarios sólo se clasifican en dueños y grupos.
11. Un sistema operativo de red:
a. Se caracteriza porque su estructura interna está orientada a objetos.

b. Se caracteriza porque comparte unos pocos recursos, normalmente discos e impresoras, a
través de una red con otras máquinas conectadas entre sí.
c. Almacena el archivo de contraseñas en un archivo encriptado con un algoritmo de triple
clave pseudoaletoria.
d. Todas las anteriores.
12. Al hablar de seguridad externa, se hace referencia explicita a:
a. Seguridad de datos.
b. Sistemas de protección
c. Seguridad física o lógica.
d. Seguridad física y de administración.
e. Ninguna de las anteriores
Página 146 de 164

13. Señale la alternativa que da sentido correcto a la frase: “Si cada usuario pudiese ser un dominio
entonces el conjunto de objetos al que se puede acceder depende de ___________. Hay
conmutación de dominio cuando cambia _____________, y si un nuevo usuario inicia una sesión
ocurre ____________”.
a. un User Id, el usuario, una conmutación de dominios.

b. la identidad del usuario, los derechos de acceso, la creación de un objeto.
c. los objetos, el dominio, la creación de un usuario nuevo.
d. el usuario, la conmutación de dominio, la generación de derechos de acceso.
Página 147 de 164

Caso N° 1
Columna A Columna B
Añaden varios bits de control al octeto o palabra a transmitir, de
1.- Caballo de troya tal forma que detectan errores de uno o más bits y los corrigen.
2.- Intrusión Corresponde a una ranura para montar el procesador.

Definición dada para una entrada no autorizada o indebida en el
3.- Mecanismo llave/cerradura sistema.
En sistemas de archivos auxiliares donde se registran todas las
4.- Perfil Móvil operaciones que realiza un usuario.
Permite que el usuario ingrese a distintos computadores con los
mismos permisos de acceso a recursos y programas, la misma
5.- Seguridad física interfaz y privilegios similares.
Programa aparentemente útil que contiene un trozo de código
6.- Socket que hace algo no deseado.
Son los mecanismos que impiden a los agentes físicos la
destrucción de la información existente en el sistema.
Un proceso puede efectuar una operación con un objeto sólo si
el dominio bajo el que se ejecuta posee una llave específica
para alguna de las cerraduras del objeto.
Caso N° 2
Columna A Columna B
Consiste en que cada cierto tiempo se realice una copia del
1.- Caza Claves contenido de los archivos.
Es la capacidad de un dispositivo o aplicación de poder
2.- Compatibilidad adaptarse en distintos ambientes computacionales.
Es un conjunto de pares (objeto, operaciones); cada par
3.- Criptografía identifica un objeto y las operaciones permitidas sobre él.
Es un proceso de transformación que se aplica a unos datos
4.- Dominio de protección para ocultar su contenido.
Programa que pide "login:" y luego "password:", para engañar a
5.- Matriz de acceso los usuarios de modo que estos revelen su clave.
Se refiere a las instalaciones del sistema informático y al acceso
6.- Seguridad externa de personas al sistema y su información.
Tabla que indica los objetos a los que puede acceder un sujeto
y permisos que tiene sobre él.
Página 148 de 164

1. Indique a lo menos 3 medios de respaldo de Información, y sus características.
2. Nombre 3 normas que se deben mantener para evitar accesos no autorizados a una red o el sistema
operativo.
3. Explique qué es la Criptografía
4. En una empresa turística se desea implementar una pequeña red LAN para llevar en un principio el
manejo de los sistemas de facturación, de control de suministros y un sistema contable. Los usuarios
en esta red serán 4 personas: dos asistentes contables que utilizarán el sistema de facturación en
los casos que sea necesario, una persona que llevará el control de suministros, el contador que
utilizará el sistema contable.
A usted se le ha encargado definir los requerimientos de esta red indicando las estructuras de
hardware necesarias para satisfacer estos requerimientos. Se pide:
a) Sugerir un sistema operativo (de los vistos en clases) para administrar esta red.
b) Los tipos de procesos que se ejecutarán.
c) Cantidad y tipos de usuarios.
d) Tipo de tarjeta de red.
e) Cantidad y tipo de servidores.
f) Procesadores para cada estación de trabajo.
5. Se tienen los siguientes dominios de usuarios:
a) Dominio Jefaturas: Acceso total a las estaciones de trabajo (E1), (E2), (E3). Acceso total a las
impresoras láser (L1), inyección de tinta (I1), bases de datos (B1) y (B2).
b) Dominio Operarios: Acceso total a estaciones de trabajo: (E4), (E5), (E6). Acceso total a la
impresoras láser (L1) y a una impresora inyección de tinta (I2). Acceso total a la base de batos
(B2) y de lectura y ejecución a la base de datos (B1).
c) Dominio Administradores: Acceso total a todos los equipos y a las impresora láser (L1) y la
inyección de tinta (I1). Accesos de lectura y ejecución a la base de datos (B2).
SE PIDE:
a. Dibujar un esquema con los dominios y accesos a cada uno de los recursos para cada
dominio.
b. Realizar una matriz de acceso considerando los permisos a cada recurso que se posean en los
distintos dominios: Lectura (R), Escritura (W) y Ejecución(X).
Página 149 de 164

Respuestas y Soluciones:
Unidades I, II, III & IV Unidades V & VI Unidades VII, VIII & IX
N° Resp. N° Resp. N° Resp.
1 a 1 b 1 b
2 b 2 e 2 d
3 c 3 d 3 c
4 a 4 d 4 e
5 b 5 c 5 c
6 c 6 b 6 d
7 c 7 a 7 c
8 d 8 e 8 e
9 b 9 e 9 e
10 c 10 b 10 d
11 b 11 a 11 b
12 a 12 d 12 d
13 c 13 a 13 a
14 b 14 b 14 -
15 d 15 d 15 -
16 a 16 d 16 -
17 d 17 c 17 -
18 c 18 a 18 -
19 c 19 c 19 -
20 d 20 b 20 -
21 c 21 b 21 -
22 a 22 a 22 -
23 b 23 d 23 -
24 c 24 c 24 -
25 d 25 d 25 -
26 a 26 - 26 -
27 b 27 - 27 -
28 d 28 - 28 -
29 c 29 - 29 -
30 d 30 - 30 -
31 c 31 - 31 -
32 a 32 - 32 -
33 d 33 - 33 -
34 d 34 - 34 -
35 e 35 - 35 -
36 b 36 - 36 -
37 c 37 - 37 -
38 c 38 - 38 -
39 b 39 - 39 -
40 c 40 - 40 -
41 d 41 - 41 -
42 a 42 - 42 -
43 c 43 - 43 -
44 c 44 - 44 -
45 c 45 - 45 -
Página 150 de 164

Unidades I, II, III & IV
Caso N° 1
Columna A Columna B
1) Sistemas Batch 4 Cambio de estado de un proceso.
2) SJF 5 Almacena el estado general de un proceso cuando este no

está activo.
3) Tiempo Compartido
1 Ejecutan un conjunto de tareas sin la intervención de un
4) Transición usuario u operador.
5) PCB 2 Planificación adecuada para procesamiento por lotes.
6) Proceso distribuido 3 Varios usuarios o procesos compartiendo un Procesador.
7) Memoria RAM 7 Medio de almacenamiento primario
8) Gestión de excepciones 6 Es la conexión de computadores entre sí a través de una

gran variedad de dispositivos
9) Sistema operativo
8 Tratamiento de errores de un programa en ejecución.
10) Proceso
9 Programa que se instala en la memoria del computador en el
11) Monoprogramación momento de arranque, interpreta y codifica las ordenes del
usuario
12) Editor
10 Programa en ejecución con el entorno asociado (registros,
variables, etc).
Caso N° 2
Columna A Columna B
1) Proceso en tiempo real 6 Programa de control que reacciona ante cualquier interrupción de
eventos externos y da servicio a los procesos.
2) S.O. no corrige el error
2 Errores de Hardware.
3) Round Robin
3 Se le da un tiempo de ejecución a un proceso y vencido su tiempo
4) Cola de Procesos se le da el turno a otro.
5) Planificador de trabajos 4 Existe cuando en estado Ready hay varios procesos en espera por
el Procesador.
6) Núcleo del sistema
operativo 1 Requiere una respuesta inmediata. Se le asigna una alta prioridad.
7) Política no apropiativa 10 Programa que permite escribir o corregir archivos de texto,

generalmente programas fuente.
8) Interprete de comandos
9 Programa traductor de un lenguaje de alto nivel a código de
9) Compilador maquina; efectúa un control previo de todo el programa.
10) Editor 8 Programas encargados de crear el entorno de trabajo de los

usuarios.
11) DOS
11 Sistema operativo monousuario
12) Multiprogramación
5 Decide cual será el próximo trabajo que se va a ejecutar
Página 151 de 164
Unidades V & VI
Caso N° 1
Columna A Columna B
1.- Partición variable 2 Técnica que combina hardware y software permitiendo la

2.- Memoria virtual real
3.- Fragmentación externa 1 Técnica que asigna dinámicamente la memoria a los trabajos
4.- Algoritmo del peor ajuste
__ Es una dirección de memoria relocalizable
5.- Sistemas combinados
3 La memoria libre en el sistema que no puede ser asignada a
6.- Partición fija ningún proceso
6 Gestión de memoria con particiones continuas de tamaño fijo
5 Forma de aprovechar los conceptos de la división lógica de los

programas con la granularidad de las páginas
__ Estrategia que permite determinar el tamaño de una página
4 El proceso es asignado a la partición más grande de la

memoria
Caso N° 2
Columna A Columna B
1.- Sistemas combinados 6 El proceso es asignado a la partición más grande de la

memoria
2.- Memoria virtual
1 Forma de aprovechar los conceptos de la división lógica de los
3.- Partición fija programas con la granularidad de las páginas
4.- Partición variable __ Consiste en reemplazar la página más vieja
5.- Fragmentación externa 3 Gestión de memoria con particiones continuas de tamaño fijo
6.- Algoritmo del peor ajuste 5 La memoria libre en el sistema que no puede ser asignada a
ningún proceso
__ Es la traducción de memoria lógica a física
4 Técnica que asigna dinámicamente la memoria a los trabajos

2 Técnica que combina hardware y software permitiendo la

real
Página 152 de 164

Unidades VII, VIII & IX
Caso N° 1
Columna A Columna B
Añaden varios bits de control al octeto o palabra a transmitir, de
1.- Caballo de troya tal forma que detectan errores de uno o más bits y los corrigen.
2.- Intrusión 6 Corresponde a una ranura para montar el procesador.

Definición dada para una entrada no autorizada o indebida en el
3.- Mecanismo llave/cerradura 2 sistema.
En sistemas de archivos auxiliares donde se registran todas las
4.- Perfil Móvil operaciones que realiza un usuario.
Permite que el usuario ingrese a distintos computadores con los
mismos permisos de acceso a recursos y programas, la misma
5.- Seguridad física 4 interfaz y privilegios similares.
Programa aparentemente útil que contiene un trozo de código
6.- Socket 1 que hace algo no deseado.
5 destrucción de la información existente en el sistema.
Un proceso puede efectuar una operación con un objeto sólo si
el dominio bajo el que se ejecuta posee una llave específica
3 para alguna de las cerraduras del objeto.
Caso N° 2
Columna A Columna B
Consiste en que cada cierto tiempo se realice una copia del
1.- Caza Claves contenido de los archivos.
Es la capacidad de un dispositivo o aplicación de poder
2.- Compatibilidad 2 adaptarse en distintos ambientes computacionales.
Es un conjunto de pares (objeto, operaciones); cada par
3.- Criptografía 4 identifica un objeto y las operaciones permitidas sobre él.
Es un proceso de transformación que se aplica a unos datos
4.- Dominio de protección 3 para ocultar su contenido.
Programa que pide "login:" y luego "password:", para engañar a
5.- Matriz de acceso 1 los usuarios de modo que estos revelen su clave.
Se refiere a las instalaciones del sistema informático y al acceso
6.- Seguridad externa 6 de personas al sistema y su información.
Tabla que indica los objetos a los que puede acceder un sujeto
5 y permisos que tiene sobre él.
Página 153 de 164

Preguntas de desarrollo
1. Por supuesto que sí. La multiprogramación siempre contribuye a aumentar el rendimiento de los
recursos, ya que saca más partido del procesador. Además, a un usuario individual le puede
resultar muy útil tener varios programas en ejecución simultánea, como ocurre en un entorno de
ventanas típico, en el cual el usuario puede tener abierta varias aplicaciones al mismo tiempo. Esto
permite aumentar la productividad del usuario, ya que no ha de esperar a que una aplicación
finalice para trabajar con otro programa.
2. El algoritmo FCFS no tiene la capacidad de expulsar del procesador a un proceso que no lo

solicite. Por este motivo, un proceso intensivo en CPU puede acaparar el procesador por tiempo
indefinido, postergando a los restantes procesos preparados. Esto significa que un programa
interactivo, que exige tiempos de respuesta bajos, pueda verse retrasado un tiempo excesivo y por
tanto incumplir los requisitos de interactividad.
3. Fundamentalmente, para garantizar que el estado de la entrada/salida es correcto que se respetan

las políticas de acceso a los recursos definidas por el sistema operativo. Si cualquier proceso
pudiera acceder a E/S directamente, podría dejarla en un estado inconsistente. Podría saltarse las
prioridades de acceso a los recursos. En los dispositivos de almacenamiento o transmisión de
datos, se podría leer información no autorizada. Por todo ello, el acceso directo a E/S sólo se
puede hacer con las rutinas dadas por el sistema operativo, en modo privilegiado.
4. Si los programadores pretenden escribir aplicaciones que contengan varios flujos de ejecución
concurrentes, estos usarán el mismo código y además necesitarán comunicarse información con
frecuencia. Por ello se considera apropiado definir una clase de procesos que compartan código,
datos y demás recursos dentro de una aplicación: son los procesos ligeros o hilos. El proceso
pesado es la estructura que contiene uno o varios hilos, más los recursos compartidos por estos
hilos. Con ello se pueden escribir aplicaciones concurrentes con menos consumo de memoria y
menor tiempo de comunicación entre hilos (ya que lo hacen a través de la memoria compartida).
5. Porque cuanto más baja sea la duración del cuanto de tiempo, más cambios de contexto se
producirán por unidad de tiempo. Como el cambio de contexto no realiza trabajo productivo, el
rendimiento del procesador decae. En particular, si el cuanto de tiempo es inferior a la duración de
un cambio de contexto, el procesador pasará más tiempo administrando que realizando trabajo
productivo.
7. Es un programa encargado de crear el entorno de trabajo de los usuarios
8. Es una técnica que realiza el tratamiento de errores de un programa en ejecución
9.a. La ventaja principal es poder dotar de concurrencia interna a una aplicación, con un coste
reducido. Varios hilos dentro de un proceso pesado comparten el mismo espacio de memoria
(código y datos), así como los recursos que la aplicación tenga asignados. Si nuestro sistema
operativo no diera la posibilidad de declarar hilos en un proceso, las activi dades concurrentes de
una aplicación tendrían que definirse mediante procesos pesados, que no comparten memoria ni
recursos, y por tanto se consumirían más recursos.
9.b. Ventajas del intérprete en el núcleo: Dado que es una aplicación de uso muy frecuent e, si se tiene
el código en el núcleo, la ejecución de las aplicaciones puede ser más rápida (no hay que cargarla
del disco).
Inconvenientes del intérprete en el núcleo: El núcleo crece de tamaño. Cuando no se está

utilizando el intérprete de órdenes, se está ocupando memoria con código que no se emplea. El
sistema es menos flexible, ya que si se quisiera cambiar la versión del intérprete de órdenes, se
tendría que reinstalar el núcleo del sistema operativo.
Página 154 de 164

9.c. Principalmente, porque en un sistema operativo multiprogramado o multiusuario existen
restricciones de acceso a los recursos: protección de zonas de memoria, restricción del uso de
archivos y dispositivos de E/S, etc. En segundo lugar, y muy relacionado con lo anterior, para
poder preservar la integridad del sistema operativo, que no debe ser dañado por el uso indebido
de los programas de usuario.
9.d. Las llamadas al sistema son los mecanismos que utilizan las aplicaciones para solicitar servicios al
núcleo del sistema operativo, mientras que los programas del sistema son aplicaciones
independientes que se distribuyen junto al sistema operativo y que resuelven necesidades básicas
de operación o administración (por ejemplo: editores, compiladores, intérpretes de órdenes, etc.)
Las llamadas al sistema son la interfaz del sistema operativo para las aplicaciones, mientras que
los programas del sistema son la interfaz del sistema operativo para los usuarios.
9.e. No necesariamente. Un sistema puede ser multitarea sin ser multiusuario. Aunque sólo exista un
usuario en el sistema, éste puede encontrar útil lanzar varias aplicaciones concurrentes, como
puede suceder en Windows.
10.a. Se está dando preferencia a los programas de pequeño tamaño, con lo cual se estimula a los
programadores a que escriban aplicaciones lo más pequeñas que puedan (lo cual es deseable).
AMPLIACIÓN: Si esta idea se extendiera al Planificador de Largo Plazo, se estaría hablando de
mantener en la cola de preparados a los procesos con menos demanda de memoria: en ese caso,
la política tendría el efecto beneficioso de mantener en ejecución la mayor cantidad de procesos
posible.
10.b. El efecto negativo más inmediato es el perjuicio causado a los procesos que demanden más
memoria para su ejecución, con el riesgo de inanición. Otro efecto negativo es que la política no
tiene en cuenta características importantes de los procesos, como la duración de sus ráfagas de
CPU, sus requisitos de interactividad, etc., que se sabe que influyen mucho en el rendimiento de la
planificación de procesos. Un proceso de pequeño tamaño no implica un proceso de menos
duración. Por tanto, el rendimiento de esta política sería imprevisible y no óptimo.
10.c. Por supuesto que sí, ya que se pueden conocer por anticipado las necesidades de memoria de un
programa (código y datos), o al menos una estimación fiable.
Unidades V & VI
1. Gestionar la memoria en los siguientes aspectos: Asegurar la independencia de las zonas, es decir
la protección de memoria Asegurar que los programas de usuarios no se vean afectados por la
división de memoria
2. La fragmentación que sufre la memoria es su mayor inconveniente debido a la sobrecarga que se

origina en el procesador para realizar la compactación con la consiguiente pérdida de tiempo
3. Es una técnica del sistema operativo que permite mejorar la utilización de la memoria realizando
intercambios desde la memoria principal a dispositivos rápidos de almacenamiento secundario
4. En la programación en paralelo, la estructura de control ParBegin / ParEnd, indica que una

ejecución secuencial se dividirá en varias secuencias de ejecución en paralelo (hilos de control) y
luego se reanudarán como una sola ejecución secuencial
5. La anomalía de Belady consiste en que algunos algoritmos de reemplazo de páginas, la tasa de

fallas de página puede aumentar al incrementar el número de marcos asignados.
6. El sistema operativo debe ofrecer mecanismos para sincronizar la ejecución de procesos: Uno de
estos son los semáforos. Los semáforos son rutinas de software (que en su nivel más interno se
auxilian del hardware) para lograr exclusión mutua en el uso de recursos
7. Es cuando dos o mas procesos esperan por un mismo recurso el cual no puede ser liberado, lo
cual imposibilita a los procesos continuar con sus ejecuciones de manera normal
Página 155 de 164
Unidades VII, VIII & IX
1. Cintas (DAT, DLT, 6150 6525, tipo Reel), CDROM, Discos ópticos, Técnicas RAID. (Arreglos tipo
1 3 4 y 5), el tipo 0 es un RAID pero no respalda, etc.
2. Evitar que los usuario introduzcan sus contraseñas en un archivo por lotes para una autentificaron
automática. Los usuario no autorizados pueden visualizar los archivos por lotes; Requerir que la
contraseña tenga un mínimo de caracteres; Requerir el cambio de contraseñas a lo menos cada
30, 60 ó 90 días; Requerir el uso de contraseñas únicas cuando se cambian, es decir, un usuario
no puede seleccionar la misma contraseña dos veces; Al abandonar sus estaciones de trabajo el
usuario debe salir del sistema o bloquear su estación; Etc.
3. Es un proceso de transformación que se aplica a unos datos para ocultar su contenido.
4.a. Windows NT Server y Windows NT Cliente. (o bien Novell, Linux, MAC, etc.)
4.b. Los procesos a ejecutar serán todos de tipo interactivos. Pueden existir procesos Batch, en el caso
de realizar respaldos para la seguridad de los datos.
4.c. Los tipos de usuarios pueden ser de dos tipos: el administrador de la red que utilizará en forma
esporádica el servidor y el resto de usuarios que usará cada uno sus aplicaciones
correspondientes (depende del sistema operativo que se haya seleccionado en 1).
4.d. Una tarjeta para de red para cada computador (Ethernet) con una velocidad de transmisión
adecuada (rápida).
4.e. Sólo un servidor que atiende solicitudes de datos y servicios de impresión principalmente para la
persona que lleva el control de suministros y el contador. Sería recomendable un procesador de 1
GHz, 40 GB de disco duro y 128 MB de RAM. (aunque una estación de trabajo también puede dar
servicios)
4.f. Puede ser muy variable, pero se puede recomendar que los demás procesadores de cada equipo
sean sobre 500 MHz, 5 GB de disco duro y 64 MB de RAM.
5.a.
5.b.
Dominio E1 E2 E3 E4 E5 E6 L1 I1 I2 B1 B2
Jefaturas RWX RWX RWX RWX RWX RWX RWX
Operarios RWX RWX RWX RWX RWX RX RWX
Administrador RWX RWX RWX RWX RWX RWX RWX RWX RX
Página 156 de 164

Problemas
1.
Tiempo de Llegada (ut) Tiempos de CPU(ut) Tiempo con FCFS Tiempo con SJF
0.5 16 16 54
1.0 8 24 12
1.5 14 38 38
2.0 12 50 24
2.5 4 54 4
TIEMPOS PROMEDIOS 36,4 26,4
2.a.
Con planificación FCFS Con planificación SJF
Tiempo de Tiempo de Tiempo de Tiempo de Índice de Tiempo de Tiempo de Índice de
Llegada ejecución finalización servicio servicio finalización servicio servicio
0 3 3 3 1,00 3 3 1,00
2 2 5 3 0,67 5 3 0,67
4 4 9 5 0,80 9 5 0,80
6 5 14 8 0,63 15 9 0,56
8 1 15 7 0,14 10 2 0,50
PROMEDIOS 5,20 0,65 4,40 0,70
2.b. La planificación SJF es más eficiente ya que el promedio de su índice de servicio es más cercano a
la unidad.
3.a. Primero el más corto (SJF) con expropiación: admite dos posibilidades
Solución A: P0 , P0 , P1 , P2 , P2 , P3 , P3 , P3 , P3 , P1 , P1 , P1 , P1 , P0 , P0 , P0 , P0 , P0 , P0 , P0
Proceso Tiempo de Tiempo de
retorno espera
P0 20 11
P1 11 6
P2 2 0
P3 4 0
Media 9,25 4,25
Solución B: P0 , P0 , P1 , P2 , P2 , P1 , P1 , P1 , P1 , P3 , P3 , P3 , P3 , P0 , P0 , P0 , P0 , P0 , P0 , P0
retorno espera
P0 20 11
P1 7 2
P2 2 0
P3 8 4
Media 9,25 4,25
3.b. Round-Robin (Q = 3 u.t.): admite dos posibilidades, se presenta una solución
Solución A: P0 , P0 , P0 , P1 , P1 , P1 , P2 , P2 , P0 , P0 , P0 , P3 , P3 , P3 , P1 , P1 , P0 , P0 , P0 , P3
retorno espera
P0 19 10
P1 14 9
P2 5 3
P3 15 11
Media 13,2 8,2
Página 157 de 164

4.a.
SRTF 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
P0 X X X X X X X
P1 X X X X
P2 X
P3 X X X
Round-Robin, q=3 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
P0 X X X X X X X
P1 X X X X
P2 X
P3 X X X
4.b. Hay más cambios de contexto en el RR (seis) que en el SRTF (cinco).
4.c. El menor tiempo de espera medio lo da el SRTF, como era de esperar, con 11/4=2’75 u.t. El RR da
una media de 26/4=6’5 u.t.
4.d. La decisión sobre cuál es el algoritmo más justo depende del concepto que se tenga de “justicia”.
En el ámbito de este concepto pueden entrar: el reparto equilibrado del procesador, la igualdad de
oportunidades en el acceso al mismo, la menor desviación respecto a la media de los tiempos de
espera, etc.
Tiempos de espera
SRTF Round-Robin
P0 8 8
P1 1 8
P2 0 5
P3 2 5
Si se habla de igualdad en el trato, se puede observar que en el RR las desviaciones respecto a la

media en el tiempo de espera son menores (1’5 u.t. de diferencia) que en el SRTF, en el cual hay
más disparidad de resultados. Obsérvese la diferencia entre P0 y P2. Este dato es un argumento a
favor de calificar al RR como más justo.
Sin embargo, la aparente justicia del RR no es tan clara. Comparado con el RR, el SRTF no
perjudica a ningún proceso, exceptuando quizás a P0, que tiene un periodo de espera continua de
8 u.t. y que en el RR disfruta del procesador con más frecuencia. Por el contrario, P1 y P2 están
muy penalizados en el RR. Como el SRTF beneficia a más procesos que el RR, podría afirmarse
que en este caso es más justo.
Unidades V & VI
1. Desarrollo
Cadena de referencias
1 6 1 2 1 0 4 7 0 3 7 4 5 3 3 5 1 1 6 1
Marcos de página
1 1 1 1 1 1 1 1 1 3 3 3 3 3 3 3 3 3 3 3
6 6 6 6 6 4 4 4 4 4 4 4 4 4 4 4 4 6 6
2 2 2 2 7 7 7 7 7 7 7 7 7 1 1 1 1
0 0 0 0 0 0 0 5 5 5 5 5 5 5 5
Respuestas
El número de fallas de páginas 10
El número de referencias a páginas que ya están en memoria 10
La página más utilizada Página N° 1
La página menos utilizada Página N° 2
Página 158 de 164

2. Desarrollo
Cadena de referencias
1 1 1 2 1 0 4 7 0 3 7 4 5 2 3 5 1 0 6 1
Marcos de página
1 1 1 1 1 1 1 7 7 7 7 7 7 7 7 7 1 1 1 1
2 2 2 2 2 2 3 3 3 3 3 3 3 3 0 0 0
0 0 0 0 0 0 0 5 5 5 5 5 5 6 6
4 4 4 4 4 4 4 2 2 2 2 2 2 2
Respuestas
El número de fallas de páginas 11
El número de referencias a páginas que ya están en memoria 09
La página más utilizada Página N° 1
La página menos utilizada Página N° 6
3. Con un monitor (lenguaje estilo Ada):
Monitor ReservaMemoria is procedure entry devuelve (nbytes: natural) is

begin begin
procedure entry reserva (nbytes: natural) is espacio_libre := espacio_libre + nbytes;
begin HayEspacio.Signal;
while espacio_libre < nbytes loop end devuelve;
HayEspacio.Wait; HayEspacio: condition;
HayEspacio.Signal; N: constant natural := …;
end loop; espacio_libre: natural range 0..N := N;
espacio_libre := espacio_libre - nbytes; end ReservaMemoria;
end reserva;
NOTA: El signal posterior al wait es imprescindible para despertar a todos los procesos en espera
cuando se devuelve memoria al sistema. P.ej. si hay dos procesos en espera que necesitan 10 y
30 bytes, y un proceso que finaliza devuelve 50 bytes, hay que desbloquear a los dos procesos.
Considérese también el ejemplo en el que estén esperando tres procesos que necesitan 60, 10 y
30 bytes; y que un proceso devuelve 50 bytes. Si se desbloquea el proceso de 60, tiene que volver
a bloquearse, pero hay que darle una oportunidad a los procesos de 10 y de 30 bytes. El signal de
devuelve() se puede sustituir por un broadcast, en cuyo caso no hace falta hacer el signal posterior
al wait del método reserva().
Con cerrojos y variables condición (estilo Nachos, escrito en C++):
const int N = …;
class ReservaMemoria {
private:
int espacio_libre;
Lock cerrojo;
Condition HayEspacio;
public:
ReservaMemoria ()
: HayEspacio(cerrojo)
{ espacio_libre = N; }
void reserva (int nbytes) {
cerrojo.Acquire();
while ( espacio_libre < nbytes ) {
HayEspacio.Wait();
HayEspacio.Signal();
}
espacio_libre -= nbytes;
cerrojo.Release();
}
Página 159 de 164

void devuelve (int nbytes) {
cerrojo.Acquire();
espacio_libre += nbytes;
HayEspacio.Signal();
cerrojo.Release();
}
};
NOTA: la misma que para la solución de Ada.
4. a) Sirve para reincorporar en la cola de preparados a un hilo que estaba bloqueado (apuntado
porla variable thread).
b) Se está usando como una cola FIFO.
c) No. Cuando un hilo que hace una P() descubre que el semáforo vale cero, se bloquea con
Sleep() y no reevalúa el semáforo hasta que alguien le despierta. Por tanto, mientras está
bloqueado está fuera de la cola de preparados.
d) El while es necesario, porque cuando el hilo que hizo la P() se recupera del Sleep(), ingresa en
la cola de preparados por el final. Delante de él, en la cola de preparados, puede haber otros
procesos que van a hacer operaciones P() sobre el mismo semáforo, con lo cual, cuando le
llegue el turno de CPU al proceso despertado, puede ocurrir que el semáforo vuelva a estar a
cero. Por eso tiene que volver a evaluar el valor del semáforo y bloquearse si de nuevo lo
encuentra a cero. Para sustituir el while por un if, habría que hacer modificaciones en los
algoritmos aquí expuestos.
5. La solución planteada no es válida, ya que no se cumple los requisitos de progreso y de espera

limitada. La condición de exclusión mutua siempre se cumple, aunque aquí no hace falta
demostrarlo. Si los dos procesos intentan entrar al mismo tiempo en sección crítica, se puede dar
la siguiente secuencia de acciones (estado inicial: P0 y P1 están en la línea 2):
Paso Acción Efecto

(p0,2) flag[0]:=true
<aquí> (p0,3) flag[1]=true, P0 entra en el while
(p1,3) flag[0]=true, P1 entra en el while
(p0,4) flag[0]:=false
(p0,5) como flag[1]=false, P0 no entra en el while
(p1,5) como flag[0]=false, P1 no entra en el while
(p0,7) P0 vuelve a la línea 3
(p1,7) P1 vuelve a la línea 3
El estado final es el mismo que en el punto marcado como <aquí>: los dos booleanos están a true
y tanto P0 como P1 están a punto de ejecutar la línea 3. Esto quiere decir que se puede producir la
misma secuencia de acciones nuevamente, y así indefinidamente. Por tanto no se garantiza que, si
uno o varios procesos quieren entrar en sección crítica, se tome una decisión en tiempo finito. Esto
viola el requisito llamado de progreso.
Por otro lado, la condición de espera limitada tampoco se cumple, ya que un proceso que acaba de
salir de sección crítica puede volver a entrar una y otra vez a pesar de que su compañero quiera
también entrar. Véase ésta secuencia, cuyo estado inicial es P0 en la línea 8 y P1 en la línea 2:
Acción Efecto
(p0,9) flag[0]:=false, P0 sale de sección crítica.
(p1,2) flag[1]:=true, P1 expresa su intención de entrar.
(p0,10) P0 ejecuta su sección no crítica
(p0,2) Flag[0]:=true, P0 quiere entrar otra vez en s.c.
(p1,3) P1 observa que flag[0]=true, entra en el bucle
Página 160 de 164
(p0,3) P0 observa que flag[0]=false: no entra en el bucle
(p0,7) P0 sale del bucle
(p0,8) P0 está en sección crítica
(p1,5) P1 observa que flag[1]=true, sigue iterando
Esta secuencia es posible y además se puede repetir indefinidamente, de forma que no se

garantiza que P1 entra en sección crítica en un tiempo finito aunque P0 entra tantas veces como
desea.
En conclusión, el algoritmo propuesto no se puede considerar una solución correcta al problema de

la sección crítica.
6. La solución aportada no es correcta, puesto que el principio de exclusión mutua no se cumple.

Efectivamente, supóngase que los dos procesos (P0 y P1) intentan entrar en la sección crítica y se
ejecutan, por ejemplo, de la siguiente manera:
T0: P0 comprueba el estado de Flag[1] y lo encuentra a "falso"

T1: P1 comprueba el estado de Flag[0] y lo encuentra a "falso"
Entonces, los procesos tendrían vía libre para acceder a la sección crítica; no cumpliéndose por
tanto el principio de exclusión mutua.
7. var
buffer: shared record
depósito: array [0 .. n-1] of elemento;
recuento, entrada, salida: integer; --inicializadas a cero
end;
Productor:
region buffer when ( recuento < n ) do
begin
deposito[entrada] := psiguiente;
entrada := (entrada+1) mod n;
recuento := recuento + 1;
end;
Consumidor:
region buffer when (recuento > 0 ) do
begin
csiguiente := depósito[salida];
salida := (salida+1) mod n;
recuento := recuento - 1;
end;
Página 161 de 164

BIBLIOGRAFÍA
ALCALDE, Eduardo y otros. Introducción a los Sistemas Operativos. Madrid: McGraw Hill, 1992.
DEILEL, Harvey. Introducción a los Sistemas Operativos. E.U.A: Addison Wesley, 1993.
MILENKOVIC, Milan. Sistemas Operativos, Conceptos y Diseño. México: McGraw Hill, 1994.
TANENBAUM, Andrew. Sistemas Operativos Distribuidos. México: Prentice Hall, 1996.
TANENBAUM, Andrew. Sistemas Operativos Modernos. México: Prentice Hall, 1992.
Página 162 de 164

ÍND ICE ALFA BÉT IC O
A H
Acceso directo................................................. 38, 127 Hardware...................................21, 113, 117, 133, 151
Acceso directo a memoria............. 29, 30, 106, 107, 127 Hebras............................................................ 25, 114
Acceso secuencial................................................... 38
Administración I
de CPU............................................................... 48
de Datos.............................................................. 33 Interbloqueo......... 67, 68, 83, 85, 86, 137, 139, 140, 142
de Dispositivos.................................................... 40 Interrupciones ............11, 19, 21, 26, 29, 31, 32, 33, 127
de Memoria......................................................... 52 J
Ajuste.................................................51, 64, 138, 139
Ajuste rápido.......................................................... 64 JOIN..................................................................... 68
Algoritmo ...17, 18, 25, 26, 28, 33, 37, 39, 41, 44, 48, 49,
50, 51, 52, 56, 57, 58, 62, 63, 64, 67, 69, 70, 71, 72, 73, L
74, 77, 79, 81, 82, 84, 85, 86, 87, 96, 102, 104, 118, 119,
124, 128, 132, 134, 136, 138, 139, 141, 143, 144, 146, LFU..........................................................63, 64, 131
152, 154, 155, 158, 160, 161 Linux.........................121, 122, 123, 124, 125, 145, 156
Almacenamiento..................................................... 99 Localidad............................................................... 61
API..................................................................... 113 Lock..........................................................67, 72, 159
Archivos................................................ 9, 28, 34, 118 Look ..................................................................... 45
Auditoría............................................................... 95 LRU..........................................59, 131, 138, 139, 143
B M
Batch.............................................. 130, 133, 151, 156 Matriz de accesos........................................91, 94, 149
Best Fit........................................................... 64, 138 Mejor en Ajustarse........................................... 64, 138
Bits adicionales...................................................... 63 Memoria.............. 53, 105, 130, 133, 138, 141, 151, 152
Buffers......................................27, 73, 74, 77, 82, 131 Localidad.................................................... 37, 60, 61
Paginación ........................................56, 115, 138, 140
C Segmentación....................................55, 115, 138, 140
Swapping........................................................ 54, 142
Caballo de Troya........................................... 148, 153 Virtual............................................................ 53, 130
Caché........................................................... 106, 110 Memoria Virtual................................................... 130
Cíclico................................................................... 58 Memory Manager Unit ................................. 54, 57, 59
Cifrado...............................95, 119, 120, 148, 149, 153 MFU..................................................................... 64
C-Look.................................................................. 45 MMU......................................................... 54, 57, 59
Comunicación ...................................9, 13, 17, 75, 104 Monitor residente.................................................. 129
Concurrencia........................................................ 128 Monitores............................ 79, 97, 112, 113, 129, 159
Conjunto de trabajo................................................. 61 Monoprogramación............................11, 131, 133, 151
Contexto. 50, 91, 103, 104, 113, 124, 126, 128, 129, 136, Multiprogramables......................11, 130, 131, 133, 151
137, 138, 145, 154, 158
Criptografía.........................95, 119, 120, 148, 149, 153 N
C-SCAN...........................................................44, 45
Netware.....................108, 109, 110, 111, 112, 125, 156
D Nominación........................................................... 88
Deadlocks............ 67, 68, 83, 85, 86, 137, 139, 140, 142 P
Dekker..............................................................70, 71
Desempeño ................................................. 26, 45, 51 Paginación ........................................56, 115, 138, 140
Directorios...................................................... 35, 106 PARBEGIN........................................................... 68
Discos............................................................ 43, 156 PAREND............................................................... 68
Dispositivos........................................33, 40, 106, 127 PCB...................................................... 20, 22, 24, 49
Distribuidos......................................................... 162 Peor ajuste............................................... 64, 141, 152
DMA.......................................... 29, 30, 106, 107, 127 Peterson............................................................69, 71
Dominio .............. 94, 116, 120, 145, 147, 148, 149, 153 Planificación
Dominios de protección.................................... 94, 145 de CPU............................................................... 48
de Memoria......................................................... 52
E de Procesos......................................................... 16
Planificaciones......................... 43, 44, 45, 50, 133, 151
Eschenbach............................................................ 45 Bits adicionales.................................................... 63
Estructuras Cíclico................................................................ 58
de Hardware........................................................ 98 C-SCAN........................................................44, 45
de Sistema Operativo..................................... 97, 100 Eschenbach ......................................................... 45
FCFS.. 40, 43, 44, 48, 49, 50, 128, 129, 132, 134, 135,
F 154
FCFS ..... 40, 43, 44, 48, 49, 50, 128, 129, 132, 134, 135, FIFO.. 49, 50, 58, 63, 64, 104, 131, 138, 139, 143, 144,
160
154
FIFO... 49, 58, 63, 64, 104, 131, 138, 139, 143, 144, 160 LFU........................................................63, 64, 131
Firmware ............................................................7, 97 LRU .......................................59, 131, 138, 139, 143
MFU................................................................... 64
First Fit........................................................... 64, 138
Prioridades.......................................................... 19
FORK.................................................................... 68
Fragmentación.......................................... 60, 141, 152 Randómico.......................................................... 58
Round Robin ................ 48, 50, 51, 128, 132, 133, 151
Página 163 de 164
SCAN............................................................44, 45 Sistemas. 10, 12, 13, 14, 97, 98, 100, 112, 131, 133, 141,
SCAN-N............................................................. 44 145, 146, 151, 152, 162
Segunda oportunidad............................................ 63 Batch......................................10, 130, 133, 151, 156
SJF.........48, 49, 50, 128, 129, 132, 133, 135, 151, 157 Maestro Esclavo............................................ 76, 101
SRT...............................................................48, 49 Multiprogramables...................11, 130, 131, 133, 151
SSTF....................................................... 43, 44, 45 Tiempo Real...................................................... 131
Primero en Ajustarse........................................ 64, 138 Sistemas Operativos
Primitiva.... 17, 18, 25, 26, 28, 33, 37, 39, 41, 44, 48, 49, Distribuidos......................................................... 14
50, 51, 52, 56, 57, 58, 62, 63, 64, 67, 69, 70, 71, 72, 73, Historia............................................................... 10
74, 77, 79, 81, 82, 84, 85, 86, 87, 96, 102, 104, 118, 119, Servicios..........................................................9, 11
124, 128, 132, 134, 136, 138, 139, 141, 143, 144, 146, SJF............48, 49, 50, 128, 129, 132, 133, 135, 151, 157
152, 154, 155, 158, 160, 161 Software................................................................ 25
Prioridades............................................. 24, 48, 72, 86 SRT .................................................................48, 49
Interrupciones...................................................... 32 SSTF.......................................................... 43, 44, 45
Planificaciones..................................................... 19 Swapping........................................................ 54, 142
Procesos....................17, 18, 25, 72, 131, 133, 151, 157
Concurrencia ..................................................... 128 T
DeadLock............................................................ 83
Thread................................................................. 143
Definición........................................................ 17
PCB...................................................... 24, 133, 151 Tiempo Compartido....................................... 133, 151
Transición de estados......................................... 19 Tiempo Real......................................................... 131
Timesharing........................................... 129, 133, 151
Propietarios............................................................ 81
Transición..................................................... 133, 151
Protección................................................... 15, 37, 94
Transición de estados
R de dispositivos..................................................... 28
de procesos.......................................................... 19
Randómico............................................................. 58 Trustees............................................................... 111
Recursos................................................................ 48
Registro............................................................... 103 U
Round Robin ................... 48, 50, 51, 128, 132, 133, 151
RPC............................................................... 79, 100 Unix ....34, 39, 40, 97, 102, 104, 105, 106, 121, 123, 124,
126, 137, 145, 150
S Unlock..............................................................67, 72
SCAN...............................................................44, 45 V
SCAN-N................................................................ 44
Vigilancia.............................................................. 93
Sección Crítica..................................67, 69, 70, 71, 72
Virtual........................................................ 51, 55, 56
Segmentación....................................55, 115, 138, 140
Seguridad. 91, 93, 109, 111, 118, 119, 145, 146, 148, 153 W
Semáforos....................................................... 72, 105
Signal...................................... 67, 72, 73, 77, 159, 160 Wait .................................... 27, 28, 67, 72, 73, 77, 159
Siguiente en Ajustarse............................................. 64 Windows ....112, 113, 114, 116, 117, 118, 119, 120, 145,
Sincronización...................................... 17, 68, 71, 109 155, 156
Sistema de Archivos.............................................. 118 Windows 2000 ......................... 116, 117, 118, 119, 120
Windows NT.....................113, 114, 116, 118, 145, 156
Página 164 de 164

INACAP - Manual de Sistemas Operativos I

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

INACAP - Manual de Sistemas Operativos I

Încărcat de

Drepturi de autor:

Formate disponibile

M ANUAL DE SISTEM AS OPERATIVOS I

Dirección de Área Infor mática

Carlos Covarrubias Astudillo

Sugerencia de distribución de tiempo de lectura y estudio.

CAPÍTULO I : INTRODUCCIÓN 1 hrs.

RESOLUCIÓN DE PREGUNTAS Y PROBLEMAS 12 hrs.

TIEMPO TOTAL DE LECTURA Y ESTUDIO 36 hrs.

SERVICIOS DE LOS SISTEMAS OPERATIVOS........................................11

ELEMENTOS BÁSICOS ...............................................................................15

ASPECTOS DE SEGURIDAD .......................................................................88

ALGUNOS SISTEMAS OPERATIVOS ......................................................102

PREGUNTAS Y PROBLEMAS RESUELTOS............................................126

El sistema operativo es el ente intermedio entre las aplicaciones

A pesar de que todo el mundo utiliza sistemas operativos casi a

• Proveer una máquina virtual, es decir, un ambiente en el cual el

El Sistema Operativo Como Máquina Virtual

2. Decir al controlador que efectué la operación;

4. Interpretar el resultado de la operación (una serie de bits);

5. Reintentar si algo anduvo mal, etc.

• Mantiene el estado de los programas y datos residentes en memoria, esperando el uso de la

c. Manejo de dispositivos de E/S

• Controla el flujo de datos desde y hacia cualquier dispositivo de entrada y salida.

d. Administración de archivos en disco

e. Comunicación con el usuario

• Permite que el operador controle el computador.

Sistemas De Procesamiento Por Lotes (Batch)

M ultipro grama ción

Tiempo Com part ido

El tiempo compartido (o sistemas en línea) es una extensión lógica de la multiprogramación. La CPU

Sistemas De Tiem po Real

b. Aceleración de los cálculos

Si un cálculo determinado puede dividirse en varios subcálculos que se ejecuten concurrentemente, un

Estos esquemas se pueden clasificar en sistemas multiprocesadores simétricos, en el cual cada

• Operaciones de entrada/salida. Como un programa no puede acceder directamente a un

• Asignación de recursos. Cuando hay múltiples usuarios o múltiples trabajos ejecutándose al

Se pueden agrupar en tres categorías: control de procesos o de trabajos, manipulación de dispositivos y

Control de procesos y de trabajos:

• Solicitar dispositivo y liberar dispositivo.

• Obtener y/o establecer hora o fecha.

Programas Del S istema

Se pueden dividir en las siguientes categorías:

• Modificación de archivos: Editores de texto usados para crear y modificar el contenido de un

• Soporte al lenguaje de programación: Compiladores, intérpretes y ensambladores que dan

“La diferencia entre un programa (conjunto de instrucciones) y un proceso (instrucciones ejecutándose)

• El mecánico sería el procesador que va a realizar el trabajo.

Relación Entre Los Procesos

El sistema operativo debe suministrar los servicios necesarios que permitan:

a) Ejecución concurrente de los procesos.

a) Decidir qué proceso se ejecutará o tomará el procesador.

Dependiendo de la interacción entre los procesos, estos se clasifican en:

Especificación De Los Procesos

• Implícitos: Procesos generados y eliminados por el SO.

Estados De Los Procesos

a) Activo: Proceso que está ejecutándose en un instante dado.

El sistema operativo dispone de algoritmos de planificación y de gestión de los procesos y de los

Estado RUNNING o EN EJECUCIÓN

Estado BLOCKED o EN ESPERA

Estados Intermedios, Externos o Especiales

WAIT (o ESPERA, o INICIAL, ...)

Transiciones entre los estados

A continuación se explicarán detalladamente estas últimas transiciones de estados:

Terminate (id-proceso): RUNNING ß END

Activate (id-proceso): WAIT ß READY

Dispatch (id-proceso): READY ß URNG