View
283
Download
1
Category
Preview:
Citation preview
Resumen Sistema Operativo Esto es un resumen del libro rejunte de sistema operativo Martin 7/19/2010
Universidad Tecnológica Nacional Facultad Regional Villa María
2
BALOG MARTIN AÑO 2010
INDICE
Contenido Prologo ............................................................................................................................................ 7
1 Introducción a los sistemas informáticos .................................................................................... 8
1.1 Elementos básicos ............................................................................................................... 8
1.2 Registros del procesador ..................................................................................................... 8
1.3 Ejecución de instrucciones .................................................................................................. 9
1.4 Interrupciones ..................................................................................................................... 9
1.5 Jerarquía de la memoria.................................................................................................... 10
1.6 Memoria caché .................................................................................................................. 11
1.7 Protección por hardware .................................................................................................. 12
2 Introducción a los sistemas operativos ..................................................................................... 14
2.1 Conceptos de sistemas operativos .................................................................................... 14
2.2 Funciones y características de los sistemas operativos .................................................... 14
2.3 Historia y evolución de los sistemas operativos ............................................................... 16
2.4 Estructura del SO ............................................................................................................... 16
2.4.1 Componentes y servicios del sistema operativo ....................................................... 17
2.4.2 Implementación de las estructuras de los sistemas operativos ............................... 19
2.4.3 Sistemas Abiertos ...................................................................................................... 20
2.5 Categorías de los sistemas operativos .............................................................................. 22
2.6 Definición de sistemas operativos distribuidos ................................................................ 23
2.6.1 Objetivos y ventajas .................................................................................................. 23
2.6.2 Aspectos del diseño de los sistemas operativos distribuidos ................................... 25
3 Procesos .................................................................................................................................... 27
3.1 Concepto de proceso y programa ..................................................................................... 27
3.2 Modelado de los procesos ................................................................................................ 28
3.2.1 Jerarquías .................................................................................................................. 28
3.2.2 Estados, transiciones y operaciones con procesos ................................................... 29
3.2.3 Tabla de proceso o BCP ............................................................................................. 32
3.3 Planificación de procesos .................................................................................................. 34
3.3.1 Niveles de planificación ............................................................................................. 35
Universidad Tecnológica Nacional Facultad Regional Villa María
3
BALOG MARTIN AÑO 2010
3.3.2 Objetivos, criterios y algoritmos de planificación ..................................................... 35
3.3.3 Planificación de multiprocesadores .......................................................................... 39
3.3.4 Planificación en Tiempo Real .................................................................................... 40
3.4 Comunicación entre procesos ........................................................................................... 42
3.4.1 Estructura básica ....................................................................................................... 43
3.4.2 Condiciones de excepción ......................................................................................... 44
3.5 Sincronización de procesos ............................................................................................... 44
3.5.1 El problema de la sección crítica ............................................................................... 44
3.5.2 Hardware de sincronización ...................................................................................... 46
3.5.3 Semáforos.................................................................................................................. 47
3.5.4 Problemas clásicos de sincronización ....................................................................... 48
3.5.5 Monitores .................................................................................................................. 49
3.5.6 Transacciones atómicas ............................................................................................ 50
4 Bloqueo - Deadlock ................................................................................................................... 53
4.1 Tipos de recursos .............................................................................................................. 53
4.2 Definición de bloqueo ....................................................................................................... 53
4.3 Condiciones para un bloqueo ........................................................................................... 53
4.4 Modelación de bloqueo .................................................................................................... 54
4.5 Algoritmo del avestruz ...................................................................................................... 54
4.6 Detección y recuperación .................................................................................................. 55
4.7 Evasión de bloqueos .......................................................................................................... 57
4.8 Prevención de bloqueos .................................................................................................... 59
5 Sistema de archivos ................................................................................................................... 62
5.1 Interfaz con el sistema de archivos ................................................................................... 62
5.1.1 Concepto de archivo ................................................................................................. 62
5.1.2 Métodos de acceso ................................................................................................... 66
5.1.3 Estructura de directorios ........................................................................................... 67
5.1.4 Protección ................................................................................................................. 73
5.2 Implementación de un sistema de archivos...................................................................... 75
5.2.1 Estructuras del sistema de archivos .......................................................................... 75
5.2.2 Métodos de asignación ............................................................................................. 77
5.2.3 Administración del espacio libre ............................................................................... 82
5.2.4 Implementación de directorios ................................................................................. 83
Universidad Tecnológica Nacional Facultad Regional Villa María
4
BALOG MARTIN AÑO 2010
5.3 Archivos compartidos ........................................................................................................ 84
5.4 Administración de disco .................................................................................................... 86
5.5 Confiabilidad del sistema de archivos ............................................................................... 86
6 Entrada-Salida ........................................................................................................................... 89
6.1 Principios del hardware de E/S ......................................................................................... 89
6.1.1 Dispositivos y controladores de E/S .......................................................................... 89
6.1.2 Escrutinio. Interrupciones. DMA ............................................................................... 90
6.2 Principios de software ....................................................................................................... 92
6.2.1 Objetivos del software de E/S ................................................................................... 92
6.2.2 Manejadores de interrupciones ................................................................................ 93
6.2.3 Software de E/S independiente del dispositivo ........................................................ 93
6.2.4 Software de E/S en el espacio del usuario ................................................................ 94
6.3 Interfaz de E/S de las aplicaciones .................................................................................... 95
6.3.1 Dispositivos por bloques y por carácter .................................................................... 96
6.3.2 Dispositivos de red .................................................................................................... 97
6.3.3 Relojes y temporizadores .......................................................................................... 97
6.3.4 E/S bloqueadora y no bloqueadora .......................................................................... 97
6.4 Subsistema de E/S del núcleo ........................................................................................... 98
6.4.1 Planificador de E/S .................................................................................................... 98
6.4.2 Utilización de buffers, cachés y spool ....................................................................... 98
6.4.3 Manejo de errores ..................................................................................................... 99
6.4.4 Estructura de datos del núcleo ............................................................................... 100
6.5 Discos .............................................................................................................................. 100
6.5.1 Estructuras de disco ................................................................................................ 100
6.5.2 Planificación de discos ............................................................................................. 101
6.5.3 Manejo de errores ................................................................................................... 105
7 Seguridad y protección............................................................................................................ 106
7.1 Protección ....................................................................................................................... 106
7.1.1 Objetivos de la protección ...................................................................................... 106
7.1.2 Dominio de protección ............................................................................................ 106
7.1.3 Matriz de acceso ..................................................................................................... 106
7.1.4 Implementación de la matriz de acceso. ................................................................. 107
7.1.5 Revocación de derechos de acceso ......................................................................... 109
Universidad Tecnológica Nacional Facultad Regional Villa María
5
BALOG MARTIN AÑO 2010
7.1.6 Sistemas basados en capacidades ........................................................................... 110
7.2 Seguridad ......................................................................................................................... 111
7.2.1 El problema de la seguridad .................................................................................... 111
7.2.2 Validación ................................................................................................................ 111
7.2.3 Contraseñas de un solo uso .................................................................................... 112
7.2.4 Amenazas por programas ....................................................................................... 113
7.2.5 Vigilancia de amenazas ........................................................................................... 113
7.2.6 Cifrado ..................................................................................................................... 114
7.2.7 Clasificación de seguridad de las computadoras .................................................... 114
8 Computadoras distribuidas ..................................................................................................... 116
8.1 Estructuras de sistemas distribuidos ............................................................................... 116
8.1.1 Sistemas operativos de red ..................................................................................... 116
8.1.2 Sistemas operativos distribuidos ............................................................................ 116
8.1.3 Servicios remotos .................................................................................................... 118
8.1.4 Gestión de procesos ................................................................................................ 130
8.2 Protocolos (constituyen una serie de normas) ............................................................... 130
8.2.1 Concepto ................................................................................................................. 130
8.2.2 Características ......................................................................................................... 130
8.2.3 Funciones ................................................................................................................ 131
9 Unix / Linux .............................................................................................................................. 144
9.1 Unix ................................................................................................................................. 144
9.1.1 Historia .................................................................................................................... 144
9.1.2 Gestión de procesos – Procesos en Unix ............................................................... 145
9.1.3 Sistema de archivos ................................................................................................. 145
9.1.4 Gestión de E/S – Entrada/Salida en Unix .............................................................. 145
9.2 Linux ................................................................................................................................ 146
9.2.1 Historia .................................................................................................................... 146
9.2.2 Principios de diseño ................................................................................................ 146
9.2.3 Arquitectura ............................................................................................................ 147
9.2.4 Gestión de procesos ................................................................................................ 147
9.2.5 Sistema de archivos ................................................................................................. 148
9.2.6 Gestión de E/S – Entrada y Salida .......................................................................... 149
9.2.7 Seguridad ................................................................................................................. 150
10 Windows .............................................................................................................................. 151
Universidad Tecnológica Nacional Facultad Regional Villa María
6
BALOG MARTIN AÑO 2010
10.1 Windows 95 ..................................................................................................................... 151
10.1.1 Arquitectura ............................................................................................................ 151
10.1.2 Registro ................................................................................................................... 153
10.2 Windows NT .................................................................................................................... 155
10.2.1 Historia .................................................................................................................... 155
10.2.2 Principios de diseño ................................................................................................ 155
10.2.3 Componentes del sistema ....................................................................................... 155
10.2.4 Subsistemas de entorno .......................................................................................... 159
10.2.5 Subsistema de archivos ........................................................................................... 159
10.3 Windows CE ..................................................................................................................... 160
11 Otros sistemas operativos ................................................................................................... 166
11.1 Apple Macintosh ............................................................................................................. 166
11.2 OS/2 ................................................................................................................................. 166
11.3 Netware ........................................................................................................................... 166
11.4 Otros ................................................................................................................................ 166
12 Gestión de memoria ............................................................................................................ 167
12.1 Requisitos para la gestión de memoria ........................................................................... 167
12.1.1 Reubicación ............................................................................................................. 167
12.1.2 Protección ............................................................................................................... 167
12.1.3 Compartimiento ...................................................................................................... 167
12.1.4 Organización lógica ................................................................................................. 168
12.1.5 Organización física ................................................................................................... 168
12.2 Partición de la memoria .................................................................................................. 168
12.2.1 Particiones estáticas ................................................................................................ 168
12.2.2 Particiones Dinámicas ............................................................................................. 169
12.3 Paginación ....................................................................................................................... 170
12.4 Segmentación .................................................................................................................. 171
12.5 Memoria virtual ............................................................................................................... 172
Terminología ................................................................................................................................... 179
Universidad Tecnológica Nacional Facultad Regional Villa María
7
BALOG MARTIN AÑO 2010
Prologo
Esto no se puede decir que es un pequeño resumen porque no lo es me quedo bastante extenso
pero están todos los temas del programa. Pido disculpa solo faltan la Unidad Nº 11 Otros Sistemas
Operativos.
Muchos de estos capítulos fueron o pueden llegar a ser temas a tomarse en un teórico.
Agradezco la colaboración de Roxana.
Espero que les sirva para algo o de última para tenerlo de referencia.
Universidad Tecnológica Nacional Facultad Regional Villa María
8
BALOG MARTIN AÑO 2010
1 Introducción a los sistemas informáticos
1.1 Elementos básicos
Procesador: Controla la operación del computador y lleva a cabo las funciones de
procesamiento de datos.
Memoria Principal: Almacena los datos y los programas. Es volátil.
Módulos de E/S: Transportan los datos entre el computador y su entorno exterior.
Interconexión de sistemas: Ciertos mecanismos y estructuras que permiten la
comunicación entre procesos.
1.2 Registros del procesador
Un procesador incluye un conjunto de registros que proporcionan un nivel de memoria, que es
más rápido y pequeño que la memoria principal.
Funciones:
Registros visibles de usuario: es aquel que puede ser referenciado por medio del lenguaje de
máquina que ejecuta el procesador y está generalmente disponible para todos los programas. Es el
utilizado por el programador.
Registros disponibles:
Registros de datos: Son el propósito general y pueden ser empleados por cualquier
instrucción de máquina que lleve a cabo operaciones sobre los datos.
Registros de dirección: Contienen direcciones de la memoria principal de datos e
instrucción o contener una parte de la dirección.
Registro índice: Implica sumar un índice a un valor base, para obtener la dirección
efectiva.
Puntero de segmento: La memoria se divide en segmentos que son bloques de
palabras de longitud variable. Una referencia a la memoria consta de una
referencia a un segmento particular y un desplazamiento dentro del segmento.
Puntero de pila: La pila estará en la memoria principal y estará formada por un
conjunto secuencial de registros, con uno dedicado a señalar la parte superior de la
pila, que toma el nombre de la cima de la pila (poner push; sacar pop).
Registros de control y de estado: se emplean para controlar las operaciones del procesador, de los
cuales no son visibles por el usuario.
Registros esenciales:
Contador de programa (PC, Program Counter): Contiene la dirección de la instrucción a ser
leída.
Registro de instrucción (IR, Instruction Register): Contiene la última instrucción leída.
Además incluye un registro o conjunto de registro llamado palabra de estado del programa (PSW,
Program Status Word), que contiene información de estado, como así también, códigos de
Universidad Tecnológica Nacional Facultad Regional Villa María
9
BALOG MARTIN AÑO 2010
condición que son un conjunto de bits activados por el hardware del procesador como resultado
de determinadas operaciones. Estos bits de condición se agrupan en uno o más registros sin
olvidar que, normalmente, forman parte de un registro de control.
1.3 Ejecución de instrucciones
El procesador lee una instrucción de la memoria e incrementa el contador de programa además de
activar el registro de instrucción. Luego interpreta la instrucción y realiza la acción requerida:
Véase Figura 1.1
Procesador-Memoria: Se transfieren datos del procesador a la memoria o viceversa.
Procesador-E/S: Se transfieren datos desde o hacia un dispositivo periférico.
Tratamiento de datos: El procesador puede realizar alguna operación aritmética o lógica
sobre los datos.
Control: Secuencia de ejecución alterada.
Funciones de E/S
Los módulos de E/S pueden intercambiar datos directamente con el procesador. Al igual que el
procesador puede iniciar una lectura o escritura en la memoria, indicando la dirección de una
ubicación especifica, el procesador también puede leer datos de un modulo de E/S o escribir datos
en un modulo de E/S.
Durante la transferencia el modulo de E/S emite ordenes de lectura o escritura en la memoria
relevando al procesador de la responsabilidad del intercambio. Esta operación se conoce como
acceso directo a la memoria (DMA, Direct Memory Access).
1.4 Interrupciones
Mejoran la eficiencia del procesamiento.
Clases de interrupciones:
De programa: Por alguna condición que se produce como resultado de la ejecución de una
instrucción (desbordamiento aritmético, la división por cero, el intento de ejecutar una
instrucción ilegal de la maquina o una referencia a una zona de memoria fuera del espacio
permitido por el usuario).
De reloj: Por un reloj interno del procesador. Permite al sistema operativo realizar ciertas
funciones con determinada regularidad.
Figura 1.1 Ciclo básico de instrucción
Universidad Tecnológica Nacional Facultad Regional Villa María
10
BALOG MARTIN AÑO 2010
De E/S: Por un controlador de E/S, puede indicar que una operación ha terminado o una
condición de error.
Por fallo del hardware: Por fallos como corte de energía o error de paridad.
Se añade un ciclo de interrupción al ciclo de instrucción, donde el procesador comprueba si ha
ocurrido alguna interrupción, de ser así:
1. El dispositivo emite una señal de interrupción al procesador.
2. El procesador finaliza la ejecución de la instrucción en curso.
3. Pregunta por la interrupción y envía una señal de reconocimiento para que el dispositivo
suprima la señal de interrupción.
4. Salva la información necesaria (palabra de estado PSW y contador de programa PC) y la
guarda en la pila de control del sistema.
5. Carga el PC, con la dirección de inicio del tratamiento de interrupción y comienza con el
mismo. En caso de que haya más de una debe elegir cuál atenderá o bien dicha
información puede estar incluida en la señal original.
6. La rutina comienza salvando en la pila el contenido de todos los registros.
7. Examina el estado de la información relativa a la generación de E/S y reconoce el
dispositivo.
8. Cuando termina el tratamiento se recuperan de la pila los valores de los registros y se
restauran.
9. Luego se restaura el PC y PSW y se continúa con el programa interrumpido.
Interrupciones múltiples
Supóngase que pueden producirse múltiples interrupciones. Se puede:
Inhabilitar las interrupciones mientras se esté procesando una, y antes de reanudar el
programa habilitarlas. No se tienen en cuenta las prioridades de tiempo.
Definir prioridades y permitir que se interrumpa la rutina de tratamiento.
Multiprogramación
Cuando el programa es interrumpido puede que no se le devuelva el control al mismo proceso
porque existe otro programa pendiente de mayor prioridad y se le transfiere a éste. Varios
programas que se ejecutan por turnos se denominan multiprogramación.
1.5 Jerarquía de la memoria
Las limitaciones de la memoria se pueden resumir en las siguientes características: coste,
capacidad y tiempo de acceso. Véase Figura 1.2. Se utilizan gran variedad de tecnologías para
diseñar los sistemas de memoria, los cuales cumplen las siguientes relaciones:
A mayor tiempo de acceso, mayor coste por bit.
A mayor capacidad, menor coste por bit.
A mayor capacidad, tiempo de acceso más lento.
Universidad Tecnológica Nacional Facultad Regional Villa María
11
BALOG MARTIN AÑO 2010
MemoriaInterna
Registro caché, Memoria Principal
Disco magnético
Cinta magnética
MemoriaExterna
AlmacenamientoSecundario
Figura 1.2 Jerarquía de la memoria
Al descender de la pirámide:
Disminución del coste por bit
Aumento de la capacidad
Aumento del tiempo de acceso
Disminución de la frecuencia de acceso a la memoria por parte del procesador
1.6 Memoria caché
Contiene una copia de una parte de la memoria principal y sirve para agilizar la lectura del
procesador a la memoria. Primero se comprueba que la palabra a leer está en caché y se envía al
procesador, sino un bloque de memoria principal se introduce en la caché y luego se envía al
procesador la palabra. Figura 1.3.
Figura 1.3 Memoria caché
Diseño de la cache
Tener en cuenta:
Tamaño del cache: las caches pequeñas pueden tener un impacto significativo sobre el
rendimiento.
Tamaño del bloque: Es la unidad de intercambio de datos entre la cache y la memoria
principal. La tasa de aciertos significa que la información se encontró en la cache. A
medida que el tamaño del bloque crece, pasan a la cache más datos útiles. Sin embargo, la
tasa de aciertos comenzará a disminuir.
Universidad Tecnológica Nacional Facultad Regional Villa María
12
BALOG MARTIN AÑO 2010
Función de traducción (mapping): Determina la posición de la cache que ocupará el
bloque. Cuando un bloque se trae a la cache puede que otro tenga que ser reemplazado;
convendría hacer esto de forma que se redujera la probabilidad de reemplazar un bloque
que se vaya a necesitar en un futuro próximo. Cuanto más flexible sea la función de
traducción, más complejo será el sistema de circuitos necesario para determinar si un
bloque dado está en la cache.
Algoritmo de reemplazo: Elige, bajo las restricciones de la función de traducción, el bloque
que hay que reemplazar. Una estrategia bastante efectiva es reemplazar el bloque que
lleva más tiempo en la cache sin que se hayan hecho referencias a él. Esta táctica de
denomina algoritmo del menos usado (LRU, Least Recently Used).
Política de escritura: Dicta cuándo tiene lugar la operación de escribir en memoria. Puede
producirse cada vez que el bloque se actualice. La escritura se produce sólo cuando se
reemplaza el bloque. Reduce las operaciones de escritura en memoria pero deja la
memoria principal en un estado obsoleto.
1.7 Protección por hardware
El hardware detecta los errores de programación, los atrapa y le transfiere el control al sistema
operativo (igual que una interrupción). Se exhibe un mensaje apropiado y se produce un vuelco de
la memoria del programa.
Operación en modo dual
Existe el modo usuario y el modo supervisor o de monitor, para distinguirlos se agrega al hardware
del computador un bit de modo, supervisor (0) o usuario (1). Este tipo de operación ayuda a
proteger el sistema operativo porque las instrucciones de máquina que puedan causar daño se
llaman privilegiadas y solo las ejecuta el modo supervisor.
Protección de E/S
Se definen las operaciones de E/S como privilegiadas, para que sólo las ejecute el modo
supervisor.
Protección de la memoria
Cada programa tiene los siguientes registros de memoria base y limite. El registro Base (empieza),
contiene la dirección de memoria física valida más pequeña; el registro Limite contiene el tamaño
del intervalo. Sólo el sistema operativo carga valores en estos registros con instrucciones
privilegiadas. Véase Figura 1.4
Universidad Tecnológica Nacional Facultad Regional Villa María
13
BALOG MARTIN AÑO 2010
Protección de la CPU
Cuando un programa de usuario no devuelve el control al sistema operativo se utiliza el
temporizador para que interrumpa al computador después de un período determinado, tiene un
reloj fijo y un contador que decrementa en cada tic del reloj.
Figura 1.4 Protección de memoria
Universidad Tecnológica Nacional Facultad Regional Villa María
14
BALOG MARTIN AÑO 2010
2 Introducción a los sistemas operativos
2.1 Conceptos de sistemas operativos
Es un conjunto de programas que actúan como interfaz entre el usuario de una computadora y el
hardware de la misma, controlando y coordinando su uso entre los programas de aplicación y
asignando recursos a los usuarios para hacer el sistema más eficiente y conveniente.
2.2 Funciones y características de los sistemas operativos
Funciones:
Secuenciar las tareas: llevar un cierto orden respecto de los diferentes trabajos que debe
realizar.
Interpretar un lenguaje de control: debe comprender los diferentes tipos de órdenes o
comandos que le imparte el usuario para comunicarse con la computadora para poder
ejecutar las tareas.
Administrar errores y Detección de errores: debe tomar las adecuadas acciones según los
diferentes tipos de errores que se produzcan como así también el permitir la intervención
externa. Por cada tipo de error, el sistema operativo tiene que tomar un tipo de acción
distinto.
Administrar las interrupciones: debe interpretar y satisfacer todas las interrupciones que
se puedan llegar a producir.
Scheduling: administrar equitativamente el recurso procesador entre las diferentes tareas.
Controlar y coordinar los recursos existentes: debe llevar debida cuenta de todos los
recursos como así también del estado en que se encuentran y las funciones que realizan
en todo momento.
Proteger: la información de todos los usuarios entre sí, como así también debe asegurar la
integridad de los datos.
Debe permitir el procesamiento interactivo y ser de fácil interacción para los usuarios.
Control global: de todos los recursos del sistema.
Ejecución de programas: El sistema operativo debe ser capaz de cargarlos, darles el control
y determinar su fin normal o anormal.
Operaciones de E/S: El programa del usuario no puede ejecutar operaciones de E/S
directamente, por lo tanto el sistema operativo tiene que proveer ciertos medios para
hacerlo.
Manipulación del Sistema de Archivos: Los programas se leen y escriben en archivos por
medio del sistema de archivos en diversos dispositivos de almacenamiento.
Accounting: contabilizar los recursos que son usados por cada usuario. Mejora los servicios
de computación.
Características:
Concurrencia: consiste en la existencia de varias actividades simultáneas o paralelas.
Problemas:
Universidad Tecnológica Nacional Facultad Regional Villa María
15
BALOG MARTIN AÑO 2010
Conmutar de una tarea a otra.
Proteger una determinada actividad de los efectos de otra
Sincronizar las tareas que sean mutuamente dependientes.
Tipos de evento:
Eventos paralelos: simula que todos los programas son ejecutados al mismo
tiempo.
Eventos simultáneos: pueden ocurrir en el mismo instante de tiempo.
Eventos pipeline: pueden ocurrir en intervalos de tiempo superpuestos.
Utilización conjunta de recursos: Varias actividades concurrentes tienen que compartir
determinados recursos o información.
Razones:
El costo; es absurdo disponer de infinitos recursos.
La posibilidad de trabajar a partir de lo que hicieron otros.
La posibilidad de compartir datos.
La eliminación de información redundante.
Almacenamiento a largo plazo: Permite que el usuario guarde sus datos o programas en la
computadora. El problema es proporcionar un acceso fácil, la protección de la información
y el resguardo de la misma ante fallas del sistema.
Indeterminismo: El mismo programa ejecutado con los mismos datos ayer u hoy debe
producir los mismos resultados. Es indeterminista en el sentido de que debe responder a
circunstancias que pueden ocurrir en un orden impredecible.
Eficiencia: Algunos criterios son:
Tiempo transcurrido entre tareas
Tiempo ocioso del procesador central
Tiempo de ejecución de las tareas batch
Tiempo de respuesta en los sistemas interactivos
Utilización de los recursos
Rendimiento (tareas ejecutadas por hora)
Fiabilidad: debe estar completamente libre de todo tipo de errores y ser capaz de resolver
satisfactoriamente todas las contingencias que pudiesen presentársele. En la práctica ello
nunca ocurre.
Facilidad de corrección: Debería ser posible corregir o mejorar un sistema operativo. Esto
se puede lograr si el sistema es de construcción modular con interfaces claramente
definidas entre los diferentes módulos. Se suele denominar Sistema Abierto.
Tamaño pequeño: El espacio que consume en la memoria el sistema operativo debería
esperarse que fuera pequeño ya que cuanto mayor es el mismo provoca que exista una
zona mayor no destinada a tareas de los usuarios y está más sujeto a errores.
Universidad Tecnológica Nacional Facultad Regional Villa María
16
BALOG MARTIN AÑO 2010
2.3 Historia y evolución de los sistemas operativos
No está hecho en la próxima versión es probable que aparezca.
2.4 Estructura del SO
Estructura del kernel o núcleo
El núcleo o kernel normalmente representa solo una pequeña parte de lo que por general se
piensa que es todo el sistema operativo, pero es tal vez el código que más se utiliza. Por esta
razón, el núcleo reside en memoria principal, mientras que otras partes del sistema operativo son
cargadas sólo cuando se necesitan. El kernel de un sistema operativo normalmente contiene el
código necesario para realizar las siguientes funciones:
Manejo de interrupciones
Creación y destrucción de procesos
Cambios de estado de los procesos
Despachar, suspender, reanudar y sincronizar los procesos
Comunicación entre procesos
Manipulación de los bloques de control de procesos
Apoyo a las actividades de E/S, asignación y liberación de memoria y gestión del sistema
de archivos
Núcleo monolítico: Como ejemplo de sistema operativo de núcleo monolítico está UNIX. Estos
sistemas tienen un núcleo grande y complejo, que engloba todos los servicios del sistema. Está
programado de forma no modular, y tiene un rendimiento mayor que un micronúcleo. Sin
embargo, cualquier cambio a realizar en cualquier servicio requiere la parada de todo el sistema y
la recompilación del núcleo
Micronúcleo: La arquitectura de micronúcleo ofrece la alternativa al núcleo monolítico. Se basa en
una programación altamente modular y tiene un tamaño mucho menor que el núcleo monolítico.
Como consecuencia, el refinamiento y el control de errores son más rápidos y sencillos. Además, la
actualización de los servicios es más sencilla y ágil, ya que sólo es necesaria la recompilación del
servicio y no de todo el núcleo. Como contraprestación, el rendimiento se ve afectado
negativamente. En la actualidad la mayoría de los sistemas operativos distribuidos en desarrollo
tienden a un diseño de micronúcleo. Los núcleos tienden a contener menos errores y a ser más
fáciles de implementar y de corregir. El sistema pierde ligeramente en rendimiento, pero a cambio
consigue un gran aumento de la flexibilidad.
Sistemas por capas: Consiste en organizar el sistema operativo como una jerarquía de capas, cada
una construida sobre la inmediata inferior. La capa inferior es el hardware, la capa más alta es la
interfaz del usuario.
Una capa del sistema operativo es la implementación de un objeto abstracto que es el
encapsulamiento de datos y de operaciones que pueden manipular esos datos.
Universidad Tecnológica Nacional Facultad Regional Villa María
17
BALOG MARTIN AÑO 2010
La ventaja de este enfoque es la modularidad, la capas se eligen de tal manera que ocupen solo
funciones y servicios de capas de niveles inferiores, otra ventaja es que facilita el diseño e
implementación del sistema.
La desventaja es la definición apropiada de las distintas capas, puesto que las capas pueden usar
las capas que están a un nivel más bajo, la planificación debe ser muy cuidadosa. Otra desventaja
es que tienden a ser menos eficientes.
Maquinas virtuales: Una maquina virtual no es una maquina extendida sino que son una copia
exacta del hardware simple, con su modo núcleo/usuario, E/S, interrupciones y todo lo demás que
posea la maquina real. Un problema de este enfoque es el tema de los discos debido a que la
maquinas virtuales va a requerir considerable espacio en disco.
Una ventaja de este método es que la protección de los distintos recursos del sistema es total,
cada máquina está completamente aislada de las demás, de esta manera es posible compartir un
minidisco y compartir una red de maquinas virtuales.
2.4.1 Componentes y servicios del sistema operativo
Gestión de procesos: Podemos pensar en un proceso como una porción de un programa en
ejecución o todo el programa, como un trabajo por lotes, como un programa de usuario de
tiempo compartido. Un proceso es un trabajo que se ejecuta por lotes o un programa que
se ejecuta en tiempo compartido.
Un proceso necesita de recursos para llevar a cabo su tarea, estos recursos se le otorgan al
proceso en el momento que se lo crea o bien se le asignan durante su ejecución. Cuando el
proceso termine el sistema operativo recuperara cualesquier recursos reutilizables que
haya ocupado, una proceso es una entidad activa, su ejecución se debe realizar en
secuencia. La CPU ejecuta una instrucción de proceso tras otra hasta que el proceso
termina. El sistema consiste en una colección de procesos, algunos de los cuales son
procesos del sistema operativo, siendo el resto del usuario.
El sistema operativo se encarga de las siguientes actividades relacionadas con procesos:
Crear y eliminar
Suspender y reanudar
Proveer mecanismos para la sincronización
Proveer mecanismos para la comunicación
Proveer mecanismos para manejar bloqueos mutuos(deadlocks)
Gestión de la memoria principal: La memoria principal es una matriz grande de palabras o
bytes, cuyo tamaño va desde ciento de miles hasta ciento de millones, cada palabra o byte
tiene su propia dirección. La memoria principal es un depósito de datos a los que se puede
acceder rápidamente y que son compartidos por la CPU y los dispositivos de E/S, es el
único dispositivo de almacenamiento grande que la CPU puede acceder y direccional
directamente, las instrucciones deben estar en la memoria para que las CPU puedan
ejecutarlas. El sistema operativo se encarga de las siguientes operaciones relacionadas con
la gestión de memoria:
Universidad Tecnológica Nacional Facultad Regional Villa María
18
BALOG MARTIN AÑO 2010
Saber cuáles partes de la memoria se están usando actualmente y quien las está
usando.
Decidir cuales procesos se cargaran en la memoria cuando se disponga de espacio.
Asignar y liberar espacio de memoria cuando se necesite.
Gestión de archivos: La gestión de archivos es uno de los componentes más visibles de un
sistema operativo, los computadores pueden almacenar información en distintos tipos de
medios físicos.
Los sistemas operativos presentan una perspectiva lógica uniforme del almacenamiento
de información, abstrayendo las propiedades físicas de sus dispositivos de
almacenamiento para definir una unidad de almacenamiento lógica, el archivo. Un archivo
es una colección relacionada definida por su creador, por lo general representan
programas y datos.
El sistema operativo implementa el concepto abstracto del archivo administrando los
medios de almacenamiento masivo, los archivos se organizan en directorios.
El sistema operativo se encarga de las siguientes actividades relacionadas con la gestión de
archivos:
Crear y eliminar archivos.
Crear y eliminar directorios.
Proveer las primitivas para manipulación de archivos y directorios.
Establecer la correspondencia de los archivos con el almacenamiento secundario.
Resguardar los archivos en medios de almacenamiento estables.
Gestión del sistema de E/S: Uno de los objetivos de un sistema operativo es ocultar las
peculiaridades de dispositivos de hardware específicos de modo que el usuario no las
perciba, el subsistema de E/S oculta las peculiaridades de los dispositivos de E/S del resto
del sistema operativo mismo y consiste en:
Un componente gestión de memoria que incluye el uso de buffers, cache y spool.
Una interfaz general con los controladores de dispositivos.
Drivers para dispositivos de hardware especifico.
Gestión de almacenamiento secundario: Dado que la memoria principal es demasiado
pequeña para dar cabida a todos los archivos y programas y que pierde toda su
información cuando deja de recibir corriente eléctrica, el sistema de computación debe
contar con algún almacenamiento secundario para respaldar a la memoria principal. La
mayor parte de los sistemas de computador utilizan discos como almacenamiento en
línea, casi todos los programas se guardan en un disco hasta que se cargan en la memoria
y luego utiliza al disco como fuente y destino de su procesamiento.
El sistema operativo se encarga de las siguientes actividades relacionadas con la gestión
de discos:
Administración del espacio libre.
Asignación del almacenamiento.
Planificación del disco.
Universidad Tecnológica Nacional Facultad Regional Villa María
19
BALOG MARTIN AÑO 2010
Trabajo con redes: Un sistema distribuido es una colección de procesadores que no
comparten memoria, dispositivos periféricos ni reloj se comunican con los otros
procesadores a través de distintas líneas de comunicación. Los procesadores del sistema
se conectan por medio de una red de comunicaciones, la red puede estar total o
parcialmente conectada y su diseño debe considerar estrategias de encaminamiento y
conexión, también los problemas de contención y seguridad.
Los sistemas operativos normalmente generalizan el acceso por red como una forma de
acceso a archivos.
Sistema de protección: Si un sistema de computación tiene múltiples usuarios y permite la
ejecución concurrente de múltiples procesos, es preciso proteger cada proceso de las
actividades de los demás. Se incluyen mecanismos para asegurar que solo aquellos
procesos que hayan obtenido la autorización debida al sistema operativo puedan operar
con los archivos, segmentos de memoria, procesadores y demás recursos.
El termino protección se refiere a un mecanismo para controlar el acceso de programas,
procesos o usuarios a los recursos definidos por un sistema de computador. Un sistema
orientado hacia la protección permite distinguir entre el uso autorizado y no autorizado.
Sistemas de interpretación de órdenes: Uno de los programas del sistema más importante
de un sistema operativo es el intérprete de órdenes o de comandos, que es la interfaz
entre el usuario y el sistema operativo. Algunos sistemas operativos incluyen el interprete
de ordenes en el núcleo, otros tratan el interprete de ordenes como un programa especial
que se está ejecutando cuando se inicia un trabajo o cuando un usuario ingrese a un
sistema de tiempo compartido.
Cuando se inicia un trabajo nuevo en un sistema por lotes, o cuando un usuario ingrese en
un sistema de tiempo compartido, se ejecuta automáticamente un programa que lee e
interpreta estos enunciados de control, dicho programa recibe el nombre de shell, la
función shell es sencilla: obtener la siguiente orden y ejecutarla.
2.4.2 Implementación de las estructuras de los sistemas operativos
El primer problema que presenta el diseño del sistema es definir sus objetivos y especificaciones.
En el nivel más alto el diseño estará afectado por la selección del hardware y el tipo de
procesamiento que se implementara en el sistema.
La ingeniería de software es el campo general que abarca dichos principios, ciertas ideas de ese
campo son especialmente aplicables a los sistemas operativos.
Un elemento importante es la separación de la política y el mecanismo. Los mecanismos
determinan como se hace algo, las políticas deciden que se hará. Esta separación entre la política y
el mecanismo es muy importante para la flexibilidad.
Las decisiones de política son importantes en todos los problemas de asignación y planificación de
recursos. Siempre que es necesario decidir si se debe asignar o no un recurso hay que tomar una
decisión de política, si la pregunta es “como” no “que” lo que debe determinarse es el mecanismo.
Universidad Tecnológica Nacional Facultad Regional Villa María
20
BALOG MARTIN AÑO 2010
Una vez diseñado un sistema operativo es necesario implementarlo, tradicionalmente los sistemas
operativos se han escrito en lenguajes ensamblador, sin embargo esto ha dejado de ser cierto en
general ahora es posible escribir sistema operativo en lenguajes de alto nivel.
Las ventajas de usar un lenguaje de alto nivel o al menos un lenguaje de implementación de
sistemas para escribir un sistema operativo son:
El código se puede escribir más rápidamente.
Es más compacto y más fácil de entender y depurar.
Las mejoras en la tecnología de compiladores pueden mejorar el código con solo
recompilarlo.
Un sistema operativo es mucho más fácil de transportar.
Una vez que se ha escrito el sistema y que ya está funcionando correctamente es posible
identificar las rutinas que son cuellos de botella y sustituirlas por equivalentes en lenguaje
ensamblador. En varios sistemas, el sistema operativo es quien se encarga de esa tarea
produciendo listados de rastreo del comportamiento del sistema. Todos los sucesos se registran
en una bitácora con sus tiempos y parámetros importantes y se guardan en un archivo. Más
adelante un programa de análisis puede procesar el archivo e identificar los cuellos de botella.
La principal desventaja de usar lenguajes de alto nivel son una menor velocidad y mayores
necesidades de almacenamiento.
2.4.3 Sistemas Abiertos
La idea de sistemas abiertos surge de la necesidad de un sistema operativo estándar mundial; y
éstos deberían ofrecer los siguientes elementos:
Interoperabilidad entre computadoras de cualquier fabricante.
Portabilidad de software en distintos hardware.
Compatibilidad entre diferentes versiones de sistemas operativos.
Escalabilidad del software en diferentes plataformas de hardware.
Existen serias razones que han motivado el surgimiento de los sistemas abiertos, las cuales pueden
resumirse de la siguiente manera:
Los sistemas propietarios obligan a que el mantenimiento de los equipos sea dado por el
mismo proveedor.
La carencia de recursos disponibles: preparación humana, dinero, capacidad de proceso
para emigrar las aplicaciones viejas a las nuevas.
Los usuarios demandaban que los equipos permitieran las comunicaciones entre equipos
de diferentes proveedores.
Conceptos y características
Un sistema abierto es aquel que es capaz de hacer que todos los componentes del sistema de
computación sean compatibles en cualquier ambiente sin importar la compañía que lo haya
producido, que posea un ambiente estándar de aplicaciones disponibles por proveedores
Universidad Tecnológica Nacional Facultad Regional Villa María
21
BALOG MARTIN AÑO 2010
controlados por usuarios y la industria. Para definir un sistema como abierto es necesario tener en
cuenta los siguientes criterios:
Que el sistema cumpla con una especificación bien definida y disponible para la industria.
Que esta especificación sea cumplida por varios productos independientes de diferentes
compañías es decir, que haya varias implementaciones diferentes en el mercado.
Que estas especificaciones no sean controladas por un grupo pequeño de compañías.
Que esta especificación no esté atada a una arquitectura o tecnología específica.
Las características más sobresalientes de un sistema abierto son:
De gran utilidad en ambiente multiusuario.
Poseen procesadores muy poderosos capaces de controlar un gran número de terminales
y capacidades de almacenamiento que sobrepasan los GigaBytes.
Obtienen gran integración de subsistemas de información en una base de datos única.
Menos costosos, complejidad mínima y más flexibles.
No están atados a un solo tipo de hardware propietario.
Poseen un ambiente integrado de información.
Cumplen y/o generan estándares.
Sus especificaciones son generales.
Los software poseen alto grado de portabilidad.
Flexibilidad de los lenguajes de programación.
Manejo de ambientes operativos distintos (desarrollo y producción).
Para que un estándar de sistema abierto sea evaluable, debe tener:
Una consistente y bien documentada interface que exprese claramente todos los tipos
usuales de acciones utilizadas en la clase de aplicaciones que direcciona.
Implementación a través de un amplio rango de hardware.
Patrocinio por parte de un cuerpo de estándares establecidos que tienen la
responsabilidad de mantener la publicación de los requerimientos que los conformen de
manera estable.
Entre los beneficios principales que obtendría el usuario al trabajar con sistemas abiertos se
encuentran:
Mayor provecho de tecnología.
Múltiples proveedores de hardware y software.
Ambiente estándar de aplicaciones.
Múltiples soluciones disponibles de acuerdo con necesidades específicas.
Una mayor protección de la inversión en equipos de cómputos.
Más disponibilidad de aplicaciones.
Disponibilidad de una base amplia de donde obtener referencia.
Los sistemas abiertos incluyen aspectos importantes como:
1. Una mayor extensión
Universidad Tecnológica Nacional Facultad Regional Villa María
22
BALOG MARTIN AÑO 2010
2. Una mayor propiedad
Los sistemas abiertos no sólo abarcan sistemas operacionales, sino un todo de software y
hardware, es un campo tecnológico que tiene interoperabilidad entre los sistemas establecidos y
la nueva técnica.
La potencia de un sistema abierto debe medirse en los siguientes puntos:
Consistentes, bien documentados, que permita expresar claramente los tipos de acciones
más usuales en las diversas aplicaciones.
Capacidad de ser implementado en un amplio rango de equipos.
Fiable de acuerdo a los estándares establecidos
La arquitectura abierta permite al usuario escoger una ruta específica dentro de una gama de
posibilidades, es una arquitectura que enfatiza la interoperabilidad y la flexibilidad.
Existen elementos de vital importancia en un sistema abierto, que son:
Interoperabilidad: Esta característica permite operar entre equipos de arquitecturas
diferentes, nos ofrece la ventaja del uso de distintos periféricos, permite la ejecución de
aplicaciones típicas.
Portabilidad: Es la capacidad del sistema de correr el mismo software en computadoras
con plataformas de hardware distintos entre fabricantes. La portabilidad de aplicaciones la
componen:
Conversión: Es la nueva descripción de códigos fuentes con el objetivo de
funcionar eficientemente en otro sistema.
Portación: Es la recopilación que requieren las aplicaciones cuando el sistema
operacional y los lenguajes de programación tienen que cumplir con los
estándares.
Compatibilidad: Significa que una aplicación pueda moverse de un sistema a otro.
Escalabilidad. Es la habilidad de correr el software en toda plataforma desde un
computador de escritorio hasta un mainframe.
Un sistema abierto es más que un sólo sistema operativo, el software no varía en su arquitectura.
Al cambiar de tecnología las aplicaciones de software se pueden preservar y usar en nuevas
maneras. Esto conlleva a un ahorro de tiempo y de dinero invertido en la programación de las
aplicaciones.
2.5 Categorías de los sistemas operativos
Secuencia por Lotes: Los programas con necesidades similares son introducidos
como lotes y se ejecutan los comandos uno tras otro sin la intervención tidel
usuario.
Multiprogramación: Aumenta la utilización de la CPU, logrando que ésta siempre tenga
algo que ejecutar. Levanta uno de los trabajos de la cola de trabajos y comienza a
ejecutarlo. En el momento en que tenga que esperar por algo, la CPU se entrega a otro
trabajo, y así sucesivamente.
Universidad Tecnológica Nacional Facultad Regional Villa María
23
BALOG MARTIN AÑO 2010
Tiempo Compartido: Existe un procesador para todos los usuarios que utilizan el sistema
todos a la vez. Ejecuta programas separados intercambiando porciones de tiempo,
tratando de obtener un sistema interactivo usando multiprogramación y planificación de
CPU.
Multitareas: Una computadora procesa varias tareas al mismo tiempo.
Monotareas: Solo puede ejecutar las tareas de una en una.
Monousuario: puede atender a un solo usuario.
Multiusuario: Cumplen simultáneamente las necesidades de dos o más usuarios, que
comparten los mismos recursos. Se emplean en redes.
Tiempo Real: Tienen restricciones de tiempo bien definidas, y el procesamiento tiene que
efectuarse dentro de ese intervalo o el sistema fallará.
Tipos:
Tiempo real duro: Garantizan que las tareas críticas se terminarán a tiempo. Estos
sistemas operativos casi nunca tienen memoria virtual por ello son incompatibles
con el funcionamiento de los sistemas de tiempo compartido y no pueden
combinarse con ellos.
Tiempo real blando: Una tarea de tiempo real crítica, goza de prioridad respecto a
otras tareas y conserva esa prioridad hasta que se lleve a cabo.
Multiprocesamiento: Muchas CPU que comparten memoria y periférico
Asignar a cada procesador una tarea específica: Hay un procesador central de
control y los demás tienen tareas específicas.
Uso de redes: Varias computadoras independientes que se comunican e
intercambian datos y archivos. Cada una tiene su propio sistema operativo.
2.6 Definición de sistemas operativos distribuidos
Es una colección de computadoras independientes que aparecen ante los usuarios del sistema
como una única computadora.
Distribuye el cómputo entre varios procesadores que se comunican entre sí a través de diversas
líneas de comunicación, como buses de alta velocidad o líneas telefónicas.
Redes de área local (LANs, Local Area Networks): permiten conectar docenas, e incluso cientos de
máquinas dentro de un edificio, de tal forma que se puede transferir pequeñas cantidades de
información entre ellas en un milisegundo o un tiempo parecido.
Redes de área amplia (WANs, Wide Area Networks): permiten que millones de máquinas en toda
la Tierra se conecten con velocidades que varían de 64 Kbps a Gbts para ciertas redes
experimentales avanzadas.
2.6.1 Objetivos y ventajas
Razones para construir sistemas distribuidos:
Universidad Tecnológica Nacional Facultad Regional Villa María
24
BALOG MARTIN AÑO 2010
Recursos Compartidos: Si varios sitios distintos (con diferentes capacidades) se conectan
entre sí, un usuario de un sitio podría aprovechar los recursos disponibles en otro. el uso
de recursos compartidos en un sistema distribuido ofrece mecanismos para compartir
archivos en sitios remotos y realizar otras operaciones.
Computación más rápida: Si un cálculo dado se puede dividir en varios subcálculos
susceptibles de ejecución concurrente, un sistema distribuido podría permitimos distribuir
el cálculo entre los distintos sitios, y ejecutarlo de forma concurrente. Si un sitio en
particular actualmente está sobrecargado de trabajos, algunos de ellos podrían
transferirse a otros sitios cuya carga sea más ligera. Esta transferencia de trabajos se llama
carga compartida.
Confiabilidad: Si un sitio de un sistema distribuido falla, los sitios restantes podrían seguir
funcionando, el fallo de uno no deberá afectar a los demás.
Comunicación: Hay muchos casos en los que los programas necesitan intercambiar datos
con otros programas del mismo sistema.
Ventajas de los sistemas distribuidos con respecto a los centralizados
Económica: Los microprocesadores ofrecen mejor proporción precio-rendimiento que los
mainframes.
Velocidad: Puede tener mayor poder de cómputo que un mainframe.
Distribución coherente: Algunas aplicaciones utilizan máquinas que están separadas a
cierta distancia.
Confiabilidad: Si una máquina se descompone, el sistema puede sobrevivir como un todo.
Crecimiento por incrementos: Se puede añadir poder de cómputo en pequeños
incrementos.
Ventajas de los sistemas distribuidos con respecto de las PCs independientes
Muchos usuarios necesitan compartir ciertos datos. Estos son absolutamente esenciales, de modo
que las máquinas deben estar conectadas entre sí. La conexión de las máquinas conduce a un
sistema distribuido.
Los datos no son los únicos elementos que se pueden compartir. Otros candidatos son también los
periféricos caros.
Un sistema distribuido tiene mayor flexibilidad potencial que el hecho de darle a cada usuario una
computadora personal aislada. Aunque un modelo consiste en darle a cada persona una PC y
conectarlas mediante LAN, ésta no es la única posibilidad. Otra es tener una mezcla de PC y
compartidas.
Desventajas de los sistemas distribuidos
Software: Existe poco software para los sistemas distribuidos.
Redes: La red se puede saturar o causar otros problemas.
Seguridad: Un acceso sencillo también se aplica a datos secretos.
Universidad Tecnológica Nacional Facultad Regional Villa María
25
BALOG MARTIN AÑO 2010
2.6.2 Aspectos del diseño de los sistemas operativos distribuidos
Transparencia
De localización: Los usuarios no pueden indicar la localización de los recursos.
De migración: Los recursos se puede mover a voluntad sin cambiar sus nombres.
De replica: Los usuarios no pueden indicar el número de copias existentes.
De concurrencia: Varios usuarios pueden compartir recursos de manera automática.
De paralelismo: Las actividades pueden ocurrir en paralelo sin el conocimiento de los
usuarios.
Flexibilidad
Es probable que este proceso tenga muchas salidas falsas y una considerable retroalimentación. La
mejor forma de evitar los problemas es mantener las opciones abiertas. Existen dos escuelas de
pensamiento en cuanto a la estructura de los sistemas distribuidos. Una escuela mantiene que
cada máquina debe ejecutar un núcleo tradicional que proporcione la mayoría de los servicios
(Núcleo Monolítico (a)). La otra sostiene que el núcleo debe proporcionar lo menos posible y que
el grueso de los servicios del sistema operativo se obtenga a partir "de los servidores al nivel
usuario (Micronúcleo (b)). Estos dos modelos, conocidos como el núcleo monolítico y el
micronúcleo, respectivamente
Es decir la flexibilidad lo que hace es difundir la carga de trabajo entre las máquinas disponibles en
la forma más eficaz en cuanto a los costos.
Confiabilidad
Si una máquina se descompone el sistema sobrevive como un todo.
Desempeño
Tiempo de repuesta, rendimiento, uso del sistema y cantidad consumida de la capacidad de la red.
Escalabilidad
Se puede añadir poder de cómputo en pequeños incrementos.
Cuello de botella
Es lo que los diseñadores deben evitar de los sistemas distribuidos
Figura 2.1 Flexibilidad
Universidad Tecnológica Nacional Facultad Regional Villa María
26
BALOG MARTIN AÑO 2010
Sistema operativo de Red
Permiten a los usuarios, en estaciones de trabajo independientes, la comunicación por medio de
un sistema compartido de archivos, pero deja que los usuarios dominen su estación de trabajo.
Sistema operativo Distribuidos
Convierten toda la colección de hardware y software en un sistema integrado, como uno de
tiempo compartido. Permite que un programa se ejecute en varios procesadores a la vez.
Sistema operativo de multiprocesador
Existen varios CPUs, que aparecen como un uniprocesador virtual y comparten la memoria. Allí se
encuentra contenida una estructura de datos llamada cola de ejecución donde esperan los
procesos listos para ejecutarse. Existe una sola copia del sistema operativo.
Universidad Tecnológica Nacional Facultad Regional Villa María
27
BALOG MARTIN AÑO 2010
3 Procesos
3.1 Concepto de proceso y programa
Un proceso es una abstracción de un programa en ejecución, compuesto por el código ejecutable,
una sección de datos que contiene las variables globales, una sección de stack o pila que contiene
datos temporales, tales como parámetros de subrutinas, direcciones de retornos y variables
temporales; y el estado de los registros del procesador; este corresponde a una entidad activa, en
cambio el programa corresponde a una entidad pasiva.
La ejecución de un programa de un usuario también será un proceso.
Un programa es un conjunto de instrucciones, un proceso es un conjunto de instrucciones más su
contexto (BCP) y en ejecución. Ver Figura 3.1
El programa utiliza únicamente memoria secundaria, en cambio el proceso utiliza memoria
principal y procesador.
Un proceso puede involucrar la ejecución de más de un programa. Recíprocamente, un
determinado programa o rutina pueden estar involucrados en más de un proceso. Un proceso es
llevado a cabo por acción de un agente (unidad funcional) que ejecuta el programa asociado. Se
conoce a esta unidad funcional con el nombre de procesador.
La concurrencia puede verse como la activación de varios procesos a la vez. Suponiendo que haya
tantos procesadores como procesos esto no reviste inconveniente alguno. Pero, si sucede como
habitualmente que los procesadores son menos que los procesos se puede lograr una
concurrencia aparente conmutando los procesadores de uno a otro proceso. Si esta conmutación
se lleva a cabo en intervalos lo suficientemente pequeños, el sistema aparentará un
comportamiento concurrente al ser analizado desde la perspectiva de una escala mayor de
tiempo.
Un proceso es una secuencia de acciones y es dinámico, mientras que un programa es una
secuencia de instrucciones y es estático. El no-determinismo y la concurrencia pueden describirse
en términos de interrupciones de procesos entre acciones y de conmutación de procesadores
entre procesos.
En los sistemas multiprogramados, de tiempo compartido que operan sobre una computadora con
un procesador se produce el fenómeno denominado Procesamiento concurrente. Consiste en que
Figura 3.1 Diferencias entre programa y procesos
Universidad Tecnológica Nacional Facultad Regional Villa María
28
BALOG MARTIN AÑO 2010
la CPU alterna la ejecución de los procesos en porciones fijas de tiempo, este fenómeno se le
conoce como Seudoparalelismo, ante los ojos de los usuarios, la ejecución de sus procesos es
paralela; esta ilusión es producto de que el tiempo fijo que asigna el sistema a cada uno de los
procesos es muy pequeño. Cuando el sistema computacional está provisto de varios procesadores,
entonces él puede realizar lo que se denomina Procesamiento paralelo, esto implica que los
procesos pueden ser ejecutados efectivamente en distintos procesadores en forma paralela. La
alternancia de los procesos en el sistema es regulada por el administrador de procesos y obedece
a un algoritmo de planificación. En la Figura 3.2 se refleja el fenómeno de la concurrencia.
3.2 Modelado de los procesos
3.2.1 Jerarquías
Cuando un proceso crea a otro proceso, a través de la llamada de
sistema (fork), el proceso creado se llama “hijo” y el creador
“padre”. Una vez que el hijo fue creado, tanto el padre como el
hijo se ejecutan en forma concurrente. Si un proceso padre
desea cambiar la imagen de su hijo, o sea, asignarle otra tarea,
entonces debe ejecutar una llamada al sistema que le permita
hacerlo (exec).
El padre no debe terminar antes que cualquiera de sus hijos, en
este caso, los hijos quedan huérfanos (defunct o zombie). Existe
otras llamadas a sistema que les permite a los procesos padres
esperar por la muerte de sus hijos: wait, wait3 y waitpid. Cada
hijo le avisa a su padre cuando termina a través de una llamada a
sistema exit.
Los procesos demonios (daemon), los cuales se ejecutan como
parte del sistema y lo hacen en forma asincrónica, permanecen
en estado bloqueado esperando por la ocurrencia de un evento.
Fin de proceso
Mientras se está ejecutando un proceso este puede abandonar su estado por diversas razones:
Figura 3.2 Fenómeno de concurrencia
Figura 3.3 Jerarquías de procesos
Universidad Tecnológica Nacional Facultad Regional Villa María
29
BALOG MARTIN AÑO 2010
FIN NORMAL (Proceso completo)
ERROR (Fin anormal)
NECESITA RECURSOS (E/S, etc) (Pasa a Bloqueado)
DESALOJO (Por algún proceso de mayor prioridad) (Pasa a Listos)
Las dos primeras causales de finalización se refieren al fin Total del proceso, en tanto que las dos
últimas indican solamente un fin temporal del mismo. El término desalojo significa que, por alguno
de los algoritmos de administración de procesador, se considera que el tiempo de uso del
procesador por parte de ese proceso ha sido demasiado alto.
3.2.2 Estados, transiciones y operaciones con procesos
Un proceso se está ejecutando si tiene asignada la CPU. Un proceso está listo si pudiera utilizar una
CPU en caso de haber una disponible. Un proceso está bloqueado si está esperando que suceda
algún evento antes de poder proseguir su ejecución. Solamente puede haber un proceso en
ejecución a la vez, pero puede haber varios listos y varios pueden estar bloqueados. Se forma una
lista de procesos listos y otra de procesos bloqueados. La lista de procesos bloqueados
normalmente no está ordenada; los procesos no se desbloquean en orden de prioridad, sino que
lo hacen en el orden de ocurrencia de los eventos que están esperando.
Transiciones de estado de los procesos
Cuando se admite una tarea en el
sistema, se crea el proceso
correspondiente y se inserta
normalmente al final de la lista de
procesos listos. La asignación del
procesador al primer proceso de la lista
de procesos listos se denomina
despacho; dicha actividad la realiza una
entidad del sistema llamada
despachador. Véase Figura 3.4
Operaciones con procesos
Crear un proceso
Destruir un proceso
Suspender un proceso
Reanudar un proceso
Cambiar la prioridad de un proceso
Bloquear un proceso
Despertar un proceso
Despachar un proceso
Permitir que un proceso se comunique con otro
Crear un proceso implica muchas operaciones como:
Figura 3.4 Transiciones de estado
Universidad Tecnológica Nacional Facultad Regional Villa María
30
BALOG MARTIN AÑO 2010
Dar un nombre al proceso
Insertarlo en la lista de procesos conocidos del sistema (o tabla de procesos)
Determinar la prioridad inicial del proceso
Crear bloque de control de proceso
Asignar los recursos iniciales al proceso
Un proceso puede crear a un nuevo proceso. (Véase en Jerarquía de procesos)
Suspensión y Reanudación
Si un sistema está funcionando mal y es probable que falle, se puede suspender los
procesos activos para reanudarlos cuando se haya corregido el problema.
Un usuario que desconfié de los resultados parciales de un proceso puede suspenderlo (en
vez de abortarlo) hasta que verifique si el proceso funciona correctamente o no.
Algunos procesos se pueden suspender como respuesta a las fluctuaciones a corto plazo
de la carga del sistema y reanudarse cuando las cargas regresen a niveles normales.
Se han añadido dos nuevos estados, denominados suspendido_listo y suspendido_bloqueado los
estados activos, y debajo de ella los estados suspendidos. Véase Figura 3.5
Una suspensión puede ser iniciada por el propio proceso o por otro. En un sistema con un solo
procesador, el proceso en ejecución puede suspenderse a sí mismo; ningún otro proceso podría
estar en ejecución al mismo tiempo para realizar la suspensión. En un sistema de múltiples
procesadores, un proceso en ejecución puede suspender a otro que se esté ejecutando en ese
mismo momento en un procesador diferente. Solamente otro proceso puede suspender un
proceso listo.
Figura 3.5 Transición de estados de los procesos, incluidas la suspensión y la recaudación
Universidad Tecnológica Nacional Facultad Regional Villa María
31
BALOG MARTIN AÑO 2010
Procesamiento de interrupciones
En un sistema de cómputo, una interrupción es un evento que altera la secuencia en que el
procesador ejecuta las instrucciones. La interrupción es generada por el hardware del sistema de
cómputo. Cuando ocurre una interrupción:
El sistema operativo toma el control.
El sistema operativo guarda el estado del proceso interrumpido.
El sistema operativo analiza la interrupción y transfiere el control a la rutina apropiada
para atenderla; en muchos sistemas actuales el hardware se encarga de esto
automáticamente.
La rutina del manejador de interrupciones procesa la interrupción.
Se restablece el estado del proceso interrumpido.
Se ejecuta el proceso interrumpido.
Una interrupción puede ser iniciada específicamente por un proceso en ejecución (en cuyo caso se
suele denominar trampa (trap), y se dice que está sincronizada con la operación del proceso) o
puede ser causada por algún evento que puede estar relacionado o no con el proceso en
ejecución.
Una ventaja importante de las interrupciones es que son una forma económica de llamar la
atención de la CPU, de modo que la CPU no necesita escrutar constantemente los dispositivos para
ver si alguno requiere atención.
Los sistemas orientados hacia las interrupciones pueden sobrecargarse. Si éstas llegan con mucha
frecuencia, el sistema no será capaz de atenderlas.
Clases de interrupciones
Interrupciones SVC (supervisor call, llamadas al supervisor): son iniciadas por un proceso
en ejecución que ejecute la instrucción SVC. Una SVC es una petición generada por el
usuario de un servicio particular del sistema.
El sistema operativo está al tanto de todos los usuarios que intentan rebasar sus límites y
puede rechazar ciertas peticiones si el usuario no tiene los privilegios necesarios.
Interrupciones de E/S: Son iniciadas por hardware de entrada y salida. Estas interrupciones
indican a la CPU el cambio de estado de un canal o un dispositivo. Las interrupciones de
E/S se producen cuando finaliza una operación de E/S o cuando dispositivo pasa al estado
listo, por ejemplo.
Interrupciones externas: Son causadas por diversos eventos. incluyendo la expiración de
un cuanto de un reloj que interrumpe, la pulsación de la tecla de interrupción de la
consola o la recepción de una señal procedente de otro procesador en un sistema de
múltiples procesadores.
Interrupciones de reinicio: Ocurren cuando se presiona el botón de reinicio de la consola o
cuando llega desde otro procesador una instrucción de reinicio SICP (señal del procesador)
en un sistema de múltiples procesadores.
Universidad Tecnológica Nacional Facultad Regional Villa María
32
BALOG MARTIN AÑO 2010
Interrupciones de verificación del programa: Problemas lógicos son causadas por una
amplia clase de problemas que pueden ocurrir cuando se ejecutan las instrucciones en
lenguaje de máquina de un programa. Dichos problemas incluyen la división entre cero, el
exceso o defecto de los números que pueden ser manejados por las operaciones
aritméticas, la presencia de datos con un formato erróneo, el intento de ejecutar un
código de operación inválido, el intento de hacer referencia a una localidad de memoria
que esté fuera de los límites de la memoria real, el intento por parte de un proceso de
usuario de ejecutar una instrucción privilegiada y el intento de hacer referencia a un
recurso protegido.
Interrupciones de verificación de la máquina: Son ocasionadas por el mal funcionamiento
del hardware.
Cambio de Contexto
Este concepto está directamente relacionado con la idea de los sistemas de tiempo compartido. Se
denomina conmutación de contexto al mecanismo mediante el cual el sistema almacena la
información del proceso que se está ejecutando y recupera la información del proceso que
ejecutará enseguida.
3.2.3 Tabla de proceso o BCP
Para manejar la información de todos los procesos, el sistema operativo maneja una tabla de
procesos, la que contiene una entrada son la información de cada proceso, a cada una de estas
entradas en la tabla de procesos se le conoce con el nombre de BCP- BLOQUE DE CONTROL DE
PROCESO contiene el contexto de un proceso y todos los datos necesarios para hacer posible la
ejecución de ese proceso para satisfacer sus necesidades. Véase Figura 3.7
Figura 3.6 Cambio de contexto
Universidad Tecnológica Nacional Facultad Regional Villa María
33
BALOG MARTIN AÑO 2010
Por lo general esta estructura posee diversas informaciones asociadas al proceso, incluyendo:
Estado del proceso: El estado puede ser en ejecución, listo o bloqueado.
Contador de programas: contiene la dirección de la siguiente instrucción.
Información de planificación: Esta información incluye prioridad del proceso, apuntadores
a colas de planificación, etc.
Información contable: incluye cantidad de tiempo de CPU asignado, hora de inicio del
proceso, etc.
Información de planificación de memoria: incluye información de registros límites de
acceso, punteros a segmentos de datos, códigos, etc.
Información del Sistema de archivos: Esta información incluye protecciones, identificación
de usuario, grupo, etc.
Información del estado de E/S: incluye, solicitudes pendientes de E/S, dispositivos de E/S
asignados al proceso, etc.
Pensando en una implementación más dinámica se puede implementar a la TBCP como un
encadenamiento de BCP’s. En forma más detallada cada uno de sus campos contiene:
Apuntador a proceso anterior: El primer BCP tendrá una identificación que lo señale como
tal y deberá ser conocida su ubicación por el Planificador de Procesos.
Apuntador a proceso posterior: El último BCP tendrá un nil(nulo). No se descartan
encadenamientos circulares, pero por ahora se los presenta como lineales.
Identificación de Proceso
Palabra de control: espacio reservado o apuntador en donde se guarda la PC cuando el
proceso no se encuentra en ejecución.
Registros: ídem anterior, pero para los registros de uso general del proceso.
TDP: apuntador al lugar en donde se encuentra la Tabla de Distribución de Páginas
correspondiente a este proceso.
Dispositivos: apuntador a todos los dispositivos a los que tiene acceso el proceso al
momento. Esta información puede ser estática si es necesario que el proceso declare
antes de comenzar su ejecución los dispositivos a usar, o completamente dinámica si
existe la capacidad de obtener y liberar dispositivos a medida que se ejecuta el proceso.
Archivos: ídem Dispositivos pero para los archivos del proceso.
Figura 3.7 Tabla de BCP
Universidad Tecnológica Nacional Facultad Regional Villa María
34
BALOG MARTIN AÑO 2010
Tiempos: Tiempo de CPU utilizado hasta el momento. Tiempo máximo de CPU permitido a
este proceso. Tiempo que le resta de CPU a este proceso.
Estado: Ejecutando. Listo. Bloqueado. Wait (En espera).
Apuntador al BCP del proceso anterior en el mismo estado
Apuntador al BCP del proceso posterior en el mismo estado
Información para el algoritmo de adjudicación del procesador: aquí se tendrá la
información necesaria de acuerdo al algoritmo en uso.
Apuntador al BCP del proceso anterior en función del algoritmo
Apuntador al BCP del proceso posterior en función del algoritmo
Apuntador al BCP del Proceso Padre
Apuntador a los BCP Hijos: Si no tiene contendrá nil.
Accounting: información que servirá para contabilizar los gastos que produce este
proceso.
3.3 Planificación de procesos
La administración del procesador involucra las distintas maneras a través de las cuales el sistema
operativo comparte este recurso entre los distintos procesos que están compitiendo por su uso.
Está enfocada en diferentes aspectos: el primero es la cantidad de procesos (throughput) por
unidad de tiempo que se pueden ejecutar en un sistema; y el segundo, es el tiempo de respuesta
(turnaround time) de esos procesos. La idea de repartir el recurso procesador entre distintos
procesos se debe a que tenemos la posibilidad de utilizar el tiempo de procesador abandonado
por un proceso para que lo pueda usar otro. Esas otras actividades generalmente son de E/S, y
esto es posible porque existe algo que está ayudando a realizar esa E/S, es decir, existen canales o
procesadores de E/S que ayudan a descargar del procesador central esa actividad.
Turnaround o tiempo de respuesta
Normalmente nos encontramos con un proceso A que tiene una cantidad de tiempo de
procesador, y otra cantidad de tiempo muerto desde el punto de vista del procesador, porque está
realizando una operación de E/S, procesa nuevamente, E/S, y procesa nuevamente. La idea es
tratar de, en esos momentos en donde la actividad está descargada en un procesador
especializado en E/S, usar ese tiempo para que otro proceso ejecute.
La ventaja es que los procesos terminan antes del valor esperado en promedio en
monoprogramación.
Lógicamente que suponer que las ráfagas de procesador de uno de los procesos coinciden
exactamente con los tiempos de E/S del otro proceso es prácticamente una ilusión, más aún
considerando que existen otros tiempos asociados a la multiprogramación que complican aún más
la interacción entre los procesos.
O sea, en el primer momento se está ejecutando el proceso A, luego se produce alguna
interrupción provocada por el mismo programa o recibida del exterior, se debe entonces salvar los
registros y la palabra de control del proceso A se satisfará ese pedido, y después se cargarán los
Universidad Tecnológica Nacional Facultad Regional Villa María
35
BALOG MARTIN AÑO 2010
registros y la palabra de control para el proceso B. A este tiempo dedicado a la atención de
interrupciones, salvaguarda y carga de contextos, en suma, el tiempo dedicado por el sistema
operativo a ejecutar sus propias rutinas para proveer una adecuada administración entre los
diferentes procesos se lo suele denominar el overhead (sobrecarga) del sistema operativo.
3.3.1 Niveles de planificación
Planificación de alto nivel: determina cuáles trabajos podrán competir activamente por los
recursos del sistema o cuales trabajos deben admitirse en el sistema, por lo que también
se llama planificación de admisión.
Planificación de nivel intermedio: determina qué procesos pueden competir por la CPU. El
planificador de nivel intermedio responde a las fluctuaciones temporales en la carga del
sistema mediante la suspensión temporal y la activación de procesos para lograr una
operación más fluida del sistema y para ayudar al alcanzar ciertas metas globales de
rendimiento del sistema.
Planificación de bajo nivel: determina a cuál proceso listo se le asignará la CPU cuando
ésta se encuentre disponible, y de hecho se encarga de asignar la CPU a ese proceso (es
decir, despacha la CPU al proceso). El despachador debe residir en todo momento en el
almacenamiento primario.
3.3.2 Objetivos, criterios y algoritmos de planificación
Objetivos
En el diseño de una disciplina de planificación deben considerarse muchos objetivos.
Ser justa: una disciplina de planificación es justa si todos los procesos se tratan de la
misma forma y ningún proceso se aplaza en forma indefinida.
Elevar al máximo la producción o rendimiento: una disciplina de planificación debe tratar
el mayor número de posible de procesos por unidad de tiempo.
Aumentar al máximo el número de usuarios interactivos: que reciben respuesta en
tiempos aceptables.
Ser predecible: una tarea debe ejecutarse aproximadamente en el mismo tiempo y casi al
mismo costo sea cual sea la carga del sistema.
Reducir al mínimo el gasto extra: este punto no suele considerarse como una de los
objetivos más importantes. El gasto extra se considera por lo común como un desperdicio
de recursos del sistema como gasto extra puede mejorar en gran medida el rendimiento
total del sistema.
Equilibrar el aprovechamiento de los recursos: los mecanismos de planificación deben
mantener ocupados los recursos los recursos del sistema.
Lograr un equilibrio entre respuesta y el aprovechamiento: la mejor manera de garantizar
tiempos de respuesta adecuados es tener suficientes recursos disponibles en el momento
en que son necesarios.
Universidad Tecnológica Nacional Facultad Regional Villa María
36
BALOG MARTIN AÑO 2010
Evitar el aplazamiento indefinido: es tan perjudicial como el bloqueo mutuo. La mejor
forma de evitarlo es emplear el envejecimiento, mientras un proceso espera un recurso, su
prioridad debe crecer.
Imponer prioridades: en los ambientes en que se asignan prioridades a los procesos los
mecanismos de planificación deben favorecer a los procesos de más alta prioridad.
Dar preferencia a los procesos que ocupan recursos decisivos: aunque un proceso tenga
baja prioridad, podría estar ocupando un recurso decisivo, y el recuso puede ser requerido
por un proceso de prioridad alta.
Dar un mejor trato a los procesos que muestren un comportamiento deseable.
Degradarse paulatinamente con las cargas pesadas: un mecanismo de planificación no
debe desplomarse bajo el peso de una carga fuerte en el sistema. Debe evitar la carga
excesiva impidiendo la creación de procesos nuevos cuando la carga es pesada.
Muchas de estas metas están en conflicto unas con otras, por lo que la planificación se toma un
problema complejo.
Criterios de planificación
Para lograr los objetivos de planificación, un mecanismo debe considerar:
Limitación de un proceso por E/S: cuando un proceso obtiene la CPU, ¿sólo la usará
brevemente antes de generar una petición de E/S?
Limitación de un proceso por CPU: Cuando un proceso obtiene la UCP, ¿tiende a usarIa
hasta que expira su cuanto de tiempo?
Si un proceso es por lotes o interactivo. Los usuarios interactivos suelen hacer peticiones
"triviales" que deben atenderse de inmediato para garantizar tiempos de respuesta
adecuados.
Cuan urgente es la respuesta.
Las prioridades de los procesos: Los procesos de alta prioridad deben recibir mejor
tratamiento que los de baja prioridad.
La frecuencia con la que un proceso está generando fallas de página: un proceso que
genera pocas fallas de página tiene acumulados sus conjuntos de trabajo en el
almacenamiento principal.
La frecuencia con la que los recursos de un proceso son apropiados por otro de mayor
prioridad: Los procesos cuyos recursos son apropiados muy a menudo deben recibir un
tratamiento menos favorable.
Cuánto tiempo real de ejecución ha recibido el proceso: Algunos diseñadores opinan que
deben favorecer los procesos con poco tiempo de ejecución.
Cuánto tiempo más necesitará el proceso para terminar: Los tiempos de espera promedio
pueden reducirse al mínimo ejecutando primero aquellos procesos que requieran los
menores tiempos de ejecución para terminar.
Planificación apropiativa y no apropiativa
Universidad Tecnológica Nacional Facultad Regional Villa María
37
BALOG MARTIN AÑO 2010
Una disciplina de planificación es no apropiativa si una que la CPU ha sido asignada al proceso, ya
no se le puede arrebatar. Una disciplina de planificación es apropiativa si al proceso se le puede
arrebatar la CPU.
La apropiación tiene un precio. El cambio de contexto implica un gasto extra. Para que la técnica
de apropiación sea efectiva deben mantenerse muchos procesos en almacenamiento principal de
manera que el siguiente proceso se encuentre listo cuando quede disponible la CPU.
En los sistemas no apropiativos, los trabajos largos retrasan a los cortos, pero el tratamiento para
todos los procesos es más justo.
Al diseñar un mecanismo de planificación apropiativa no hay que perder de vista la arbitrariedad
de casi todos los sistemas de prioridades.
Algoritmos de planificación
FIFO o FCFS: Entre las políticas que puede aplicar el planificador de procesos para la
selección de procesos que deben pasar del estado de listos al estado de ejecución existe
obviamente la más trivial, como ser la FIFO (first-in first-out) o FCFS (first come first
served): Significa que el primero que está en la cola es el primero que va a usar el recurso
procesador. No es desalojado del uso del recurso procesador ya que una vez que lo toma
lo sigue usando. En el momento en que se produce una interrupción de E/S, se atenderá la
misma, produciendo momentáneamente el abandono del uso del procesador por parte
del proceso, pero después de finalizada la atención de tal interrupción, el proceso original
retomará el uso de la CPU. No Apropiativa.
Más Corto Primero (JSF) Sin Desalojo: Una de las políticas que siempre da el mejor
resultado para aquello que se quiere ordenar en función del tiempo es la del más corto
primero (Job Short First). Esto implica ordenar los distintos procesos de acuerdo al tiempo
que van a necesitar del recurso procesador. En la práctica es casi imposible saber con
anterioridad cuánto tiempo de procesador va a necesitar un proceso. Lo que se puede
hacer es calcular lo que se presume que va a utilizar. No Apropiativa.
Administración por Prioridades: Otro tipo de administración del procesador consiste en
dar prioridades a los procesos. La idea es que algunos procesos tengan mayor prioridad
que otros para el uso del procesador por razones de criterio.
Por prioridad administrativa.
Por recursos: Administración de Memoria Particionada.
Es necesario implementar un mecanismo que evite un bloqueo indefinido para aquellos
procesos que tienen las más bajas prioridades. Una solución puede ser que a medida que
transcurre el tiempo la prioridad de los procesos relegados se incrementa paulatinamente.
Round-Robin: Esta administración consiste en dar a cada proceso la misma cantidad o
cuota de uso del procesador. La asignación se comporta como una manecilla que recorre
el segmento circular y que al pasar al próximo proceso genera una interrupción por reloj.
A todos los procesos se les da un quantum, que es una medida del tiempo que podrán
usar el procesador antes de ser interrumpidos por reloj. Obviamente puede ocurrir que
cuando le toque al siguiente proceso, éste se encuentre bloqueado por operaciones de
Universidad Tecnológica Nacional Facultad Regional Villa María
38
BALOG MARTIN AÑO 2010
E/S, en tal caso se pasa al siguiente proceso, y el anterior tendrá que esperar que le toque
el procesador nuevamente la próxima vuelta. Apropiativa.
Multicolas: Otra forma de prioridad es asignar distintas colas y distintos quantums
dependiendo del tipo de bloqueo al que llega el proceso o por las características del
proceso. A este esquema se le podría agregar que el programa en ejecución cuando es
interrumpido vaya a alguna de las colas perdiendo el uso del procesador.
Las variantes del Round-Robin y Multicolas pueden ser :
Todos los procesos tienen el mismo Quantum
Si un proceso usó poco procesador se lo puede colocar por la mitad de la cola
Si un proceso acaba de ingresar se le otorga más tiempo
Si un proceso ejecutó muchas veces hasta el límite más alto de quantum sólo se le
permitirá ejecutar cuando no haya otro proceso
Dar preferencia a los procesos que realizan mucha E/S
Dar preferencia a los procesos interactivos
Dar preferencia a los procesos más cortos
Pasar procesos de una cola a otra según el comportamiento que demuestren
Se puede seleccionar de las colas de acuerdo a su historial
Este tipo de administración logra lo que se denomina un Balance General del Sistema debido a que
compensa la utilización de los recursos respecto de la ejecución de los procesos otorgando mayor
prioridad de ejecución (cola de Listos de mayor prioridad) a los procesos que utilizan los
periféricos más lentos y viceversa. Las colas de menor prioridad que contienen a los procesos que
realizan E/S sobre periféricos veloces se encuentran cargadas continuamente ya que el proceso
demora muy poco tiempo en realizar su E/S y vuelve rápidamente a la cola de Listos, las colas de
mayor prioridad usualmente se vacían con bastante frecuencia ya que sus procesos demoran un
tiempo considerable en volver del estado de Bloqueado.
Efecto Residual
El problema de los procesos que están al final de la cola, es que hay que encontrar un mecanismo
para que vuelvan a tener derecho a tomar el recurso procesador, para evitar el efecto residual de
los procesos que no lo tomarían nunca. Para evitar ese defecto lo que se hace es en el momento
en que el proceso abandona el recurso procesador, se realiza una cuenta de cuándo debería ser la
próxima vez que debería tomar el recurso procesador.
Si tuviéramos dos colas:
Hora próxima procesador = Hora actual + (n)Q1 * Quantum1 + (n- 1)Q2 * Quantum Q2
Si el proceso uno abandona el recurso procesador en un determinado instante, se toma la hora
actual, se mira qué cantidad de procesos hay en esa cola y se lo multiplica por el quantum. Puede
suceder que existan procesos en Q2 y Q3 cuya hora de próximo uso de procesador ya haya pasado
hace un rato. Lo que se hace es examinar las colas y, se les asigna el procesador por más que haya
procesos a los cuales les correspondan su uso en colas de más alta prioridad.
Universidad Tecnológica Nacional Facultad Regional Villa María
39
BALOG MARTIN AÑO 2010
3.3.3 Planificación de multiprocesadores
Cuando un sistema informático tiene más de un único procesador, aparecen varios elementos
nuevos en el diseño de la tarea de planificación.
Los sistemas multiprocesador pueden clasificarse de la siguiente manera:
Agrupación o multiprocesador débilmente acoplado o distribuido: consta de un conjunto
de sistemas relativamente autónomos, donde cada procesador tiene su propia memoria
principal y sus propios canales de E/S.
Procesadores especializados funcionalmente: un buen ejemplo son los procesadores de
E/S. Existe un procesador principal, de propósito general; los procesadores especializados
están controlados por el procesador principal y le ofrecen servicios.
Multiprocesador fuertemente acoplado: consta de un conjunto de procesadores que
comparten una memoria principal común y se encuentran bajo el control integrado de un
sistema operativo.
Granularidad (Otra forma de clasificarlos)
Una buena forma de caracterizar los multiprocesadores y situarlos en el contexto de otras
arquitecturas es considerar la granularidad de la sincronización o frecuencia de sincronización
entre los procesos de un sistema. Existen las siguientes categorías de paralelismo:
Paralelismo independiente: No hay sincronización explícita entre los procesos, cada uno
representa una aplicación independiente. Se utiliza en sistemas de tiempo compartido.
Paralelismo de grano grueso y muy grueso: Hay una sincronización muy burda. Los
procesos concurrentes se ejecutan en un monoprocesador multiprogramado.
Paralelismo de grano medio: Hay un grado más alto de coordinación e interacción entre
los procesos y la planificación de un hilo puede afectar al rendimiento de toda la
aplicación.
Paralelismo de grano muy fino: Inherente en un único flujo de instrucciones, especializado
y fragmentado.
Elementos del diseño
En la planificación de un multiprocesador se deben considerar:
Asignación de procesos a los procesadores: consiste en tratar a los procesadores como un
recurso reservado y asignar los procesos a los procesadores.
Uso de la multiprogramación en procesadores individuales: cuando cada proceso se asigna
estáticamente a un procesador durante todo un ciclo de vida.
Expedición de un proceso: es la selección real del proceso a ejecutar.
Planificación de hilos para multiprocesadores
Para asignar los procesadores existen los siguientes métodos:
Reparto de cargas: Los procesos no se asignan a un procesador en particular. Se pueden
utilizar la versión Primero en llegar/Primero en servirse, Primero el de menor número de
hilos o Primero el de menor número de hilos (preferente).
Universidad Tecnológica Nacional Facultad Regional Villa María
40
BALOG MARTIN AÑO 2010
Ventajas: ningún procesador está ocioso mientras haya trabajo pendiente, no se necesita
un planificador centralizado, la cola es global y se puede acceder a ella por cualquier
medio.
Desventajas: La cola central ocupa una región de la memoria a la cual se debe acceder con
exclusión mutua y si muchos procesadores buscan trabajo puede convertirse en cuello de
botella, si cada procesador dispone de una caché local, el uso de la caché será menos
eficiente, es improbable que todos los hilos de un proceso consigan acceder a los
procesadores al mismo tiempo.
Planificación por grupos: Se planifica un conjunto de hilos afines para su ejecución en un
grupo de procesadores, utilizando un reparto uniforme del tiempo y planificación
ponderada por el número de hilos.
Ventajas: Pueden reducirse los bloqueos por sincronización, se necesitan menos
intercambios de procesos y se incrementa el rendimiento, la sobrecarga de planificación
puede reducirse.
Asignación dedicada de procesadores: Consiste en dedicar un grupo de procesadores a
una aplicación mientras dure. Se debería limitar el número de hilos activos al número de
procesadores o bien utilizar el concepto de conjunto de trabajo de actividades donde el
número mínimo de actividades (hilos) que se planifican en los procesadores es aceptable
para que la aplicación procese.
Planificación dinámica: el número de hilos en un programa se puede cambiar en el curso
de la ejecución. Es responsabilidad del sistema operativo, asignar los procesadores. Si el
trabajo que los solicita es recién llegado, se le quita un procesador a otro que tenga más
de uno asignado, si no se puede satisfacer las necesidades del solicitante, éste queda
pendiente. Cuando se libera un procesador, se recorre la cola de peticiones varias veces
asignando los procesadores libres de manera FIFO.
3.3.4 Planificación en Tiempo Real
Es un tipo de procesamiento en el que la exactitud del sistema no depende sólo del resultado
lógico sino también del instante en que se produzca el resultado. En un sistema en tiempo real,
algunas de las tareas so tareas de tiempo real y tienen un cierto grado de urgencia. También,
intentan controlar o reaccionar ante sucesos que tienen lugar en el mundo exterior.
Estas tareas se pueden clasificar en:
Tareas rígidas: deben cumplir el plazo, sino producirá daños no deseados o un error fatal
en el sistema.
Tareas flexibles: tiene un plazo asociado, que es conveniente, pero no obligatorio; aunque
haya vencido el plazo, aún tiene sentido planificar y completar la tarea.
Tareas aperiódicas: debe comenzar o terminar en un plazo o bien puede tener una
restricción tanto para el comienzo como para la finalización.
Tareas periódicas: en este caso, el requisito se puede enunciar como “una vez por cada
periodo T” o “exactamente cada T unidades”.
Universidad Tecnológica Nacional Facultad Regional Villa María
41
BALOG MARTIN AÑO 2010
Características de los sistemas operativos en tiempo real
Requisitos especiales de sus áreas generales son:
Determinismo: hace referencia a cuánto tiempo consume un sistema operativo en
reconocer una interrupción.
Sensibilidad: se refiere a cuánto tiempo consume un sistema operativo en dar servicio a la
interrupción, después de reconocerla.
Control del usuario: se refiere al control que posee el usuario del sistema operativo.
Fiabilidad: se refiere a la capacidad de no perder ni degradar el rendimiento del sistema.
Tolerancia a los fallos: hace referencia a la capacidad de un sistema de conservar la
máxima capacidad y los máximos datos posibles en caso de fallo.
Clases de algoritmos
Métodos con tablas estáticas: realizan un análisis estático de las planificaciones de
expedición posibles. El resultado del análisis es una planificación que determina, en
tiempo de ejecución, cuando debe comenzar la ejecución de una tarea.
Métodos preferentes con prioridades estáticas: también se realiza un análisis estático,
pero no se realiza ninguna planificación. En cambio, se usa dicho análisis para asignar
prioridades a tareas, de forma que se puede emplear un planificador convencional
preferente con prioridades.
Métodos de planificación dinámica: se determina la viabilidad en tiempo de ejecución
(dinámicamente) en vez de antes de empezar la ejecución (estáticamente). Se acepta una
nueva tarea para ejecutar sólo si es factible cumplir sus restricciones de tiempo.
Métodos dinámicos del mejor resultado: no se realiza ningún análisis de viabilidad. El
sistema intenta cumplir todos los plazos y abandona cualquier proceso ya iniciado y cuyo
plazo no se haya cumplido.
Acá están sus planificaciones respectivas:
Planificación con tablas estáticas: es aplicable a tareas periódicas. El planificador intenta
trazar un plan que le permita cumplir las exigencias de todas las tareas periódicas. Este un
método predecible, pero también es inflexible, puesto que cualquier cambio en las
exigencias de una tarea requiere que se trace de nuevo el plan.
Planificación preferente con prioridades estáticas: hace uso del mecanismo de
planificación preferente con prioridades, habitual en la mayoría de los sistemas
multiprogramados que no son en tiempo real. En un sistema que no sea en tiempo real,
puede emplearse una gran variedad de factores para determinar la prioridad.
Planificación dinámica basada en un plan: después de que una tarea llega al sistema, pero
antes de comenzar a ejecutarla, se intenta crear un plan que contenga las tareas
previamente planificadas, así como la recién llegada.
Planificación dinámica del mejor resultado: es el método utilizado en la mayoría de los
sistemas de tiempo real comercializados en la actualidad. Cuando llega una tarea, el
sistema le asigna una prioridad en función de sus características. Con este tipo de
planificación, no se sabe si se va a cumplir una restricción de tiempo hasta que vence el
Universidad Tecnológica Nacional Facultad Regional Villa María
42
BALOG MARTIN AÑO 2010
plazo o la tarea termina. Esta es la mayor desventaja de esta forma de planificación. Su
ventaja está en la facilidad de implementación.
3.4 Comunicación entre procesos
Existen los siguientes tipos de procesos:
Independientes que no afectan ni pueden ser afectados por ningún otro proceso
Cooperativos que si afectan y pueden ser afectados porque comparten tanto la memoria
como recursos y datos.
Para estos últimos existe un problema llamado condiciones de competencia, el cual se refiere a
que dos o más procesos leen o escriben en ciertos datos compartidos y el resultado final
dependiendo de quién ejecuta qué y en qué momento. Se debe impedir que esto ocurra y para
eso se necesita exclusión mutua, que asegura que los recursos no-compartidos sean accedidos por
un solo proceso a la vez. La parte del programa en la cual se tiene acceso a la memoria compartida
se llama sección crítica, nunca dos procesos pueden estar en su sección crítica.
Métodos para lograr la exclusión mutua
Desactivación de interrupciones: Hacer que cada proceso desactive las interrupciones justo
antes de entrar en su sección crítica y las active una vez que saliera de ella. Si hay más de
una CPU, esta acción solo afecta a la CPU, que ejecutó la instrucción. Es conveniente que
el propio núcleo desactive las interrupciones por unas cuantas instrucciones mientras
actualiza variables y listas.
Variables de cerradura: Se cuenta con una variable compartida de cerradura, si ésta es 0 el
proceso cambia el valor a 1 y entra a la región critica. Un 0 indica que no hay procesos en
región critica y un 1 que ese proceso está en región critica.
Instrucción TSL: Se tiene una instrucción TSL (Test and Set Lock) que lee el contenido de
una palabra de memoria en un registro y luego almacena un valor distinto de cero en esa
dirección de memoria. Las operaciones de lectura y almacenamiento son indivisible;
ninguno de los demás procesos pueden tener acceso a la palabra hasta que termine la
instrucción. La CPU que ejecuta TSL cierra el Bus para que las demás CPU no tengan acceso
a la memoria.
Semáforos
Un semáforo es una variable entera a la que una vez que se le ha asignado un valor inicial, solo
puede accederse a través de las siguientes operaciones atómicas estándar: espera y señal. Pueden
contar la cantidad de procesos que hay en espera de un recurso.
Tipos de semáforos
Contadores: Toman valores positivos mayores e iguales a 0. Se utilizan para la
sincronización.
Binarios: Son aquellos cuyo valor binario pueden ser 0 o 1. Se utilizan para la exclusión
mutua.
Universidad Tecnológica Nacional Facultad Regional Villa María
43
BALOG MARTIN AÑO 2010
Se pueden usar para resolver problemas de sección crítica con n procesos y sincronización. Todos
los procesos comparten un semáforo mutex y la principal desventaja es que se requiere de espera
activada que desperdicia ciclo de CPU. La operación bloquear suspende al proceso que la invoca y
la operación despertar reanuda la ejecución del proceso bloqueado.
Bloqueos mutuos o inanición
Un conjunto de procesos está en estado de bloqueo mutuo cuando cada uno de los procesos del
conjunto está esperando un suceso que sólo otro proceso del conjunto puede causar. La inanición
es la situación en la que los procesos esperan indefinidamente dentro del semáforo.
Monitores
Otra construcción de sincronización de alto nivel es el tipo monitor. Un monitor es una colección
de procedimientos, variables y estrucutras de datos, definidas por el programador que se agrupan
en cierto tipo particular de módulo o paquete. La representación consiste en declaraciones de
variables cuyos valores definen su estado. Los procesos pueden llamar a los procedimientos de un
monitor cuando lo deseen. Los monitores tienen la prioridad de permitir que sólo uno de los
procesos esté activo en cada momento dentro del monitor.
3.4.1 Estructura básica
La definición de unidireccional se debe plantear con más cuidado, ya que un enlace podría estar
asociado a más de dos procesos. Así, decimos que un enlace es unidireccional solo si cada proceso
conectado al enlace puede enviar o recibir, pero no ambas cosas, y cada enlace tiene por lo menos
un proceso receptor conectado a el. Hay varios métodos para implementar lógicamente un enlace:
Comunicación directa o indirecta.
Comunicación simétrica o asimétrica.
Uso de buffers automático o explicito.
Envió por copia o envió por referencia.
Mensajes de tamaño fijo o variable.
Comunicación directa: Se debe nombrar explícitamente el destino o remitente. Las propiedades
son:
Se establece automático un enlace y los procesos sólo necesitan saber la identidad del
otro para comunicarse.
Un enlace se asocia a dos procesos.
Entre cada par de procesos solo existe un enlace.
El enlace puede ser unidireccional o bidireccional.
Comunicación indirecta: Los mensajes se envían a, y se reciben de, buzones. Un proceso se puede
comunicar con otro a través de varios buzones. Un buzón puede ser propiedad de un proceso,
donde distinguimos entre el propietario y usuario de dicho buzón, o del sistema operativo, el cuál
tiene existencia propia, es independiente y no está unido a ningún proceso especifico. Las
propiedades son:
Se establece un enlace solo si tienen un buzón compartido.
Universidad Tecnológica Nacional Facultad Regional Villa María
44
BALOG MARTIN AÑO 2010
Un enlace puede estar asociado a más de dos procesos.
Entre cada par puede haber varios enlaces distintos
Los enlaces pueden ser unidireccionales o bidireccionales.
Uso de buffers: Capacidad que determina el número de mensajes que pueden esperar por un
enlace.
Capacidad cero: La cola tiene longitud máxima 0, el enlace no puede tener mensajes
esperando en él. Los dos procesos se deben sincronizar. Esta sincronización se denomina
encuentro.
Capacidad limitada: La cola tiene una longitud finita.
Capacidad ilimitada: Puede esperar cualquier cantidad de mensajes. El emisor nunca
espera.
3.4.2 Condiciones de excepción
Cuando ocurre un fallo en el sistema, éste debe tratar de recuperarse del mismo. Se puede dar
que:
El proceso termina: El emisor o receptor podría terminar antes de que se procese un
mensaje y dejaría mensajes que nunca se recibirán o procesos esperando mensajes que
nunca se enviarán.
Se pierdan los mensajes: Un mensaje podría perderse en la red de comunicación a causa
de un fallo de hardware o de la línea de comunicaciones. Se puede especificar un intervalo
de tiempo durante el cual se esperará la llegada del mensaje de acuse de recibo y si se
vence se supondrá que el mensaje se perdió y se enviará nuevamente.
Se alteraron los mensajes: El mensaje podría llegar a su destino, pero sufrir alteraciones,
por ejemplo, por el ruido del canal de comunicaciones.
3.5 Sincronización de procesos
Un proceso cooperativo es uno que puede afectar o ser afectado por los demás procesos que se
ejecutan en el sistema. Los procesos cooperativos podrían compartir directamente un espacio de
direcciones lógico (es decir, tanto código como datos), o bien compartir datos únicamente a través
de archivos.
3.5.1 El problema de la sección crítica
Cada proceso tiene un segmento de código, llamado sección crítica, en la que el proceso podría
estar modificando variables comunes, actualizando una tabla, escribiendo un archivo, y cosas así.
La característica importante del sistema es que, cuando un proceso se está ejecutando en su
sección crítica, ningún otro proceso puede ejecutarse en su sección crítica. Así, la ejecución de
secciones críticas de los procesos es mutuamente exclusiva en el tiempo. Cada proceso debe
solicitar permiso para ingresar en su sección crítica. La sección de código que implementa esta
solicitud es la sección de ingreso. La sección crítica puede ir seguida de una sección de egreso. El
código que queda es la sección restante.
Universidad Tecnológica Nacional Facultad Regional Villa María
45
BALOG MARTIN AÑO 2010
Una solución al problema de la sección crítica debe satisfacer los requisitos siguientes:
Mutua exclusión: Si el proceso Pi se está ejecutando en su sección critica, ningún otro
proceso puede estarse ejecutando en su sección critica.
Progreso: Si ningún proceso se está ejecutando en su sección critica y hay procesos que
desean ingresar en sus secciones criticas, sólo aquellos procesos que no se estén
ejecutando en su sección restante podrán participar en la decisión de cual proceso será el
siguiente en ingresar en su sección critica.
Espera limitada: Hay un límite para el número de veces que se permite a otros procesos
ingresar en sus secciones criticas después de que un proceso ha solicitado ingresar en su
sección critica y antes de que se le otorgue la autorización para hacerlo.
Las soluciones no dependen de ningún supuesto relacionado con las instrucciones de hardware ni
el número de procesadores que el hardware apoya, pero sí se supone que las instrucciones del
lenguaje de máquina básicas (las instrucciones primitivas como cargar, almacenar y probar) se
ejecutan de forma atómica.
3.5.1.1 Conceptos de exclusión mutua, región crítica
No lo hice
3.5.1.2 Soluciones para dos y múltiples procesos
Los algoritmos que pueden aplicarse a sólo dos procesos a la vez, se detallan a continuación. Los
procesos se numeran P0 y P1. Por comodidad, al presentar Pi, usamos Pj para denotar el otro
proceso; es decir, j = 1 – i.
Algoritmo 1
La primera estrategia es hacer que los procesos compartan una variable entera común turno cuyo
valor inicial es 0 (o 1). Si turno = i, se permite que se ejecute el proceso Pi en su sección crítica.
Esta solución asegura que sólo un proceso a la vez podrá estar en su sección crítica. Sin embargo,
no satisface el requisito de progreso, ya que requiere una alternación estricta de los procesos en la
ejecución de la sección crítica.
Algoritmo 2
El problema del algoritmo 1 es que no retiene suficiente información acerca del estado de cada
proceso; sólo recuerda cual proceso tiene permiso de ingresar en su sección crítica. Para remediar
este problema, podemos sustituir la variable turno por el siguiente arreglo:
var indicador: array[0..1] of boolean;
Los elementos del arreglo tienen como valor inicial false. Si indicador[i] es true, este valor indica
que Pi está listo para ingresar en la sección crítica.
En esta solución se satisface el requisito de mutua exclusión. Desafortunadamente, no satisface el
requisito de progreso.
Algoritmo 3
Universidad Tecnológica Nacional Facultad Regional Villa María
46
BALOG MARTIN AÑO 2010
Si combinamos las ideas clave del algoritmo 1 y el 2, obtenemos una solución correcta al problema
de la sección crítica, en la que se satisfacen los requisitos antes mencionados. Los procesos
comparten dos variables:
var indicador: array[0..1] of boolean;
turno: 0..1;
Inicialmente, indicador [0] = indicador [1] = false, y el valor de turno no importa (pero es 0 o 1).
Para ingresar en la sección crítica, el proceso Pi primero asigna true a indicador[i], y luego dice que
le toca el otro proceso ingresar si es lo apropiado (turno = j). Si ambos proceso tratan de ingresar
al mismo momento. Sólo una de esas asignaciones durará; la otra ocurrirá, pero se sobrescribirá
de inmediato. El valor final de turno decide cual de los dos procesos podrá ingresar en su sección
crítica primero.
Ahora un algoritmo para resolver el problema si tenemos n procesos. Este algoritmo recibe el
nombre de algoritmo de la panadería.
Al entrar en el establecimiento, cada cliente recibe un número, y se atiende al cliente que tienen el
número más bajo. Desafortunadamente, el algoritmo de la panadería no puede garantizar que dos
procesos (clientes) no recibirán el mismo número. En caso de haber un empate, se atiende
primero al cliente que tiene el nombre más bajo. Es decir, si Pi y Pi reciben el mismo número, y si i
< j, se atenderá primero a Pi. Puesto que los nombres de proceso son únicos y totalmente
ordenados, nuestro algoritmo es completamente determinista.
Las estructuras de datos comunes son:
var escogiendo : array[0..n - 1] of boolean;
número: array[0..n - 1] of integer;
3.5.2 Hardware de sincronización
Las características del hardware pueden facilitar la tarea de programación y mejorar la eficiencia
del sistema.
El problema de la sección crítica se podría resolver fácilmente en un entorno uniprocesador si
pudiéramos prohibir las interrupciones mientras se está modificando una variable compartida. Así,
podríamos tener la certeza de que la secuencia de instrucciones actual se ejecutara en orden sin
expropiación.
Desafortunadamente, esta solución no es factible en un entorno multiprocesador. La
desactivación de interrupciones en un multiprocesador puede requerir mucho tiempo, mientras se
envía el mensaje a todos los procesadores. Esta transferencia de mensajes retarda el ingreso en
cada sección crítica, y la eficiencia del sistema disminuye.
Por lo anterior, muchas máquinas cuentan con instrucciones de hardware especiales que nos
permiten determinar y modificar el contenido de una palabra, o bien intercambiar el contenido de
dos palabras, atómicamente.
Universidad Tecnológica Nacional Facultad Regional Villa María
47
BALOG MARTIN AÑO 2010
La instrucción Evaluar-y-Asignar (Test-and-Set, TAS). La característica importante es que esta
instrucción se ejecuta atómicamente; es decir, como una unidad ininterrumpible. Por lo tanto, si
dos instrucciones Evaluar-y-Asignar se ejecutan simultáneamente (cada una en una CPU distinta),
se ejecutaran secuencialmente en algún orden arbitrario.
Si la máquina tienen la instrucción Evaluar-y-Asignar, podemos implementar la mutua exclusión
declarando una variable booleana cerradura, cuyo valor inicial es false.
La instrucción intercambiar, opera sobre el contenido de dos palabras; el igual que la instrucción
Evaluar-y-Asignar, se ejecuta atómicamente.
Si la máquina tiene la instrucción Intercambiar, se puede lograr la exclusión mutua como sigue. Se
declara una variable booleana global cerradura y se le asigna el valor inicial false. Además, cada
proceso tiene una variable booleana local llave.
3.5.3 Semáforos
Las soluciones del problema de la sección crítica, no son fáciles de generalizar a problemas más
complejos. Podemos usar una herramienta de sincronización llamada semáforo un semáforo S es
una variable entera a la que, una vez que se le ha asignado un valor inicial, sólo puede accederse a
través de dos operaciones atómicas estándar: espera (wait) y señal (signal).
Las modificaciones del valor entero del semáforo en las operaciones espera y señal se deben
ejecutar de forma indivisible.
Uso
Podemos usar semáforos para resolver el problema de la sección crítica con n procesos. Todos los
procesos comparten un semáforo, mutex (de mutual exclusión, mutua exclusión) que recibe como
valor inicial 1.
También podemos usar semáforos para resolver diversos problemas de sincronización.
Implementación
La principal desventaja de la definición de semáforos, es que requieren espera activa (busy
waiting). Mientras un proceso está en su sección crítica, cualquier otro proceso que trate de
ingresar en su sección crítica deberá dar vueltas continuamente en su código de ingreso. Este dar
vueltas evidentemente es un problema en un sistema multiprogramado real, en el que una sola
CPU se comparte entre muchos procesos. La espera activa desperdicia ciclos de CPU que algún
otro proceso tal vez podría utilizar productivamente. Este tipo de semáforo también se denomina
cerradura de giro (spinlock) (porque el proceso “da vueltas” mientras espera la cerradura). Las
cerraduras de giro son útiles en los sistemas multiprocesador. Su ventaja es que no requiere una
conmutación de contexto.
La lista de procesos que esperan se puede implementar fácilmente con un campo de enlace en
cada bloque de control de proceso (PCB). Cada semáforo contiene un valor entero y un apuntador
puntero a una lista de PCB.
Universidad Tecnológica Nacional Facultad Regional Villa María
48
BALOG MARTIN AÑO 2010
Debemos garantizar que dos procesos no puedan ejecutar operaciones espera y señal para el
mismo semáforo al mismo tiempo.
En un entorno uniprocesador (es decir, en el que sólo hay una CPU), basta con inhibir las
interrupciones durante la ejecución de las operaciones espera y señal.
En un entorno multiprocesador, si el hardware no ofrece instrucciones especiales, podemos
utilizar cualquiera de las soluciones de software correctas para el problema de la sección crítica,
donde las secciones críticas consisten en los procedimientos espera y señal.
Bloqueos mutuos e inanición
Decimos que un conjunto de procesos está en un estado de bloqueo mutuo cuando cada uno de
los procesos del conjunto está esperando un suceso que sólo otro proceso del conjunto puede
causar. Los sucesos que nos interesan principalmente aquí son la adquisición y liberación de
recursos.
Otro problema relacionado con los bloqueos mutuos es el bloqueo indefinido inanición, una
situación en la que procesos esperan indefinidamente dentro del semáforo. Puede ocurrir un
bloqueo indefinido si agregamos procesos a, y retiramos procesos de, la lista asociada al semáforo
en orden LIFO (last-in, first-out; último que entra, primero que sale).
Semáforos binarios
La construcción de semáforos que describimos en las secciones anteriores se conoce comúnmente
como semáforos de conteo, ya que su valor entero puede variar dentro de un dominio irrestricto.
Un semáforo binario es uno cuyo valor binario sólo puede variar entre 0 y 1.
3.5.4 Problemas clásicos de sincronización
El problema del buffer limitado
Supondremos que la reserva consiste en n bufferes, cada uno de los cuales puede contener un
elemento. El semáforo mutex asegura la mutua exclusión de los accesos a la reserva de buffers e
inicialmente tiene el valor 1. Los semáforos vacios y llenos cuentan el número de buffers vacios y
llenos, respectivamente. El semáforo vacios asume el valor inicial n; llenos se inicia con el valor 0.
El problema de los lectores y escritores
Un objeto de datos (como un archivo o registro) se va a compartir entre varios procesos
concurrentes.
Distinguimos entre procesos llamando lectores a los que sólo están interesados en leer, y
escritores a los demás. Si dos lectores acceden al objeto de datos compartido simultáneamente,
no pasará nada malo. Sin embargo, si un escritor y algún otro proceso (sea lector o escritor)
acceden al objeto compartido simultáneamente, el resultado puede ser un caos.
Para asegurar que tales dificultades no se presenten, exigimos que los escritores tengan acceso
exclusivo al objeto compartido. Este problema de sincronización se denomina problema de
lectores y escritores.
Universidad Tecnológica Nacional Facultad Regional Villa María
49
BALOG MARTIN AÑO 2010
El problema de lectores y escritores tiene varias variaciones, el más sencillo, denominado primer
problema de lectores y escritores, exige que no se mantenga esperando ningún lector a menos
que un escritor ya haya obtenido permiso para usar el objeto compartido. En otras palabras,
ningún lector deberá esperar que otros lectores terminen simplemente porque un escritor está
esperando. El segundo problema de lectores y escritores requiere que, una vez que un escritor
está listo, realice su escritura lo antes posible.
En la solución al primer problema de lectores y escritores, los procesos lectores comparten las
estructuras de datos siguientes.
var mutex, escr: semáforo;
cuentalect: integer;
Los semáforos mutex y escr inician en 1; cuentalect inicia en 0. El semáforo escr es común a los
procesos lectores y escritores. El semáforo mutex sirve para asegurar la mutua exclusión cuando
se actualice la variable cuentalect; la cual lleva a la cuenta de los procesos que están leyendo
actualmente el objeto. El semáforo escr funciona como semáforo de mutua exclusión para los
escritores.
El problema de los filósofos comensales
El problema de los filósofos comensales se considera un problema de sincronización clásico, ya
que es un ejemplo de una clase amplia de problemas de control de concurrencia. Se trata de una
representación sencilla de la necesidad de asignar varios recursos entre varios procesos sin que
haya bloqueos mutuos ni inanición.
3.5.5 Monitores
Otra construcción de sincronización de alto nivel es el tipo monitor. Un monitor se caracteriza por
un conjunto de operadores definidos por el programador.
La construcción de monitor garantiza que sólo podrá estar activo un proceso a la vez dentro del
monitor. La construcción del monitor, tal como se ha definido hasta ahora, no es lo bastante
potente como para modelar algunos esquemas de sincronización adicionales. La construcción
condición proporciona dichos mecanismos.
Las únicas operaciones que se pueden invocar para una variable de condición son espera y señal.
La operación
x.espera
significa que el proceso que invoca esta operación se suspenderá hasta que otro proceso invoque
x.señal
La operación x.señal reanuda uno y sólo un proceso suspendido.
Universidad Tecnológica Nacional Facultad Regional Villa María
50
BALOG MARTIN AÑO 2010
3.5.6 Transacciones atómicas
La mutua exclusión de las secciones críticas asegura que éstas se ejecutarán atómicamente. Hay
muchos casos en los que nos gustaría asegurar que una sección crítica forme una sola unidad
lógica de trabajo que se ejecute hasta terminar o bien no se ejecute en absoluto.
Modelo de sistema
Una colección de instrucciones (operaciones) que realiza una sola función lógica es una
transacción. Un aspecto importante del procesamiento de transacciones es la preservación de la
atomicidad a pesar de la posibilidad de fallos dentro del sistema de computador.
Una transacción es una unidad de programa que accede a, y quizá actualiza, diversos elementos
de datos que podrían residir en el disco dentro de archivos. Desde nuestro punto de vista, una
transacción no es más que una secuencia de operaciones leer (read) y escribir (write), que termina
con una operación confirmar (commint) o bien con un abortar (abort). Una operación de
confirmar indica que la transacción termino su ejecución con éxito, mientras que una de abortar
implica que la transacción tuvo que interrumpir su ejecución normal a causa de algún error lógico.
Al fin de asegurar la propiedad de atomicidad, una transacción abortada no debe tener efecto
alguno sobre el estado de los datos que ya modifico. Así, el estado de los datos accedidos por una
transacción abortada se debe restaurar al que prevalecía justo antes de que la transacción
comenzara a ejecutarse. Decimos que tal transacción se revirtió.
Para determinar la forma en que el sistema debe asegurar la atomicidad, es necesario primero
identificar las propiedades de los dispositivos empleados. Los diferentes tipos de medios de
almacenamiento se distinguen por su velocidad relativa, capacidad e inmunidad a fallos:
Almacenamiento volátil: La información que reside en el almacenamiento volátil casi
nunca sobrevive a una caída del sistema. Ejemplos de estos medios son la memoria
principal y caché. El acceso al almacenamiento volátil es extremadamente rápido, tanto
por la velocidad del acceso a la memoria misma como porque es posible acceder
directamente a cualquier elemento de datos en almacenamiento volátil.
Almacenamiento no volátil: La información que reside en almacenamiento no volátil por lo
regular sobrevive a una caída del sistema. Ejemplos de este tipo de medios son los discos y
pendrive. Por otro lado, tanto los discos como los pendrive están sujetos a fallos, que
pueden causar pérdidas de información.
Almacenamiento estable: La información que reside en almacenamiento estable nunca se
pierde. Para implementar una aproximación de tal almacenamiento necesitamos replicar
la información en varios depósitos de almacenamiento no volátil (usualmente discos) con
modos de fallo independientes, y actualizar la información de forma controlada.
Recuperación basada en bitácoras
Una forma de asegurar la atomicidad es registrar, en almacenamiento estable, información que
describe todas las modificaciones hechas por la transacción a los diferentes datos a los que
accedió. El método más ampliamente utilizado para realizar esta forma de registro es el uso de
Universidad Tecnológica Nacional Facultad Regional Villa María
51
BALOG MARTIN AÑO 2010
bitácoras de escritura adelantada. El sistema mantiene, en almacenamiento estable una
estructura de datos llamada bitácora (log).
Con la ayuda de la bitácora, el sistema puede manejar cualquier fallo que no cause la pérdida de
información en almacenamiento estable. El algoritmo de recuperación emplea los siguientes
procedimientos:
Deshacer(Ti), que restaura el valor anterior de todos los datos actualizados por la
transacción Ti.
Rehacer(Ti), que asigna a todos los datos actualizados por la transacción Ti los nuevos
valores
Las operaciones deshacer y rehacer deben ser idempotentes (es decir, múltiples ejecuciones de
una operación deben tener el mismo resultado que una sola ejecución) para garantizar un
comportamiento correcto, incluso si ocurre un fallo durante el proceso de recuperación.
Punto de verificación (checkpoints)
Cuando ocurre un fallo del sistema, debemos consultar la bitácora para determinar cuáles
transacciones necesitan rehacerse y cuáles necesitan deshacerse. En principio, habrá que
examinar toda la bitácora para hacer estas determinaciones. Tal estrategia tiene las siguientes
desventajas:
El proceso de búsqueda consume mucho tiempo
La mayor parte de las transacciones que, según nuestro algoritmo, deben rehacerse, ya
actualizaron realmente los datos que, según la bitácora.
A fin de reducir estos tipos de gastos extra, introducimos el concepto de puntos de verificación.
Durante la ejecución, el sistema mantiene la bitácora de escritura adelantada.
Transacciones atómicas concurrentes
Puesto que cada transacción es atómica, la ejecución concurrente de transacciones debe ser
equivalente al caso en que esas transacciones se ejecutan en serie en algún orden arbitrario. Esta
propiedad, llamada seriabilidad¸ se puede mantener con sólo ejecutar cada transacción dentro de
una sección crítica. Es decir, todas las transacciones comparten un semáforo común mutex, cuyo
valor inicial es 1.
Seriabilidad
Un plan en el que cada transacción se ejecuta atómicamente se denomina plan serial. Cada plan
serial consiste en una secuencia de instrucciones de diversas transacciones, en que las
instrucciones que pertenecen a una transacción dada aparecen juntas. Así pues, para un conjunto
de n transacciones, existen ¡n! planes seriales validos distintos. Cada plan serial es correcto,
porque equivale a la ejecución atómica de las distintas transacciones participantes, en algún orden
arbitrario.
Si permitimos que la ejecución de dos transacciones traslapen se superponga, el plan resultante ya
no es serial. Para comprobar esto, necesitamos definir el concepto de operaciones en conflicto.
Están en conflicto si acceden al mismo dato, y al menos una de esas operaciones es de escribir.
Universidad Tecnológica Nacional Facultad Regional Villa María
52
BALOG MARTIN AÑO 2010
Protocolo de cerraduras
Una forma de asegurar la seriabilidad es asociar a cada dato una cerradura, y exigir que cada
transacción siga un protocolo de cerraduras (locking protocol) que rija la manera en que se
adquieren y liberan las cerraduras. Hay varios modos de poner cerraduras a un dato.
Compartido: Si una transacción Ti obtuvo una cerradura de modo compartido (denotado
por S) para el dato Q, podrá leer este dato, pero no escribirlo.
Exclusivo: Si una transacción Ti obtuvo una cerradura de modo exclusivo (denotado por X)
para el dato Q, podrá leer y escribir ese dato.
Un protocolo que asegura la seriabilidad es el protocolo de cerraduras de dos fases, el cual exige a
toda transacción emitir solicitudes de cerrar y liberar en dos fases:
Fase de crecimiento: Una transacción puede obtener cerraduras, pero no puede liberar
ninguna cerradura.
Fase de encogimiento: Una transacción puede liberar cerraduras, pero no puede obtener
ninguna cerradura nueva.
Protocolos basados en marcas de tiempo
El orden entre cada par de transacciones en conflicto se determina en el momento de la ejecución
con base en la primera cerradura que ambos solicitan. Otro método consiste en escoger con
anticipación un ordenamiento entre las transacciones. El método más común para hacerlo es usar
un esquema de ordenamiento por marca de tiempo.
A cada transacción Ti del sistema asociamos una marca de tiempo fija única, denotada por TS(Ti).
El sistema asigna esta marca de tiempo antes de que la transacción Ti inicie su ejecución.
Las marcas de tiempo de las transacciones determinan el orden de seriabilidad.
El protocolo de ordenamiento por marca de tiempo asegura la seriabilidad por conflictos. Esta
capacidad es consecuencia del hecho de que las operaciones en conflicto se procesan en orden
por marca de tiempo. El protocolo asegura que no habrá bloqueos mutuos, ya que las
transacciones jamás esperan.
Universidad Tecnológica Nacional Facultad Regional Villa María
53
BALOG MARTIN AÑO 2010
4 Bloqueo - Deadlock
4.1 Tipos de recursos
Los bloqueos pueden ocurrir cuando los procesos obtienen el acceso exclusivo a dispositivos,
archivos, etc. Un recurso puede ser un dispositivo en hardware (por ejemplo un disco rigido) o una
parte de información (por ejemplo. Un registro cerrado (locked) en una base de datos). Es decir un
recurso puede ser cualquier cosa que sólo puede ser utilizada por un único proceso en un instante
dado.
Los recursos dados son de diferentes tipos:
Apropiables: es aquel que se puede tomar del proceso que lo posee sin efectos dañinos.
Ejemplo memoria
No apropiable: es aquel que no se puede tomar de su poseedor activo sin provocar un
fallo de cálculo. Si un proceso comienza a imprimir una salida, se toma la impresora y se le
da a otro proceso, el resultado será una salida incomprensible. Las impresoras no son
apropiables.
Los bloqueos se relacionan con los recursos no apropiables. Lo usual es que los bloqueos
potenciales asociados a recursos apropiables se pueden resolver, mediante la reasignación de
recursos de un proceso a otro.
Secuencia de eventos necesarios para utilizar un recurso es:
1. Solicitar el recurso.
2. Utilizar el recurso.
3. Liberar el recurso.
4.2 Definición de bloqueo
Se puede definir de manera formal como sigue:
Un conjunto de procesos se bloquea si cada proceso del conjunto espera un evento que sólo
puede ser provocado por otro proceso del conjunto.
Puesto que todos los procesos están esperando, ninguno de ellos realizará un evento que pueda
despertar a los demás miembros del conjunto y todos los procesos esperarán por siempre.
4.3 Condiciones para un bloqueo
Las condiciones para la existencia de un bloqueo:
1. Condición de exclusión mutua. Cada recurso está asignado a un único proceso o está
disponible.
2. Condición de posesión y espera. Los procesos que tienen, en un momento dado, recursos
asignados con anterioridad, pueden solicitar nuevos recursos.
3. Condición de no apropiación. Los recursos otorgados con anterioridad no pueden ser
forzados a dejar un proceso. El proceso que los posee debe liberarlos en forma explícita.
Universidad Tecnológica Nacional Facultad Regional Villa María
54
BALOG MARTIN AÑO 2010
4. Condición de espera circular. Debe existir una cadena circular de dos o más procesos, cada
uno de los cuales espera un recurso poseído por el siguiente miembro de la cadena.
Estas condiciones deben estar presentes para que ocurra un bloqueo. Si una de ellas está ausente,
no es posible el bloqueo.
4.4 Modelación de bloqueo
Las graficas tienen diferentes tipos de nodos: procesos (que aparecen como círculos) y recursos
(cuadrados). Un arco de un nodo de recurso a un nodo de proceso indica que el recurso fue
solicitado con anterioridad, fue otorgado y es poseído en este momento por dicho proceso. Figura
4.1(a) Un arco de un proceso a un recurso indica que el proceso está bloqueado, en espera de ese
recurso. Figura 4.1(b)
A D
C
S
T U
BR
(a) (b) (c)
Figura 4.1 Gráficas de asignación de recursos. (a) Posesión de un recurso. (b) Solicitud de un recurso. (c) Bloqueo
Lo que debemos comprender es que las graficas de recursos son una herramienta que nos permite
ver si una secuencia solicitud/liberación conduce a un bloqueo. Lo único que hay que hacer es
realizar las solicitudes y liberaciones, pasó por paso y después de cada paso verificar si la grafica
contiene algún ciclo. En tal caso tenemos un bloqueo.
Estrategias para enfrentar los bloqueos:
1. Simplemente ignorar el problema.
2. Detección y recuperación.
3. Evitarlos en forma dinámica mediante una cuidadosa asignación de recursos.
4. Prevención mediante la negación estructural de una de las cuatro condiciones necesarias.
Examinaremos cada uno de estos métodos en las siguientes cuatro secciones.
4.5 Algoritmo del avestruz
El punto de vista más simple es el algoritmo del avestruz: esconder la cabeza en la arena como
avestruz para pretender que no existe problema alguno.
UNIX sufre potencialmente de bloqueos que ni siquiera se detectan, puesto que se rompen de
manera automática. El número total de procesos en el sistema queda determinado por el número
de entradas en la tabla de procesos. Así, los espacios en la tabla de procesos son recursos finitos.
Si falla un FORK debido a que la tabla está totalmente ocupada, un punto de vista razonable para
el programa que realiza el FORK es esperar un tiempo aleatorio e intentar de nuevo.
Universidad Tecnológica Nacional Facultad Regional Villa María
55
BALOG MARTIN AÑO 2010
El punto de vista de UNIX es simplemente ignorar el problema. Bajo la hipótesis de que la mayoría
de los usuarios preferiría un bloqueo ocasional, en vez de una regla que restringiera a todos los
usuarios a un proceso, un archivo abierto y un algo de cada cosa. Si los bloqueos se pudieran
eliminar, no tendría que haber mucho análisis. El problema es que el precio es alto, lo cual se debe
principalmente a que se pondrían restricciones inconvenientes a los procesos.
4.6 Detección y recuperación
Si se usa esta técnica el sistema operativo, no intenta evitar los bloqueos, sino que deja que
aparezcan, intenta detectar cuando esto ocurre y después lleva a cabo una acción para
recuperarse después del hecho.
Detección de bloqueos de forma un recurso de cada tipo
Comencemos con el caso más sencillo: sólo existe un recurso de cada tipo. Uno de estos sistemas
tendría una impresora, un plotter y una unidad de cinta.
Se conocen muchos algoritmos para la detección de ciclos en las graficas dirigidas. Utiliza una
estructura de datos, L, una lista de nodos. Durante el algoritmo, los arcos se señalan para indicar
que ya han sido inspeccionados.
1. Para cada nodo N de la gráfica, se desarrollan los siguientes pasos, con N como nodo
inicial.
2. Se inicializa L como una lista vacía y todos los arcos se inicializan como no marcados.
3. Se añade el nodo activo al final de L y se verifica si el nodo aparece en L dos veces. Si lo
hace, la gráfica contiene un ciclo (que se enlista en L) y el algoritmo termina.
4. Desde el nodo dado, se verifica si existen arcos que salgan de él y no estén marcados. En
caso afirmativo, se pasa al Paso 5; en otro caso, al Paso 6.
5. Se elige al azar un arco de salida no marcado y se le marca. Después se sigue este arco
hasta el nuevo nodo activo y se regresa al Paso 3.
6. Hemos llegado a un punto donde no podemos continuar. Se regresa al nodo anterior; es
decir, aquel que estaba activo antes de éste; se la señala de nuevo como nodo activo y se
le pasa al Paso 3. Si este nodo era el nodo inicial, la grafica no contiene ciclos y el
algoritmo termina.
Este algoritmo está lejos de ser óptimo. Sin embargo, demuestra la existencia de un algoritmo
para la detección de bloqueos.
Detección de bloqueos de forma varios recursos de cada tipo
Cuando existen varias copias de alguno de los recursos, se necesita un método distinto para la
detección de bloqueos. Presentaremos ahora un algoritmo con base en matrices para la detección
de un bloqueo entre n procesos, P1 hasta Pn. Sea m el número de clases de recursos, con E1
recursos de la clase 1. E2 recursos de la clase 2 y, en general, Ei recursos de la clase i (1 ≤ i ≥ m). E
es el vector de recursos existentes. Proporciona el número total de instancias en existencia de
cada recurso. Por ejemplo si la clase 1 la forman las unidades de cinta E1=2 indica que el sistema
tiene dos unidades de cinta.
Universidad Tecnológica Nacional Facultad Regional Villa María
56
BALOG MARTIN AÑO 2010
En todo momento, algunos de los recursos están asignados y no están disponibles. Sea A el vector
de recursos disponibles, con Ai el número de instancias disponibles del recurso i (es decir, no
asignado). Si las dos unidades están asignadas, entonces A1=0.
Necesitamos ahora dos arreglos, C, la matriz de la asignación actual y R la matriz de solicitudes. El
renglón i-ésimo de C indica el número de instancias de cada clase Pi poseída por el momento. Así,
Cij es el número de instancias del recurso j deseadas por Pi.
Existe un importante invariante para estas cuatro estructuras de datos. En particular, cada recurso
está asignado o disponible. Esto significa que
m
∑ Cij + Aj = Ej i=j
En otras palabras, si sumamos todas las instancias del recurso j asignadas y el número de
instancias disponibles, el resultado es el numero de instancias existentes de esa clase de recurso.
El algoritmo de detección de bloqueos es:
1. Se busca un proceso no marcado Pi, para el que el i-ésimo renglón de R sea menor que A.
2. Si se encuentra tal proceso, se suma el i-ésimo renglón de C a A, se marca el proceso y se
regresa al paso 1.
3. Si no existe tal proceso, el algoritmo termina.
Al concluir el algoritmo, los procesos no marcados, de existir alguno, están bloqueados.
Lo que hace el algoritmo en el paso 1 es buscar un proceso que se pueda ejecutar hasta su final.
Tal proceso se caracteriza por tener demandas de recursos que pueden ser satisfechas por los
recursos disponibles en ese momento. Se ejecuta entonces el proceso seleccionado hasta que
termine, en cuyo momento regresa los recursos que utilizaba al fondo de recursos disponibles.
Ahora que sabemos cómo detectar los bloqueos, surge la cuestión de cuándo buscarlos. Una
posibilidad es verificar esto cada vez que se solicite un recurso. Esto ciertamente los detectaría tan
pronto como sea posible, pero podría ser caro en términos del tiempo de la CPU. Otra alternativa
es verificar cada k minutos o tal vez cuando el uso de la CPU baje de cierto valor fijo. La razón para
tomar en cuenta el uso de la CPU es que si se bloquean suficientes procesos, existirán pocos
procesos en ejecución y la CPU estará inactiva con más frecuencia.
Recuperación de un bloqueo
Supongamos que nuestro algoritmo de detección de bloqueos tiene éxito y detecta un bloqueo. Se
necesita alguna forma de recuperarse y lograr que el sistema continúe nuevamente.
Recuperación mediante la apropiación
Podría ser posible tomar un recurso en forma temporal de su poseedor y dárselo a otro proceso.
La posibilidad de quitar un recurso a un proceso, hace que otro recurso lo utilice y después
regresarlo sin que el proceso lo note depende en gran medida de la naturaleza del recurso. Con
frecuencia, la recuperación mediante esta vía es difícil o imposible. La elección del proceso a
Universidad Tecnológica Nacional Facultad Regional Villa María
57
BALOG MARTIN AÑO 2010
suspender depende de mucho de cuales procesos poseen recursos que pueden ser tomados con
facilidad.
Recuperación mediante rollback
Se pueden hacer que los procesos sean verificados en forma periódica. La verificación de un
proceso indica que su estado se escribe en un archivo de modo que pueda volver a iniciar más
tarde. El punto de verificación no sólo contiene la imagen de la memoria, sino también, los
recursos asignados en ese momento al proceso.
Al detectar un bloqueo, es fácil ver cuáles son los recursos necesarios. Para la recuperación, un
proceso posee un recurso necesario regresa hasta cierto instante en el tiempo anterior a la
adquisición de algún otro recurso, mediante la inicialización de alguno de sus anteriores puntos de
verificación. Todo el trabajo realizado antes del punto de verificación se pierde. Así, el proceso
regresa a un momento anterior en el que no poseía el recurso, el cual se asigna ahora a uno de los
procesos bloqueados. Si el proceso que volvió a iniciar intenta adquirir de nuevo el recurso, tendrá
que esperar hasta que esté disponible.
Recuperación mediante la eliminación de procesos
La forma más cruda, pero más sencilla, de romper un bloqueo es eliminar uno o más procesos.
Una posibilidad es eliminar un proceso del ciclo. Con algo de suerte, los demás procesos podrán
continuar. Si esto no ayuda, se puede repetir hasta romper el ciclo.
Otra alternativa es elegir como víctima un proceso que no esté en el ciclo, para poder liberar sus
recursos.
Cuando sea posible, es mejor eliminar un proceso que pueda volver a iniciar su ejecución sin
efectos dañinos. Por ejemplo, siempre se puede reiniciar una compilación puesto que lo único que
hace es leer un archivo fuente y producir un archivo objeto.
4.7 Evasión de bloqueos
En la mayoría de los sistemas, los recursos se solicitan uno a la vez. El sistema debe poder decidir
si el otorgamiento de un recurso es seguro o no y asignarlo sólo en caso de que sea seguro.
Podemos evitar los bloqueos, siempre que dispongamos de cierta información de antemano.
Trayectoria de recursos
Los principales algoritmos para evitar los bloqueos se basan en el concepto de estados seguros.
Véase la Figura 4.2.
Lo importante a observar aquí es que en el punto t, B solicita un recurso. El sistema debe decidir si
otorgarlo o no. Si lo otorga, el sistema entrara a una región insegura y se bloqueara en algún
momento. Para evitar el bloqueo, hay que suspender a B hasta que A haya solicitado y liberado el
plotter.
Universidad Tecnológica Nacional Facultad Regional Villa María
58
BALOG MARTIN AÑO 2010
Figura 4.2 Trayectorias de recursos de dos procesos
Estados seguros e inseguros
Se dice que un estado es seguro si no está bloqueado y existe una forma de satisfacer todas las
solicitudes pendientes, mediante la ejecución de los procesos en cierto orden.
Es importante observar que un estado inseguro no es un estado bloqueado.
Así, la diferencia entre un estado seguro y uno inseguro es que a partir de un estado seguro, el
sistema puede garantizar la conclusión de todos los procesos, mientras que a partir de un estado
inseguro, no existe tal garantía.
El algoritmo del banquero para sólo un recurso
Un algoritmo de planificación que puede evitar los bloqueos se debe a Dijkstra y se lo conoce
como el algoritmo del banquero. Se modela de la forma en que el banquero de un pueblo
trabajaría con un grupo de clientes a los que ha otorgado líneas de crédito.
El algoritmo del banquero consiste entonces en estudiar cada solicitud al ocurrir esta y ver si su
otorgamiento conduce a un estado seguro. En caso afirmativo, se otorga la solicitud; en caso
contrario, se le pospone. Para ver si un estado es seguro, el banquero verifica si tiene los recursos
suficientes para satisfacer a otro cliente. En caso afirmativo, se supone que estos préstamos se
volverán a pagar; entonces, se verifica al siguiente cliente cercano al límite y así sucesivamente.
El algoritmo del banquero para varios recursos
Universidad Tecnológica Nacional Facultad Regional Villa María
59
BALOG MARTIN AÑO 2010
En la figura 4.3 vemos dos matrices. La de la izquierda muestra el número de recursos asignados
por el momento a cada uno de los cinco procesos. La matriz de la derecha muestra el número de
recursos que necesita cada proceso para terminar.
Los tres vectores a la derecha de la figura muestran los recursos existentes E, los recursos poseídos
P y los recursos disponibles A.
Figura 4.3 El algoritmo del banquero con varios recursos
Mostramos a continuación el algoritmo para decidir si un estado es seguro:
1. Se busca un renglón R cuyas necesidades de recursos no satisfechas sean menores o
iguales que A. Si no existe tal renglón, el sistema se bloqueara en algún momento, puesto
que ningún proceso podrá concluirse.
2. Supongamos que el proceso del renglón elegido solicita todos los recursos que necesita (lo
cual es posible) y concluye. Se señala dicho proceso como concluido y se añaden sus
recursos al vector A.
3. Se repiten los pasos 1 y 2 hasta que todos los procesos queden señalados como
concluidos, en cuyo caso, el estado inicial era seguro; o bien, hasta que ocurra un bloqueo,
en cuyo caso, no lo era.
El algoritmo del banquero fue publicado por Dijkstra. Por desgracia, pocos autores han tenido la
audacia de señalar el algoritmo es maravilloso en la teoría, pero es inútil en la práctica, puesto que
los procesos rara vez conocen de antemano sus necesidades máximas de recursos. Además, el
número de procesos no es fijo, sino que varía en forma dinámica al conectarse y desconectarse los
usuarios. Es más los recursos que se creían disponibles pueden desvanecerse de pronto (las
unidades de cinta pueden descomponerse). Así, en la práctica pocos, si no es ninguno de los
sistemas existentes, utilizan el algoritmo del banquero para evitar los bloqueos.
4.8 Prevención de bloqueos
Una vez que sabemos que es imposible evitar los bloqueos, pues se requiere información acerca
de las futuras solicitudes (lo cual es desconocido). Entonces si podemos garantizar que al menos
Universidad Tecnológica Nacional Facultad Regional Villa María
60
BALOG MARTIN AÑO 2010
una de las condiciones para la existencia de bloqueo nunca se satisface, entonces los bloqueos
serán imposibles por razones estructurales.
Prevención de la condición de exclusión mutua
Si ningún recurso se asigna de manera exclusiva a un solo proceso, nunca tendríamos bloqueos.
Sin embargo, es igual de claro que si permitimos que dos procesos escriban en la impresora al
mismo tiempo se tendría un caos. Con un spooling de la salida a la impresora, varios procesos
podrían generar salida al mismo tiempo.
Por desgracia, no todos los dispositivos pueden hacer uso del spooling (la tabla de procesos no se
presta al spooling)
Evitar la asignación de un recurso cuando no sea absolutamente necesario e intentar asegurarse
de que los menos procesos posibles puedan pedir el recurso.
Prevención de la condición detenerse y esperar
Si podemos evitar que los procesos que conservan recursos esperen más recursos, podemos
eliminar los bloqueos. Una forma de lograr esto es exigir a todos los procesos que soliciten todos
sus recursos antes de iniciar su ejecución. Si todo está disponible, el proceso tendrá asignado todo
lo que necesite y podrá ejecutarse hasta el final.
Un problema inmediato de este punto de vista es que muchos procesos no saben el número de
recursos necesarios sino hasta iniciar su ejecución.
Una forma un poco distinta de romper la condición detenerse y esperar es exigir a un proceso que
solicita un recurso que libere en forma temporal los demás recursos que mantiene en ese
momento. Después, el proceso intenta recuperar todo al mismo tiempo.
Prevención de la condición de no apropiación
Si un proceso tiene asignada la impresora y se encuentra a la mitad de la impresión de su salida, el
hecho de quitarle a fuerza la impresora puesto que no dispone de un plotter es por lo menos
difícil, si no es que imposible.
Prevención de la condición de espera circular
Se puede eliminar de varias formas. Una de ellas es disponer de una regla que indique que un
proceso sólo está autorizado a utilizar un recurso en cada momento. Si necesita otro, debe liberar
al primero. Esta restricción es inaceptable para un proceso que copie un enorme archivo de una
cinta a una impresora.
Otra forma de evitar la espera circular es mediante una numeración global de todos los recursos.
La regla es la siguiente: los proceso pueden solicitar los recursos cuando lo deseen, pero las
solicitudes se deben hacer en orden numérico. Un proceso puede solicitar primero una impresora
y después una unidad de cinta, pero no puede solicitar primero un plotter y después una
impresora.
Universidad Tecnológica Nacional Facultad Regional Villa María
61
BALOG MARTIN AÑO 2010
Una ligera variante de este algoritmo es eliminar el requisito de adquirir los recursos en orden
estrictamente creciente y sólo insistir en que ningún proceso solicite un recurso con número
menor al que posee en el momento.
Aunque el orden numérico de los recursos elimina el problema de los bloqueos, podría ser
imposible encontrar un orden que satisfaga a todos.
Los distintos métodos para prevenir el bloqueo se resumen a continuación:
Exclusión mutua Realizar un spooling general
Detenerse y esperar Solicitar todos los recursos al principio
No apropiación Retirar los recursos
Espera circular Ordenar los recursos en forma numérica
Universidad Tecnológica Nacional Facultad Regional Villa María
62
BALOG MARTIN AÑO 2010
5 Sistema de archivos
5.1 Interfaz con el sistema de archivos
El sistema de archivos proporciona el mecanismo para el almacenamiento y acceso en línea tanto
de datos como de programas del sistema operativo y de todos los usuarios del sistema de
computación. Consiste en distintas partes:
Una colección de archivos: cada uno de los cuales contiene datos relacionados.
Una estructura de directorios: que organiza todos los archivos del sistema y proporciona
información sobre ellos.
Algunos sistemas operativos tienen otra característica más
Particiones: que sirven para separar física o lógicamente grandes colecciones de
directorios.
5.1.1 Concepto de archivo
El sistema operativo abstrae las propiedades físicas de sus dispositivos de almacenamiento para
definir una unidad de almacenamiento lógica, el archivo. El sistema operativo establece una
correspondencia entre archivos y los dispositivos físicos, los cuales generalmente son no volátiles,
así que su contenido persiste a pesar de cortes en la electricidad y rearranques del sistema.
Un archivo es una colección de información relacionada que se graba en almacenamiento
secundario y al cual se asigna un nombre. Casi siempre, los archivos representan programas y
datos. Los archivos de datos pueden ser numéricos, alfabéticos, alfanuméricos o binarios.
Un archivo tiene cierta estructura definida según su tipo:
Texto: es una secuencia de caracteres organizados en líneas (y tal vez en páginas).
Fuente: es una secuencia de subrutinas y funciones, cada una de las cuales consta de
declaraciones seguidas de enunciados ejecutables.
Objeto: es una secuencia de bytes organizados en bloques que el enlazador del sistema
entiende.
Ejecutable: es una serie de secciones de código que el cargador puede traer a la memoria
y ejecutar.
5.1.1.1 Atributos
Un archivo tiene un nombre, para comodidad de sus usuarios humanos, y usamos ese nombre
para hacer referencia al archivo. Algunos sistemas distinguen entre letras mayúsculas y minúsculas
en los nombres, mientras que otros los consideran equivalentes. Una vez que un archivo recibe un
nombre, se vuelve independiente del proceso, el usuario e incluso el sistema que lo creó.
Un archivo tiene otros atributos que varían de un sistema operativo a otro, pero generalmente
son:
Nombre: El nombre simbólico del archivo es la única información que se mantiene en
forma comprensible para seres humanos.
Tipo: Esta información se necesita en sistemas que conocen distintos tipos.
Universidad Tecnológica Nacional Facultad Regional Villa María
63
BALOG MARTIN AÑO 2010
Ubicación: Esta información es un puntero a un dispositivo y a la posición del archivo en
ese dispositivo.
Tamaño: Este atributo incluye el tamaño actual del archivo (en bytes, palabras o bloques),
y tal vez el tamaño máximo permitido.
Protección: La información de control de acceso determina quién puede leer, escribir,
ejecutar, etc., el archivo.
Hora, fecha e identificación del usuario: Esta información podría mantenerse para (1) la
creación, (2) la última modificación y (3) el último uso. Estos datos pueden ser útiles para
protección, seguridad y control de su uso.
La información acerca de todos los archivos se guarda en la estructura de directorios que también
reside en el almacenamiento secundario.
5.1.1.2 Operaciones con archivos
Un archivo es un tipo de datos abstracto. Para definir debidamente un archivo, necesitamos
considerar las operaciones que se pueden realizar con los archivos. El sistema operativo cuenta
con llamadas al sistema para crear, escribir, leer, reubicar, borrar y truncar archivos.
Crear un archivo. Se requieren pasos para crear un archivo
1. Debe encontrarse espacio para él en el sistema de archivos.
2. Es preciso insertar una entrada para el nuevo archivo en el directorio. Esta entrada
registra el nombre del archivo y su ubicación en el sistema de archivos.
Escribir un archivo. Para escribir un archivo, emitimos una llamada al sistema que
especifique tanto el nombre del archivo como la información que se escribirá en él.
Leer un archivo. Para leer de un archivo usamos una llamada al sistema que especifica el
nombre del archivo y el lugar (de la memoria) donde deberá colocarse el siguiente bloque
de archivo.
Reubicarse dentro de un archivo. Se busca en el directorio la entrada apropiada y se asigna
un valor dado a la posición actual del archivo. Esta operación también se la conoce como
búsqueda en un archivo.
Eliminar un archivo. Para eliminar un archivo, buscamos en el directorio el archivo
nombrado. Una vez que se encuentra la entrada correspondiente, se libera todo el espacio
que el archivo ocupa (para que otros archivos puedan usarlo) y se borra la entrada del
directorio.
Truncar un archivo. Hay ocasiones en que el usuario desea que los atributos de un archivo
no cambien, pero desea borrar el contenido del archivo. Para que el usuario no tenga que
borrar el archivo y después volver a crearlo, esta función permite dejar todos los atributos
sin alteración (exceptuando la longitud del archivo) y hacer que el archivo tenga la
longitud cero.
Anexión (appending) de información nueva al final de un archivo existente.
Cambio de nombre (renaming) de un archivo existente.
Universidad Tecnológica Nacional Facultad Regional Villa María
64
BALOG MARTIN AÑO 2010
Generalmente, el sistema operativo tiene dos niveles de tablas internas. Hay una tabla por
proceso de todos los archivos que cada proceso tiene abiertos. En esa tabla se guarda información
acerca del uso que el proceso da al archivo.
Cada entrada de la tablada de proceso apunta a su vez a una tabla de archivos abiertos que abarca
todo el sistema. Esta tabla contiene información independiente de los procesos, como la ubicación
del archivo en disco, las fechas de acceso y el tamaño del archivo.
Cada archivo abierto tienen asociados varios elementos de información:
Puntero al archivo. El sistema debe seguir la pista a la última posición de lectura/escritura
con un puntero a la posición actual en el archivo
Contador de aperturas del archivo. Cuando los archivos se cierran, el sistema operativo
debe reutilizar sus entradas de la tabla de archivos abiertos, pues de lo contrario podría
quedarse sin espacio en la tabla. Este contador sigue la pista al número de aperturas y
cierres, y llega a cero después del último cierre. Entonces, el sistema puede eliminar la
entrada.
Ubicación del archivo en disco. La mayor parte de las operaciones con archivos solicitan al
sistema modificar datos del archivo. La información necesaria para localizar el archivo en
el disco se mantiene en la memoria para no tener que leerla del disco en cada operación.
5.1.1.3 Tipos de archivos
Una consideración importante al diseñar un sistema de archivos, y todo el sistema operativo, es si
este último debe reconocer y manejar tipos de archivos. Si un sistema operativo reconoce el tipo
de un archivo, puede trabajar con él de maneras razonables.
Una técnica común para implementar los tipos de archivos es incluir el tipo como parte del
nombre del archivo. El nombre se divide en diferentes partes: un nombre y una extensión,
generalmente separados por un carácter de punto.
Tipo de archivo Extensión usual Función
Ejecutable exe, com, bin o ninguna Programa en lenguaje de maquina listo para ejecutase
Objeto obj, o Compilado, en lenguaje de máquina, no enlazado
Código fuente c, p, pas, f77, asm, a Código fuente en diversos lenguajes
Por lotes bat, sh Ordenes al intérprete de ordenes
Texto txt, doc Datos textuales, documentos
Procesador de textos wp, tex, rrf, etc. Formatos de diversos procesadores de textos
Biblioteca lib, a Bibliotecas de rutinas para programadores
Impresión o visualización
ps, dvi, gif Archivo en ASCII o binario en un formato para impresión o visualización
Archivado arc, zip, tar Archivos relacionados agrupados en un solo archivo, a veces comprimido para almacenarse
Tabla 5.1 Tipos de archivos comunes
Universidad Tecnológica Nacional Facultad Regional Villa María
65
BALOG MARTIN AÑO 2010
El sistema utiliza la extensión para indicar el tipo del archivo y el tipo de operaciones que pueden
realizarse con ese archivo. Por ejemplo, sólo es posible ejecutar un archivo que tenga una
extensión “.com”, “.exe”, o “.bat”. Los archivos “.com” y “.exe” son dos formas de archivos
ejecutables binarios, mientras que un archivo “.bat” es un archivo por lotes (batch) que contiene,
en formato ASCII órdenes para el sistema operativo.
5.1.1.4 Estructuras de archivos
Los tipos de archivo también pueden servir para indicar la estructura interna del archivo.
Algunos sistemas operativos imponen (y reconocen) un número mínimo de estructuras de archivo.
UNIX, MS-DOS y otros han adoptado este enfoque. UNIX considera a cada archivo como una
secuencia de bytes de ocho bits; el sistema operativo no interpreta de manera alguna esos bits.
Semejante esquema ofrece un máximo de flexibilidad, pero poco apoyo. Cada programa de
aplicación debe incluir su propio código para interpretar un archivo de entrada y determinar la
estructura apropiada. Todos los sistemas operativos deben reconocer al menos una estructura – la
de un archivo ejecutable – para que el sistema pueda cargar y ejecutar programas.
Otro ejemplo de sistema operativo que reconoce un número mínimo de estructuras es el
Macintosh Operating System, que espera que los archivos contengan partes:
Rama de recursos (resource fork). Contienen información de interés para el usuario.
Rama de datos (data fork). Contiene código o datos del programa el contenido tradicional
de un archivo.
Si hay muy pocas estructuras la programación se dificulta; si hay demasiadas, el sistema operativo
crece excesivamente y el programador podría confundirse.
Estructura interna de los archivos
Internamente, localizar una posición relativa dentro de un archivo puede ser complicado para el
sistema operativo. Toda la E/S de disco se realiza en unidades de un bloque (registro físico), y
todos los bloques tienen el mismo tamaño. Es poco probable que el tamaño de los registros físicos
coincida exactamente con la longitud del registro lógico deseado. Una solución común a este
problema es empaquetar varios registros lógicos en bloques físicos.
El tamaño de registro lógico, el tamaño de bloque físico y la técnica de empaquetado determinan
el número de registros lógicos que hay en cada bloque físico. El empaquetado puede correr por
cuenta ya sea del programa de aplicación del usuario o bien del sistema operativo.
En cualquier caso, el archivo puede considerarse como una secuencia de bloques. Todas las
funciones de E/S básicas operan en términos de bloques. La conversión de registros lógicos en
bloques físicos es un problema de software relativamente sencillo.
Cabe señalar que el hecho de que el espacio en disco siempre se asigne por bloques hace que, en
general, alguna porción del último bloque de cada archivo se desperdicie. Los bytes
desperdiciados que se asignan para manejar todo en unidades de bloques (en vez de bytes) son
fragmentación interna. Todos los sistemas de archivos padecen fragmentación interna; cuanto
mayor es el tamaño de bloque, mayor es la fragmentación interna.
Universidad Tecnológica Nacional Facultad Regional Villa María
66
BALOG MARTIN AÑO 2010
5.1.2 Métodos de acceso
Los archivos guardan información. Para usar esta información es preciso leerla y colocarla en la
memoria del computador. Hay varias formas de acceder a la información del archivo. Algunos
sistemas ofrecen únicamente un método de acceso a los archivos; otros, como el de IBM, manejan
muchos métodos de acceso distintos.
Acceso secuencial
Es el más sencillo. La información del archivo se procesa en orden, un registro tras otro. Este modo
de acceso es, por mucho, el más común.
El grueso de las operaciones con archivos son lecturas y escrituras. Una operación de lectura lee la
siguiente porción del archivo y automáticamente adelanta un puntero de archivo, que sigue la
pista de posición de E/S. Así mismo, una escritura anexa información al final del archivo y adelanta
el puntero al final de ese material (el nuevo final de archivo). Figura 5.1. Este acceso se basa en un
modelo de archivo de cinta, y funciona tan bien en los dispositivos de acceso secuencial como en
los de acceso aleatorio.
Figura 5.1 Archivo de acceso secuencial
Acceso directo o Acceso relativo
El método de acceso directo de los archivos se basa en el modelo de discos, ya que estos permiten
el acceso aleatorio a cualquier bloque de archivo. Para el acceso directo, el archivo se visualiza
como una secuencia numerada de bloques o registros.
Los archivos de acceso directo son muy útiles para obtener acceso inmediato a grandes cantidades
de información. Las bases de datos suelen ser de este tipo. Cuando llega una consulta relacionada
con un tema en particular, calculamos el número de bloque que contiene la respuesta y luego
leemos directamente ese bloque para obtener la información deseada.
Las operaciones con archivos deben modificarse para incluir número de bloque como parámetro.
Así, tenemos leer n y escribir n, donde n es el número de bloque.
El número de bloque que el usuario proporciona al sistema operativo normalmente es un número
de bloque relativo, que es un índice relativo al principio del archivo. El empleo de número de
bloque relativos permite al sistema operativo decidir dónde colocará el archivo y ayudara a
impedir que el usuario acceda a porciones del sistema de archivos que tal vez no formen parte de
su archivo. Algunos sistemas usan 0 como primer número de bloque relativo; otros usan 1.
Otros métodos de acceso
Universidad Tecnológica Nacional Facultad Regional Villa María
67
BALOG MARTIN AÑO 2010
Es posible definir otros métodos de acceso con base en el método de acceso directo. Estos
métodos adicionales generalmente implican la construcción de un índice para el archivo. El índice
contiene punteros a los diversos bloques. Para encontrar un registro en el archivo, primero
efectuamos una búsqueda en el índice y luego usamos el puntero para acceder al archivo
directamente y encontrar el registro deseado. Figura 5.2.
En casos de archivos grandes, el archivo de índice mismo podría ser demasiado grande para
mantenerse en la memoria. Una solución es crear un índice del archivo índice. El archivo índice
primario contendría punteros a archivos de índice secundarios, que apuntarían a los datos
propiamente dichos.
Figura 5.2 Ejemplo de archivos de índice y relativos
5.1.3 Estructura de directorios
Los sistemas de archivos de los computadores pueden ser muy extensos. Para administrar todos
esos datos, necesitamos organizarlos. Esta organización por lo regular se efectúa en partes:
El sistema de archivos se divide en particiones, también llamadas minidiscos en el mundo
de IBM o volúmenes en los ámbitos de PC y Macintosh. Cada disco de un sistema contiene
al menos una partición que es una estructura de bajo nivel en la que residen archivos y
directorios. A veces se usan particiones para contar con varias áreas independientes
dentro de un disco, cada una de las cuales se trata como un dispositivo de
almacenamiento aparte.
Cada partición contiene información acerca de los archivos que hay en ella. Esta
información se mantiene como entradas de un directorio de dispositivo o tabla de
contenido de volumen, conocido más comúnmente sólo como “directorio”, registra
información – como nombre, ubicación tamaño y tipo – de todos los archivos de esa
partición.
Al considerar una estructura de directorios en particular, hay que tener en mente las operaciones
que se realizarán con un directorio:
Buscar un archivo. Necesitamos poder examinar una estructura de directorios para hallar
la entrada de un archivo específico.
Universidad Tecnológica Nacional Facultad Regional Villa María
68
BALOG MARTIN AÑO 2010
Crear un archivo. Es preciso crear archivos nuevos y agregarlos al directorio.
Eliminar un archivo. Si un archivo ya no se necesita, querremos eliminarlo del directorio.
Listar un directorio. Necesitamos poder exhibir una lista de todos los archivos de un
directorio, y el contenido de la entrada de directorio para cada archivo de la lista.
Cambiar el nombre de un archivo. Puesto que el nombre de un archivo da a sus usuarios
una idea de su contenido, debemos poder cambiar el nombre si cambia el contenido o el
uso de un archivo.
Recorrer el sistema de archivos. Es útil poder acceder a todos los directorios y a todos los
archivos dentro de una estructura de directorios. Por confiabilidad, es aconsejable guardar
el contenido y la estructura del sistema de archivos a intervalos regulares.
Directorio de un solo nivel
La estructura de directorio más sencilla es la de un solo nivel. Todos los archivos se guardan en el
mismo directorio, que es fácil de manejar y mantener. Figura 5.3.
Un directorio de un solo nivel tiene limitaciones importantes cuando el número de archivos
aumenta o si hay más de un usuario. Puesto que todos los archivos están en el mismo directorio,
deben tener nombres únicos.
Incluso si hay un solo usuario a medida que el número de archivos aumenta se hace difícil recordar
los nombres de todos los archivos, a fin de crear sólo archivos con nombres únicos.
Figura 5.3 Directorio de un solo nivel
Directorio de dos niveles
La desventaja principal de los directorios de un solo nivel es la confusión de nombres de archivos
entre diferentes usuarios. La solución estándar es crear un directorio individual para cada usuario.
En la estructura de directorio de dos niveles, cada usuario tiene su propio directorio de archivos de
usuario (UFD, user file directory). Cada UFD tiene una estructura similar, pero lista sólo los archivos
de un usuario. Cuando se inicia un trabajo de usuario o un usuario inicia una sesión, se realiza una
búsqueda en el directorio de archivos maestro (MFD, master file directory), el cual esta indizado
por nombre de usuario o número de cuenta; cada entrada apunta al UFD de ese usuario. Véase la
Figura 5.4.
La estructura de directorio de dos niveles resuelve el problema de conflictos entre nombres, pero
aún tiene problemas. Tal estructura aísla efectivamente un usuario de otro. Este aislamiento es
una ventaja cuando los usuarios son totalmente independientes, pero es una desventaja cuando
los usuarios quieren cooperar en alguna tarea y acceder uno a los archivos del otro. Algunos
Universidad Tecnológica Nacional Facultad Regional Villa María
69
BALOG MARTIN AÑO 2010
sistemas simplemente no permiten que otros usuarios accedan a los archivos locales de un
usuario.
Si se va a permitir el acceso, un usuario debe poder nombrar un archivo del directorio de otro
usuario. Para nombrar un archivo de forma única en un directorio de dos niveles, hay que
proporcionar tanto el nombre del usuario como el del archivo. La especificación de un nombre de
usuario y un archivo define un camino (path) desde la raíz (el directorio maestro) a una hoja (el
archivo especificado). Así, un nombre de usuario y un nombre de archivo definen un nombre de
camino. Todo archivo del sistema tiene un nombre de camino. Para obtener un archivo de forma
única, un usuario debe conocer el nombre del camino del archivo deseado.
Un caso especial ocurre con los archivos de sistema. Los programas se proporcionan como parte
del sistema generalmente se definen como archivos. Para no tener que copiar los archivos de
sistema en cada uno de los directorios de usuarios, (para que estos los puedan utilizar porque el
sistema de directorios buscaría a los archivos en el directorio de archivos de usuario actual), pero
esto implicaría un enorme desperdicio de espacio.
Una solución estándar es complicar un poco el procedimiento de búsqueda. Se define un
directorio de usuario especial que contiene los archivos del sistema (por ejemplo el usuario 0).
Cada vez que se proporciona un nombre de archivo para cargarlo, el primer lugar donde el sistema
operativo busca es el directorio de usuario local. Si se encuentra el archivo, se usa; si no, el sistema
busca automáticamente en el directorio de usuario especial que contiene los archivos de sistema.
Figura 5.4 Estructura de directorios de dos niveles
Directorio con estructura de árbol
Después de haber visto cómo puede conceptuarse un directorio de dos niveles como un árbol de
dos niveles, la generalización natural es extender la estructura de directorios a un árbol con altura
arbitraria. Véase la Figura 5.5. Esta generalización permite a los usuarios crear sus propios
subdirectorios y organizar sus archivos de manera acorde. El árbol es la estructura de directorios
más común. Un árbol tiene un directorio raíz y cada archivo del sistema tiene un nombre de
camino único; este es el camino que se sigue desde la raíz a través de todos los subdirectorios,
hasta un archivo determinado.
Un directorio (o subdirectorio) contiene un conjunto de archivos o subdirectorios. Un directorio no
es más que otro archivo, pero se trata de manera especial. Todos los directorios tienen el mismo
formato interno.
Universidad Tecnológica Nacional Facultad Regional Villa María
70
BALOG MARTIN AÑO 2010
Figura 5.5 Estructura de directorios de árbol
Cuando se hace referencia a un archivo, este se busca en el directorio actual. Si se requiere un
archivo que no está en el directorio actual, el usuario deberá especificar un nombre de camino o
bien cambiar de directorio actual de modo que sea el que contiene ese archivo.
Los nombres de camino pueden ser de diferentes tipos:
Absolutos parte de la raíz y sigue un camino descendiente hasta el archivo especificado,
dando los nombres de directorio que están en el camino.
Relativos define un camino a partir del directorio actual.
Si permitimos al usuario definir sus propios subdirectorios, podrá imponer una estructura a sus
archivos. Dicha estructura podría incluir directorios individuales para archivos relacionados con
diferentes temas o diferentes formas de información.
Una decisión de política importante en una estructura de directorios de árbol es cómo manejar la
eliminación de un directorio. Si un directorio está vacío, podría simplemente borrarse su entrada
en el directorio que lo contiene. Supongamos que el directorio por eliminar no está vacío, sino que
contiene archivos, o posiblemente subdirectorios. Se puede adoptar una de las dos políticas.
Algunos de los sistemas, no eliminan un directorio si no está vacío. Así, para eliminar un directorio,
el usuario debe eliminar primero todos los archivos de ese directorio.
Una estrategia alternativa, es ofrecer la opción de que, cuando se solicita eliminar un directorio, se
eliminen también todos los archivos y subdirectorios de ese directorio. La segunda política es más
cómoda, pero más peligrosa, ya que permite eliminar toda una estructura de directorios con una
sola orden.
En un sistema de directorios con estructura de árbol, los usuarios pueden acceder además de sus
archivos, a los archivos de oros usuarios. Especificando sus nombres de camino.
Universidad Tecnológica Nacional Facultad Regional Villa María
71
BALOG MARTIN AÑO 2010
Directorio de grafo acíclico
Cuando dos usuarios o más están trabajando en un proyecto conjunto. Los archivos asociados a
ese proyecto se pueden almacenar en un directorio para separarlos de los otros proyectos y
archivos de los usuarios. El subdirectorio común debería compartirse. Un directorio o archivo
compartido existe en el sistema de archivos en dos (o más), lugares al mismo tiempo. Cabe señalar
que un archivo (o directorio) compartido no es lo mismo que dos copias del archivo. Con dos
copias, cada usuario podría ver su copia en vez del original, pero si un usuario modifica el archivo,
los cambios no aparecen en la copia del otro. Con un archivo compartido solo hay un archivo real,
así que cualquier modificación hecha por una persona será de inmediato visible para la otra. Esta
forma de compartir tiene especial importancia en el caso de los directorios compartidos; un
archivo nuevo creado por una persona aparecerá automáticamente en todos los subdirectorios
compartidos.
Un grafo acíclico permite a los directorios tener subdirectorios y archivos compartidos. Véase la
Figura 5.6. El mismo archivo o subdirectorio puede estar en dos directorios distintos.
Figura 5.6 Estructura de directorios de grafo acíclico
Los archivos y subdirectorios compartidos se pueden implementar de varias formas. Una de las
más comunes consiste en crear una nueva entrada de directorio llamada enlace (link). Un enlace
es realmente un puntero a otro archivo o subdirectorio. Por ejemplo un enlace podría
implementarse como un nombre de trayectoria absoluto o relativo (un enlace simbólico). Los
enlaces se identifican fácilmente por su formato en la entrada de directorio, y de hecho son
punteros indirectos con nombre. El sistema operativo hace caso omiso de estos enlaces al recorrer
los arboles de directorio a fin de preservar la estructura acíclica del sistema.
Otro enfoque para la implementación de archivos compartidos es sencillamente duplicar toda la
información acerca de ellos en los dos directorios que los comparten. Así, ambas entradas serán
idénticas e iguales. Las entradas de directorio duplicadas, en cambio, hacen indistinguibles el
Universidad Tecnológica Nacional Facultad Regional Villa María
72
BALOG MARTIN AÑO 2010
original y la copia. Un problema importante de las entradas de directorio duplicadas es el
mantenimiento de la consistencia si se modifica el archivo.
Una estructura de directorios de grafo acíclico es más flexible que un árbol sencillo, pero también
es más compleja. Es preciso analizar con cuidado varios problemas: un archivo puede tener
múltiples nombres de camino absoluto, y es posible que nombres de archivos distintos se refieran
al mismo archivo. Si estamos tratando de recorrer todo el sistema de archivos es problema se
vuelve importante, ya que no queremos recorrer las estructuras compartidas más de una vez.
Otro problema tiene que ver con la eliminación. Una posibilidad es quitar el archivo cuando
alguien lo elimina, pero esta acción podría dejar punteros “colgantes” que apunten a un archivo
que ya no existe.
En un sistema en el que el comportamiento se implementa con enlaces simbólicos, esta situación
es un poco más fácil de manejar. La eliminación de un enlace no tiene que afectar el archivo
original; sólo se elimina el enlace. En el caso de UNIX, los enlaces simbólicos se dejan cuando un
archivo se elimina, y es obligación del usuario darse cuenta de que el archivo original no existe o
ha sido reemplazado.
Otra forma de manejar la eliminación es conservar el archivo hasta que se hayan eliminado todas
las referencias a él. Para implementar tal estrategia, debemos contar con algún mecanismo para
determinare si ya se elimino la última referencia al archivo. Podríamos mantener una lista de
todas las referencias a un archivo. Cuando se establece un enlace o copia de la entrada de
directorio, se agrega una nueva entrada a la lista de referencias al archivo. Cuando un enlace o
entrada de directorio se borra, se quita su entrada de la lista. El archivo se elimina cuando una lista
de referencias está vacía.
No es necesaria realmente mantener toda la lista; basta con llevar sólo una cuenta del número de
referencias.
Para evitar estos problemas, algunos sistemas no permiten directorios compartidos ni enlaces.
Directorio de grafo general
La ventaja principal de un grafo acíclico es la relativa sencillez de los algoritmos que recorren el
grafo y que determinan si ya no hay mas referencias a un archivo. Nos interesa evitar recorrer dos
veces las secciones compartidas de un grafo acíclico, principalmente por razones de desempeño.
Si se permite la existencia de ciclos en el directorio, también nos interesara evitar las búsquedas
repetidas de cualquier componente.
Cuando existen ciclos, también es posible que la cuenta de referencias sea distinta de cero aunque
ya no sea posible referirse a un directorio o archivo. Esta anomalía es un resultado de la
posibilidad de autorreferencias (ciclos) en la estructura de directorios. Es este caso, generalmente
es necesario utilizar un esquema de recolección de basura para determinar cuándo se ha
eliminado la última referencia y el espacio en disco puede liberarse. La recolección de basura
implica recorrer todo el sistema de archivos marcando todo aquello a lo que puede accederse. En
una segunda pasada, se junta todo lo que no se marcó en una lista de espacio libre. La desventaja
Universidad Tecnológica Nacional Facultad Regional Villa María
73
BALOG MARTIN AÑO 2010
de la recolección de basura en un sistema basado en discos en que se consume mucho tiempo y
por esa razón pozas veces se intenta.
La recolección de basura solo es necesaria por la posibilidad de que haya ciclos en el grafo. Por ello
es mucho más fácil trabajar con una estructura de grafo acíclico.
5.1.4 Protección
Cuando se guarda información en un sistema de computación, una preocupación importante es su
protección tanto de los datos físicos (confiabilidad) como de un acceso indebido (protección).
La confiabilidad generalmente se logra duplicando los archivos. Muchos computadores tienen
programas del sistema que copian automáticamente (o por intervención del operador) los
archivos de disco en cinta a intervalos regulares para mantener una copia en caso de destruirse
accidentalmente un sistema de archivos. Tal destrucción puede ocurrir por problemas de
hardware (como errores al leer o escribir), picos o interrupciones en el suministro de electricidad,
suciedad, extremos de temperatura y vandalismo.
La protección se puede proporciona de muchas maneras. En un sistema monousuario pequeño,
podríamos protege los archivos retirando físicamente los discos flexibles y guardándolos bajo llave
en un cajón del escritorio o un archivero. En un sistema multiusuario se necesitan otros
mecanismos.
5.1.4.1 Tipos de accesos
La necesidad de proteger los archivos es un resultado directo de la capacidad para acceder a ellos.
En los sistemas que no permiten el acceso a los archivos de otros usuarios no se necesita
protección. Así, un extremo seria brindar protección absoluta prohibiendo el acceso. El otro
extremo es proporcionar acceso libre sin protección. Ambas estrategias son demasiado extremas
para un uso general. Lo que se necesita es un acceso controlado.
Los mecanismos de protección proporcionan acceso controlado limitando las formas en que puede
accederse a los archivos. El acceso se permite o niega dependiendo de varios factores, uno de los
cuales es el tipo de acceso solicitado. Pueden controlarse varios tipos de operaciones distintas:
Leer. Leer un archivo
Escribir. Escribir o reescribir un archivo
Ejecutar. Cargar el archivo en la memoria y ejecutarlo
Anexar. Escribir información nueva al final del archivo.
Eliminar. Borrar el archivo y liberar su espacio para una posible reutilización
Listar. Listar el nombre y los atributos de un archivo
La protección solo puede proporcionarse en el nivel más bajo.
5.1.4.2 Listas y grupos de accesos
La forma más común de abordar el problema de la protección es hacer que el acceso dependa de
la identidad del usuario. El esquema más general para implementar el acceso dependiente de la
Universidad Tecnológica Nacional Facultad Regional Villa María
74
BALOG MARTIN AÑO 2010
identidad es asociar a cada archivo y directorio una lista de acceso que especifique el nombre del
usuario y los tipos de acceso que se permiten a cada usuario.
El principal problema de las listas de acceso es su longitud. Si queremos permitir a todo mundo
leer un archivo, debemos indicar acceso de lectura para todos los usuarios de la lista. Esta técnica
tiene consecuencias indeseables:
La construcción de semejante lista podría ser una tarea tediosa e inútil, sobre todo si no
conocemos anticipadamente la lista de usuarios del sistema.
La entrada de directorio que antes tenía un tamaño fijo ahora necesita ser de tamaño
variable, lo que complica la administración del espacio.
Estos problemas pueden resolverse empleando una versión condensada de la lista de acceso.
Para condensar la lista de acceso, muchos sistemas reconocen categorías de usuarios en relación
con cada archivo:
Propietario. Es el usuario que creó el archivo.
Grupo. Un conjunto de usuarios que están compartiendo el archivo y necesitan un acceso
similar es un grupo, o grupo de trabajo.
Universo. Todos los demás usuarios del sistema constituyen el universo.
Con esta clasificación de protección más limitada, sólo se necesitan tres campos para definir la
protección. Cada campo suele ser una colección de bits, cada uno de los cuales permiten o
impiden el acceso correspondiente. Por ejemplo, el sistema UNIX define tres campos de tres bits
cada uno: rwx, donde
r controla el acceso de lectura,
w controla el acceso de escritura y
x controla la ejecución
Se mantiene un campo para el propietario del archivo, uno para el grupo del propietario y uno
para todos los demás usuarios. En este esquema se necesitan nueve bits por archivo para registrar
la información de protección.
Cabe señalar que este esquema no es tan general como el de la lista de acceso. Supongamos que
se desea excluir a un integrante de la lista de personas (integrantes del universo) que pueden leer
el texto.
Otras estrategias de protección
Otra forma de abordar el problema de la protección: asociar una contraseña a cada archivo. El
acceso a cada archivo se puede controlar por medio de una contraseña. Si las contraseñas se
escogen al azar y se cambian a menudo, este esquema podría ser eficaz para limitar el acceso a un
archivo a los usuarios que conocen la contraseña. Este esquema tiene varias desventajas:
Si asociamos una contraseña distinta a cada archivo, el número de contraseñas que un
usuario necesitara recordar podría ser grande, y el esquema dejaría de ser practico. Si sólo
se usa una contraseña para todos los archivos, y llega a descubrirse todos los archivos
estarán accesibles.
Universidad Tecnológica Nacional Facultad Regional Villa María
75
BALOG MARTIN AÑO 2010
Es común que sólo se asocie una contraseña a cada archivo, lo que implica que la
protección es de todo o nada. Si queremos proporcionar protección en un nivel más
detallado, necesitamos varias contraseñas.
Cabe señalar que en una estructura de directorios con varios niveles, no sólo es necesario proteger
a los archivos individuales sino un mecanismo de protección de directorios. Nos interesa controlar
la creación y eliminación de archivos en un directorio. La operación listar el contenido de un
directorio también debe protegerse.
5.2 Implementación de un sistema de archivos
Se ocupa primordialmente de cuestiones relacionadas con el almacenamiento de archivos y el
acceso a ellos en el medio de almacenamiento secundario más común, el disco. Exploraremos las
formas de asignar espacio en disco, recuperar espacio liberado, encontrar los datos y establecer la
comunicación entre otras partes del sistema operativo y el almacenamiento secundario.
5.2.1 Estructuras del sistema de archivos
Para mejorar la eficacia de E/S, las transferencias entre la memoria y el disco se efectúan en
unidades de bloques. Cada bloque ocupa uno o más sectores. Dependiendo de la unidad de disco,
el tamaño de los sectores varía entre 32 bytes y 4096 bytes, aunque por lo general es de 512
bytes. Los discos tienen características importantes que los convierten en un medio cómodo para
almacenar muchos archivos:
Se pueden reescribir en el mismo lugar; es posible leer un bloque del disco, modificar el
bloque y volverlo a escribir en el mismo lugar.
Podemos acceder directamente a cualquier bloque de información del disco. Esto facilita
el acceso ya sea secuencial o aleatorio a cualquier archivo, y el cambio de un archivo a
otro sólo requiere mover las cabezas de lectura-escritura y esperar que el disco gire.
Organización del sistema de archivos
Para ofrecer un acceso eficiente y cómodo al disco, el sistema operativo impone en él un sistema
de archivos que permite almacenar, encontrar y recuperar con facilidad los datos. Un sistema de
archivos presenta problemas de diseño muy distintos:
Definir qué aspecto debe presentar el sistema de archivos a los usuarios. Esta tarea
implica la definición de un archivo y sus atributos, las operaciones que se permiten con un
archivo y la estructura de directorios para organizar los archivos.
Hay que crear algoritmos y estructuras de datos que establezcan una correspondencia
entre el sistema de archivos lógico y los dispositivos de almacenamiento físico.
El sistema de archivos en sí generalmente se compone de muchos niveles diferentes. Véase la
Figura 5.7. Cada nivel de diseño aprovecha las funciones de los niveles inferiores para crear nuevas
funciones que se usaran en los niveles superiores.
El nivel más bajo, el control de E/S, consta de drivers o controladores (en software) de dispositivos
y manejadores de interrupciones para transferir información entre la memoria y el sistema de
disco. El driver de dispositivo por lo regular escribe patrones de bits específicos en posiciones
Universidad Tecnológica Nacional Facultad Regional Villa María
76
BALOG MARTIN AÑO 2010
especiales de la memoria del controlador de E/S para decirle a éste sobre qué posición del
dispositivo debe actuar y qué acciones debe emprender.
Figura 5.7 Sistema de archivos por capa
El sistema de archivos básico sólo necesita emitir órdenes genéricas al driver de dispositivo
apropiado para leer y escribir bloques físicos en el disco. Cada bloque físico se identifica con su
dirección numérica en disco.
El módulo de organización de archivos conoce los archivos y sus bloques lógicos, además de los
bloques físicos. Sabiendo el tipo de asignación de archivos empleada y la ubicación del archivo, el
módulo de organización de archivos puede traducir las direcciones de bloques lógicos en
direcciones de bloques físicos para que el sistema de archivos básico realice la transferencia.
También incluye el administrador de espacio libre, que sigue la pista a los bloques no asignados y
los proporciona al módulo de organización de archivos cuando se le solicitan.
Por último el sistema de archivos lógico emplea la estructura de directorios para proporcionar al
módulo de organización de archivos la información que éste necesita, a partir de un nombre de
archivo simbólico. El sistema de archivos lógico también se encarga de la protección y la seguridad.
Antes de que el archivo pueda usarse para procedimientos de E/S, es preciso abrirlo. Cuando un
archivo se abre, se busca la entrada deseada en la estructura de directorios. Es común que partes
de dicha estructura se guarden en una caché de memoria para agilizar las operaciones con
directorios. Una vez localizado el archivo generalmente se copia en una tabla en la memoria,
llamada tabla de archivos abiertos, que contiene información acerca de todos los archivos que
actualmente están abiertos Tabla 5.2.
Universidad Tecnológica Nacional Facultad Regional Villa María
77
BALOG MARTIN AÑO 2010
El índice para esta tabla se devuelve al programa de usuario, y todas las referencias posteriores se
hacen a través del índice, no de un nombre simbólico. El nombre que se da al índice varía. Los
sistemas UNIX lo llaman descriptor de archivo; Windows NT lo llama mando de archivo (file
handle); y otros sistemas lo llaman bloque de control de archivo (FCB, file control block). En tanto
no se cierre el archivo, todas las operaciones con él se harán a través de la tabla de archivos
abiertos.
índice nombre de
archivo permisos fechas de acceso puntero a bloque
de disco
0 Prueba.c rw rw rw …
1 Correo.txt rw
2 . . .
n Tabla 5.2 Tabla de archivos abiertos representativa
Montaje de sistemas de archivos
Así como un archivo debe abrirse antes de poder usarse, un sistema de archivos debe montarse
antes de estar disponible para todos los procesos del sistema. El procedimiento de montaje es
sencillo. Se proporciona al sistema operativo el nombre del dispositivo, junto con la posición
dentro de la estructura de archivos en la que se debe adosar (attach) el sistema de archivos
(llamada punto de montaje).
Luego, el sistema operativo verifica que el dispositivo contenga un sistema de archivos válido; esto
lo hace pidiendo al driver de dispositivo que lea el directorio del dispositivo y compruebe que
tenga el formato esperado. Por último, el sistema operativo está montado en el punto de montaje
especificado. Este esquema permite al sistema operativo recorrer su estructura de directorios,
conmutando entre sistemas de archivos según sea apropiado.
5.2.2 Métodos de asignación
La naturaleza de acceso directo de los discos nos brinda flexibilidad en la implementación de los
archivos. En casi todos los casos, muchos archivos se almacenan en el mismo disco. El problema
principal es cómo asignar espacio a esos archivos de modo que el espacio se aproveche de forma
eficaz y se pueda acceder rápidamente a los archivos. Hay métodos de asignación de espacio en
disco que se usan ampliamente: contigua, enlazada e indizada. Cada método tiene sus ventajas y
desventajas.
Asignación contigua
El método de asignación contigua requiere que cada archivo ocupe un conjunto de bloques
continuos en el disco. Las direcciones de disco definen un ordenamiento lineal en él. El número de
búsquedas de disco necesarias para acceder a archivos asignados contiguamente es mínimo, lo
mismo que el tiempo de búsqueda cuando finalmente se necesita una búsqueda. La asignación
contigua de un archivo está definida por la dirección en disco y la longitud (en unidades de bloque)
Universidad Tecnológica Nacional Facultad Regional Villa María
78
BALOG MARTIN AÑO 2010
del primer bloque. Si el archivo tiene n bloques, y comienza en la posición b, ocupara los bloques,
b, b + 1, b + 2,…, b +n – 1. La entrada de directorio para cada archivo indica la dirección del bloque
inicial y la longitud del área asignada a este archivo (Véase la Figura 5.8).
Una dificultad de la asignación contigua es encontrar espacio para un archivo nuevo. Las
estrategias de primer ajuste y mejor ajuste son las que más comúnmente se usan para seleccionar
un hueco libre del conjunto de huecos disponibles.
Estos algoritmos padecen el problema de la fragmentación externa. Hay fragmentación externa
siempre que el espacio libre se divide en trozos, y se convierte en un problema cuando el trozo
contiguo más grande es insuficiente para una solicitud; el almacenamiento se fragmenta en varios
huecos, ninguno de los cuales es lo bastante grande como para contener los datos.
La asignación contigua tiene otros problemas. Uno de los más importantes es determinar cuánto
espacio se necesita para un archivo. Cuando se crea un archivo, es preciso encontrar la cantidad
total de espacio que necesitara, y asignarla.
Si asignamos un espacio demasiado pequeño a un archivo, podríamos encontrarnos con que ya no
podemos extender ese archivo.
Un archivo que crece lentamente durante un periodo largo (meses o años) tendría que recibir
inicialmente suficiente espacio para su tamaño final, aunque gran parte de ese espacio no se
ocupe durante largo tiempo. En este caso el archivo tiene una gran cantidad de fragmentación
interna.
Figura 5.8 Asignación contigua de espacio en disco
Asignación enlazada
Resuelve todos los problemas de la asignación contigua. Cada archivo es una lista enlazada de
bloques de disco, los cuales pueden estar dispersos en cualquier parte del disco. El directorio
contiene un puntero al primer y al último bloque del archivo (Véase la Figura 5.9). Cada bloque
contiene un puntero al siguiente bloque. Estos punteros no se proporcionan al usuario. Así, si cada
Universidad Tecnológica Nacional Facultad Regional Villa María
79
BALOG MARTIN AÑO 2010
bloque tiene 512 bytes, y una dirección de disco (el puntero) requiere cuatro bytes, el usuario vera
bloques de 508 bytes.
Figura 5.9 Asignación enlazada de espacio en disco
Cuando se usa asignación enlazada no hay fragmentación externa, pues cualquier bloque libre de
la lista de espacio libre se puede usar para satisfacer una solicitud. Además, no hay necesidad de
declarar el tamaño de un archivo en el momento de crearlo. Un archivo puede continuar
creciendo en tanto haya bloques libres.
Uno de los problemas de la asignación enlazada. El principal de ellos es que sólo puede usarse
efectivamente para archivos de acceso secuencial. Cada acceso a un puntero requiere una lectura
del disco, y a veces una búsqueda de disco. Por consiguiente no resulta eficiente proveer una
capacidad de acceso directo para archivos de asignación enlazada.
Otra desventaja de la asignación enlazada es el espacio que ocupan los punteros. Si un puntero
requiere cuatro bytes de un bloque de 512 bytes, el 0.78% del disco se usará para punteros, no
para información. Cada archivo requiere un poco más de espacio del que requería en otro caso.
La solución usual a este problema es juntar bloques en múltiplos, llamados cúmulos (clusters), y
asignar los cúmulos en lugar de los bloques. Los cúmulos pueden servir para mejorar el tiempo de
acceso a disco con muchos otros algoritmos, y es por ello que se usan en casi todos los sistemas
operativos.
Un problema adicional es la confiabilidad. Dado que los archivos se enlazan mediante punteros
que están dispersos por todo el disco, consideremos lo que sucedería si un puntero se perdiera o
dañara.
Una variación importante del método de asignación enlazada es usar una tabla de asignación de
archivos (FAT, file-allocation table). Se aparta una sección del disco al principio de cada partición
para guardar en ella la tabla, la cual tienen una entrada para cada bloque del disco y esta indizada
por número de bloque. La FAT se usa de manera similar a una lista enlazada. La entrada de
directorio contiene el número de bloque del primer bloque de archivo. La entrada de la tabla
Universidad Tecnológica Nacional Facultad Regional Villa María
80
BALOG MARTIN AÑO 2010
indizada por ese número de bloque contiene el número del siguiente bloque de archivo. Esta
cadena continua hasta el último bloque, que tiene una valor especial de fin-de-archivo (end of file)
como entrada de tabla (Véase la Figura 5.10).
Cabe señalar que el esquema de asignación por FAT puede dar pie a un número significativo de
movimientos de la cabeza del disco, a menos que la FAT se mantenga en caché. Un beneficio es
que se mejora el tiempo de acceso aleatorio, porque la cabeza del disco puede encontrar la
posición de cualquier bloque leyendo la información en la FAT.
Figura 5.10 Tabla de asignación de archivos
Asignación indizada
La asignación enlazada resuelve los problemas de fragmentación externa y declaración de tamaño
de la asignación contigua, pero, si no se usa una FAT, no puede apoyar un acceso directo eficiente,
ya que los punteros a los bloques están dispersos junto con los bloques mismos por todo el disco y
necesitan recuperarse en orden. La asignación indizada resuelve este problema al reunir todos los
punteros en un mismo lugar: el bloque índice.
Cada archivo tiene su propio bloque índice, que es una matriz de direcciones de bloques de disco.
La i-ésima entrada del bloque índice apunta al i-ésimo bloque del archivo. El directorio contiene la
dirección del bloque índice (Véase la Figura 5.11). Para leer el i-ésimo bloque, usamos el puntero
de la i-ésima entrada del bloque índice para encontrar y leer el bloque deseado.
La asignación indizada apoya el acceso directo sin sufrir fragmentación externa, porque cualquier
bloque libre del disco puede satisfacer una solicitud de espacio adicional.
La asignación indizada si desperdicia espacio. El gasto extra de los punteros de bloque índice
generalmente es mayor que el de los punteros de la asignación enlazada. Con la asignación
indizada, es preciso asignar un bloque índice entero, aun si sólo uno o dos punteros son diferentes
de nil.
Universidad Tecnológica Nacional Facultad Regional Villa María
81
BALOG MARTIN AÑO 2010
Figura 5.11 Asignación indizada de espacio en disco
Esto hace surgir una pregunta de qué tan grande debe ser el bloque índice. Cada archivo debe
tener un bloque índice, así que nos conviene que el bloque sea lo más pequeño posible. Sin
embrago, si el bloque índice es demasiado pequeño no podría contener suficientes punteros para
un archivo grande, y se necesitara un mecanismo para resolver este problema:
Esquema enlazado. Un bloque índice normalmente ocupa un bloque de disco; por tanto,
se puede leer y escribir directamente por sí solo. Para manejar archivos grandes,
podríamos enlazar varios bloques índices. Es decir si un archivo es pequeño la última
palabra del bloque índice es nil o un puntero a otro bloque índice (para archivos grandes).
Índice multinivel. Una variante de la representación enlazada es usar un bloque índice de
primer nivel que apunte a un conjunto de bloques índice de segundo nivel, que a su vez
apuntan a los bloques de disco. Para acceder a un bloque, el sistema operativo usa el
índice de primer nivel para encontrar un bloque índice de segundo nivel, y ese bloque para
hallar el bloque de datos deseado. Este enfoque podría extenderse a un tercer o cuarto
nivel dependiendo del tamaño máximo del archivo deseado. Pero con dos niveles de
índices a 4096 bytes por bloque me permitiría guardar archivos hasta de cuatro gigabytes.
Esquema combinado. Otra alternativa es guardar los primeros, digamos 15 punteros del
bloque índice en el bloque índice (o i-nodo) del archivo. Los primeros 12 de estos punteros
apuntan a bloques directos; es decir, contienen direcciones de bloques que contienen
datos del archivo. Así, los datos de archivos pequeños (de no más de 12 bloques) no
necesitan un bloque índice aparte. Los siguientes tres punteros apuntan a bloques
indirectos. El primer puntero de bloque indirecto es la dirección de un bloque indirecto
simple: un bloque índice que no contiene datos, sino las direcciones de bloques que si
contienen datos. Luego viene un puntero a un bloque indirecto doble, que contiene la
dirección de un bloque que contiene las direcciones de bloques que contienen punteros a
los bloques de datos reales. El último puntero contendría la dirección de un bloque
indirecto triple. Con este método el número de bloques que es posible asignar a un archivo
Universidad Tecnológica Nacional Facultad Regional Villa María
82
BALOG MARTIN AÑO 2010
excede la cantidad de espacio que puede direccionarse con los punteros de archivo de
cuatro bytes que usan muchos sistemas operativos.
Los esquemas de asignación indizada exhiben algunos de los mismos problemas de desempeño
que la asignación enlazada. En términos específicos, los bloques índice se pueden colocar en un
caché en la memoria, pero los bloques de datos podrían estar dispersos por toda una partición.
5.2.3 Administración del espacio libre
Puesto que la cantidad de espacio en disco es limitada, es necesario reutilizar el espacio de los
archivos borrados para archivos nuevos. Para seguir la pista al espacio libre en el disco, el sistema
mantiene una lista de espacio libre en la que se registran todos los bloques de disco que están
libres, es decir, no asignados a algún archivo o directorio. Para crear un archivo, buscamos en la
lista de espacio libre la cantidad de espacio necesaria y la asignamos al nuevo archivo. Luego el
espacio se elimina de la lista.
Vector de bits
Es común implementar la lista de espacio libre como mapa de bits o vector de bits. Cada bloque se
representa con un bit. Si el bloque está libre, el bit es 1; si el bloque está asignado, el bit es 0. Por
ejemplo:
2,3,4,5,8,10,11,12,13,14,18,25,26 y 27 están libres
001111001111110001100000011100000…..
La principal ventaja de este enfoque es que resulta relativamente sencillo y eficiente encontrar el
primer bloque libre, o n bloques libres consecutivos en el disco. Efectivamente, muchos
computadores cuentan con instrucciones de manipulación de bits que pueden servir para este fin.
Desafortunadamente, los vectores de bits son ineficientes si el vector entero no se mantiene en la
memoria principal (y se escribe ocasionalmente en el disco para fines de recuperación). El
mantenimiento en memoria principal es posible si el disco no es demasiado grande.
Lista enlazada
Otra estrategia consiste en enlazar entre sí todos los bloques de disco libres, manteniendo un
puntero al primer bloque libre en una posición especial del disco y colocándolo en caché en la
memoria. Este primer bloque contiene un puntero al siguiente bloque del disco, y así. (Véase la
Figura 5.12). Este enfoque no es eficiente; para recorrer la lista necesitaríamos leer cada bloque,
ocupando una cantidad sustancial de tiempo de E/S. por fortuna, el recorrido de la lista de bloques
libres no es una acción frecuente. Normalmente, el sistema operativo sólo necesita un bloque libre
para poder asignarlo a un archivo, así que se usa el primer bloque de la lista. Cabe señalar que el
método FAT incorpora la contabilización de bloques libres en la estructura de datos de asignación,
así que no se necesita otro método aparte.
Universidad Tecnológica Nacional Facultad Regional Villa María
83
BALOG MARTIN AÑO 2010
Figura 5.12 Lista enlazada de espacio libre en disco
Agrupamiento
Una modificación de la estrategia de lista de espacio libre es almacenar las direcciones de n
bloques libres en el primer bloque libre. Los primeros n-1 de esos bloques estarán efectivamente
libres. El último bloque contendrá las direcciones de otros n bloques libres, y así sucesivamente. La
importancia de esta implementación es que permite encontrar rápidamente las direcciones de un
gran número de bloques libres, a diferencia de la estrategia estándar de lista enlazada.
Conteo
En lugar de mantener una lista de n direcciones de bloques de disco libres, podemos mantener la
dirección del primer bloque libre y el número n de bloques libres contiguos que siguen al primero.
Cada entrada de la lista de espacio libre consistirá en una dirección de disco y una cuenta. Aunque
cada entrada requiere más espacio que una dirección de disco sencilla, la lista sera más corta en
tanto la cuenta sea generalmente mayor que 1.
5.2.4 Implementación de directorios
La selección de los algoritmos de asignación de directorios y administración de directorios afecta
considerablemente la eficiencia, desempeño y confiabilidad del sistema de archivos.
Lista lineal
El método más sencillo para implementar un directorio es usar una lista de nombres de archivo
con punteros a los bloques de datos. Una lista lineal de entradas de directorio requiere una
búsqueda lineal para hallar una entrada específica. Este método es sencillo de programar pero
consume mucho tiempo al ejecutarse. Para crear un archivo nuevo, primero hay que examinar el
directorio para comprobar que ningún archivo existente tenga el mismo nombre. Luego, se añade
una nueva entrada al final del directorio. Para eliminar un archivo, buscamos en el directorio el
archivo en cuestión y liberamos el espacio que tiene asignado.
Universidad Tecnológica Nacional Facultad Regional Villa María
84
BALOG MARTIN AÑO 2010
La desventaja real de una lista lineal de entradas de directorio es la búsqueda lineal para encontrar
un archivo. La información de directorio se usa muy a menudo, y una implementación lenta del
acceso a ella seria perceptible para los usuarios.
Tabla de dispersión (hash table)
Otra estructura de datos que se ha usado para directorios de archivos es la tabla de dispersión. Las
entradas de directorio se guardan en una lista lineal, pero también se usa una estructura de datos
de dispersión. La tabla de dispersión recibe un valor que se calcula a partir del nombre de archivo
y devuelve un puntero a la entrada de ese archivo en la lista lineal. Esto puede reducir mucho el
tiempo de búsqueda en directorios. La inserción y eliminación también son más o menos directas,
aunque deben tomarse medidas para manejar las colisiones; situaciones en las que dos nombres
de archivo se dispersan a la misma posición. Los principales problemas de la tabla de dispersión
son que su tamaño generalmente es fijo y que la función de dispersión depende del tamaño de
dicha tabla.
5.3 Archivos compartidos
Cuando varios usuarios trabajan juntos en un proyecto, con frecuencia necesitan compartir los
archivos. Como resultado, con frecuencia conviene que un archivo compartido aparezca en forma
simultánea en distintos directorios, los cuales pertenecen a distintos usuarios (Véase la Figura
5.13). La conexión entre el directorio B y el archivo compartido se llama enlace. El propio sistema
de archivos es una grafica dirigida acíclica¸ en vez de un árbol.
Figura 5.13 Sistema de archivos con un archivo compartido
Los archivos compartidos son convenientes, pero también presentan ciertos problemas. Para
comenzar, si los directorios realmente contienen direcciones en disco, entonces hay que hacer una
copia de las direcciones en disco en el directorio B al enlazar el archivo. Si B o C se añaden al
archivo, los nuevos bloques se enlistan sólo en el directorio del usuario que hace el añadido. Los
cambios no se verán visibles para los demás usuarios, lo cual contradice el propósito de compartir
el archivo.
Este problema se puede resolver de diferentes formas:
Universidad Tecnológica Nacional Facultad Regional Villa María
85
BALOG MARTIN AÑO 2010
Primera solución. Los bloques del disco no se enlistan en los directorios, sino en una pequeña
estructura de datos asociada al propio archivo. Los directorios apuntarían entonces sólo a esa
pequeña estructura de datos.
Segunda solución. B se enlaza con uno de los archivos C, haciendo que el sistema cree un nuevo
archivo de tipo LINK, el cual entra en el directorio B. este nuevo archivo sólo contienen el nombre
de la ruta de acceso del archivo al cual se enlaza. Este punto de vista se llama enlace simbólico.
Cada uno de estos métodos tienen sus desventajas.
Primera solución. Al momento de enlazarse B con el archivo compartido, el nodo-i registra a C
como propietario del archivo. La creación de un enlace no modifica la propiedad (Véase la Figura
5.14), aunque aumenta el contador de enlaces del nodo-i, de forma que el sistema sabe el número
de entradas de directorio que apuntan en cierto momento al archivo.
Figura 5.14 (a) Situación anterior del enlace. (b) Después de la creación del enlace. (c) Después de que el propietario original elimina el archivo
Si más adelante, C intenta eliminar el archivo, el sistema se enfrenta a un problema. Si elimina el
archivo y limpia el nodo-i, B tendrá una entrada de directorio que apunta a un nodo-i no válido.
Todo lo que hay que hacer es eliminar la entrada del directorio C, pero dejar intacto el nodo-i, con
su contador = 1, como se muestra en la figura 5.15 (c). Tenemos entonces una situación en la que
B es el único usuario que tiene una entrada de directorio para un archivo poseído por C. si el
sistema hace ciertas cuentas o proporciones, C continuara pagando por el archivo hasta que B
decida eliminarlo, momento en el cual el contador toma valor 0 y el archivo se elimina.
Segunda solución. Este problema no surge con los enlaces simbólicos, puesto que sólo el
propietario verdadero tiene un apuntador al nodo-i. Los usuarios enlazados al archivo sólo tienen
nombres de ruta de acceso y no apuntadores a nodo-i. Cuando el propietario elimina el archivo,
éste se destruye. Los intentos posteriores de uso del archivo por medio de un enlace simbólico
fracasaran cuando el sistema no pueda localizar el archivo. La eliminación de un enlace simbólico
no afecta en lo absoluto a un archivo.
El problema con los enlaces simbólicos es su costo extra. Hay que leer el archivo que contiene la
ruta de acceso, para después analizar dicha ruta y seguirla, componente a componente, hasta
Universidad Tecnológica Nacional Facultad Regional Villa María
86
BALOG MARTIN AÑO 2010
alcanzar el nodo-i toda esta actividad puede requerir un número considerable de accesos
adicionales al disco. Los enlaces simbólicos tienen la ventaja de que se pueden utilizar para enlazar
archivos en otras maquinas, en cualquier parte del mundo, proporcionando tan sólo la dirección
de la red de la maquina donde reside el archivo, además de su ruta de acceso en esa máquina.
5.4 Administración de disco
Existen diferentes estrategias generales posibles para almacenar un archivo de n bytes:
asignar n bytes consecutivos de espacio en el disco
dividir el archivo en cierto número de bloques (no necesariamente) adyacentes.
El almacenamiento de un archivo como una serie adyacente de bytes tiene el problema obvio de
que si un archivo crece, será muy probable que deba desplazarse en el disco. El desplazamiento de
un archivo de una posición a otra dentro del disco es lento. Por esta razón, casi todos los sistemas
de archivos dividen a los archivos en bloques de tamaño fijo que no tienen que ser adyacentes.
Tamaño del bloque
Una vez que se ha decidido almacenar los archivos en bloques de tamaño fijo, surge la pregunta
del tamaño que deben ser dichos bloques.
Si se tiene una unidad de asignación grande como un cilindro, esto significa que cada archivo,
incluso un archivo de 1 byte, ocupara todo un cilindro. Por lo que se desperdiciaría mucho espacio.
La lectura de cada bloque requiere por lo general de un retraso por la búsqueda y la rotación, por
lo que la lectura de un archivo con muchos bloques pequeños será muy lenta.
El compromiso usual es elegir un tamaño de bloque de 512, 1k o 2 k bytes. Si se utiliza un tamaño
de bloque de 1 k en un disco cuyo tamaño de sector es de 512 bytes entonces el sistema de
archivos siempre leerá o escribirá en dos sectores consecutivos y los considerará como una sola
unidad indivisible.
5.5 Confiabilidad del sistema de archivos
Si el sistema de archivos de una computadora se pierde, ya sea por razones de hardware, software
o ratas que roen los discos flexibles, será difícil restaurar toda la información, tardara algún tiempo
y, en muchos casos, será imposible. Las consecuencias pueden ser catastróficas para las personas
que han perdido sus programas, documentos, archivos de clientes, registros de impuestos, bases
de datos, planes de comercialización u otros datos.
Manejo de un bloque defectuoso
Los discos tienen con frecuencia bloques defectuosos. Los discos rígidos por lo general tienen
bloques defectuosos del principio, simplemente es demasiado caro producirlos libres de defectos.
De hecho, los fabricantes anexan a cada unidad una lista de bloques defectuosos detectados por
sus pruebas.
Diferentes soluciones al problema de los bloques defectuosos:
Hardware. Consiste en dedicar un sector del disco a la lista de bloques defectuosos.
Universidad Tecnológica Nacional Facultad Regional Villa María
87
BALOG MARTIN AÑO 2010
Software. Requiere que el usuario o el sistema de archivos construyan con cuidado un
archivo con todos los bloques defectuosos. Esta técnica los elimina de la lista de bloques
libres, de forma que nunca pueden aparecer en los archivos de datos. Mientras no se lea o
escriba en este archivo de bloques defectuosos, no surgirán problemas. Se debe tener
cuidado durante los respaldos del disco para evitar leer este archivo.
Respaldos
Es importante respaldar los archivos con frecuencia.
Los sistemas de archivos de los discos flexibles se pueden respaldar mediante un simple copiado
de todo el disco en otro limpio.
Para los discos Winchester grandes (por ejemplo, 500M), el respaldo de toda la unidad es difícil y
consume mucho tiempo. Una estrategia de fácil implantación pero que desperdicia la mitad del
espacio de almacenamiento es que la computadora tenga dos unidades en vez de una. Ambas
unidades se dividen en dos partes: datos y respaldo. Cada noche, la parte de datos de la unidad 0
se copia en la parte de respaldo de la unidad 1 y viceversa, como se muestra en la Figura 5.16.
Otra forma de vaciar todo el sistema de archivos cada día es mediante los vaciados por
incrementos. La forma más simple de estos vaciados es mediante un vaciado completo en forma
periódica, por ejemplo, una vez al mes o a la semana y hacer un vaciado diario sólo de aquellos
archivos modificados desde el último vaciado total.
Para la implantación de este método, debe mantenerse en el disco una lista de los tiempos de
vaciado de cada archivo.
MS-DOS ayuda un poco en la realización de respaldos. A cada archivo se le asocia un bit de
atributo llamado bit de biblioteca. Al hacer un respaldo del sistema de archivos, los bits de
biblioteca de todos los archivos toman el valor 0. Después, cuando se modifica un archivo, el
sistema activa en forma automática su bit de biblioteca. Cuando es tiempo del siguiente respaldo,
el programa de respaldo revisa todos los bits de biblioteca y sólo respalda aquellos archivos cuyos
bits de biblioteca estén activos.
Figura 5.15 El respaldo de cada unidad en la otra desperdicia la mitad del espacio de almacenamiento
Desempeño del sistema de archivos
Universidad Tecnológica Nacional Facultad Regional Villa María
88
BALOG MARTIN AÑO 2010
El acceso al disco es mucho más lento que el acceso a la memoria. Como resultado de esta
diferencia en los tiempos de acceso, muchos sistemas de archivo han sido diseñados para reducir
el número de accesos a disco necesarios.
La técnica más común para reducir los accesos a disco es el bloque caché o buffer caché. Un cache
es una colección de bloques que pertenecen desde el punto de vista lógico al disco, pero que se
mantienen en la memoria por razones de rendimiento.
Se utilizan varios algoritmos para la administración del caché, pero uno de los más comunes es el
de verificar todas las solicitudes de lectura para saber si el bloque solicitado se encuentra en el
caché. En caso afirmativo, se satisface la solicitud sin un acceso a disco.
Cuando hay que cargar un bloque en un caché totalmente ocupado, hay que eliminar algún
bloque y volverlo a escribir en el disco en caso de que haya sido modificado antes de haberlo
traído del disco.
Al escribir de manera rápida los bloques críticos, reduciremos en gran medida la probabilidad de
que una falla total del sistema haga naufragar el sistema de archivos.
No es recomendable mantener los bloques de datos en él durante mucho tiempo antes de
reescribirlos.
El caché no es la única forma de aumentar el rendimiento de un sistema de archivos. Otra técnica
importante es la reducción de la cantidad de movimiento del brazo del disco, colocando los
bloques que probablemente tengan un acceso secuencial más cercano entre sí, de preferencia en
el mismo cilindro.
Universidad Tecnológica Nacional Facultad Regional Villa María
89
BALOG MARTIN AÑO 2010
6 Entrada-Salida
Una de las funciones principales de un sistema operativo es el control de todos los dispositivos de
entrada/salida de la computadora. Deben enviar comandos a los dispositivos, detectar las
interrupciones y controlar los errores. El código de E/S representa una fracción significativa del
sistema operativo.
6.1 Principios del hardware de E/S
Hay varias maneras de analizar el hardware de E/S. Nuestro interés estará restringido a la forma
de programar el hardware y no a su funcionamiento interno.
6.1.1 Dispositivos y controladores de E/S
Dispositivos de E/S
Los dispositivos de E/S se pueden dividir en categorías:
De bloque. Es aquel que almacena la información en bloques de tamaño fijo cada uno con
su propia dirección. La propiedad esencial es la posibilidad de leer o escribir en un bloque
en forma independiente de los demás. Los discos son dispositivos de bloques.
De carácter. Envía o recibe un flujo de caracteres, sin sujetarse a una estructura de
bloques. No se pueden utilizar direcciones ni tienen una operación de búsqueda. Las
impresoras de línea, cintas de papel, tarjetas perforadas, interfaces de red, ratones y
muchos otros dispositivos no parecidos a los discos son dispositivos de caracter.
Controladores de dispositivos
Las unidades de E/S constan por lo general de un componente mecánico y otro electrónico. El
componente electrónico se llama controlador del dispositivo o adaptador. El componente
mecánico es el propio dispositivo.
La tarjeta controladora tiene por lo general un conector, en el que se puede conectar el cable que
va al dispositivo en sí. Muchos controladores pueden manejar dos, cuatro y hasta ocho
dispositivos idénticos.
El sistema operativo casi siempre trabaja con el controlador y no con el dispositivo. Casi todas las
micros y minicomputadoras utilizan el modelo de un bus de la Figura 6.1
Figura 6.1 Un modelo para conexión del CPU, memoria, controladores y dispositivos de E/S
La interfaz entre el controlador y el dispositivo es con frecuencia de muy bajo nivel.
Universidad Tecnológica Nacional Facultad Regional Villa María
90
BALOG MARTIN AÑO 2010
La labor del controlador es convertir el flujo de bits en serie en un bloque de bytes y llevar a cabo
cualquier corrección de errores necesaria. Lo común es que el bloque de bytes se ensamble, bit a
bit, en un buffer dentro del controlador.
Cada controlador tiene unos cuantos registros que utiliza para la comunicación con la CPU. En
ciertas computadoras, estos registros son parte del espacio normal de direcciones de memoria.
Este esquema se llama E/S mapeada a memoria. Otras computadoras utilizan un espacio de
direcciones especial para la E/S, asignando a cada controlador una parte de él.
El sistema operativo realiza la E/S al escribir comandos en los registros de los controladores.
Muchos de los comandos tienen parámetros, los cuales también se cargan en los registros del
controlador. Al aceptar un comando, la CPU puede dejar al controlador y dedicarse a otro trabajo.
Al terminar el comando, el controlador provoca una interrupción para permitir que el sistema
operativo obtenga el control de la CPU y verifique los resultados de la operación.
6.1.2 Escrutinio. Interrupciones. DMA
Escrutinio (Polling)
En el presente ejemplo, el anfitrión escribe sus salidas a través de un puerto, coordinándose con el
controlador mediante un saludo como sigue:
El anfitrión lee repetidamente el bit ocupado hasta que ese bit se apaga.
El anfitrión enciende el bit escribir en el registro de orden y escribe un byte en el registro
de salidas de datos.
El anfitrión enciende el bit de orden lista.
Cuando el controlador percibe que el bit de orden lista está encendido, enciende el bit
ocupado.
El controlador lee el registro de orden y ve la orden es escribir; luego lee el registro de
salida de datos para obtener el byte y realiza la E/S con el dispositivo.
El controlador apaga el bit orden lista; borra el bit de error del registro de situación para
indicar que la E/S con el dispositivo se realizó con éxito, y apaga el bit ocupado para indicar
que ya terminó.
Este ciclo se repite para cada byte.
En el caso 1, el anfitrión está en espera activa (busy waiting) o escrutinio: está en un ciclo, leyendo
el registro de estado una y otra vez hasta que el bit ocupado se apaga. Si el controlador y el
dispositivo son rápidos, este método es razonable, pero si la espera puede ser larga tal vez lo
mejor sea que el anfitrión conmute a otra tarea.
Es obvio que la operación de escrutinio es eficiente, pero se vuelve ineficiente si se intenta
repetidamente y casi nunca encuentra que un dispositivo está listo para ser atendido, mientras
hay otras tareas de procesamiento que la CPU debe realizar. En tales casos, podría ser más
eficiente hacer que el controlador del hardware notifique a la CPU cuando el dispositivo esté listo
para recibir el servicio, en vez de exigir a la CPU que escrute repetidamente para detectar una
Universidad Tecnológica Nacional Facultad Regional Villa María
91
BALOG MARTIN AÑO 2010
finalización de E/S. El mecanismo de hardware que permite a un dispositivo notificar a la CPU se
denomina interrupción.
Interrupciones
Decimos que el controlador de dispositivo genera una interrupción acertando una señal en la línea
de solicitud de interrupción, la CPU atrapa la interrupción y despacha al manejador de
interrupción, el cual despeja la interrupción dando servicio al dispositivo.
La mayor parte de las CPU tienen diferentes líneas de solicitud de interrupción:
Interrupción no enmascarable. Está reservada para sucesos como errores de memoria no
recuperables.
Interrupción enmascarable. La CPU puede desactivarla antes de ejecutar secuencias de
instrucciones críticas que no deben interrumpirse. Los controladores de dispositivos usan
la interrupción enmascarable para solicitar servicios.
El mecanismo de interrupciones acepta una dirección: un número que selecciona una rutina de
manejo de interrupción específica de entre un grupo pequeño. En la mayor parte de las
arquitecturas, esta dirección es un desplazamiento dentro de una tabla llamada vector de
interrupciones, que contiene las direcciones en memoria de los manejadores de interrupciones
especializados. El propósito de un mecanismo de interrupciones vectorizado es reducir la
necesidad de que un solo manejador de interrupciones explore todas las posibles fuentes de
interrupciones para determinar cuál necesita servicio.
El mecanismo de interrupciones también implementa un sistema de niveles de prioridad de
interrupciones. Este mecanismo permite a la CPU diferir el manejo de las interrupciones de baja
prioridad sin tener que enmascarar todas las interrupciones, y hace posible que una interrupción
de alta prioridad supedite la ejecución de una interrupción de baja prioridad.
El mecanismo de interrupciones también sirve para manejar una amplia variedad de excepciones,
como dividir por cero, acceder a una dirección de memoria protegida o inexistente, o intentar
ejecutar una instrucción privilegiada desde el modo usuario.
Las interrupciones también pueden servir para administrar el flujo de control dentro del núcleo.
En síntesis, en los sistemas operativos modernos se usan interrupciones ampliamente para
manejar sucesos asincrónicos y transferir el control a través de trampas a rutinas en modo de
supervisor del núcleo. Para que las tareas más urgentes puedan llevarse a cabo primero, los
computadores modernos emplean un sistema de prioridades de interrupciones. Los controladores
de dispositivos, fallos de hardware y llamadas al sistema generan interrupciones que activan
rutinas del núcleo. Dado el intenso uso de interrupciones para el procesamiento sensible a los
retardos, un manejo eficiente de las interrupciones es requisito para lograr un buen desempeño
del sistema.
Acceso directo a memoria DMA
DMA se ideó para aliviar a la CPU, se delega parte del trabajo a un controlador de acceso directo a
memoria y la CPU solo le proporciona la dirección del bloque en el disco, la dirección en memoria
Universidad Tecnológica Nacional Facultad Regional Villa María
92
BALOG MARTIN AÑO 2010
a donde debe ir el bloque y el número de bytes a transferir, y continúa con otros trabajos. El
controlador entonces lee todo el bloque de órdenes del dispositivo a su buffer y comienza a copiar
el primer byte a la memoria, el saludo entre los controladores se realiza mediante “solicitud DMA”
y “Reconocimiento de DMA”. Entonces se incrementa la dirección DMA y se decrementa el
contador DMA en el número de bytes que acaba de transferir, repitiéndose esto hasta que el
controlador se acumula, en ese momento el controlador provoca una interrupción.
Los controladores simples no pueden enfrentarse a las E/S simultáneas, mientras se lleva a cabo
una transferencia en la memoria el sector que pasa debajo de la cabeza del disco se pierde y el
controlador sólo podrá leer hasta el siguiente bloque, por eso se implementa un salto software
bloques llamado separación. Los bloques están numerados de manera que se conserve la máxima
velocidad posible del hardware. Ver Figura 6.2.
Figura 6.2 (a) Sin separación. (b) Separación simple. (c) Separación doble.
6.2 Principios de software
Las metas generales del software son fáciles de establecer, la idea básica es organizar el software
como una serie de capas, en donde las capas inferiores se encarguen de ocultar las peculiaridades
del hardware a las capas superiores y de forma que éstas se preocupen por presentar una interfaz
agradable, limpia y regular a los usuarios.
6.2.1 Objetivos del software de E/S
Un concepto clave en el diseño del software de E/S es la independencia del dispositivo. Debe ser
posible escribir programas que se puedan utilizar con archivos en un disco flexible o un disco duro,
sin tener que modificar los programas para cada tipo de dispositivo.
Otro aspecto importante del software de E/S es el manejo de errores. En general, los errores
deben manejarse lo más cerca posible del hardware. Si el controlador descubre un error de
lectura, debe tratar de corregirlo, en la medida de lo posible.
Otro de los aspectos claves son las transferencias síncrona (por bloques) o asíncrona (controlada
por interrupciones). La mayor parte de la E/S es asíncrona (la CPU inicia la transferencia y realiza
otras labores hasta una interrupción). Los programas del usuario son mucho más fáciles de escribir
si las operaciones de E/S son por medio de bloques.
El concepto final que analizaremos es la comparación de los dispositivos que se pueden compartir
y los dispositivos de uso exclusivo. Algunos de los dispositivos de E/S, como los discos, pueden ser
utilizados por varios usuarios al mismo tiempo. Otros dispositivos, como las impresoras, deben
Universidad Tecnológica Nacional Facultad Regional Villa María
93
BALOG MARTIN AÑO 2010
dedicarse a un solo usuario hasta concluir con él. El sistema operativo debe administrar los
dispositivos compartidos y de uso exclusivo de forma que evite dichos problemas.
Estos objetivos se logran de una forma comprensible y eficiente al estructurar el software de E/S
en capas:
Manejadores de interrupciones.
Directivas de dispositivos.
Software de sistema operativo independiente de los dispositivos.
Software a nivel usuario.
6.2.2 Manejadores de interrupciones
Las interrupciones son un hecho desagradable de la vida. Deben ocultarse en lo más profundo de
las entrañas del sistema operativo, de forma que sólo una pequeña parte del sistema sepa de
ellas. La mejor forma de esconderlas es que cada proceso que inicie una operación de E/S se
bloquee hasta que termine la E/S y ocurra la interrupción.
Al ocurrir la interrupción, el procedimiento de interrupción realiza lo debido para eliminar el
bloqueo del proceso que lo inicio. El efecto real de la interrupción será que un proceso antes
bloqueado podrá continuar su ejecución.
6.2.3 Software de E/S independiente del dispositivo
Las funciones que se muestran en la tabla 6.1 se realizan por lo general en el software
independiente del dispositivo.
Interfaz uniforme para los manejadores de dispositivos
Nombres de los dispositivos Protección del dispositivo
Proporcionar un tamaño de bloque independiente del dispositivo
Uso de buffer
Asignación de espacio en los dispositivos por bloques
Asignación y liberación de los dispositivos de uso exclusivo
Informe de errores Tabla 6.1 Funciones del software de E/S independiente del dispositivo
La función básica del software independiente del dispositivo es llevar a cabo las funciones de E/S
comunes a todos los dispositivos, además de proporcionar una interfaz uniforma del software a
nivel usuario.
Un aspecto fundamental en un sistema operativo lo forman los nombres de los archivos y los
dispositivos de E/S. el software independiente del dispositivo se encarga de asociar los nombres
simbólicos de los dispositivos con el nombre adecuado.
Un aspecto muy relacionado con los nombres es el de la protección.
Los distintos discos pueden tener diferentes tamaños de sector. Es labor del software
independiente del dispositivo ocultar ese hecho y proporcionar un tamaño uniforme de los
bloques a los niveles superiores. De manera análoga, algunos dispositivos de caracter entregan sus
Universidad Tecnológica Nacional Facultad Regional Villa María
94
BALOG MARTIN AÑO 2010
datos un byte a la vez, mientras que otras los entregan en unidades mayores. Estas diferencias
también deben permanecer ocultas.
El almacenamiento en buffers también es otro aspecto; tanto de los dispositivos de bloque como
los de carácter.
Para los dispositivos de bloque, el hardware insiste por lo general en la lectura y escritura
de bloques a la vez, pero los procesos del usuario son libres de leer y escribir en unidades
arbitrarias.
Para los dispositivos de carácter, los usuarios pueden escribir los datos al sistema de
manera más rápida que la velocidad con la que pueden salir, por lo que requiere uso de
buffers.
El manejo de errores lo realizan los manejadores. La mayoría de los errores dependen en gran
medida del dispositivo, por lo que sólo éste sabe qué hacer. Un error común se produce cuando
un bloque de disco ha sido dañado y no se puede leer más. Después de que el manejador ha
intentado leer el bloque un cierto número de veces, se da por vencido e informa del hecho al
software independiente del dispositivo. A partir de ese momento, la forma de manejo de error es
independiente del dispositivo.
6.2.4 Software de E/S en el espacio del usuario
Aunque la mayoría del software de E/S está dentro del sistema operativo, una pequeña parte de él
consta de bibliotecas ligadas entre sí con los programas del usuario e incluso programas completos
que se ejecutan dentro del núcleo. Las llamadas al sistema, entre ellas, las llamadas del sistema de
E/S, en general son llevadas a cabo por los procedimientos de biblioteca.
Existen procedimientos de E/S que realmente efectúan cierto trabajo. En particular, el formato de
la entrada y la salida son realizados por medio de procedimientos de biblioteca. La biblioteca
estándar de E/S contiene varios procedimientos relacionados con E/S y todos se ejecutan como
parte de los programas del usuario.
No todo el software de E/S a nivel usuario consta de procedimientos de biblioteca. Otra categoría
importante es el sistema de spooling. El spooling es una forma de trabajar con los dispositivos de
E/S de uso exclusivo en un sistema de multiprogramación. Aunque es fácil, desde el punto de vista
técnico, dejar que los procesos del usuario abran el archivo especial de carácter correspondiente a
la impresora, supongamos que un proceso lo abrió y después no llevo a cabo actividad alguna
durante horas. Ningún otro proceso podría imprimir nada.
En vez de esto, lo que se hace es crear un proceso especial, llamado un demonio y un directorio
especial, llamado directorio de spooling. Para imprimir un archivo, un proceso genera en primer
lugar todo el archivo por imprimir y lo pone en el directorio de spooling. El demonio, que es el
único proceso con permiso para utilizar el archivo especial de la impresora, debe imprimir los
archivos en el directorio. Al proteger el archivo especial contra el uso directo de los usuarios, se
elimina el problema de tener a alguien manteniendo algún archivo abierto un largo tiempo
innecesario.
Universidad Tecnológica Nacional Facultad Regional Villa María
95
BALOG MARTIN AÑO 2010
La Figura 6.3 resume el sistema de E/S, con todas las capas y las principales funciones de cada una.
Figura 6.3 Capas del sistema de E/S y las principales funciones de cada.
Las flechas de la Figura 6.3 muestran el flujo de control.
6.3 Interfaz de E/S de las aplicaciones
En esta sección, estudiaremos técnicas de estructuración e interfaces para el sistema operativo
que permite tratar los dispositivos de E/S de una forma uniforme y estandarizada.
Al igual que en otros problemas complejos de ingeniería de software, la estrategia aquí incluye
abstracción, encapsulamiento y estructuración del software en capas. Específicamente, podemos
eliminar por abstracción las diferencias detalladas de los dispositivos de E/S identificando unas
cuantas clases generales. Accedemos a cada una de estas clases a través de un conjunto de
funciones estandarizadas: una interfaz. Las diferencias reales se encapsulan en módulos del núcleo
llamados controladores de dispositivo que internamente se adaptan a cada dispositivo, pero que
exportan una de las interfaces estándar.
El propósito de la capa de driver de dispositivo es ocultar las diferencias entre los controladores de
dispositivos de modo que el subsistema de E/S del núcleo no las perciba. Hacer al subsistema de
E/S independiente del hardware simplifica la tarea del creador de sistemas operativos, y también
beneficia a los fabricantes de hardware. Ellos diseñan nuevos dispositivos de modo que sean
compatibles con una interfaz anfitrión-controlador existente, o bien escriben drivers para
establecer una interfaz entre el nuevo hardware y los sistemas operativos más utilizados. Así, es
posible conectar nuevos periféricos a un computador sin esperar a que el proveedor de sistemas
operativos desarrolle el código de soporte. Desafortunadamente para los fabricantes de
dispositivos, cada tipo de sistema operativo tiene sus propios estándares para la interfaz de driver.
Un dispositivo podría venderse con múltiples drivers, por ejemplo, drivers para Windows 98,
Windows XP, Windows Vista, Linux, MacOS.
Los dispositivos varían en muchas dimensiones, tabla 6.2
Aspecto Variación Ejemplo
Modo de transferencia de datos
Por caracter Por bloques
Terminal Disco
Método de acceso Secuencial Módem
Universidad Tecnológica Nacional Facultad Regional Villa María
96
BALOG MARTIN AÑO 2010
Aleatorio CD-ROM
Planificación de transferencia
Sincrónica Asincrónica
Cinta Teclado
Velocidad del dispositivo Latencia Tiempo de búsqueda Tasa de transferencia Retardo entre operaciones
Dirección de E/S Sólo lectura Sólo escritura Lectura-escritura
CD-ROM Controlador de gráficos Disco
Tabla 6.2 Características de los dispositivos de E/S
Flujo de caracteres o bloques. Un dispositivo basado en flujo de caracteres transfiere bytes
uno por uno, mientras que un dispositivo por bloques transfiere un bloque de bytes como
una unidad.
Acceso secuencial o aleatorio. Un dispositivo secuencial transfiere datos en un orden fijo
determinado por el dispositivo, mientras que el usuario de un dispositivo de acceso
aleatorio puede pedir al dispositivo que se coloque en cualquiera de las posiciones de
almacenamiento de datos disponibles.
Sincrónico y asincrónico. Un dispositivo sincrónico realiza transferencias de datos con
tiempos de repuesta predecibles. Un dispositivo asincrónico exhibe tiempos de repuesta
irregulares o impredecibles.
Compartible o dedicado. Un dispositivo compartible puede ser utilizado de forma
concurrente por varios procesos o hilos; no así un dispositivo dedicado.
Velocidad de operación. Las velocidades de los dispositivos van desde unos cuantos bytes
por segundo hasta unos cuantos gigabytes por segundo.
Lectura-escritura, sólo lectura o sólo escritura. Algunos dispositivos realizan tanto entrada
como salida, pero otros sólo manejan una dirección de datos.
La mayor parte de los sistemas operativos cuenta además con una llamada al sistema de escape o
puerta trasera que pasa, de forma transparente órdenes arbitrarias de una aplicación a un driver
de dispositivos.
6.3.1 Dispositivos por bloques y por carácter
La interfaz de dispositivos por bloques captura todos los aspectos necesarios para acceder a
unidades de disco y otros dispositivos orientados a bloques. La expectativa es que el dispositivo
entienda órdenes como leer y escribir, y, si el dispositivo de acceso aleatorio, tenga una orden
buscar (seek) para especificar cuál bloque debe transferir a continuación. Un teclado es un
ejemplo de dispositivos al que se accede a través de una interfaz de flujo de caracteres. Las
llamadas al sistema básicas de esta interfaz permiten a una aplicación obtener (get) o colocar (put)
un carácter. Tal estilo de acceso es idóneo para dispositivos de entrada como teclados, ratones y
módems, que producen datos de entrada “espontáneamente”, es decir, en momentos que la
aplicación no necesariamente puede predecir. Este estilo de acceso también es bueno para
Universidad Tecnológica Nacional Facultad Regional Villa María
97
BALOG MARTIN AÑO 2010
dispositivos de salida como impresoras o tarjetas de audio, que naturalmente se ajustan al
concepto de flujo lineal de bytes.
6.3.2 Dispositivos de red
Dado el desempeño y las características de direccionamiento de la E/S de red, difieren
significativamente de la E/S de disco, la mayor parte de los sistemas operativos proporciona una
interfaz de E/S de red diferente de la interfaz de leer-escribir-buscar que se emplea con los discos.
Es la interfaz de sockets de red.
Las llamadas al sistema de la interfaz de sockets permiten a una aplicación crear un socket,
conectar un socket local a una dirección remota, detectar si una aplicación remota se “enchufa” en
el socket local, y enviar y recibir paquetes por la conexión. Para apoyar la implementación de
servidores. La interfaz de sockets ofrece además una función llamada seleccionar (select) que
administrar un conjunto de sockets. Una llamada a seleccionar devuelve información acerca de
cuáles sockets tiene un paquete que espera ser recibido, y cuales sockets tiene espacio para
aceptar un paquete que se enviará.
6.3.3 Relojes y temporizadores
La mayor parte de los computadores cuentan con relojes y temporizadores de hardware que
realizan funciones principales:
Dar la hora actual
Dar el tiempo transcurrido
Establecer un temporizador para iniciar la operación X en el instante T
El hardware para medir tiempo transcurrido e iniciar operaciones se denomina temporizador de
intervalos programable, y puede configurarse de modo que espere cierto tiempo y luego genere
una interrupción. El temporizador puede ajustarse de modo que efectúe esta acción una vez, o
que repita el proceso para generar interrupciones periódicas. El planificador utiliza este
mecanismo para generar una interrupción que desaloje un proceso al término de su porción de
tiempo. El subsistema de E/S de disco también lo usa para invocar la escritura de buffers de caché
sucios en disco periódicamente, y el subsistema de red lo usa para cancelar operaciones que están
procediendo con demasiada lentitud a causa de congestión o fallos en la red.
6.3.4 E/S bloqueadora y no bloqueadora
Un aspecto más de la interfaz de llamadas al sistema tiene que ver con la elección entre E/S
bloqueadora y no bloqueadora (asincrónica). Cuando una aplicación usa una llamada al sistema
bloqueadora, la ejecución de la aplicación se suspende. La aplicación se pasa de la cola de
ejecución del sistema operativo a una cola de espera. Una vez finalizada la llamada al sistema, la
aplicación se coloca otra vez en la cola de ejecución, donde es elegible para reanudar su ejecución,
momento en el cual recibirá los valores devueltos por la llamada al sistema.
Universidad Tecnológica Nacional Facultad Regional Villa María
98
BALOG MARTIN AÑO 2010
Algunos procesos en el nivel de usuario necesitan E/S no bloqueadora. Un ejemplo es una interfaz
con el usuario que recibe entradas de teclado y del ratón mientras procesa y exhibe datos en la
pantalla.
Una llamada no bloqueadora no detiene la ejecución de la aplicación durante un tiempo largo; en
vez de ello, regresa rápidamente, con un valor de retorno que indica cuántos bytes se
transfirieron.
Una alternativa para una llamada al sistema no bloqueadora es una llamada al sistema asincrónica.
Una llamada asincrónica regresa de inmediato, sin esperar que termine la E/S. la aplicación sigue
ejecutando su código, y la finalización de la E/S en algún instante futuro se comunica a la
aplicación ya sea estableciendo alguna variable en el espacio de direcciones de la aplicación o
disparando una señal o interrupción por software, o mediante una rutina de retrollamada que se
ejecuta fuera del flujo de control lineal de la aplicación. Las diferencias entre las llamadas al
sistema no bloqueadoras y las asincrónicas. Una llamada leer no bloqueadora regresa
inmediatamente con cualesquier datos que estén disponibles: todos los bytes solicitados, sólo
algunos, o ninguno. Una llamada leer asincrónica solicita una transferencia que se efectuara en su
totalidad, pero que terminara en algún momento futuro.
6.4 Subsistema de E/S del núcleo
Los núcleos ofrecen muchos servicios relacionados con la E/S, veremos la forma en que se apoyan
en el hardware y en la infraestructura de controladores de dispositivo en software (drivers).
6.4.1 Planificador de E/S
Planificar un conjunto de E/S significa determinar un buen orden de ejecución para ellas. La
planificación puede mejorar el desempeño global del sistema, repartir equitativamente el acceso
entre los procesos y reducir el tiempo de espera promedio de las operaciones de E/S. Los
creadores de sistemas operativos implementan la planificación manteniendo una cola de
solicitudes para cada dispositivo. Cuando una aplicación emite una llamada de E/S bloqueadora, la
solicitud se coloca en la cola para ese dispositivo. El planificador de E/S reacomoda el orden de la
cola para mejorar la eficiencia global del sistema y el tiempo de repuesta que las aplicaciones
experimentan.
Una forma en que el subsistema de E/S mejora la eficiencia del computador es planificando las
operaciones de E/S. Otra es utilizando espacio de almacenamiento en la memoria principal o en
disco, con técnicas de uso de buffers, cachés y spool.
6.4.2 Utilización de buffers, cachés y spool
Uso de buffers
Un buffer es una área de memoria en la que se almacenan datos mientras se transfieren entre dos
dispositivos o entre un dispositivo y una aplicación. Se usan buffers por diferentes razones:
Universidad Tecnológica Nacional Facultad Regional Villa María
99
BALOG MARTIN AÑO 2010
Diferencia de velocidad entre el productor y el consumidor. El uso de buffer doble
desacopla el productor y el consumidor de los datos, y relaja las necesidades de
temporización entre ellos.
Adaptador entre dispositivos que tienen diferentes tamaños de transferencia de datos.
Tales disparidades son comunes sobre todo en las redes de computadores, donde se
emplean ampliamente buffers para fragmentar y reensamblar mensajes. En el lado
transmisor, un mensaje grande se fragmenta en pequeños paquetes, que se envían por
red. El lado receptor coloca los paquetes de red en un buffer de reensamblado para
formar la imagen de los datos originales.
Apoyar la semántica de copiado de la E/S de aplicaciones. Con semántica de copiado, se
garantiza que la versión de los datos que se escribió en el disco es la versión que existía en
el momento en que la aplicación hizo la llamada al sistema, sin importar que después haya
habido cambios en el buffer de la aplicación. Una forma sencilla en que el sistema
operativo puede garantizar la semántica de copiado es que la llamada escribir copie los
datos de la aplicación en un buffer del núcleo antes de devolver el control a la aplicación.
La escritura al disco se realiza desde el buffer del núcleo, para que los cambios
subsecuentes al buffer de la aplicación no afecten la escritura.
Uso de cachés
Un caché es una región de memoria rápida que contiene copias de datos. El acceso a la copia en
caché es más eficiente que el acceso al original. La diferencia entre un buffer y un caché es que un
buffer podría contener la única copia existente de un elemento de información, mientras que un
caché, por definición, sólo contiene una copia en almacenamiento más rápido de un elemento que
existe en otro lado.
El uso de cachés y de bufferes son funciones distintas, pero hay ocasiones en que una región de
memoria se puede usar para ambos fines. Por ejemplo, para mantener la semántica de copiado y
hacer posible una planificación eficiente de la E/S de disco.
Uso de spool y reservación de dispositivos
Un spool es un buffer que contiene salidas para un dispositivo, como una impresora, que no puede
aceptar corrientes de datos intercaladas. Si bien una impresora sólo puede dar servicio a un
trabajo a la vez, es posible que varias aplicaciones deseen imprimir sus salidas al mismo tiempo,
sin que tales salidas se mezclen. La salida de cada aplicación se guarda en un archivo de disco
aparte. Cuando una aplicación termina de imprimir, el sistema de spool coloca el archivo de spool
correspondiente en la cola de la impresora. El sistema operativo proporciona la interfaz de control
que permite a los usuarios y administradores del sistema exhibir la cola, eliminar trabajos no
deseados antes de que se impriman, suspender la impresión mientras se da servicio a la
impresora, y demás.
6.4.3 Manejo de errores
Un sistema operativo que emplea memoria protegida puede evitar muchos tipos de errores de
hardware y de las aplicaciones, de modo que un problema mecánico menor no cause un fallo total
Universidad Tecnológica Nacional Facultad Regional Villa María
100
BALOG MARTIN AÑO 2010
del sistema. Los sistemas operativos pueden compensar los fallos transitorios. Por ejemplo, si una
lectura de disco falla, se puede intentar de nuevo; un error de envió en la red puede dar pie a un
reenvío, si el protocolo así lo especifica.
Por regla general, una llamada al sistema de E/S devuelve un bit de información acerca del estado
de la llamada, para iniciar si tuvo éxito o fracasó.
6.4.4 Estructura de datos del núcleo
El núcleo necesita mantener información de estado acerca del uso de los componentes de E/S;
esto lo hace a través de diversas estructuras de datos internas. El núcleo emplea muchas
estructuras similares para seguir la pista a las conexiones de red, comunicaciones con dispositivos
por caracteres y otras actividades de E/S.
En síntesis, el subsistema de E/S coordina una amplia colección de servicios que se proporcionan a
las aplicaciones y a otras partes del núcleo. El subsistema de E/S supervisa:
La administración del espacio de nombres para archivos y dispositivos
El control de acceso a archivos y dispositivos
El control de operaciones (por ejemplo, un módem no puede buscar)
La asignación de espacio para el sistema de archivos
La asignación de dispositivos
El uso de buffers, cachés y spool
La vigilancia del estado de los dispositivos, el manejo de errores y la recuperación después
de fallos
La configuración e iniciación de drivers de dispositivos
6.5 Discos
Casi todas las computadoras tienen discos para almacenar la información. El uso de discos, tiene
ventajas con respecto del uso de la memoria principal como almacenamiento:
La capacidad de espacio de almacenamiento disponible es mucho más grande.
El precio por bit es más barato.
La información no se pierde al apagar la computadora
6.5.1 Estructuras de disco
Las unidades de disco moderno se direccionan como grandes arreglos unidimensionales de
bloques lógicos, que son las unidades de transferencia más pequeñas. El tamaño de un bloque
lógico suele ser de 512 bytes, aunque a algunos discos se les puede dar formato de bajo nivel
escogiendo un tamaño de bloque lógico distinto, como 1024 bytes.
El arreglo unidimensional de bloques lógicos se hace corresponder secuencialmente con los
sectores del disco. El sector 0 es el primer sector de la primera pista del cilindro más exterior. La
correspondencia procede en orden por esa pista, luego por las demás pistas de ese cilindro y luego
por el resto de los cilindros desde el más exterior hasta el más interior.
Universidad Tecnológica Nacional Facultad Regional Villa María
101
BALOG MARTIN AÑO 2010
Utilizando esta correspondencia, deberá ser posible convertir un número de bloque lógico en una
dirección de disco al estilo antiguo que consiste en un número de cilindro, un número de pisa
dentro de ese cilindro y un número de sector dentro de esa pista. En la práctica, es difícil realizar
esta traducción, por diferentes razones:
Casi todos los discos tienen algunos sectores defectuosos, pero la correspondencia oculta
esto sustituyendo sectores de reserva de algún otro punto del disco.
El número de sectores por pista no es constante. Cuanto más lejos esta una pista del
centro del disco, más larga es, y más sectores puede contener. Así, los discos modernos se
organizan en zonas de cilindros. El número de sectores por pista es constante dentro de
una zona.
6.5.2 Planificación de discos
Una de las obligaciones del sistema operativo es usar el hardware de forma eficiente. En el caso de
las unidades de disco, esto implica tener un tiempo de acceso breve y gran ancho de banda de
disco. El tiempo de acceso tiene componentes principales:
Tiempo de búsqueda (seek time). Es el tiempo que tarda el brazo del disco en mover las
cabezas al cilindro que contiene el sector deseado.
Latencia rotacional. Es el tiempo adicional que el disco tarda en girar hasta que el sector
deseado queda bajo la cabeza del disco.
El ancho de banda del disco es el número total de bytes transferidos, dividido entre el tiempo total
transcurrido entre la primera solicitud de servicio y la finalización de la última transferencia.
Cada vez que un proceso necesita E/S de o al disco, emite una llamada al sistema operativo. La
solicitud especifica varios elementos de información:
Si esta operación es de entrada o salida
La dirección en disco para la transferencia
La dirección en memoria para la transferencia
El número de bytes por transferir
Si la unidad de disco y controlador deseados están disponibles, la solicitud puede atenderse de
inmediato; si no, todas las solicitudes de servicio nuevas tendrán que colocarse en la cola de
solicitudes pendientes para esa unidad.
Planificación FCFS
La forma más sencilla de planificación de disco es, desde luego, el servicio por orden de llegada
(FCFS, first come first server). Este algoritmo es intrínsecamente justo, pero generalmente no
proporciona el servicio más rápido. Consideremos, por ejemplo, una cola de disco que contiene
solicitudes de E/S a bloques que están en los cilindros
98, 183, 37, 122, 14, 124, 65, 67
En ese orden. Si la cabeza del disco inicialmente esta en el cilindro 53, primero se moverá del 53 al
128, luego al 183, 37, 122, 14, 124, 65 y por último al 67, para un movimiento total de cabeza de
640 cilindros. Este plan se diagrama en la Figura 6.4
Universidad Tecnológica Nacional Facultad Regional Villa María
102
BALOG MARTIN AÑO 2010
El problema con este plan lo ilustra la amplia oscilación entre el 122 a 14 y luego de regreso al 124.
Si las solicitudes para los cilindros 37 y 14 pudieran atenderse juntas antes o después de las
solicitudes para el 122 y el 124, el movimiento total de la cabeza podría reducirse sustancialmente,
y el desempeño mejoraría.
Figura 6.4 Planificación de disco FCFS
Planificación SSTF
Parece razonable atender todas las solicitudes cercanas a la posición actual de la cabeza antes de
mover la cabeza a una posición lejana para atender otras solicitudes. Este supuesto es la base del
algoritmo de tiempo de búsqueda más corto primero (SSTF, shortest-seek-time-first), que
selecciona la solicitud que tiene el menor tiempo de búsqueda a partir de la posición actual de la
cabeza. Puesto que el tiempo de búsqueda aumenta con el número de cilindros que la cabeza
recorre, SSTF escoge la solicitud pendiente más cercana a la posición actual de la cabeza.
Para nuestro ejemplo de cola de solicitudes, la solicitud más cercana a la posición inicial de la
cabeza (53) es la del cilindro 65, 67, 37, 14, 98, 122, 124 y por último la 183 (Figura 6.5). Este
método de planificación da pie a un movimiento total de la cabeza de sólo 236 cilindros – poco
más que un tercio de la distancia necesaria para la planificación FCFS. Este algoritmo mejora
sustancialmente el desempeño.
La planificación SSTF es en esencia una forma de planificación de trabajo más corto primero (SJF) y
al igual que la planificación SJF, puede causar inanición de algunas solicitudes. Recuerde que en
cualquier momento pueden llegar más solicitudes. Mientras atendemos una solicitud puede llegar
una cercana a la que estamos atendiendo, por lo que se atenderá enseguida, y se hará esperar a
las solicitudes mayores.
Aunque el algoritmo SSTF representa una mejora sustancial respecto al algoritmo FCFS, no es
óptimo. En el ejemplo, sería mejor mover la cabeza del cilindro al 37, aunque no sea el más
cercano, y luego el 14, antes de dar la vuelta para atender 65, 67, 98, 122, 124 y 183. Esta
estrategia reduce el movimiento total de la cabeza a 208 cilindros.
Universidad Tecnológica Nacional Facultad Regional Villa María
103
BALOG MARTIN AÑO 2010
Figura 6.5 Planificación de disco SSTF
Planificación SCAN
En el algoritmo SCAN, el brazo del disco parte de un extremo del disco y se mueve hacia el otro,
atendiendo las solicitudes a medida que llega a cada cilindro, hasta llegar al otro extremo del
disco. Ahí, la dirección de movimiento de la cabeza se invierte, y continúa la atención. La cabeza
barre continuamente el disco de un lado a otro.
Antes de aplicar SCAN para planificar las solicitudes para los cilindros 98, 183, 37, 122, 14, 124, 65
y 67, necesitamos conocer la dirección de movimiento de la cabeza, además de la posición actual
de la misma (53). Si el brazo del disco se está moviendo hacia 0, la cabeza atenderá el 37, 14. En el
cilindro 0, el brazo cambiará de dirección y se moverá hacia el otro extremo del disco atendiendo
las solicitudes 65, 67 122, 124 y 183. (Figura 6.6)
Este algoritmo también es conocido como el algoritmo del elevador, ya que el brazo del disco se
comporta igual que el elevador de un edificio, que atiende primero todas las solicitudes para subir
y luego cambia de dirección para atender las solicitudes de bajar.
Figura 6.6 Planificación de disco SCAN
Planificación C-SCAN
Universidad Tecnológica Nacional Facultad Regional Villa María
104
BALOG MARTIN AÑO 2010
La planificación SCAN circular (C-SCAN) es una variante de SCAN diseñada para dar un tiempo de
espera más uniforme. Al igual que SCAN, C-SCAN mueve la cabeza de un extremo del disco al otro,
atendiendo las solicitudes en él camino, sólo que ahora, cuando la cabeza llega al otro extremo,
regresa de inmediato al principio del disco sin atender solicitudes (Figura 6.7). Básicamente trata
los cilindros como una lista circular que continúa del último cilindro al primero.
Figura 6.7 Planificación de disco S-CAN
Planificación LOOK
Observe que, de acuerdo con nuestra descripción, tanto SCAN, como C-SCAN mueven el brazo a
todo lo ancho del disco. En la práctica, ninguno de estos dos algoritmos se implementa así. Por lo
regular, el brazo sólo llega hasta la última solicitud en cada dirección y luego cambia de dirección
inmediatamente, sin primero ir hasta el extremo del disco. Estas versiones de SCAN y C-SCAN se
llaman LOOK y C-LOOK porque miran (look, en ingles) si hay una solicitud antes de continuar en
una dirección dada. (Figura 6.8)
Figura 6.8 Planificación de disco C-LOOK.
Universidad Tecnológica Nacional Facultad Regional Villa María
105
BALOG MARTIN AÑO 2010
6.5.3 Manejo de errores
No lo encontré en todo el rejunte.
Universidad Tecnológica Nacional Facultad Regional Villa María
106
BALOG MARTIN AÑO 2010
7 Seguridad y protección
7.1 Protección
La protección se refiere a un mecanismo para controlar el acceso de los programas, procesos o
usuarios a los recursos definidos por un sistema de computación. Este mecanismo debe permitir
especificar los controles que se impondrán, y debe contar con una forma de hacerlos cumplir.
7.1.1 Objetivos de la protección
Hay varias razones para proporcionar protección.
La más obvia es la necesidad de evitar que un usuario mal intencionado viole una restricción de
acceso. No obstante, la necesidad general más importante es la de asegurar que cada componente
activo de un programa en un sistema use los recursos sólo en forma congruente con las políticas
expresas para el uso de tales recursos. Este requisito es indispensable para tener un sistema
confiable.
Puede mejorar la confiabilidad detectando errores latentes en las interfaces entre los subsistemas
componentes. La detección temprana de errores de interfaz a menudo puede evitar la
contaminación de un subsistema sano por un subsistema que no está funcionando correctamente.
Un sistema orientado hacia la protección proporciona mecanismos para distinguir entre los usos
autorizados y los no autorizados.
El papel de la protección en un sistema de computación es ofrecer un mecanismo para hacer
cumplir las políticas que gobiernan el uso de los recursos.
Un principio importante es la separación entre política y mecanismo. Los mecanismos determinan
cómo se hacen las cosas. En contraste, las políticas deciden qué cosas se harán.
7.1.2 Dominio de protección
Un sistema de computación es una colección de procesos y objetos. Con objetos nos referimos
tanto a objetos de hardware (como CPU, segmentos de memoria, impresoras, discos), como de
software (archivos, programas, semáforos). Cada objeto tiene un nombre único que lo distingue
de todos los demás objetos del sistema, y sólo se puede acceder a cada uno empleando
operaciones bien definidas y significativas. En esencia, los objetos son tipos de datos abstractos.
Queda claro que a un proceso sólo debe permitírsele acceder a los recursos para los cuales tiene
autorización de acceso. Además, en un instante dado, el proceso sólo deberá poder acceder a los
recursos que necesite para llevar a cabo su tarea. Este requisito, conocido como el principio de
necesidad de conocer, es útil para limitar la cantidad de daño que un proceso que falla podría
causar en el sistema.
7.1.3 Matriz de acceso
Nuestro modelo de protección puede visualizarse de forma abstracta como una matriz, llamada
matriz de acceso. Las filas de la matriz de acceso representan dominios, y las columnas, objetos.
Cada entrada de la matriz consiste en un conjunto de derechos de acceso. Dado que la columna
Universidad Tecnológica Nacional Facultad Regional Villa María
107
BALOG MARTIN AÑO 2010
define explícitamente el objeto, podemos omitir el nombre del objeto en el derecho de acceso. La
entrada acceso(i,j) define el conjunto de operaciones que un proceso que se ejecuta en el dominio
Di puede invocar con el objeto Oj.
Las decisiones de política relativas a la protección se pueden implementar con la matriz de acceso.
Dichas decisiones se refieren a que derechos deben incluirse en la (i,j)-ésima entrada. También
debemos decidir en qué dominio se ejecutará cada proceso. Esta última decisión de política
generalmente corresponde al sistema operativo.
La matriz de acceso proporciona un mecanismo apropiado para definir e implementar un control
estricto de la asociación tanto estática como dinámica entre procesos y dominios.
Los procesos deberán poder cambiar de un dominio a otro. Se permite la conmutación del domino
Di al dominio Dj si y sólo si el derecho de acceso conmutar ϵ acceso(i,j).
Para poder modificar de forma controlada el contenido de las entradas de la matriz de acceso se
requieren operaciones adicionales copiar (copy), dueño (owner) y control.
La capacidad para copiar un derecho de acceso de un dominio (fila) de la matriz de acceso a otro
se denota con un asterisco (*) añadido al derecho de acceso. El derecho de copiar permite copiar
el derecho de acceso solo dentro de la columna (esto es, el objeto) para la cual se define el
derecho.
El derecho de copiar permite a un proceso copiar algunos derechos de una entrada de una
columna a otra entrada de la misma columna. Necesitamos un mecanismo para añadir nuevos
derechos y quitar algunos derechos. El derecho de dueño controla estas operaciones.
Los derechos copiar y dueño permiten a un proceso modificar las entradas de una columna.
También se requiere un mecanismo para modificar las entradas de una fila. El derecho control sólo
aplica a los objetos dominio.
7.1.4 Implementación de la matriz de acceso.
Tabla global
La implementación más sencilla de la matriz de acceso es una tabla global que consiste en un
conjunto de tripletas ordenadas <dominio, objeto, conjunto-de-derechos>. Cada vez que una
operación M se ejecuta con un objeto Oj dentro del dominio Di, se busca en la tabla global una
tripleta <Di, Oj, Rk>, donde M ϵ Rk. si se encuentra tal tripleta, se permite que la operación
continúe; si no, se genera una condición de excepción (error). Esta implementación tiene varias
desventajas. La tabla suele ser grande y por tanto no puede mantenerse en la memoria principal,
por lo que requiere E/S adicional. Es difícil aprovechar agrupamientos especiales de objetos o
minios. Por ejemplo si todo mundo puede leer un objeto en particular deberá tener una entrada
individual en cada dominio.
Listas de acceso para objetos
Cada columna de la matriz de acceso se puede implementar como una lista de acceso para un
objeto. Obviamente, las entradas vacías pueden desecharse. La lista resultante para cada objeto
Universidad Tecnológica Nacional Facultad Regional Villa María
108
BALOG MARTIN AÑO 2010
consiste en pares ordenados <dominio, conjunto-de-derechos>, que define todos los dominios con
un conjunto no vacio de derechos de acceso para ese objeto.
Este enfoque puede extenderse con facilidad para definir una lista más un conjunto por omisión
de derechos de acceso. Si se intenta una operación M con un objeto Oj en el dominio Di,
examinamos la lista de acceso al objeto Oj en busca de una entrada <Di, Rk> con M ϵ Rk. Si se
encuentra la entrada, permitimos la operación; si no, examinamos el conjunto omisión. Si M está
en ese conjunto, permitimos el acceso; si no, negamos el acceso y ocurre una condición de
excepción. Por eficiencia, podríamos examinar primero el conjunto por omisión, y luego la lista de
acceso.
Listas de capacidades para dominios
Asociamos cada fila con su dominio. Una lista de capacidades para un dominio es una lista de
objetos junto con las operaciones que se permiten con esos objetos. Es común representar un
objeto con su nombre o su dirección física, llamada capacidad.
La lista de capacidades se asocia a un dominio, pero nunca está directamente accesible para un
proceso que se ejecuta en ese dominio. Más bien, la lista de capacidades es en sí un objeto
protegido que el sistema operativo mantiene y al cual el usuario sólo puede acceder
indirectamente. Si todas las capacidades están seguras, el objeto al que protegen también está
seguro contra un acceso no autorizado.
Las capacidades suelen distinguirse de otros datos en una de las siguientes formas:
Cada objeto tiene una etiqueta para denotar su tipo ya sea como capacidad o como dato
accesible. Las etiquetas en sí no deben ser directamente accesibles para los programas de
aplicación. Aunque sólo se necesita un bit para distinguir entre capacidades y otros
objetos, es común usar más bits. Así, el hardware puede distinguir por sus etiquetas
enteros, números de punto flotante, punteros, booleanos, caracteres, instrucciones,
capacidades y valores no iniciados.
El espacio de direcciones asociado a un programa se puede dividir en partes
Una accesible para el programa y contiene sus datos e instrucciones normales.
Otra que contiene la lista de capacidades, sólo es accesible para el sistema
operativo. Un espacio segmentado es útil para soportar este enfoque.
Un mecanismo de cerradura y llave
El esquema cerradura-llave es un término medio entre las listas de acceso y las listas de
capacidades. Cada objeto tiene una lista de patrones de bits únicos, llamados cerraduras. Así
mismo, cada dominio tiene una lista de patrones de bits únicos, llamados llaves. Un proceso que
se ejecuta en un documento puede acceder a un objeto sólo si ese dominio tiene una llave que
coincida con una de las cerraduras del objeto.
Al igual que con las listas de capacidades, el sistema operativo debe administrar la lista de llaves
de un dominio a nombre de ese dominio. No se permite a los usuarios examinar ni modificar la
lista de llaves (o de cerraduras) directamente.
Universidad Tecnológica Nacional Facultad Regional Villa María
109
BALOG MARTIN AÑO 2010
7.1.5 Revocación de derechos de acceso
En un sistema de protección dinámico, a veces puede ser necesario revocar derechos de acceso a
objetos compartidos por diferentes usuarios. Podrían surgir varias preguntas respecto a la
revocación:
Inmediata o diferida
Selectiva o general
Parcial o total
Temporal o permanente
Con un esquema de lista de acceso, la revocación es fácil. Se busca en la lista de acceso el o los
derechos por revocar y se eliminan de la lista. La revocación es inmediata, y puede ser general o
selectiva, total o parcial y permanente o temporal.
Las capacidades, en cambio, presentan un problema de revocación mucho más difícil. Puesto que
las capacidades están distribuidas en todo el sistema, debemos hallarlas antes de poder
revocarlas. Hay varios esquemas distintos para implementar la revocación de capacidades, e
incluyen los siguientes:
Readquisición. Periódicamente, se eliminan capacidades de cada dominio. Si un proceso
quiere usar una capacidad, podría encontrarse con que esa capacidad se eliminó. El
proceso podrá entonces tratar de readquirir la capacidad. Si el acceso se revocó, el
proceso no podrá readquirir la capacidad.
Retropunteros. Se mantiene una lista de punteros con cada objeto, los cuales apuntan a
todas las capacidades asociadas a ese objeto. Si se requiere revocar una capacidad, se
pueden seguir estos punteros y modificar las capacidades según sea necesario.
Indirección. Las capacidades no pautan a los objetos directamente, sino indirectamente.
Cada capacidad apunta a una entrada única de una tabla global, que a su vez apunta al
objeto. Implementamos la revocación buscando en la tabla global la entrada deseada y
eliminándola.
Claves. Una clave es un patrón de bits único que se puede asociar a cada capacidad. Esta
clave se define cuando se crea la capacidad, y el proceso que posee esa capacidad no
puede modificarla ni inspeccionarla. Se puede definir o reemplazar una clave maestra
asociada a cada objeto usando la operación establecer-clave (set-key). La revocación
sustituye la clave maestra por un nuevo valor con la operación establecer-clave; esto anula
la validez de todas las capacidades previas para este objeto.
Este esquema no permite la revocación selectiva, ya que sólo una clave maestra se asocia a cada
objeto. Si asociamos una lista de claves a cada objeto, podremos implementar la revocación
selectiva. Por último, podemos agrupar todas las claves en una tabla de claves global. Una
capacidad sólo es válida si su clave coincide con alguna clave de la tabla global. Implementamos la
revocación eliminando la clave coincidente en la tabla. Con este esquema, podemos asociar una
clave a varios objetos, y varias claves a cada objeto, con lo que la flexibilidad es máxima.
Universidad Tecnológica Nacional Facultad Regional Villa María
110
BALOG MARTIN AÑO 2010
7.1.6 Sistemas basados en capacidades
A continuación sistemas de protección basados en capacidades. Estos sistemas varían en cuanto a
su complejidad y al tipo de políticas que se pueden implementar. Ninguno de ellos se usa
ampliamente, pero son campos de prueba interesantes para teorías acerca de la protección.
Hydra
Hydra es un sistema de protección basado en capacidades que ofrece una flexibilidad
considerable. El sistema proporciona un conjunto fijo de posibles derechos de acceso que el
sistema conoce e interpreta. Los derechos incluyen formas de acceso tan básicas como el derecho
a leer, escribir o ejecutar un segmento de memoria.
Las operaciones con objetos se definen por procedimientos. Los procedimientos que implementan
tales operaciones son en sí una forma de objetos, y se accede a ellos de forma indirecta a través
de capacidades. Cuando se comunica a Hydra la definición de un objeto, los nombres de las
operaciones con ese tipo se convierten en derechos auxiliares, los cuales pueden describirse en
una capacidad para un ejemplar del tipo. Para que un proceso realice una operación con un objeto
con tipo, la capacidad que posea para ese objeto deberá contener entre sus derechos auxiliares el
nombre de la operación que se está invocando.
Otro concepto interesante es la amplificación de derechos. Este esquema permite certificar un
procedimiento como confiable para actuar sobre un parámetro formal de un tipo especificado, a
nombre de cualquier proceso que posea el derecho de ejecutar el procedimiento.
La amplificación es útil para conceder a los procedimientos de implementación acceso a las
variables de representación de un tipo de datos abstracto.
El mecanismo de invocación de procedimientos de Hydra se diseño como una solución directa
para el problema de subsistemas que sospechan uno del otro.
Sistema Cambridge CAP
En CAP hay diferentes clases de capacidades:
Ordinarias se denominan capacidades de datos y pueden servir para obtener acceso a los
objetos, pero los únicos que se confieren son los estándar de lectura, escritura o ejecución
de los segmentos de almacenamiento individuales asociadas al objeto. Las capacidades de
datos se interpretan con microcódigo en la maquina CAP.
El microcódigo de CAP protege, pero no interpreta, una capacidad de software. La
interpretación corre por cuenta de un procedimiento protegido (es decir, privilegiado) que
un programador de aplicaciones podría escribir como parte de un subsistema.
La interpretación de una capacidad de software se deja por completo al subsistema, a través de
los procedimientos protegidos que contiene.
Universidad Tecnológica Nacional Facultad Regional Villa María
111
BALOG MARTIN AÑO 2010
7.2 Seguridad
La información almacenada en el sistema (tanto datos como código), así como los recursos físicos
del sistema de computación, tienen que protegerse contra acceso no autorizado, destrucción o
alteración mal intencionada, y la introducción accidental de inconsistencias.
7.2.1 El problema de la seguridad
Las violaciones de seguridad (mal uso) del sistema se pueden clasificar como intencionales
(maliciosas) o accidentales. Es más fácil protegerse contra un mal uso accidental que contra un
abuso mal intencionado. Entre las formas de acceso mal intencionado están:
Lectura no autorizada de datos (robo de información)
Modificación no autorizada de datos
Destrucción no autorizada de datos
No es posible lograr una protección absoluta del sistema contra un abuso mal intencionado, pero
puede hacerse que el costo para el delincuente sea tan alto que frustre la mayor parte de, si no
todos, los intentos de acceder, sin la autorización debida, a la información que reside en el
sistema.
Para proteger el sistema debemos tomar medidas de seguridad en los siguientes niveles:
Físico. El sitio o sitios que contienen los sistemas de computación deben asegurarse
físicamente contra el ingreso armado o subrepticio de intrusos.
Humano. Los usuarios deben seleccionarse cuidadosamente para reducir la posibilidad de
autorizar un usuario que luego dará acceso a un intruso (a cambio de un soborno, por
ejemplo).
Se debe mantener la seguridad en ambos niveles para garantizar la seguridad del sistema
operativo.
7.2.2 Validación
Un problema de seguridad importante para los sistemas operativos es el de la validación. El
sistema de protección depende de una capacidad para identificar los programas y procesos que se
están ejecutando. La validación se basa en uno o más de los siguientes elementos:
Posesión del usuario. Una llave o tarjeta
Conocimiento del usuario. Un identificador de usuario y una contraseña
Atributo del usuario. Huella dactilar, patrón de retina o firma
Contraseñas
La estrategia más común para validad la identidad de un usuario es el empleo de contraseñas.
Cuando el usuario se identifica con un identificador de usuario o nombre de cuenta, se le pide una
contraseña. Si la contraseña que el usuario proporciona coincide con la que esta almacenada en el
sistema, éste supone que el usuario está autorizado. Podrían asociarse diferentes contraseñas a
diferentes derechos de acceso. Por ejemplo, podrían requerirse contraseñas distintas para leer,
anexar y actualizar un archivo.
Universidad Tecnológica Nacional Facultad Regional Villa María
112
BALOG MARTIN AÑO 2010
Vulnerabilidades de las contraseñas
Los problemas con las contraseñas tienen que ver con la dificultad para mantener secreta una
contraseña. Las contraseñas pueden perder su utilidad si se adivinan, exponen accidentalmente o
transfieren indebidamente de un usuario autorizado a uno no autorizado.
Hay formas comunes de adivinar una contraseña:
Una es que el intruso (sea humano o un programa) conozca al usuario o tenga información
acerca de él. Con demasiada frecuencia, la gente usa información obvia (digamos los
nombres de sus gatos o sus cónyuges) como contraseñas.
La otra es usar fuerza bruta, probando todas las posibilidades combinaciones de letras,
números y signos de puntuación hasta hallar la contraseña.
El fracaso de la seguridad por contraseña a causa de exposición puede ser resultado de vigilancia
visual o electrónica. Un intruso puede mirar por encima del hombro de un usuario cuando éste
está ingresando al sistema, y averiguar la contraseña fácilmente si observa el teclado.
El último problema que pone en peligro las contraseñas es consecuencia de la naturaleza humana.
La mayor parte de las instalaciones de computación tienen la regla de que no se permite a los
usuarios compartir cuentas. A veces, los usuarios rompen esta regla para ayudar a sus amigos o
burlar la contabilidad, y este comportamiento puede dar pie a que usuarios no autorizados – y
posiblemente perjudiciales – accedan al sistema.
Algunos sistemas también envejecen las contraseñas y obligan a los usuarios a cambiar sus
contraseñas a intervalos regulares (cada tres meses, por ejemplo) este método tampoco es una
garantía, porque los usuarios fácilmente podrían alternar entre dos contraseñas. La solución a este
problema, que se ha implementado en algunos sistemas, es registrar un historial de contraseñas
para cada usuario. Por ejemplo, el sistema podría registrar las últimas N contraseñas y no permitir
que se vuelvan a usar.
Contraseñas cifradas
Un problema a todas las estrategias anteriores es la dificultad para mantener secreta la
contraseña. El sistema UNIX usa cifrado para no tener que mantener en secreto su lista de
contraseñas. Cada usuario tiene una contraseña. El sistema contiene una función que es
extremadamente difícil (o imposible, desearían los diseñadores) de invertir, pero fácil de calcular.
Es decir, dado el valor x, es fácil calcular el valor de la función f(x). Pero dado un valor de la función
f(x), es imposible calcular x. esta función se usa para codificar todas las contraseñas. Sólo se
almacenan las contraseñas codificadas. Cuando un usuario presenta una contraseña, se codifica y
compara con la contraseña codificada almacenada. Aun si se logra ver esta última, no podrá
decodificarse, y no podrá determinarse la contraseña.
7.2.3 Contraseñas de un solo uso
Para evitar los problemas del husmeo de contraseñas y las miradas por encima del hombro, un
sistema podría usar un juego de contraseñas apareadas. Cuando se inicia una sesión, el sistema
selecciona al azar y presenta una parte de un par de contraseñas; el usuario deberá proporcionar
Universidad Tecnológica Nacional Facultad Regional Villa María
113
BALOG MARTIN AÑO 2010
la otra parte. En este sistema, se presenta un reto al usuario y éste debe responder con la repuesta
correcta a ese reto.
En un sistema de contraseñas de un solo uso, la contraseña es diferente en cada ocasión.
Cualquiera que capture la contraseña de una sesión y trate de reutilizarla en otra, fallará. Las
contraseñas de un solo uso son una de las únicas formas de evitar una validación indebida causada
por la exposición de la contraseña.
Otra variación de las contraseñas de un solo uso es el empleo de un libro de código, o cuaderno de
un solo uso, que es una lista de contraseñas de un solo uso. Con este método, se usa cada una de
las contraseñas de la lista, en orden, una vez, y luego se tacha o borra.
7.2.4 Amenazas por programas
En un entorno en el que un programa escrito por un usuario podría ser utilizado por otro usuario,
existe una posibilidad de abuso que podría dar pie a un comportamiento inesperado. A
continuación métodos comunes para causar tal comportamiento: los caballos de Troya y las
puertas secretas.
Caballo de Troya
Muchos sistemas cuentan con mecanismos que permiten a un usuario ejecutar programas escritos
por otros usuarios. Si tales programas se ejecutan en un dominio que proporciona los derechos de
acceso del usuario ejecutante, podrían abusar de esos derechos. Un segmento de código que
abusa de su entorno se denomina caballo de Troya.
Una variación del caballo de Troya sería un programa que emula un programa de ingreso al
sistema (login). Un usuario confiado comienza a ingresar en el sistema desde una terminal y se da
cuenta de que al parecer tecleo mal su contraseña. El usuario lo intenta de nuevo y tiene éxito. Lo
que ha sucedido es que su clave de validación y su contraseña han sido robados por el emulador
de login. A partir de ese momento, el usuario interactuó con el verdadero programa de login.
Puerta secreta (Trap Door)
El diseñador de un programa o sistema podría dejar un “agujero” en el software que sólo él puede
usar.
Podría incluirse una puerta secreta ingeniosa en un compilador. El compilador podría generar
código objeto estándar y también una puerta secreta, independientemente del código fuente que
se esté compilando. Las puertas secretas son un problema difícil porque para detectarlas es
preciso analizar todo el código fuente de todos los componentes de un sistema.
7.2.5 Vigilancia de amenazas
La seguridad de un sistema se puede mejorar con diferentes técnicas de administración:
Vigilancia de amenazas. El sistema puede buscar patrones de actividad sospechosos en un
intento por detectar violaciones de la seguridad. Un ejemplo, si hay varios intentos
incorrectos cuando un usuario está tratando de entrar al sistema, podría ser indicio de un
intento por adivinar una contraseña.
Universidad Tecnológica Nacional Facultad Regional Villa María
114
BALOG MARTIN AÑO 2010
Bitácora de auditoría. Simplemente registra la hora, el usuario y el tipo de todos los
accesos a un objeto. Después de una violación de la seguridad, la bitácora de auditoría
puede servir para determinar cómo y cuando ocurrió el problema, y tal vez la magnitud de
los daños. Desafortunadamente, las bitácoras pueden crecer mucho, y el registro de datos
en ellas puede ocupar recursos del sistema que los usuarios entonces no pueden
aprovechar.
El problema de poder conectar computadoras confiables sin peligro a una red no confiable. Una
solución es emplear una pared cortafuego (firewall) para separar los sistemas en los que se confía
en los que no se confía. Una pared cortafuego es un computador o encaminador que se coloca
entre lo confiable y lo no confiable, limita el acceso por red entre los dos dominios de seguridad y
vigila y asienta en una bitácora todas las conexiones. Una pared cortafuego puede dividir una red
en múltiples dominios. Una implementación común considera a Internet como el dominio no
confiable; una red semiconfiable y semisegura, llamada zona desmilitarizada (DMZ, demilitarized
zone) es otro dominio; y las computadoras de la compañía son un tercer dominio. Se permiten
conexiones de Internet a los computadores de la DMZ, y de los computadores de la compañía a
Internet, pero no de los computadores de Internet o de la DMZ a los computadores de la
compañía.
7.2.6 Cifrado
Cada vez más información confidencial (clasificada) se transmite por canales en los que podría
haber espías e interceptores de mensajes. Para mantener segura información tan sensible,
necesitamos mecanismos que permitan a un usuario proteger los datos que se transfieren por la
red.
El cifrado es un método común de proteger información que se transmite por enlaces no
confiables. El mecanismo básico funciona como sigue:
1. La información (texto) se cifra (codifica) de su forma comprensible original (llamada texto
limpio) a una forma interna (llamada texto cifrado). Esta forma interna del texto, aunque
se puede leer, no es comprensible.
2. El texto cifrado se puede almacenar en un archivo legible o transmitirse por canales
desprotegidos.
3. Para entender el texto cifrado, el receptor debe descifrarlo (decodificarlo) para convertirlo
otra vez en texto limpio.
Aun si un individuo o programa no autorizado obtiene acceso a al información cifrada, no le servirá
si no puede decodificarla. El reto principal al usar este método es crear esquemas de cifrado que
sean imposibles (o al menos extraordinariamente difíciles) de romper.
7.2.7 Clasificación de seguridad de las computadoras
Los criterios de Evaluación de Confiabilidad de Sistemas de Computación del Departamento de la
Defensa de Estados Unidos especifican diferentes divisiones de seguridad en los sistemas: A, B, C y
D. la clasificación de más bajo nivel es la división D, o de protección mínima. Se aplica a sistemas
Universidad Tecnológica Nacional Facultad Regional Villa María
115
BALOG MARTIN AÑO 2010
que se evaluaron pero no lograron satisfacer los requisitos de cualquiera de las otras clases de
seguridad. Por ejemplo, MS-DOS y Windows 3.1 están en la división D.
La división C, que es el siguiente nivel de seguridad, proporciona protección discrecional y
contabilización de los usuarios y sus acciones mediante el uso de funciones de auditoría. La
división C tiene niveles: C1 y C2. Un sistema clase C1 cuenta con alguna forma de control que
permite a los usuarios proteger información privada y evitar que otros usuarios lean o destruyan
accidentalmente sus datos. La mayor parte de las versiones de UNIX son clase C1.
El total de los sistemas de protección de un sistema de computación (hardware, software y
firmware) que obligan al cumplimiento correcto de una política de seguridad se denomina Base de
Computador Confiable (TCB, Trusted Computer Base). La TCB de un sistema C1 controla el acceso
entre usuarios y archivos permitiendo al usuario especificar y controlar el comportamiento de
objetos entre individuos nombrados o grupos definidos.
Un sistema clase C2 aúna a los requisitos de un sistema C1 el de un control de acceso a nivel
individual. La TCB también se protege contra la modificación de su código o estructuras de datos.
Además, ninguna información producida por un usuario previo está disponible para otro usuario
que accede a un objeto de almacenamiento que se liberó y devolvió al sistema. Algunas versiones
especiales seguras de UNIX se han certificado en el niel C2.
Los sistemas de protección obligatoria de la división B tienen todas las propiedades de un sistema
clase C2, pero además “pegan” etiquetas de confidencialidad a cada objeto. La TCB clase B1
mantiene la etiqueta de seguridad de cada objeto en el sistema; la etiqueta se usa para tomar
decisiones relacionadas con el control de acceso obligatorio.
Un sistema clase B2 extiende las etiquetas de confidencialidad a cada recurso del sistema, como
los objetos de almacenamiento.
Un sistema clase B3 permite crear listas de control de acceso que denotan usuarios a los que no se
concede acceso a un objeto nombrado dado.
La clasificación de nivel más alto es la división A. un sistema de clase A1 es funcional y
arquitectónicamente equivalente a un sistema B3, pero usa especificaciones de diseño formales y
técnicas de verificación que confieren un alto grado de seguridad de que la TCB se implemento
correctamente. Un sistema más allá de la clase A1 podría diseñarse y desarrollarse en una
instalación confiable por personal de confianza
Cabe señalar que el uso de una TCB sólo asegura que el sistema podrá hacer cumplir aspectos de
una política de seguridad. La TCB no especifica cuál debe ser la política.
Universidad Tecnológica Nacional Facultad Regional Villa María
116
BALOG MARTIN AÑO 2010
8 Computadoras distribuidas
8.1 Estructuras de sistemas distribuidos
8.1.1 Sistemas operativos de red
Un sistema operativo de red proporciona un entorno en el que lo usuarios, quienes se dan cuenta
de la multiplicidad de máquinas, pueden acceder a recursos remotos ya sea iniciando una sesión
en la máquina remota apropiada o transfiriendo datos desde la máquina remota a su propia
máquina.
Inicio de sesión remoto
Una función importante de los sistemas operativos de red es permitir a los usuarios iniciar una
sesión en un conmutador remoto. Internet ofrece el recurso telnet para este fin. El proceso de la
máquina remota pide al usuario un nombre de inicio de sesión y una contraseña. Después de
recibir la información correcta, el proceso actúa como “apoderado” del usuario, quien puede
trabajar en la máquina remota igual que cualquier usuario local.
Transferencia remota de archivos
Otra función importante de un sistema operativo de red es proporcionar un mecanismo para
transferir archivos de una máquina a otra. En un entorno así, cada computador mantiene su
propio sistema de archivos local. Si un usuario de un sitio A quiere acceder a un archivo situado en
otro computador B, será preciso copiar el archivo explícitamente del computador B al computador
A.
Internet ofrece un mecanismo para realizar este tipo de operaciones con el programa Protocolo de
Transferencia de Archivos (FTP, File Transfer Protocol).
En este esquema, la ubicación del archivo no es transparente para el usuario; los usuarios deben
saber exactamente dónde está el archivo. Además, no se comparten realmente los archivos,
porque el usuario sólo puede obtener una copia de un archivo para traerla a su sitio; así, podría
haber varias copias del mismo archivo, lo que implica un desperdicio de espacio. Además, si se
modifican dichas copias, se perderá la consistencia entre ellas.
Un aspecto importante de telnet y FTP es que obligan al usuario a cambiar de paradigma. Para
usar FTP, el usuario necesita conocer un conjunto de órdenes totalmente distinto de las órdenes
normales del sistema operativo. Para los usuarios, es más fácil, usar un recurso si ello no implica el
empleo de un conjunto de órdenes distinto. Los sistemas operativos distribuidos están diseñados
para aliviar este problema.
8.1.2 Sistemas operativos distribuidos
En un sistema operativo distribuido, los usuarios acceden a recursos remotos del mismo modo
como lo hacen a los recursos locales. La migración de datos y procesos de un sitio a otro está bajo
el control del sistema operativo distribuido.
Migración de datos
Universidad Tecnológica Nacional Facultad Regional Villa María
117
BALOG MARTIN AÑO 2010
Supongamos que un usuario del sitio A desea acceder a datos (digamos un archivo) que residen en
el sitio B. Hay métodos básicos que usan los sistemas para transferir los datos.
Una estrategia es transferir todo el archivo al sitio A. A partir de ese momento, todos los
accesos al archivo serán locales. Cuando el usuario ya no necesite acceder al archivo, se
enviara de regreso al sitio B una copia del archivo (si es que se modificó). Aun si sólo se
efectuó un cambio pequeño a un archivo grande, es preciso transferir todos los datos.
La otra estrategia consiste en transferir al sitio A sólo aquellas porciones del archivo que
realmente son necesarias para la tarea inmediata. Si se requiere otra porción después, se
efectuará otra transferencia. Cuando el usuario ya no desee acceder al archivo, cualquier
parte de él que se haya modificado se deberá enviar de vuelta al sitio B.
Queda claro que, si sólo se desea acceder a una parte pequeña de un archivo grande, el segundo
enfoque es preferible. Si se accederá a porciones significativas del archivo, resulta más eficiente
copiar todo el archivo.
Cabe señalar que no basta con transferir simplemente datos de un sitio a otro. El sistema también
deberá efectuar diversas traducciones de datos si los dos sitios participantes no son directamente
compatibles.
Migración de cómputos
En algunas circunstancias, podría ser más eficiente transferir el cómputo al otro sistema, en lugar
de traer los datos. Generalmente, si el tiempo que toma transferir un archivo es mayor que el
necesario para ejecutar la orden remota, se deberá usar la orden remota.
Supongamos que el proceso P desea acceder a un archivo en el sitio A. el acceso se realiza en el
sitio A, y podría iniciarse con una llamada a procedimiento remoto (RPC, Remote Procedure Call).
Una RPC utiliza un protocolo de datagrama (UDP en Internet) para ejecutar una rutina en un
sistema remoto. El proceso P invoca un procedimiento predefinido en el sitio A. el procedimiento
se ejecuta correctamente y luego devuelve los resultados a P.
Como alternativa, el proceso P puede enviar un mensaje al sitio A. el sistema operativo del sitio A
creara entonces un proceso Q nuevo cuya función es realizar la tarea designada. Una vez que el
proceso Q termina su ejecución, envía el resultado requerido a P empleando el sistema de
mensajes. Cabe señalar que, con este esquema, el proceso P podría ejecutarse de manera
concurrente con el proceso Q y, de hecho, podría tener varios procesos en ejecución
simultáneamente en varios sitios.
Ambos métodos pueden servir para acceder a varios archivos que residen en sitios distintos.
Migración de procesos
Cuando se somete un proceso para ejecutarse, no siempre se ejecuta en el sitio en el que se inicio.
Podría ser ventajoso ejecutar todo el proceso, o partes de él, en sitios diferentes. Razones para
usar tal esquema:
Balanceo de cargas: Los procesos (o subprocesos) podrían distribuirse en la red con objeto
de emparejar la carga de trabajo.
Universidad Tecnológica Nacional Facultad Regional Villa María
118
BALOG MARTIN AÑO 2010
Agilización del cómputo: Si un solo proceso se puede dividir en varios subprocesos que
podrían ejecutarse simultáneamente en diferentes sitios, podría ser posible reducir el
tiempo de retorno total del proceso.
Preferencias de hardware: El proceso podría tener características que lo hacen más
apropiado para ejecutarse en algún procesador expecializado.
Preferencias de software: El proceso podría requerir software que está disponible sólo en
cierto sitio, y el software no puede moverse o bien resulta más económico mover el
proceso.
Acceso a datos: Al igual que en la migración de cómputos, si los datos que se usaran en el
computo son abundantes, podría ser más eficiente ejecutar el proceso de forma remota,
en vez de transferir todos los datos a la máquina local.
Técnicas complementarias que pueden servir para transferir procesos en una red de
computadores
El sistema puede intentar ocultar el hecho de que un proceso migro desde el cliente. Este
esquema tiene la ventaja de que el usuario no necesita codificar su programa
explícitamente para que efectué la migración. Casi siempre, este método que se usa para
equilibrar las cargas y agilizar los cómputos entre sistemas homogéneos.
El otro enfoque es permitir (o exigir) que el usuario especifique explícitamente cómo debe
migrar un proceso. Este método suele usarse en situaciones en las que se debe mover el
proceso para satisfacer una preferencia de hardware o software.
8.1.3 Servicios remotos
Consideremos un usuario que necesita acceder a datos situados en algún otro sitio. Por ejemplo,
un usuario podría querer averiguar el número total de líneas, palabras y caracteres que tiene un
archivo situado en otro lugar.
Una forma de realizar esta transferencia es por medio del método de servicio remoto. Las
solicitudes de acceso se presentan al servidor, el cual realiza los accesos y remite los resultados al
usuario. Existe una correspondencia directa entre los accesos y el tráfico entre el usuario y el
servidor. Las solicitudes de acceso se traducen en mensajes para los servidores, y las respuestas
del servidor se empacan como mensajes y se envían de vuelta a los usuarios. Cada acceso es
atendido por el servidor y produce tráfico en la red.
8.1.3.1 Llamadas a procedimientos remotos
Una de las formas más comunes de servicio remoto es el paradigma RPC. La RPC se diseño como
una forma de abstraer el mecanismo de llamada a procedimiento para usarlo entre sistemas con
conexiones de red. Dado que estamos tratando con un entorno en el que los procesos se ejecutan
en sistemas distintos, tenemos que usar un esquema de comunicación basado en mensajes para
proporcionar un servicio remoto. Los mensajes están bien estructurados, y por tanto no son
simples paquetes de datos. Los mensajes se dirigen a un demonio de RPC que está “escuchando”
en un puerto del sistema remoto, y contienen un identificador de la función que se debe ejecutar,
Universidad Tecnológica Nacional Facultad Regional Villa María
119
BALOG MARTIN AÑO 2010
así como los parámetros que se deben pasar a esa función. A continuación, se ejecuta la función
solicitada y las salidas, si las hay, se devuelven al solicitante en un mensaje aparte.
Un puerto no es más que un número que se incluye al principio de un paquete de mensaje. Si bien
un sistema normalmente tiene una sola dirección de red, puede tener muchos puertos dentro de
esa dirección para diferenciar los múltiples servicios de red que presta.
El mecanismo RPC es común en los sistemas conectados a redes, así que hay varios aspectos de su
funcionamiento que conviene explicar. Una cuestión importante es la semántica de las llamadas.
Las RPC pueden fallar, o duplicarse y ejecutarse más de una vez, a causa de errores de red
comunes. Puesto que estamos tratando con una transferencia de mensajes por enlaces de
comunicación no confiables, es mucho más fácil para un sistema operativo asegurar que se haya
actuado en repuesta a un mensaje cuando más una vez, que asegurar que se haya actuado en
respuesta al mensaje exactamente una vez.
Otro aspecto importante es la comunicación entre el servidor y el cliente. La RPC requiere una
vinculación entre el cliente y el puerto del servidor. Ninguno de los dos sistemas (Cliente o
Servidor) tiene información completa acerca del otro porque no comparten memoria. Hay
estrategias comunes:
La información de vinculación podría decidirse con antelación, en forma de direcciones de
puerto fijas. En el momento de la compilación una llamada RPC tiene asociado un número
de puerto fijo. Una vez compilado el programa, el servidor no podrá cambiar el número de
puerto del servicio solicitado.
La vinculación puede efectuarse dinámicamente mediante un mecanismo de encuentros
(también llamado concertador) en un puerto RPC fijo. Un cliente envía entonces un
mensaje, que contiene el nombre de la RPC, al demonio de encuentros, solicitando la
dirección de puerto de la RPC que necesita ejecutar. El demonio devuelve el número de
puerto, y las llamadas RPC se pueden enviar a ese puerto hasta que el proceso termine (o
el servidor se caiga). Este método requiere el gasto extra de la solicitud inicial, pero es más
flexible que la primera estrategia.
El esquema de llamadas a procedimientos remotos es útil para implementar un sistema de
archivos distribuido. Se puede implementar un sistema así como un conjunto de demonios y
cliente de RPC. Los mensajes se dirigen al puerto DFS de un servidor en el que se realizará una
operación con un archivo. El mensaje contiene la operación de disco por efectuar. Dichas
operaciones podrían ser leer, escribir, cambiar de nombre, eliminar o estado, y corresponden a las
llamadas al sistema usuales relacionadas con los archivos. El mensaje de retorno contiene los
datos que hayan sido resultado de esa llamada, la cual el demonio DFS ejecuta a nombre del
cliente.
8.1.3.2 Hilos
Proceso e Hilos
El concepto de proceso incluye las características siguientes:
Universidad Tecnológica Nacional Facultad Regional Villa María
120
BALOG MARTIN AÑO 2010
Unidad de propiedad de los recursos: Un proceso incluye un espacio de direcciones
virtuales para mantener la imagen del proceso y, de cuando en cuando, al proceso se le
puede asignar el control o la propiedad de recursos tales como la memoria principal,
canales de E/S, dispositivos de E/S y archivos. El sistema operativo utiliza la función de
protección para prevenir las interferencias no deseadas entre procesos y recursos.
Unidad de expedición: La ejecución de un proceso sigue un camino de ejecución (traza) a
través de uno o más programas. Esta ejecución puede ser intercalada con la de otros
procesos.
Estas características son independientes y deben ser tratadas de manera independiente por el
sistema operativo. En algunos sistemas operativos de desarrollo reciente. Para distinguir estas dos
características, la unidad de expedición se conoce como hilo o proceso ligero (lightweight process),
mientras que a la unidad de propiedad de los recursos se le suele llamar proceso o tarea.
Multihilo
El termino multihilo hace referencia a la capacidad de un sistema operativo para mantener varios
hilos de ejecución dentro de un mismo proceso.
En un entorno multihilo, un proceso se define como la unidad de protección y unidad de
asignación de recursos. A los procesos se les asocian los siguientes elementos:
Un espacio de direcciones virtuales, que contiene la imagen del proceso.
Acceso protegido a los procesadores, otros procesos (para la comunicación entre
procesos), archivos y recursos de E/S (dispositivos y canales).
En un proceso puede haber uno o más hilos, cada uno con lo siguiente:
El estado de ejecución del hilo (Ejecución, Listo, etc.)
El contexto del procesador, que se salva cuando no está ejecutando; una forma de ver el
hilo es como un contador de programa independiente operando dentro de un proceso.
Una pila de ejecución.
Almacenamiento estático para las variables locales.
Acceso a la memoria y a los recursos del proceso, compartidos con todos los otros hilos
del mismo.
Todos los hilos de un proceso comparten el estado y los recursos del proceso. Residen en el mismo
espacio de direcciones y tienen acceso a los mismos datos. Cuando un hilo modifica un dato en la
memoria, los otros hilos utilizan el resultado cuando acceden al dato. Si un hilo abre un archivo
con permisos de lectura, el resto de los hilos del mismo proceso también pueden leer de él.
Los beneficios clave de los hilos se derivan de las implicaciones de rendimiento:
Se tarda mucho menos tiempo en crear un nuevo hilo en un proceso existente que en
crear un nuevo proceso.
Se tarda mucho menos tiempo terminar un hilo que un proceso.
Se tarda mucho menos tiempo en cambiar entre dos hilos de un mismo proceso.
Los hilos aumentan la eficiencia de la comunicación entre programas en ejecución. En la
mayoría de los sistemas operativos, la comunicación entre procesos independientes
Universidad Tecnológica Nacional Facultad Regional Villa María
121
BALOG MARTIN AÑO 2010
requiere la intervención del núcleo para ofrecer protección y para proporcionar los
mecanismos necesarios para la comunicación. Sin embargo, puesto que los hilos de un
mismo proceso comparten memoria y archivos, pueden comunicarse entre sí sin invocar al
núcleo.
Los hilos son también útiles en los monoprocesadores para simplificar la estructura de un
programa que lleva a cabo diferentes funciones.
La planificación y la expedición se lleva a cabo con los hilos; por lo tanto, la mayor parte de la
información de estado relacionada con la ejecución se mantiene en estructuras de datos de los
hilos. Puesto que todos los hilos de un proceso comparten el mismo espacio de direcciones, todos
deben entrar en el estado Suspendido al mismo tiempo. De manera similar, la terminación de un
proceso supone terminar con todos los hilos dentro de dicho proceso.
Funcionalidad de los hilos
Los hilos poseen un estado de ejecución y pueden sincronizarse entre ellos. Se estudiaran estos
aspectos de la funcionalidad de los hilos en orden.
Estados de un hilo
Si un proceso está expulsado de la memoria principal, todos sus hilos deberán estarlo porque
todos comparten el espacio de direcciones del proceso, es por eso que no tienen sentido asociar
estados de suspensión a hilos porque esos estados pertenecen al concepto de procesos.
Hay operaciones básicas con el cambio de estado en hilos:
Creación: Cuando se crea un nuevo proceso, también se crea un hilo para ese proceso.
Posteriormente, un hilo de un proceso puede crear otros hilos dentro del mismo proceso,
proporcionando un puntero de instrucción y los argumentos del nuevo hilo. El nuevo hilo
tendrá su propio contexto y su propio espacio de pila, y pasara a la cola de Listos.
Bloqueo: Cuando un hilo necesita esperar por un proceso, se bloquea (salvando sus
registros de usuario, contador de programa y punteros de pila). Ahora, el procesador
podrá pasar a ejecutar otro hilo Listo.
Desbloqueo: Cuando se produce el suceso por el que un hilo se bloqueo, el hilo pasa a la
cola de Listos.
Terminación: Cuando un hilo finaliza, se liberan su contexto y sus pilas.
Un punto importante es la posibilidad de que el bloqueo de un hilo lleve al bloqueo de todo el
proceso. Evitando la ejecución de cualquier otro hilo del mismo proceso, incluso si éste está en
estado Listo. Es evidente que la flexibilidad y la potencia de los hilos se pierden si el bloqueo de un
hilo supone el bloqueo de todo el proceso.
Sincronización de hilos
Todos los hilos de un proceso comparten el mismo espacio de direcciones y otros recursos, como
los archivos abiertos. Cualquier modificación de un recurso desde un hilo afecta al entorno del
resto de los hilos del mismo proceso. Por lo tanto, es necesario sincronizar la actividad de los
distintos hilos para que no interfieran unos con otros o corrompan las estructuras de datos.
Universidad Tecnológica Nacional Facultad Regional Villa María
122
BALOG MARTIN AÑO 2010
Hilos a nivel de núcleo y a nivel de usuario
Existen grandes categorías para la implementación de hilos:
Hilos a nivel de usuario (ULT)
Hilos a nivel de núcleo (KLT) también llamados hilos soportados por el núcleo (Kernel-
supported threads), o procesos ligeros
Hilos a nivel de usuario
En una aplicación ULT pura todo el trabajo de gestión de hilos lo realiza la aplicación y el núcleo no
es consciente de la existencia de hilos. Es posible programar cualquier aplicación como multihilo
mediante una biblioteca de hilos, que es un paquete de funciones para gestionar ULT. La biblioteca
de hilos contiene el código para crear y destruir hilos, para intercambiar mensajes y datos entre
hilos, para planificar la ejecución de hilos y para salvar y restaurar el contexto de los hilos.
Por defecto, una aplicación comienza su ejecución con un único hilo. Esta aplicación y su hilo
pertenecen a un único proceso, gestionado por el núcleo, en cualquiera de los instantes en los que
la aplicación se está ejecutando la aplicación puede crear un nuevo hilo que se ejecuta dentro del
mismo proceso. La creación se lleva a cabo ejecutando la utilidad de creación de la biblioteca de
hilos crea una estructura de datos para el nuevo hilo y cede el control a uno de los hilos del
proceso que está en el estado de Listos, elegido mediante algún algoritmo de planificación.
Cuando el control pasa a la biblioteca, se salva el contexto del hilo actual, que se restaura cuando
el control pasa de la biblioteca al hilo. Esencialmente, el contexto está formado por el contenido
de los registros de usuario, el contador de programa y los punteros de pila.
Todas las operaciones descriptas en el párrafo anterior, se llevan a cabo en el espacio de usuario
dentro de un mismo proceso. El núcleo no tiene conocimiento de ellas. El núcleo continua
planificando el proceso como una unidad y asignándoles un único estado (Listo, Ejecución,
Bloqueado, etc.).
Ventajas de usar ULT en lugar de KLT:
El intercambio de hilos no necesita los privilegios del modo de núcleo, porque todas las
estructuras de datos de gestión de hilos están en el espacio de direcciones de usuario de
un mismo proceso. Por lo tanto, el proceso no debe cambiar a modo de núcleo para
gestionar hilos. Con ello se evita la sobrecarga de dos cambios de modo.
Se puede realizar una planificación específica. Para una aplicación puede ser mejor la
planificación mediante turno rotatorio mientras que para otra puede ser mejor la
planificación por prioridades. Se puede realizar un algoritmo de planificación a medida de
la aplicación sin afectar a la planificación subyacente del sistema operativo.
Los ULT pueden ejecutar en cualquier sistema operativo. Para dar soporte a ULT no es
necesario realizar cambios en el núcleo subyacente. La biblioteca de hilos es un conjunto
de utilidades de aplicación compartidas por todas las aplicaciones.
Desventajas en el uso de ULT en vez de KLT:
Universidad Tecnológica Nacional Facultad Regional Villa María
123
BALOG MARTIN AÑO 2010
En un sistema operativo, la mayoría de las llamadas al sistema son bloqueadoras. Así pues,
cuando un ULT ejecuta una llamada al sistema no sólo se bloquea ese hilo, sino todos los
hilos del proceso.
En una estrategia ULT pura, una aplicación multihilo no puede aprovechar las ventajas de
los multiprocesadores. El núcleo asigna un proceso a un sólo procesador cada vez. Por lo
tanto, sólo puede ejecutar un hilo de cada proceso en cada instante.
Hilos a nivel de núcleo
En una aplicación KLT pura, todo el trabajo de gestión de hilos lo realiza el núcleo. En el area de la
aplicación no hay código de gestión de hilos, únicamente una Interfaz de programas de aplicación
(API) para las funciones de gestión de hilos en el núcleo.
Todos los hilos de la misma aplicación pertenecen a un único proceso. El núcleo mantiene la
información de contexto del proceso como un todo y la de cada hilo dentro del proceso. El núcleo
realiza la planificación en función de los hilos. Este método resuelve los principales inconvenientes
de la solución ULT:
El núcleo puede planificar simultáneamente múltiples hilos del mismo proceso en
múltiples procesadores.
Si se bloquea uno de los hilos de un proceso, el núcleo puede planificar otro hilo del
mismo proceso.
Otra ventaja de la solución KLT es que las propias funciones del núcleo pueden ser multihilo.
La principal desventaja de la solución KLT comparada con la solución ULT es que el paso del control
de un hilo a otro dentro del mismo proceso necesita un cambio de modo a modo de núcleo.
Aproximaciones combinadas
Algunos sistemas operativos ofrecen un mecanismo que combina ULT y KLT. El ejemplo más
importante es Solaris. En un sistema combinado, la creación de hilos, así como la mayor parte de
la planificación y sincronización de los hilos de una aplicación se realiza por completo en el espacio
de usuario. Los múltiples ULT de una sola aplicación se asocian con varios (el mismo o menor
número) KLT. El programador puede ajustar el número de KLT para cada aplicación y máquina en
particular para obtener el mejor resultado global.
En un método combinado, los múltiples hilos de una aplicación se pueden ejecutar en paralelo en
múltiples procesadores y las llamadas al sistema bloqueadoras no necesitan bloquear todo el
proceso.
8.1.3.3 Multiproceso simétrico
Durante mucho tiempo se ha abordado el encauzamiento de instrucciones hasta el punto de
solapar la lectura con la ejecución de operaciones. Ambas son ejemplo de funciones en paralelo.
Conforme ha ido evolucionando la tecnología y ha ido disminuyendo el coste del hardware, los
diseñadores de computadoras han buscado más y más ocasiones para el paralelismo,
normalmente para incrementar el rendimiento y, en algunos casos, para incrementar la fiabilidad.
Los enfoques más conocidos que ofrecen paralelismo mediante la duplicación de procesadores:
Universidad Tecnológica Nacional Facultad Regional Villa María
124
BALOG MARTIN AÑO 2010
Multiproceso simétrico (SMP)
Agrupaciones cluster
Arquitectura SMP
Resulta útil ver donde encajan las arquitecturas SMP dentro de la clasificación de los procesadores
paralelos. La forma más común de clasificar estos sistemas, es la taxonomía que destaca los
sistemas de procesamiento en paralelo introducidos por primera vez por Flynn. Propone las
siguientes categorías de sistemas informáticos:
Flujo de instrucción simple/dato simple (SISD): un único procesador ejecuta un único flujo
de instrucciones para operar sobre datos almacenados en una única memoria.
Flujo de instrucción simple/dato múltiples (SIMD): una única instrucción de máquina
controla la ejecución simultánea de varios elementos del proceso según una secuencia de
bloqueos. Cada elemento del proceso tiene una memoria de datos asociada, por lo que
cada instrucción se ejecuta sobre un conjunto de datos diferente por medio de distintos
procesadores. En esta categoría se encuentran los vectores y matrices de procesadores.
Flujo de instrucción múltiple/datos simples (MISD): se transmite una secuencia de datos a
un conjunto de procesadores, cada uno de los cuales ejecuta una instrucción de la
secuencia. Esta estructura no se ha implementado nunca.
Flujo de instrucción múltiple/datos múltiples (MIMD): un conjunto de procesadores
ejecuta simultáneamente varias secuencias de instrucciones sobre distintos conjuntos de
datos.
En la organización MIMD, los procesadores son de carácter general, porque deben ser capaces de
procesar todas las instrucciones necesarias para realizar la transformación de datos adecuada.
Estos sistemas se pueden subdividir en función de la comunicación entre procesadores (Figura
8.1). Si cada procesador tiene una memoria dedicada, cada elemento del proceso es un
computador autocontenido. Si los procesadores comparten una memoria común, cada uno de
ellos accede a programas y datos almacenados en la memoria compartida y se comunican entre sí
por medio de esa memoria: estos sistemas se denominan multiprocesadores con memoria
compartida.
Figura 8.1 Arquitectura de procesadores paralelos.
Universidad Tecnológica Nacional Facultad Regional Villa María
125
BALOG MARTIN AÑO 2010
Una posible clasificación general de los multiprocesadores con memoria compartida está basada
en la forma en que se asignan los procesos a los procesadores. Los enfoques más importantes son
maestro/esclavo y simetría.
Maestro/esclavo: el núcleo del sistema operativo siempre ejecuta en un procesador
determinado. El resto de los procesadores solamente pueden ejecutar programas de
usuario y, en ocasiones, utilidades del sistema operativo. El maestro es el responsable de
la planificación de procesos e hilos. Una vez que un proceso/hilo está activo, si un esclavo
necesita de un servicio del sistema operativo (por ejemplo, una solicitud de E/S) debe
enviar una petición al maestro y esperar a que se realice el servicio. Este método es más
sencillo y necesita de menos modificaciones sobre un sistema operativo monoprocesador
multiprogramado. La resolución de conflictos se simplifica porque uno de los procesadores
tiene el control de toda la memoria y los dispositivos de E/S. Las desventajas de esta
solución son las siguientes:
Un fallo en el maestro puede producir una caída de todo el sistema.
El maestro puede llegar a ser un cuello de botella, porque él solo debe llevar a
cabo toda la planificación y gestión de procesos.
Multiprocesador simétrico: el núcleo puede ejecutar en cualquier procesador y,
normalmente, cada procesador se autoplanifica a partir de una cola de procesos o hilos
libres. El núcleo puede estar construido como múltiples procesos o hilos, lo que permite
que haya partes del mismo que se ejecuten en paralelo. Con el enfoque SMP, el sistema
operativo es más complejo. Debe asegurarse de que dos procesadores no escojan el
mismo proceso y que los proceso no se pierdan de algún modo, desde la cola. Se deben
usar técnicas para resolver y sincronizar las solicitudes concurrentes de recursos.
Organización SMP
La figura 8.2 muestra la organización de un SMP. Hay múltiples procesadores, cada uno de los
cuales tiene su propia unidad de control, unidad aritmético-lógica y registros. Cada procesador
tiene acceso a una memoria principal compartida y a los dispositivos de E/S a través de algún tipo
de mecanismo de interconexión: un modo habitual es mediante un bus compartido. Los
procesadores pueden comunicarse entre sí por medio de la memoria (los mensajes y la
información de estado se almacena en espacios de direcciones compartidos). Los procesadores
también pueden intercambiar señales directamente.
Universidad Tecnológica Nacional Facultad Regional Villa María
126
BALOG MARTIN AÑO 2010
Figura 8.2 Organización de un multiprocesador simétrico
Consideraciones de diseño de un sistema operativo multiprocesador
Un sistema operativo SMP gestiona el procesador y el resto de los recursos del computador para
que el usuario pueda ver el sistema como si fuera un sistema monoprocesador multiprogramado.
Un usuario puede construir aplicaciones que unen múltiples procesos o múltiples hilos dentro de
procesos sin tener en cuenta si dispone de un solo procesador o de muchos. De este modo un
sistema operativo multiprocesador debe ofrecer toda la funcionalidad de un sistema
multiprogramado, junto con las características adicionales para trabajar con múltiples
procesadores. Algunos puntos clave de diseño son los siguientes:
Proceso o hilos concurrentes: Es necesario que las funciones del núcleo sean reentrantes,
para permitir que varios procesadores ejecuten el mismo código del núcleo al mismo
tiempo.
Planificación: Se debe evitar los conflictos ya que la planificación se puede realizar en
cualquier procesador.
Sincronización: Cuando varios procesos activos pueden acceder a espacios de memoria o
recursos compartidos, es necesario tomar precauciones para ofrecer una sincronización
eficaz.
Gestión de memoria: La gestión de memoria en un multiprocesador debe solucionar todos
los problemas encontrados en los monoprocesadores
Fiabilidad y tolerancia a los fallos: El sistema operativo debe realizar una degradación
proporcional en caso de fallo de un procesador.
Micronúcleos NO ES UN TEMA DENTRO DEL PROGRAMA PERO SIEMPRE LO RE CALCO EN LA TEORIA
Un concepto que ha recibido mucha atención últimamente es el de micronúcleo (microkernel). Un
micronúcleo es un pequeño núcleo del sistema operativo que proporciona las bases para
aplicaciones modulares. Hay una serie de cuestiones cuyas repuestas son diferentes según los
Universidad Tecnológica Nacional Facultad Regional Villa María
127
BALOG MARTIN AÑO 2010
distintos equipos de diseño de sistemas operativos. Estas cuestiones tratan acerca de lo pequeño
que debe ser el núcleo para ser calificado de micronúcleo, de cómo diseñar los gestores (drivers)
de dispositivos para alcanzar el mejor rendimiento a la vez que sus funciones se independizan del
hardware, de si las operaciones que no sean del núcleo deben ejecutarse en el espacio del núcleo
o en el del usuario y de si se debe mantener el código de los subsistemas existentes (por ejemplo
un versión del UNIX) o empezar desde cero.
Este enfoque fue popularizado por el sistema operativo Match. En teoría, esta aproximación
brinda una gran flexibilidad y modularidad. Otra aplicación muy conocida en el enfoque de
micronúcleos es W2K, que presenta no sólo la modularidad, sino la portabilidad. Este enfoque
general de diseño parece que va asentarse en casi todos los computadores personales, estaciones
de trabajo y sistemas operativos servidores que se desarrollen en el futuro.
Arquitectura micronúcleo
La filosofía en que se basa el micronúcleo es que sólo las funciones absolutamente esenciales del
núcleo del sistema operativo deben permanecer en el núcleo. Las aplicaciones y los servicios
menos esenciales se construyen sobre el micronúcleo y se ejecutan en modo de usuario. Aunque
la línea divisoria entre lo que está dentro y lo que está fuera del micronúcleo varia de un diseño a
otro, la característica común es que muchos servicios que tradicionalmente han formado parte del
sistema operativo son ahora subsistemas externos que interactúan con el núcleo y con otros
subsistemas: estos incluyen los controladores de dispositivo, los sistemas de archivos, los gestores
de memoria virtual, los sistemas de ventanas y los servicios de seguridad.
El micronúcleo funciona como un distribuidor de mensajes: valida los mensajes, los pasa entre las
componentes y otorga el acceso al hardware. El micronúcleo también actúa como función de
protección, evitando el intercambio de mensajes cuando no está permitido.
Ventajas de la organización micronúcleo
Hay varias ventajas en el uso de micronúcleos. Algunas de ellas son las siguientes:
Uniformidad de interfaces.
Extensibilidad.
Flexibilidad.
Portabilidad.
Fiabilidad.
Soporte a sistemas distribuidos.
Soporte para sistemas operativos a objetos. (OOOS).
Interfaz uniforme para solicitudes realizadas por los procesos. Los procesos no necesitan
diferenciar entre servicios de usuario y de núcleo, ya que todos los servicios se utilizan mediante
paso de mensajes.
Las arquitecturas micronúcleo facilitan la extensibilidad, permitiendo añadir nuevos servicios al
conjunto de servicios ya existentes en alguna de las áreas funcionales.
Universidad Tecnológica Nacional Facultad Regional Villa María
128
BALOG MARTIN AÑO 2010
Relacionada con la extensibilidad de la arquitectura micronúcleo surge la flexibilidad. No sólo se
pueden añadir nuevas características al sistema operativo, sino que se pueden reducir las
características actuales para dar lugar a una implementación más pequeña y más eficiente.
La portabilidad es una característica importante en un sistema operativo. En la arquitectura
micronúcleo, todo, o al menos la mayoría, del código específico del procesador está en el
micronúcleo. De este modo, los cambios necesarios para portar el sistema a un nuevo procesador
son menores y tienden a estar ordenados en agrupaciones lógicas.
Cuanto mayor es el tamaño de un producto software, más difícil es garantizar su fiabilidad. Con
una arquitectura micronúcleo se pueden obtener mayor ganancia de fiabilidad. Un pequeño
micronúcleo puede probarse de un modo muy riguroso. El uso de un pequeño número de
Interfaces de Programa de Aplicación (API) aumenta la probabilidad de producir código de calidad
para los servicios del sistema operativo externos al núcleo.
El micronúcleo ofrece, por si mismo, soporte a sistemas distribuidos, incluidas agrupaciones
controladas por un sistema operativo distribuido. Cuando un cliente envía un mensaje a un
proceso servidor, el mensaje debe incluir un identificador del servicio solicitado. Si el sistema
distribuido (por ejemplo, una agrupación) está configurado para que todos los procesos y servicios
tengan un identificador único, en realidad hay una única imagen del sistema a nivel de
micronúcleo.
Una arquitectura micronúcleo trabaja adecuadamente en el entorno de un sistema operativo
orientado a objetos. Una solución prometedora para aunar las arquitecturas micronúcleo con los
principios de los OOOS es el uso de componentes. Los componentes son objetos con interfaces
claramente definidas que se pueden interconectar para formar un software construido como
bloques. Todas las interacciones entre los componentes utilizan la interfaz. Otros sistemas, como
Windows 2000, no dependen única o exclusivamente de métodos orientados a objetos, sino que
incorporan los principios de orientación a objetos en el diseño del micronúcleo.
Rendimiento de micronúcleos
Una desventaja potencial, citada con frecuencia, de los micronúcleos es su rendimiento. Consume
más tiempo construir y enviar un mensaje, o aceptar y decodificar la respuesta, a través del
micronúcleo que mediante una simple llamada al sistema. Sin embargo, hay otros factores a tener
en cuenta, por lo que es difícil generalizar acerca de la penalización en el rendimiento.
La mayoría de ellos dependen del tamaño y funcionalidad del micronúcleo. Hay varios estudios
que revelan una importante penalización en el rendimiento en la primera generación de
micronúcleos. Para optimizar el código del micronúcleo, uno de los esfuerzos fue el aumento de
tamaño del micronúcleo al reintegrar en el sistema operativo servicios críticos y controladores de
dispositivo. Incrementando selectivamente la funcionalidad del micronúcleo se reduce el número
de cambios de modo usuario/núcleo y el número de cambios de espacio de direcciones del
proceso.
Universidad Tecnológica Nacional Facultad Regional Villa María
129
BALOG MARTIN AÑO 2010
Otro enfoque consiste en no hacer el micronúcleo mayor, sino más pequeño, se sostiene que, con
un diseño adecuado, un micronúcleo muy reducido elimina la penalización del rendimiento e
incrementa la flexibilidad y fiabilidad.
Diseño de micronúcleo
Un micronúcleo debe incluir aquellas funciones que dependen directamente del hardware y cuya
funcionalidad es necesaria para dar soporte a las aplicaciones y servidores que ejecutan en modo
de núcleo. Estas funciones se engloban en las siguientes categorías generales: gestión de memoria
a bajo nivel, comunicación entre procesos (IPC) y gestión de interrupciones y E/S.
Gestión de memoria a bajo nivel
El micronúcleo tiene el control del concepto hardware de espacio de direcciones, para permitir
implementar la protección en el proceso. Mientras que el micronúcleo es responsable de traducir
cada página virtual en un marco de página físico, la función principal de la gestión de memoria se
puede implementar fuera del mismo.
Se sugiere un conjunto de operaciones del micronúcleo que pueden dar soporte a la paginación y
gestión de memoria externas:
Cesión: el propietario de un espacio de direcciones (un proceso) puede ceder varias de sus
páginas a otro proceso. El núcleo retira esas páginas del espacio de direcciones del
proceso que las cede y las asigna al proceso elegido.
Asociación: un proceso puede asociar cualquiera de sus páginas al espacio de direcciones
de otro, de forma que ambos procesos tienen acceso a estas páginas. De esta forma se
crea memoria compartida entre los dos procesos.
Rellenado: un proceso puede reclamar cualquier página concedida o asociada a otro.
En un principio, el núcleo define toda la memoria física como un único espacio de direcciones
controlado por un proceso del sistema base. Cuando se crea un nuevo proceso, se le conceden o
asocian páginas de este espacio de direcciones original. Este tipo de esquema permite soportar
simultáneamente múltiples esquemas de memoria virtual.
Comunicación entre procesos
Los mensajes son el mecanismo básico de comunicación entre procesos o hilos en un sistema
operativo con micronúcleo. Un mensaje incluye una cabecera, que identifica a los procesos emisor
y receptor, y un cuerpo, que contiene directamente los datos. Se puede pensar en la IPC en forma
de puertos asociados a procesos. Un puerto es, en esencia, una cola de mensajes destinados a un
proceso en particular. Cada puerto tiene asociada una lista de capacidades de acceso (capabilities)
que indica qué procesos pueden comunicarse con éste. El núcleo mantiene los identificadores de
puerto y las listas de capacidades de acceso. Un proceso puede obtener acceso a un puerto
enviando un mensaje al núcleo indicándole la nueva capacidad de acceso.
El paso de mensajes entre procesos independientes sin solapamiento de espacios de direcciones
supone copias de memoria a memoria y está limitado por la velocidad de la memoria y no
depende de la velocidad del procesador.
Universidad Tecnológica Nacional Facultad Regional Villa María
130
BALOG MARTIN AÑO 2010
Gestión de interrupciones y E/S
En una arquitectura, es posible gestionar las interrupciones de hardware como mensajes e incluir
los puertos de E/S en espacios de direcciones, pero el micronúcleo no se hace cargo de la gestión
de interrupciones específicas de un dispositivo. En lugar de eso, se genera un mensaje desde el
proceso de usuario en ese momento asociado a esa interrupción.
8.1.4 Gestión de procesos
No lo encontré en todo el rejunte, ni siquiera en el libro Fundamentos de sistemas operativos
Séptima edición.
8.2 Protocolos (constituyen una serie de normas)
8.2.1 Concepto
Para que dos entidades se comuniquen con éxito deben “hablar el mismo lenguaje”. Qué
comunican, cómo se comunican y cuando lo hacen deben constituir un conjunto de reglas
aceptadas mutuamente entre las entidades involucradas. El conjunto de convenciones se
denomina protocolo, que puede definirse como un conjunto de normas que gestionan el
intercambio de datos entre dos entidades. Los elementos clave de un protocolo son:
Sintaxis: comprende cuestiones tales como formato de datos, codificación y niveles de
señal.
Semántica: comprende información de control para la coordinación y la gestión de
errores.
Temporización: comprende la coordinación en la velocidad y el orden secuencial.
8.2.2 Características
Algunas características importantes de un protocolo son:
Directo/indirecto.
Monolítico/estructurado.
Simétrico/asimétrico.
Normalizado/no normalizado.
La comunicación entre dos entidades puede ser directa o indirecta. En la Figura 8.3 se muestran
diferentes situaciones posibles. Si dos sistemas comparten un enlace punto a punto, las entidades
en estos sistemas pueden comunicarse directamente; es decir, se pasan directamente datos e
información de control entre ellas sin intervención de un agente activo. Lo mismo se puede decir
de una configuración multipunto, aunque en este caso las entidades deben estar relacionadas con
la tarea de control de acceso, provocando que el protocolo sea más complejo. Si los sistemas se
conectan a través de una red de comunicaciones conmutada, no es posible el uso de un protocolo
directo. Las dos entidades deben depender del funcionamiento de otras entidades para
intercambiar datos. Un caso más externo es una situación en la que dos entidades no comparten
ni siquiera la misma red conmutada, sino que se encuentran conectadas indirectamente a través
Universidad Tecnológica Nacional Facultad Regional Villa María
131
BALOG MARTIN AÑO 2010
de dos o más redes. Un conjunto de redes interconectadas de esta forma se denomina internet o
interconexión de redes.
Figura 8.3 Medios de conexión de sistemas de comunicación
Otra característica de un protocolo es si este es monolítico o estructurado. Es evidente que la
tarea de comunicación entre entidades en sistemas diferentes es demasiado compleja para
gestionarla como una sola unidad.
Una alternativa consiste en hacer uso de técnicas de diseño y de implementación estructurados.
En lugar de un único protocolo, existe un conjunto de ellos que presentan una estructura
jerárquica o en capas. Se implementan funciones primitivas en entidades de nivel inferior que
ofrecen servicios a entidades de nivel superior.
Un protocolo puede ser simétrico o asimétrico. La mayor parte de los protocolos son simétricos; es
decir, la comunicación se realiza entre entidades paritarias. La asimetría puede deberse a la lógica
de un intercambio (por ejemplo, un proceso “cliente” y otro “servidor”), o por el deseo de hacer
una de las entidades o sistemas tan sencillo como sea posible.
Por último, un protocolo puede ser normalizado o no. Un protocolo no normalizado es un
protocolo diseñado para una situación de comunicación específica o, a lo sumo, para un modelo
particular de un conmutador.
8.2.3 Funciones
Las funciones de los protocolos se pueden agrupar en las siguientes características:
Segmentación y ensamblado
Universidad Tecnológica Nacional Facultad Regional Villa María
132
BALOG MARTIN AÑO 2010
Encapsulación
Control de conexión
Envío ordenado
Control de flujo
Control de errores
Direccionamiento
Multiplexación
Servicios de transmisión
Segmentación (en TCP/IP se usa el término fragmentación) y ensamblado
En el nivel de aplicación denominaremos mensaje a una unidad lógica de transferencia de datos.
Ahora bien, si la entidad de aplicación envía datos en mensajes o en una secuencia continua, los
protocolos de nivel inferior pueden necesitar dividir los datos en bloques de menor tamaño y
todos del mismo. Este proceso se llama segmentación. Por conveniencia, denominaremos unidad
de datos de protocolo (PDU, Protocol Data Unit) a un bloque de datos intercambiado entre dos
entidades a través de un protocolo.
Existen varias razones para hacer uso de la segmentación. Entre las razones usuales se
encuentran:
La red de comunicaciones sólo puede aceptar bloques de datos de tamaño máximo.
El control de errores puede resultar más eficiente con tamaños menores de PDU.
Se puede proporcionar un acceso más equitativo a las facilidades de transmisión
compartidas con un retardo más reducido.
Un tamaño menor de PDU podría significar que las entidades receptoras necesiten
reservar memorias temporales de menor capacidad.
Una entidad puede necesitar que la transferencia de datos entre de vez en cuando en
algún tipo de “cierre” para operaciones de comprobación y de reinicio/recuperación.
La segmentación presenta varias desventajas que proporcionan argumentos para la creación de
bloques tan grandes como sea posible
Como veremos, cada PDU contiene una cantidad mínima fija de información de control.
Así, cuanto menor sea el bloque, mayor será el porcentaje global de bits suplementarios.
La recepción de una PDU pueden generar una interrupción que debe ser atendida.
Se consume más tiempo en procesar PDU más pequeñas y numerosas.
Todos estos factores deben ser tenidos en consideración por el diseñador de protocolos para
determinar el tamaño máximo y mínimo de las PDU.
Lo contrario a segmentar es ensamblar. Eventualmente, los datos segmentados deben agruparse
en mensajes apropiados para el nivel de aplicación. La tarea se complica si se reciben las PDU
fuera de secuencia.
Encapsulado
Universidad Tecnológica Nacional Facultad Regional Villa María
133
BALOG MARTIN AÑO 2010
Cada PDU consta no sólo de datos, sino también de información de control. En cambio, algunas
PDU contienen sólo información de control, sin datos. La información de control se clasifica en
categorías:
Dirección: se puede indicar la dirección del emisor y/o la del receptor.
Código de detección de errores: a veces se incluye algún tipo de secuencia de
comprobación de trama para detección de errores.
Control de protocolo: se incluye información adicional para implementar las funciones de
protocolo.
La incorporación de información de control a los datos se denomina encapsulado.
Control de conexión
Una entidad puede transmitir datos a otra entidad de forma que cada PDU se trate
independientemente de las PDU anteriores. Esto se conoce como transferencia de datos no
orientada a conexión; un ejemplo es el uso de datagramas. Aunque este modo es útil, una técnica
igualmente importante es la transferencia de datos orientada a conexión, de la que el circuito
virtual es un ejemplo.
Si las estaciones prevén un intercambio largo de datos y/o algunos detalles de su protocolo
cambian dinámicamente, es preferible (incluso necesaria) la transferencia de datos orientada a
conexión. Se establece una asociación lógica, o conexión, entre entidades. Tiene lugar en fases
(Figura 8.4):
1. Establecimiento de conexión
2. Transferencia de datos
3. Liberación de conexión
Figura 8.4 Fases de una transferencia de datos orientada a conexión
Durante la fase de establecimiento de conexión, dos entidades se componen de acuerdo para
intercambiar datos. Generalmente, una estación enviará una petición de conexión (de forma no
orientada a la conexión) a la otra. Una autoridad central puede o no estar involucrada. La entidad
receptora acepta o rechaza la petición y, una vez establecida la conexión, se pasa a la fase de
Universidad Tecnológica Nacional Facultad Regional Villa María
134
BALOG MARTIN AÑO 2010
transferencia de datos. Durante esta fase se intercambian tanto datos como información de
control (por ejemplo, control de flujo, control de errores). Por último un extremo o el otro desean
liberar la conexión, lo que consiguen enviando una petición de liberación. Alternativamente, una
autoridad central podría ser la encargada de liberarla.
Realmente podemos definir una transferencia de datos orientada a conexión esencialmente como
una en la que ambos extremos numeran las PDU y gestionan los números de entrega y de salida. El
orden secuencial permite la realización de funciones principales: entrega ordenada, control de
flujo y control de errores.
Entrega ordenada
Si dos entidades comunicadas se encuentran en estaciones diferentes en una red, existe el peligro
de que las PDU no se reciban en el mismo orden en que fueron enviadas debido a que siguen
diferentes caminos a través de la red. Si cada PDU tiene un único número, y los números se
asignan de forma secuencial, la reordenación de las PDU recibidas en base a los números de
secuencia resulta una tarea lógica sencilla para la entidad receptora.
Control de flujo
El control de flujo es una función realizada por la entidad receptora para limitar la cantidad o tasa
de datos que envía la entidad emisora.
La forma más sencilla de control de flujo es un procedimiento de parada y espera (stop-and-wait),
en el que cada PDU debe ser confirmada antes de que se envié la siguiente. El uso de protocolos
más eficientes implica la utilización de alguna forma de crédito ofrecido por el emisor, que es la
cantidad de datos que se pueden enviar sin necesidad de confirmación. La técnica de ventana
deslizante es un ejemplo de este mecanismo.
Control de errores
Es necesario el uso de técnicas para gestionar la pérdida o los errores de datos e información de
control. La mayor parte de las técnicas incluyen detección de errores, basada en el uso de una
secuencia de comprobación de trama, y retransmisión de PDU. La retransmisión se consigue a
veces mediante el uso de un temporizador. Si una entidad emisora no recibe una confirmación de
una PDU dentro de un período de tiempo especificado, retransmitirá los datos.
Direccionamiento
El concepto de direccionamiento en una arquitectura de comunicaciones es complejo y abarca un
gran número de cuestiones. Entre ellas deben tenerse en cuenta las siguientes:
Nivel de direccionamiento
Ámbito del direccionamiento
Identificadores de conexión
Modo de direccionamiento
El nivel de direccionamiento hace mención al nivel en que se llama a una entidad dentro de la
arquitectura de comunicaciones. Generalmente, en una configuración se asocia una única
dirección a cada sistema final (por ejemplo, estación o terminal) y a cada sistema intermedio (por
Universidad Tecnológica Nacional Facultad Regional Villa María
135
BALOG MARTIN AÑO 2010
ejemplo, un dispositivo de encadenamiento). Esta dirección es, en general, una dirección del nivel
de red. En el caso de la arquitectura TCP/IP se conoce como una dirección IP, o simplemente
dirección internet. En la arquitectura OSI, esta dirección se la conoce como punto de acceso al
servicio de red (NSAP, network service Access point).
El ámbito de direccionamiento la dirección internet o dirección NSAP mencionada anteriormente
es una dirección global. Las características más importantes de una dirección global son:
Sin ambigüedad global: una dirección global identifica un único sistema, permitiéndose el
uso de sinónimos; es decir, un sistema puede tener más de una dirección global.
Aplicabilidad global: en una dirección global es posible identificar cualquier otra dirección
global, en cualquier sistema, mediante la dirección global del otro sistema.
Cada subred debe mantener una única dirección para cada dispositivo de interfaz con la subred.
El ámbito de direccionamiento es generalmente relevante sólo para direcciones del nivel de red.
Un puerto o SAP por encima del nivel de red es único en un sistema específico, pero no necesita
ser único globalmente.
El concepto de identificadores de conexión entra en juego cuando se consideran transferencias de
datos orientadas a conexión (por ejemplo, circuito virtual) en lugar de transferencia no orientadas
a conexión (por ejemplo, datagramas).
Otro concepto importante en direccionamiento es el modo de direccionamiento. Una dirección se
refiere generalmente a un único sistema o puerto; en este caso se le denomina dirección
individual. Una dirección con múltiples receptores o destinos pueden ser de difusión, dirigida a
todas las entidades de un dominio, o multidestino, dirigida a un subconjunto especifico de
entidades.
Multiplexación
Puede existir múltiples circuitos virtuales que terminan en el mismo sistema final; podemos decir
que estos circuitos virtuales están multiplexados sobre la interfaz física entre el sistema final y la
red. La multiplexación también se puede realizar mediante el uso de nombres de puerto, que
también permiten múltiples conexiones simultáneas.
La Multiplexación se puede usar en una o en dos direcciones (Figura 8.5). La multiplexación hacia
arriba (upward) tienen lugar cuando se multiplexan, o comparten, varias conexiones del nivel
superior a través de una sola conexión del nivel inferior o para proporcionar varias conexiones del
nivel superior en un entorno en el que existe una sola conexión del nivel inferior. La multiplexación
hacia abajo (downward), o división, implica que se crea una sola conexión del nivel superior
encima de múltiples conexiones del nivel inferior, dividiéndose el trafico de la conexión superior
entre las distintas conexiones inferiores. Esta técnica se puede usar para proporcionar fiabilidad,
prestaciones o eficiencia.
Universidad Tecnológica Nacional Facultad Regional Villa María
136
BALOG MARTIN AÑO 2010
Figura 8.5 Multiplexación y conexiones de protocolo
Servicios de transmisión
Un protocolo puede ofrecer una gran variedad de servicios adicionales a las entidades que hagan
uso de él. Ejemplos comunes:
Prioridad: determinados mensajes, tales como los mensajes de control, pueden necesitar
ir hacia la entidad de destino con un retardo mínimo.
Grado de servicio: ciertas clases de datos pueden necesitar un umbral de rendimiento
mínimo u otro de retardo máximo.
Seguridad: se pueden utilizar mecanismos de seguridad, de acceso restringido.
Todos estos servicios dependen del sistema de transmisión subyacentes y de cualesquiera
entidades de nivel inferior que intervengan.
Arquitectura OSI
Debido a la complejidad de la interconexión de computadoras, se ha tenido que dividir todos los
procesos necesarios para realizar las conexiones en diferentes niveles. Cada nivel se ha creado
para dar una solución a un tipo de problema particular y tendrá asociado un protocolo.
La comunicación según el modelo OSI (estándar) siempre se realizará entre dos sistemas, la
información se genera, por ejemplo, en el nivel 7 de uno de ellos y desciende por el resto de los
niveles hasta llegar al nivel 1 y llega hasta el nivel 1 del otro sistema, donde va ascendiendo hasta
Universidad Tecnológica Nacional Facultad Regional Villa María
137
BALOG MARTIN AÑO 2010
alcanzar el nivel 7. Cada uno de los niveles va añadiendo a los datos a transmitir la información de
control de forma que los datos originales van siendo recubiertos por capas.
Las capas del modelo son:
1. Física: se ocupa de la transmisión del flujo de bits a través del medio
2. Enlace: divide el flujo de bits en unidades con formato, intercambiando estas unidades
mediante el empleo de protocolos
3. Red: establece las comunicaciones y determina el camino que tomaran los datos en la red
4. Transporte: asegura que el receptor reciba exactamente lo que el emisor envió y a veces
asegura al emisor que el receptor ha recibido correctamente la información.
5. Sesión: Establece la comunicación entre las aplicaciones, la mantiene y la finaliza en el
momento adecuado. Permite a los usuarios realizar y mantener diferentes conexiones a la
vez (sesiones).
6. Presentación: Conversión entre distintas representaciones de datos entre terminales y
organizaciones de sistemas de archivos con características diferentes.
7. Aplicación: Las personas que utilizan las aplicaciones hacen una petición de un servicio y la
aplicación utiliza el servicio que le ofrece el nivel de aplicación para poder realizar el
trabajo encomendado.
Arquitectura del protocolo TCP/IP
El protocolo TCP está orientado a la conexión y funciona en el nivel de transporte y el IP en el de
red. Se descompone en diferentes niveles, cuatro de software y uno de hardware.
Aplicación: se trata de un nivel simple en el que se encuentran las aplicaciones que
acceden a servicios disponibles a través de internet.
Transporte: el emisor divide la información en paquetes, le añade los datos necesarios
para el control de flujo y control de errores y los envía a la próxima capa junto con la
dirección de destino. En el receptor este nivel se encarga de ordenar y unir las tramas.
Red: coloca la información que le llega en datagramas, le añade cabeceras para su nivel y
lo envía al nivel inferior.
Enlace: recibe los datagramas y los transmite al hardware de la red.
Estos son los cuatro de software.
Física: define características del medio de transmisión, tasa de señalización y esquema de
codificación de las señales.
Sistemas distribuidos de archivos
Es importante distinguir los siguientes conceptos:
Servicio de archivo: es la especificación de los servicios que el sistema de archivos ofrece a
sus clientes.
Servidor de archivos: es un proceso que se ejecuta en alguna maquina y ayuda a implantar
el servicio de archivos. Un sistema puede contener varios servidores de archivos, cada uno
de los cuales ofrece un servicio de archivos distinto.
Diseño
Universidad Tecnológica Nacional Facultad Regional Villa María
138
BALOG MARTIN AÑO 2010
Un sistema distribuido de archivos tiene componentes:
El verdadero servicio de archivos encarga de las operaciones en los archivos individuales,
como lectura, escritura y adición
El servicio de directorios se encarga de crear y administrar directorios, añadir y eliminar
archivos de los directorios.
La interfaz del servicio de archivos
Un archivo puede tener atributos, partes de información relativos a él pero que no son parte del
archivo propiamente dicho. El servicio de archivos proporciona primitivas para leer y escribir en
algunos de los atributos.
Si los archivos una vez creados no se pueden modificar se dice que tal archivo es inmutable, esto
facilita el soporte del ocultamiento y duplicación de archivos.
Cada usuario tiene cierto tipo de boleto llamado posibilidad, que determina los tipos de acceso
permitidos para cada objeto. Se incluye una lista para control de acceso asociada a cada archivo
con los usuarios que pueden tener acceso y la forma de los mismos.
Los servicios de archivos se pueden dividir en tipos, según si soportan un modelo carga/descarga o
un modelo de acceso remoto. En el primero solo se proporcionan las siguientes operaciones
principales: la lectura y escritura y luego se devuelve al servidor. En el segundo se proporciona
gran número de operaciones para abrir, cerrar, leer, escribir, examinar y modificar archivos o
atributos de él. No se necesita ninguna transferencia porque se ejecutan en el servidor.
La interfaz del servicio de directorios
Proporciona las operaciones para crear y eliminar directorios, nombrar o cambiar el nombre de
archivos y mover éstos de un directorio a otro. Los directorios pueden tener subdirectorios y estos
contener subdirectorios también por lo tanto se conduce a un árbol llamado sistema jerárquico de
archivos. Es posible crear enlaces o apuntadores a un directorio arbitrario que puede estar en
cualquier directorio, lo que permite construir graficas de directorios. Sólo se puede eliminar un
enlace si el directorio al cual apunta está vacío.
Transparencia
La transparencia con respecto a la posición significa que el nombre de la ruta de acceso no sugiere
la posición del archivo. Un sistema donde los archivos se pueden desplazar sin que cambien sus
nombres tienen independencia con respecto a la posición.
Nombre de dos niveles
Los archivos tienen nombres simbólicos para uso de las personas pero también tienen nombres
binarios internos, para uso del propio sistema. Cuando se abre un archivo el sistema busca el
nombre simbólico en el directorio correspondiente para obtener el nombre binario, que debe
indicar el servidor además del archivo especifico. Otra alternativa es utilizar un enlace simbólico
que es una entrada de directorio asociada a una cadena.
Semántica de los archivos compartidos
Universidad Tecnológica Nacional Facultad Regional Villa María
139
BALOG MARTIN AÑO 2010
Si dos o más usuarios comparten el mismo archivo, es necesario definir con precisión la semántica
de la lectura y escritura para evitar problemas. Se pueden utilizar maneras distintas para compartir
archivos en un sistema distribuido.
Semántica de Unix: Cada operación en un archivo es visible a todos los usuarios de manera
instantánea.
Semántica de sesión: Ningún cambio es visible a otros procesos hasta que el archivo se
cierre.
Archivos inmutables: No existen actualizaciones en archivos, pero si en directorios, se
puede crear un archivo nuevo y reemplazarlo.
Transacciones: Con transacciones atómicas se garantiza que todas las llamadas contenidas
en ellas se llevaran a cabo en orden.
Implantación de un sistema distribuido de archivos
Uso de archivos
Antes de implementar cualquier sistema es bueno tener idea del posible uso que le va a dar, para
ello es necesario hacer algunas mediciones que pueden ser estáticas, si se realizan al examinar el
disco o dinámicas. La clara existencia de distintas clases de archivos sugiere que se deberían
utilizar mecanismos diferentes para el manejo de esas clases.
Algunas propiedades observadas de los sistemas de archivos son:
La mayoría de los archivos son pequeños.
La lectura es más común que la escritura.
La lectura y escritura son secuenciales.
Es poco usual compartir archivos y éstos tienen una vida corta.
Existen distintas clases de archivos con propiedades diferentes.
Estructura de sistema
Una forma de organizar la estructura del servicio de archivos y directorios es combinar ambos en
un servidor, pero como las dos funciones no tienen relación real entre sí es más flexible
mantenerlas separadas. De esta manera es posible que una jerarquía de directorios se reporta
entre varios servidores. Para buscar un archivo se puede realizar una búsqueda interactiva, que
requiere que el cliente sea consciente de cuál servidor contiene cual directorio y necesita más
mensajes, o una búsqueda automática que es más eficiente.
Existen pensamientos diferentes:
Uno asegura que los servidores no deben contener los estados de los clientes, es decir ser
sin estados,
El otro sostiene que es correcto que los servidores conserven información de estado de los
clientes
En estos últimos al abrir un archivo, el cliente recibe un descriptor de archivo que el servidor
utiliza para determinar el archivo necesario. La tabla que asocia los descriptores de archivo con los
archivos propiamente dichos es información de estado. En el caso de un servidor sin estado, cada
Universidad Tecnológica Nacional Facultad Regional Villa María
140
BALOG MARTIN AÑO 2010
solicitud debe estar autocontenida. Puede ocurrir que se pierdan todas las tablas de un servidor
por una falla y éste no tendría idea de las relaciones entre clientes y archivos abiertos. Los
servidores sin estado son más tolerante a fallas.
Ocultamiento
En un sistema cliente/servidor existen diferentes lugares donde se pueden almacenar los archivos:
Disco del servidor
Memoria del servidor
Memoria del cliente
Disco del cliente
El lugar más directo es el disco del servidor, existe mucho espacio y los archivos son accesibles a
todos los clientes. El problema es el desempeño porque las transferencias tardan mucho tiempo,
pero se puede mejorar si se ocultan (conservan) los archivos de más reciente uso en la memoria
principal del servidor. Se utiliza un algoritmo para determinar que archivos deben permanecer en
el caché, además de decidir qué tamaño tendrá la caché y si se ocupa toda la capacidad qué
archivo se eliminará de la misma.
Para eliminar el acceso a la red se puede hacer el ocultamiento del lado del cliente usando la
memoria principal o el disco. Al colocar la caché en la memoria principal puede tener diferentes
opciones:
Ocultar los archivos en forma directa dentro del propio espacio de direcciones de un
proceso usuario,
Colocar el caché en el núcleo con la desventaja de que siempre se tenga que llamar al
núcleo,
Colocar el caché en un proceso administrador del caché independiente y a nivel usuario.
Consistencia del caché
Para mantener la consistencia se utiliza el algoritmo de escritura a través del caché. Cuando se
modifica una entrada del caché el nuevo valor se mantiene dentro de él, pero también se envía de
inmediato al servidor. Se puede adoptar la semántica de sesión y solo escribir un archivo de nuevo
en el servidor hasta que este se cierre, este algoritmo se llama de escritura al cierre, para evitar el
inconveniente de tener valores obsoletos en el caché.
Réplica
Algunas razones por las cuales los sistemas distribuidos proporcionan la réplica como servicio a sus
clientes son:
Aumentar la confiabilidad al disponer de respaldos independientes de cada archivo,
Permitir el acceso al archivo aunque falle un servidor de archivos
Repartir la carga del trabajo entre varios servidores.
Es importante la transparencia con respecto a la réplica, el usuario puede tener conciencia de que
existen archivos duplicados o bien el sistema puede hacer todo a espalda de ellos.
Hay diferentes formas de llevar a cabo las réplicas:
Universidad Tecnológica Nacional Facultad Regional Villa María
141
BALOG MARTIN AÑO 2010
El programador controla el proceso, las direcciones en la red de todas las copias se pueden
asociar con el nombre del archivo y cuando se busque el nombre se encuentran todas las
copias.
Réplica retrasada se llama cuando sólo se crea una copia de cada archivo en un servidor y
más tarde éste crea las réplicas en otros servidores en forma automática. El archivo puede
cambiar antes de que se hagan las copias.
Se usa la comunicación en grupo, todas las llamadas escribir el sistema se transmiten en
forma simultánea a todos los servidores a la vez, por lo que las copias adicionales se hacen
al mismo tiempo que el original.
Protocolos de actualización
Réplica de la copia primaria: Uno de los servidores se denomina primario y a él se
actualizan los archivos, después el envía comandos a los secundarios para ordenarles la
misma modificación.
Voto: Los clientes deben solicitar y adquirir el permiso de varios servidores (la mitad + 1)
antes de leer o escribir un archivo duplicado.
Proceso Cliente/Servidor Es un capitulo diferente al tema anterior pero todo dentro de la unidad 8
Las máquinas clientes son PC monousuario o puestos de trabajo que ofrecen una interfaz muy
amigable para el usuario final. Cada servidor ofrece una serie de servicios de usuarios compartidos
a los clientes. El tipo más común de servidor es el servidor de bases de datos.
Además de los clientes y los servidores, el tercer ingrediente básico es la red. Los usuarios,
aplicaciones y recursos se hallan distribuidos y quedan enlazados por una sola LAN o WAN.
LAN (Redes de área local): son redes de hasta unos cuantos kilómetros de extensión. Se
usan para conectar computadoras personales o estaciones de trabajo, con el objeto de
compartir recursos e intercambiar información.
WAN (Redes de área amplia): Son redes que se extienden sobre un área geográfica
extensa.
Existen una serie de características que llaman la atención en el entorno cliente/servidor:
Hay una gran confianza en depositar aplicaciones amigables para los usuarios en sus
propios sistemas
Alivia a los departamentos individuales y divisiones de gran porte de la carga de mantener
servicios de computación sofisticados, permitiéndoles elegir cualquier tipo de máquina e
interfaz que necesiten para acceder a los datos y a la información.
Los usuarios disponen de mejores ofertas de equipos en la elección de productos y en la
combinación de equipos de varios fabricantes.
La gestión y seguridad de la red tienen una prioridad alta en la organización y operaciones
de los sistemas de información.
Aplicaciones cliente/servidor
Universidad Tecnológica Nacional Facultad Regional Villa María
142
BALOG MARTIN AÑO 2010
En tanto que un cliente particular y un servidor compartan los mismos protocolos de
comunicación y soporten las mismas aplicaciones, las diferencias de niveles inferiores no son
relevantes. La figura 8.6 ilustra el caso más general.
Figura 8.6 Arquitectura genérica cliente/servidor
Un factor importante para el éxito de esta arquitectura es la manera en que el usuario interactúa
con el sistema como un todo, por eso el diseño de la interfaz de usuario de la máquina es vital.
Aplicaciones de bases de datos
Aquí el servidor de bases de datos, y la interacción entre el cliente y éste se hace mediante
transacciones. El servidor necesita complejos sistemas gestores de BD para mantenerla.
Cliente/servidor bien empleado existe una labor masiva de ordenación y búsqueda en la BD, un
disco grande o varios discos, una CPU y una arquitectura de E/S de alta velocidad. En caso
contrario se puede mover parte de la lógica de la aplicación al servidor para realizar análisis de
datos, así como recuperación y búsqueda de los mismos.
Clases de aplicaciones cliente/servidor
Proceso basado en una máquina central: no es realmente un proceso cliente/servidor, se
refiere más bien al entorno tradicional de mainframe.
Proceso basado en el servidor: el servidor es básicamente responsable de ofrecer una
interfaz de usuario gráfica, mientras casi todo el tratamiento se hace en el servidor.
Proceso basado en el cliente: casi todo el proceso de la aplicación puede hacerse en el
cliente. Permite al usuario utilizar aplicaciones a la medida de sus necesidades locales.
Proceso cooperativo: el proceso de la aplicación se lleva acabo de forma optimizada,
aprovechando la potencia de las maquinas cliente servidor y la distribución de los datos.
Arquitectura cliente/servidor de tres capas
El software de la aplicación está distribuido entre diferentes tipos de máquinas: una máquina de
usuario o cliente, un servidor de capa intermedia y un servidor final. El servidor intermedio es
paralelo entre el cliente delgado y una variedad de servidores finales de base de datos, pueden
Universidad Tecnológica Nacional Facultad Regional Villa María
143
BALOG MARTIN AÑO 2010
convertir protocolos y traducir un tipo de consulta de base de datos a otro, además puede mezclar
e integrar resultados de distintas fuentes de datos y servir como pasarela entre aplicaciones de
computador de escritorio y antiguas aplicaciones finales.
Consistencia de las cachés de archivos
El rendimiento de la E/S referente a los accesos locales o archivos puede degradarse por causa del
retardo introducido por la red, por eso pueden usarse cachés de archivos para almacenar los
registros a los que se ha accedido hace poco.
El problema de mantener actualizadas las cachés locales se conoce como problema de
consistencia da cachés. Una solución sería emplear técnicas de bloqueo de archivos para prevenir
el acceso simultáneo a un archivo por más de un cliente. Otra alternativa es notificar al escritor
que debe reescribir los bloques alterados de inmediato y a los procesos lectores, que tengan
abierto el archivo, que sus copias no son válidas.
Middleware
Interfaz estándar de programación y protección que se sitúa entre la aplicación y el software de
comunicaciones y el sistema operativo, para lograr que las aplicaciones no sólo parezcan las
mismas en PC y puestos de trabajo, sino que también utilicen el mismo método de acceso a los
datos sin importar la ubicación de los mismos.
La finalidad básica del middleware es hacer que una aplicación o usuario del cliente acceda a una
serie de servicios del servidor sin preocuparse de las diferencias entre servidores. Para lograrlo se
basan en el paso de mensajes a las llamadas o procedimientos remoto.
Universidad Tecnológica Nacional Facultad Regional Villa María
144
BALOG MARTIN AÑO 2010
9 Unix / Linux
9.1 Unix
Es un sistema interactivo de tiempo compartido que fue diseñado por programadores, para
programadores, con los objetivos de ser sencillo, elegante, consistente, flexible y con gran
potencia. Uno de los criterios guía de Unix es que todo programa debe realizar sólo una cosa y
hacerla bien.
Unix puede considerarse como un tipo de pirámide:
Figura 9.1 Las capas de un sistema Unix
9.1.1 Historia
En la década de los sesentas Bell Laboratories y General Electric iniciaron el diseño del sistema
MULTICS (Multiplexed Information and Computing Service, Servicio de información y computo con
multiplexación) el cual fracaso. Bell Labs abandonó el proyecto y uno de sus investigadores. Ken
Thompson decidió escribir un nuevo MULTICS en una mini computadora PDP-7 que denominaron
UNICS (Sistema de información y cómputo con uniplexión), el cual más adelante cambiaron a
UNIX.
Luego trasladaron UNIX a otras computadoras más modernas PDP-11/20, PDP-11/45 y PDP-11/70,
en la década de los ’70. Pero ese traslado implicaba volver a escribir el código de todo el sistema
por eso Thompson decidió volver a escribirlo en un lenguaje de alto nivel, llamado C, junto con
Ritchie.
Una vez que se implantó un compilador portable de C para poder trasladar Unix a cualquier
máquina, AT&T lanzó su primer producto comercial Unix, el sistema III que fue reemplazado casi
inmediatamente con el sistema V. En la universidad de California en Berkeley, se pudo modificar el
sistema, ya que se contaba con el código fuente, de manera que utilizaba memoria virtual y
paginación, los nombres eran mayores de 14 caracteres, se introdujo el uso de redes y se
añadieron más programas.
Universidad Tecnológica Nacional Facultad Regional Villa María
145
BALOG MARTIN AÑO 2010
9.1.2 Gestión de procesos – Procesos en Unix
Unix es un sistema de multiprogramación, por lo tanto se pueden ejecutar varios procesos
independientes al mismo tiempo Los procesos que se ejecutan en segundo plano o asíncrona se
denominan demonios. Un demonio típico es el cron, quien despierta cada un minuto y verifica si
hay trabajo para él, si existe hace el trabajo, después se duerme hasta que es tiempo de la
próxima verificación.
Como en Unix se puede planificar actividades con anticipación al llegar el día y la hora de la cita el
demonio cron inicializa el programa de sonido como un nuevo proceso. Los demonios son proceso
independientes, y los procesos en Unix se crean mediante la llamada al sistema Fork, la cual crea
una copia exacta del proceso original (padre) al hijo. Fork regresa un ID hijo y un valor distinto de
cero (pid, identificador de proceso) al padre.
Los procesos se pueden comunicar entre sí mediante transferencia de mensajes, creando un canal
llamado tubo, o bien mediante interrupciones de software cuando un proceso envía una señal.
Cada proceso tiene un espacio de direcciones con segmentos:
Texto: contiene las instrucciones de máquina que conforman el código ejecutable del
programa.
Datos: es un espacio para almacenar las variables, cadenas, arreglos y otros datos del
programa.
Pila: comienza en la parte superior del espacio de direcciones virtuales y crece hacia abajo
en dirección de 0.
9.1.3 Sistema de archivos
Un archivo se abre mediante la llamada al sistema OPEN, el sistema verifica que exista e
inspecciona los bits de derechos. Si se permite el acceso el sistema regresa un entero positivo
pequeño llamado descriptor de archivo. Al iniciar un proceso siempre se cuenta con descriptores:
Para la entrada estándar 0,
Para la salida estándar 1,
Para el error estándar 2.
Si dos usuarios comparten un archivo se les permite que hagan una nueva entrada en el directorio
que apunte a dicho archivo esta entrada se llama enlace.
Unix maneja un mecanismo de cerradura que requiere que quien haga la llamada determine el
archivo por cerrar, el byte de inicio, el número de bytes y el tipo de cerradura: compartida o
exclusiva.
9.1.4 Gestión de E/S – Entrada/Salida en Unix
Unix integra al sistema de archivos lo que se conoce como archivos especiales. Los archivos
especiales se dividen en categorías:
de bloque: consta de una serie de bloques numerados que se pueden direccionar y
acceder de manera individual, estos son utilizados en los discos.
Universidad Tecnológica Nacional Facultad Regional Villa María
146
BALOG MARTIN AÑO 2010
de carácter: Se utilizan para los dispositivos de entrada o salida de un flujo de caracteres,
son utilizados n terminales, impresoras, redes, ratones, etc.
Las redes constituyen un ejemplo de E/S. el diseño de Berkeley incluye los enchufes (socket) que
son análogos a los buzones y los teléfonos, pueden crearse y destruirse de manera dinámica y
cada uno soporta un tipo particular de red:
Orientado a la conexión por flujo confiable de bytes: dos procesos en distintas máquinas
establecen de manera efectiva el equivalente de un tubo entre ellos.
Orientado a conexiones por flujo confiable de paquetes: se preserva las fronteras de los
paquetes
Transmisión no confiable de paquetes: El usuario tiene acceso directo a la red.
Sólo se necesitan crear los enchufes en la computadora fuente y destino para establecer la
conexión.
9.2 Linux
9.2.1 Historia
En 1991 un estudiante finlandés, Linus Torvalds, escribió y bautizo un pequeño pero autosuficiente
núcleo para el procesador 80386.
Una distribución Linux incluye todos los componentes estándar del sistema, más un conjunto de
herramientas administrativas que simplifican la instalación inicial y la modernización, además
sirven para controlar la instalación y la desinstalación de otros paquetes del sistema.
En 1994 se desarrollo un núcleo Linux que incluía soporte para protocolos de redes TCP/IP,
interfaz de sockets y además para drivers de dispositivos para ejecutar internet.
En 1995 y 1996 se amplió el soporte de hardware, arquitectura de bus PCI, adición de soporte de
múltiples arquitecturas multiprocesador.
9.2.2 Principios de diseño
Linux es un sistema multiusuario, multitarea, con un conjunto completo de herramientas
compatibles con Unix. El sistema de archivos de Linux se ajusta a la semántica tradicional de Unix,
y el modelo estándar de trabajo con redes de Unix se implementa plenamente.
Adamas de la velocidad y la eficiencia, el diseño de un sistema se concentra en la estandarización.
Los estándares POSIX son un conjunto de especificaciones de diferentes aspectos del
comportamiento de un sistema operativo.
El sistema Linux se compone de cuerpos principales de códigos:
Núcleo: Se encarga de mantener todas las abstracciones importantes del sistema
operativo, incluidas cosas tales como memoria virtual y procesos.
Bibliotecas del sistema: definen un conjunto estándar de funciones a través de las cuales
las aplicaciones pueden interactuar con el núcleo.
Utilitarios del sistema: Son programas que realizan tareas de administración especializadas
individuales.
Universidad Tecnológica Nacional Facultad Regional Villa María
147
BALOG MARTIN AÑO 2010
El núcleo se ejecuta en modo privilegiado, puede cargar y descargar módulos dinámicamente,
además proporciona toda la funcionalidad necesaria para ejecutar procesos.
Las bibliotecas permiten a las aplicaciones hacer solicitudes de servicios al núcleo, y además se
encargan de reunir los argumentos para la llamada al sistema y organizarlos en la forma especial
necesaria para efectuar la llamada.
En modo usuario se incluyen los utilitarios del sistema que son los programas necesarios para
iniciar el sistema y los utilitarios de usuarios.
Los módulos de núcleo se ejecutan en modo privilegiado y cuando se prueba un nuevo driver se
puede compilar de forma independiente. El soporte de módulos tiene componentes:
Gestión de módulos: permite cargar módulos en la memoria y comunicarse con el resto del
sistema.
Registro de controladores: permite a los módulos notificar al resto del núcleo que está
disponible un nuevo controlador.
Resolución de conflictos: este mecanismo permite a diferentes drivers reservar recursos de
hardware y proteger dichos recursos.
Cuando un modulo se carga un utilitario del sistema examina primero el modulo en busca de
referencias no resueltas y todos los símbolos que faltan por resolver se buscan en la tabla de
símbolos del núcleo y se sustituyen en el código.
El núcleo mantiene tablas dinámicas de todos los controladores conocidos que incluyen: drivers de
dispositivos, sistemas de archivos, protocolos de red, formato binario.
9.2.3 Arquitectura
No lo encontré en todo el rejunte, ni siquiera en el libro Fundamentos de sistemas operativos
Séptima edición.
9.2.4 Gestión de procesos
Se crea un proceso nuevo con la llamada al sistema Fork (bifurcar), y un programa nuevo se
ejecuta después de una llamada a execve.
Las propiedades de los procesos se clasifican en grupos:
Identidad del proceso: comprende los siguientes elementos:
Identificador de proceso (PID): cada proceso tiene un identificador único, sirven
para especificar procesos al sistema operativo cuando una aplicación emite una
llamada al sistema para enviar una señal a, modificar o esperar otro proceso.
Credenciales: cada proceso debe tener asociado un identificador de usuario y uno
o más identificadores de grupo, que determinan los derechos de acceso a los
recursos y archivos del sistema que el proceso tiene.
Personalidad: Cada proceso tiene asociado un identificador de personalidad que
puede modificar un poco la semántica de ciertas llamadas al sistema.
Es posible modificar las credenciales del proceso en cambio el PID primario es inmutable e
identifica de forma única al proceso hasta que éste termine.
Universidad Tecnológica Nacional Facultad Regional Villa María
148
BALOG MARTIN AÑO 2010
Entorno de proceso: consiste en vectores:
De argumentos: que es una lista de argumentos de línea de órdenes que se usan
para invocar el programa que se está ejecutando;
De entorno: que es una lista de pares “nombre=valor” que asocian variables de
entorno con nombre a valores de texto arbitrarios.
Contexto de un proceso: es el estado del programa en ejecución en cualquier instante
dado y cambia constantemente.
Contexto de planificación: la información que el planificador necesita para
suspender y reiniciar el proceso. Una parte clave es la pila.
Contabilidad: el núcleo mantienen información acerca de los recursos que cada
proceso está consumiendo.
Tabla de archivos: es un arreglo de punteros a estructuras de archivos del núcleo.
Contexto del sistema de archivos: aplica a las solicitudes de abrir nuevos archivos.
Tabla de manejadores de señales: define la rutina que se invocará cuando lleguen
señales especificas.
Contexto de memoria virtual: describe el contenido del espacio de direcciones
privado de dicho proceso.
Procesos e hilos
Un proceso representa la ejecución de programas individuales, mientras que los hilos representan
contextos de ejecución individuales pero concurrentes dentro de un solo proceso que se ejecuta
un solo programa.
Dos procesos individuales tienen su propio espacio de direcciones independientes y dos hilos
dentro del mismo proceso comparten el mismo espacio de direcciones.
La llamada al sistema clone acepta un argumento que le dice cuáles subcontextos debe copiar y
cuáles debe compartir al crear el proceso nuevo (hilo).
Para planificar los procesos Linux tiene algoritmos: (está en un tema no incluido en el programa)
Para procesos de tiempo compartido: con prioridades basadas en créditos, cada vez que
ocurre una interrupción el proceso pierde un crédito y cuando llega a cero se escoge otro
proceso,
Para procesos de tiempo real: utilizando FIFO y turno circular.
9.2.5 Sistema de archivos
Los archivos de Unix pueden ser cualquier cosa capaz de manejar la entrada o la salida de un flujo
de datos. Los drivers de dispositivos pueden aparecer como archivos, y el usuario también ve
como archivos los canales de comunicación entre procesos o las conexiones de red.
El núcleo de Linux maneja todos estos diferentes tipos de archivos ocultando los detalles de
implementación de cualquier tipo de archivo individual detrás de una capa de software, el sistema
de archivos virtual (VFS, virtual file system).
Virtual
Universidad Tecnológica Nacional Facultad Regional Villa María
149
BALOG MARTIN AÑO 2010
Tiene los siguientes componentes:
Un conjunto de definiciones que definen el aspecto que puede tener un objeto archivo
Una capa de software para manipular dichos objetos. Los tipos principales de objetos son:
Objeto i-nodo
Objeto archivo: que representan archivos individuales,
Objeto sistema de archivos: que representa todo un sistema de archivos.
Existe una tabla de funciones, la cual lista las direcciones de las funciones reales que implementan
esas operaciones para un objeto específico.
Los objetos i-nodo y archivo son los mecanismos empleados para acceder a archivos. El i-nodo
representa el archivo como un todo y el archivo representa un punto de acceso a los datos del
archivo. El objeto archivo indica en qué lugar del archivo el proceso está leyendo o escribiendo
actualmente, además recuerda si éste pidió permisos de escritura cuando abrió el archivo.
Linux ext2fs
El segundo sistema de archivos extendido, ext2fs, almacena en disco los archivos de directorios,
igual que los normales, aunque su contenido se interpreta diferente. No usa fragmentos, sino que
realiza todas sus asignaciones en unidades más pequeñas llamadas bloques. El sistema está
dividido en varios grupos de bloques, para el caso de bloques de datos se intenta escoger el mismo
grupo en el que se asignó el i-nodo del archivo, y en el caso de asignaciones de i-nodos se
selecciona el mismo grupo en el que está el directorio padre del archivo.
Se mantiene un mapa de bits con los bloques libres y cuando se encuentra el siguiente bloque por
asignar, el sistema preasigna bloques extra al archivo para reducir la fragmentación y el costo de
CPU, de la asignación de disco.
Proc de Linux
El sistema de archivos de procesos de Linux, conocido como sistema de archivos proc, no almacena
su contenido realmente en ninguna parte, sino que se calcula bajo demanda según las solicitudes
de E/S de archivo de los usuarios.
Implementa una estructura de directorios y el contenido de los archivos, y debe definir un número
de i-nodo único y persistente para cada directorio y los archivos asociados.
Se divide un i-nodo en dos campos para transformarlo a tipo de información, los 16 bits superiores
se toman como PID y el resto como información que se está solicitando acerca del proceso.
9.2.6 Gestión de E/S – Entrada y Salida
El sistema de E/S de Linux es muy parecido al de Unix, los drivers de los dispositivos aparecen
como archivos normales. Se dividen en clases:
Dispositivos por bloques: incluyen todos los que permiten acceso aleatorio a bloques de
datos de tamaño fijo totalmente independientes. Incluidos los discos duros, discos
flexibles y CD-ROM. Utilizan buffers para contener la información de los drivers y se
organiza una lista de solicitudes para cada controlador de dispositivos.
Universidad Tecnológica Nacional Facultad Regional Villa María
150
BALOG MARTIN AÑO 2010
Dispositivos por caracteres: son casi todos los demás, que no necesitan apoyar toda la
funcionalidad de los archivos normales. Se deben registrar, junto con el driver, el conjunto
de funciones que implementan las distintas operaciones de E/S a menos que se utilice un
dispositivo de terminal, el cual usa una disciplina de línea como intérprete de la
información.
Dispositivos de red: los usuarios no pueden transferir datos directamente a los dispositivos
de red, sino que deben comunicarse indirectamente abriendo una conexión al subsistema
de red del núcleo.
9.2.7 Seguridad
Los problemas de seguridad se pueden clasificar en grupos:
Validación: Asegurarse de que nadie pueda tener acceso al sistema sin antes demostrar
que tiene derecho de entrar.
La contraseña de usuario se combina con un valor de “sal” aleatorio y el resultado se
codifica con una función de transformación unidireccional y se almacena en el archivo de
contraseñas. Se ha introducido el cifrado de las contraseñas que se guardan en un archivo
secreto que el público no puede leer, además de otros métodos de validación que
incorporan la hora de conexión.
Control de acceso: Proporcionar un mecanismo para verificar si un usuario tiene derecho
de acceder a un objeto dado, y evitar el acceso a objetos si es necesario.
Se utilizan identificadores de usuario (UID) e identificadores de grupo (GID) que son
numéricos únicos. Los procesos de usuarios pueden tener muchos (GID). Si el UID del
proceso coincide con el de un objeto, éste tiene derechos de usuario, lo mismo pasa con el
GID, sólo que el derecho es de grupo, sino tiene derechos de mundo. La única excepción es
el UID privilegiado root. Un proceso con este UID especial tiene acceso automático a
cualquier objeto del sistema, pasando por alto las verificaciones de acceso normales.
Linux efectúa el control de acceso asignado a los objetos una máscara de protección que
especifica cuáles modos de acceso (lectura, escritura o ejecución) se otorgaran a los
procesos en sus distintos roles (usuario o propietario, grupo o mundo).
Universidad Tecnológica Nacional Facultad Regional Villa María
151
BALOG MARTIN AÑO 2010
10 Windows
10.1 Windows 95
10.1.1 Arquitectura
Figura 10.1 Hardware
Registro
Sirve como repositorio central para la información específica del hardware y que se puedan
detectar el hardware y los componentes Conectar y Listo del sistema. Permite una sola localización
de la información de la configuración de la computadora.
Controladores de dispositivos
Un controlador universal incluye la mayoría del código necesario para que dispositivos de una
clase particular se comuniquen con los componentes adecuados del sistema operativo. Un
controlador de dispositivo virtual administra un recurso del sistema por el que más de una
aplicación pueda usar ese recurso al mismo tiempo. Mantiene el estado del dispositivo para cada
aplicación y asegura que el dispositivo esté en su estado cuando la aplicación se retoma.
Administrador de configuración
Dirige el proceso de configuración, trabaja con un número de subcomponentes que identifican
cada bus y cada dispositivo del sistema, y la configuración de cada uno. También ayuda a visualizar
los cambios en el número y tipo de los dispositivos. Llama al enumerador de buses, que son
nuevos controladores que se responsabilizan de la creación del árbol del hardware
(representación jerárquica de todos los buses y dispositivos de la computadora), para que
identifique todos los dispositivos en sus buses específicos y con sus respectivos requisitos de
Universidad Tecnológica Nacional Facultad Regional Villa María
152
BALOG MARTIN AÑO 2010
recursos. El enumerador de bus localiza y reúne la información de los controladores de
dispositivos que se cargan para cada dispositivo y el administrador de configuración llama a los
árbitros de recursos para asignar recursos a cada uno de ellos.
Administrador de máquina Virtual
Proporciona a cada aplicación y proceso que se ejecuta, los recursos que necesita, crea y mantiene
los entornos de maquina virtual y además es responsable de áreas claves de servicios:
Planificación de procesos: el planificador de procesos es el componente responsable de
proporcionar recursos del sistema a las aplicaciones y demás procesos que se ejecuten, y
de planificar los procesos que permiten que se puedan ejecutar muchas aplicaciones
concurrentemente.
Cada proceso consiste en al menos una hebra, que es una unidad de código que puede
ejecutarse concurrentemente con otras. Windows 95 lleva a cabo el sistema de multitarea
con derecho preferente para las aplicaciones Win32, quienes pueden sacar partido de
multitareas, es decir, que quita o cede el control a una tarea que se está ejecutando según
las necesidades del sistema.
Planificación de la memoria: Cada proceso se asigna a un espacio de direcciones virtuales y
único de 4 GB, los 2 GB superiores son compartidos y los 2 GB inferiores son privados de la
aplicación, este espacio se divide en bloques iguales llamados páginas. La paginación por
petición se refiere al método por el que la información se devuelve a la memoria a medida
que es necesitada por el proceso. Se mapean direcciones virtuales de la memoria y esto
asegura que la hebra pueda acceder a la memoria de su proceso si lo necesitaba, pero no
a la de otros procesos.
Modo MS-DOS: El administrador de memoria virtual crea un entorno operativo exclusive
para la aplicación llamado Modo MS-DOS, donde ningún otro proceso o aplicación puede
competir por los recursos del sistema.
Sistema de archivos instalables
La arquitectura del sistema de archivos está compuesta de los siguientes componentes:
Administrador de sistemas de archivos instalables: (IFS Installable File System). Es
responsable de arbitrar el acceso a los diferentes componentes del sistema de archivos. En
Windows 95 los reexpedidores de red se implementan como sistemas de archivos bajo
este Administrador, por lo que se pueden utilizar un número ilimitado de reexpedidores
de 32 Bits.
Controladores del sistema de archivos: Incluye acceso a dispositivos de discos FAT,
sistemas de archivos CD-ROM y dispositivos reexpedidores de red.
Sistema de archivos VFAT: El controlador VFAT 32 proporciona manipulación del
sistema de archivos almacenado en disco, interactúa con el subsistema bloque de
E/S para proporcionar acceso al disco y mapea cualquier controlador de disco en
modo real. Tabla de asignación de archivos (FAT).
Sistema de archivos CD-ROM: La caché del controlador del sistema de archivos
CD-ROM es dinámica y tiene las siguientes ventajas:
Universidad Tecnológica Nacional Facultad Regional Villa María
153
BALOG MARTIN AÑO 2010
No emplea memoria convencional,
Mejora el rendimiento del controlador MSCDEX y la caché en modo real,
Mejora la multitarea cuando se accede a la información CD-ROM,
Permite caché dinámica.
Parte central del sistema
Está compuesto por:
Usuario: Administra la entrada desde teclado, ratón y otros dispositivos de entrada y
administra la salida hacia la interfaz de usuario. Así como también el controlador de
sonido, el temporizador y los puertos de comunicaciones.
Núcleo: Proporciona las funciones base del sistema operativo incluyendo servicios de E/S
sobre archivos, administración de la memoria virtual y planificación de tareas. Gestiona las
excepciones, que son eventos que suceden cuando un programa se ejecuta y pide
software fuera del flujo normal del control de ejecución.
Interfaz de dispositivo gráfico (GDI): Administra lo que aparece en pantalla y da soporte
gráfico para las impresoras y otros dispositivos de salida.
Interfaz de usuario
La interfaz de órdenes contiene varias herramientas de escritorio, incluyendo entorno de red,
indicadores de progreso, barra de herramientas, cuadros de diálogos comunes, vistas de arboles y
de listas, etc.
Aplicaciones permitidas
Las aplicaciones Win32, que se ejecutan en un espacio separado de direcciones y las aplicaciones
Win16, que se ejecutan juntas en un espacio común de direcciones. También se permiten las
aplicaciones MS-DOS que se ejecuten sobre su propia Maquina Virtual.
10.1.2 Registro
El registro proporciona una base de datos unificada en forma jerárquica para almacenar los datos
de configuración de las aplicaciones y del sistema. Las claves del registro pueden contener
subclaves y son similares a una cabecera entre corchetes de un archivo INI, estos se admiten
solamente para la compatibilidad con aquellas aplicaciones y herramientas relacionadas.
El registro proporciona los siguientes beneficios a Windows 95:
Una sola fuente es la que proporciona datos.
Los usuarios y administradores pueden configurar las opciones de la computadora
mediante herramientas estándar del panel de control y otras herramientas
administrativas.
Pueden usarse un conjunto de funciones independientes de la red.
El sistema operativo automáticamente hace copias de seguridad de la última configuración
correcta utilizada al iniciar la computadora.
Editor del registro
Universidad Tecnológica Nacional Facultad Regional Villa María
154
BALOG MARTIN AÑO 2010
No aparece en ningún menú o en el escritorio, se copia automáticamente en el directorio cuando
Windows 95 se instala desde disco compacto. El editor de Registro no está disponible con los
disquetes de Windows 95.
Puede ser usado para ver o modificar el registro en una computadora local o en el de una
computadora de la red.
Estructura del registro
Cuando se instala Windows 95 en el mismo directorio de versiones anteriores, las configuraciones
previas se mueven desde archivos INI al Registro y se cambia la configuración del escritorio.
Cada vez que se añaden o se quitan dispositivos Conectar y Listo, los datos de configuración se
añaden al registro.
Los controladores de dispositivos envían y reciben parámetros de carga y datos de configuración
del Registro.
La estructura del Registro representa la información específica de la base de datos de la
computadora y de los usuarios individuales. La computadora incluye configuración del hardware y
software instalados y del usuario incluye configuraciones de los perfiles de usuario, escritorio,
preferencias sobre algún software y configuraciones personales de impresora y de red.
Está compuesta por ramas:
Hkey_Local_Machine: Esta clave contiene información específica de la computadora sobre
el tipo de hardware instalado, configuración del software y demás.
Hkey_Current_Config: Esta clave contiene información sobre la configuración actual del
hardware.
Hkey_Dyn_Data: Esta clave contiene información dinámica del estado de varios
dispositivos, y puede cambiar a medida que éstos se añaden o se quitan de la
computadora.
Hkey_Classes_Root: Esta clave describe configuraciones de software.
Hkey_Users: Esta clave contiene información sobre todos los usuarios que acceden al
sistema, además de una clave para cada uno.
Hkey_Current_User: Esta clave apunta a la rama anterior para el usuario que está
actualmente conectado.
Un valor de entrada tiene partes:
El tipo de dato del valor (que aparece como icono),
El nombre del valor,
El valor en si mismo.
Información del Registro
El registro consiste en archivos:
USER.DAT: Guarda la información específica del usuario.
SYSTEM.DAT Contiene las configuraciones especificas de la computadora y del hardware.
Universidad Tecnológica Nacional Facultad Regional Villa María
155
BALOG MARTIN AÑO 2010
Estos archivos pueden estar físicamente en sitios diferentes. Los datos se escriben en el Registro
sólo cuando sucede algo desde que han transcurrido unos segundos después de cambiar datos.
Cada vez que se inicia Windows 95 con éxito, el sistema operativo hace copias de seguridad del
Registro copiando los archivos anteriormente citados solo con extensión .DA0. el Registro puede
ser exportado, importado o recreado mediante el editor. Con la exportación se puede salvar una
rama y con la importación se puede restaurar un archivo. Aunque el registro reemplaza la función
básica de los archivos de inicialización empleados por versiones anteriores, éstos todavía aparecen
en el directorio y se utilizan para compatibilidad con aplicaciones y controladores de esas
versiones.
10.2 Windows NT
10.2.1 Historia
En 1988, Microsoft decidió desarrollar un sistema operativo portátil de nueva tecnología (NT) que
apoyara las interfaces de programación de aplicaciones (API, Application Programming Interfaces).
Dave Cutter fue contratado con la encomienda de construir este nuevo sistema operativo.
10.2.2 Principios de diseño
Los objetivos de diseño que Microsoft ha expresado para NT incluyen:
Extensibilidad: NT se implementó con una arquitectura de capas, el ejecutivo proporciona
los servicios básicos del sistema, encima de él hay varios subsistemas servidores y entre
éstos están los subsistemas de entorno o ambiente.
Transportabilidad: Un sistema operativo es portátil si se le puede trasladar de una
arquitectura de hardware a otra con relativamente pocos cambios. Todo el código de NT
que depende del procesador se ha aislado en una biblioteca de enlazado dinámico (DLL,
Dynamic Link Library).
Confiabilidad: Es la capacidad para manejar condiciones de error, incluida la capacidad del
sistema operativo para protegerse a sí mismo y a sus usuarios contra software defectuoso
o mal intencionado, empleando protección por hardware para la memoria virtual y
mecanismos de protección por software para los recursos del sistema operativo.
Compatibilidad: NT la ofrece en el nivel de fuente con aplicaciones que siguen el estándar
IEEE, además puede ejecutar los binarios de muchos programas compilados.
Desempeño: Los subsistemas se pueden comunicar entre sí de forma eficiente empleando
un recurso de llamadas a procedimientos locales que transfiere mensajes con gran
rapidez.
Soporte internacional: NT cuenta con soporte para diferentes ubicaciones a través de la
API de soporte a idiomas internacionales (NLS, National Language Support).
10.2.3 Componentes del sistema
La arquitectura NT es un sistema de módulos en capas que se dividen a su vez en modo protegido
y modo usuario.
En el modo protegido están:
Universidad Tecnológica Nacional Facultad Regional Villa María
156
BALOG MARTIN AÑO 2010
Capa de abstracción de hardware: (HAL, Hardware Abstraction Layer). Es una capa de
software que oculta las diferencias de hardware para que no las perciban los niveles
superiores del sistema operativo y exporta una interfaz de máquina virtual. Las ventajas
son que sólo se necesita una versión de cada drivers y que apoya el multiprocesamiento
simétrico.
Núcleo: El núcleo nunca se pagina a disco y su ejecución nunca se desaloja. Tiene
obligaciones principales:
Planificación de hilos,
Manejo de interrupciones y excepciones,
Sincronización de bajo nivel del procesador,
Recuperación después de una interrupción del suministro de electricidad.
El núcleo está orientado a los siguientes conjuntos de objetos:
Despachador (Dispatcher): que controlan el despacho y la sincronización en el
sistema, sucesos, mutante, mutex, semáforos hilos y temporizadores.
De control: Que incluyen llamadas a procedimientos asincrónicas, interrupciones,
notificación potencia, situación de potencia, procesos y perfiles.
El despachador usa un esquema de prioridades de 32 niveles, para determinar el orden de
ejecución de los hilos, que se divide en clases:
La clase de tiempo real: que contiene hilos cuya prioridad va desde 16 a 31,
La clase variable: que contiene hilos cuya prioridad va desde 0 a 15.
Se recorre el conjunto de colas (Una por cada nivel) de la más alta a la más baja hasta
encontrar un hilo listo para ejecutarse, de no encontrar ninguno se ejecuta el hilo ocioso.
Cuando se agota el cuanto de tiempo de un hilo su prioridad se reduce y cuando se libera
su prioridad aumenta, la magnitud del cambio depende de qué estaba haciendo el hilo.
El núcleo también maneja las trampas para excepciones e interrupciones generadas por
hardware o software. El manejador de trampas puede encargarse de las excepciones
sencillas y el despachador de excepciones maneja las demás invocando una rutina de
servicio o una rutina interna del núcleo. Para ello NT mantiene una tabla de despacho de
interrupciones individual para cada procesador.
NT ejecuta multiprocesamiento simétrico y para evitar que dos hilos modifiquen una
estructura de datos compartida al mismo tiempo, emplea cerraduras giratorias.
Ejecutivo: Presta un conjunto de servicios que pertenecen a los siguientes grupos:
Gestor de objetos: Su tarea es supervisar el uso de todos los objetos. Cuando un
hilo desea usar un objeto, invoca el método open a fin de obtener un mango
(handle) para ese objeto. Los mangos son una interfaz estandarizada que
permiten acceder y manipular un recurso del sistema. Cada cabecera de objeto
contiene una cuenta del numero de procesos que tienen mangos para es objeto.
Cuando el contador llega a cero se elimina del espacio de nombres si es temporal,
es decir, que sólo existe mientras algún proceso tiene un mango para ese objeto,
también puede ser permanente representando una entidad.
Universidad Tecnológica Nacional Facultad Regional Villa María
157
BALOG MARTIN AÑO 2010
Además el gestor de objetos mantiene una cuenta de referencias, ya que a veces
NT usa punteros en vez de mangos. Un proceso recibe un mango de objeto
creando un objeto, abriendo uno ya existente, recibiendo un mango duplicado de
otro objeto o heredando un mango de un padre.
Gestor de memoria virtual (VM): Utiliza un esquema de gestión basado en páginas
con un tamaño de página de 4 KB. Cada proceso tiene un espacio de direcciones
virtual de 4 GB, donde los 2 GB superiores son idénticos para todos y los 2 GB
inferiores son distintos para cada proceso. Hay un proceso con los siguientes
pasos para asignar memoria:
El primer paso reserva una porción del espacio de direcciones del
proceso,
El último paso confirma la asignación dedicando espacio en el archivo, de
paginación.
NT permite limitar la cantidad de espacio para un proceso y que esté desconfirme
memoria que ya no está usando.
NT ofrece una alternativa llamada objeto sección de memoria, que representa un
bloque de memoria compartida. Esta sección puede estar basada, lo que significa
que aparece en la misma dirección virtual para todos los procesos que acceden a
ella. Además se puede limitar el tamaño máximo de una sección y puede
respaldarse con espacio de disco.
Cada proceso tiene un directorio de páginas y cada entrada apunta a una tabla de
páginas, cuya entrada a su vez apunta a un marco de página en la memoria física.
Una página puede estar en uno de los siguientes estados:
Valida: Esta siendo usada por un proceso activo,
Libre: No se hace referencia,
En ceros: Pagina libre que se ha llenado de ceros,
A punto: Ha sido eliminada del conjunto de trabajo de un proceso,
Modificada: Se ha escrito en ella, pero todavía no se ha copiado en el
disco,
Defectuosa: No puede utilizarse porque se detecto un error de hardware.
El gestor de (VM) sigue la pista a todas las páginas de memoria física en una base
de datos de marcas de páginas y cuando no hay marcos disponibles en la lista de
los libres se usa una política de reemplazo FIFO.
Gestor de procesos: Presta servicios para crear, eliminar y usar hilos y procesos,
no tiene conocimiento de las relaciones padre-hijo ni de jerarquías de procesos.
Recurso de llamadas a procedimientos locales (LPC, Local Procedure Call): Sirve
para transferir solicitudes y resultados entre procesos clientes y servidores dentro
de una sola máquina. El proceso servidor pública un objeto puerto de conexión
que es visible globalmente, crea un canal y devuelve un mango al cliente. De aquí
en más se necesita especificar una de los diferentes tipos de técnicas de
transferencia de mensajes:
Universidad Tecnológica Nacional Facultad Regional Villa María
158
BALOG MARTIN AÑO 2010
Apropiado para mensajes pequeños: usa una cola y los mensajes se
copian de un proceso al otro.
Para mensajes más grandes: se utiliza el objeto sección y los mensajes
que se envían contienen puntero e información de tamaño que se
refieren a la sección.
Para transferencias rápida: Se usa por las porciones de exhibición grafica
del subsistema Win32 para el gestor de ventanas y las interfaces con
dispositivos gráficos. Se preparan los siguientes objetos:
Un hilo servidor,
Un objeto sección,
Objeto par de sucesos.
Gestor de E/S: Se encarga de los sistemas de archivos, gestión de cachés, drivers
de dispositivos y controladores de red, además mantiene al tanto de cuales
sistemas de archivos instalables están cargados y gestiona buffers para solicitudes
de E/S.
Convierte las solicitudes que recibe a una forma estándar llamada paquete de
solicitud de E/S, y luego remite el paquete al controlador correcto para que lo
procese, una vez finalizada la operación lo recibe de vuelta del controlador y
termina de atender la solicitud.
Cuando el gestor de E/S recibe una solicitud de lectura de nivel de usuario envía
un paquete al gestor de cachés, quien intenta copiar los datos del archivo con el
que se estableció la correspondencia al buffer del invocador, si lo logra la
operación habrá finalizado.
Una operación de lectura de nivel de núcleo es similar, excepto que se puede
acceder directamente a los datos en el caché, en lugar de copiarlos en un buffer
en el espacio de usuario.
El gestor de cachés mantienen un historial pequeño de las solicitudes de lectura e
intenta predecir solicitudes futuras, también se encarga de indicar al gestor de
VM que escriba de vuelta en disco el contenido del caché. Se acumulan escrituras
durante 4 o 5 segundos y luego despierta al hilo escritor.
Gestor de referencias de seguridad: Cada vez que un proceso abre un mango para
un objeto, el monitor de referencias de seguridad examina el testigo de seguridad
del proceso y la lista de control de acceso del objeto para determinar si el proceso
cuenta con los derechos necesarios.
En el modo usuario están:
Subsistemas de entorno: que emulan diferentes sistemas operativos
Subsistemas de protección: ofrecen funciones de seguridad.
Universidad Tecnológica Nacional Facultad Regional Villa María
159
BALOG MARTIN AÑO 2010
10.2.4 Subsistemas de entorno
Los subsistemas de entorno permiten a NT ejecutar programas escritos para otros sistemas
operativos, utiliza el recurso de llamadas procedimientos locales para obtener servicios del núcleo
para el proceso
Puesto que cada subsistema se ejecuta como proceso en modo de usuario individual, una caída en
uno no afecta a los demás. Como excepción está Win32 que proporciona las capacidades del
teclado, ratón, y pantalla, si él falla, el sistema quedara inutilizado. Clasifica las aplicaciones como
graficas o basadas en caracteres, transformando la salida de una basada en caracteres en una
representación grafica dentro de una ventana.
Algunos entornos son:
MS-DOS: Una aplicación Win32 llamada máquina dos virtual (VDM, Virtual Dos Machine),
se encarga de proporcionar este entorno. Esta aplicación tiene una unidad de ejecución de
instrucciones para ejecutar o emular las instrucciones y los servicios de interrupción de
software de MS-DOS.
El Shell de órdenes de NT es un programa que crea una ventana muy similar a un entorno
MS-DOS y cuando se ejecuta alguna aplicación MS-DOS, éste inicia un proceso de máquina
dos virtual para ejecutar el programa.
Windows de 16 bits: También utiliza la aplicación de Win32, que incorpora software
adicional llamado Windows on Windows, Las rutinas adaptadoras convierten las
direcciones de 16 bits a direcciones de 32 bits, pero las aplicaciones Win16 sólo se
ejecutan una a la vez, todas son un mismo hilo y residen en el mismo espacio de
direcciones, además de compartir la misma cola de entrada.
Win32: Ejecuta aplicaciones Win32 y gestiona toda la E/S de teclado, ratón y pantalla. Es el
entorno controlador, ya que valida todos los objetos y los mangos antes de usarlos.
Subsistema POSIX: Está diseñado para ejecutar aplicaciones POSIX, que tienen acceso a
cualquier sistema de archivos de NT.
Subsistema de ingreso y seguridad: Antes de que un usuario pueda acceder a objetos en
NT, el subsistema de ingreso debe validarlo. El subsistema de seguridad genera testigos de
acceso que representan a los usuarios en el sistema, e invoca un paquete de validación
para que valida a los usuarios empleando información del subsistema de ingreso o del
servidor de red. Cada vez que el usuario intenta acceder a un objeto del sistema, como
cuando abre un mango para el objeto, se pasa el testigo de acceso al monitor de
referencias de seguridad, que verifica los privilegios y las cuotas.
10.2.5 Subsistema de archivos
La entidad fundamental del sistema de archivos de NT es el volumen que se basa en particiones de
disco lógicas. Se usan cúmulos como unidad de asignación de disco, que son números de sectores
del disco.
Un archivo es un objeto estructurado que consiste en atributos, y cada uno es un flujo de bytes
independiente. Todo archivo se describe con uno o más registros de un arreglo que se almacena
Universidad Tecnológica Nacional Facultad Regional Villa María
160
BALOG MARTIN AÑO 2010
en un archivo especial llamado tabla de archivos maestra (MFT, Master File Table). Los atributos
pequeños se llaman residentes y los grandes se llaman no residentes.
Recuperación
Todas las actualizaciones de las estructuras del sistema de archivos se realizan dentro de
transacciones. La transacción escribe un registro de bitácora que contiene información para
rehacer y deshacer. Después de una caída, el sistema puede restaurar las estructuras de datos
procesando los registros de la bitácora; primero se rehacen las operaciones de las transacciones
confirmadas y luego se deshacen las operaciones de transacciones que no lograron confirmarse
antes de la caída. Se asegura que las estructuras de datos no tengan daños y reflejen algún estado
consistente previo.
La bitácora tiene secciones:
Área de bitácora: que es una cola circular de registros de bitácora,
Área de reinicio: Que contiene información de contexto, como la posición donde debe
comenzar a leer durante una recuperación.
Seguridad
Cada objeto archivo tiene un atributo de descriptor de seguridad almacenado en su registro de
tabla de archivos maestra y contiene el testigo de acceso del dueño del archivo, una lista de
control de acceso que indica los privilegios de acceso que se otorgan a cada usuario que tiene
acceso al archivo.
10.3 Windows CE
Windows CE es un sistema operativo destinado fundamentalmente a organizadores personales y a
sistemas empotrados y dedicados. Últimamente se desarrollan también numerosas máquinas cuyo
funcionamiento dependerá de otros sistemas de mayor tamaño (funcionamiento al que llamamos
empotrado) y que han de cumplir una labor muy especifica.
Surge la necesidad de crear un sistema operativo que se adapte a diferentes circunstancias, a
diferentes especificaciones y que sea capaz de trabajar con una mínima cantidad de recursos.
Mercado al que se dirige
Los tipos de sistema a los que se dirige Windows CE son:
Sistemas Empotrados: Estos han de formar parte de un sistema mayor e interactuar con él.
Esta interacción puede ser en tiempo real. Este tipo de sistemas han de poder adaptarse
bien al entrono en el que se integran.
Organizadores personales (PDAs, Personal Digital Assistant): Como su nombre lo indica, es
una herramienta de organización que deberá facilitar las opciones típicas de agenda,
dietario, calendario, etc. Pero además puede ser útil para guardar documentos, trabajos
con hojas de cálculo, redactar y/o enviar correo electrónico, etc. Un organizador personal
también debería incorporar sistemas de visualización de video, reproducción y grabación
de sonido y un largo etc.
Universidad Tecnológica Nacional Facultad Regional Villa María
161
BALOG MARTIN AÑO 2010
Objetivos y limitaciones
Un sistema empotrado se dedica a una tarea muy específica y en cada caso tendrá una función
propia diferente a los demás. Por lo tanto, el sistema operativo deberá ser flexible y adaptable en
cuanto a sus funciones. El sistema deberá ser muy flexible en cuanto a los recursos necesarios,
siendo capaz de trabajar incluso en situaciones de mínimos recursos.
Los organizadores personales, comercialmente requieren un bajo costo para el usuario para tener
éxito, por consiguiente, el sistema resultante deberá ser económico, minimizando el número de
recursos internos necesarios, principalmente memoria y procesador.
Windows CE deberá ser capaz de trabajar en condiciones de memoria muy limitada. Ha de ser
capaz de trabajar también con diferentes procesadores (todos ellos de 32 bits) con lo cual debe ser
un sistema adaptable a diferentes configuraciones, extrayendo el máximo rendimiento de cada
una de ellas. También deberá ser capaz de interactuar con otras máquinas, por lo que las
comunicaciones son un elemento importante del sistema y se les debe dar soporte adecuado,
incorporando todos los sistemas y protocolos habituales. El desarrollo de controladores (drivers)
para diferentes dispositivos sea sencillo, puesto que de no ser así, los fabricantes de dichos
dispositivos no querrán trabajar con Windows CE.
Características deseadas de Windows CE:
Reducción del uso de memoria
Compatibilidad con sistemas anteriores
Win32
Limitaciones de los dispositivos de Entrada/Salida (pantalla, teclado,…)
Portabilidad ejecutable desde ROM. Modularidad
Velocidad de respuesta: capaz de operar en tiempo real
Flexibilidad: funcional y de recursos necesarios
Sistema de comunicaciones completo
Modular
Windows CE permite que cada fabricante pueda seleccionar las partes del sistema operativo que
necesita para su dispositivo y pueda compilarlas de forma que sólo se incorpore aquello que sea
necesario optimizando el funcionamiento y reduciendo los costes de fabricación del cliente ya que
estará limitando las necesidades de memoria y componentes.
Sistemas empotrados y dedicados
Windows CE se puede ejecutar desde una memoria ROM o una memoria Flash. Además es capaz
de realizar el almacenamiento persistente de datos en memoria RAM, ya que los dispositivos en
los que trabaja no tienen por qué disponer de una unidad de almacenamiento persistente como
puede ser un disco duro, una unidad de disquete, etc.
Arquitectura de Windows CE
Kernel: Se trata de un Sistema operativo multitarea, es decir, capaz de ejecutar varios threads
(tareas), de forma concurrente repartiendo el tiempo de procesador entre ellos y garantizando
Universidad Tecnológica Nacional Facultad Regional Villa María
162
BALOG MARTIN AÑO 2010
que cada tarea tenga su propio espacio en memoria, que utiliza un sistema de prioridades para
planificar la ejecución.
GWE Graphics Windows Events: GWE es el componente de sistema operativo que da soporte a los
gráficos, al controlador de ventanas y al controlador de eventos. Para ello se implementan
librerías:
Windows GDI (Graphics Device Interface)
User
En cuanto al controlador de eventos, es el que permite la compatibilidad con la programación
estándar de otros sistemas operativos Windows, basada en mensajes.
Sistema de archivos (File System): Windows CE es un sistema muy flexible en cuanto a los
dispositivos de almacenamiento soportados, da soporte al almacenamiento de archivos en
memoria RAM y ROM, también puede gestionar otros dispositivos como disco duros, CD-ROM,
DVDs, memorias Flash, etc. Para la gestión del sistema de ficheros se utiliza un subconjunto de las
APIs del sistema de archivos de Win32, manteniendo así la compatibilidad con otras versiones de
sistemas operativos Windows.
OAL (OEM Adaptation Layer): Esta capa que permite que los fabricantes programen sus propias
funciones de control de hardware (drivers) adaptándose a la interfaz que se les proporciona, que
incluye rutinas de servicio a interrupciones e interfaces para funcionalidades especificas del
hardware como puede ser la alimentación.
Controladores de dispositivos (Drivers): Windows CE trabaja con diferentes tipos de drivers:
Nativos: Incorporados en el sistema operativo,
Instalables: Proporcionado por los fabricantes.
La idea importante es la facilidad que se ofrece a los fabricantes a través de las interfaces
disponibles, que les permiten crear sus propios controladores de una forma bastante directa.
APIs de comunicación: Un dispositivo con este sistema operativo ha de tener conectividad con
otros sistemas Windows, con Internet y con otros dispositivos Windows CE. Por ello utiliza como
protocolo principal TCP/IP, mejorado en este caso para la comunicación sin cable (wireless),
dispone de gran cantidad de APIs de alto nivel sockets, comunicación por puerto serie, telefonía,
Win1Net (FTP y HTTP), LAN (NDIS). También se dispone de una API propia de acceso remoto para
poder trabajar con una PC.
Núcleo del sistema
Uno de los requisitos principales de Windows CE es la utilización de la menor cantidad posible de
memoria. Para ello se usa un sistema de paginación con TLB (Translation Look-aside Buffer) virtual.
La paginación es un modelo de gestión de memoria que consiste en dividir en secciones de
longitud fina –páginas– el espacio lógico del proceso.
El TLB mantiene un caché que guarda la relación entre las direcciones virtuales de los procesos y
las direcciones físicas correspondientes, acudiendo a esta tabla cuando se produce un fallo de
pagina. Es decir, cuando la ejecución de un proceso accede a una posición del espacio de memoria
Universidad Tecnológica Nacional Facultad Regional Villa María
163
BALOG MARTIN AÑO 2010
de un proceso para buscar un dato que anteriormente estaba allí pero que ha sido sobrescrito.
Para evitar que una aplicación pueda bloquear el sistema, se mantienen por separado el sistema
de ficheros (que se ejecuta en modo usuario), el gestor de ventanas y los controladores de
dispositivos. De esta forma, si alguno de ellos falla no provocará fallos en el resto.
¿Cómo se aplica este modelo en Windows CE?
Como Windows CE es un sistema operativo multithread (multitareas), si un proceso tiene varias
tareas independientes entre sí y éstas tienen la misma prioridad, se ejecutan simultáneamente
repartiendo el tiempo de procesador.
Cuando se ejecuta una aplicación se está creando un proceso. Dicho proceso dividirá sus funciones
en tareas (como mínimo una, que se crea a la vez que el proceso), representadas para el sistema
operativo en forma de threads. El proceso es quien gestiona los threads, que de él dependen y la
interacción entre ellos. Un thread puede encontrarse en los siguientes estados:
Running: El thread se está ejecutando en la CPU.
Suspended: El thread está en la CPU a la espera de ejecutarse.
Sleeping: Thread bloqueado durante un periodo de tiempo determinado.
Blocked: La tarea está bloqueada esperando algún recurso.
Terminated: El thread ha terminado de ejecutarse..
Es importante una buena planificación en la ejecución de tareas para evitar conflictos en el acceso
a recursos o datos compartidos. Es importante evitar siempre los siguientes problemas que se
introducen al uso de thread:
Uso de la memoria: Para minimizar el uso de memoria del sistema, Windows CE utiliza un
método llamado PSL (Protected Server Library), que consiste en una mezcla entre las
conocidas DLLs y los procesos cuyo objetivo es disminuir el uso de memoria manteniendo
un funcionamiento de tipo cliente – servidor. Cuando un proceso cliente realiza una
llamada a una PSL, el kernel obtiene la dirección y averigua que APL y qué servidor ha de
utilizar, pudiendo así preparar la lista de argumentos y realizar la llamada.
Memoria virtual: Windows CE crea un espacio de direcciones virtuales que comparten
todos los procesos. El objetivo de estas direcciones virtuales es hacer transparente para el
desarrollador cualquier aspecto de la memoria física del dispositivo. El tamaño de este
espacio de direcciones es de 4 GB. (232,por procesadores de 32 bits). Para gestionar su uso,
se divide dicho espacio en bloques destinados a la:
Memoria virtual: Son los primeros 2 GB. de direcciones, es usada por los procesos
Memoria física: Es para su direccionamiento
Una parte de los primeros 2 GB, si dividen en 33 bloques (slots) de 32 MB, cada uno
destinado a un proceso. De esta manera asignamos un espacio de direcciones diferentes a
cada proceso y conseguimos así que no se produzcan interferencias entre procesos. De
estos 33 slots (numerados del 0 al 32), el 0 será ocupado en todo momento por el proceso
activo (el que se está ejecutando) y el resto se utilizaran para los demás procesos,
limitando el número de procesos que puede gestionar Windows CE a 32.
Universidad Tecnológica Nacional Facultad Regional Villa María
164
BALOG MARTIN AÑO 2010
Cuando un proceso pasa a estar activo se copia en el slot 0, de esta forma el kernel
siempre accede a la misma posición de memoria para obtener los datos del proceso en
ejecución. En el slot 1 se halla el kernel y en los 2 y 3 normalmente el GWE y el file system
respectivamente. Para garantizar la protección del sistema ante fallos se utiliza un sistema
que asocia a cada thread una clave que indica a qué bloques de memoria tiene acceso. De
esta forma se asegura de que cada tarea sólo tenga acceso a sus propios datos.
Mensajes
El paso de mensajes es un sistema sencillo e intuitivo de sincronización/comunicación entre
procesos que se ejecutan concurrentemente. Consiste en el intercambio de mensajes que pueden
contener cualquier tipo de información que se necesite.
Los procesos que se ejecutan en Windows CE, concretamente, los threads de dichos procesos
utilizan mensajes para controlar los recursos del sistema, así como para comunicarse con el
usuario y con el sistema operativo. Dichos mensajes pueden ser originados por la actividad del
usuario (por ejemplo, cuando trabaja con el teclado), por los threads de otros procesos o otros
threads del mismo proceso. Cada thread tiene su propia cola de entrada de mensajes, que va
analizando continuamente para controlar la ejecución.
Interrupciones
Las interrupciones son un elemento clave en un sistema operativo cuando se trata de responder
rápidamente a un evento externo. El objetivo es conseguir un equilibrio entre facilidad de
implementación y uso se ha de facilitar la tarea de los fabricantes de dispositivos y la optimización
del funcionamiento del sistema en pasos:
Rutinas de servicio a la interrupción (ISR)
Threads de servicio a la interrupción (IST)
Scheduler (Planificación de procesos y threads)
El sistema operativo tiene un número de prioridades determinado y una cola de ejecución para
cada prioridad. Cuando ha de ejecutarse un thread se le asigna una prioridad y se sitúa en la cola
correspondiente. Windows CE ofrece 256 niveles de prioridad para los threads, siendo 0 el de
mayor prioridad y 255 el de menor. Del 248 al 255 se reserva para aplicaciones y se mapean a los 8
niveles disponibles en anteriores versiones de Windows CE, dejando el resto (0 a 247) para
aplicaciones de tiempo real, controladores (drivers) y procesos de sistema. Siempre se ejecutan
primero los threads de mayor prioridad. Cuando dos o más threads tienen la misma prioridad es
cuando se utiliza el algoritmo de round-robin; si un thread se bloquea, no continuara su ejecución
hasta que no se hayan ejecutado el resto de tareas de la misma prioridad que estaban en la cola.
Un thread sólo puede permanecer en ejecución (running) durante un tiempo determinado seguido
(quantum). Si se agota su tiempo y no ha acabado su actividad, se suspende hasta que le vuelva a
tocar el turno. Las prioridades de los threads en Windows CE son fijas, cambiando sólo cuando un
thread de menor prioridad está bloqueando un recurso que necesita un thread de prioridad
mayor, volviendo a asignarle después la misma prioridad que tenía antes del cambio.
Windows CE puede gestionar el acceso a recursos compartidos mediante los siguientes métodos:
Universidad Tecnológica Nacional Facultad Regional Villa María
165
BALOG MARTIN AÑO 2010
Funciones de espera: Bloquean un thread en función del estado de uno o varios objetos
(objetos de sincronización u otros procesos o threads)
Funciones de bloqueo (Interlocked Functions): Garantizan el acceso atómico a variables
compartidas, avisando a un thread que esté usando una determinada variable cuando ésta
es susceptible de ser modificada por otra tarea.
Objeto de sincronización:
Eventos: Usados para modificar a los threads cuando pueden realizar su tarea, o
para comunicar a otros threads o procesos que un evento particular ha sucedido.
Secciones criticas: Son secciones de código asociadas al uso de un recurso
compartido y que requieren un acceso exclusivo a un conjunto de datos
compartidos.
Objetos de exclusión mutua: El acceso a un objeto de exclusión mutua se realiza
únicamente de forma secuencial. Hasta que el thread que está accediendo al
objeto no acabe su actividad, no podrá acceder ningún otro thread.
Semáforos: Un semáforo es, de hecho un contador que se utiliza en aquellos
recursos en los que se permita el acceso concurrente a un número limitado de
threads. El contador se decrementa con cada nuevo acceso y se incrementa con
cada thread que acaba su acceso, de forma que cuando el contador vale cero,
ningún thread puede acceder hasta que no acabe uno de los que ya estaban
accediendo al recurso.
Mensajes: Los threads envían mensajes para iniciarse, para comunicarse con el
sistema operativo/usuario y para controlar los recursos del sistema. También
reciben mensajes a través de una cola (independiente para cada thread) de
mensajes que cuando queda vacía indica que se puede suspender el thread y
ahorrar así su uso de procesador. Sólo usaran esta cola de mensajes aquellos
threads que tengan una ventana asociada.
Universidad Tecnológica Nacional Facultad Regional Villa María
166
BALOG MARTIN AÑO 2010
11 Otros sistemas operativos
Esta unidad no la hice porque a los sistemas que nombra 11.1, 11.2, 11.3, no están en el rejunte, ni
siquiera en el libro Fundamentos de sistemas operativos Séptima edición.
11.1 Apple Macintosh
No lo encontré en el libro
11.2 OS/2
No lo encontré en el libro
11.3 Netware
No lo encontré en el libro
11.4 Otros
No lo encontré en el libro
Universidad Tecnológica Nacional Facultad Regional Villa María
167
BALOG MARTIN AÑO 2010
12 Gestión de memoria
En un sistema monoprogramado, la memoria principal se divide en partes:
Una para sistema operativo (monitor residente, núcleo)
Otra para el programa que se ejecuta en ese instante.
En un sistema multiprogramado, la parte de <<usuario>> de la memoria debe subdividirse aun
más para hacer sitio a varios procesos. La tarea de subdivisión la lleva a cabo dinámicamente el
sistema operativo y se conoce como gestión de memoria.
En un sistema multiprogramado resulta vital una gestión efectiva de la memoria, si solo hay unos
pocos procesos en la memoria, entonces la mayor parte del tiempo estarán esperando a la E/S y el
procesador estará desocupado. Por ello, hace falta repartir eficientemente la memoria para
introducir tantos procesos como sea posible.
12.1 Requisitos para la gestión de memoria
Con la gestión de la memoria, los requisitos que se intentan satisfacer son:
Reubicación.
Protección.
Compartición.
Organización lógica.
Organización física.
12.1.1 Reubicación
Una vez que se ha descargado un programa en el disco, se necesita reubicar el proceso en un área
distinta de la memoria cuando vuelva a ser cargado, ya que sería limitado que deba situarse en la
misma región que antes. El sistema operativo debe conocer la ubicación de la información de
control del proceso y de la pila de ejecución, puesto que él gestiona la memoria y es responsable
de traer el proceso a la memoria principal, estas direcciones deben ser fáciles de conseguir.
12.1.2 Protección
Puesto que se desconoce la ubicación de un programa en la memoria principal, es imposible
comprobar las direcciones absolutas (físicas) durante la compilación para asegurar la protección,
por ello la mayoría de los lenguajes de programación permiten el cálculo dinámico de direcciones.
Todas las referencias a la memoria deben comprobarse durante la ejecución para asegurar que
hacen referencia sólo al espacio de memoria destinado a dicho proceso. El procesador es el que
debe satisfacer las exigencias de protección de la memoria, no el sistema operativo.
12.1.3 Compartimiento
Debe tener la flexibilidad de permitir el acceso de varios procesos a la misma zona de la memoria y
controlar los accesos a aéreas compartidas de la misma sin comprometer la protección básica.
Universidad Tecnológica Nacional Facultad Regional Villa María
168
BALOG MARTIN AÑO 2010
12.1.4 Organización lógica
La memoria principal se organiza como un espacio de direcciones lineal o unidimensional que
consta de una secuencia de bytes o palabras. Si el sistema operativo y el hardware del computador
pueden tratar de forma efectiva los programas de usuario y los datos en forma de módulos de
algún tipo, se conseguirá una serie de ventajas, tales como:
Los módulos pueden escribirse y compilarse independientemente,
Pueden otorgarse distintos grados de protección a cada módulo,
Es posible introducir mecanismos por medio de los cuales los procesos puedan compartir
módulos.
La herramienta que más fácilmente satisface estas necesidades es la segmentación.
12.1.5 Organización física
La memoria se organiza en al menos los siguientes niveles:
Memoria principal: ofrece un acceso rápido, es volátil y tiene un costo relativamente alto
Memoria secundaria: es más lenta y barata y es no volátil.
La tarea de mover información entre estos niveles es tarea del sistema por las siguientes razones:
1. La memoria principal disponible para un programa y sus datos puede ser insuficiente y el
programador debe emplear una técnica de superposición en la cual el programa y sus
datos se organizan de tal forma que puede haber varios módulos asignados a la misma
región de memoria.
2. En un entorno multiprogramado, el programador no conoce durante la codificación
cuánto espacio habrá disponible o donde estará este espacio.
12.2 Partición de la memoria
La tarea principal del sistema de gestión de memoria es cargar los programas en la memoria
principal para su ejecución en el procesador. En casi todos los sistemas multiprogramados
modernos, esta tarea requiere un sofisticado esquema llamado memoria virtual. La memoria
virtual está, basada en el uso de una de las siguientes técnicas básicas:
Segmentación
Paginación
Antes de ver estas técnicas de memoria virtual, veremos técnicas más simples que no requieren el
uso de memoria virtual:
Particiones estática
Particiones dinámicas
12.2.1 Particiones estáticas
Dividir la memoria en regiones con límites fijos. Una posibilidad es emplear particiones de igual
tamaño, pero tiene las siguientes dificultades:
Un programa demasiado grande puede no caber en la partición y el uso de la memoria es
extremadamente ineficiente ya que cualquier programa por más pequeño que sea,
Universidad Tecnológica Nacional Facultad Regional Villa María
169
BALOG MARTIN AÑO 2010
ocupara una partición completa y se malgasta espacio, hay fragmentación interna (cuando
el bloque de datos cargado es más pequeño que la partición).
Otra posibilidad es emplear particiones de distintos tamaños.
Algoritmo de ubicación
Con particiones del mismo tamaño, la ubicación es trivial, en cualquier partición libre se puede
cargar un proceso.
Con particiones de distintos tamaños se puede asignar cada proceso a la partición más pequeña en
la que quepa en este caso, hace falta una cola de planificación por cada partición que alberga los
procesos, o bien emplear una única cola para todos los procesos y seleccionar la partición
disponible más pequeña que pueda albergar al proceso.
Desventajas
El número de particiones limita el número de procesos activos.
Los trabajos pequeños no hacen un uso eficiente del espacio de las particiones.
12.2.2 Particiones Dinámicas
Las particiones son variables en número y longitud y cuando se carga un proceso en la memoria,
se le asigna exactamente lo que necesita y no más. Sufre la fragmentación externa ya que hay gran
número de huecos pequeños en los que no cabe un proceso. Para combatir este problema se
utiliza la compactación donde se desplazan los procesos para que estén contiguos de forma que
toda la memoria libre quede junta en un sólo bloque. El inconveniente es que consume mucho
tiempo y necesita de la capacidad de reubicación dinámica.
Algoritmo de ubicación
Se pueden considerar los siguientes algoritmos de ubicación:
Mejor ajuste: que elije los bloques de tamaño más próximo al solicitado,
Primer ajuste: que escoge el primer bloque disponible que sea suficientemente grande,
Siguiente ajuste: que recorre la memoria desde el lugar de la última ubicación y elige el
siguiente bloque disponible que sea suficientemente grande.
El algoritmo del primer ajuste es el más sencillo, rápido y mejor.
Sistema de colegas
Los bloques de memoria disponibles son de tamaño 2K para valores de K tal que L ≤ K ≤ U y donde:
2L tamaño de bloque más pequeño asignable
2U tamaño de bloque más grande asignable
Si se hace una solicitud de tamaño x el bloque se divide por la mitad hasta alcanzar el tamaño
adecuado y a medida que se desocupan los colegas se unen otra vez para formar el bloque inicial.
(Figura 12.1)
Universidad Tecnológica Nacional Facultad Regional Villa María
170
BALOG MARTIN AÑO 2010
Figura 12.1 Ejemplo del sistema de colegas
Direcciones
Una dirección lógica es una referencia a una posición de memoria independiente de la asignación
actual de datos a la memoria; se debe hacer una traducción a una dirección física antes de poder
realizar un acceso a la memoria. Una dirección relativa es un caso particular de dirección lógica, en
la cual la dirección se expresa como una posición relativa a algún punto conocido. Una dirección se
expresa como una posición relativa a algún punto conocido. Una dirección física o absoluta es una
posición real en la memoria. Las direcciones relativas pasan por las siguientes etapas:
Se añade el valor del registro base para obtener una dirección absoluta
La dirección absoluta se compara con el valor del registro límite
12.3 Paginación
La memoria principal se encuentra dividida en trozos iguales de tamaño fijo relativamente
pequeños y cada proceso está dividido también en pequeños trozos de tamaño fijo y del mismo
tamaño que los de memoria. Los trozos del proceso se llaman páginas y pueden asignarse a los
trozos libres de memoria llamados marcos o encuadre (frame). En caso de que no haya suficientes
marcos sin usar contiguos para albergar al proceso se puede emplear de nuevo el concepto de
dirección lógica y asignar los marcos libres siguientes. El sistema operativo mantiene una tabla de
páginas para cada proceso donde se guarda la posición de los marcos utilizados por el mismo.
(Figura 12.2)
1 Bloque de 1 Megabyte 1 MB
A = Solicitud de 100 KB A 128 KB 256 KB 512 KB
B = Solicitud de 240 KB A 128 KB B 512 KB
C = Solicitud de 64 KB A C 64 B 512 KB
Liberación B A C 64 256 KB 512 KB
Liberación A 128 KB C 64 256 KB 512 KB
Liberación C 256 KB 256 KB
1 MB
Universidad Tecnológica Nacional Facultad Regional Villa María
171
BALOG MARTIN AÑO 2010
Figura 12.2 Asignación de páginas de procesos a marcos libres
12.4 Segmentación
El programa y sus datos asociados se dividen en un conjunto de segmentos, que pueden ser de
longitud variable de un programa a otro y tienen un máximo de longitud. Una dirección lógica
segmentada consta de las siguientes partes:
Un numero segmentado
Un desplazamiento
Un programa puede ocupar más de una partición y éstos no tienen por qué estar contiguo, es la
diferencia principal con la partición dinámica. La segmentación elimina la fragmentación interna
pero sufre la fragmentación externa. Mientras la paginación es transparente al programador, la
segmentación es visible, y se ofrece como una ventaja, pero el programador debe ser consciente
de la limitación de tamaño máximo de los segmentos.
Habrá una tabla de segmentos para cada proceso y una lista de bloques libres en la memoria
principal. Cada entrada de la tabla de segmentos tendría que contener la dirección de comienzo
del segmento correspondiente y proporcionar la longitud del mismo para garantizare que no se
usan direcciones no validas.
Universidad Tecnológica Nacional Facultad Regional Villa María
172
BALOG MARTIN AÑO 2010
12.5 Memoria virtual
Estructuras de hardware y de control
Si la paginación o la segmentación está presente con sus características, no será necesario que
todas las páginas o todos los segmentos de un proceso estén en la memoria durante la ejecución.
A la parte de un proceso que está realmente en la memoria principal se llama conjunto residente
del proceso. Si el procesador encuentra una dirección lógica que no está en la memoria, genera
una interrupción y el sistema operativo pone al proceso interrumpido en estado Bloqueado y toma
el control (el sistema operativo). Luego trae a la memoria el fragmento que contiene la dirección
que falta para ejecutar de nuevo el proceso.
Se pueden mantener más procesos en la memoria principal, puesto que se van a cargar solo
algunos fragmentos de un proceso particular y habrá sitio para más procesos. Es posible que un
proceso sea más grande que toda la memoria principal.
Como los procesos se ejecutan sólo en la memoria principal, a esta memoria se le llama memoria
real, pero un programador o usuario percibe en potencia una memoria mucho mayor que está
situada en el disco, la memoria virtual.
La Tabla 12.1 resume las características de la paginación y la segmentación, con y sin memoria
virtual.
Paginación Simple Memoria virtual paginada Segmentación simple Memoria virtual
segmentada
La memoria principal está dividida en trozos pequeños de tamaño fijo llamados marcos.
La memoria principal está dividida en trozos pequeños de tamaño fijo llamados marcos.
La memoria principal no está dividida.
La memoria principal no está dividida.
El compilador o el sistema de gestión de memoria dividen los programas en páginas.
El compilador o el sistema de gestión de memoria dividen los programas en páginas.
El programador especifica al compilador los segmen-tos del programa (es decir, el programador toma la de-cisión).
El programador especifica al compilador los segmen-tos del programa (es decir, el programador toma la de-cisión).
Fragmentación interna en los marcos.
Fragmentación interna en los marcos.
No hay fragmentación interna.
No hay fragmentación interna.
No hay fragmentación externa.
No hay fragmentación externa.
Fragmentación externa. Fragmentación externa.
El sistema operativo debe mantener una tabla de páginas para cada proceso indicando en qué marco está cada página.
El sistema operativo debe mantener una tabla de páginas para cada proceso indicando en qué marco está cada página.
El sistema operativo debe mantener una tabla de segmentos para cada proceso, indicando la dirección de carga y la longitud de cada segmento.
El sistema operativo debe mantener una tabla de segmentos para cada proceso, indicando la dirección de carga y la longitud de cada segmento.
El sistema operativo debe mantener una lista de marcos libres.
El sistema operativo debe mantener una lista de marcos libres.
El sistema operativo debe mantener una lista de huecos libres en la memoria principal.
El sistema operativo debe mantener una lista de huecos libres en la memoria principal.
El procesador emplea el número de página y el desplazamiento para calcular las direcciones absolutas.
El procesador emplea el número de página y el desplazamiento para calcular las direcciones absolutas.
El procesador emplea el número de segmentos y el desplazamiento para calcular las direcciones absolutas.
El procesador emplea el número de segmentos y el desplazamiento para calcular las direcciones absolutas.
Todas las páginas de un No todas las páginas de un Todos los segmentos de un No todos los segmentos de
Universidad Tecnológica Nacional Facultad Regional Villa María
173
BALOG MARTIN AÑO 2010
proceso tienen que estar en la memoria principal para que el proceso se ejecute, a menos que se use superposición.
proceso tienen que estar en marcos de la memoria principal para que el proceso se ejecute. Las páginas se pueden leer cuando se necesiten.
proceso tienen que estar en la memoria principal para que el proceso se ejecute, a menos que se use superposición.
un proceso tienen que estar en marcos de la memoria principal para que el proceso se ejecute. Los segmentos se pueden leer cuando se necesiten.
La carga de una página en la memoria principal puede exigir descargar otra en el disco.
La carga de un segmento en la memoria principal puede requerir descargar uno o más segmentos en el disco.
Tabla 12.1 Características de la paginación y segmentación
Memoria virtual y cercanía de referencias
Cuando tenemos un proceso grande formado por un programa largo y un conjunto de series de
datos, se puede aprovechar mejor la memoria cargando tan sólo algunos fragmentos.
Prácticamente toda la memoria estará ocupada con fragmentos de procesos y cuando el sistema
operativo traiga uno nuevo a la memoria deberá expulsar otro. Demasiados intercambios de
fragmentos conducen a lo que se llama hiperpaginación (thrashing), donde el procesador pasa
más tiempo intercambiando fragmentos que ejecutando instrucciones. Por ello el sistema
operativo intenta adivinar que fragmentos se usaran con menor y mayor probabilidad en un
futuro. El principio de cercanía afirma que las referencias a los datos y al programa dentro de un
proceso tienden a agruparse.
Para que la memoria virtual sea práctica y efectiva, se necesitan los siguientes ingredientes:
Tiene que existir un soporte de hardware.
El sistema operativo debe incluir un software para gestionar el movimiento de páginas o
segmentos entre la memoria secundaria y memoria principal.
Paginación en memoria virtual
Con la memoria virtual basada en paginación se necesita una tabla de páginas. En cuyas entradas
habrá un bit para indicar si la página correspondiente está presente en la memoria principal o no.
Figura 12.3 (a).Si el bit indica que la página está en la memoria, la entrada incluye también el
número de marco de esa página. Además hay otro bit de control, el bit de modificación que indica
si el contenido de la página se ha alterado desde que se cargo en la memoria.
Estructura de la tabla de páginas
La lectura de una palabra de la memoria supone la traducción por medio de la tabla de páginas de
una dirección virtual o lógica formada por un número de página y un desplazamiento a una
dirección física que está formada por un número de marco y un desplazamiento. El número de
página de la dirección virtual se emplea como indica en la tabla para buscar el número de marco,
éste se combina con la parte de desplazamiento de la dirección virtual para generar la dirección
real deseada.
Se puede utilizar un esquema de 2 niveles para organizar las tablas grandes. O bien adoptar un
esquema de tabla de páginas invertida donde la parte del número de página de una dirección
Universidad Tecnológica Nacional Facultad Regional Villa María
174
BALOG MARTIN AÑO 2010
virtual se traduce a una tabla de dispersión por medio de una función de dispersión simple. Hay
una entrada en cada tabla por cada página de memoria real y uno por cada página virtual.
Figura 12.3 Formatos típicos de gestión de memoria
Buffer de traducción adelantada
Cada referencia a la memoria virtual genera los siguientes accesos:
Uno para obtener la entrada de la tabla
Otro para obtener el dato deseado.
La mayoría de los esquemas de memoria virtual hacen uso de una caché especial para las entradas
de la tabla de páginas, llamada generalmente buffer de traducción adelantada (TLB, Translation
Lookaside Buffer). Si la página buscada no está en la memoria se produce un fallo de página que se
debe atender con una rutina de gestión de fallos de página. Cada entrada al buffer debe incluir el
número de página y la entrada a la tabla, el procesador estará equipado con un hardware que
permite consultar simultáneamente varias entradas del buffer para determinar si hay una
coincidencia en el número de página a esta técnica se la llama correspondencia asociativa.
Tamaño de la pagina
Cuanto menor sea el tamaño de la pagina, menor será la cantidad de fragmentación interna y
mayor será el número de páginas que se necesiten por proceso, esto significa que las tablas serán
Universidad Tecnológica Nacional Facultad Regional Villa María
175
BALOG MARTIN AÑO 2010
mayores y deberán estar en la memoria virtual. Se pueden producir los siguientes fallos de
páginas:
Uno para traer la parte necesaria de la tabla de páginas
Otro para traer la página del proceso
El porcentaje de fallas se tiene en cuenta con respecto al tamaño de página, la tasa de fallas baja
conforme aumenta el número de páginas en memoria principal. Cuando crece el tamaño de los
procesos en la memoria y decrece su cercanía, disminuye el porcentaje de aciertos en los accesos
al buffer.
Segmentación en memoria virtual
Se utiliza la misma estructura, con una tabla de segmentos y se necesitara un bit en cada entrada
para indicar si el segmento correspondiente se encuentra en la memoria principal. También se
necesitara un bit de control, llamado de modificación que indique si el segmento ha sido
modificado desde que se cargó en la memoria. Figura 12.3 (b). Para leer una palabra de la
memoria se traduce una dirección virtual o lógica, que tiene un número de segmento y un
desplazamiento, a una dirección física mediante una tabla de segmentos.
Ventajas
A la estructura de datos se le puede asignar su propio segmento y el sistema operativo
expandirá o reducirá el mismo cuando se necesite.
Permite modificar y recopilar los programas independientemente.
Se presta a la compartición entre procesos.
Se presta a la protección.
Paginación y segmentación combinadas
En un sistema con paginación y segmentación combinadas, el espacio de direcciones de un usuario
se divide en varios segmentos, y cada uno se vuelve a dividir en varias páginas de tamaño fijo que
tienen la longitud de un marco de memoria principal. Desde el punto de vista del programador
una dirección lógica todavía está formada por un número de segmento y un desplazamiento y
desde el punto de vista del sistema, el desplazamiento del segmento se ve como un número de
página dentro del segmento y un desplazamiento dentro de la página. Asociada con cada proceso
existente una tabla de segmentos y varias tablas de páginas, una por cada segmento del proceso.
Figura 12.3 (c).
Protección y compartimiento
Para conseguir la compartición, es posible que un segmento se referencie desde las tablas de
segmentos de más de un proceso.
Para la protección se puede ofrecer una estructura de anillo de protección donde los anillos
interiores o con números menores gozan de mayores privilegios que los anillos externos o con
números mayores. Los principios básicos de este sistema son:
Un programa puede acceder sólo a datos que estén en el mismo anillo o en un anillo de
menor privilegio.
Universidad Tecnológica Nacional Facultad Regional Villa María
176
BALOG MARTIN AÑO 2010
Un programa puede hacer llamadas a servicios que residan en el mismo anillo o en anillos
más privilegiados.
Software del sistema operativo
El diseño del gestor de memoria en un sistema operativo depende de las siguientes áreas de
decisión:
Si se emplean o no técnicas de memoria virtual
El uso de paginación, segmentación o ambas
Los algoritmos empleados para los diversos problemas de la gestión de memoria
Las decisiones tomadas en las dos primeras áreas dependen de la plataforma de hardware
disponible, pero la mayoría ofrece memoria virtual y casi todos los problemas de combinación de
paginación y segmentación pertenecen a la paginación. El tercer punto depende del software.
Políticas del sistema operativo sobre la memoria virtual
Políticas de lectura (fetch): Está relacionada con la decisión de cuando se debe cargar una
página en la memoria principal. Con la paginación por demanda se trae una página a la
memoria sólo cuando se hace referencia a una posición de dicha página. El principio de
cercanía hace que la mayoría de las futuras referencias estén en páginas que se han
cargado hace poco. Con la paginación previa, se cargan otras páginas distintas a las
demandadas porque es más eficiente traer un número de páginas contiguas de una vez
que ir trayéndolas de a una y tardar más tiempo. Sin embargo la utilidad de la paginación
previa no ha sido demostrada.
Políticas de ubicación: Tienen que ver con determinar dónde va a residir una parte de un
proceso en la memoria principal. En un sistema de segmentación se tienen las políticas del
mejor ajuste, el primer ajuste, y otras. Para un sistema que usa tanto paginación como
paginación combinada con segmentación, la ubicación carece de importancia.
Políticas de reemplazo: Cuando se debe cargar una nueva página y no hay lugar, se debe
decidir qué página reemplazar. Tiene que ver:
El número de marcos de página a asignar
Las páginas a reemplazar deben limitarse a las del proceso que provoco el fallo o
abarcar todos los marcos de la memoria
Cuál es la página especifica que debe elegirse para el reemplazo
Algunos marcos de la memoria principal pueden estar bloqueados y la página cargada
actualmente en él no puede ser reemplazada.
Algoritmos básicos que se emplean para la selección de una página a reemplazar:
El algoritmo óptimo selecciona para reemplazar la página que tiene que esperar
una mayor cantidad de tiempo para que se produzca una referencia a ella. Es
imposible de implementar, puesto que requiere que el sistema operativo tenga
un conocimiento exacto de los sucesos futuros. Sin embargo, sirve como un
estándar con el que comparar los otros algoritmos.
Universidad Tecnológica Nacional Facultad Regional Villa María
177
BALOG MARTIN AÑO 2010
Usada menos recientemente (LRU, Least Recently Used): Reemplaza la página que
no ha sido referenciada desde hace más tiempo. Se puede etiquetar cada página
con el momento de su última referencia.
Primera en entrar primera en salir (FIFO, First In First Out): Trata los marcos
asignados a un proceso como un buffer circular y las páginas se suprimen de la
memoria según la técnica de turno rotatorio (round-robin).
La política del reloj asocia a cada marco un bit de uso. Cuando se carga una página
por primera vez el bit de uso se pone a 0 y cuando se hace referencia el bit de uso
se pone a 1. Se considera un buffer circular con un puntero asociado y cuando
llega el momento de reemplazar una página. El sistema operativo recorre el
buffer buscando un marco con el bit de uso a 0. Cada vez que se encuentre un
marco con el bit a 1 lo pone a 0 hasta que llega a la posición inicial si todos están
en 1 o apuntando el siguiente en ser reemplazado.
También se asocia un bit de modificación a cada página y por lo tanto a cada
marco. Con la combinación (u = 0; m = 0), (u = 1; m = 0), (u = 0; m = 1), (u = 1; m =
1). Se selecciona para reemplazar el marco que tenga (u = 0; m = 0), si esto falla,
entonces se recorre de nuevo buscando (u = 0; m = 1) en cada pasada el bit de
uso se pone a 0.
Almacenamiento intermedio de páginas: para mejorar el rendimiento no se
pierde de vista la página reemplazada sino que se la asigna a la vista de páginas
libres, si no ha sido modificada, o a la lista de páginas modificadas si lo ha sido.
Estas listas actúan como una caché de páginas.
Gestión de conjunto residente
Tamaño del conjunto residente: Cuanto menor es la cantidad de memoria
asignada a un proceso, mayor es el número de procesos que pueden estar en la
misma, si en la memoria hay un número pequeños de páginas de un proceso el
porcentaje de fallos de paginas es mayor. Teniendo en cuenta estos factores, hay
las siguientes políticas:
Asignación fija: otorga a cada proceso un número fijo de páginas en las
que ejecutar.
Asignación variable: Permite que el número de marcos asignados a un
proceso cambie a lo largo de su vida.
Alcance del reemplazo
Una política de reemplazo local escoge únicamente de entre las páginas
residentes del proceso que originó el fallo de página.
Una política de reemplazo global considera todas las páginas de la
memoria como candidatas para reemplazar.
El conjunto de trabajo de un proceso en un instante virtual t y con un
parámetro ∆, es el conjunto de páginas a las que el proceso ha hecho
referencia en las últimas ∆ unidades de tiempo virtual.
Universidad Tecnológica Nacional Facultad Regional Villa María
178
BALOG MARTIN AÑO 2010
Reemplazo local Reemplazo global
Asignación Fija
El número de marcos asignados a un proceso es fijo.
La página a reemplazar se elige de entre los marcos asignados al proceso.
No es posible
Asignación Variable
El número de marcos asignados a un proceso puede cambiar para mantener su conjunto de trabajo
La página a reemplazar se elige de entre los marcos del proceso
La página a reemplazar se elige de entre todos los marcos disponibles, esto hace que cambie el tamaño del conjunto residente.
Tabla 12.2 Gestión del conjunto residente
Políticas de vaciado: Se preocupa de determinar el momento en que hay que escribir en la
memoria secundaria una página modificada. Las alternativas más habituales son:
Vaciado por demanda: Una página se escribirá en la memoria secundaria sólo
cuando haya sido elegida para reemplazarse
Vaciado previo: Se escriben las páginas modificadas antes de que se necesiten sus
marcos, de forma que las páginas puedan escribir por lotes.
Control de carga: Consiste en determinar el número de procesos que pueden estar en la
memoria principal, lo que ha venido a llamarse grado de multiprogramación.
Grado de multiprogramación: Cuando el grado de multiprogramación supera un
valor pequeño se podría esperar que la utilización del procesador aumentara,
puesto que hay menos posibilidades de que todos los procesos estén bloqueados.
Se puede utilizar un método conocido como el criterio L = S, que ajusta el grado
de multiprogramación de forma que el tiempo medio entre fallos sea igual al
tiempo medio exigido para procesar un fallo de página.
Suspensión de procesos: Para reducir el grado de multiprogramación se deben
suspender (descargarse) uno o más procesos actualmente residentes, las
posibilidades son las siguientes:
Procesos con la prioridad más baja.
Procesos con fallos de página.
Último proceso activado.
Proceso con el conjunto residente más pequeño.
El proceso mayor.
Procesos con la mayor ventana de ejecución restante.
Universidad Tecnológica Nacional Facultad Regional Villa María
179
BALOG MARTIN AÑO 2010
Terminología
Directorio de archivos de usuario UFD User File Directory
Directorio de archivos maestro MFD Master File Directory
Bloque de control de archivo FCB File Control Block
Tabla de asignación de archivos FAT File Allocation Table
Primero en llegar primero en atenderse FCFS First Come First Server
Tiempo de búsqueda más corto primer SSTF Shortest Seek Time First
Trabajo más corto primero SJF
Zona desmilitarizada DMZ Demilitarized Zone
Base de Computador Confiable TCB Trusted Computer Base
Protocolo de Transferencia de Archivos FTP File Transfer Protocol
Sistema de archivos de red NFS Network File System
Llamada a procedimiento remoto RPC Remote Procedure Call
Proceso ligero lightweight process
Hilos a nivel de usuario ULT User Level Thread
Hilos a nivel de núcleo KLT Kernel Level Thread
hilos soportados por el núcleo KST Kernel Supported Threads
Interfaz de programas de aplicación API
Multiproceso simétrico SMP Symmetric multiprocessor
Flujo de instrucción simple/dato simple SISD
Flujo de instrucción simple/dato múltiples SIMD
Flujo de instrucción múltiple/datos simple MISD
Flujo de instrucción múltiple/datos múltiples MIMD:
Micronúcleo Microkernel
Comunicación entre procesos IPC
Unidad de datos de protocolo PDU Protocol Data Unit
Dirección internet IP
Punto de acceso al servicio de red NSAP Network Service Access Point
Punto de acceso al servicio SAP Service Access Point
Protocolo de control de la transmisión TCP Transmission Control Protocol
Protocolo software control de transmisión UDP User Datagram Protocol
Protocolo sencillo de transferencia de correo SMTP Simple Mail Transfer Protocol
Redes de área local LAN Local area network
Redes de área amplia WAN Wide Area Network
Servicio de información y computo con multiplexación
MULTICS Multiplexed Information and Computing Service
Sistema de información y cómputo con uniplexión
UNICS
Identificador de proceso PID
Identificador de usuario UID
Identificador de grupo GID
Sistema de archivos virtual VFS Virtual File System
Sistema de archivos extendido Extfs Extended File System
Universidad Tecnológica Nacional Facultad Regional Villa María
180
BALOG MARTIN AÑO 2010
Segundo sistema de archivos extendido ext2fs Extended Second File System
sistemas de archivos instalables IFS Installable File System
Tabla de asignación de archivos FAT File Assignment Table
Interfaz de dispositivo gráfico GDI Graphics Device Interface
Interfaces de programación de aplicaciones API Application Programming Interfaces
Biblioteca de enlazado dinámico DLL, Dynamic Link Library
Instituto de ingenieros eléctricos y electrónicos IEEE Institute of Electrical and Electronic Engineers
Soporte a idiomas internacionales NLS National Language Support
Capa de abstracción de hardware HAL Hardware Abstraction Layer
Llamadas a procedimientos locales LPC Local Procedure Call
Máquina dos virtual VDM Virtual Dos Machine
Tabla de archivos maestra MFT Master File Table
Organizadores personales PDAs Personal Digital Assistant
Buffer de traducción adelantada TLB Translation Lookaside Buffer
Usada menos recientemente LRU Least Recently Used
Primera en entrar primera en salir FIFO First In First Out
Recommended