sistemas operativos - resumen a

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


3


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


4


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


5


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


6


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


7


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.


8


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


9


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


10


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.


11


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.


12


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


13


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


14


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:


15


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.


16


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.


17


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:


18


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.


19


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.


20


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


21


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


22


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.


23


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:


24


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.


25


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


26


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.


27


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


28


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


29


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


30


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


31


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.


32


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


33


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


34


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


35


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.


36


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


37


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


38


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.


39


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).


40


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”.


41


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


42


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.


43


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.


44


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.


45


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


46


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.


47


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.


48


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.


49


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.


50


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


51


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.


52


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.


53


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.


54


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.


55


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.


56


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


57


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.


58


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


59


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


60


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.


61


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


62


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.


63


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.


64


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


65


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.


66


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


67


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.


68


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


69


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.


70


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.


71


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


72


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


73


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


74


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.


75


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


76


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.


77


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)


78


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


79


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


80


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.


81


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


82


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.


83


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.


84


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:


85


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


86


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.


87


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


88


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.


89


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.


90


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


91


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


92


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


93


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


94


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.


95


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


96


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


97


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.


98


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:


99


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


100


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.


101


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


102


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.


103


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


104


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.


105


6.5.3 Manejo de errores

No lo encontré en todo el rejunte.


106


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


107


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


108


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.


109


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.


110


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.


111


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.


112


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


113


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.


114


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


115


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.


116


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


117


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.


118


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,


119


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:


120


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


121


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.


122


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:


123


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:


124


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.


125


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.


126


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


127


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.


128


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.


129


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.


130


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


131


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


132


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


133


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


134


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


135


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.


136


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


137


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


138


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


139


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


140


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:


141


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


142


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


143


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.


144


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.


145


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.


146


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.


147


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.


148


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


149


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.


150


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).


151


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


152


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:


153


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


154


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.


155


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:


156


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.


157


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:


158


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.


159


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


160


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.


161


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


162


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


163


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.


164


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:


165


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.


166


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


11.3 Netware


11.4 Otros



167


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.


168


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,


169


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)


170


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


171


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.


172


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


173


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


174


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


175


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.


176


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.


177


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.


178


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.


179


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


180


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

sistemas operativos - resumen a

Documents