Teórico, Práctico, Preguntas (Damián Salvia) (1) - 230210 - 001706

Sistemas Operativos, FING - UdelaR Damián Salvia
Sistemas
Operativos
Facultad de Ingeniería - UdelaR
Damián Salvia - 2014
1
Índice - Temas
1 Introducción ................................................................................................................9
2 Evolución histórica de los Sistemas Operativos ........................................................... 10
2.1 Sistemas por lotes sencillos (Batch) [‘70] ................................................................................ 10
2.2 Sistemas por lotes multiprogramados [‘80] ............................................................................ 10
2.3 Sistemas de tiempo compartido [‘80] ..................................................................................... 11
2.4 Sistemas de computador personal [‘80].................................................................................. 11
2.5 Sistemas paralelos [‘90]........................................................................................................... 12
2.6 Sistemas distribuidos [‘90] ...................................................................................................... 15
2.7 Sistemas Cluster [‘00] .............................................................................................................. 15
2.8 Sistemas de tiempo real [‘00] .................................................................................................. 15
2.9 Sistemas Multimedia ............................................................................................................... 16
2.10 Sistemas de mano (Handheld) ................................................................................................ 16
2.11 Sistemas Interactivos .............................................................................................................. 16
3 Estructura de los Sistemas Informáticos ..................................................................... 17
3.1 Componentes Básicos ............................................................................................................. 17
3.1.1 CPU (Central Process Unit) ........................................................................................ 17
3.1.2 I/O (Entrada/Salida) .................................................................................................. 18
3.1.3 Memoria .................................................................................................................... 19
3.2 Protección por Hardware ........................................................................................................ 21
3.2.1 Operación en Modo Dual .......................................................................................... 21
3.2.2 Protección de E/S ...................................................................................................... 22
3.2.3 Protección de Memoria ............................................................................................ 22
3.2.4 Protección de CPU..................................................................................................... 23
3.2.5 Conclusiones ............................................................................................................. 23
3.3 Estructura de los Sistemas Operativos .................................................................................... 24
3.3.1 Administración de Procesos ...................................................................................... 24
3.3.2 Administración de Memoria ..................................................................................... 24
3.3.3 Subsistema de E/S ..................................................................................................... 25
3.3.4 Administración de Memoria Secundaria ................................................................... 25
3.3.5 Subsistema de Archivos ............................................................................................ 25
3.3.6 Subsistema de Red .................................................................................................... 26
3.3.7 Sistema de Protección ............................................................................................... 26
3.4 Servicio del Sistema Operativo ................................................................................................ 26
3.5 Llamadas al Sistema ................................................................................................................ 28
3.5.1 System Call - Control de Procesos ............................................................................. 29
3.5.2 System Call - Gestión de Archivos ............................................................................. 29
3.5.3 System Call - Gestión de Dispositivos........................................................................ 30
3.5.4 System Call - Gestión de Información ....................................................................... 30
3.5.5 System Call - Comunicación ...................................................................................... 30
3.6 Estructura del sistema ............................................................................................................. 32
3.6.1 Sistema monolítico .................................................................................................... 32
3.6.2 Sistema en capas ....................................................................................................... 32
3.6.3 Sistemas con microkernel ......................................................................................... 33
3.6.4 Sistemas con módulo ................................................................................................ 34
3.7 Máquinas virtuales (VM) ......................................................................................................... 34
4 Procesos .................................................................................................................... 36
4.1 Estado de un Proceso .............................................................................................................. 37
4.2 Bloque Descriptor de Proceso (PCB) ....................................................................................... 38
4.3 Creación de procesos .............................................................................................................. 39
4.4 Colas de Planificación de Procesos. ......................................................................................... 41
4.5 Cambio de Contexto ................................................................................................................ 43
2
4.6 Comunicación entre Procesos ................................................................................................. 44

4.7 Threads, Hebras o Hilos ........................................................................................................... 46
4.7.1 Mx1 . Many-to-one ................................................................................................... 48
4.7.2 1x1 . One-to-one ....................................................................................................... 48
4.7.3 MxN . Many-to-many ................................................................................................ 49
5 Planificación .............................................................................................................. 50
5.1 Clases de Procesos .................................................................................................................. 50
5.2 Esquema de Planificación ........................................................................................................ 51
5.3 Criterios de Planificación ......................................................................................................... 52
Algoritmos de Planificación ............................................................................................ 52
I. First Come First Served (FCFS) .............................................................................. 52
II. Shortest Job First (SJF) .......................................................................................... 53
III. Priority .................................................................................................................. 54
IV. Round Robin (RR) ................................................................................................. 55
V. Multilevel Queue .................................................................................................. 56
VI. Multilevel Feedback Queue .................................................................................. 56
Sistemas Multiprocesador .............................................................................................. 57
6 Sincronización de procesos – Programación Concurrente ............................................ 59
6.1 Grafo de precedencia .............................................................................................................. 59
6.2 Concurrencia basada en COBEGIN-COEND ............................................................................. 60
6.3 Concurrencia basada en FORK-JOIN ........................................................................................ 62
6.4 El problema de la Sección Crítica ............................................................................................ 65
6.4.1 El problema de Alicia y Bernardo .............................................................................. 67
Solución 1 .............................................................................................................. 68
Solución 2 .............................................................................................................. 68
Solución 2 bis ........................................................................................................ 70
Solución 3 .............................................................................................................. 71
6.4.2 Algoritmo de Dekker ................................................................................................. 72
6.4.3 Algoritmo de Peterson .............................................................................................. 73
6.4.4 Algoritmo del Ticket .................................................................................................. 74
6.4.5 Algoritmo de la Panadería de Lamport ..................................................................... 75
6.4.6 Test&Set y Exchange ................................................................................................. 76
6.5 Semáforos................................................................................................................................ 78
6.5.1 Equivalencia Semáforos Binarios – Semáforos de Conteo ........................................ 82
Semáforos Binarios  Semáforos de Conteo ....................................................... 82
Semáforos de Conteo  Semáforos Binarios ....................................................... 82
6.5.2 Problema de Alicia y Bernardo .................................................................................. 83
6.5.3 Problema Productor-Consumidor ............................................................................. 84
Buffer infinito ........................................................................................................ 84
Buffer finito ........................................................................................................... 85
6.5.4 Problema Lectores – Escritores ................................................................................. 86
6.5.5 Problema Filósofos que Cenan .................................................................................. 87
6.5.6 Semáforos en UNIX ................................................................................................... 89
6.6 Monitores ................................................................................................................................ 90
6.6.1 Equivalencia Monitor - Semáforo ............................................................................. 93
Monitor → Semáforo ............................................................................................ 93
Semáforo → Monitor ............................................................................................ 94
6.6.2 Problema Productor – Consumidor .......................................................................... 95
6.6.3 Problema Lectores – Escritores ................................................................................. 96
6.6.4 Problema Filósofos que Cenan .................................................................................. 98
6.7 Mensajería ............................................................................................................................. 100
6.7.1 Equivalencia Mensajería - Semáforos .................................................................... 103
Mensajería → Semáforos ................................................................................... 103
3
Semáforos → Mensajería ................................................................................... 103

6.7.2 Equivalencia Mensajería - Monitores ..................................................................... 104
Mensajería → Monitores ................................................................................... 104
Monitores → Mensajería ................................................................................... 105
6.7.3 Problema de Alicia y Bernardo ................................................................................ 105
6.7.4 Problema Productor-Consumidor ........................................................................... 106
6.7.5 Problema Lectores-Escritores ................................................................................. 106
6.7.6 Problema Filósofos que Cenan ................................................................................ 108
6.8 Rendezvous - ADA ................................................................................................................ 109
6.8.1 Equivalencia Rendezvous → Semáforos................................................................. 114
6.8.2 Problema de Alicia y Bernardo ................................................................................ 115
6.8.3 Problema Productor-Consumidor ........................................................................... 115
6.8.4 Problema Lectores-Escritores ................................................................................. 116
6.8.5 Problema Filósofos que Cenan ................................................................................ 117
7 Deadlocks................................................................................................................ 118
7.1 Bloque Descriptor de Recursos (RCB) .................................................................................... 118
7.2 Modelo del sistema ............................................................................................................... 119
7.3 Condiciones necesarias para la existencia de deadlock ........................................................ 120
7.4 Grafo de Asignación de Recursos .......................................................................................... 120
7.5 Tratamiento de deadlocks ..................................................................................................... 121
7.5.1 Ignorar el deadlock.................................................................................................. 121
7.5.2 Prevenir el deadlock ................................................................................................ 122
7.5.3 Evitar el deadlock .................................................................................................... 123
Algoritmo por Grafo de Asignación de Recursos ................................................ 124
Algoritmo del Banquero ...................................................................................... 124
Algoritmo de seguridad ............................................................................. 126
Algoritmo de solicitud de recursos ............................................................ 126
7.5.4 Detectar y Recuperar el deadklock ......................................................................... 128
Detección cuando se dispone de un solo ejemplar de cada recurso .................. 129
Detección cuando se dispone de varios ejemplares de cada recurso ................ 130
Recuperación después de un deadlock ............................................................... 132
I. Terminación de un proceso ......................................................................... 132
II. Expropiación de recursos ............................................................................ 132
8 Administración de Memoria ..................................................................................... 133
8.1 Reasignación de direcciones ................................................................................................. 133
8.1.1 Carga dinámica (dynamic loading) .......................................................................... 135
8.1.2 Ensamblaje dinámico (dynamic linking) .................................................................. 136
8.1.3 Superposición (overlay)........................................................................................... 136
8.1.4 Intercambio (swapping) .......................................................................................... 136
8.2 Asignación de memoria ......................................................................................................... 137
8.2.1 Multiprogramación con particiones fijas ................................................................ 139
8.2.2 Multiprogramación con particiones variables ........................................................ 139
8.2.3 Paginación ............................................................................................................... 141
Rendimiento de la paginación ............................................................................ 143
Protección de memoria ...................................................................................... 143
Estructura de la tabla de páginas ........................................................................ 144
I. Jerárquica ..................................................................................................... 144
II. Diccionario/Hash ......................................................................................... 145
III. Tabla invertida ........................................................................................... 145
Páginas compartidas ........................................................................................... 146
8.2.4 Segmentación.......................................................................................................... 146
Protección de memoria ...................................................................................... 148
Segmentos compartidos ..................................................................................... 149
4
8.2.5 Combinación Paginación - Segmentación ............................................................... 150

8.3 Consideraciones frente a estrategias de gestión de memoria .............................................. 151
9 Memoria Virtual ...................................................................................................... 152
9.1 Paginación bajo demanda ..................................................................................................... 152
Rendimiento de la paginación bajo demanda .............................................................. 155
9.2 Copia durante escritura ......................................................................................................... 155
9.3 Reemplazo de páginas ........................................................................................................... 156
Algoritmos de reemplazo ............................................................................................. 158
I. FIFO .................................................................................................................... 158
II. Second Chance ................................................................................................... 159
III. Optimal ............................................................................................................... 160
IV. Not Recently Used (NRU) ................................................................................... 160
V. Least Recently Used (LRU) .................................................................................. 161
9.4 Estrategia de asignación de frames ....................................................................................... 162
9.5 Hiperpaginación - Trashing .................................................................................................... 163
Modelo Working Set ..................................................................................................... 163
Modelo Page-Fault Frequently ..................................................................................... 164
10 Sistema de archivos ................................................................................................. 164
10.1 Concepto de archivo ............................................................................................................. 165
10.1.1 Atributos de un archivo ............................................................................................ 165
10.1.2 Operaciones sobre archivos ..................................................................................... 166
10.1.3 Tipos de archivos ...................................................................................................... 167
10.1.4 Estructura externa del sistema de archivos .............................................................. 167
10.1.5 Estructura interna del sistema de archivos .............................................................. 168
10.1.6 Métodos de acceso a un archivo .............................................................................. 168
10.2 Concepto de directorio ......................................................................................................... 169
10.2.1 Operaciones sobre directorios ................................................................................. 169
10.2.2 Estructura de directorios .......................................................................................... 170
I. Único nivel: .......................................................................................................... 170
II. Dos niveles: ......................................................................................................... 170
III. Árbol: ................................................................................................................... 171
IV. Grafo: .................................................................................................................. 172
10.3 Protección del sistema de archivos ....................................................................................... 173
10.4 Implementación del sistema de archivos .............................................................................. 174
10.4.1 Montaje de un sistema de archivos ......................................................................... 176
10.4.2 Sistemas de archivos virtual (VFS – Virtual File System)........................................... 177
10.4.3 Métodos de asignación ............................................................................................. 177
I. Asignación Contigua (Contiguous Allocation): ................................................... 177
II. Asignación Enlazada (Linked Allocation): ........................................................... 178
III. Asignación Indizada (Indexed Allocation): ......................................................... 180
10.4.4 Administración del espacio libre .............................................................................. 182
10.5 i-Nodo – UNIX ....................................................................................................................... 182
10.6 FAT – Windows...................................................................................................................... 188
11 Estructura de los dispositivos masivos de datos ........................................................ 197
11.1 Planificador de disco ............................................................................................................. 199
11.2 Algoritmos de planificación de disco..................................................................................... 200
I. First Come First Served (FCFS) ..................................................................................... 200
II. Shortest Seek First Time (SSTF) .................................................................................... 200
III. SCAN / C-SCAN ............................................................................................................. 201
IV. LOOK / C-LOOK............................................................................................................. 201
11.3 Selección de los algoritmos de planificación de disco .......................................................... 202
11.4 Formateo del disco ................................................................................................................ 203
11.5 Sector de arranque - Boot ..................................................................................................... 204
5
11.6 Estructuras RAID.................................................................................................................... 204

Niveles RAID ................................................................................................................. 205
I. RAID 0 ................................................................................................................. 206
II. RAID 1 ................................................................................................................. 206
III. RAID 2 ................................................................................................................. 206
IV. RAID 3 ................................................................................................................. 207
V. RAID 4 ................................................................................................................. 208
VI. RAID 5 ................................................................................................................. 208
VII. RAID 6 ................................................................................................................. 209
VIII. Combinaciones de RAIDs ................................................................................... 209
RAID 0+1 ...................................................................................................... 209
RAID 1+0 ...................................................................................................... 210
Selección de un nivel RAID ........................................................................................... 210
12 Sistema de E/S ......................................................................................................... 211
12.1 Operaciones de E/S ............................................................................................................... 212
I. E/S Programada (Programmed I/O) ............................................................................. 212
II. Interrupciones (Interrupt- Driven I/O) ......................................................................... 213
III. Acceso Directo a Memoria (Direct Access Memory) ................................................... 215
12.2 Interfaz de E/S de las aplicaciones ........................................................................................ 216
12.3 Subsistema de E/S del kernel – Servicios del SO sobre E/S ................................................... 217
I. I/O Scheduling .............................................................................................................. 217
II. Buffering (Uso de buffers) ........................................................................................... 218
III. Caching (Uso de chaches) ............................................................................................ 218
IV. Spooling (Uso de SPOOL) ............................................................................................. 218
V. Error Handling (Manejo de Errores) ............................................................................. 218
VI. I/O Protection (Protección de E/S)............................................................................... 219
13 Protección & Seguridad............................................................................................ 220
13.1 Protección ............................................................................................................................. 220
13.1.1 Objetivos ................................................................................................................... 220
13.1.2 Principios de la protección ....................................................................................... 221
13.1.3 Dominios de protección............................................................................................ 221
13.1.4 Estructuras de dominio de protección ..................................................................... 221
13.1.5 Ejemplos donde se determinan dominios de protección ......................................... 222
Modo Dual .......................................................................................................... 222
UNIX .................................................................................................................... 223
MULTICS .............................................................................................................. 223
13.1.6 Matriz de acceso ....................................................................................................... 224
Conmutación ..................................................................................................... 2243
Copia ................................................................................................................... 225
Implementación .................................................................................................. 225
I. Tabla global .................................................................................................. 226
II. Lista de acceso para objetos ....................................................................... 226
III. Lista de capacidades para dominios .......................................................... 226
IV. Cerradura y llave ........................................................................................ 227
Comparación de las implementaciones .............................................................. 227
13.1.7 Protección basada en el lenguaje ............................................................................. 227
13.1.8 Revocación de derechos de acceso .......................................................................... 228
13.2 Seguridad .............................................................................................................................. 230
13.2.1 Amenazas relacionadas con programas ................................................................... 232
13.2.2 Técnicas para mejorar la seguridad ante amenazas ................................................. 232
I. Monitorización ................................................................................................... 233
II. Criptografía ......................................................................................................... 234
Algoritmo RSA: .............................................................................................. 235
6
13.2.3 Autenticación de usuario .......................................................................................... 236

Contraseñas personales .................................................................................... 236
Contraseñas cifradas ......................................................................................... 236
Contraseñas de un solo uso .............................................................................. 237
13.2.4 DAC vs MAC .............................................................................................................. 237
13.2.5 Clasificación de seguridad de los computadores ...................................................... 237
I. Nivel D – Seguridad mínima ............................................................................... 238
II. Nivel C – Seguridad Discrecional ........................................................................ 238
Nivel C1 – Protección por Seguridad Discrecional ....................................... 238
Nivel C2 – Protección por Acceso Controlado .............................................. 238
III. Nivel B – Seguridad Obligatoria .......................................................................... 238
Nivel B1 – Protección por Seguridad Etiquetada ......................................... 238
Nivel B2 – Protección Estructurada ............................................................. 239
Nivel B3 – Dominios de Seguridad ............................................................... 239
IV. Nivel A – Seguridad Alta ..................................................................................... 239
14 Virtualización .......................................................................................................... 240
Virtualización de CPU ...................................................................................................................... 241
I. Hypervisor tipo I - Unhosted ........................................................................................ 241
II. Hypervisor tipo II - Hosted ........................................................................................... 242
III. Paravirtualización ........................................................................................................ 243
IV. Emulación de plataforma ............................................................................................. 243
Virtualización de aplicaciones ......................................................................................................... 243
Virtualización de la memoria .......................................................................................................... 244
Virtualización de E/S ....................................................................................................................... 244
Ventajas de la virtualización ........................................................................................................... 244
Bibliografía ..................................................................................................................... 245
Práctico - Letra & Resolución – En clase ............................................................................ 246
Práctico 2 – Ejercicio 10 .................................................................................................................. 246
Práctico 4 – Ejercicio 4 .................................................................................................................... 253
Preguntas teóricas ........................................................................................................... 269
1º Parcial ......................................................................................................................................... 269
May 2012 ............................................................................................................................... 269
May 2013 ............................................................................................................................... 270
2º Parcial ......................................................................................................................................... 272
Jul 2012.................................................................................................................................. 272
Jul 2013.................................................................................................................................. 273
Exámenes ........................................................................................................................................ 276
Feb 2010 ................................................................................................................................ 276
Mar 2010 ............................................................................................................................... 280
Jul 2010.................................................................................................................................. 283
Dic 2010 ................................................................................................................................. 285
Feb 2011 ................................................................................................................................ 287
Mar 2011 ............................................................................................................................... 290
7
Jul 2011.................................................................................................................................. 292

Dic 2011 ................................................................................................................................. 294
Feb 2012 ................................................................................................................................ 295
Mar 2012 ............................................................................................................................... 297
Jul 2012.................................................................................................................................. 299
Dic 2012 ................................................................................................................................. 300
Feb 2013 ................................................................................................................................ 302
Mar 2013 ............................................................................................................................... 303
Jul 2013.................................................................................................................................. 305
Dic 2013 ................................................................................................................................. 308
Feb 2014 ................................................................................................................................ 311
Mar 2014 ............................................................................................................................... 312
8
1 Introducción
Los componentes de un Sistema Informático podemos distribuirlo como
se muestra en el siguiente esquema:
Un Sistema Operativo (SO) es un programa que actúa como

intermediario entre las aplicaciones de usuario y el hardware. También
podemos decir que el SO es un programa individual que está siempre cargado
en memoria, denominado Núcleo del Sistema (Kernel).
Objetivos del SO:
- Comodidad: Facilitar a los programadores la complejidad del hardware.

- Eficiencia: Aprovechar al máximo el hardware disponible.
Tareas del SO:
- Brindar un ambiente donde ejecutar los programas de usuario de forma

amigable, intuitiva y expresiva.
- Administrar en forma equitativa el hardware y el software.
- Promover un entorno sin interferencia para cada usuario.
A medida que los SO se encontraban con obstáculos, se dio pie a nuevos

dispositivos de hardware que lo solucionaran, dando lugar así a nuevas
Arquitecturas.
9
2 Evolución histórica de los Sistemas Operativos

2.1 Sistemas por lotes sencillos (Batch) [‘70]
Antiguamente los ordenadores eran grandes y costosos.
Los dispositivos de entrada eran lectores de tarjetas y los de salida
impresoras de línea o perforadores de tarjetas, provocando la casi
nula interacción con el usuario. En este
caso, el SO procesa las tareas de a una, y
son agrupados en batches (conjuntos de
trabajos o lotes) apuntando a la
optimización del trabajo dado al
computador.
2.2 Sistemas por lotes multiprogramados [‘80]

La introducción de la tecnología de discos magnéticos fue útil pues
proporcionan memoria no volátil que permiten
guardar una secuencia de trabajos a ser
ejecutados, comportándose como una especie de
buffer(1). De esta forma la CPU se mantiene
procesando continuamente sin esperar por
entradas o salidas. Ésta técnica es llamada
SPOOL (Simultaneous Peripheral Operation On-
line)(2).
Al escoger un trabajo en memoria,

en un sistema sin multiprogramación, éste
debe que esperar a que se complete cierta
acción (por ejemplo terminar una operación
E/S) dejando la CPU ociosa. En sistema
multiprogramado, el sistema selecciona
otro trabajo y lo ejecuta. En algún momento
el primer trabajo termina su espera y
recupera la CPU.
1
SPOOLER: Buffer donde se guardan datos a la espera de su procesamiento por parte de un dispositivo
más lento.
2
Proceso mediante el cual se introducen trabajos en un buffer de manera que un dispositivo pueda
acceder a ellos cuando esté listo.
10
2.3 Sistemas de tiempo compartido [‘80]

Los sistemas por lotes tienen el problema de
que el usuario no puede interactuar con el trabajo
durante su ejecución. En un sistema de tiempo
compartido se ejecutan múltiples trabajos mientras la
CPU conmuta entre ellos, la cual se efectúa a un
ritmo humano, limitadas por la velocidad de
respuesta del usuario, la cual es lenta para la CPU.
La conmutación es tan frecuente que los usuarios
pueden interactuar con cada programa durante su
ejecución, dando la impresión de que cada usuario
tiene su propio CPU.
Para que los usuarios accedan con comodidad a los datos, deben contar con
un sistema de archivos controlados por el SO. Éstos se organizan en directorios,
facilitando su localización y acceso.
Cada usuario tiene por lo menos un programa individual en la memoria

(conocido como proceso) dando lugar a algoritmos de Planificación (Scheduling) para
garantizar una repartición equitativa del procesador.
Al igual que los sistemas por lotes multiprogramados, se necesita mantener

varios trabajos simultáneamente en la memoria, por lo que requiere gestión y
protección de memoria. El disco funciona como memoria virtual, permitiendo ejecutar
trabajos que no caben en la memoria principal.
2.4 Sistemas de computador personal [‘80]

Con la caída de costos de hardware, se volvió factible tener un sistema
dedicado a un solo usuario. En lugar de tratar de aprovechar al máximo la CPU, optan
por maximizar la comodidad del usuario, y la rapidez con la que responden a sus
necesidades. Aunque aparentemente, la protección de archivos no es necesaria en las
PC, es común que las PCs se vinculen con otros a través de Internet, siendo
propensas a los programas mal intencionados como virus y gusanos. En resumen, las
características de los SO para macrocomputadoras, se fueron ajustando a los
computadores personales.
11
2.5 Sistemas paralelos [‘90]

Estos sistemas, también conocidos como sistemas multiprocesadores, tienen
más de un procesador que permiten la ejecución simultánea y sincronizada de varios
procesos.
Cuando usamos n-procesadores, esperamos un aumento de n en rendimiento

o velocidad, pero no es así, es menor que n, porque deben compartir los recursos.
Ventajas:
- Confiabilidad del procesador, ya que si uno falla, no se detiene el sistema,

sino que los demás se encargan de procesar.
- Tolerancia a fallos, teniendo un mecanismo de detección y corrección de
errores.
Encontramos cuatro tipos de clasificaciones de los sistemas

paralelos/multiprocesadores:
1. Según cómo ejecutan los procesos, se dividen en dos:
- Simétricos (SMP): Cada procesador realiza todas las tareas

correspondientes al SO.
- Asimétrico: asignan a cada procesador una tarea específica. Existe un

procesador maestro que planifica el trabajo de los procesadores esclavos y
se lo asigna. Es necesario controlar cuidadosamente la E/S, para asegurar
que los datos lleguen al procesador apropiado.
2. Según cómo se comunican, se dividen en dos grupos:
- Altamente Integrados (tightly coupled): los canales de comunicación entre

los procesadores son rápidos (a través de un bus común).
- Levemente Integrados (loosely coupled): los canales de comunicación

entre los procesadores son lentos (a través de una red)
12
3. Según la Taxonomía de Flynn3, se divide en cuatro grupos,

diferenciándose entre sí por la cantidad de instrucciones paralelas y los flujos
de datos disponibles. En las imágenes mostradas, cada PU (processing unit) es
una unidad de procesamiento.
- SISD (Single Instruction – Single Data): Se ejecuta una instrucción en cada

momento, no hay paralelismo.
- SIMD (Single Instruction – Multiple Data): Se ejecuta una instrucción sobre

distintos conjuntos de datos simultáneamente.
- MISD (Multiple Instruction – Single Data): Se utiliza para agregar

paralelismo redundante.
3
En función de cuántas instrucciones se ejecutan en simultáneo y sobre qué datos.
13
- MIMD (Multiple Instruction – Multiple Data): Se ejecutan distintas

instrucciones en paralelo sobre distintos conjuntos de datos.
Dentro de esta clasificación existen dos variantes:
 Sistemas de memoria compartida: Los procesadores se

encuentran en un único nodo altamente integrado (todos comparten
el bus que los conecta con la memoria).
 Sistemas de memoria distribuida: Los procesadores se

encuentran en nodos independientes (cada uno con su memoria) y
están conectados a través de redes.
14
4. Según el costo con que los procesadores acceden a memoria,

encontrando dos clasificaciones:
- UMA (Uniform Memory Access): Cada procesador accede a cualquier lugar

de la memoria con el mismo costo en cuanto a tiempo.
- NUMA (Non Uniform Memory Access): Los procesadores tienen un

conjunto de lugares de memoria a los cuales acceden más rápidamente
que a otros.
2.6 Sistemas distribuidos [‘90]

Tenemos una colección de computadoras físicamente separadas que están
conectadas en red para proporcionar a los usuarios acceso a los diversos recursos
que el sistema mantiene. Se distribuye el cómputo entre varios procesadores que no
comparten ni la memoria ni el reloj, donde cada procesador tiene su propia memoria
local y se comunican entre sí por un bus.
2.7 Sistemas Cluster [‘00]

Son sistemas donde existen varios nodos
fuertemente conectados, denominados clausters
(del inglés “grupo”), que trabajan juntos como una
única computadora. Su finalidad es proveer alta
disponibilidad y poder distribuir la carga entre sí.
Los nodos se comunican para monitorear el
estado de los demás.
Los sistemas Cluster se clasifican en:
 Simétricos [Activo-Activo]: Todos los nodos ejecutan tareas y asumen las

de otros ante fallas.
 Asimétricos [Activo-Pasivo]: Los nodos se dividen en dos grupos, los
activos, que ejecutan las tareas, y los pasivos, que no realizan tareas hasta
que suplen la falla de uno de los nodos activos.
2.8 Sistemas de tiempo real [‘00]

Se utiliza cuando los requisitos de tiempo para una operación son estrictos,
tiene restricciones de tiempo bien definidas. En otras palabras, todo resultado debe
producirse en un cierto tiempo, de lo contrario el sistema falla.
Existen dos variantes:
 Hard Real Time: Las tareas críticas se deben terminar a tiempo. Todos los
retardos del sistema están limitados, por lo tanto los datos se deben
guardar en memoria rápida como ROM, además carecen de la mayor parte
de las funciones avanzadas de los SO, como por ejemplo, memoria virtual.
 Soft Real Time: Una tarea crítica tiene prioridad respecto a otras, y se
deben evitar los retardos, pero no apoyan el cumplimiento estricto de
plazos.
15
2.9 Sistemas Multimedia

En estos sistemas es necesario que cierto contenido multimedia (audio y/o
video) sea entregado al usuario dentro de cierto margen temporal.
2.10 Sistemas de mano (Handheld)

Se especializan en entregar un conjunto importante de prestaciones al usuario
contando con recursos de hardware muy limitados (poca memoria, pantalla reducida,
limitación de batería, etc).
2.11 Sistemas Interactivos

Provee una comunicación en línea entre el usuario y el sistema, donde el
usuario da instrucciones al sistema o a las aplicaciones, y recibe una respuesta a la
misma.
16
3 Estructura de los Sistemas Informáticos

Esta sección pretende ser un adelanto de lo que serán las siguientes
secciones, dando los conceptos básicos a conocer para poder comprenderlas luego.
El SO debe asegurar el correcto funcionamiento del sistema informático. El

hardware debe contar con los mecanismos para que los programas de usuario no
interfieran con la operación correcta del sistema.
3.1 Componentes Básicos

Un sistema de computación se distribuye de la siguiente forma:
Se distribuye en tres componentes o subsistemas básicos detallados a

continuación.
3.1.1 CPU (Central Process Unit)

Encargada de ejecutar las instrucciones de los programas. Lo hace por medio
de un ciclo de instrucciones (básicamente fetch, decode, excecute) donde en algunos
casos se aumenta su performance ejecutando estas instrucciones en paralelo, técnica
conocida como pipieline.
Existen varias arquitecturas de procesadores, se clasifican en RISC (Reduced

Instruction Set Computer) y CISC (Complex Instruction Set Computer).
Dentro de estas instrucciones se distingue un conjunto de instrucciones

privilegiadas (acceso a la E/S, protección de memoria, y memoria virtual), que
solamente deberán ser ejecutadas por el SO. Un protocolo seguro para aumentar el
nivel de ejecución que se basa en siempre transferir el control a código autenticado
(trusted) para aumentar el nivel de ejecución.
17
3.1.2 I/O (Entrada/Salida)

Se componen de dos partes, dispositivo y controlador(4). El SO debe
implementar componentes de software (device drivers) para comunicarse con todas
las interfaces generadas por estos controladores.
Los device drivers son cargados de diferentes formas:
 Precargados en el núcleo del sistema.

 Se cargan al iniciar el SO mediante un archivo de configuración.
 Instalados manualmente
La CPU y los controladores de dispositivos funcionan de manera concurrente,

compitiendo por los ciclos de memoria, utilizando un controlador de memoria para
sincronizar el acceso.
Los controladores tienen un conjunto de registros utilizados en la comunicación

con el SO a través del driver. Para acceder a estos registros existen dos alternativas:
o Memory Mapped IO: El acceso a estos registros se realiza accediendo a

direcciones especiales de la memoria principal. Para escribir en estas
direcciones se utilizan las mismas instrucciones que para un acceso normal a
la memoria.
 Ventaja: No necesita instrucciones especiales
 Desventaja: Se necesita proteger el área de memoria destinada a la
E/S de los procesos de usuario contra el acceso no autorizado.
o Direct IO Instruction: Existen instrucciones especificas (que estarán dentro

del grupo de instrucciones privilegiadas, generalmente IN/OUT) para acceder a
la información de los dispositivos, los que son asignados a una dirección de
puerto (IO port adress).
 Ventaja: No consume espacio de la memoria principal
 Desventaja: Las instrucciones de E/S deben ser privilegiadas.
Para realizar una operación de E/S, podemos encontrarnos con varios

métodos. En términos de “cuál es mejor”, en orden de menos a más, encontramos:
o Consulta (Polling): El procesador realiza un pedido y queda en busy wating

esperando una respuesta, consultando si está listo el pedido. Tiene como
desventaja que consume ciclo de la CPU esperando.
o Interrupciones (Interrupts): El procesador envía el pedido y se libera para

realizar otras tareas hasta ser interrumpido por el controlador indicando que
este terminó el pedido.
o Acceso directo a memoria (DMA): Los dispositivos escriben directamente en

la memoria principal sin la intervención del procesador por medio de un
dispositivo de hardware especial, el DMA. Generan una interrupción cuando se
termino de escribir en la memoria.
4
Parte del dispositivo (o periférico) que contiene su inteligencia, y por tanto lo controla.
18
Los SO modernos son controlados por interrupciones, ya que el SO espera,

hasta que suceda algo. Se cuenta con una rutina de servicio para cada una de las
interrupciones, cargada en el llamado vector de interrupciones, y la rutina es
identificada por un número de dispositivo único, incluido en la solicitud de la
interrupción, la cual se encarga de atenderla.
El hardware, puede generar una interrupción en cualquier momento, enviando

una señal a la CPU, a través del bus. El software solo puede hacerlo ejecutando una
función especial denominada “llamada al sistema” (SystemCall). Una trap (excepción)
es una interrupción generada por software en forma sincrónica (controlada), indicando
un error o la solicitud de un servicio del SO por parte de un programa. Cuando ocurre
una excepción, se transfiere el control al SO, el SO guarda el contexto, y atiende la
interrupción.
3.1.3 Memoria
El sistema de memoria está construido en base a una jerarquía que permite
optimizar la utilización del procesador, tal y como muestra la siguiente imagen:
Detallando cada nivel:
o REGISTROS: Se encuentran físicamente ubicados en la CPU, y son las

memorias más rápidas.
o CACHE: Su principal función es mantener copias de la memoria principal, de

forma de acceder en forma rápida a los datos (aprovechando el Principio de
19
Localidad(5)). El tamaño de la caché y sus políticas de reemplazo generan un

alto impacto en la performance del sistema. Trae aparejado un problema con
nombre propio: Coherencia de caché. Es un problema de hardware y consiste
básicamente en mantener una consistencia de los datos. Si leo un archivo A,
hago una copia en el caché, y luego en un registro interno. Si lo modifico, el
valor de A va a variar en los distintos lugares donde se encuentra, y será igual
en todos los lugares luego de que lo vuelva a guardar en el disco. En un
sistema monoprocesador esto no causa problemas, en cambio si los hay en
uno multiprocesador en el que además de mantener registros internos, la CPU
cuenta también con un caché local. De esta forma podría haber una copia de A
en varios cachés simultáneamente, y como pueden trabajar concurrentemente,
es preciso asegurarse de actualizar el valor de A en todos los cachés, de forma
que no genere información falsa.
o MEMORIA PRINCIPAL: Es del tipo volátil y de mayor capacidad que una

caché.
o MEMORIA SECUNDARIA: Se utiliza como medio de almacenamiento masivo

pues no es volátil. A diferencia de las memorias de mayor jerarquía, ésta tiene
componentes mecánicas.
Consta de:
- Platos de metal que giran a alta velocidad

- Brazo mecánico que contiene cabezales de Lectura/Escritura para cada
plato.
5
Establece que los programas acceden a una porción reducida del espacio de memoria. Para ello realiza
copias de las posiciones más accedidas (Principio de Localidad Temporal) y bloques contiguos a él
(Principio de Localidad Espacial)
20
La superficie de los platos se divide en:
- Pistas circulares.
- Sectores por cada pista.
- Cilindros, el conjunto de todas las pistas (de todos los platos) que están
en una posición del brazo mecánico.
Existen distintos tipos de buses de conexión, cada uno con su protocolo de

comunicación. Entre ellos:
- IDE (Integrated Drive Electronics)

- ATA (Advance Technology Attachment)
- SATA (Serial Advance Technology Attachment)
- SCSI (Small Computer-System Interface)
- SAS (Serial Attached SCSI)
o MEMORIA TERCIARIA: Se utiliza como almacenamiento externo.
Para que un computador comience a funcionar necesita tener un programa

inicial que ejecutar. Este programa de arranque, suele ser sencillo y está cargado en
memoria ROM; asigna valores iniciales a todos los aspectos del sistema, desde los
registros de la CPU, hasta los controladores de dispositivos y la memoria. Luego carga
en memoria el Kernel, a fin de comenzar la ejecución del SO.
3.2 Protección por Hardware

Los primeros sistemas eran monousuario, operados por el programador, el cual
tenía control total sobre el sistema. A medida que se fueron desarrollando los SO, se
les comenzó a transferir el control del sistema, desempeñando principalmente las
actividades de E/S.
El SO para mejorar el aprovechamiento de la CPU, comenzó a compartir los

recursos del sistema entre varios programas concurrentemente. Cuando el sistema se
ejecutaba sin compartir, un error en el programa podía causar problemas solo sobre él
mismo. Sin embargo, al compartir, muchos procesos pueden verse afectados por ese
error. Para ello se debió introducir protección entre los distintos procesos que
ejecutaban en un sistema.
3.2.1 Operación en Modo Dual

Se requiere protección para cualquier recurso compartido. Para ello el
hardware debe distinguir como mínimo entre dos modos de ejecución:
 User Mode: en este modo se pueden ejecutar un conjunto muy reducido de

instrucciones de hardware. Todo usuario tiene derecho a ejecutar en este
modo.
21
 Monitor Mode: en este modo todas las instrucciones de hardware están

disponibles, inclusive las privilegiadas. Solo el SO puede ejecutar en este
modo.
Esto es implementado en hardware por medio de un bit, llamado MODE BIT,

para indicar en qué modo se está ejecutando.
3.2.2 Protección de E/S

Dado que todas las instrucciones de E/S son privilegiadas, solo se acceden en
modo monitor, lo que garantiza que los procesos a nivel usuario no accedan
directamente a los dispositivos de E/S. Si se intenta ejecutar una en modo usuario, el
hardware la detecta, efectúa una interrupción y pasa el control al SO.
3.2.3 Protección de Memoria

Si se accediera a la memoria indistintamente, particularmente se podría
acceder al vector de interrupciones y alterar la dirección de la interrupción que genera
el hardware, asumiendo el control del computador en modo monitor. Para que esto no
ocurra se debe proteger la memoria.
Podemos separar el espacio de memoria de cada programa, determinando el

espacio de direcciones al cual el programa puede acceder y proteger el resto de la
memoria que no está en ese espacio.
El rango de memoria privilegiada se almacena dos en registros y se efectúa trap

si cualquier programa en modo usuario intenta acceder a esa zona de memoria. Los
registros de control son:
 Registro base: Contiene la dirección de memoria física válida más

pequeña.
 Registro límite: Contiene el tamaño del intervalo.
El hardware de la CPU compara todas las direcciones generadas por el usuario

con estos registros, pasando el control al SO si se produce algún error. El SO tiene
22
acceso irrestricto a la memoria, pudiendo cargar los programas de usuario en

cualquier lado y pudiendo expulsar esos programas en caso de error.
La unidad que convierte direcciones lógicas a físicas es la MMU (Memory

Management Unit) y es la que controla el acceso a memoria. La MMU solamente debe
ser administrada en modo monitor (por el SO), por ejemplo al cargar los registros base
y límite.
3.2.4 Protección de CPU

Debemos impedir que un programa de entre en loop infinito y nunca devuelva
el control al SO. Para ello existe un timer que interrumpe al computador después de un
período determinado y cede el control al SO que puede cerrar el programa o cederle
más tiempo.
Las instrucciones que modifican el funcionamiento del timer deben ser

privilegiadas. Otra implementación de los timers es para sistemas de tiempo
compartido, dándole un tiempo determinado para los programas de cada usuario.
3.2.5 Conclusiones
En el momento de arrancar el sistema, el hardware inicia en modo monitor,
luego se carga el SO inicializando los componentes necesarios y se pasa a modo
usuario.
Dado que las instrucciones de E/S son privilegiadas, y solo el SO puede

ejecutarlas, los programas de usuario, deben hacer un pedido al SO para que realice
la E/S en su nombre. Esta solicitud recibe el nombre de system call. El hardware trata
esta interrupción como una trap, y pasa al modo monitor, entregándole el control al
SO. Si la solicitud es válida, el SO efectúa la E/S solicitada y devuelve el control al
usuario (pasando nuevamente a modo usuario).
Otra instrucción como halt (detener la CPU) es privilegiada, ya que un

programa de usuario no debe parar el computador. Las instrucciones para activar y
desactivar el sistema de interrupciones también son privilegiadas, al igual que la
instrucción que cambia del modo usuario al modo monitor. Al ser privilegiadas, solo las
realiza el SO.
23
3.3 Estructura de los Sistemas Operativos

Un SO crea el entorno en el que se ejecutan los programas. Los SO se pueden
estudiar examinando los servicios que proporciona y analizando la interfaz con
usuarios y programadores, o bien se puede hacer desglosándolo en sus componentes
y viendo las interconexiones. Dada su complejidad, un SO debe ser modularizado en
varios componentes, detallados a continuación.
3.3.1 Administración de Procesos

Un proceso es una porción de programa en ejecución, el cual necesita tiempo
de la CPU, memoria, archivos y dispositivos E/S. Esos recursos se le otorgan cuando
se crea o en el momento de ejecución.
Un programa es una entidad pasiva, en cambio un proceso es una entidad

activa.
La ejecución de un proceso se debe realizar en secuencia, ejecutando una

instrucción tras otra hasta que el proceso termina. Dos procesos asociados al mismo
programa se consideran como dos secuencias de ejecución individuales. Además, en
un instante dado, se ejecuta como máximo una instrucción del proceso.
Un proceso es la unidad de trabajo de un sistema. El sistema consiste en una

colección de procesos de dos tipos:
 Del SO: Ejecutan código del sistema

 Del usuario: Ejecutan código del usuario
Todos estos procesos se pueden ejecutar de forma concurrente, multiplexando

la CPU entre ellos.
El SO respecto a gestión de procesos se encarga de:
- Crear y eliminar procesos, tanto de usuario como del propio SO

- Suspender y reanudar procesos
- Proveer mecanismos para sincronizar procesos
- Proveer mecanismos para comunicar procesos
- Proveer mecanismos para manejar bloqueos mutuos (deadlocks)
3.3.2 Administración de Memoria

La memoria principal es una matriz de palabras o bytes, que contiene datos a
los cuales se puede acceder rápidamente y son compartidos por la CPU y los
dispositivos E/S.
Es el único dispositivo de almacenamiento grande que la CPU puede

direccionar y acceder directamente.
Para ejecutar un programa, es preciso cargarlo en memoria previamente. Hay

muchos esquemas de gestión de memoria, que dependen principalmente del
hardware.
24
El SO se encarga de:
- Saber que partes de la memoria se están usando, y quien las usa.

- Decidir que procesos cargar en memoria cuando se disponga de
espacio
- Asignar y liberar memoria según se necesite
3.3.3 Subsistema de E/S

El SO deberá encapsular y ocular las características específicas de los
diferentes dispositivos de hardware para que el usuario no las perciba. Solo el driver
del dispositivo conoce las peculiaridades, y el SO proporciona una interfaz general con
los controladores de dispositivos. De esta forma, sin importar cuál sea el dispositivo,
siempre tengo un servicio que lo habilita.
Para ello se provee de:
- Conjunto de servicios a modo de interfaz con el subsistema que

implementen técnias de caché, buffering y spooling.
- Una interfaz cliente con el SO para los manejadores de dispositivos
(device drivers) que permita interactuar con cualquier modelo de
dispositivo.
- Device drivers específicos.
- Montaje y desmontaje de dispositivos.
3.3.4 Administración de Memoria Secundaria

Como la memoria principal es pequeña y volátil, para dar lugar a todos los
datos y programas el almacenamiento secundario debe respaldar la memoria principal.
Casi todos los programas se guardan en un disco hasta que se cargan en

memoria, por eso es importante una correcta administración del almacenamiento.
- Administración de espacio libre

- Asignación del almacenamiento
- Planificación del disco
El almacenamiento secundario es frecuente así que su uso debe ser eficiente.

La velocidad del computador podría depender del subsistema de disco y los algoritmos
que lo manipulan.
3.3.5 Subsistema de Archivos

Los sistemas almacenan información en medios físicos como cintas o discos,
los cuales tienen sus propias características y organización, y son controlados por un
dispositivo.
El SO define una perspectiva lógica de almacenamiento, independiente del

dispositivo (abstrayendo el hardware), el archivo. Pero debe establecer una
correspondencia entre el archivo y el medio físico. Los archivos normalmente se
25
organizan en directorios para facilitar su uso, y si pueden ser accedidos por varios
usuarios a la vez el SO debe llevar un control.
- Crear y eliminar archivos

- Crear y eliminar directorios
- Proveer las primitivas de manipulación de archivos y directorios
- Establecer la correspondencia de archivos con el almacenamiento
secundario
- Resguardarlos en un medio de almacenamiento no volátil
3.3.6 Subsistema de Red

En una red, hay una colección de procesadores que no comparten memoria, ni
periféricos, ni reloj. Se comunican a través de una red de comunicaciones (sistema
distribuido).
La red puede estar total o parcialmente conectada, y su diseño debe

considerar los problemas de contención y seguridad.
El acceso a los recursos compartidos, permite acelerar cálculos, y los SO

gestionan esa red.
3.3.7 Sistema de Protección

Si un SO tiene múltiples usuarios, y permite la ejecución concurrente de
procesos, debe proteger cada proceso de las actividades de los demás.
Debe asegurar que solo aquellos procesos que obtuvieron autorización debida
del SO puedan operar con archivos, memoria, CPU o demás recursos. Esto se hace
mediante mecanismos por los que se controla el acceso de los procesos a los
recursos, debiendo incorporar reglas de acceso y asegurar su verificación.
3.4 Servicio del Sistema Operativo

El SO proporciona servicios a los programas y a los usuarios de esos
programas. Estos varían de un SO a otro, pero hay clases comunes.
 Interfaz de usuario (UI): Proporciona un mecanismo para que el usuario

ejecute una solicitud sin escribir un programa. Se presenta en dos
variantes:
 Línea de comandos (CLI – Command Line Interface): Utiliza

comandos de texto. Pueden ser implementados de dos formas:
o El propio intérprete contiene el código que el comando tiene que

ejecutar
26
o Se realiza a través de una serie de programas del sistema,

cargando en memoria el archivo pertinente y ejecutándolo.
En los sistemas que disponen de varios intérpretes de comandos

entre los que elegir, los intérpretes se conocen como Shell (por
ejemplo shell MS-DOS (Window), shell Bourne, shell Korn, shell C
(en UNIX y Linux)).
 Interfaz de comandos por lotes: Los comandos se introducen en

archivos. Habitualmente se utiliza una interfaz gráfica de usuario
(GUI – Graphic User Interface) por medio de un sistema de
ventanas.
 Ejecución de programas: El sistema debe poder cargar un programa en la

memoria y ejecutarlo. El programa debe poder terminar su ejecución,
normal o anormalmente (indicando el error).
 Operaciones de E/S: Un programa en ejecución podría requerir E/S,

implicando el uso de un archivo o dispositivo E/S. Por cuestiones de
seguridad y eficiencia, los usuarios casi nunca pueden controlar los
dispositivos de E/S directamente, por lo tanto el sistema debe incluir un
mecanismo para realizarlo.
 Manipulación del sistema de archivos: Los programas necesitan leer,

escribir, buscar, crear y eliminar archivos.
 Comunicaciones entre procesos: Los procesos necesitan intercambiar

información con otro. Puede hacerse usando memoria compartida o
transfiriendo mensajes, y hay dos formas de comunicación:
- Ocurre entre procesos que se ejecutan en el mismo computador.

- Implica procesos que se ejecutan en computadores distintos conectados
en una red.
 Detección de errores: Pueden ocurrir errores en el hardware, en los

dispositivos E/S o en programas de usuario. Para cada tipo de error, el SO
debe emprender la acción apropiada para asegurar un funcionamiento
correcto y consistente del sistema de computación.
Hay otro grupo de funciones que aseguran el funcionamiento eficiente del

sistema:
 Asignación de recursos: Si hay varios usuarios o varios trabajos

ejecutándose al mismo tiempo, es preciso asignar recursos a cada uno.
Algunos tienen código de asignación especial, como memoria principal y
almacenamiento de archivos. Otros tienen código de solicitud y liberación
mucho más general, como los dispositivos de E/S.
 Contabilización: Es importante saber que usuarios están usando recursos,

cuantos recursos usan, y de qué tipo.
 Protección: Los dueños de una información quieren controlar su uso. Se

asegura que todos los accesos a los recursos del sistema sean
27
controlados, para ello se obliga a que cada usuario del sistema deba
identificarse, por lo general con una contraseña, antes de poder acceder a
los recursos. Esto sirve para defender los dispositivos de E/S externos
contra intentos de acceso no autorizado, y registrar todas las conexiones.
3.5 Llamadas al Sistema

Son la interfaz provista por el kernel para que los procesos a nivel usuario
puedan acceder a los diferentes servicios que brinda el SO.
En sus comienzo los system calls estaban programados en lenguaje

ensamblador, actualmente están programados en lenguajes de alto nivel (como C y
C++). De esta forma, los programas de usuario tienen un acceso más directo a los
servicios.
Estos servicios son invocados por los procesos en modo usuario, cuando
ejecutan lo hacen en modo monitor, y al retornar se vuelven al modo usuario.
Existen 3 formas de pasar los parámetros al SO ante un system call:
 Por medio de registros. Se utilizan un conjunto de registros para pasar los

parámetros. Tiene el problema de que limita el número o la longitud de los
parámetros que se quieren pasar.
 Por medio de un bloque de memoria apuntado a través de un registro.
 Por medio de stack. El proceso guarda los parámetros con operaciones
PUSH y el SO los retira con la operación POP.
A los system calls se les asocia un número que los identifica. A continuación se
observa en la siguiente imagen un esquema del funcionamiento de los mismos:
Un system call incluye las siguientes tareas:
 Cargar los parámetros (en el stack, registro o bloque de memoria)

 Cargar el número de system call en algún registro específico.
28
 Invocar a la trap adecuada (system call handler, manejador de la

excepción, en x86 se dispara con la instrucción INT $0x80)
 Cambiar a modo monitor (seteando el MODE_BIT), controla que el
número de system call pasado en el registro sea menor que el mayor del
sistema y se invoca al system call correspondiente.
 Retornar el valor del system call puesto en un registro específico, de la
misma forma a cómo se cargó.
Los system call pueden agruparse de forma muy general en cinco categorías,
cada una con un propósito específico, detallados a continuación.
3.5.1 System Call - Control de Procesos

 Fin, abortar: Un programa en ejecución debe poder detenerse ya sea
normalmente (end) como anormalmente (abort). Si el programa se topa con
algún problema hace un vuelco de memoria y se genera un mensaje de
error.
 Cargar, ejecutar: Un proceso o trabajo que ejecuta un programa, podría

querer cargar (load) y ejecutar (execute) otro programa. Estas funciones
permiten al intérprete, ejecutar un programa cuando se le solicita, y luego
devolver el control al programa que se estaba ejecutando anteriormente.
 Crear proceso, terminar proceso: Siguiendo el caso anterior, si el

programa llamado, continúa ejecutándose en forma concurrente con el
programa que lo llamó, hemos creado un nuevo trabajo, o proceso. Si
vemos que no se necesita más, podemos terminar el proceso.
 Obtener atributos de proceso, establecer atributos de proceso: Si

quiero determinar y restablecer los atributos de un proceso como su
prioridad, o su tiempo de ejecución máximo, obtengo y establezco los
atributos del proceso.
 Esperar un lapso de tiempo (wait time): Después de crear procesos, es

posible que tengamos que esperar a que terminen de ejecutarse.
 Esperar suceso (wait event), indicar la ocurrencia de suceso: Es más

probable que deseemos esperar que ocurra un suceso específico, por lo
tanto el proceso deberá generar una señal cuando ese suceso haya
ocurrido.
 Asignar y liberar memoria: Ayuda a depurar programas.
3.5.2 System Call - Gestión de Archivos

 Crear archivo, eliminar archivo: Ambas llamadas necesitan el nombre del
archivo, y tal vez alguno de sus atributos.
29
 Abrir, cerrar: Una vez creado, se necesita abrirlo para usarlo, y cerrarlo
cuando no lo necesitemos más.
 Leer, escribir, reposicionar: Mientras el archivo está abierto, podemos

leer, escribir y reposicionarnos (saltar al fin de archivo, volver al principio).
 Obtener atributos de archivo, establecer atributos de archivo:

Necesitamos obtener los valores de algunos de los atributos del archivo, o
cambiarlos.
3.5.3 System Call - Gestión de Dispositivos

Un programa podría requerir recursos adicionales durante su ejecución, como
más memoria, acceso a archivos, etc. El SO debe administrarlos, para ver si están
ocupados, etc.
 Solicitar dispositivo, liberar dispositivo: Cuando hay múltiples usuarios,

debo solicitar los dispositivos, a fin de obtener su uso exclusivo, cuando no
lo necesito más, debo liberarlo.
 Leer, escribir, reposicionar: Trabajo con el dispositivo.
La gestión de dispositivo es similar a la de los archivos.
3.5.4 System Call - Gestión de Información

Hay llamadas al sistema para obtener la hora y fecha actuales, devolver
información de sistema, como número de usuarios actuales, espacio libre en el disco,
etc.
El SO mantiene información acerca de todos sus procesos, y hay llamadas al

sistema para obtenerla, y restablecer la información.
3.5.5 System Call - Comunicación

Hay dos modelos de comunicación comunes.
 Transferencia de mensajes: La información se intercambia por medio de

un recurso de comunicación entre procesos provisto por el SO. Para
hacerlo se debe conocer el nombre del computador en la red (host name).
 Abrir conexión - cerrar conexión: Se piden para establecer la

conexión, y para que se establezca, el host debe aceptar la
conexión.
 Leer mensaje - escribir mensaje: Se usan para comunicarse.
30
 Memoria compartida: Los procesos utilizan llamadas al sistema para

obtener acceso a regiones privadas de memoria de otros procesos, estas
zonas no están controladas por el SO.
Ambos métodos son comunes en los SO, y algunos hasta implementan los dos.
La transferencia de mensajes es útil cuando se desean intercambiar pocos datos,
evitando conflictos. La memoria compartida es más rápida, pero hay problemas en las
áreas de protección y sincronización.
31
3.6 Estructura del sistema

El sistema está dividido en componentes pequeños, donde cada uno de los
módulos debe ser una porción bien definida del sistema. Estos componentes se
conectan entre sí, formando un núcleo. Esto provoca que los SO puedan ser muy
diferentes. Se debe tener en cuenta:
 Metas de los usuarios: ser amigable, intuitivo, confiable, seguro, y rápido.
 Metas del SO: fácil de diseñar, implementar y mantener, flexible, confiable

y eficiente.
Encontramos básicamente cuatro diseños de SO:
- Sistema monolítico
- Sistema en capas
- Sistema con micronúcleo
- Sistema con módulo
3.6.1 Sistema monolítico

No tiene una estructura definida. El sistema es escrito como una colección de
procedimientos públicos, generalmente en C como una colección de archivos *.h. Si
bien cualquier procedimiento puede invocar a otro, es posible tener buenos diseños y
lograr buena eficiencia del SO. El principal problema que enfrentan es su
mantenimiento. Sin embargo, su principal ventaja es que casi no consume overead.
Las interfaces y niveles de funcionalidad no están bien separados. Por ejemplo,

los programas de aplicación pueden acceder a las rutinas de E/S básicas para escribir
directamente en pantalla y disco, dejando el sistema a merced de programas mal
intencionados, lo que hace que el sistema completo falle cuando fallan los programas
de usuario.
3.6.2 Sistema en capas

Si se cuenta con el apoyo apropiado de
hardware, los SO se pueden dividir en
fragmentos más pequeños y adecuados que los
originales. Así el SO puede mantener un control
mucho mayor sobre el computador y las
aplicaciones que lo usan.
Una de las formas de modularizar,

consiste en dividir el sistema en varias capas,
cada una construida sobre las capas inferiores.
La capa 0 es el hardware, y la N (la más alta)
es la interfaz con el usuario.
Una capa es una implementación de un objeto abstracto, que es el

encapsulamiento de datos y operaciones que manipulan esos datos.
32
La capa M consiste en estructuras de datos y rutinas que las capas de nivel

superior puede invocar. A su vez M puede invocar operaciones en las capas inferiores.
Cada capa se implementa utilizando solo operaciones provistas por capas del nivel
inferior.
 Ventajas:
- Al utilizar solo operaciones implementadas en el nivel inferior, se simplifica
la depuración y verificación del sistema. Si se encuentra un error en
determinado nivel, el mismo deberá estar localizado en dicho nivel dado
que los niveles inferiores ya han sido depurados.
- Se logra abstracción, ya que no sabemos como la capa inferior
implementó la operación, sino que solo la usamos. Cada capa oculta las
estructuras de datos, operaciones y hardware, de las capas superiores.
 Desventajas:
- El principal problema es la definición apropiada, puesto que una capa solo
puede usar las capas de nivel más bajo, y la planificación debe ser muy
cuidadosa.
- El sistema por capas tiende a ser menos eficiente, ya que una rutina
invoca a otra y así sucesivamente, creando un gasto extra.
3.6.3 Sistemas con microkernel

Este diseño del SO propone eliminar todos los componentes no esenciales del
kernel e implementarlos como programas del sistema y de nivel de usuario; el
resultado es un kernel más pequeño, de allí microkernel.
Sistemas de este tipo se constituyen de un kernel reducido que brinda un

manejo mínimo de procesos y memoria. Su función principal es proveer una capa de
comunicación entre procesos (el paso de mensajes). Cliente y servicio nunca
interactúan directamente, sino que lo hacen intercambiando mensajes con el
microkernel.
 Ventajas:
- Aumenta la portabilidad y escalabilidad ya que encapsula las
características físicas del SO.
- Para incorporar un nuevo servicio no es necesario modificar el núcleo.
33
- Es más seguro ya que los servicios corren en modo usuario.

- El diseño simple y funcional típicamente resulta en un sistema más
confiable.
 Desventajas:
- Pueden tener un rendimiento peor a otras soluciones debido a la carga de
procesamiento adicional impuesta por las funciones del sistema.
3.6.4 Sistemas con módulo

Es quizás la mejor metodología utilizada para diseñar SO. Utiliza las técnicas
de programación orientada a objetos para crear un kernel modularizado. Consta de un
conjunto de componentes fundamentales y enlaza dinámicamente los servicios
adicionales. Un diseño así permite al kernel proporcionar servicios básicos y también
permite implementar funcionalidades dinámicamente.
El resultado es similar a un
Sistema en Capas en el sentido de que
se ofrecen interfaces bien definidas y
protegidas, pero es más flexible ya que
cualquier módulo puede llamar a
cualquier otro. Además, es similar al
Sistema con Microkernel en cuanto a
que el módulo principal dispone de las
funciones esenciales y de los
conocimientos de cómo cargar y
comunicarse con otros módulos; sin
embargo, es más eficiente en el
sentido de que los módulos no
necesitan invocar un mecanismo de
paso de mensajes para comunicarse.
En conclusión, toma las ventajas del diseño en capas y en base a microkernel.
3.7 Máquinas virtuales (VM)

Software que simula a una computadora y puede ejecutar programas como si
fuese una computadora real. Una característica esencial de las máquinas virtuales es
que los procesos que ejecutan están limitados por los recursos de hardware y
abstracciones proporcionados por ellas. Estos procesos no pueden escaparse de esta
“computadora virtual”. El SO que reside en la VM recibe el nombre de SO huésped
(Guest SO)
34
El concepto de máquina virtual, es simple, pero difícil de implementar. La VM

en sí solo puede ejecutarse en modo usuario, pero el software virtual puede hacerlo en
modo monitor, puesto que es el SO. En consecuencia, debemos tener un modo
usuario virtual y modo monitor virtual (o hypervisor), que se ejecuten en modo usuario
físico, y deben comportarse igual al modo usuario real y modo monitor real.
Una máquina virtual también implementa discos virtuales sobre los discos
físicos, denominados minidiscos en el SO VM. El sistema implementa cada minidisco
asignando tantas pistas de disco físico como necesite. Obviamente, la suma de los
tamaños de los minidiscos debe ser menor al tamaño del disco físico.
Ventajas:
- Seguridad: los procesos en cada máquina virtual son independientes de

los procesos en las otras.
- Facilidad de desarrollo: Se puede correr un SO a modo de test en una
máquina virtual sin correr riesgos en el SO real.
- Flexibilidad: Correr un SO de una arquitectura en una máquina diferente.
- Alta disponibilidad: En caso de falla de una máquina virtual, se puede
levantar otra rápidamente en otro hardware.
Desventajas:
- Las operaciones pueden tardar más que un SO real, puesto que las
instrucciones del SO invitado deben ser interpretadas.
- El tiempo de respuesta es poco predecible.
35
4 Procesos
Podemos considerar un proceso como un programa en ejecución. También es
considerado como la unidad de trabajo de los SO. Un SO entonces consiste en una
colección de procesos, por un lado Procesos de Usuario y por otro Procesos del
Sistema.
Un programa es una entidad pasiva, por lo general un archivo conteniendo las

instrucciones a ejecutar (archivo ejecutable), mientras que un proceso es una entidad
activa, con una instrucción a ser ejecutada y un conjunto de recursos asignados. Un
programa se transforma en un proceso al ser cargado en memoria.
Cada procesos tiene incorporado un

identificador (denominado pid - process id), su PC
(program counter), registros y variables.
Al ser cargado en memoria se incorporan:
 Stack: contiene datos temporales, como

parámetros, direcciones de retorno y
variables locales.
 Heap: es un espacio de memoria asignado
al proceso dinámicamente en tiempo de
ejecución.
 Datos: contiene variables globales
 Código: secuencia de instrucciones del
proceso
Los primeros sistemas solo permitían la ejecución de un programa a la vez, el

cual asumía el control total del sistema y tenía acceso a todos sus recursos. Los SO
actuales permiten cargar múltiples programas en memoria y ejecutarlos en forma
concurrente. De esta forma, un proceso tiene un hilo de ejecución (thread) que es visto
como una CPU virtual. El procesador es alternado entre los diferentes procesos,
dando la idea de que se ejecutan en paralelo. A su vez, puede haber dos o más
procesos asociados al mismo programa, esos procesos se consideran secuencias de
ejecución independientes.
36
4.1 Estado de un Proceso

A lo largo de la ejecución de un proceso, este cambia de estado. El estado está
definido por la actividad actual del proceso.
Solo un proceso puede estar ejecutándose en un instante dado, pero muchos

procesos pueden estar listos y esperando. El diagrama de estados que sigue un
proceso es:
Donde cada estado representa:
 NEW: El proceso es creado.

 READY: El proceso se encuentra esperando a que le asignen el
procesador para ejecutar (o seguir ejecutando en algunos casos).
 RUNNING: El proceso está ejecutando sus instrucciones en el
procesador.
 WATING: El proceso está esperando algún suceso o evento de I/O.
 TERMINATED: El proceso ha terminado su ejecución.
Donde las transiciones entre los estados indican:
 NEW  READY: Al crearse un proceso pasa inmediatamente a la

cola de procesos listos, es admitido.
 READY  RUNNING: El proceso en estado listo solo espera a que
el procesador se libere, para que luego el despachador lo seleccione
como el próximo proceso a ejecutar.
 RUNNING  READY: Ante una interrupción el proceso puede
perder el procesador (en caso de que haya procesos listos),
pasando nuevamente a la cola de procesos listos.
 RUNNING  WATING: El proceso solicita algún suceso o evento
I/O que puede demorar, mientras espera por él se le cede el
procesador a otro proceso y pasa a la cola de espera.
 WATING  READY: Una vez que ocurre el evento que el proceso
esperaba es puesto nuevamente en la cola de procesos listos.
37
 RUNNING  TERMINATED: Cuando el proceso termina su

ejecución, el SO debe liberar las estructuras que representan al
proceso.
Este esquema aplica a un planificador expropiativo, donde es posible quitarle

la CPU a un proceso ante una interrupción. En un planificador no expropiativo, el
diagrama cambia un poco, pues la única forma de quitarle el procesador al proceso es
que el mismo realice un pedido de E/S o eventualmente finalice su ejecución,
quedando de la siguiente forma:
4.2 Bloque Descriptor de Proceso (PCB)

Dentro del kernel, cada proceso es representado mediante una estructura de
datos llamada Process Control Block (PCB). Dentro de esta estructura se
encuentran datos sobre la ejecución del proceso, entre los cuales se encuentran:
 Estado del proceso

 PID del proceso
 Valor del PC (program counter)
 Valor de los registros de la CPU (indefinido
mientras el proceso se encuentra en estado
running).
 Tipo de planificación, que incluye valores
usados por el algoritmo de Scheduling
 Utilización de memoria del proceso, incluyendo
el valor de los registros base y limite, tablas de
página, tablas de segmento, etc
 Información contable, tal como el uso de CPU y
memoria, tiempo que lleva ejecutando, etc
 Estado de E/S, como los dispositivos asignados
al proceso, los archivos abiertos, etc
 Prioridad
 Ancestro, cuál es el proceso padre.
 Descendientes, cuáles son los procesos hijos.
38
4.3 Creación de procesos

Todos los procesos son creados a partir de otros procesos (salvo casos
especiales, como el proceso init en sistemas Linux).
Al proceso creador se le denomina padre y al creado hijo. Estos hijos pueden

crear nuevos procesos, generando un árbol de procesos. La relación padre-hijo define
una jerarquía entre los procesos del sistema.
Cuando un proceso crea otro nuevo, hay dos posibilidades de ejecución:
 El padre sigue ejecutándose de forma concurrente con sus hijos

 El padre espera hasta que algunos de sus hijos, o todos hayan terminado.
También existen dos posibilidades en términos del espacio de direcciones del

nuevo proceso:
 El proceso hijo es un duplicado del padre.

 Se carga un programa en el proceso hijo.
Dicho esto, podemos afirmar que existen varias opciones respecto a qué
recursos comparten padre e hijo al momento de la creación del hijo, puede ser que
estos procesos compartan todo, algo, o nada. Cuando un proceso es creado, el hijo
tiene un hilo de ejecución independiente al del padre, con un PC independiente. El SO
crea un nuevo PCB para el proceso hijo.
En sistemas UNIX existe un system call llamado fork() que es la encargada de

crear nuevos procesos. Esta llamada hace dos copias idénticas del proceso salvo en
el valor de retorno de la función (que es 0 para el hijo, y el pid del hijo para el padre).
Esta llamada combinada con el system call exec(), que borra el espacio de memoria
de un proceso y carga un nuevo programa en este, permiten cargar cualquier
programa en memoria. El padre o bien puede crear más hijos o si no tiene nada que
hacer mientras se ejecuta el hijo puede ejecutar el system call wait() para auto-
excluirse de la cola de procesos listos hasta que el proceso se complete.
El siguiente código en C ilustra las llamadas al sistema descritas

anteriormente para el ambiente UNIX.
39
Ahora tenemos dos procesos diferentes ejecutando una copia del mismo
programa. El valor pid del proceso hijo es cero; el del padre es un valor entero mayor
que cero. El proceso hijo sustituye su espacio de direcciones mediante el comando
/bin/ls de UNIX (utilizado para obtener un listado de directorios) usando el system call
execlp() que es una versión del exec(). El padre espera a que el proceso hijo se
complete usando la system call wait(). Cuando el proceso hijo termina, invocando
implícita o explícitamente exit(), el proceso padre reanuda su ejecución finalizando
mediante la llamada exit().
En cambio, la creación de procesos en Windows es un tanto distinta. Se realiza

mediante la función CreateProcess() de la API de Win32, que también crea un nuevo
proceso hijo a partir de un padre. A diferencia de fork() en UNIX, esta función necesita
al menos diez parámetros y requiere cargar un programa específico en el espacio de
6
direcciones del proceso hijo durante su creación .
El siguiente código en C ilustra el funcionamiento de la creación de procesos

en el ambiente Windows.
6
Por mas información consultar Fundamentos de Sistemas Operativos – Silberschatz – pg.83
40
4.4 Colas de Planificación de Procesos.

El objetivo de la multiprogramación es tener algún proceso de ejecución en
todo momento, a fin de aprovechar al máximo la CPU. El objetivo es conmutar la CPU
entre procesos con tal frecuencia que los usuarios puedan interactuar con cada
programa durante su ejecución. En el caso de un único CPU, solo se ejecuta un
proceso por vez.
Como se vio en la Sección 4.1, los procesos son agrupados en colas

dependiendo del estando en el que estén. De ésta forma tenemos:
 Cola de procesos del sistema (job queue): Están todos los procesos del
sistema. Al crearse un nuevo proceso se agrega su PCB a esta cola.
Cuando un proceso termina su ejecución es borrado.
41
 Cola de procesos listos (ready queue): Contiene a los procesos que estén
en estado ready esperando a ser asignados por el procesador.
 Cola de espera de dispositivos (I/O queue): Existe una de estas colas por
cada uno de los dispositivos en el sistema. En ellas, se encuentran los PCB
de los procesos que se encuentran esperando por una operación sobre el
dispositivo.
Esquemáticamente:
Una representación que habitualmente se emplea para explicar la planificación

de procesos es el Diagrama de Colas, como se muestra a continuación:
42
En el diagrama, cada rectángulo representa una cola y existen básicamente

dos tipos: La cola de procesos listos y un conjunto de colas de dispositivos. Los
círculos representan los recursos que dan servicio a las colas y las flechas indican el
flujo del proceso en el sistema. Al crearse un proceso pasa a la ready queue, donde
espera su turno en la cola hasta ser despachado. Una vez en la CPU puede ocurrir o
bien que termine o bien que ocurra uno de los siguientes casos:
 Solicita un dispositivo de E/S y pasa a la I/O queue del dispositivo.

 Expira su tiempo en la CPU y se devuelve a la ready queue
 Crea un procesos hijo y espera a que este termine
 Ocurra una interrupción y pase de nuevo a la ready queue.
4.5 Cambio de Contexto

El cambio de la CPU a otro proceso, requiere guardar el estado del proceso
anterior, y cargar el estado guardado del nuevo proceso. Esta tarea se denomina
context switch, y es un gasto extra, porque el sistema no realiza ningún trabajo útil
durante la conmutación.
Un context switch implica las siguientes tareas:
 Respaldar
 Salvar el contexto del proceso desalojado de la CPU en su PCB
 Cambiar el estado del proceso que estaba ejecutando en la CPU al
que corresponda.
 Reanudar
 Cargar el contexto del proceso asignado a la CPU a partir del PCB
 Cambiar el estado del proceso asignado a la CPU a running
Toda información es guardada en el PCB del proceso. Antes de volver a la

ejecución del proceso, el SO debe tomar los valores presentes en el PCB y enviarlos a
los lugares correspondientes de manera que el proceso pueda ejecutar normalmente
como si nada hubiese pasado.
43
Cuanto más complejo sea el SO, más trabajo hay que efectuar en la
conmutación. Esta conmutación se ha convertido en un cuello de botella, tan
importante que se están empleando estructuras nuevas, como threads, para evitarla.
Esquemáticamente:
4.6 Comunicación entre Procesos

Los procesos que se ejecutan concurrentemente pueden ser de dos tipos:
 Procesos Independientes: No puede afectar ni verse afectado por otro

proceso. No comparte datos con ningún otro proceso.
 Procesos Cooperativos: Puede afectar o verse afectado por otro proceso.

Comparte datos con otros procesos.
Las razones para permitir la concurrencia son:
 Compartir información: Varios usuarios podrían estar interesados en el

mismo elemento de información (Ej.: un archivo).
 Aceleración de los cálculos: Divido las tareas en subtareas y las ejecuto

en paralelo. Esta aceleración sólo puede lograrse en sistemas
multiprocesador.
44
 Modularidad: Se puede seguir un patrón modular, dividiendo las funciones

del sistema en procesos individuales o threads.
 Comodidad: Un mismo usuario podría querer trabajar en muchas tareas al

mismo tiempo (Ej.: Podría estar imprimiendo, compilando y editando al
mismo tiempo).
Para permitir cooperación entre los procesos se requiere mecanismos que

permitan comunicación y sincronización entre ellos. Para ello el SO brinda el IPC (Inter
Process Comunicaction) que permite a los procesos comunicarse y sincronizarse sin
compartir espacio de direccionamiento en memoria. Para ello tenemos dos modelos(7):
 Memoria compartida: Se establece una región de memoria que los

procesos puedan compartir datos.
 Paso de mensajes: Se realiza a través de dos primitivas (SEND y

RECIVE) por medio de un enlace de comunicación (MAILBOX).
Ejemplo:
Un proceso productor produce información que es consumida por un

proceso consumidor. Para que los procesos puedan ejecutarse de forma
concurrente, es preciso contar con un buffer de elementos, que el productor
pueda llenar, y el consumidor vaciar. Un productor puede producir un
elemento mientras el consumidor consume otro. El productor y el consumidor
deben estar sincronizados para que el consumidor no trate de consumir un
elemento que todavía no se ha producido. No solo hay que controlar que el
consumidor no consuma (si el buffer está vacío), sino también el productor
7
Ambos modelos son comunes y muchos SO implementan ambos
45
debe esperar si el buffer está lleno (pues el buffer no es ilimitado, podría

serlo teóricamente, pero no en la práctica).
4.7 Threads, Hebras o Hilos

Un thread, también conocido como proceso ligero, es la unidad básica de
utilización de la CPU. Es un flujo de control dentro de un proceso.
Cada thread consta de un PC, un juego de registro, un stack y una prioridad.

El thread comparte con sus thread pares la sección de código, la sección de datos y
los recursos del SO como archivos abiertos.
A nivel del PCB, el sistema debe tener una estructura independiente para cada
thread de un proceso que contenga por lo menos el stack, registros y el program
counter, tal y como muestra la siguiente imagen:
Ventajas:
- Respuesta: Desarrollar una aplicación con varios hilos de control permite

tener un mejor tiempo de respuesta
- Compartir recursos: A diferencia del IPC, no es necesario acceder al
kernel para comunicar o sincronizar los hilos.
- Economía: Es más liviano crear un thread que un proceso tradicional
nuevo (o procesos pesado), debido a que como los threads comparten
código, datos y recursos, hace que la conmutación de la CPU entre hilos
sea mucho más económica que los cambios de contexto entre procesos, ya
que no hay que realizar operaciones relacionadas con la gestión de
memoria; esto se conoce como overhead. A su vez, es más liviano eliminar
un thread pues solo se debe eliminar su contexto (registros) y stack,
mientras que en un proceso debemos eliminar todo el PCB.
- Utilización de arquitecturas con multiprocesadores: Permite que los
threads de un mismo proceso ejecuten en forma paralela.
Desventajas:
46
- Dificulta la programación: Al compartir todo, el espacio de

direccionamiento de un thread mal programado puede romper el
funcionamiento del resto del thread.
- Control de concurrencia: Al permitir ejecución de procesos en paralelo.
Los hilos operan en muchos sentidos, de la misma forma que los procesos.
Pueden estar en varios estados (listo, bloqueado, ejecutando o terminado).
La estructura no ofrece protección entre hilos. Sin embargo, esa protección no

debería ser necesaria, puesto que el dueño de la tarea con múltiples hilos es un único
usuario.
Los threads pueden ser implementados en dos formas:
1. A nivel usuario (user level thread - ULT): Por medio de bibliotecas de

usuario La conmutación de hilos no necesita invocar al SO ni causar
interrupciones para pasar al núcleo. La librería provee soporte sobre los
threads para Crear, Planificar y Administrar, sin soporte del SO, éste solo
reconoce un hilo de ejecución en el proceso.
Ventajas:
o Desarrollo de aplicaciones en sistemas sin soporte a hilo:

Aprovechar los beneficios de programar orientado a threads, o se
puede portar una aplicación a un SO que carezca de la noción de
varios hilos de ejecución.
o Cambio de contexto: El cambio de contexto entre threads es más
simple ya que no consume el overead(8) que tendría el SO.
o Planificación independiente: Se puede crear una nueva estrategia
de planificación diferente a la del SO.
Desventajas:
o Un fallo de página de un threads hace que se bloquee el proceso

junto con todos los otros hilos pares. Lo mismo ocurre con la E/S y
los system call.
o En un sistema multiprocesador todos los threads competirán por un
único procesador, pues el SO reconoce un solo hilo de ejecución.
2. A nivel de kernel (kernel level thread - KLT): El SO provee la Creación,

Planificación y Administración de threads. El SO reconoce tantos hilos de
ejecución como threads se hayan creado.
Ventajas:
o Mejor aprovechamiento de un sistema multiprocesador: El SO

puede asignar threads del mismo proceso en distintos
procesadores.
o Ejecución independiente: Si un thread se bloquea, los demás
threads pueden seguir ejecutando.
8
Tiempo desperdiciado por el procesador para realizar un cambio de contexto.
47
Desventajas
o A nivel del núcleo ante un cambio de contexto es necesario hacer un

system call, lo que lo hace más lento que la conmutación entre hilos
a nivel de usuario
Dado que la mayoría de los SO proveen threads tanto a nivel usuario como a
nivel del kernel es que surgen distintos modelos detallados a continuación.
Básicamente se utiliza la notación UserThread x KernelThread.
4.7.1 Mx1 . Many-to-one

El SO reconoce varios user
thread que se corresponden a un único
kernel thread. Los user threads
ejecutarán cuando estén asignados al
kernel thread, y además el proceso esté
asignado al CPU por medio del
planificador del SO.
El inconveniente con este modelo

es que el proceso completo se bloquea
si un thread realiza una llamada
bloqueante al sistema. Dado que solo un
thread puede acceder al kernel cada vez,
no podrán ejecutarse varios thread en
paralelo sobre múltiples procesadores.
4.7.2 1x1 . One-to-one

El SO reconoce a cada user thread asociado a un kernel thread. Cada user
thread es planificado en forma independiente En este caso no hay planificador a nivel
usuario.
Permite ejecutar varios thread en paralelo en distintos procesadores. El único

inconveniente de este modelo es que al crear un user thread requiere crear su
correspondiente kernel thread.
48
4.7.3 MxN . Many-to-many

El SO asocia cada proceso a un
conjunto de kernel threads
independiente de los user threads que
haya creado el proceso.
De esta forma, en el kernel

existen varios threads para un proceso,
cada uno de los cuales se corresponde
con varios user threads (de aquí la
restricción M>N para que tenga
sentido). El planificador a nivel usuario
asigna los user threads a los kernel
threads.
El planificador del SO solo reconoce los kernel threads, ejecutándolos cuando

el planificador del SO le da el control al proceso y el planificador a nivel de usuario
asigna ese thread para ejecutar. Se pueden ver a los kernel thread como CPU
virtuales.
Con este modelo los desarrolladores pueden crear tantos user threads como
sean necesarios y los correspondientes kernel threads pueden ser ejecutados en
forma paralela en un multiprocesador. Asimismo, cuando un thread realiza una
llamada bloqueante al sistema, el kernel puede planificar otro thread para su
ejecución.
49
5 Planificación
La planificación de la CPU es la base de los SO multiprogramados. Tiene como
objetivo tener algún proceso en ejecución en todo momento para así maximizar el uso
de la CPU. Al conmutar la CPU entre procesos se aumenta la performance del
computador.
Esta tarea surge cuando varios procesos están en estado ready y el

procesador está libre, se debe elegir qué proceso será asignado al procesador para
pasar a estado running.
El componente del SO que realiza la elección del proceso es llamado

Planificador (Scheduler).
El módulo del SO que da el control del CPU al proceso seleccionado por el

planificador es denominado Despachador (Distpacher). Realiza las siguientes
funciones:
 Cambiar el contexto
 Cambiar a modo usuario
 Reanudar (o consecuentemente iniciar) el programa de usuario.
Debe ser lo más rápido posible, porque se invoca en cada conmutación. El

tiempo de demora, se denomina latencia del despachador.
A grandes rasgos se distinguen tres tipos de planificadores:
 Largo plazo: Se determina qué programas son admitidos y cuántos corren

a la vez, sin tener que cargarlos en memoria. Mientras más procesos,
menos porcentaje de uso de procesador.
 Mediano plazo: Genera un subconjunto de programas que carga en
memoria determinando si agregar más o no.
 Corto plazo: Determina qué proceso es ejecutado en el procesador de
forma eficiente.
5.1 Clases de Procesos

Los procesos en ejecución alternan entre dos estados, ciclos de CPU y espera
por E/S. Las distintas políticas de planificación resultan exitosas según la clase de
procesos que ejecuten. De esta forma es que todo proceso tiene un ciclo de ráfaga de
ejecución (CPU-burst) y un ciclo de ráfaga de espera de E/S (I/O-burst).
Dependiendo de estos valores, un proceso puede ser más intensivo en el uso de CPU
o en el uso de E/S. Así es que distinguimos dos clases de procesos:
 Procesos CPU-bound: Procesos con alto uso de CPU.

 Procesos I/O-bound: Procesos que realizan muchos acceso a dispositivos
de E/S.
Como regla general, un proceso debe acceder a un recurso con prioridad

inversamente proporcional al uso que haga de este.
50
5.2 Esquema de Planificación

Siempre que la CPU esta ociosa, se debe escoger un proceso de la cola de
procesos listos (ready queue). La cola de procesos no necesariamente es FIFO, sino
que puede ser una cola de prioridad, un árbol o una lista enlazada sin orden alguno.
Los posibles eventos donde el planificador es invocado son:
1. Cuando un proceso pasa de RUNNING  WATING

2. Cuando un proceso pasa de RUNNING  READY
3. Cuando un proceso pasa de WATING  READY
4. Cuando un proceso pasa de RUNNING  TERMINATED
En los casos (1) y (4) el planificador debe invocarse forzosamente. Un

planificador será expropiativo si en los casos (2) y (3) invoca al planificador, en caso
contrario diremos que es no expropiativo.
La idea es que en los planificadores expropiativos la ejecución de un proceso

puede ser cortada en cualquier momento, mientras que en un planificador no
expropiativo la ejecución de un proceso se efectúa sin interrupciones mientras no
solicite operaciones sobre la E/S (el proceso puede tener control de la CPU todo el
tiempo que necesite).
Los planificadores expropiativos implementan también un timer, de manera

que la ejecución de un proceso es cortada automáticamente después de cierto
intervalo de tiempo. Una desventaja de estos sistemas es que si dos procesos
comparten ciertos datos y además uno de los proceso está modificando un dato
cuando se le es quitada la CPU, en caso que el otro proceso quiera leer ese dato, éste
será incoherente.
La utilización de planificadores expropiativos o no expropiativos depende de las

características del sistema que se está desarrollando:
 Sistemas por lotes: Como no existe interacción con el usuario, los

planificadores no expropiadores son ideales.
 Sistemas interactivos y de tiempo compartido: Dado que existen varios

procesos de usuario ejecutando concurrentemente, los planificadores
expropiativos son ideales ya que mejoran el tiempo de respuesta al usuario.
 Sistemas de tiempo real: No es necesario tener planificadores

expropiativos, ya que los procesos pueden estar mucho tiempo sin
ejecutarse, pero cuando lo hacen es por un periodo corto.
51
5.3 Criterios de Planificación

Los algoritmos de planificación tendrán distintas propiedades y favorecerán
cierta clase de procesos. Para ello es necesario definir criterios:
 Utilización de CPU (CPU Utilization): Porcentaje de uso, de forma de

determinar el CPU-Burst.
 Rendimiento (Throughtput): También denominado tasa de procesamiento.

Número de procesos que ejecutaron completamente por unidad de tiempo.
 Tiempo de retorno (Turnaround time): También denominado tiempo de

ejecución. Suma de los intervalos de tiempo en que el proceso espera para
cargarse en memoria, esperar en la cola de procesos listos, ejecuta en la
CPU y realiza operaciones de E/S.
 Tiempo de espera (Wating time): Suma de los intervalos de tiempo que un

proceso es estuvo en la cola de procesos listos.
 Tiempo de respuesta (Response time): Intervalo de tiempo desde que un

proceso es cargado hasta que brinda su primer respuesta (no todas).
El objetivo consiste en maximizar la utilización de la CPU y la tasa de

procesamiento (rendimiento), y minimizar el tiempo de ejecución, el tiempo de espera
y el tiempo de respuesta. En la mayoría de los casos se busca optimizar algún valor
promedio, y en otros casos optimizar valores máximo y mínimo, todo depende de qué
situación deseemos (9).
Algoritmos de Planificación
Deciden a qué proceso de la ready queue debe asignársele el procesador. A
continuación se detallan los algoritmos.
I. First Come First Served (FCFS)

Su denominación en español, primero en llegar, primero en ser servido. Los
procesos son ejecutados en el orden en que llegan a la ready queue.
Es un algoritmo no expropiativo y se implementa con una cola FIFO. El

problema es que el tiempo de espera promedio suele ser muy largo.
Empleamos un diagrama de Grant para mostrar cómo el tiempo promedio de

espera puede resultar muy variable en función de la duración de las ráfagas de la
CPU. Asumimos que todos los procesos llegan en el orden que aparecen en la tabla
en el instante .
9
Por ejemplo se puede buscar minimizar el valor máximo del tiempo de respuesta, o maximizar el valor
mínimo de la tasa de transferencia.
52
Otro posible problema que puede generar este esquema de planificación es el

denominado efecto convoy. Puede darse en el siguiente escenario: existen procesos
ejecutando operaciones de E/S y un proceso de larga duración utilizando la CPU; una
vez que los procesos que están ejecutando la E/S finalicen su cometido, pasarán a la
cola de procesos listos esperando por ese único proceso deje la CPU, dejando a la
E/S inactiva hasta que termine.
II. Shortest Job First (SJF)

Su denominación en español, selección del trabajo más corto. El algoritmo
asocia a cada proceso el largo de su próximo CPU-burst. Cuando el procesador queda
libre, se le asigna el proceso con menor largo. En caso de tener dos procesos con
igual CPU-burst se usa FCFS para romper el empate.
El problema que tiene es que en el momento de decidir el planificador no tiene

conocimiento sobre cuál será el largo del próximo CPU-bust, el que debería estimar de
alguna manera.(10) Si se pudiera saber en todo momento el valor del largo del próximo
CPU-burst, este algoritmo seria el óptimo en cuanto a tiempos de espera.
Este algoritmo admite dos variantes:
 No expropiativa: Una vez que se le asigna el procesador a un proceso no

se le podrá quitar.
 Expropiativa: Si un nuevo proceso aparece en la ready queue con menor
CPU-burst, se le quita la CPU para asignarla al nuevo proceso.
10
Para lo cual existen estrategias, como por ejemplo predecir en base a la media exponencial. Si es la
duración de la n-ésima ráfaga de CPU y el valor predicho para la siguiente ráfaga de CPU. Entonces
para , denominado peso relativo del historial reciente, tenemos que:
, donde el parámetro controla el peso relativo del historial reciente y pasado
de nuestra predicción. Usualmente se toman y es una constante o promedio global para el sistema.
53
Consideremos el siguiente ejemplo para el caso no expropiativo y expropiativo

con sus respectivos diagramas de Grant.
III. Priority
A cada proceso se le asigna un número entero que representa su prioridad. Al
elegir un proceso para ser ejecutado, se elige siempre al proceso con mayor prioridad
(11)
dentro de la ready queue, si existen procesos con igual prioridad se planifican en
FCFS.
Por lo general se implementa expriopiativamente, de manera que si un proceso

con prioridad mayor a la del proceso que está siendo ejecutado entra en la ready
queue, éste pasa a ejecutar sacando al proceso que estuviera antes. Aunque también
puede implementarse en forma no expropiativa, poniendo al nuevo proceso de
prioridad mayor al que está usando la CPU al principio en la cola (puesto que si
ejecutaba un proceso de menor prioridad en la CPU, los procesos que ya habían en la
cola son de menor o igual prioridad).
El SJF puede ser visto como un algoritmo basado en prioridad donde la

prioridad viene dada por el valor del largo del próximo CPU-burst.
11
Al representarse mediante un número, una prioridad baja puede corresponderse tanto con números
altos o bajos, de forma análoga los de prioridad alta; depende del SO y puede llegar a ser confuso.
Generalmente una prioridad es el inverso de la siguiente ráfaga de CPU. A su vez las prioridades pueden
definirse interna o externamente al SO.
54
La desventaja de este método es que posee posposición indefinida, ya que

procesos con baja prioridad pueden no ser ejecutados nunca si siempre aparecen
procesos con mayor prioridad. Esto puede o bien provocar bloqueo indefinido del
proceso de baja prioridad o muerte por inanición si el sistema falla, perdiendo así
todos esos procesos de prioridad baja.
Para evitar este problema se puede pasar a un sistema con prioridades

dinámicas de envejecimiento, de manera que la prioridad de un proceso va
aumentando a medida que pasa el tiempo, asegurando que en algún momento tendrá
una prioridad lo suficientemente alta como para ser ejecutado.
Por lo general, un proceso que es I/O-bound debería tener mayor prioridad que
un proceso CPU-bound. Este algoritmo es adecuado para sistemas interactivos.
IV. Round Robin (RR)

Su denominación en español, turno circular. A cada proceso se le da un
periodo fijo de tiempo (llamado quantum) para que use el procesador. Si al finalizar el
quantum no finalizó su ejecución el proceso es interrumpido y el Scheduler es llamado
para asignar el procesador a otro proceso. El proceso interrumpido que sale del
procesador es agregado al final de la cola (de aquí la “circularidad” del método).
Este algoritmo es
relativamente sencillo de
implementar. Para que sea
efectivo, el tamaño del
quantum debe ser el
adecuado.
Si es muy pequeño
comparado con el tiempo
que lleva un cambio de
contexto, la mayoría del
tiempo se utiliza haciendo cambios de contexto y por lo tanto poco tiempo haciendo
tareas “útiles”. Si el quantum es muy grande, el sistema degenera en un FCFS.
Consideremos el siguiente ejemplo para el caso expropiativo con sus

respectivos diagramas de Grant, un quantum preestablecido y que todos los procesos
llegan en el orden que aparecen en la tabla en el instante .
Por lo general tiene un tiempo de respuesta mejor que el SJF, pero tiene un
mayor tiempo de retorno. El tiempo de retorno varía según el quantum
55
V. Multilevel Queue
Su denominación en español es colas de múltiples niveles. Este tipo de
planificación es útil cuando es fácil clasificar los procesos en diferentes grupos.
Se divide la ready queue en varias colas distintas, y asigna los procesos a la

cola correspondiente dependiendo de sus propiedades.
Cada cola tiene su algoritmo de planificación, y hay planificación entre todas las
colas, la cual es generalmente expropiativa de prioridades fijas. Además cada cola
tiene prioridad absoluta sobre las colas de más baja prioridad.
Un proceso pertenece a una única cola, y no puede cambiar de cola durante su

ejecución.
Otra posibilidad es dividir el tiempo entre las colas, donde cada una obtiene
cierta porción de tiempo de la CPU, que reparte entre sus procesos.
VI. Multilevel Feedback Queue

Su denominación en español, colas de múltiples niveles realimentadas. Es
igual al anterior salvo que los procesos pueden cambiar de cola durante su ejecución,
dependiendo de sus propias necesidades o de las necesidades del sistema para que
funcione en forma óptima.
La idea es categorizar a los procesos según su CPU-burst, de manera que la

cola con mayor prioridad sea aquella con los procesos I/O-bound, mientras que los
procesos con menor prioridad sean aquellos con alto CPU-bound.
De esta forma, los procesos con menor uso de procesador son los primeros en
ser atendidos cuando lo necesitan. A lo largo de la historia de los procesos estos son
movidos entre las colas dependiendo de qué uso hagan del procesador.
56
Para definir un Multilevel Feedback Queue es necesario saber:
 El número de colas
 El algoritmo de planificación de cada cola
 El método para subir a un proceso de una cola a una cola superior
 El método para bajar un proceso a una cola inferior
 El método para saber a qué cola enviar a un proceso cuando cambia su
estado a pronto
Consideremos el siguiente ejemplo. Tenemos un planificador de colas

multinivel retroalimentadas formada por tres colas numeradas del 0 al 2, cada una con
su planificación. Primero el planificador ejecuta todos los procesos de la cola 0.
Cuando está se vacía pasa a ejecutar los de la cola 1 y análogamente los de la cola 2.
Si se está ejecutando un proceso de una cola de prioridad más baja y llega un nuevo a
una cola de prioridad superior se le expropia el CPU.
En este ejemplo si un proceso no concluye con la planificación de la cola en

que se encuentra (para la cola 0 y 1 con el quantum) pasará a la cola de nivel inferior y
así sucesivamente, hasta llegar a la última cola (en este caso FCFS) y será servido
siempre que las colas de nivel superior estén vacías.
El diseño de colas multinivel retroalimentadas son el algoritmo más general y

consecuentemente más complejo, difíciles de diseñar.
Sistemas Multiprocesador
En sistemas multiprocesadores, se puede compartir la carga, pero torna más
compleja la planificación. Existen básicamente dos métodos de planificación en los
sistemas multiprocesador:
 Multiprocesamiento asimétrico: todas las decisiones sobre la

planificación, el procesamiento de E/S y otras actividades son gestionadas
por un mismo procesador (el maestro).
 Multiprocesamiento simétrico: cada uno de los procesadores se

autoplanifica. Aquí podemos encontrar dos variantes en cuando a la
planificación:
o Todos los procesos están en una ready-queue común y cada
procesador consume de él
o Cada procesador tiene su propia ready-queue privada.
57
Ventaja:
- Se aprovecha al máximo la caché del procesador, ya que cuando un
proceso la pobló con sus datos, cuando vuelva algunos de esos datos
puede que todavía estén presentes en la cache, aumentando así la
cantidad de hit caché y mejorando entonces la performance del sistema.
Desventaja:
- Pueden desbalancearse las colas, dándole mucho trabajo a un mismo
procesador mientras los demás no hacen nada. Una posible solución es
implementar algoritmos para equilibrar la carga que cada tanto chequeen
que la carga esté balanceada entre los procesadores, y en caso de que no
sea así redistribuye procesos de un procesador a otro para lograr ese
objetivo. Sin embargo dado que cada CPU tiene su propia caché, al
cambiar el proceso de CPU se debe invalidar la caché del CPU origen y
rellenar la caché del CPU destino (que tiene un alto costo asociado), para
así no dar lugar a inconsistencias. Para resolverlo los sistemas de
multiprocesamiento simétrico intentan mantener la ejecución de un
programa en un mismo CPU, esto se conoce como afinidad al
procesador(12), reduciendo así el costo que tiene invalidar/rellenar las
cachés.
12
Se presenta en dos formas
 Afinidad suave: intentar mantener un proceso en un mismo CPU, pero sin garantías de que
lo haga.
 Afinidad dura: permite a un proceso especificar que no debe cambiar de CPU
58
6 Sincronización de procesos – Programación Concurrente

Los conceptos claves en los que se basan los SO modernos son el de proceso
y el de hilo. Los temas fundamentales de diseño están relacionados con la gestión de
procesos:
 Multiprogramación: Es la gestión de varios procesos dentro de un sistema

monoprocesador – Programación Concurrente
 Multiproceso: Es la gestión de varios procesos dentro de un sistema

multiprocesador – Programación Paralela
 Proceso distribuido: Es la gestión de varios procesos que ejecutan en

múltiples PC remotas. – Programación Distribuida
La sincronización es el punto clave de los tres paradigmas de programación

antes dicha y son términos en contraposición al paradigma secuencial. Puede
presentarse en tres contextos diferentes:
 Varias aplicaciones: La multiprogramación se creó para permitir que el

tiempo de procesador de la máquina fuese compartido dinámicamente
entre varios trabajos o aplicaciones activas.
 Aplicaciones estructuradas: Como ampliación de los principios del diseño

modular y la programación estructurada, algunas aplicaciones pueden
implementarse eficazmente como un conjunto de procesos concurrentes.
 Estructura del SO: Las mismas ventajas de estructuración son aplicables a

los programadores de SO.
Como ya vimos, un proceso cooperativo es aquel que puede afectar o ser

afectado por otros procesos ejecutándose en el sistema. Estos pueden compartir un
espacio de direcciones lógicas (código y datos) o solo datos a través de archivos.
6.1 Grafo de precedencia

Grafo acíclico y dirigido, cuyos nodos corresponden a los procesos y las aristas
la precedencia. El grafo de precedencias indica sin ambigüedades en qué orden es
necesario ejecutar los procesos.
Es acíclico pues solo se establecen las precedencias entre los procesos. No

confundir con lo que pueda ocurrir dentro de un loop, donde quizás si hayan
precedencias circulares, pero a nivel del grafo no tiene sentido que haya circularidad.
59
6.2 Concurrencia basada en COBEGIN-COEND

Para declarar procesos concurrentes necesitamos herramientas que haga
explícita tal situación. Muchos lenguajes de alto nivel traen consigo palabras
reservadas como COBEGIN - COEND. Todas las sentencias dentro de un bloque
declarado con COBEGIN - COEND se ejecutan concurrentemente.
Debemos tener cuidado como declarar bloques COBEGIN - COEND de forma

de asegurarnos un buen resultado. A continuación algunos ejemplos:
Existe una asociación directa entre un grafo de precedencia y el código

concurrente que implementa. De esta forma, para el grafo anterior tenemos:
60
Una forma de simple traducir un grafo de precedencia a un código utilizando las

sentencias COBEGIN-COEND es distinguir bloques o subgrafos que puedan ser
ejecutados concurrentemente, buscando aquellos nodos que tengan un ancestro en
común y todos deriven en un único hijo. De esta forma:
61
Sin embargo, no todos los grafos de

precedencia pueden ser representados con las
instrucciones COBEGIN-COEND como se
muestra en el grafo de la derecha.
Solo aquellos grafos que formen

subgrafos disjuntos concurrentes podrán ser
traducidos a un código utilizando COBEGIN-
COEND.
En este caso, ¿S1, S3 y S2

concurrentes? ¿S4 y S5 concurrentes? ¿Cómo
logro ejecutar S4 concurrentemente con S5 si
ejecuté S1, S3 y S2 concurrentes?
El conjunto de situaciones de concurrencia descripto por COBEGIN-COEND

está estrictamente incluido en el conjunto de situaciones de concurrencia descripto por
los grafos de precedencias.
Una conclusión inmediata de lo anterior es que vamos a necesitar más

herramientas, COBEGIN-COEND no alcanza.
6.3 Concurrencia basada en FORK-JOIN

En este esquema se utilizan una serie de primitivas que permiten crear y unir
hilos de ejecución. Estas sentencias son:
 FORK:
Sintaxis: FORK etiqueta
Comportamiento: En el momento de ejecutar la sentencia FORK, el

proceso se divide en dos. Uno de los procesos resultantes continua
ejecutando en la línea inmediatamente posterior a la que contiene al
FORK, mientras que el otro proceso resultante continua su ejecución en
la línea marcada por la etiqueta (eventualmente ambos procesos
pueden continuar ejecutando en la misma línea si es que la etiqueta
apunta a la instrucción después del FORK).
 JOIN:
Sintaxis: JOIN contador, etiqueta
Comportamiento: El contador es una variable entera global. Al

momento de ejecutar el JOIN, el contador es decrementado. Si contador
= 0, el proceso salta a la instrucción indicada por etiqueta, de lo
contrario el proceso termina. La intención es que el contador este
inicializado con la cantidad de procesos que deberían llegar al JOIN, de
forma que todos los procesos salvo el ultimo terminen, y el último pase
a ejecutar la siguiente tarea, que deberá estar en la posición indicada
62
por etiqueta. La semántica de esta instrucción se ejecuta de forma

atómica como se muestra a continuación:
 GOTO:
Sintaxis: GOTO etiqueta
Comportamiento: El proceso salta a la dirección indicada por etiqueta.
 QUIT:
Sintaxis: QUIT
Comportamiento: Termina el proceso.
Esquemáticamente lo que ocurre es:
Una consideración a tener en cuenta es que la sintaxis del JOIN puede variar.
Por ejemplo, podemos encontrar casos donde el JOIN no especifique ninguna
etiqueta, solo el contador, de forma que tenemos JOIN contador, y por tanto su
semántica seguiría el siguiente esquema:
El SO UNIX sigue un esquema como el de FORK-JOIN, como ya vimos en la

Sección 4.3 acerca de la Creación de Procesos (ver el código C de ejemplo, pag. 40).
La asociación entre un grafo de precedencia y FORK-JOIN es prácticamente

directa. De esta forma, para el grafo que ya hemos visto es:
63
Con estas primitivas, el grafo que no podíamos solucionar utilizando las

sentencias COBEGIN-COEND, podemos solucionarlo usando FORK-JOIN como se
muestra a continuación:
La solución alternativa en este caso resulta mejor, puesto que al declarar los
contadores a medida que se necesitan se logra una mejor performance que si se
declararan al principio del código.
Con FORK-JOIN podemos implementar cualquier grafo de precedencia.
64
6.4 El problema de la Sección Crítica

Si consideramos un sistema que consta de n-procesos que se
ejecutan concurrentemente, cada proceso tiene incluido un en su código una
secuencia de declaraciones como esta:
Donde básicamente podemos encontrar cuatro secciones:
 Sección de Ingreso: Secuencia de instrucciones encargada de solicitar

permiso para entrar a la sección crítica.
 Sección Crítica: Secuencia de instrucciones donde el proceso puede

modificar datos comunes a todos los procesos a ejecutarse en forma
concurrente; tales como variables, tablas, archivos, entre otros.
 Sección de Egreso: Secuencia de instrucciones encargada de indicar que

se terminó de ejecutar la sección crítica.
 Sección Restante: Secuencia de instrucciones que corresponde al resto

del código, se ejecuta concurrentemente con los otros procesos sin afectar
nada.
Nuestra tarea es diseñar protocolos para la Sección de Ingreso y la Sección

de Egreso. De esta forma, una buena solución deberá satisfacer las siguientes cinco
condiciones:
1. Consistencia: Los programas deberán ser consistentes en el sentido que

no deberán depender del orden en que se ejecuten las instrucciones
concurrentes.
2. Mutua exclusión: A lo sumo un proceso a la vez se encuentra ejecutando

su sección crítica. Esto quiere decir que si un proceso está ejecutando su
sección crítica, los demás no pueden estar ejecutando sus secciones
críticas.
3. Ausencia de demoras innecesarias (o posposición indefinida): Si un

proceso está ejecutando su sección crítica y algunos procesos desean
entrar a sus correspondientes secciones críticas, la selección de quién
entra luego de que el proceso termine de ejecutar no puede posponerse
indefinidamente. Se produce un gasto de CPU. Esquemáticamente se
puede ver como:
65
Imaginemos la siguiente situación. Dos

personas caminan por la calle en sentidos
opuestos y se van acercando una a la otra. En
algún momento éstas se chocarán, y deberán
decidir cómo salir del problema para poder
seguir su camino. Al querer cederle el paso a
la otra persona, ésta se mueve hacia uno de
los lados pero la otra intenta hacer lo mismo,
volviendo a enfrentarse. Si repitiéramos este
proceso para salir del problema estaríamos
frente a una posposición indefinida.
4. Ausencia de deadlocks: Si dos o más procesos están intentando entrar a

sus secciones críticas, al menos uno tendrá éxito. Lo que se debe evitar es
todos los procesos esperen entrar a sus secciones críticas, pero ninguno
sea capaz de hacerlo.
Decimos que se produce un deadlock cuando un proceso espera por un
evento producido por un proceso que está esperando un evento del
proceso . Esquemáticamente se puede ver como:
Un auto en un cruce espera que su transversal ceda el

paso de la calle, y éste espera que otro auto avance, pero
este no puede avanzar porque tiene el mismo problema,
entrando en una especie de ciclo. De ésta forma ningún
auto avanza, entrando en deadlock.
5. Ausencia de alternancia: No puedo obligar a que se ejecuten primero un

proceso, luego el otro, vuelvo al primero, etc.
66
6.4.1 El problema de Alicia y Bernardo

Es un problema de acceso a la región crítica bajo mutua exclusión. El
enunciado del problema es el siguiente:
Alicia y Bernardo son vecinos, cada uno vive en su casa propia y comparten
un patio en común. Además cada uno tiene un perro que necesitan sacar a
pasear, pero si los perros están juntos se pelean. El problema consiste en
encontrar una forma de que ambos puedan convivir cumpliendo las reglas
anteriormente descriptas.
Formalizando el problema, Alicia y Bernardo son dos procesos y el patio es el

recurso a mutuo excluir. Claramente se trata de un problema de la sección crítica para
dos procesos.
Este problema así planteado da lugar a distintas soluciones como se detallará a

continuación, todas ellas presentan un problema: busy-wating.
Más adelante veremos herramientas que solucionan este problema y además

analizaremos otros problemas clásicos de la sincronización de procesos concurrentes.
67
Solución 1
Una posible solución se basa en determinar de quién es el turno para pasear al
perro. De esta forma resulta:
Los dos procesos comparten la variable global turno, y dependiendo del valor
de la variable pasean al perro.
Se cumple la mutua exclusión, no hay deadlocks ni posición indefinida, pero

presenta alternancia, pues hasta que Alicia no pasee el perro, Bernardo no puede
hacerlo.
Imaginemos que Alicia luego del pasear a su perro le cede el turno a Bernardo
y se va de viaje a Europa. Posteriormente, Bernardo pasea su perro y le cede el turno
a Alicia, pero ella aún no regresó de su viaje. De esta forma, hasta que Alicia no
regrese y pasee a su perro, Bernardo no podrá pasear al suyo.
Solución 2
Para resolver el problema de la alternancia, una segunda solución utiliza
banderas para determinar quién está paseando al perro en un determinado momento.
De esta forma, antes de pasear al perro se mira la bandera del otro, esperando que
éste al terminar de pasear su perro baje la bandera, y al hacerlo, levantar su propia
bandera para mostrar que paseará al perro, y luego de hacerlo, bajarla para que el
otro pueda pasear al perro. De esta forma resulta:
68
Los dos procesos comparten dos variables globales, dos banderas (flag_A y
flag_B). Consultando sus valores deciden si pasear al perro, modificándolas cuando lo
hacen o dejan de hacer.
Este algoritmo no se satisface la condición de mutua exclusión puesto que si

Alicia y Bernardo miran la bandera del otro al mismo tiempo y ésta se encuentra baja,
ambos levantan la bandera y sacan a pasear a los perros.
Formalmente lo que ocurre es que ambos procesos evalúan las flags

simultáneamente en su intensión de solicitar entrar en sus respectivas secciones
críticas. Esto es satisfecho puesto que los dos procesos cumplen con el protocolo de
la sección de ingreso y se le cede el permiso a ejecutar sus secciones críticas,
incumpliendo así la condición de mutua exclusión.
Para analizar la situación se utiliza el

método de entrelazado que representa el estado
de las banderas en cada una de las instrucciones,
tal y como se muestra en la figura de la derecha.
Como vemos, puede llegar a ocurrir que

ambos ejecuten la instrucción (3), que
corresponde con PASEAR_PERRO, violando la
condición de mutua exclusión.
La zona celesta clara muestra una zona de

peligro de posible acceso a la sección crítica,
mientras que la celeste oscura representa la
sección crítica propiamente dicha.
69
Solución 2 bis
Para resolver el problema de la mutua exclusión, otra forma de hacer lo mismo
que se propone en la Solución 2 es que uno levante su propia bandera, mostrando la
intensión de pasear al perro, y luego mire la bandera del otro para ver si puede pasear
al perro.
Esto se hace intercambiando las líneas (1) y (2) del algoritmo anterior,
resultando así:
Se resuelve el problema de mutua exclusión, pero este algoritmo puede llegar a

presentar un deadlock. Esto se ve mediante el método del entrelazado, donde la
zona roja representa el estado donde se produce el deadlock.
Esto ocurre cuando ambos levantan su bandera simultáneamente mostrando

su intensión de pasear al perro, y al mirar la bandera del otro ambos ven que tienen la
bandera levanta.
70
Solución 3
Si combinamos los dos primeros algoritmos, llegamos a la solución definitiva,
llamado Algoritmo de Dekker. De esta forma resulta:
Peterson soluciona igual que Dekker, pero es más general ya que esta última
solución es complicada para más de dos personas. La solución por el Algoritmo de
Peterson para el problema de Alicia y Bernardo viene dado por:
71
6.4.2 Algoritmo de Dekker

La solución general de Dekker para N-procesos toma un arreglo de banderas y
una variable turno, resultando así:
Notar que cuando se cede el turno al próximo proceso lo hace en forma circular
en función del identificador del proceso (en este caso i-ésimo), esto provoca
alternancia.
72
6.4.3 Algoritmo de Peterson

El Algoritmo de Peterson también es conocido como Algoritmo Tie-Breaker.
Su generalización para N-procesos, toma dos arreglos: uno de banderas y otro de
turnos. De esta forma resulta:
73
6.4.4 Algoritmo del Ticket

El Algoritmo de Peterson es un poco complejo y consecuentemente difícil de
entender. Esto se debe a que no es del todo obvio generalizar el algoritmo para dos
procesos a N-procesos. El Algoritmo del Ticket, resulta más amigable de entender
puesto que se basa en la misma idea que se usa a la hora de ir a una tienda y ‘sacar
número’ para ser llamado y luego atendido. De esta forma resulta:
Este algoritmo presenta dos desventajas. La primera es que como las variables
numero y siguiente no están acotadas superiormente, lo que eventualmente puede
producir un overflow puesto que siempre se las incrementa.
La segunda desventaja refiere a evaluar las instrucciones de la función

FetchAndAdd en forma atómica, o sea, sin interrupciones y en forma secuencial. Una
alternativa posible para solucionar este último problema es incorporando a la función
FetchAndAdd un protocolo de ingreso y egreso a la sección crítica que queremos que
se ejecute atómicamente. De esta forma, podemos reescribir la función FetchAndAdd
como:
74
6.4.5 Algoritmo de la Panadería de Lamport

Este algoritmo también es conocido como el Algoritmo Ticket-Like y soluciona
el problema de manejar una secuencia de instrucciones en forma atómica.
Se comporta de manera similar al Algoritmo del Ticket, con la diferencia de que

cuando un cliente llega a la panadería, primero mira alrededor a todos los demás
clientes y toma un número más grande que el de los demás. Los clientes de esta
forma se fijan entre ellos en vez de fijarse en un contador central que les diga quién es
el siguiente para decidir el orden del servicio. De esta forma resulta:
Donde la relación:
== true IF OR ( AND )
== false OTHERWISE
75
Algo que puede resultar llamativo del código propuesto es la secuencia de

instrucciones
turno[ i ] = 1 ;
turno[ i ] = max ( turno [ 0 : N-1 ] ) + 1 ;
Esto se debe a que, en ausencia de la primera instrucción, sigue existiendo la

posibilidad que dos procesos accedan a la sección crítica.
Suponiendo dos procesos P0 y P1, imaginemos que P0 lee turno[1] y obtiene

0. Luego, P1 empieza su protocolo de entrada, ve que turno[0] sigue siendo 0, setea
turno[1] = 1 y luego entra a su sección crítica. En este punto, P0 puede continuar su
protocolo de entrada, setear turno [0] = 1 y luego entrar a su sección crítica mientras
turno[0] y turno[1] son 1 y P0 toma precedencia en este caso. Esta situación es
llamada Condición de Carrera, donde P0 no vio que P1 cambió turno[1] = 1. Para
solucionarlo, cada proceso setea su valor en el arreglo turno a 1 (o cualquier valor
distinto de cero) y empieza su protocolo de entrada.
6.4.6 Test&Set y Exchange

Muchas maquinas cuentan con instrucciones de hardware para modificar
variables en forma atómica. En estos casos sólo interesa saber si algún proceso está
ejecutando su sección crítica o no.
La instrucción Test&Set se ejecuta atómicamente como unidad ininterrumpible,

por lo tanto, si se ejecutan dos o más a la vez, lo van a hacer secuencialmente y no
concurrentemente. Dicha instrucción sigue el siguiente comportamiento:
Y se utiliza para resolver el problema de la sección crítica de la siguiente

manera:
76
Por otro lado, la instrucción Exchange, análogamente al caso de Test&Set,

también se ejecuta atómicamente. Sigue el siguiente esquema:
Y se utiliza para resolver el problema de la sección crítica de la siguiente

manera:
77
6.5 Semáforos
Como ya se dijo, todos los algoritmos propuestos anteriormente
presentan el problema del busy-waiting. Con los Semáforos y otras
herramientas que veremos luego se soluciona este problema, ya que todas
ellas trabajan con lo que se denomina primitivas bloqueantes.
Los Semáforos son un TAD propuesto por Dijkstra que consisten en un

número entero no negativo, manipulado mediante una serie de operaciones atómicas:
 INIT: Inicializa el semáforo con un valor no negativo. La operación sigue el

siguiente comportamiento:
 P (WAIT): Decrementa el valor del semáforo. Si el valor del semáforo se

hace negativo, el proceso que ejecuta un P se bloquea. La operación sigue
el siguiente comportamiento:
 V (SIGNAL): Incrementa el valor del semáforo. Si el valor no es positivo, se

despierta(13) un proceso bloqueado por una operación P. La operación sigue
el siguiente comportamiento:
Las operaciones P y V nacen de los términos en holandés Proberen y

Verhogen, que significan ‘intentar’ y ‘aumentar’ respectivamente. Estas operaciones, al
ser atómicas, son indivisibles y no pueden ser interrumpidas. Por ello, el acceso a las
operaciones P y V debe ser mutuoexcluido. Debido a esto, la implementación de los
semáforos y la semántica sobre sus operaciones varía, de forma que:
 Utilizando busy-wating: Utilizan espera para la sincronización
13
Cuando pasan de la cola de bloqueados a la cola de procesos listos
78
 Utilizando operaciones: Permiten dormir y despertar procesos
Una implementación alternativa a la anterior
Las implementaciones de dormirProceso() y despertarProcesos() son

totalmente personales.
 Otras: Algunas implementaciones utilizan técnicas de T&S, o se invoca al

Scheduler, entre otras.
Las soluciones que usan semáforos no deben presuponer que las tareas
bloqueadas por una operación P, sean despertadas por V en algún orden particular. Lo
que si debe ocurrir es que toda operación P tiene una operación V asociada.
Un caso problemático de los Semáforos se da cuando se declaran dos

semáforos Q y S, y dos procesos ejecutan
y si al principio S y Q están en 0, puede haber deadlock.
79
Podemos hacer una analogía entre los semáforos presentados imaginando la

siguiente situación:
En una casa se realiza una fiesta, y en su techo hay una bandera con un
número entero; cuando su valor es positivo indica la cantidad de lugares libres,
cuando es cero es porque está llena, y cuando es negativo indica las personas
que están esperando a entrar. La bandera se actualiza en función del flujo de
personas dentro de la casa. Cuando una persona llega solicita permiso para
entrar y en función del valor de la bandera, si hay lugar, entra a la casa; sino se
queda esperando afuera hasta que alguno se vaya.
El tipo de semáforo presentado hasta ahora recibe el nombre de semáforos de

conteo. Una alternativa a estos son los denominados semáforos binarios, que solo
adoptan el valor 0 o 1. Si un semáforo binario está en 0 y se ejecuta un V (signal),
entonces queda en 1, análogamente si está en 1 y se ejecuta un V (signal), entonces
queda en 1. Son más fáciles de implementar y a partir de ellos se pueden implementar
los generales (haciendo que las operaciones indivisibles sean protegidas con un
semáforo binario).
Volviendo al grafo que no pudimos solucionar con COBEGIN-COEND, pero si

con FORK-JOIN, veremos ahora como solucionarlo utilizando Semáforos.
80
Utilizando semáforos binarios, primero etiquetamos las aristas problemáticas

(donde hay un FORK o un JOIN) y cada una de ellas se corresponde a un semáforo.
De esta forma resulta:
Los semáforos se inicializan en 0, por lo tanto todas las P bloquean y son las V
las que van destrancando ordenadamente.
Una alternativa a la solución anterior, pero esta vez usando un único semáforo
de conteo:
La principal desventaja de los semáforos es que al ser variables globales

tienen las dificultades de manejo que estas tienen (por ejemplo, en Sistemas
Distribuidos). Tampoco hay forma de consultar el valor de un semáforo, o sea, no
existe una operación status.
A continuación veremos cómo Semáforos Binarios y de Conteo son

herramientas equivalentes e ilustraremos como usar Semáforos en los clásicos
problemas de sincronización.
81
6.5.1 Equivalencia Semáforos Binarios – Semáforos de Conteo

Semáforos Binarios y de Conteo son equivalentes en el sentido de que pueden
resolver los mismos problemas de sincronización. Para ver dicha equivalencia basta
con mostrar cómo uno se implementa a partir del otro
Semáforos Binarios  Semáforos de Conteo
Semáforos de Conteo  Semáforos Binarios
82
6.5.2 Problema de Alicia y Bernardo

Recordemos que este problema tiene su origen en el problema de la mutua
exclusión de procesos para el acceso a la sección crítica. La solución viene dada por:
Para más de dos procesos el protocolo es el mismo. Si queremos que de n

procesos, sólo k (k<n) entren a la vez a la región crítica, entonces basta cambiar
83
6.5.3 Problema Productor-Consumidor

Enunciado del problema es el siguiente:
Contamos con un conjunto de procesos Productor que

almacenan en un buffer y con un conjunto de procesos
Consumidor que consumen del buffer.
De esta forma, el buffer debe ser mutuo excluido de los procesos involucrados,
y a su vez se debe controlar que un proceso Productor no coloque datos en un buffer
lleno, y análogamente, un proceso Consumidor no consuma datos de un buffer vacío.
Podemos encontrarnos frente a tres situaciones, que el buffer sea infinito, finito
o de capacidad nula. Este último se utiliza para la idea de randezvous que veremos
más adelante.
Buffer infinito
84
Buffer finito
En este caso debemos considerar un semáforo más que evite que se
coloquen datos en un buffer lleno. De esta forma tenemos:
Una observación de esta solución, es que siempre se cumple que:
85
6.5.4 Problema Lectores – Escritores

El enunciado:
Hay dos tipos de procesos, los Lectores y los Escritores,
compartiendo una base de datos. Los Lectores leen los
registros de la base de datos, mientras que los
Escritores actualizan la base de datos. Cada
transacción, si se ejecuta de forma atómica, transforma
la base de datos de un estado consistente a otro. Si dos
Lectores acceden simultáneamente no pasa nada malo,
sin embargo, si un Escritor y otro proceso (Lector o
Escritor) acceden simultáneamente, el resultado puede
ser erróneo.
El problema plantea el uso de una base de datos, pero bien podría ser un
archivo compartido, una lista enlazada, una tabla, o lo que sea.
La solución propuesta da preferencia a los lectores, lo cual no es justo si existe

un gran flujo de lectores puesto que no dejan acceder a los escritores a la base de
datos.
86
6.5.5 Problema Filósofos que Cenan

El enunciado del problema
Cinco filósofos se sientan alrededor de una mesa

circular. Cada filósofo invierte su vida únicamente
en pensar y comer. En el centro de la mesa hay un
gran plato de fideos. Se cuenta con cinco palitos
chinos dispuestos entre cada plato. Dado que los
fideos son largos y enredados, y los filósofos no
son muy hábiles con los palitos, un filósofo debe
utilizar dos palitos chinos para comer una ración.
Los filósofos se ponen de acuerdo en utilizar los
palitos que están inmediatamente a su izquierda y
derecha, y son muy pacientes para comer su ración
Una forma de solucionar el problema es representar cada palito con un

semáforo binario. De esta forma resulta:
87
Esta solución tiene dos problemas:
 No permite que dos vecinos coman simultáneamente

 Puede generar deadlock cuando todos los filósofos estén
hambrientos pero ninguno es capaz de adquirir ambos palitos (por
ejemplo, cuando los cinco toman su palito izquierdo, no pueden
tomar el derecho).
Algunas formas de solucionarlo son:
 Permitiendo que solo cuatro filósofos se sienten a la vez

 Solo permitir que tome los palillos sólo cuando los dos estén
disponibles (tomándolos dentro de una sección crítica)
 Solución asimétrica, donde los filósofos pares toman primero el de la
derecha y los impares primero el de la izquierda.
El código permitiendo que solo cuatro filósofos se sienten a la vez, se incorpora

un nuevo semáforo comedor que permite cuatro filósofos en la mesa.
88
6.5.6 Semáforos en UNIX

En Unix System V se trabaja con arrays de semáforos.
Operaciones:
 id = semget (key, count, flag)
Crea un semáforo. En id devuelve el identificador del semáforo. El

nombre del semáforo es key, count da el largo máximo del array de
semáforos, flag permite manejar distintas variantes.
 val_viejo = semop (id, oplist, count)
El retorno id es el semáforo a operar, oplist es un array con valores y

count dice cuántos de esos valores se consideran. Se suman los
valores del array oplist al array del semáforo. Si algún semáforo da 0, el
proceso que hizo semop se bloquea.
 semctl (id, nro, cmd, arg)
Setea el semáforo, id identifica al array de semáforos sobre el que

opera, nro es el número a configurar en todos los elementos del array,
cmd y arg permiten comandos y argumentos específicos.
89
6.6 Monitores
Los Monitores son módulos que proporcionan protocolos de comunicación
entre los procesos, encapsulando la representación de un objeto abstracto (recurso
compartido) y brindando un conjunto de operaciones que lo manipulan.
Los procesos pueden acceder al estado del objeto únicamente mediante las
operaciones que se proveen. La mutua exclusión está implícita asegurando que las
operaciones de un mismo monitor se ejecuten secuencialmente.
Todo monitor cumple tres propiedades:
 Solo los nombres de las operaciones son vistas fuera del monitor
 Las declaraciones dentro del monitor no tienen accesos a las variables
declaradas por fuera de él.
 Las variables del monitor son inicializadas antes de que cualquier operación
sea invocada.
Sigue un enfoque similar al OO (Orientado a Objetos), como si fuera una clase,

con la particularidad de que un solo proceso puede estar activo en el monitor, y si un
segundo proceso intenta ingresar, éste se bloquea. Su sintaxis queda determinada de
la siguiente manera:
La forma de invocar a una operación del Monitor es mediante el operador ‘.’ de

la siguiente forma: nombre_monitor . OPk.
90
Esquemáticamente podemos representar un monitor de la siguiente forma:
Como ya dijimos, la mutua exclusión está implícita, dado que el código

asociado a todas las operaciones es una sección crítica y por lo tanto nunca hay dos
instancias de una misma operación en ejecución. Sin embargo el monitor puede
suspender la ejecución de una operación para eventualmente ejecutar otra y más
tarde retomar la operación suspendida. Esto se logra mediante variables de tipo
Condition. Su declaración es: VAR X : Condition;
Por tanto estamos frente a un nuevo data type. El valor de la variable X

representa una cola de procesos demorados, inicialmente vacía. Esta cola no es
visible directamente al programador. Se cuenta con tres operaciones para manipular
las variables de tipo Condition:
 X.wait: El proceso que llega a ejecutar esta acción se suspende hasta que
otro proceso invoque X.signal dentro del mismo monitor. El proceso queda
en una cola FIFO que forma parte de X y le libera el monitor para que otro
proceso pueda hacer uso de él.
 X.signal: Si no hay procesos encolados en X, la acción no tiene efecto. Si

X tiene procesos encolados, el proceso que invoca X.signal cede el monitor
al primer proceso que quedó en espera. El proceso que ha cedido el
monitor podrá recuperarlo cuando el proceso que lo recibió salga del
monitor, salvo que este último lo ceda con otro signal a un tercer proceso.
 X.empty: Verifica si la cola de procesos de X está vacía. Su resultado es

true si la cola es vacía, sino es false. En el curso se prefiere evitar utilizar
esta operación.
91
Esquemáticamente podemos ver una variable de tipo Condition dentro de un

monitor de la siguiente manera:
Un problema que surge de la incorporación de las variables tipo condition es

que si un proceso ejecuta un signal y despierta un proceso, hay dos procesos que
pueden ejecutar en el monitor: El despertador y el despertado. Es inadmisible que
ambos procesos continúen, ya que de hacerse se violaría la condición que establece
que solo un proceso puede ejecutar el código del monitor. Por lo tanto, hay dos
posibilidades:
 Signal and Continue (SC) [Mesa]: Favorece que siga la ejecución el

proceso despertador, y el proceso despertado se ejecuta después. Es un
esquema no expropiativo. La razón de seguir este esquema es que el
proceso despertador nunca se bloqueó esperando una condición.
 Signal and Wait (SW) [Hoare]: El proceso despertador espera a ejecutar, y

el proceso despertado sigue la ejecución. Es un esquema expropiativo. La
razón de seguir este esquema es que el proceso fue despertado por algún
motivo.
Lo ideal es implementar la solución de manera que funcione sin importar si los

monitores actúan según una conducta o la otra. Por ello, conviene ubicar los signal al
final de un procedimiento del monitor para no tener problema con ninguno de los dos
esquemas. En caso de no ser posible, aclarar en la solución cual de las dos conductas
es la apropiada para que funcione.
En el siguiente diagrama de estados se ilustra cómo funciona la sincronización

de un monitor, tanto si sigue un esquema SC o SW.
92
6.6.1 Equivalencia Monitor - Semáforo

Semáforos y Monitores son equivalentes en el sentido de que pueden resolver
los mismos problemas de sincronización. Para ver dicha equivalencia basta con
mostrar cómo uno se implementa a partir del otro.
Monitor → Semáforo
Mostraremos dos formas de implementación de las primitivas de un Semáforos
a partir de Monitores.
La Alternativa (1) presenta el uso de la operación empty, que no se recomienda

en el curso. La más aceptable es la Alternativa (2).
Para implementar un semáforo binario con la Alternativa (2) podemos

reemplazar el cont por una variable booleana ocupado y la variable de condición
ocupado por una que se llame noOcupado. A su vez sustituimos las sentencias
93
cont=cont – 1 por ocupado=true y cont=cont+1 por ocupado=false, y la condición

cont==0 por ocupado.
Semáforo → Monitor
Mostraremos una posible forma de implementar Monitores a partir de
Semáforos. Para ello tendremos un semáforo mutex que mutuoexcluya el acceso a las
operaciones del monitor, otro semáforo por cada variable tipo condición (mostraremos
una) y un contador de procesos que esperan por dicha variable.
94
6.6.2 Problema Productor – Consumidor

En este caso solamente consideraremos el problema de sincronización para un
buffer acotado o finito.
95
6.6.3 Problema Lectores – Escritores

Esta solución al principio puede resultar un tanto extraña. Hay que tener en
cuenta que los contadores cantLectBloq y cantEscBloq se usan para no utilizar la
operacion empty sobre las variables de condición okLeer y okEscribir. Otra
consideración, es que esta solución no tiene una prioridad fija hacia Lectores o
Escritores, sino que va cambiando dependiendo de las necesidades. Una última
observación es que esta solución funciona con ambas semánticas de las variables tipo
condición, SW o SC.
96
97

Permitiendo solo cuatro filósofos en la mesa tenemos dos monitores, uno para
permitir la entrada a la mesa y otro para levantar/dejar el tenedor.
98
99
6.7 Mensajería
La funcionalidad real del paso de mensajes se ofrece, normalmente, por medio
de un par de primitivas:
 SEND: Encargada enviar mensajes
 RECIVE: Encargada de recibir mensajes
Este es el conjunto mínimo de operaciones necesario para que los procesos

puedan pasarse mensajes. Sin embargo la semántica de estos sistemas varía
ampliamente, y por lo tanto la programación también varía. De esta forma
encontramos tres grandes clasificaciones para el paso de mensajes:
 Comportamiento:
 Asincrónico: El envío es no bloqueante y la recepción es bloqueante. El

emisor sigue ejecutándose sin esperar a que la comunicación tenga efecto,
mientras que la recepción se bloquea a la espera de algún mensaje.
 Sincrónico: El envió y la recepción son bloqueantes. El se
bloquea hasta el mensaje.
OBS: La recepción siempre es bloqueante.
 Nombrado:
 Implícito: Se sabe a quién se envía o quién recibe el mensaje, por tanto no

es necesario especificarlo. Son de la forma:
 Explícito: Es necesario saber a quién envía o quién recibe el mensaje, por

tanto es necesario especificarlo. Son de la forma:
A su vez éstos se clasifican en dos tipos dependiendo de cómo se

comunican:
o Directo: Se sabe el identificador de quién envía o quién recibe el

mensaje. Son de la forma:
100
o Indirecto: Los mensajes se envían a una estructura de datos

compartida formada denominada buzón o mailbox (14) (cola) que
pueden guardar los mensajes temporalmente. Para que dos
procesos se comuniquen, uno envía mensajes al buzón y el otro
los toma del éste. Son de la forma:
La primitiva RECEIVE escrita como fue presentada, asume que el

pasaje del parámetro mensaje se hace por referencia. Por eso, se pueden
encontrar variantes, tal como
donde RECEIVE retorna el mensaje.
 Cardinalidad:
 (1:1) : Cada canal tiene un emisor y un receptor.
 (n:1) : Varios procesos pueden enviar mensajes por el canal y sólo uno
puede recibirlos.
 (n:m) : Varios emisores y varios receptores.
14
Para su creación se dispone de una primitiva CREATE(nombre_mailbox)
o CREATE(nombre_mailbox, tamanio_cola) en el caso que sea necesario dar la capacidad del mailbox.
101
Es posible utilizar cualquier combinación de éstos tipos de protocolos para

lograr la comunicación por medio de mensajería para cada proceso. Al resolver un
problema por Mensajería debe especificarse el protocolo de las operaciones SEND y
RECIVE, y si corresponde, también especificar el tamaño y propiedades del mailbox.
No es aceptable una solución que admita variables globales.
Un problema típico que surge en el manejo de estas primitivas para la

sincronización de procesos ocurre cuando:
No funciona correctamente, supongamos la siguiente situación:
- Llega una instancia del proceso P1, ejecuta el SEND y luego se le expropia
la CPU sin llegar a ejecutar el RECEIVE
- Llega otra instancia distinta de P1 y ejecuta lo mismo pero incluyendo el
RECEIVE
- Se retoma la ejecución de la primer instancia (la que fue desalojada de la
CPU)
Claramente, se recibirán los valores “al revés”. La primer instancia recibirá el

valor que envió la segunda, y la segunda instancia recibirá el valor que envió la
primera. Existen dos soluciones a este problema:
- Mutuoexcluir el SEND y RECEIVE del proceso P1 mediante un mailbox

mutex (de tamaño 1) – Poco elegante
- Se considera un mailbox por cada instancia de ese proceso, de forma que
sepa a quién mandarle el mensaje.
NOTA: Los problemas clásicos de sincronización presentados a continuación utilizan

la siguiente semántica:
- SEND – No bloqueante, de nombrado explícito indirecto.

- RECEIVE – Bloqueante, de nombrado explícito indirecto.
Y supondrán que el tamaño del mailbox es infinito. En caso de no cumplir alguna de

estas condiciones se dará aviso de ello.
102
6.7.1 Equivalencia Mensajería - Semáforos

Semáforos y Mensajería son equivalentes en el sentido de que pueden resolver
mostrar se implementan las primitivas de uno a partir del otro.
Mensajería → Semáforos
Semáforos → Mensajería
103
6.7.2 Equivalencia Mensajería - Monitores

Monitores y Mensajería son equivalentes en el sentido de que pueden resolver
mostrar se implementan las primitivas de uno a partir del otro.
Mensajería → Monitores
Necesitamos básicamente dos mailbox, uno tamaño unitario que mutuoexcluya
el acceso a las operaciones del monitor, y otro mailbox que mantenga los procesos
bloqueados esperando por la variable de condición, cuyo tamaño es arbitrario.
104
Monitores → Mensajería
105
Para el caso de buffer infinito no necesitamos del mailbox noLleno, ni tampoco

especificar la capacidad del mailbox buffer.
6.7.5 Problema Lectores-Escritores

La siguiente solución utiliza, además de los procesos Lectores y Escritores, un
proceso Controlador que se encarga de dar los permisos de lectura y escritura según
el caso. Notemos que el mailbox colaMsgCont guarda dos tipos de datos
simultáneamente. Esto puede hacerse así, o más prolijamente declarar un struct o
record con dos campos y que aloje solo un tipo de datos. También debemos saber de
antemano cuántos lectores y escritores hay, para que el Controlador sapa a quién
enviarle mensajes.
106
107

La comunicación se da por dos tipos de mailbox, uno de tamaño 4 para permitir
cuatro filósofos en la mesa, y otros cinco de tamaño 1 para cada tenedor.
108
6.8 Rendezvous - ADA

ADA es un lenguaje de programación cuyo punto de partida para su diseño fue
Pascal. Debido a esto comparte grandes características de este lenguaje. Su nombre
es en honor a la Condesa Lady Ada Lovelace, la primera programadora de la historia.
Para la comunicación y sincronización de tareas, ADA utiliza la idea de

RENDEZVOUS, del francés cita o encuentro. En términos informáticos, momentos en
que dos hilos de ejecución se encuentran.
En este contexto, existen tareas que solicitan encuentros, y otras tareas que
aceptan encuentros. Los pedidos de encuentro son vistos como llamadas a subrutinas
desde la tarea que los llama. El intercambio de datos entre procesos se da en estos
puntos específicos en que los procesos se encuentran.
Cuando un proceso pide un encuentro, éste se bloquea hasta que sea

atendido, o también puede quedarse esperando hasta recibir a alguien que quiera
tener un encuentro con él. Las citas son atendidas siguiendo un algoritmo FCFS (First
Come First Served).
La sintaxis de ADA permite manejar concurrencia entre tareas mediante TASK,

su sintaxis es la siguiente:
Las TASK se ejecutan concurrentemente luego del BEGIN del programa

principal.
Un rendezvous es generado por una tarea a través de una declaración ENTRY
y la otra tarea realizando una invocación a esta tarea ENTRY. De esta forma, la
sintaxis para solicitar/aceptar citas:
109
Por ejemplo:
IMPORTANTE: Es un mal hábito de programación utilizar variables globales a

la hora de trabajar con concurrencia en ADA. El código de un ACCEPT debe ser corto.
Un ejemplo más completo es el típico Factorial, escrito en ADA:
110
Dado que cada tarea es única, si necesitáramos dos tareas con exactamente el
mismo código deberíamos escribirlo dos veces con distinto nombre. Para ello, las
TASK pueden definirse como TYPE siguiendo la siguiente sintaxis:
De esta forma, podemos declarar varias TASK con el nombre que le dimos,
cada una siguiendo el mismo BODY.
ADA cuenta con otra herramienta que resulta útil con concurrencias, el
SELECT, que permite seleccionar entre varias entradas separadas por OR.
A su vez, si es necesario que alguna de las entradas de una selección se

acepte sólo en determinadas condiciones, se puede tener como prefijo una cláusula
WHEN llamada guarda y son evaluadas al ejecutar el SELECT. Las entradas cuyas
guardas son verdaderas se tienen en cuenta para la selección y decimos que están
abiertas. Por el contrario, las entradas cuyas guardas son falsas se ignoran y se dice
que están cerradas. Las entradas que no tienen guarda se consideran siempre
abiertas.
Dado que es un error que todas entradas estén cerradas, se cuenta con una
cláusula ELSE que se ejecuta si al llegar al SELECT no se puede aceptar
inmediatamente ninguna otra entrada.
Cabe destacar que cada entrada contiene al menos un ACCEPT, y siempre al

principio (sin código entre medio). Entonces, considerando el contenido entre
paréntesis rectos como opcional, la sintaxis del SELECT queda determinada de la
siguiente forma:
111
Dado que la cláusula ELSE puede resultar muy rígida, y además puede
generar busy-waiting si siempre se sale por ella, tenemos como alternativa la cláusula
DELAY que sigue la siguiente sintaxis
y su semántica implica esperar X-tiempos por si alguna guarda se habilita.
Podríamos ver al ELSE como un OR DEYAY 0. La ausencia de ELSE o DELAY

en un SELECT podría llegar a provocar un error. No puede haber ELSE y alternativas
DELAY en un mismo SELECT.
El SELECT funciona de la siguiente manera:
 Se evalúan todas las guardas para determinar cuáles entradas están

abiertas.
 Si hay más de una entrada abierta con al menos una tarea esperando
un encuentro por ella, se elige al azar entre esas entrada cuál se va a
atender. Dentro de una misma entrada el orden es FIFO.
 Si no hay ninguna tarea esperando en alguna entrada abierta y hay una

opción ELSE entonces se sale por el ELSE.
 Si no hay ninguna tarea esperando en alguna entrada abierta y hay una

opción DELAY X entonces se espera como máximo la X tiempo para
ver si alguna tarea pide un encuentro con una entrada abierta. Si alguna
tarea pide encuentro se la atiende; en caso contrario, cuando pasa el
tiempo especificado, se sale por la clausula DELAY.
 Si hay entradas abiertas pero no hay opción ELSE ni DELAY X, se

queda bloqueado hasta que alguna tarea pida un encuentro por una de
las entradas abiertas.
 En ausencia de una cláusula ELSE, si al evaluar las guardas se

determina que no hay ninguna entrada abierta (notar que una entrada
que no tiene guarda siempre está abierta) entonces se aborta el
programa.
La semántica planteada para el SELECT es para aceptar citas. La semántica

para del SELECT para solicitar citas queda determinada únicamente de las siguientes
dos maneras
112
donde si hay alguien bloqueado esperando un ACCEPT y se solicita un encuentro con

este, se efectiviza dicho encuentro; sino se sale por la cláusula ELSE o se espera
cierta cantidad de tiempo en el OR DELAY para ver si se efectiviza una cita. En este
caso las alternativas de SELECT en la tarea emisora no pueden tener guarda. El caso
de SELECT-ELSE se utiliza para que la solicitud de citas no sea bloqueante.
Una aclaración, la instrucción DELAY X también se utiliza como una sentencia

de ADA, pudiendo aparecer en cualquier parte del código y donde el proceso que la
ejecuta se bloquea por X-unidades de tiempo.
Otra herramienta que proporciona ADA es verificar el estado de un ENTRY

mediante el operador ‘count. Este atributo devuelve el número de tareas actualmente
en cola de espera para entrar en el procedimiento ENTRY. De esta forma podemos
utilizar este operador para determinar en qué orden ejecutar las instrucciones del
cuerpo de SELECT (deja de ser aleatorio).
Un ejemplo sencillo para ver su funcionamiento se basa en establecer

prioridades entre los procesos, de esta forma:
Un error habitual al utilizar el SELECT combinado con el operador ‘count surge

cuando consideramos el valor de ‘count sobre un ACCEPT con el mismo nombre
dentro de una misma guarda, tal y como se muestra a continuación:
113
Si bien sintácticamente es correcto, la semántica del SELECT cambia. Si

ningún proceso pidió una cita con e1, por ejemplo, no se espera para ver si alguno lo
pide (no pasa a la cola de bloqueados), sino que directamente no ofrece ese ACCEPT
porque la guarda no está abierta. Esto podría ser correcto, pero depende del contexto
al que se aplique.
6.8.1 Equivalencia Rendezvous → Semáforos

Semáforos y Rendezvous son equivalentes en el sentido de que pueden
resolver los mismos problemas de sincronización, en particular si utilizamos ADA para
los rendezvous. Para ver dicha equivalencia basta con mostrar se implementan las
primitivas de uno a partir del otro.
Notar que definimos el TASK Semáforo como TYPE de forma de declarar la

cantidad que queramos de Semáforos, todos respetando el mismo código. Observar
también que no se utiliza ELSE ni OR DELAY por cómo funcionan los semáforos.
114
115
Siendo , o bien (para no usar el ARRAY) pueden declararse dinámicamente

instancias de Productor/Consumidor en el cuerpo principal. Notar que la variable
ocupado de la TASK Buffer_finito, o bien está dentro del rango 0 < ocupado <
TAM_BUFF o bien está por fuera (por debajo o por encima) por eso no se utiliza ELSE
ni DELAY, porque una de las entradas siempre queda abierta.
6.8.4 Problema Lectores-Escritores
116

Permitiendo 4 filósofos en la mesa:
117
7 Deadlocks
Decimos que un sistema informático está en deadlock (o en interbloqueo) si
para un conjunto de procesos cada proceso espera por un evento que es provocado
por un proceso de ese conjunto.
7.1 Bloque Descriptor de Recursos (RCB)

Por recurso entendemos a todo dispositivo de hardware e información
almacenada en el sistema (por ejemplo, un fichero).
En una computadora puede haber distintos tipos de recursos así como también
varias unidades de un tipo particular de recurso. Para ello definimos un recurso como
una entidad que se utiliza para realizar un trabajo determinado en el sistema y que
solo la puede usar un proceso en un instante dado.
Los recursos se pueden clasificar a grandes rasgos en dos tipos:
 Reutilizables: pueden usarse por varios procesos, uno a la vez (esperando

en una cola).
 Consumibles: una vez utilizados desaparecen, exigiendo que haya un
proceso consumidor y otro productor de ese recurso.
Debido a esto, es necesario incluir una estructura de datos para modelar los
distintos recursos presentes en el sistema. Toda clase de recurso R se describe
mediante su Resourse Control Block (RCB). Éste incluye:
 Un identificador único (ID)

 Una flag que indica si es reutilizable o consumible.
 El propietario del recurso
 Una lista de los recursos disponibles de tipo R.
 Una cola de los procesos a la espera por operaciones relacionadas al
recurso R. Cada nodo contendrá:
o un puntero al PCB correspondiente
o información sobre el pedido
o que está esperando dentro del recurso para ser desbloqueado.
 El estado del recurso, dañado, disponible, funcionando, etc.
 Un puntero al código administrador del recurso
 Un puntero para realizar altas y bajas en las colas.
118
7.2 Modelo del sistema

Un sistema informático consiste en:
 Cantidad finita de recursos: Deben distribuirse entre varios procesos

que compiten por ellos. Los recursos pueden ser físicos(15) o lógicos(16).
 Varios tipos de recursos: Cada tipo de recurso consta de cierta

cantidad de ejemplares idénticos (unidades de recursos).
 Cantidad finita de procesos: Existe una cantidad finita de procesos

ejecutándose.
Los procesos y recursos siguen ciertas pautas:
- Los procesos piden recursos que estén en el sistema.

- Los procesos no piden por más recursos de los que se dispone. Por
ejemplo, no piden dos recursos si solo dispongo de uno de ellos.
- Si un proceso solicita un ejemplar de un tipo de recurso específico, la
asignación de cualquier ejemplar del tipo satisface la solicitud.
Todo proceso puede utilizar un recurso siempre y cuando cumpla con la siguiente
secuencia de acciones:
 Solicitud: Si el recurso no está disponible, el proceso queda bloqueado

hasta que lo pueda utilizar
 Uso: El proceso opera con el recurso, permaneciendo bloqueado mientras
trabaja
 Liberación: El proceso libera el recurso para que otros proceso puedan
usarlo luego
La solicitud y liberación se realizan por medio de system call al SO. Una tabla
del sistema registra si cada recurso está libre o asignado. Si un proceso solicita un
recurso ocupado, se lo coloca en la cola de procesos que esperan ese recurso.
15
impresora, memoria, ciclos de CPU, etc.
16
archivos, semáforos, monitores, etc.
119
7.3 Condiciones necesarias para la existencia de deadlock

Para asegurar que un conjunto de procesos ha alcanzado la situación de
deadlock, será necesario que se cumplan simultáneamente las siguientes cuatro
condiciones:
 Mutua Exclusión: Al menos un recurso debe adquirirse de forma no

compartida, o sea, solo puede usarlo un proceso a la vez. Si otro proceso lo
solicita, debe esperar.
 Posesión y Espera (Hold & Wait): Debe existir un proceso que haya
adquirido al menos un recurso y esté esperando para adquirir recursos
adicionales, que ya fueron otorgados a otros procesos.
 No Expropiación (No Preempty): Los recursos no se pueden arrebatar, es

decir, la liberación es voluntaria por parte del proceso que adquirió el
recurso.
 Espera Circular: Debe existir un conjunto de procesos en

espera tal que espera un recurso adquirido por , espera uno
adquirido por ,…, espera uno adquirido por .
Estas condiciones son además suficientes si existe un solo ejemplar de cada

recurso implicado en la espera circular.
7.4 Grafo de Asignación de Recursos

Definimos como grafo de asignación de recursos al grafo dirigido ,
donde:
 : Conjunto de vértices, con:
, se representan con círculos
, se representan con un cuadrado y puntos adentro,

donde cada punto es una unidad de recurso. En ausencia de puntos se
asume un único ejemplar.
Claramente, para que el modelo tenga sentido,
 : Conjunto de aristas, cuyos elementos son de dos tipos:
Arista de solicitud : El proceso pide y espera el recurso
Arista de asignación : El recurso está asignado al proceso .
A partir del grafo de asignación de recursos, podemos dedicar la presencia de

un deadlock de la siguiente forma:
a. Si no contiene ciclos entonces no existe deadlock.
120
b. Si contiene ciclos, podemos encontrar dos situaciones:

1. Si los recursos solo tienen un único ejemplar, hay deadlock.
2. Si hay varios ejemplares, no necesariamente hay deadlock. Hay que
chequear las instancias del recurso.
A continuación se presentan algunos ejemplos de grafos de asignación de

recursos contemplando los casos anteriormente descriptos:
7.5 Tratamiento de deadlocks

Actualmente hay cuatro estrategias para tratar una situación de deadlock que
se detallarán a continuación y se basan en:
 Ignorarlo
 Prevenirlo
 Evitarlo
 Detectarlo y recuperarlo
7.5.1 Ignorar el deadlock

La idea de esta estrategia es no tener en cuenta en el SO estas situaciones.
También recibe el nombre de Algoritmo del Avestruz, un tanto bufonesco, pues
establece que “meta su cabeza en la arena y pretenda que no hay ningún problema”.
En principio esta estrategia parecería ser una locura, pero no lo es si se tiene

en cuenta que la aparición de deadlocks es altamente improbable. Supongamos que
ocurre un deadlock en promedio de una vez cada cinco años, pero los fallos del
sistema debido al hardware, errores del compilador y errores propios en el SO ocurren
una vez por semana. En tal situación, la mayoría de los ingenieros no estarán
dispuestos a reducir considerablemente el rendimiento del sistema por eliminar los
deadlocks.
Esta estrategia le cede el problema de prevenir los deadlocks al programador

de aplicaciones, y el SO “se lava las manos”.
121
7.5.2 Prevenir el deadlock

Esta estrategia se basa en negar alguna(17) de las cuatro condiciones
necesarias que dan origen a un deadlock y asegurar que se cumplan. De esta forma,
los mecanismos más usuales para negar dichas situaciones son:
 Caso de Mutua Exclusión: Ningún proceso puede tener acceso exclusivo

a un recurso. Por ejemplo, dos o más procesos no pueden compartir una
impresora (salvo que se utilice un SPOOL, evitando así que no se envíe
directamente al dispositivo), pero sí pueden compartir un archivo de solo
lectura. Sin embargo, esta negación es difícil de conseguir, puesto que hay
recursos que son intrínsecamente no compartibles.
 Caso de Posesión y Espera: Siempre que un proceso solicite un recurso,

no debe retener a otro. De esta forma tenemos dos alternativas para evitar
esta situación:
 El proceso solicite y reciba todos los recursos antes de iniciar su

ejecución
 El proceso pueda solicitar recursos solo cuando no tiene ninguno, y

para solicitar nuevos, libera los que tiene.
Ambos protocolos presentan dos desventajas:
o Baja tasa de utilización de los recursos dado que los recursos
pueden asignarse pero no utilizarse durante un periodo largo de
tiempo.
o Fenómeno de inanición, cuando un proceso utiliza recursos que

son muy solicitados, pudiendo así esperar indefinidamente a que
todos se liberen para usarlos
 Caso de No Expropiación: Si un proceso está reteniendo varios recursos

y solicita otro que no se le puede asignar de inmediato, entonces todos los
recursos que tiene se liberarán implícitamente. Es aplicable solo a recursos
cuyo estado puede guardarse fácilmente y restaurarse luego.
Alternativamente, si un proceso solicita varios recursos, primero
comprobamos si están disponibles. Si lo están, se le asignan
inmediatamente. Sino, comprobamos si están asignados a otro proceso que
a su vez espera por otros recursos. Si es así, se desaloja los recursos
deseados del proceso en espera y los asignamos al proceso que lo solicita.
Si los recursos no están disponibles ni retenidos por otro proceso, entonces
el proceso solicitante debe espera.
 Caso de Espera Circular: Se impone un ordenamiento total de los

recursos y se exige que cada proceso los solicite en orden creciente de
enumeración. Cuando se requieren varios ejemplares de un mismo recurso,
se debe emitir una sola solicitud que los incluya a todos. Para pedir
recursos con número mayor, debo liberar los que ya tengo.
17
Dado que deben ocurrir las cuatro simultáneamente para que se produzca un deadlock.
122
7.5.3 Evitar el deadlock

Se pueden evitar situaciones de deadlock siempre y cuando tengamos a
disposición cierta información sobre los recursos previamente.
Dado que se precisa este tipo de información, evitar los deadlocks disminuye el
rendimiento del sistema. El estado de asignación de los recursos está definido por el
número de recursos disponible y asignado, y las demandas máximas.
Un sistema está en estado seguro si existe una secuencia segura de procesos

en los que el sistema puede asignar recursos a cada uno de ellos en algún orden,
evitando bloqueos. Si no existe, el estado del sistema es inseguro, pudiendo derivar
en deadlock.
De esta forma, todo deadlock se produce en un

estado inseguro del sistema, pero no todo estado inseguro
provoca un deadlock.
La idea es asegurar que el sistema siempre

permanecerá en un estado seguro, así que antes de
asignarle cualquier recurso, debo verificarlo.
Ejemplo:
Consideremos un sistema con 12 unidades de cinta magnética y tres procesos

, y . El proceso necesita 10 unidades de cinta, necesita 5 y
necesita 9.
Ahora, suponiendo que en el instante el proceso retiene 5 unidades de

cinta, retiene 2 y necesita 2, quedando disponibles 3. En este instante, el
estado es seguro, pues la secuencia < > satisface las condiciones de
seguridad, dado que al proceso se le pueden asignar las 3 unidades de cinta
disponibles y termina su ejecución, liberando 5 unidades. A continuación, el
proceso toma estas 5 unidades libres y también culmina su proceso,
liberando 10 unidades. Por último toma 7 de las 10 unidades libres, y
culmina su proceso, liberando las 12 unidades.
Ahora, supongamos que se pasa del instante al instante , en este instante

se le asigna una unidad de cinta más al proceso (tiene 3 en vez de 2). El
estado pasa a ser inseguro, pues tenemos únicamente 2 unidades disponibles,
al asignarle estas cintas al proceso éste cuenta con 4, para terminar le falta
1, pero las otras cintas están siendo usadas por y , llevando a un
deadlock, pues ninguno libera las cintas que están usando y esperan que
alguien se las dé.
De esta forma, para evitar deadlocks contamos con dos algoritmos que nos
garantizan estar en un estado seguro del sistema.
123
Algoritmo por Grafo de Asignación de Recursos

Cuando tenemos un solo ejemplar de cada tipo de recursos, podemos usar una
variante del Grafo de Asignación de Recursos.
Además de la arista de solicitud y la de asignación, tenemos la Arista de

Reserva que indica que podría solicitar en un instante futuro. Se
representa con una flecha de línea discontinua.
Los recursos deben reservarse a priori en el sistema, o sea que antes de iniciar
la ejecución, ya deben aparecer todas las aristas de reserva.
El algoritmo para evitar un deadlock es simplemente gráfico, la solicitud de un

recurso solo puede ser satisfecha si la conversión de una arista discontinua en
continua no da lugar a ciclos(18).
Este algoritmo no es aplicable a los sistemas de asignación de recursos de

múltiples instancias de cada tipo de recurso.
Algoritmo del Banquero

Este algoritmo, a diferencia del anterior, no es gráfico sino matemático.
Cuando un proceso entra al sistema, debe declarar el número máximo de

ejemplares de cada tipo de recursos que podría necesitar, el cual no puede exceder el
total de recursos del sistema. Cuando el proceso solicita un conjunto de recursos, el
sistema debe determinar si la asignación no lo deja en un estado inseguro.
Hay que mantener varias estructuras de datos para implementar este algoritmo.
Ellas son:
 Recursos: Vector de longitud que indica el total de recursos por ejemplar

en el sistema. sii hay ejemplares del recurso .
Estructura:
 Disponible: Vector de longitud que indica el número de recursos

disponibles de cada tipo. sii hay ejemplares disponibles
del recurso .
18
Cuando se pasa de una Arista de Reserva a una Arista de Asignación
124
Estructura:
 Max: Matriz que define la demanda máxima por ejemplar de recurso

de cada proceso. sii el proceso puede solicitar como
máximo unidades del recurso .
Estructura:
 Asignación: Matriz que define el número de recursos que se han

asignado actualmente a cada proceso. sii el proceso
tiene asignados actualmente ejemplares del recurso .
Estructura:
 Necesidad: Matriz que indica los recursos que todavía le hacen falta a
cada proceso. sii el proceso necesita ejemplares
del recurso .
Estructura:
Para simplificar la notación, diremos que si y es un vector de

longitud , entonces será el vector fila -ésimo de la matriz , y
. Por otro lado notemos que se cumplen ciertas propiedades entre
estas estructuras:
 , todos los recursos están o bien

asignados o bien disponibles.
 , ningún proceso puede demandar más

recursos que la cantidad total de recursos del sistema.
 , ningún proceso tiene asignados

más recursos de cualquier tipo que los que declaró necesitar.
 , la cantidad de recursos que

necesita un proceso es la diferencia entre la cantidad de recursos que
solicitó y la cantidad que tiene asignados.
125
Algoritmo de seguridad
Tiene como objetivo determinar si el estado del sistema es seguro o no. Sigue el
siguiente esquema:
1. Sean trabajo y fin, vectores con longitud m y n respectivamente. Inicializo:

a.
b.
2. Buscar una tal que:

a.
b.
Si no existe
ir a (4)
3.
Ir a (2)
4. Si para toda , el sistema está en estado seguro.
Algoritmo de solicitud de recursos

El sistema lo utiliza para averiguar si puede satisfacer la petición de recursos. Sea
el vector de solicitudes del proceso . Si , el proceso quiere
ejemplares del tipo de recurso . Para otorgarlos se siguen los siguientes pasos:
1. Si
indicar error ya que el proceso excedió su reserva máxima
Sino
ir a (2)
2. Si ,
debe esperar a que los recursos estén disponibles.
Sino
ir a (3)
3. El sistema simula haber asignado los recursos al proceso de la forma:
4. Si el estado resultante es seguro, la transacción se lleva a cabo, asignando los recursos

a , sino tendrá que esperar, y se restaura el antiguo estado de solicitud de recursos.
126
El Algoritmo del Banquero resulta de llevar a cabo el Algoritmo de

Seguridad y el Algoritmo de Solicitud de Recursos. En pseudocódigo:
Funcion Seguridad() retorna Boolean

/* Determinar si el estado del sistema es seguro o no */
Trabajo := Disponible;
Para todo i
Fin[ i ] := false
FinPara
Mientras ∃ i : Fin[ i ] == false AND Necesidad[ i ] <= Trabajo hacer
Trabajo := Trabajo + Asignacion[ i ]
Fin [ i ] := true
FinMientras
Si i : Fin [ i ] == true
Entonces
Seguridad := true
Sino
Seguridad := false
FinSi
Fin Seguridad
Procedimiento Solicitud_Recursos(Solicitud [ i ] )
/* Averiguar si puede satisfacer la petición de recursos */
Si Solicitud [ i ] > Necesidad[ i ]
Entonces /*excedió su reserva máxima */
ERROR
FinSi
Si Solicitud [ i ] > Disponible
Entonces /* esperar a que los recursos estén disponibles */
Suspender_Proceso( i )
Sino /* simular haber asignado los recursos */
Disponible := Disponible - Solicitud [ i ]
Asignacion [ i ] := Asignacion [ i ] + Solicitud [ i ]
Necesidad[ i ] := Necesidad[ i ] - Solicitud [ i ]
Si Seguridad() /* se invoca función */
Entonces /* llevar a cabo transacción */
Dar_Recursos_A_Proceso( i )
Sino /* deshacer simulacion */
Disponible := Disponible + Solicitud [ i ]
Asignacion [ i ] := Asignacion [ i ] - Solicitud [ i ]
Necesidad [ i ] := Necesidad[ i ] + Solicitud [ i ]
Suspender_Proceso( i )
FinSi
FinSi
Fin Solicitud _Recursos
Algoritmo Banquero
/* Dadas las estructuras Disponible, Solicitud, Asignación y Necesidad */
Para todo j /* Analizar todos los recursos solicitados */
Solicitud _Recursos(Solicitud[ i , j ])
FinPara
Fin Banquero
127
Ejemplo:
Consideremos un sistema con cinco procesos ,.., y tres tipos de recursos
y . El recurso tiene 10 instancias, el tiene 5, y el tiene 7. Supongamos que
en el instante tenemos:
Podemos afirmar que el sistema se encuentra actualmente en estado seguro,

dado que la secuencia < > satisface los criterios de seguridad.
Supongamos que el proceso solicita una instancia más del recurso y dos del ,
por lo que . El primer paso del algoritmo es chequear que
o sea . El segundo paso es verificar
, o sea , lo cual se cumple. Supongamos que
la solicitud es satisfecha y se llega al siguiente nuevo estado
Primero debemos determinar si el estado del nuevo sistema es seguro, y esto

es cierto dado que la secuencia < > satisface las condiciones de
seguridad. Por lo tanto, podemos conceder inmediatamente la solicitud al proceso .
Sin embargo, cuando el sistema se encuentra en este estado, una solicitud de
por parte de no se puede conceder ya que los recursos no están disponibles.
Además, no se puede conceder una solicitud de valor por parte de , por más
que los recursos estén disponibles, pues llegaríamos a un estado inseguro. [verificarlo]
7.5.4 Detectar y Recuperar el deadklock

Si el sistema no previene o evita deadlocks, se puede encontrar con una
situación de bloqueo. Para ello necesita:
 Un algoritmo que examine el estado del sistema y determine si hay

deadlock.
 Un algoritmo para recuperarse del bloqueo.
Este esquema de detección y recuperación requiere un gasto extra que incluye

no solo los costos en tiempo para mantener la información sino también para
recuperarse después del bloqueo.
128
En primer lugar examinaremos los algoritmos que nos permiten detectar un

deadlock, y posteriormente las estrategias que nos permiten recuperarnos de él.
Si los bloqueos mutuos son frecuentes el algoritmo de detección deberá

invocarse muy seguido ya que los recursos asignados a los procesos bloqueados
están ociosos hasta romper ese deadlock, además el número de procesos bloqueados
puede crecer.
Los deadlocks sólo pueden aparecer cuando algún proceso pide un recurso y
no se le puede asignar inmediatamente. Se podría invocar el algoritmo cada vez que
esto sucede, además podemos identificar inmediatamente el proceso causante del
bloqueo. Pero invocarlo tan frecuentemente, puede causar demasiado gasto extra de
tiempo, por lo tanto se lo puede invocar luego de un tiempo determinado (Ej: 1 hora) o
cuando el uso del CPU baja del 40%. En este caso pueden existir muchos ciclos en el
grafo, y se dificulta identificar los procesos causantes del bloqueo.
Detección cuando se dispone de un solo ejemplar de cada recurso

Se utiliza el grafo de espera. Se obtiene eliminando del grafo de asignación de
recursos los nodos del tipo recurso de la siguiente forma: Si en el grafo de asignación
de recursos tenemos las aristas & entonces en el grafo de espera
tenemos la arista , siempre y cuando , y (dado que
si esto ocurre tendría la arista y no , pues demora más).
Una arista de a implica que el proceso , espera a que libere un recurso

que necesita.
Ejemplo:
Existe un deadlock sii en el grafo de espera hay un ciclo. El sistema necesita

mantener la información del grafo, y periódicamente invocar a un algoritmo de
detección de ciclos.
129
Detección cuando se dispone de varios ejemplares de cada recurso

Para este caso se utilizan estructuras similares a las del Algoritmo del
Banquero. Estas son:
 Disponible: Vector de longitud que indica el número de recursos

disponibles de cada tipo. sii hay ejemplares disponibles
del recurso .
 Asignación: Matriz que define el número de recursos que se han

asignado actualmente a cada proceso. sii el proceso
tiene asignados actualmente ejemplares del recurso .
 Solicitud: Matriz que indica la solicitud actual de cada proceso.

sii solicita ejemplares de .
El algoritmo procede de la siguiente forma

1. Sean trabajo y fin vectores con longitud m y n respectivamente. Inicializo:
a.
b. Si
Sino
2. Busco tal que

a.
b.
c. Si no existe , ir a (4)
3.
Ir a (2)
4. Si para alguna entonces el sistema está en deadlock para

ese .
130
Escrito en pseudocódigo:
Funcion Detección retorna Boolean

Trabajo := Disponible
Para todo i
Si Asignacion [ i ] <> 0
Entonces
Fin[ i ] := false
Sino
Fin [ i ] := true
FinSi
FinPara
Mientras ∃ i tal que Fin [ i ] == false AND Solicitud[ i ] <= Trabajo
Trabajo := Trabajo + Asignacion [ i ]
Fin [ i ] := true
FinMientras
Si i Fin [ i ] == true /* Aquellos procesos para los que Fin[ i ] sea falso,
Entonces forman parte de un deadlock. */
Detección := false
Sino
Detección := true
FinSi
Fin Detección
Ejemplo:
Consideremos un sistema con cinco procesos ,.., y tres tipos de recursos

y . El recurso tiene 7 instancias, el tiene 2, y el tiene 6. Supongamos que
en el instante tenemos:
Podemos afirmar que el sistema no se encuentra en estado de

deadlock. En efecto, si ejecutáramos nuestro algoritmo, comprobaremos
que la secuencia < , > da como resultado fin[i] == true para
todo i.
Suponga ahora que el proceso hace una solicitud de una

instancia más del tipo de recurso C. La matriz de solicitud se modifica
como se muestra en la derecha.
Ahora podemos afirmar que el sistema está en deadlock. Aunque podemos

reclamar los recursos retenidos por el proceso , el número de recursos disponibles
no es suficiente para satisfacer las solicitudes de los restantes. Por tanto, existe un
deadlock entre los procesos , .
131
Recuperación después de un deadlock

Cuando un algoritmo detecta un deadlock se puede o bien informar al operador
para que lo solucione manualmente o bien dejar que el SO se recupere
automáticamente. Las opciones para eliminar el deadlock son terminar anormalmente
los procesos o expropiarle recursos.
I. Terminación de un proceso
Hay dos formas:
 Abortar todos los procesos bloqueados: El costo es elevado puesto que

alguno de los procesos puede haber estado trabajando por largo tiempo.
 Abortar de a un proceso hasta desbloquearlos: Incluye un gasto

adicional, puesto que luego de eliminar cada proceso hay que llamar
nuevamente al algoritmo de detección.
La terminación forzada de procesos no es fácil, puesto que podría dejar

incoherencia de datos. Para saber que procesos del bloqueo se pueden abortar, se
debería usar un algoritmo similar al de la planificación de CPU. Se deben abortar los
procesos causando el más bajo costo posible.
Los factores para selección de procesos son:
- Prioridad del proceso

- Tiempo que ha trabajado, y cuanto más debe trabajar
- Recursos usados y de qué tipo (si los recursos se pueden expropiar
fácilmente)
- Recursos adicionales que necesita para terminar su tarea
- Cantidad de procesos para abortar
- Si los procesos son interactivos o por lotes
II. Expropiación de recursos

Expropiamos recursos de unos procesos para dárselos a otros, hasta romper el
bloqueo. Hay que considerar tres aspectos:
 Selección de la víctima: Debemos determinar el orden de expropiación

para minimizar el costo.
 Retroceso: Si expropiamos el recurso, el proceso que lo estaba usando, no

puede continuar con su ejecución normal, por lo tanto, el proceso debe
retroceder a un estado seguro, y reiniciarlo. La forma más fácil es abortar el
proceso y comenzar de nuevo, pero es más conveniente regresar el
proceso a un estado seguro, aunque se debe tener guardada información
para ello.
 Inanición: Podría suceder que siempre se escoja el mismo proceso como

víctima, por lo tanto hay que asegurarse que solo se lo va a expropiar un
número finito (pequeño) de veces.
132
8 Administración de Memoria
La memoria es vital para el funcionamiento del sistema. Es una gran matriz de
palabras o bytes, cada uno con su propia dirección. La unidad de memoria solo ve una
corriente de direcciones que le llegan, pero no sabe cómo se generan ni para qué son.
La Administración de Memoria es una de las tareas más importantes del SO

y es necesaria para poder mantener varios procesos en memoria puesto que guarda
un estrecho vínculo con la planificación de la CPU, la cual mejora el rendimiento del
computador.
El SO es responsable de:
 Mantener qué partes de memoria están siendo utilizadas y por quién.

 Decidir cuáles procesos serán cargados en memoria cuando exista espacio
disponible.
 Asignar y quitar espacio de memoria según sea necesario.
8.1 Reasignación de direcciones

A continuación veremos los pasos que
un programa de usuario, escrito en alto nivel,
debe recorrer para poder ser ejecutado.
El esquema presentado a la derecha

nos muestra como un programa fuente debe
pasar por tres etapas antes de su ejecución:
1. Compilación (Compile): Traducción de

código fuente a código objeto. El
módulo responsable es el Compilador.
Éste código aún no es una archivo
ejecutable pues pueden existir
llamadas a rutinas que no están en ese
código, esto se debe a la
modularización de los programas
(reutilización de código).
2. Ensamblaje (Liker): Se combinan

varios códigos objetos en un único
código objeto. El módulo responsable
es el Ensamblador o Linkeditor. Este
código es guardado en disco como
archivo binario ejecutable.
3. Carga (Load): Se coloca el ejecutable

en lo que se denomina cola de entrada
esperando a ser cargados en memoria.
El módulo responsable es el SO.
133
Cuando un proceso es creado, el loader asigna en la

memoria del sistema el espacio para su ejecución cargando el
espacio de direccionamiento virtual (virtual adress space)
distribuida en diferentes áreas. Las principales se muestran a
derecha. También podríamos tener un área para el mapeo de
archivos, librería dinámica locales y librería dinámicas
compartidas por varios procesos.
El gran espacio entre vacío (o hueco) entre el Heap y

el Stack forma parte de lo que se denomina espacio lógico
disperso, que solo consumirá memoria física cuando éstos
crezcan, su asignación es de naturaleza dinámica.
 Código: Se utiliza para albergar el código del programa. Cada instrucción

es ejecutada en función de la posición del PC (Program Counter).
 Datos: Se utiliza para alojar todas aquellas variables declaradas en forma

estática por el programa.
 Stack: Se utiliza para preservar el estado ante llamadas a subrutinas,

conformado básicamente por sus parámetros, variables locales y dirección
de retorno. Se comporta en forma predictiva.
 Heap: Se utiliza para reservar memoria que genera proceso en forma

dinámica, por ejemplo al utilizar las llamadas malloc(), free(), etc. Se
comporta de forma no predictiva, generando fragmentación en memoria.
Las estructuras de datos que mantiene la información de qué espacios están

libres pueden ser:
- Mapa de Bits: Se divide la memoria en unidades de asignación y un bit

representa el estado de cada unidad: 1 - asignada, 0 - libre.
- Lista Encadenada: Como se muestra en la imagen, teniendo una
referencia al comienzo de los bloques libres.
- Diccionarios: Según el tamaño del bloque libre y se mantiene una
referencia al bloque libre.
134
Toda computadora generalmente tiene más espacio en disco que en memoria.

Por ello, el esquema de Fotheringham (1961) propone que los procesos puedan tener
más memoria asignada que la disponible en la RAM, guardando la parte sobrante en
el disco duro, y volviéndola a cargar en RAM cuando sea necesario usarla. De esta
tarea se encarga el SO y genera el concepto de Memoria Virtual (concepto que
desarrollaremos con más profundidad más adelante).
Por ejemplo, en un sistema de 32 bits, un proceso puede actuar como si tuviera

4GiB de memoria, dado que cada dirección se refiere a un espacio de 1 byte, como
hay direcciones posibles, se puede acceder a bytes distintos, o sea, a 4GiB.
Una dirección generada por la CPU se denomina dirección lógica o virtual,

mientras que otra percibida por la unidad de memoria se conoce como dirección
física o real.
La asignación de la ubicación de un programa en MP(19), o adress binding,

puede ser realizada en tres momentos:
 Tiempo de compilación (compile time): El programa será asignado a un

lugar específico y conocido de la memoria física. Las direcciones de
memoria son referenciadas en forma absoluta (static relocation).
 Tiempo de carga (load time): La asignación del lugar de memoria donde
será cargado el programa es hecho al momento de la carga. Las
direcciones de memoria deben ser referenciadas en forma relativa (dynamic
reolcation).
 Tiempo de ejecución (execution time): Un programa puede variar su
ubicación en memoria física en el transcurso de la ejecución y sus
direcciones lógicas son traducidas a direcciones físicas en el momento de
ser utilizadas. Requiere soporte de HW (MMU que se encargue de la
traducción de direcciones lógicas a físicas).
La traducción de direcciones en tiempo de compilación o tiempo de carga da

pie a que las direcciones lógicas y físicas sean idénticas. En cambio en tiempo de
ejecución, las direcciones lógicas y físicas difieren.
8.1.1 Carga dinámica (dynamic loading)

El tamaño de un proceso está limitado por el tamaño de la memoria física, ya
que todos los datos del proceso deben estar en la memoria para que el proceso se
ejecute. Con la carga dinámica, una rutina no se carga hasta que se ejecuta, mientras
se mantiene en disco en formato de carga reubicable.
Ventajas
 Aprovecha mejor el espacio de memoria ya que una rutina que no se utiliza

nunca se carga.
 No requiere soporte especial por parte del SO.
19
Traducción de direcciones lógicas a direcciones físicas.
135
8.1.2 Ensamblaje dinámico (dynamic linking)

En el proceso de linkedición, las librerías utilizadas por el usuario pueden ser
incorporadas al ejecutable. Otra opción es no incluirlas, y en el lugar donde se invocan
funciones de esa librería dejar un código que carga la librería y luego ejecuta el código
de la función. De esta manera, la memoria que ocuparía la librería queda libre hasta
que el proceso decide invocar alguna función de ésta.
Ventajas
 Actualizaciones en la librería afectan automáticamente a todos los procesos

que la utilizan
 El código de una librería compartida por varios procesos puede ser cargada
una sola vez en memoria física y hacer que todos los procesos que la
utilizan direccionen en su espacio virtual a la misma región en la memoria
física.
8.1.3 Superposición (overlay)

Se usa para que un proceso pueda ser mayor que la memoria asignada. Se
busca mantener en memoria las instrucciones y datos necesarios. Si se requieren
nuevos, se borran los que ya no se necesitan.
El compilador divide el código en partes, y en la memoria se encuentra

únicamente la parte que está siendo utilizada. Se incluye una sección de código que
es mantenida siempre en memoria y se encarga de cargar y quitar las distintas partes
del código de la memoria. Este mecanismo de asignación de memoria no requiere
soporte por parte del SO.
8.1.4 Intercambio (swapping)

En sistemas multiprogramados
más de un proceso debe estar cargado
en memoria principal. Para obtener
mejores resultados, aquellos procesos
que no estén ejecutando pueden ser
sacados de la MP, siendo almacenados
en lo que llamamos almacén de
respaldo (backing store, como por
ejemplo el disco duro) hasta que pasen
a ejecutar, de manera de tener más
memoria disponible para los procesos
que si se encuentran ejecutando.
La acción de pasar un proceso de memoria a disco se denomina swap-out, y su

opuesto se denomina swap-in. Como se mueven procesos enteros de memoria a
disco, se desperdicia mucho tiempo en la transferencia. Dado que el tiempo de
transferencia es directamente proporcional a la cantidad de memoria intercambiada,
resultaría útil conocer exactamente cuánta memoria está utilizando un proceso y no
136
simplemente cuanta memoria podría estar utilizando. Si tuviéramos ese dato, solo se
intercambiaría lo que estuviese utilizando realmente con el fin de liberar memoria.
Dependiendo de cómo fue la asignación de direcciones lógicas a físicas, un

proceso al ser restaurado podrá quedar:
 En cualquier lugar, si la asignación fue en tiempo de ejecución.

 En un mismo lugar fijo, si la asignación fue en tiempo de compilación o
tiempo de carga.
Desventaja
 Puede generar fragmentación externa en disco si se permite que los
programas allí alojados estén en cualquier lugar
 Puede generar fragmentación interna en disco si a cada proceso le
corresponde una porción de memoria y el proceso es muy pequeño
comparada con esta.
8.2 Asignación de memoria

La MP generalmente se divide en dos particiones:
 SO residente (kernel)
 Procesos de usuario
Generalmente, el SO reside en los extremos de la memoria principal, su zona

alta o baja. Esta decisión se debe a la ubicación del vector de interrupciones.
La traducción de direcciones lógicas a físicas corre por cuenta de un dispositivo

de hardware que ya conocemos, la MMU. Lo hace mediante dos registros: base
register y limit register.
Para proteger el área del memoria del kernel de los procesos de usuario, el
registro base, es ahora el registro de reubicación, cuyo valor se suma a todas las
direcciones generadas por los procesos de usuario.
137
A su vez, es necesario asegurar que un proceso no pueda acceder a la a la

memoria de algún otro proceso. De esta forma, se agrega otro registro, el registro
límite, y la MMU verifica que toda dirección generada por el proceso sea menor a este
valor. De esta forma, el nuevo esquema de MMU sería:
En resumen, la verificación de direcciones generada por los procesos es

realizada por un elemento de hardware conocido como MMU, mediante dos registros:
 Relocation register: indica donde empieza el espacio de memoria del

proceso.
 Limit register: indica donde termina el espacio de memoria del proceso.
En un esquema de asignación de memoria a los procesos contamos

básicamente con dos tendencias para la asignación de memoria:
A continuación detallaremos las tendencias de alojar todo el proceso en

memoria. En la siguiente sección nos ocuparemos en detalle de la Memoria Virtual.
138
8.2.1 Multiprogramación con particiones fijas

En estos sistemas la memoria se divide en porciones de tamaño fijo, cada uno
de los cuales puede ser utilizado por un proceso, generando una cota a la cantidad de
procesos concurrentes que pueden existir. Cuando termina un proceso se carga un
nuevo proceso en el espacio que éste liberó.
Desventajas
 En caso que existan procesos que necesiten más cantidad de memoria que
la proporcionada en la partición fija no se podrá cargar nunca.
 Presenta el problema de la fragmentación interna, en caso que el proceso
sea más pequeño que la partición se deja gran parte de memoria
inutilizada.
8.2.2 Multiprogramación con particiones variables

En estos sistemas se van cargando los procesos de forma contigua en la
memoria, pero el espacio que ocupan puede variar de acuerdo al proceso.
A medida que los procesos terminan van dejando huecos en la memoria, y el

SO es el encargado de llevar un registro de qué porciones de memoria están siendo
usada y cuáles no, de forma que cuando llegue un nuevo proceso se deba buscar un
hueco de memoria libre para asignarle. Para ello existen 3 estrategias de asignación:
 First Fit: Asigna el primer agujero lo suficientemente grande que satisface

la necesidad.
 Best Fit: Asigna el agujero más chico (el mejor) entre todos los agujeros
que pueden contenerlo.
 Worst Fit: Asigna el agujero más grande que pueda contenerlo.
Ejemplo:
139
En la práctica best fit y first fit son más óptimos que worst-fit. Sin embargo entre
best fit y first fit no queda claro cuál es mejor, pero si es claro que first fit es más
sencilla de implementar.
Desventaja:
 Presenta el problema de la fragmentación externa, quedan agujeros muy

pequeños entre regiones de memoria usadas que no pueden alojar a
ningún proceso, pero que sumados pueden ser una cantidad importante de
memoria. Como solución tenemos la compactación, donde se desplaza el
contenido de memoria, hasta tener toda la memoria libre en un solo bloque.
El costo depende del algoritmo, el más simple es desplazar todos los
procesos hacia un lado, pero igualmente puede ser muy costoso.
140
8.2.3 Paginación
La paginación es un esquema de gestión de
memoria donde se divide la memoria lógica de un
proceso en bloques de tamaño fijo llamado pages
(páginas) y a la memoria física en bloques llamados
frames (marcos), ambos de igual tamaño (page size).
Cuando hay que ejecutar un proceso, sus
páginas se cargan desde el backing store en los
marcos de memoria disponibles. Evidentemente, el
backing store debe estar dividido en bloques de tamaño
fijo que tengan el mismo tamaño que los marcos.
De esta forma, en vez de realizar swapping con

procesos enteros, se realiza swapping con las páginas
del proceso. Se mueven las páginas entre la memoria
principal y el disco, en una región especial de éste
llamada swap, que tiene frames del mismo tamaño que
aquellos de la memoria principal (como hablamos en la
Sección 8.1.4, pero en vez de ser a nivel de proceso
entero, es a nivel de página).
Para hacerlo se debe contar con soporte de hardware apropiado. Es así que
cada dirección generada por CPU se divide en dos partes:
 Un número de página (p)

 Un desplazamiento de página (d)
De esta forma, el número de página (p) se utiliza como índice de una tabla de
páginas, la cual contiene la dirección base de cada página en la memoria física, que
combinada con el desplazamiento (d) nos brinda la dirección física que estábamos
buscando. De la traducción se encarga la MMU.
Si una dirección lógica de m-bytes se divide en n-bytes para el desplazamiento

y el resto para el número de página, el tamaño de la página debe ser para
aprovechar todo el rango de direcciones dentro de una página. La elección de ser
141
potencia de dos tiene que ver con el hardware, de forma que para obtener el valor de
p baste con shiftear n-lugares a derecha, y para obtener el d alcance con aplicar una
máscara, evitando así engorrosas cuentas.
Se vincula cada dirección lógica con una física, y no permite la fragmentación

externa, lo que si puede existir es la fragmentación interna ya que los frames se
asignan como unidad. En el peor de los casos, un proceso podría necesitar páginas
más 1 byte, por lo que se le asignarían frames, dando como resultado una
fragmentación interna del tamaño prácticamente igual a un frame completo. Como
posible solución podríamos tener un tamaño páginas pequeño, pero tendríamos un
gasto extra para guardar cada entrada a página.
Este esquema de asignación de memoria permite que el programa de usuario

vea la memoria como un espacio contiguo, aunque en realidad está disperso por toda
la memoria física. El SO asigna una tabla de página por cada proceso y mediante un
registro (PTBR - Page Table Base Register) incorporado al PCB del proceso, se tiene
el lugar de memoria donde se encuentra la tabla de páginas para ese proceso. Para
que la tabla de página no invada la región de memoria de otros procesos debe estar
acotada, y se logra incorporando otro registro (PTLM – Page Table Length Register).
Esto mejora el cambio de contexto entre procesos ya que solo es necesario

cambiar este par de registros para acceder a la tabla de páginas, pero el acceso a
memoria se duplica debido a que es necesario primero acceder a la tabla (en
memoria) para obtener el número de frame y luego al lugar de memoria solicitado.
Para acelerar el proceso se agrega un componente de hardware, la TLB

(Translation Look-aside Buffer). Es una cache asociativa (20), en la que cada entrada
tiene el número de página y un número de marco asociado.
20
Está compuesta por dos campos, TAG|WORD. Cuando se presenta una dirección, se comparan
simultáneamente todos los TAGs almacenados. Si ocurre un TLB hit se evita la búsqueda en la memoria
y se accede directamente al frame correspondiente, en caso contrario (TLB miss) se busca el valor en
memoria, se accede al frame deseado y se guarda el valor en el TLB para acelerar los próximos accesos
(principio de localidad).
142
La TLB puede guardar también un ASID (Address Space IDentifier) que

permite identificar a qué proceso corresponde la entrada (generalmente por su PID). Si
no se cuenta con este campo, se debe limpiar la TLB cada vez que hay un cambio de
contexto para evitar que un proceso entre a memoria de otro proceso por error.
Rendimiento de la paginación
El Tiempo Efectivo de Acceso a memoria (EAT) se puede calcular de la
siguiente manera:
Siendo:
 hit ratio la tasa de aciertos

 tbTLB el tiempo de búsqueda en la TLB
 tbMem el tiempo de búsqueda en la memoria.
Con esta fórmula, se puede calcular la efectividad de la TLB en función del hit
ratio obtenido en el sistema.
Protección de memoria
En un esquema de paginación, para proteger la memoria se puede incluir un
valor dentro de la tabla de página que indique si esa página es válida o no (valid-
invalid bit). Si se intenta realizar un acceso a una página no valida, se genera una trap.
También puede utilizarse un mecanismo similar para definir páginas de solo

lectura (por ejemplo para contener código) y paginas de lectura-escritura.
143
Estructura de la tabla de páginas

Consideremos una arquitectura estándar de hoy en día de 32 bits. Si
tuviéramos páginas de 4Kb ( bytes) entonces la tabla de páginas estaría
compuesta de entradas (en el orden un millón), lo cual es excesivamente
grande para alojarla completamente en MP, y por tanto es necesario utilizar alguna
manera más eficiente de guardar la tabla. Las soluciones propuestas son tres:
I. Jerárquica
La idea es paginar la propia tabla de páginas. Más concretamente, se divide la
tabla de páginas en tablas más pequeñas, que contienen la información de un rango
de páginas.
La primer tabla indica donde se encuentra la tabla para cada rango (tabla
externa). Entonces, se crean solamente las tablas correspondientes a los rangos que
están siendo utilizados (a demanda), evitando ocupar la memoria que se necesitaría si
se guardara la tabla entera. Se puede generalizar esta idea usando cualquier cantidad
de niveles para alojar tablas externas. Agregando niveles se puede ahorrar más
memoria, pero aumenta el tiempo necesario para resolver la dirección física de una
dirección lógica, ya que se deben hacer tantos accesos a memoria como niveles
existan.
Como ejemplo en dos niveles tenemos:
144
II. Diccionario/Hash
Se implementa un hash abierto (con listas para resolver las colisiones) en el
que se guardan las entradas correspondientes a las páginas válidas.
El esquema muestra claramente cómo funciona el algoritmo en esta situación.
III. Tabla invertida

Los dos esquemas anteriores tiene la desventaja de que si un procesos utiliza
poca memoria respecto a la que en realidad puede direccionar, necesita cargar toda la
tabla de páginas innecesariamente. En lugar de tener una tabla por proceso indizada
por el número de página, se tiene una única tabla global indizada por número de
frame. Cuando un proceso intenta acceder a una página, busca la entrada
correspondiente a ese proceso y esa página en la tabla. Dado que el tiempo de
búsqueda (search) es líneal, podría llegar a ser costoso, pero al tener una única tabla
disminuye el espacio en memoria utilizado. Para optimizar el tiempo de búsqueda se
podría tener un Hash siguiendo la idea del esquema anterior.
145
Páginas compartidas
Al utilizar frames, el compartir memoria entre procesos se simplifica. Para
hacerlo, se hace que las tablas de páginas de distintos procesos mapeen las páginas
compartidas a los mismos marcos en MP. Para ser compartible, se debe tener código
reentrante (o código puro), o sea, que no puede modificarse a sí mismo, no cambia
durante su ejecución. Cada proceso tiene sus propias páginas de datos, y comparten
las páginas del código.
En el siguiente ejemplo tenemos tres procesos compartiendo la sección de

código de un editor (en tres páginas) y cada uno con su propia página de datos:
8.2.4 Segmentación
El usuario suele ver la memoria como una colección de segmentos de tamaño
variable, sin ordenamiento entre ellos, como puede ser un programa principal, con
subrutinas, procedimientos, funciones, y estructuras de datos. La segmentación es
una técnica que apoya la a visión del usuario.
De esta forma, cada segmento tiene un nombre que lo identifica y una longitud
asociada (por ser de tamaño variable). Por simplicidad, los segmentos están
numerados. Así, una dirección lógica está compuesta por la
pareja:
 Número de segmento (s)

 Desplazamiento (d)
146
El usuario ahora pude referenciar utilizando una dirección bidimensional

(compuesto por el par anteriormente dicho), pero la memoria es una secuencia
unidimensional de bytes, por lo tanto hay que definir una tabla de segmentos que
transforme direcciones lógicas en físicas. Cada entrada de la tabla tiene una base del
segmento (dirección física inicial) y un límite (longitud del segmento).
Y dichas direcciones bidimensionales generadas por la CPU se controlan por

medio de la MMU de la siguiente manera:
De manera similar a la Paginación, la Tabla de Segmentos de un proceso se

guarda en MP para optimizar el cambio de contexto, y se accede a ella por medio de
147
un registro (STBR – Segment Table Base Register), y se la acota superiormente por

medio de otro registro (STLR - Segment Table Length Register(21)) para impedir que
acceda a áreas de memoria restringidas. Ambos registros se incluyen al PCB del
proceso. En la traducción de una dirección virtual a una física, se controlan dos cosas:
- El número de segmento solicitado no debe exceder el valor del registro

STLR, sino se estaría intentando acceder a un área de memoria ilegal y por
tanto generaría una trap a nivel del SO.
- El desplazamiento debe ser menor que el campo límite dado por la tabla de
segmento, sino se estaría por fuera del rango de direcciones válidas.
Por ejemplo, Intel x86 tiene un esquema de memoria segmentado: CS, DS, ES,
SS son registros de segmento que indican la base, y el límite está prefijado por la
arquitectura en 64Kb, porque los registros son de 16bits.
Dado que los segmentos tienen longitud variable, su ubicación se decide

dinámicamente por los algoritmos de best, first o worst fit, pudiendo causar
fragmentación externa. Como el algoritmo de reubicación es de naturaleza dinámica,
se puede compactar la memoria en cualquier momento, pero como ya vimos no es
tarea menor y puede tener un alto impacto en la performance.
Protección de memoria
La protección de memoria se implementa asignando permisos sobre los
segmentos. De esta forma, un segmento de código es normal que tenga permisos de
lectura y ejecución, pero no de escritura; mientras que un segmento de datos tendrá
permisos de lectura y escritura. Esto se logra guardando en la tabla de segmentos un
bit de protección para cada tipo de permiso (bit protection) que el hardware controla al
momento de acceder al segmento.
Sin embargo, incluso bajo este esquema, dado que la pila (stack) debe
mantenerse como escribible, es común encontrar ataques que permiten modificar la
dirección de retorno de una subrutina.
21
Define el número máximo de segmento utilizado por el proceso
148
Segmentos compartidos
En la Segmentación, compartir memoria es más simple ya que se comparte
todo un segmento como una unidad, mientras que en Paginación se debe compartir
cada página por separado. En este caso la asignación de memoria es más complicada
ya que es necesario buscar un espacio de memoria lo suficientemente grande para
almacenar el segmento pedido.
149
8.2.5 Combinación Paginación - Segmentación

Es posible combinar Paginación con Segmentación para potenciar las ventajas
de cada uno de los sistemas.
 La Paginación genera fragmentación interna

 La Segmentación sufre fragmentación externa
De esta forma la memoria es segmentada y los segmentos se conforman de

páginas.
Las direcciones virtuales contienen un identificador de segmento y un

desplazamiento, a partir de ellos se genera una dirección lineal. Luego, la dirección es
traducida a una dirección física.
150
8.3 Consideraciones frente a estrategias de gestión de memoria

Los diversos algoritmos de gestión de memoria aquí vistos difieren en muchos
aspectos. A la hora de comparar las diferentes estrategias debemos tener en cuenta:
 Soporte de hardware: Para esquemas de partición simple un registro base

o una pareja registro base-límite son suficientes; en cambio, para
paginación y segmentación es necesario una tabla de mapeos.
 Rendimiento: Para los sistemas simples solo necesitamos realizar

operaciones de comparación o de sumas. La paginación y segmentación
requieren considerar operaciones para el manejo de las tablas.
 Fragmentación: Necesitamos reducir la memoria desperdiciada. Los

sistemas de asignación de tamaño fijo, como el esquema de partición
simple ó paginación, presentan fragmentación interna. Mientras que
sistemas con unidades de asignación de tamaño variable, como el
esquema de particiones múltiples ó segmentación, presentan el problema
de la fragmentación externa.
 Reubicación: Como solución a los problemas de fragmentación externa

encontramos la compactación, y sólo es posible si la reubicación es
dinámica y se lleva a cabo en tiempo de ejecución.
 Intercambio: Los procesos se copian desde memoria a un almacén de

respaldo y luego se vuelven a copiar de vuelta a la memoria principal. Este
esquema permite ejecutar más procesos que los que cabrían en memoria
en un instante determinado.
 Compartición: Requiere que se utilice un esquema de paginación o

segmentación, con el fin de disponer de pequeños paquetes de información
compartida.
 Protección: Si se proporciona un mecanismo de paginación o

segmentación, las diferentes secciones de un programa de usuario pueden
declararse como de solo ejecución, de solo lectura o de lectura-escritura,
necesaria para el código o los datos compartidos.
151
9 Memoria Virtual
La memoria virtual es una técnica que permite ejecutar procesos que podrían
no estar totalmente en la memoria, por lo tanto su gran ventaja es que los programas
pueden ser más grandes que la memoria física.
Hace una abstracción de la memoria, considerándola

como una matriz uniforme y extremadamente grande de
almacenamiento, separando la memoria lógica que ve el usuario
de la memoria física, y evitando que los programadores tengan
que preocuparse por las limitaciones. Es difícil de implementar, y
si no se usa con cuidado puede reducir sustancialmente el
rendimiento.
El espacio de direccionamiento virtual de un proceso

es el espacio de memoria que el proceso cree poder direccionar,
generalmente desde 0 hasta cierto MAX (tal y como muestra la
figura), y no tiene por qué corresponderse con el rango de
direcciones físicas reales en la memoria, ni tampoco por qué estar contiguo en ella
(como ya vimos). Es responsabilidad de la MMU establecer la correspondencia ante
una dirección presentada en la CPU por parte de un proceso.
Observando la figura, el gran espacio (o hueco) entre el stack y el heap forma

parte de lo que se denomina espacios de direcciones dispersos, que solo consumirá
páginas físicas reales cuando crezcan el heap o el stack.
Para implementar esto se usa un sistema de paginación bajo demanda.
9.1 Paginación bajo demanda

Un sistema de Paginación
bajo demanda es similar a un
sistema de paginación con swapping.
Los procesos residen en
memoria secundaria y cuando
queremos ejecutarlo lo pasamos por
swap a la memoria, pero en vez de
intercambiar todo el proceso, usamos
un lazy swapper(22) que nunca
intercambia una página a la memoria
si no se va a necesitar.
Dado que un Swapper
intercambia todo un proceso, a
nuestro lazy swapper lo
denominamos Paginador.
22
Intercambiador perezoso
152
Cuando un proceso se va a cargar en memoria, el Paginador realiza una

estimación de cuáles son las páginas que se usaran antes que se descargue el nuevo
proceso. Notar que así se reduce el tiempo de carga y la memoria física requerida. Si
se predicen en forma correcta cuáles son las páginas que el proceso va a utilizar y
solo cargamos esas, entonces el programa ejecutara normalmente como si hubiese
sido cargado totalmente.
Es necesario el soporte de hardware para poder distinguir entre las páginas

que están en memoria y las paginas que están en disco. Esto se puede lograr con el
valid-invalid bit, donde:
 v : indicara que la página está en la memoria (y es válida, o sea, está

dentro de las direcciones del proceso)
 i : indicara que o bien no es válida o bien no está cargada en MP.
Si el proceso intenta acceder a una página no valida (no es error de

direccionamiento), causa una trap de fallo de página (page fault) y le transfiere el
control al SO y se lleva a cabo el siguiente procedimiento:
1. Se consulta una tabla interna (usualmente en el PCB del proceso) para ver
si la referencia es un acceso legal o no a la memoria.
2. Si la referencia es ilegal, se termina el proceso por tratarse de un fallo de
direccionamiento. Si la referencia es legal pero la página no se había
cargado, es cargada.
3. Se busca un marco libre donde cargar la página.
4. Se planifica una operación de disco para leer la página deseada y colocarla
en el marco libre.
153
5. Al termina la lectura, se modifica la tabla consultada diciendo que la página

ya es válida (está cargada).
6. Reiniciamos la instrucción que se interrumpió por la trap de dirección no
valida. Ahora el proceso puede acceder a la página como si nada hubiese
pasado.
El siguiente esquema muestra los pasos para tratar un fallo de página:
Como se salva el contexto del proceso interrumpido (registros, código de

condición, contador de instrucciones) al ocurrir el page fault, se puede reiniciar el
proceso exactamente en el mismo lugar y estado. En el caso extremo podríamos
iniciar la ejecución de un proceso sin páginas en la memoria, y al ir accediendo a las
instrucciones se irían cargando las páginas necesarias. Este esquema se llama
paginación bajo demanda pura.
La idea de que los programas necesiten tener en memoria varias páginas para
ejecutar una instrucción (generando varios fallos de página) es improbable, gracias a
lo que se denomina localidad de referencia(23)
El hardware para apoyar la paginación bajo demanda es el mismo que apoya la

paginación y el intercambio. Nos referimos a dos componentes:
 Tabla de Páginas: Permite marcar las entradas válidas y no válidas con el

valid-invalid bit.
23
El concepto de localidad establece que un proceso, durante su ejecución, pasa de una localidad a otra.
Una localidad es un conjunto de páginas que se utilizan conjuntamente. Un programa generalmente
está compuesto por varias localidades distintas, las cuales pueden superponerse. Por ejemplo, al llamar
a una subrutina se define una nueva localidad. En ésta se efectúan referencias a memoria de las
instrucciones de la subrutina, sus variables locales y un subconjunto de las variables globales. Al salir de
la subrutina, el proceso abandona esta localidad. Así, vemos que las localidades están definidas por la
estructura del programa y sus estructuras de datos.
154
 Memoria Secundaria: Contiene las páginas que no están en memoria

principal.
Además de esto se requiere una buena cantidad de software, y algunas

restricciones arquitectónicas como la necesidad de poder reiniciar una instrucción
después de un fallo de página. Y como peor caso, si el fallo ocurrió mientras se está
obteniendo un operando, es preciso volver a obtener la instrucción y decodificarla.
El principal problema surge cuando una instrucción puede modificar varias

posiciones distintas, y esas posiciones se traslapan. Por ejemplo, mover caracteres de
un bloque a otro (y los dos se traslapan). Si ocurre un fallo en el medio, se perdieron
datos que fueron sustituidos. Hay 2 formas de resolver el problema:
- Se intenta acceder a los dos extremos de los bloques de memoria a

modificar y si ocurre un fallo cargar la página antes de ejecutar la
modificación.
- Guardar en registros temporales los valores sobrescritos y si ocurre un fallo
volver hacia tras antes de activar la trap.
Es posible usar un esquema de paginación en cualquier sistema, mientras no

sea de paginación bajo demanda.
Rendimiento de la paginación bajo demanda

La paginación bajo demanda puede tener un efecto importante sobre el
desempeño de un sistema. Para ver el efecto debemos calcular el Effective Access
Time (EAT, tiempo de acceso efectivo):
Siendo
 p la probabilidad de que ocurra un fallo (p es muy cercano a 0)

 ma el tiempo de acceso a memoria
 TRPF el tiempo de la resolución del page fault
Para calcular el tiempo de fallo de página, debemos tener en consideración,

varios tiempos. Los tres principales son:
 Atención de la interrupción de fallo de página

 Traer la página a memoria.
 Reiniciar el proceso.
Entonces, el tiempo de acceso efectivo es directamente proporcional a la

frecuencia de fallos. Esto denota la importancia de mantener baja la frecuencia de
fallos.
9.2 Copia durante escritura

La copia durante escritura funciona permitiendo que los procesos padre e hijo
compartan inicialmente las mismas páginas. Estas páginas compartidas se marcan
como páginas de copia durante la escritura, lo que significa que si cualquiera de los
155
procesos escribe en una de las páginas compartidas, se creará una copia de esa
página compartida.
Los SO generalmente proporcionan un conjunto compartido de páginas

libres para satisfacer las solicitudes al momento de duplicar una página, y se asignan
mediante una técnica de relleno de ceros bajo demanda, donde se llenan con ceros
antes de ser asignadas, eliminando así el contenido anterior.
9.3 Reemplazo de páginas

En los esquemas vistos la frecuencia de fallos de página no han representado
un problema grave. Supongamos que un proceso que requiere 10 páginas y necesita 5
de ellas cargadas. Si una de estas produce un fallo de pagina (porque requiere de una
sexta pagina), ocurre una trap y se transfiere el control al SO puesto que no quedan
marcos libres, toda la memoria está ocupada.
Al llegar a este estado, el SO tiene varias opciones:
 Terminar el proceso de usuario. Esta opción no es muy aceptable debido

a que el SO hace paginación bajo demanda para aumentar la productividad
del computador, y además este esquema debe ser transparente para el
usuario.
 Intercambiar a disco un proceso. Haciendo esto se liberan algunos

marcos, pero se reduce el nivel de multiprogramación. Esta opción es
bastante buena pero hay otra más interesante.
 Reemplazo de páginas. Si no hay marcos libres se busca uno que no se

esté usando y lo liberamos.
156
La rutina de servicio de fallos de página:
1. Hallar la ubicación de la página deseada dentro del disco

2. Localizar un marco libre
Si ∃ marco libre
Entonces
Utilizarlo
Sino
a. Se usa un algoritmo de reemplazo de páginas para escoger el
marco víctima
b. Escribir la página víctima en memoria swap y modificar las
tablas de páginas y marcos
FinSi
3. Leer la página deseada y colocarla en el marco liberado, modificar tablas.
4. Reiniciar el proceso de usuario
Si no hay un marco libre, se requieren 2 transferencias de páginas (una hacia

fuera y una hacia adentro), duplicando el tiempo de servicio de fallo de página.
Durante este periodo (lento para la CPU) el SO se encarga de conmutar la CPU a otro
proceso, y el proceso que estaba realizando un swap a disco pasa a estar bloqueado
hasta que se finalice la transacción.
Este gasto extra puede ser solucionado empleando un bit de modificación.
Cada página o marco puede tener en hardware un bit asociado, el cual es encendido
si se escribe una palabra o byte en la página (indicando que se modificó). De esta
forma evitamos la escritura de la pagina victima si no ha sido modificada.
Para implementar la paginación bajo demanda, entonces debemos resolver dos
problemas:
 Un algoritmo de asignación de marcos. Es necesario decidir cuántos

marcos se asignan a cada proceso.
 Un algoritmo de reemplazo de páginas. Hay que seleccionar que página
se reemplaza cuando sea necesario.
157
Algoritmos de reemplazo
Existen muchos, y es probable que cada SO tenga su propio esquema de
reemplazos. Lo que queremos es el algoritmo con la frecuencia de fallos de página
más baja.
La evaluación de los algoritmos se hace ejecutándolo con una serie específica

de referencias a la memoria (denominada cadenas de referencias) y calculando el
número de fallos de página. Además se debe saber el número de marcos disponibles
en el sistema (cuantos más hallan menos fallos ocurrirán). En la secuencia no
encontramos números de página consecutivos repetidos porque estos se colapsan,
sería como acceder a la misma página una única vez.
Para ilustrar los ejemplos de los diversos algoritmos supondremos que

tenemos de tres marcos disponibles y utilizaremos la siguiente cadena de referencias
7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1
I. FIFO
Los frames son puestos en una cola cuando son asignados, y en caso de no
haber más frames libres el sistema se elige como víctima al primer frame en la cola.
No es un muy buen algoritmo ya que quizás el frame elegido es muy “viejo”

pero es usado continuamente por su dueño, por lo que dentro de poco va a tener que
ser cargado de nuevo en memoria.
Este algoritmo sufre de un problema denominado Anomalía de Belady, el cual

establece que al aumentar la cantidad frames pueden aumentar la cantidad de page
fault. La “anomalía” se presenta en que al aumentar la cantidad de marcos, espero una
reducción en la cantidad de page fault, sin embargo ocurre lo contrario. El siguiente
ejemplo da constancia de ello, suponga una cadena de referencia
1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
en caso que tengamos:
158
Para esta cadena de referencia tenemos el siguiente gráfico de la cantidad de

fallos de página en función del número de marcos disponibles:
II. Second Chance

En la tabla de página se incluye un bit de referencia que es seteado en 1 cada
vez que se realiza un acceso sobre esa página.
Cuando se va a reemplazar un frame, el sistema hace lo mismo que en el caso

FIFO, pero primero verifica el valor del bit: si es 0 realiza el cambio, si es 1 lo setea en
0 y lo envía al fin de la cola.
También es conocido como el Algoritmo del Reloj ya que se comporta como

tal, como veremos en el ejemplo a continuación. El “ * ” indica tener el bit de referencia
encendido. Al cargarse una página a causa de un page fault, dado que se reinicia su
instrucción, se activa el bit de referencia del marco (es seteado a 1).
159
III. Optimal
La idea es reemplazar el frame que no se va a utilizar por más tiempo. Este
algoritmo es el más óptimo de todos, pero como no se sabe de antemano cuando se
va a acceder a algún frame es imposible de implementar.
IV. Not Recently Used (NRU)

También conocido como Algoritmo Second Chance Mejorado. A los frames
se les asocian dos bits:
 Bit de referencia (R): se activa cuando alguien lee/escribe en el frame

 Bit de modificación (M): se activa cuando alguien escribe algo en el frame
(se modifica la página).
Si el HW no tiene estos bits, se puede simular por SW asignando el modo de la

pagina a lectura solamente cuando R esta prendido y el modo lectura/escritura cuando
R y M están prendidos.
Los bits R son seteados en 0 periódicamente por una interrupción para

distinguir qué páginas fueron accedidas recientemente. Al ocurrir un page fault los
frames son divididos en cuatro clases:
 Clase-0 : No referenciado, no modificado (0,0)

 Clase-1 : No referenciado, modificado (0,1)
 Clase-2 : Referenciado, no modificado (1,0)
 Clase-3 : Referenciado, modificado (1,1)
160
Se reemplaza un frame al azar de la clase más baja que no esté vacía. Es

sencillo de implementar, pero requiere que el hardware actualice los bits de referencia
y modificación.
La Clase-1 se obtiene cuando la página pertenece a la Clase-3 y su bit de

referencia es apagado. A su vez, la elección de la Clase-1 esté antes que la Clase-2
es porque al momento de cargar una página, el número de página solicitado se envía
a un SPOOL y el marco víctima queda en MP; de esta forma si rápidamente solicitan
la página que está en el marco víctima antes que la nueva página sea despachada por
el SPOOL, ésta aún se encuentra en MP y no genera un fallo de página, recién
cuando el SPOOL despache la nueva página el marco víctima será bajado a disco.
V. Least Recently Used (LRU)

Este algoritmo se acerca mucho al óptimo. La idea es que cada frame tiene en
la tabla de página un registro del tiempo en que fue accedido por última vez, que es
actualizado por el hardware. Se reemplaza el frame que hace más tiempo que no se
accede.
Este algoritmo no es muy usado porque requiere hardware muy especializado,

como Contadores(24) o Pila(25). No sufre la Anomalía de Belady. Una solución sencilla
consiste en aplicar la idea del algoritmo Second Chance, pero en vez de tener un solo
bit, se utiliza una palabra de n-bits. De esta forma, cada acceso a la página apaga el
primer bit (el de más a la izquierda) y cuando el timmer de la CPU interrumpe se
encarga de shifthear a la derecha. La palabra, leída como un entero, indica hace
cuánto tiempo fue referenciada esa página.
24
Cada entrada en la tabla de páginas tiene un campo de tiempo de uso y la CPU cuenta con un
contador. El contador se incrementa en cada referencia a memoria y se copia el contenido del contador
en el campo tiempo. Requiere realizar una búsqueda en la tabla de páginas para localizar la página con
menos tiempo.
25
Se implementa una pila como una lista doblemente encadenada con referencia a la cabeza y a la cola,
puesto que es necesario eliminar entradas intermedias, de forma que cuando se realiza una referencia a
memoria, se extrae esta página de la pila y se la coloca en el tope. De esta forma, la menos
recientemente usada se encuentra en la base de la pila. Requiere modificar 6 punteros en el peor caso y
no necesita realizar ninguna búsqueda de la página a sustituir.
161
9.4 Estrategia de asignación de frames

Uno de los grandes problemas es como saber cuántos frames hay que darle a
cada proceso, sobre todo cuando el sistema es multiprogramado (hay varios procesos
en memoria a la vez).
Si el sistema no implementa un algoritmo de asignación de memoria justa para

todos los procesos el sistema puede colapsar, por ejemplo, si un proceso pide
demasiada memoria. De acuerdo a esto tenemos dos tipos de estrategias:
 Equitativa: repartir los -frames entre -procesos, dando a cada uno un

número igual de frames, cercano a .
 Proporcional: Se le asigna memoria disponible a cada proceso según su

tamaño. Si es el tamaño de la memoria virtual de un proceso ,
definiendo y sabiendo que tenemos disponibles -frames,
entonces asignamos -marcos al proceso tal que
ajustándolo a un entero superior al número de marcos requeridos sin que
exceda el valor de .
Tanto en la estrategia equitativa como en la proporcional la asignación a cada

proceso podría variar según el nivel de multiprogramación (cuantos más procesos
haya en memoria, menor es la cantidad de marcos asignados a cada uno). Además,
en ambos casos se trata igual a un proceso de alta prioridad que a un proceso de baja
prioridad. Por esto, otras estrategias ofrecen marcos dependiendo del nivel de
prioridad, o según una combinación de tamaño y prioridad del proceso.
La idea entonces es ponderar la memoria que se va a otorgar a un proceso

según la cantidad de memoria virtual que éste está usando. Si hay múltiples procesos
compitiendo por los marcos, podemos clasificar los algoritmos de reemplazo de
páginas básicamente en dos categorías:
 Reemplazo global (global replacement): Permite seleccionar la víctima

entre todos los frames disponibles, incluyendo los de otros procesos.
 Reemplazo local (local replacement): Selecciona la victima solo entre los

frames que le fueron asignados.
Si se utiliza el reemplazo global, la cantidad de frames asignados a un proceso

varia respecto al tiempo. Además, como un proceso le puede sacar frames a otro, el
segundo proceso puede empezar a ejecutar más lentamente como consecuencia.
El reemplazo local, por su parte, independiza los fallos de página entre los
procesos, pero mantiene frames poco usados en memoria, razón por la cual el
reemplazo global es más utilizado.
162
9.5 Hiperpaginación - Trashing

Un proceso que no tiene suficientes marcos para su cantidad de páginas
activas (páginas que siempre está usando), provocará un fallo de página a cada
instante, por lo que comenzará a estar en un estado de frenética paginación, pasando
más tiempo paginando que ejecutando, y esto se denomina hiperpaginación.
La idea de la multiprogramación
es aumentar el uso de la CPU. Si el
proceso no tiene marcos suficientes y se
aplica un algoritmo de reemplazo global,
se empezarán a generar fallos de
página y dado que se reemplazan
páginas de cualquier otro proceso, si
éste las precisa volverá a generar fallos
de página nuevamente. Como resultado,
los procesos están a la espera del
paginador y consecuentemente la tasa
de uso de CPU disminuye, provocando que se intente incrementar el grado de
multiprogramación y se vuelva a generar así el mismo problema pero a nivel
potenciado. En este caso se está frente a un problema de hiperpaginación, y el gráfico
mostrado a izquierda vemos como el uso de CPU disminuye vertiginosamente.
Modelo Working Set

La idea del modelo del Working Set es que cada proceso en un periodo de
tiempo trabaja con un conjunto de páginas activas. Si este conjunto puede ser
colocado en memoria entonces no se sufrirá hiperpaginación.
A medida que pasa el tiempo el conjunto de paginas activas cambia, pero lo

importante es que siempre existe ese conjunto en periodos de tiempo relativamente
cortos. Para tener una aproximación del working set se utiliza un timer que interrumpe
con un t fijo, un bit que marca si el frame fue usado desde la última interrupción del
timer y un campo que marca el tiempo de la última vez que fue referenciado.
De esta forma se guardan las páginas accedidas en un lapso de tiempo, si este

lapso es pequeño no se logra captar la idea de cuál es el conjunto siendo utilizado,
pero si es muy grande el conjunto pasa a ser el conjunto de todas las paginas
accedidas por el proceso en su historia.
Una vez que se sabe el tamaño del working set de cada proceso ( –
Working Set Size), si se suman todos podemos obtener la cantidad de frames
necesarios en el sistema para evitar el trashing ( ).
163
Si esta cantidad supera a la cantidad de frames disponibles en memoria

principal ( ) entonces el sistema debe suspender procesos y despertarlos una
vez que se liberen frames como para darles a todos lo necesario, sino se tendrá
hiperpaginación porque algunos de los procesos no dispondrán de los suficientes
marcos.
Modelo Page-Fault Frequently

El modelo de Working-Set tiene bastante éxito pero parece ser una manera
bastante torpe para controlar la hiperpaginación. El modelo Page-Fault Frequently, o
Frecuencia de Fallo de Página, sigue un camino más directo.
El problema de hiperpaginación
surge cuando existe una elevada tasa
de fallos de página. Cuando es
demasiado alta sabemos que un
proceso necesita más marcos, y si es
demasiado baja, puede ser que el
proceso tenga demasiados marcos.
Por lo tanto podemos establecer un
umbral acotado por:
- Un límite superior (UH - Umbral High): Cuando la frecuencia es mayor a

este límite el proceso necesita más marcos.
- Un límite inferior (UL – Umbral Low): Cuando la frecuencia es menor a este
límite el proceso puede liberar marcos.
De esta forma, podemos medir y controlar directamente la tasa de fallos de

página para evitar la hiperpaginación.
Al igual que ocurre con la estrategia Working-Set, posiblemente se tenga que

suspender algún proceso. Si aumenta mucho la tasa de fallos y no hay marcos
disponibles, debemos seleccionar un proceso y suspenderlo. Los marcos liberados se
distribuyen entre los procesos con tasa elevada de fallos de página.
Algunas ecuaciones útiles para trabajar con los ejercicios de memoria
0)
1)
2)
3)
4)
OBS: Recordar que todos los tamaños (prefijados por tam) debe estar en la misma unidad
(byte o múltiplo de byte). El “ ” indica redondeo hacía arriba.
164
10 Sistema de archivos
El sistema de archivos proporciona los mecanismos para el almacenamiento
en línea de los datos y programas que residen en disco, y para el acceso a esa
información. Consta de dos partes:
 Colección de archivos: Almacenan una serie de datos.

 Estructura de directorios: Organiza los archivos.
Algunos sistemas de archivos tienen particiones que sirven para separar física
o lógicamente grandes colecciones de directorios.
10.1 Concepto de archivo

Los dispositivos de almacenamiento masivo permiten guardar información de
forma no volátil, persistir datos. De esta forma el SO abstrae sus propiedades físicas
para definir una unidad de almacenamiento lógico, el archivo.
Dicho esto, un archivo no es más que una colección de información relacionada

definida por su creador, teniendo una estructura determinada (texto, fuente, objeto,
ejecutable, etc.). Podemos ver al archivo como TAD.
10.1.1 Atributos de un archivo

Los atributos de un archivo pueden ser básicamente de dos tipos:
- Datos: La información que almacena.

- Metadatos: Información sobre esos datos.
Estos atributos varían de un SO a otro, pero típicamente son los siguientes:
 Nombre: Información que se mantiene en forma comprensible para los

seres humanos. Permite identificar el archivo a los usuarios. Es un
metadato desde el punto de vista del usuario.
 Etiqueta/Identificador: Generalmente un número que identifica

unívocamente un archivo dentro del sistema de archivos. No es legible a los
seres humanos. Es un metadato desde el punto de vista del SO.
 Tipo: Se necesita saber en sistemas que reconocen distintos tipos de

archivo, son reconocidos por medio de su extensión.
 Ubicación: Es un puntero a un dispositivo y a la posición del archivo en el

dispositivo. El puntero indica donde comienzan los datos, y estos pueden
estar contiguos o desparramados por todo el disco.
 Tamaño: Tamaño actual del archivo, y tal vez el tamaño máximo permitido.
 Protección: Información de control para el acceso a un archivo. Determina

quién puede leer, escribir, ejecutar, etc. el archivo.
165
 Hora, fecha e identificación de usuario: Se mantiene para los sucesos de

creación, última modificación y último uso del archivo. Pueden ser útiles
para la protección, seguridad y control de uso.
10.1.2 Operaciones sobre archivos

Dado que un archivo podemos verlo como un TAD, el SO debe brindar
servicios para su manipulación. Algunos de ellos son:
 Crear un archivo: Se realiza en dos pasos

o Encontrar espacio en el sistema de archivos.
o Insertar una entrada para el archivo en el directorio (registrando el
nombre y ubicación en el sistema de archivos)
 Escribir un archivo: Se especifica mediante un nombre y la información

que se desea escribir. Con el nombre se efectúa una búsqueda para
encontrarlo en el directorio, manteniendo un puntero de escritura indicando
la posición donde se va a escribir.
 Leer un archivo: Se efectúa una búsqueda por nombre, y se mantiene un

puntero de lectura al archivo. Generalmente se usa el mismo puntero para
lectura y escritura, ahorrando espacio (puntero de posición actual del
archivo).
 Reubicarse dentro de un archivo: Se cambia la posición actual del

archivo (el puntero). Esta operación se conoce también como búsqueda en
un archivo.
 Eliminar un archivo: Lo buscamos en el directorio, liberamos el espacio

que ocupa, y borramos la entrada del directorio.
 Truncar un archivo: Permite dejar inalterados todos los atributos de un

archivo, y borra su contenido, haciendo que su longitud sea cero, pero no lo
elimina.
Este es el conjunto mínimo de operaciones requeridas para un archivo.

También podemos encontrar otras operaciones tales como adición de información o
renombrado de archivos, así como también podemos combinar operaciones para
formar otras, como por ejemplo la copia de un archivo, que se obtiene de crear un
archivo nuevo, leer la información del archivo contiguo y escribiéndola en el nuevo.
Hasta se puede proveer un sistema de acceso único o exclusivo a un archivo por parte
de los procesos, el lock (como solución al problema de Lectores-Escritores).
Para no tener que buscar el archivo cada vez que se realiza una operación,
algunos sistemas guardan la tabla de archivos abiertos, donde colocan una entrada
cuando el archivo se utiliza por primera vez. Cuando se deja de usar, se borra esa
entrada, cerrando el archivo. La implementación de las operaciones open() y close()
en un entorno multiusuario es más complicada, ya que varios usuarios podrían abrir un
archivo al mismo tiempo.
166
Para implementar esto se utilizan dos tablas, una que contiene los archivos
abiertos de cada proceso, y otra que contiene la información de su ubicación,
punteros, etc. Los elementos de información son:
 Puntero al archivo (file pointer): Es exclusivo para cada proceso que está
trabajando con el archivo, por lo que debe mantenerse aparte de los
atributos del archivo en disco.
 Contador de aperturas del archivo: Como varios procesos pueden abrir

un archivo, el sistema debe esperar a que todos lo cierren antes de eliminar
la entrada correspondiente. Este contador sigue la pista del número de
aperturas y cierres, y llega a cero, después del último cierre.
 Ubicación del archivo en disco: Es la información necesaria para localizar

el archivo en el disco, y se mantiene en memoria, para no tener que leerla
del disco en cada operación.
 Derechos de acceso: Permite autorizar o denegar las siguientes

solicitudes de E/S, almacenando esta información en la tabla
correspondiente a cada proceso.
10.1.3 Tipos de archivos

Si un SO reconoce el tipo de un archivo, puede trabajar con él de manera
razonable. Una forma para implementar el tipo, es incluirlo dentro del nombre del
archivo. De esta forma, el nombre se divide en dos partes: nombre y extensión,
separados por un punto.
Con solo ver la extensión el sistema reconoce el tipo, y sabe que operaciones
puede realizar con él. Por ejemplo, un *.exe solo puede ser ejecutado, mientras que un
*.txt puede ser solo leído/escrito.
Otros sistemas guardan un atributo del creador del archivo, y al abrir el archivo,
el sistema por medio de ese atributo, sabe con qué programa debe abrirlo.
10.1.4 Estructura externa del sistema de archivos

Los tipos de archivos pueden servir para determinar la estructura externa del
archivo. Además, se podría obligar a que ciertos archivos tengan una estructura
determinada que el SO entiende. Por cada estructura de archivo distinta, el sistema
debe definir el código que la maneja. Otra forma es que cada programa reconozca sus
archivos, y tenga el código para trabajar con ellos, dejando al SO la obligación de
reconocer, por lo menos, la estructura del archivo ejecutable para poder cargar los
programas.
Si hay pocas estructuras, la programación se dificulta, y si hay demasiadas, el

sistema crece excesivamente.
167
10.1.5 Estructura interna del sistema de archivos

Localizar una posición en un archivo puede ser difícil para el SO puesto que los
tamaños de los archivos nunca coinciden con los tamaños de los bloques del
dispositivo de almacenamiento. Una solución común es empaquetar varios registros
lógicos en bloques físicos, considerando un archivo como una secuencia de bloques.
Al asignar el espacio por bloques podemos crear fragmentación interna.
10.1.6 Métodos de acceso a un archivo

Hay varias formas de acceder a la información del archivo. En este apartado
nombraremos dos:
 Secuencial: La información se procesa en orden, registro tras registro. El

registro depende del tipo de archivo (texto plano sería byte). Las
operaciones de lectura/escritura accederán a la información en forma
secuencial e irán incrementando el puntero de archivo (file pointer). En el
caso de la lectura, se lee la siguiente porción del archivo e incrementa el file
pointer. En el caso de la escritura, añade información al final del archivo y
avanza el file pointer al final de los datos recién escritos (el nuevo final del
archivo). Este tipo de acceso es basado en el modelo de cinta (tape), en
donde los archivos son accedidos de a un a la vez y en forma secuencial,
tal y como muestra la imagen a continuación. Es utilizado por los editores,
compiladores, operaciones de lectura y escritura, etc.
 Directo: La información es accedida en cualquier orden. Un archivo se

considera como una secuencia numerada de bloques o registros, no
existiendo restricciones sobre el orden de escritura y lectura de un archivo.
Es necesario modificar las operaciones sobre archivos para que incluyan el
número de bloque a acceder como parámetro, o alternativamente tener una
operación posicionar_en_bloque(n) y luego realizar la lectura/escritura.
Dicho número de bloque normalmente es relativo, un índice referido al
comienzo de un archivo. Este número permite al SO decidir donde hay que
colocar el archivo (denominado problema de asignación) y ayuda a impedir
que el usuario acceda a porciones del sistema de archivos que no formen
parte de su archivo. Este tipo de acceso está basado en el modelo de los
discos que está estructurado en bloques, ya que permiten el acceso
aleatorio a cualquier bloque del archivo, y son útiles para obtener acceso
inmediato a grandes cantidades de información, como por ejemplo, las
bases de datos.
No todos los sistemas de archivos soportan acceso secuencial y directo.

Algunos SO requieren que se definan como uno u otro en el momento de crearlos. Se
puede simular fácilmente el acceso secuencial a partir de uno directo manteniendo una
168
variable cp -current position- que defina la posición actual, sin embargo, simular un
archivo directo a partir de uno secuencial es extremadamente ineficiente y engorroso.
10.2 Concepto de directorio

Para administrar el sistema de archivos, hay que organizarlos. Primero se
divide el sistema de archivos en particiones, donde cada disco contiene al menos
una. Hay otros sistemas que permiten que las particiones sean mayores que un disco.
Cada partición tiene información acerca de los archivos que hay en ella,
manteniéndola como entradas de una tabla de contenido del volumen (conocido
como directorio). De esta forma, los directorios permiten a los usuarios del sistema
tener una organización lógica del sistema de archivos.
También podemos encontrar particiones denominadas RAW, que no contienen

un sistema de archivos, y su utilidad es mantener un espacio de swapping.
10.2.1 Operaciones sobre directorios

El SO brinda servicios para la manipulación de directorios. Algunos de ellos
son:
 Buscar un archivo: Se puede buscar por nombre, o listar todos los

archivos cuyos nombres coinciden con un patrón.
 Crear un archivo en directorio: Crea archivo y lo agrega al directorio.
169
 Eliminar un archivo: Elimina el archivo del directorio.
 Listar un directorio: Lista los archivos que se encuentran en él.
 Renombrar un archivo: Cambia el nombre de un archivo cuando su

contenido o uso varíe, pudiendo también modificar su posición dentro de la
estructura de directorios.
 Recorrer el sistema de archivos: Se puede querer acceder a todos los

directorios y archivos dentro de una estructura.
10.2.2 Estructura de directorios

A continuación se describen los esquemas más comunes que se usan para
definir la estructura lógica de un directorio.
I. Único nivel:
Todos los archivos se guardan en un mismo directorio, resultando fácil de
mantener y comprender, pero tiene limitaciones cuando el número de archivos
aumenta, o hay más de un usuario, ya que deben tener nombres únicos.
Incluso aunque haya un solo usuario, puede que le resulte dificultoso recordar
los nombres de todos los archivos a medida que se incrementan en número.
II. Dos niveles:

Se puede crear un directorio individual para cada usuario. Cada usuario tiene
su propio directorio de archivos de usuario (UFD – User File Directory) y al iniciar
sesión en el sistema, se explora el directorio maestro de archivos (MFD – Master
File Directory) indexado por el nombre de usuario y cada una de sus entradas apunta
al UDF del usuario en cuestión.
Si bien este esquema supera el obstáculo de la colisión de nombres, aísla a los

usuarios del sistema impidiendo que cooperen para llevar a cabo cierta tarea. Sin
170
embargo, se puede permitir acceso a los archivos de otros usuarios debiendo indicar
el nombre del usuario al que se desea acceder junto con el nombre del archivo,
definiendo así un nombre de ruta o camino (path). Por ejemplo, si quiero acceder a mi
archivo prueba simplemente lo nombro, pero si quiero acceder al del usuario B, debo
acceder mediante /usuarioB/prueba.
Este esquema puede verse como una estructura de árbol de altura dos, donde
la raíz es el MFD, sus hijos son UFD y los hijos de estos son los propios archivos, que
a su vez actúan como hojas.
III. Árbol:
Esta generalización permite a los usuarios crear sus propios subdirectorios y
organizar sus archivos de manera acorde. Cada directorio, contiene un conjunto de
archivos o subdirectorios. Un bit en cada entrada indica si esa entrada es un archivo
(0) o un directorio (1).
Si el usuario quiere un archivo del directorio actual, simplemente accede a él, si

quiero un archivo de otro directorio, debo especificar el path, moviéndose dentro de los
directorios mediante llamadas al sistema. Los path pueden ser:
 Absolutos: Parte de la raíz, y sigue el camino hasta el archivo.
 Relativos: Define un camino a partir del directorio actual.
Por ejemplo, si el directorio actual es root/spell/mail, entonces el path relativo

prt/first hace referencia al mismo archivo que el path absoluto root/spell/mail/prt/first
Una decisión de política es la eliminación de directorios. Si está vacío, se

puede borrar fácilmente. Si contiene archivos o subdirectorios, se debe decidir:
 No lo elimino: Obligo al usuario que lo vacíe antes de borrarlo, pero podría

ser un trabajo engorroso si contiene subdirectorios.
 Lo elimino: El sistema se encarga de eliminar todos los archivos y

subdirectorios de ese directorio recursivamente, pero al borrarse archivos
anidados, puede que borremos alguno importante por error u olvido.
171
En problema que acarrea este esquema es que es complicado acceder de una

rama a otra, en cuyo caso se obliga al usuario a acceder siempre desde la raíz. Sin
embargo, es el esquema más difundido, y el que usualmente conocemos.
IV. Grafo:
Sistemas aun más avanzados permiten estructuras con forma de grafo para
representar los directorios y los archivos.
Hay subdirectorios/archivos que se comparten en dos o más lugares

simultáneamente; no hay dos (o más) copias del elemento, sino que se puede acceder
al mismo elemento desde dos lugares diferentes.
Esto se logra mediante la implementación de:
 Soft links (también llamados symlinks o symbolic links) son un tipo especial
de archivo que hace referencia (apunta) al
archivo/directorio original. Podemos verlo como un
“acceso directo”, y además de ser útiles para una
estructura en grafo, también puede potenciar el uso
de la estructura de árbol. Estos enlaces se puede
hacer entre distintitos sistemas de archivos. Cuando
se borra el archivo origen y existen enlaces simbólicos a él, si se tratase de
acceder por medio de uno de estos enlaces generaría un error.
 Hard links (comúnmente llamado simplemente link) permiten que un

archivo (pero no un directorio) se encuentre
simultáneamente en más de un directorio. Tenemos
un conjunto de metadatos distintos apuntando al
mismo dato, perdiendo la distinción entre el archivo
origen y el enlace. Cuando se borra el archivo origen,
hay que tener cuidado de no borrar el dato si es que
hay varios metadatos apuntando a él. Solamente si hay un único metadato
apuntando a esos datos se puede borrar completamente el archivo, para
ello es necesario llevar un contador de referencias que indique cuántos
metadatos están apuntando a ese dato particular. Al borrar un enlace de
este tipo, se decrementa dicho contador y se elimina el metadato, y si el
contador llega a 0 se elimina el dato al que apuntaba el último metadato en
ser eliminado.
172
Un problema que debemos considerar es que un mismo archivo puede tener

múltiples path absoluto, y además, cuando se elimina algún archivo, podrían quedar
referencias colgantes (punteros) a él. Para ello se utiliza un esquema de garbage
collector que libera esos espacios de disco, pero es muy costoso. Debido a esto, es
que se prefiere trabajar en un esquema de grafo acíclico como el que se muestra a
continuación:
Pero tiene la desventaja que se necesita verifica que no se formen ciclos.
10.3 Protección del sistema de archivos

Se debe proteger la información tanto de daños físicos (problemas de
hardware, corte del suministro de energía, etc.) como de accesos indebidos en
sistemas multiusuario. En los sistemas que no permiten el acceso a archivos de otros
usuarios no se necesita este tipo de protección.
Para proteger el sistema de archivos encontramos dos estrategias:
 Tipo de acceso: Brinda acceso controlado por parte de los usuarios a los
archivos.
 Grupo de acceso: El acceso depende de la identidad del usuario,

asociando a cada archivo y directorio una lista de acceso que especifique
las operaciones permitidas para cada usuario.
En ambos casos se deben declarar una combinación de permisos sobre un

archivo. Los más comunes son:
 Escritura: permite escribir un archivo.

 Lectura: permite leer un archivo.
 Ejecución: permite la carga y posterior ejecución de un archivo.
 Borrado: permite el borrado de un archivo y liberación del espacio para su
reutilización.
 Listado: permite listar nombre y atributos de un archivo.
También contamos con otras estrategias, como por ejemplo proporcionar una
contraseña sobre cada archivo, pero tiene unas cuantas desventajas asociadas. En
sus casos extremos, si las contraseñas son distintas por cada archivo el usuario tendrá
173
que recordar demasiadas contraseñas; si se proporciona una única contraseña sobre

todos los archivos, una vez descubierta se tendrá acceso a todos los archivos.
10.4 Implementación del sistema de archivos

Ya es momento de pasar de la perspectiva del usuario del sistema de archivos
a la perspectiva del implementador.
A los usuarios les interesa la forma de nombrar los archivos, las operaciones
que pueden efectuarse con ellos, el aspecto que tiene el árbol de directorios y
cuestiones de interfaz. A los implementadores les interesa como están almacenados
los archivos y directorios, como se administra el espacio en disco y como puede
hacerse que todo funcione de forma eficiente y confiable.
Hay dos problemas de decisión de diseño del sistema de archivos:
 Definir qué aspecto debe presentar el sistema a los usuarios. Implica la

definición de un archivo y sus atributos, las operaciones y la estructura de
directorios para organizarlos.
 Crear algoritmos y estructuras de datos para establecer correspondencias

entre el sistema de archivos lógico y los dispositivos de almacenamiento
secundario.
El sistema de archivos está compuesto de varias capas, como se muestra a

continuación. Cada una de ellas aprovecha las funciones de las capa inferiores.
Detallando las capas intermedias:
 Control de E/S: Consta de drivers o

controladores de dispositivos y
manejadores de interrupciones para
transferir información entre la memoria y el
sistema de disco.
 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 (ej: unidad 1, cilindro
73, sector 10).
 Módulo de organización de archivos: Conoce los archivos, sus bloques

lógicos y sus bloques físicos, trabajando como traductor de direcciones de
bloques (lógicas a físicas) para que el sistema de archivos básico realice la
transferencia. Los bloques lógicos de cada archivo de numeran del 0 a N.
También incluye el administrador de espacio libre.
 Sistema de archivos lógico: Emplea la estructura de directorios para

proporcionar al módulo de organización la información que éste necesita, a
174
partir de un nombre de archivo. También se encarga de la protección y la

seguridad.
Para crear un archivo nuevo, un programa de aplicación llama al sistema de

archivos lógico, éste trae el directorio apropiado a la memoria, lo actualiza con la
nueva entrada, y lo vuelve a escribir en el disco.
Antes de que el archivo pueda ser utilizado para una operación de E/S, es
precioso abrirlo. Cuando un archivo se abre, se busca la entrada deseada en la
estructura de directorios. La información correspondiente, como su tamaño,
propietario, permisos de acceso y ubicación de los bloques de datos, se copia en una
tabla en la memoria llamada tabla de archivos abiertos. El índice que corresponde al
archivo abierto en esta tabla se devuelve al programa de usuario, y todas las
referencias posteriores de hacen a través del índice.
En tanto no se cierre el archivo todas las operaciones con él se harán a través

de la tabla de archivos abiertos. Cuando todos los usuarios que abrieron un archivo lo
cierran, la información actualizada del archivo se copiará de vuelta en la estructura de
directorios en el disco.
Los dispositivos físicos (discos) proveen la siguiente estructura:
 Bloque de control del archivo (File Control Block): Contienen la

información de los archivos contenidos en el sistema, pero no el nombre.
Este bloque contiene:
o Los permisos del archivo
o Fechas (creación, modificación, ultimo acceso)
o Usuario propietario, grupo propietario
o Tamaño
o Bloques de datos asignados al archivo
 Bloque de control para el boot (Boot Control Block): Contiene la

información necesaria para bootear el SO. Es conocido como Boot Block en
UNIX, y Partition Boot Sector en Windows.
 Bloque de control de la partición (Partition Control Block): Contiene la

cantidad de bloques de la partición, el tamaño de cada uno, los bloques
utilizados y libres, así como también un contador de FCB libres y punteros a
FCB. Es conocido como Master File Table en NFTS (Windows), y
Superblock en UFS (UNIX).
 Estructura de directorios: Contiene la información de los directorios para

organizar los archivos, manteniendo un conjunto de punteros a los FCB de
los archivos que le pertenecen. Dos posibles alternativas para organizarlos:
o Lista encadenada: Los nombres de los archivos y un puntero a su
FCB son dispuestos en una lista encadenada. Esto genera que el
acceso sea de orden lineal.
o Tabla de hash abierto: Con el nombre del archivo se genera la clave
que lo identifica para el acceso.
El Boot Control Block debe estar cargada en al menos una partición, el resto de
las estructuras deben estar presentes en todas las particiones.
175
El SO mantiene en memoria:
 La tabla de particiones de los sistemas de archivos en el disco
 La estructura de directorios de los directorios accedidos recientemente
 File descriptors de los archivos abiertos en el sistema
 File descriptors abiertos por un proceso especifico
10.4.1 Montaje de un sistema de archivos

La idea tras el montaje de un sistema de archivos es combinar múltiples
sistemas de archivos en una única estructura de árbol. De esta forma, un sistema de
archivos debe montarse antes de estar disponible para los procesos del sistema. El
procedimiento es el siguiente:
1. Se proporciona al SO el nombre del

dispositivo, junto con la posición dentro de
la estructura de archivos en la que debe
adosar el sistema de archivos (punto de
montaje).
2. El SO verifica que el dispositivo contenga

un sistema de archivos válido; esto lo
hace pidiendo al driver del dispositivo que
lea el directorio del dispositivo y
compruebe que tenga el formato
esperado.
3. El SO toma nota en su estructura de

directorios de que un sistema de archivos
está montado en el punto de montaje
especificado.
Por ejemplo, en sistemas Unix se puede montar un directorio a partir de un

dispositivo mediante el comando mount como se muestra en el siguiente ejemplo:
Hay que tener en cuenta que en cada sistema de archivo el identificador de un

fichero es único, pero no tiene por qué serlo globalmente.
176
10.4.2 Sistemas de archivos virtual (VFS – Virtual File System)

Es común que en un SO se acceda a más de una implementación de archivos,
como ufs, ext2, ext3, jfs, jfs2, ntfs, etc.
Para lograr mantener una estructura independiente al sistema de archivos que

se utilice se emplean técnicas de orientación a objetos.
De esta forma, se genera una estructura en tres capas:
- Interfaz del sistema de archivos (file system interface): proveen al usuario

de las operaciones más comunes sobre archivos, entre ellas: open, read.
- Interfaz del sistemas de archivos virtual (VFS interface): permite a los
usuarios acceder a información guardada de diferentes modos por medio
de una sola interfaz unificada.
- Implementación específica del sistema de archivos.
10.4.3 Métodos de asignación

El problema es cómo distribuir los archivos propiamente dichos (los datos y no
sus atributos) en el disco de forma de aprovechar el espacio, y poder acceder
rápidamente a ellos. Para ello encontramos tres métodos detallados a continuación.
I. Asignación Contigua (Contiguous Allocation):

Cada archivo ocupa un conjunto de bloques contiguos en el disco. Si el archivo
tiene bloques (largo) y comienza en la posición ocupará losbloques
.
177
La dificultad es encontrar espacio para un nuevo archivo, para ello se deben

contar con los algoritmos de asignación dinámica de almacenamiento, comúnmente
las estrategias de first fit y best fit. Como ya vimos, estos algoritmos padecen el
problema de la fragmentación externa (el disco se divide en trozos pequeños
inutilizables). Su solución, es la compactación pero insume gran cantidad de tiempo,
proceso comúnmente conocido como desfragmentación de disco.
Otro problema es que se debe determinar de antemano el espacio necesario

para alojar un archivo, además si trabajamos con archivos que crecen lentamente a
medida que pasa el tiempo, debemos asignarle un gran tamaño al crearlo, el cual va a
estar la mayor parte del tiempo desocupado, creando fragmentación interna.
En caso de exceder el límite contamos con dos soluciones:

copiarlo en un bloque más grande o utilizar un esquema de
asignación contigua modificado, en el que inicialmente se asigna un
trozo contiguo de espacio y cuando ese espacio deja de ser
suficiente se añade una extensión a la asignación inicial, conocida
como EXTENS.
II. Asignación Enlazada (Linked Allocation):

Resuelve todos los problemas de la asignación contigua. Cada archivo es una
lista enlazada de bloques de disco, el directorio contiene un puntero al primer y al
último bloque del archivo, y cada bloque contiene un puntero al siguiente.
Para crear un archivo nuevo, simplemente creamos una nueva entrada en el

directorio con valor NIL, y se asigna cero al campo size (algunos sistemas utilizan un
campo end que apunta al último bloque, en este caso se dejaría en valor NIL).
Para leer un archivo, basta con leer los bloques siguiendo los punteros de un
bloque al siguiente, y para escribir, se escribe en un bloque libre, y se lo enlaza al final
del archivo.
178
El principal problema es que sólo puede usarse efectivamente para archivos de

acceso secuencial, ya que el acceso a los bloques es lineal. La solución usual a este
problema es juntar bloques en múltiplos (por ejemplo, de a 3 bloques consecutivos),
llamados clusters, y asignar los clusters en lugar de los bloques, pero trae el problema
de fragmentación interna.
Un problema adicional surge cuando un puntero se pierde o daña, por lo tanto,

debería guardar información adicional para comprobar la correctitud, generando más
gastos. El puntero no solo podría perderse, sino que podría llegar a apuntar a datos de
otro archivo. A su vez, los punteros ocupan espacio en los bloques, disminuyendo así
el espacio efectivo de almacenamiento. También provoca un mayor movimiento de
cabezales, dado que los bloques de disco no son contiguos.
Una variación importante del método de asignación enlazada es usar una tabla
de asignación de archivos (FAT, File-Allocation Table | Utilizado en las primeras
versiones de Windows y DOS, y actualmente muy difundido en pendrives).
Se aparta una sección del disco al principio de cada partición para guardar esta
tabla, única en el sistema de archivos residente en la partición, la cual tiene una
entrada para cada bloque del disco y está indizada por número de bloque.
179
Cada entrada en la FAT o bien tiene el índice del siguiente bloque del archivo,
o bien el valor NIL indicando que el sector está libre (usualmente -1), o bien un valor
especial denominado EOF (End Of File) (usualmente 0) indicando el fin de archivo.
Para asignar un bloque nuevo a un archivo, basta con encontrar la primera

entrada de la tabla que valga NIL y sustituir el valor EOF anterior por la dirección del
nuevo bloque.
III. Asignación Indizada (Indexed Allocation):

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 un vector de direcciones de

bloques de disco. La i-ésima entrada del bloque índice apunta al i-ésimo bloque del
archivo. Cuando se crea el archivo, se asigna NIL a todos los punteros del bloque
índice. La primera vez que se escribe el i-ésimo bloque, se obtiene un bloque del
administrador de espacio libre y su dirección se coloca en la i-ésima entrada del
bloque índice.
No sufre fragmentación externa y mejora la eficiencia, pues los bloques son

accedidos directamente a partir del bloque índice. Aún así, desperdicia un gran
espacio ya que el gasto extra de guardar los punteros del bloque índice generalmente
es mayor que el de los punteros de la asignación enlazada.
Un problema que puede resultar catastrófico ocurre cuando se daña o pierde la

referencia al bloque índice del archivo, perdiendo total referencia a él.
Se trata que el tamaño del menor tamaño posible, pero acarrea el problema de
que si el tamaño del bloque índice es demasiado pequeño no podrá contener
suficientes punteros para un archivo grande. Los mecanismos para resolver este
problema son:
 Esquema enlazado: Enlazar varios bloques índice (ya que un bloque

índice ocupa normalmente un bloque de disco).
180
 Índice multinivel: Usar un bloque índice de primer nivel que apunte a un

conjuntos de bloques índice de segundo nivel, que a su vez apuntan a los
bloques de disco.
 Esquema combinado(26): Guardar los primeros, (por ejemplo) 15 punteros

del bloque índice en el bloque índice del archivo.
o Los primeros 12 punteros apuntan a Bloques Directos: bloques con

datos del archivo. Busca abarcar archivos de pequeño tamaño.
o Los restantes 3 punteros apuntan a Bloques Indirectos, de tipo:
 Simple: Bloque índice que no contiene datos, solo

direcciones de bloques que sí contienen datos. Busca
abarcar archivos de mediano tamaño.
 Doble: Contiene la dirección de un bloque que contiene las

direcciones de bloques que contienen punteros a los bloques
de datos reales. Busca abarcar archivos de gran tamaño.
 Triple. Un puntero de archivo de 32 bits, alcanza para 4Gb.

Se utiliza como auxiliar en caso de tener un archivo
excesivamente grande.
En UNIX, los FCB (File Control Block) son conocidos como i-nodos y tienen
bloques de indexación directa de uno, dos y hasta tres niveles de indexación,
permitiendo representar archivos muy grandes. A continuación la representación de un
i-nodo:
Los bloques índice se pueden colocar en un caché, pero los bloques de datos
podrían estar dispersos por toda una partición, esto causaría problemas de
desempeño.
26
Esquema utilizado en UNIX, los i-nodo. La imagen a continuación muestra esquemáticamente un i-
nodo.
181
10.4.4 Administración del espacio libre

El SO debe saber cuáles bloques están ocupados y cuáles están libres, para
ello hay varias alternativas:
 Vector de bits (Bit-map, Bit-vector): 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.
Resulta relativamente sencillo y eficiente encontrar el primer bloque libre, o
n bloques libres consecutivos en el disco, pero son ineficientes si el vector
entero no se mantiene en la memoria principal, y esto solo es posible si el
disco no es demasiado grande. – UNIX utiliza este esquema
 Lista enlazada de bloques libres (Linked-list): Se enlazan entre sí los

bloques de disco libres, manteniendo un puntero al primer bloque libre en
una posición especial del disco y colocándolo en caché. Este esquema no
es eficiente ya que para recorrer la lista necesitaríamos leer cada bloque,
ocupando una cantidad sustancial de tiempo de E/S, aunque no se necesite
hacerlo frecuentemente.
 Agrupación (Grouping): Es una variación de la lista encadenada. Consiste

en almacenar las direcciones de bloques libres en el primer bloque libre.
Los primeros de estos bloques están realmente libres, mientras que el
último contendrá las direcciones de los otros boques libres.
 Conteo (Counting): Se mantiene una lista en donde cada bloque contiene

información de cuantos bloques contiguos, a partir de él, están libres.
El esquema de FAT no utiliza ninguna de estas alternativas para administrar el

espacio libre ya que no es necesario, la propia tabla ya indica qué espacios están
libres y cuáles no.
10.5 i-Nodo – UNIX

Cada partición en UNIX contiene un bloque descriptor del sistema de archivo
denominado super-block. Éste contiene principalmente:
- Nombre del volumen (nombre del filesystem)

- Cantidad máxima de archivos (i-nodos), cantidad de archivos utilizados y
libres.
- Cantidad de bloques de datos, cantidad de bloques utilizados y libres.
- Referencial comienzo del bloque de datos, de indexación y vector de bits.
Los i-nodos son una estructura de datos propia de los sistemas de archivos
tradicionalmente empleados en UNIX, y contienen las características (permisos,
fechas, ubicación, pero NO el nombre) de un archivo regular, directorio, o cualquier
otro objeto que pueda contener el sistema de ficheros.
El concepto es particularmente importante para la recuperación de los sistemas

de archivos dañados.
182
Cada i-nodo queda identificado por un número entero, único dentro del sistema
de archivo.
Los directorios recogen una lista de parejas formadas por un número del i-nodo
y nombre identificativo que permite acceder al archivo en cuestión: cada archivo tiene
un único i-nodo, pero puede tener más de un nombre en distintos o incluso el mismo
directorio para facilitar su localización.
Los atributos más importantes del i-nodo son los siguientes:
 El identificador de dispositivo del dispositivo que alberga al sistema de

archivos.
 El número de i-nodo que identifica al archivo dentro del sistema de
archivos.
 La longitud del archivo en bytes.
 El identificador de usuario del creador o un propietario del archivo con
derechos diferenciados.
 El identificador de grupo de un grupo de usuarios con derechos
diferenciados.
 El modo de acceso: capacidad de leer, escribir, y ejecutar el archivo por
parte del propietario, del grupo y de otros usuarios.
 Las marcas de tiempo con las fechas de última modificación, acceso y de
alteración del propio i-nodo.
 El número de enlaces, esto es, el número de nombres (entradas de
directorio) asociados con este i-nodo.
El número de enlaces es utilizado por el SO a la hora de eliminar el archivo del

sistema de ficheros (tanto el i-nodo como el contenido) cuando se han borrado todos
los enlaces y el contador queda en cero.
En el curso, usualmente nos piden implementar un filesystem de acuerdo a

ciertas características. A continuación se presenta un ejercicio práctico del examen de
Marzo de 2013 referente a i-nodos.
Un sistema operativo administra sus archivos en disco utilizando el método de

asignación indexada directa con las siguientes estructuras de datos
183
Se sabe que el directorio raíz es el i-nodo número 0 y, que la tabla de i-nodos,

el bitmap, y el disco son globales. Conjuntamente, cada bloque de datos de los
directorios tiene 256 entradas de tipo dir_entry.
Además, se dispone de las siguientes primitivas
Se pide:
1. Implementar una función que retorna el i-nodo correspondiente al archivo (i-

nodo con de tipo FILE) más grande del sistema:
184
En el parámetro inode se retorna el índice en la tabla de i-nodos del inodo de

tamaño más grande. En caso que existan más de un inodo con el máximo
tamaño se debe retornar cualquiera de ellos. En el parámetro ok se retorna el
éxito en la ejecución de la operación.
2. Implementar un función que determine si un directorio está lleno o no.
El parámetro dir representa el camino absoluto del directorio a verificar (Ej.

'/home/sistoper') y el parámetro full retorna verdadero en caso que el directorio
tenga todas sus entradas ocupadas. En el parámetro ok se retorna el éxito en
la ejecución de la operación.
3. Implementar una función que renombra un archivo o directorio dentro de un

directorio:
El parámetro origen representa el camino absoluto del archivo original (Ej.

'/home/sistoper/origen.txt') y el parámetro nuevo representa el nuevo nombre
del archivo o directorio (Ej. 'destino.txt'). En el parámetro ok se retorna el éxito
en la ejecución de la operación.
185
186
187
10.6 FAT – Windows

En el curso, usualmente nos piden implementar un filesystem de acuerdo a
ciertas características. A continuación se presenta un ejercicio práctico del examen de
Marzo de 2011 referente a FAT.
Sea un sistema de archivos (filesystem) simplificado que cuenta con la siguiente

estructura de datos:
Se pide:
1. Realizar una función que encuentre un archivo en un directorio.
Donde dir_entry es el directorio donde se está buscando, name y ext son el

nombre y extensión del archivo a buscar, entry es el número de entrada donde
está el archivo y ok determina si la operación finalizó con éxito o no.
2. Implementar una función que remueva una archivo de un directorio.
dir_entry es el directorio donde se está buscando, name y ext son el nombre y

extensión del archivo a remover, ok determina si la función finalizó con éxito. Si
el nombre del archivo recibido es un directorio, la operación debe finalizar sin
éxito.
3. Implementar una función que copie un archivo.
188
d_source es el directorio origen, name_s y ext_s es el nombre del archivo

origen, d_target es el directorio destino, name_t y ext_t es el nombre del
archivo destino y ok determina si la operación finalizó con éxito o no. En caso
de utilizar alguna estructura auxiliar, mencionar y dar semántica de
operaciones. Esta operación no es aplicable a directorios. Para operar sobre el
disco utilice las operaciones: readSector y writeSector, dar parámetros y
semántica.
Notas generales:
 Las variables D y SA son globales.

 La información del directorio raíz está en SA[0].
 En la fat el valor 0 representa "fin de archivo" y el -1 "sector libre".
 El campo dir_index en file es solo usado cuando el archivo es un directorio.
 Tener en cuenta que toda operación debe dejar el sistema de archivos en
un estado consistente.
189
190
Otra circunstancia que se nos puede presentar es que a partir de ciertas

especificaciones, diseñemos el filesystem y luego implementemos ciertas
funcionalidades a partir de él. Para ello nos basaremos en el siguiente ejemplo:
Se desea implementar el sistema de archivos de un sistema operativo, de tal

manera que los siguientes requerimientos sean soportados.
 Manejo jerárquico de directorios, con cualquier profundidad.

 Un máximo de MAX_ARCHIVOS_DIR entradas por directorios.
191
 Manejo de archivos, donde estos deben soportar:

o nombres con un largo máximo de 8 caracteres.
o extensiones con un largo máximo de 3 caracteres.
o información descriptiva de cada archivo (hasta 10 caracteres).
o dirección de comienzo en la FAT del almacenamiento del archivo.
 Manejo de subdirectorios:
o nombres con un largo máximo de 8 caracteres.
Se guardan los datos de los archivos en una estructura tipo FAT, la cual tiene
una cantidad limitada de sectores en disco (MAX_SECTORES_DISCO). Cada
elemento de la FAT corresponde a un sector del disco. Cuando ese sector no está
utilizado el elemento correspondiente de la FAT contiene cero. En caso de que el
sector este asignado a un archivo pero no sea el ultimo del mismo, contiene la
dirección del siguiente sector asignado a dicho archivo. Cuando es el último sector
asignado a un archivo, contiene FFFF. Un sector tiene TAM_SECTOR bytes.
Se pide:
1. Indique las estructuras necesarias para satisfacer estos requerimientos

(incluyendo los directorios y la FAT).
2. Indique como será cargada esta estructura al iniciar el sistema y donde será
almacenada en el disco esta misma. Indique también si existe alguna
restricción en el lugar donde se almacena su estructura.
3. Dado un archivo, indicado por su camino absoluto (desde el directorio raíz),

escribir un algoritmo que encuentre dicho un archivo, y que luego lo recorra,
devolviendo la cantidad de bytes que ocupa
4. Indique tres posibles consecuencias de una caída de la maquina (por

ejemplo, por un corte de energía) en cuanto a la integridad de las estructuras
definidas.
Aclaraciones:
- Se dispone de la función auxiliar parseCamino, la cual dada una ruta

absoluta para un archivo, retorna un array de strings con los componentes
del camino junto con la cantidad de componentes en dicho camino
parseCamino(char[], char[][], integer). Por ejemplo, la invocación:
parseCamino(“/dir1/dir12/dir123/arch.ext”, ruta, cntcmp);
Deja ruta cargado con la siguiente información: ruta = { “/”, “dir1”, “dir12”,
“dir123”, “arch.ext” } y cntcmp con el valor 5. Si existe alguna condición de
error, ruta vuelve NULL y cntcmp en -1
- Los archivos indicados por un camino absoluto siempre empiezan con “/”, y
terminan con el nombre del archivo
- Se podrá disponer de las funciones
writeDirectoryToSector(dir: *** ; sector: integer);
readDirectoryFromSector(sector: integer): ***;
192
Las cuales leen y graban un directorio completo a un sector del disco. Se

asume que un directorio entero ocupa un sector. Asimismo la escritura de
un directorio, no implica la escritura de los subdirectorios en este presente.
*** representa la estructura que se defina para los directorios
- Se dispone de la función:
directoryIsLoaded(char[] dir_name): ***;
La cual indica si un directorio ha sido o no cargado desde el disco. En caso

afirmativo devuelve el directorio cargado, sino devuelve NULL. El propio
sistema operativo es el encargado de mantener en sus estructuras de
memoria los directorios cargados.
*** representa la estructura que se defina para los directorios
- Se dispone de las funciones:
writeSector(data: byte[TAM_SECTOR], sector: integer);
readSector(sector: integer, data: byte[TAM_SECTOR]);
1. Las siguientes estructuras cumplen con los requisitos pedidos.
Representamos las entradas de directorios, donde cada una puede representar un

archivo o un subdirectorio. En cualquier caso tenemos una marca de booleana de
usado. Para los archivos guardamos nombre, extensión, información descriptiva y el
primer sector de la FAT donde se encuentra la información del mismo. Luego se
encadena en la FAT la información que el archivo contiene.
Para los directorios lo que tenemos es una entrada para el nombre y el sector en el
disco donde se almacena esta estructura.
193
2. Al iniciar el sistema deberán levantarse la estructura para la FAT y para el

directorio raíz, ya que estos son los puntos iniciales desde donde se navega el sistema
de archivos. Para esto el directorio raíz será almacenado en el sector 0 del disco,
indicándose en la FAT este sector siempre como ocupado. La FAT será almacenada
en los sectores siguientes del disco, ocupando tantos sectores como corresponda al
tamaño de la estructura. La FAT deberá ser respaldada a disco antes de finalizar el
trabajo con el sistema para evitar inconsistencias en el sistema de archivos. Asimismo,
al iniciar el sistema, deberá dejarse disponible en forma global la FAT y el directorio
raíz, DIRECTORIO_RAIZ.
3. Nos pasan un archivo especificado por su camino absoluto. A partir de este

debemos recorrer desde la raíz del sistema de archivos
194
195
4. Consecuencias en cuanto a las estructuras definidas ante una caída del sistema:
- Archivos truncos: Corrupción en los archivos del disco. Una cadena de

sectores en la FAT puede quedar sin el marcador de fin FFFF, con lo cual no
se sabría donde termina el archivo.
- Archivos que compartan cola: Dos cadenas de archivos pueden unirse

(también por corrupción) en un mismo archivo
- Pueden existir cadenas ocupadas, que no pertenezcan a ningún archivo
- Los directorios pueden no ser almacenados en disco ante una caída
196
11 Estructura de los dispositivos masivos de datos

Los discos son los dispositivos de almacenamiento secundario más usados en
los sistemas de computación modernos, y tienen la siguiente estructura básica:
Se compone de:
 Uno o más platos.

 Un eje de rotación que gira los platos.
 Cada plato tiene dos caras, por tanto en número duplica al número de
platos.
 Cada cara es dividida en círculos concéntricos llamados pistas
 Cada pista se divide en sectores.
 Un cilindro está formado por la misma pista entre todos los discos
 Un brazo mecánico que se desplaza por el disco.
 El brazo contiene cabezales de lectura-escritura, que coinciden en número
con la cantidad de caras.
Los sectores son las unidades mínimas de transferencia de un disco duro. Las
caras y cilindros comienzan a numerarse desde el cero y los sectores desde el uno. En
consecuencia, el primer sector de un disco duro será el correspondiente a la cara 0,
cilindro 0 y sector 1.
Lógicamente las pistas más internas tendrán un perímetro más pequeño, por
tanto tendrán una capacidad de almacenamiento menor que las pistas más externas.
De esta forma, como la velocidad de giro de los discos es uniforme y se busca una
velocidad de transferencia uniforme, todas las pistas deberán tener la misma cantidad
de sectores, provocando que sectores en pistas externas estén más separadas.
197
Los discos pueden conectarse a un sistema informático de dos formas:
 Utilizando un controlador de disco, al que se accede a través de puertos

de E/S locales de la computadora por medio de una controlador de equipo
conectada al BUS de I/O, y esta a su vez conectada a través de un BUS
especial (ej. SATA) con el disco.
 Utilizando una conexión de red, tenemos dos variantes
o Almacenamiento Conectado a la Red (NAS – Network Attached

Storage), que puede ser por medio de conexión LAN (Local Area
Network) / WAN (Wide Area Network)
o Redes de Área de Almacenamiento (SAN – Storage-Area

Network), es una red privada que conecta los servidores con las
unidades de almacenamiento.
Las solicitudes de E/S de disco son generadas por el sistema de archivos y por
el sistema de memoria virtual. Cada solicitud especifica la dirección de disco a la que
hay que referenciar, en la forma de un número lógico de bloque que luego hay que
mapear. Por este motivo, debemos planificar el disco.
198
11.1 Planificador de disco

El SO debe usar eficientemente las unidades de disco, lo que implica tener un
tiempo de acceso breve y un gran ancho de banda, definidos como:
 Ancho de banda del disco (bandwidht): Es el número de bytes

transferidos dividido entre el tiempo total transcurrido entre la primera
solicitud de servicio y la finalización de la última transferencia.
 Tiempo de acceso: Tiene dos

componentes principales:
o Seek time (tiempo de
posicionamiento): Tiempo que
tarda el brazo del disco en
mover los cabezales hasta el
cilindro que contienen el
sector deseado.
o Rotation latency (latencia
rotacional): Tiempo adicional
que tarda el disco en girar
hasta que el sector deseado
queda bajo del cabezal.
La idea del planificador entonces es minimizar el tiempo de acceso de

acuerdo a la siguiente expresión:
Para hacerlo se intenta minimizar el tiempo de

posicionamiento (o búsqueda), dado que el tiempo de
latencia rotacional difícilmente se pueda saber puesto
que los discos modernos no revelan la especificación
física de los bloques lógicos.
La imagen izquierda muestra cómo en un

ambiente multiprogramado tenemos un conjunto de
procesos realizando solicitudes de acceso a disco
requiriendo archivos, ya sea para lectura, escritura o
ejecución. Estas solicitudes no son exclusivas de los
procesos, sino que también el propio SO puede
realizarlas. Dado que las solicitudes son puestas en la
I/O-queue del disco, debe buscarse algún mecanismo
para despacharlas de forma eficiente (siguiendo las
pautas mencionadas anteriormente), y es así surgen
distintos algoritmos para la planificación de disco.
199
11.2 Algoritmos de planificación de disco

En este contexto, se cuenta básicamente con cuatro algoritmos para la
planificación de disco, detallados a continuación.
I. First Come First Served (FCFS)

Atiende los pedidos en el orden de llegada. Es ineficiente puesto que en
algunas combinaciones del cabezal debe recorrer muchos cilindros del disco para
completar el pedido.
II. Shortest Seek First Time (SSTF)

Atiende todas las solicitudes cercanas a la posición actual de la cabeza antes
de mover a la cabeza a la posición lejana para atender otras solicitudes. Es eficiente
pues reduce el Seek Time.
Como todo lo que empieza por “shortest”, puede presentar posposición

indefinida dado que si hay un gran flujo de bloques cercanos a la posición actual, no
se sabe si en algún momento las solicitudes lejanas serán atendidas.
200
III. SCAN / C-SCAN

En el algoritmo SCAN(27), 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 hasta el otro extremo del disco, donde se invierte la dirección de
movimiento de la cabeza, continuando la atención. El algoritmo C-SCAN (Circular-
SCAN) es similar, salvo que cuando llega al otro extremo regresa de inmediato al
principio del disco sin atender solicitudes.
IV. LOOK / C-LOOK

Análogos a SCAN / C-SCAN, solo que en lugar de arrancar siempre para el
mismo sentido, arranca para el sentido donde haya pedidos.
Ejemplo – Aplicando tres de los algoritmos:
Las figuras detalladas anteriormente en cada ejemplo muestran como una cola tiene
solicitudes de E/S a bloques que están en los cilindros: 98 183 37 122 14 124 65 67. El
disco contiene 200 cilindros, numerados del 0 al 199. Suponiendo que el cabezal está
en el cilindro 53 tenemos que:
27
También conocido como el Algoritmo del Ascensor
201
- Aplicando FCFS: primero se moverá del 53 al 98, luego al 187, 37… y así hasta al
final, con un movimiento de cabeza de 640 cilindros
- Aplicando SSFT: la solicitud más cercana de la cabeza (53) es 65, luego 67, 37,
14, 98, 122, 124 y 183, por lo que hay un movimiento total de cabeza de 236.
- Aplicando SCAN: suponemos que la dirección de movimiento de la cabeza se

mueve de 53 a 0, por lo que primero se atiende a 37, luego 14, 65, 67, 98, 122,
124, 183, teniendo un movimiento total de cabeza de 282.
Como conclusión, SSTF y LOOK/C-LOOK son los algoritmos más utilizados.

SCAN/C-SCAN está comprobado que funcionan muy bien en ambientes donde se usa
mucho el disco.
11.3 Selección de los algoritmos de planificación de disco

FCFS (First Come First Served)
 Servicio por orden de llegada

 Hay un mayor movimiento total de la cabeza que da menor desempeño.
SSTF (Shortest Seek Time First)
 Se busca aquel que implique un tiempo más corto dada la posición actual
de la cabeza.
 Hay que tomar alguna política adicional para evitar posposición indefinida.
Esto se da cuando se está procesando cierta solicitud y llega una solicitud
de acceso cercana a esta posición. Ésta nueva solicitud será atendida
próximamente y en consecuencia las solicitudes (que ya estaban
pendientes) más lejanas tendrán que esperar.
 Mejor tiempo que FCFS, SCAN / C-SCAN, pero no es optimo.
SCAN
 El brazo del disco parte de un extremo del disco, y se mueve hacia el otro,
atendiendo las solicitudes correspondientes a cada cilindro. Cuando llega al
otro extremo del disco, invierte la búsqueda
 Cuando la cabeza “da la vuelta” tiene pocas solicitudes para atender,
pues sigue su recorrida en los cilindros que visito más recientemente. La
mayoría de las solicitudes pendientes estarán en los últimos cilindros a
recorrer.
 Redunda en un tiempo de espera no uniforme.
C-SCAN
 Variante del anterior. Soluciona el problema de posicionamiento y

procesamiento de solicitudes de éste, moviéndose siempre al cilindro inicial
luego de visitarlos a todos.
202
LOOK / C-LOOK
 Estos algoritmos, “miran” si hay una solicitud antes de continuar

moviéndose en una determinada dirección.
La selección de un algoritmo de planificación está estrechamente ligado el

método de asignación de archivos. Si un programa está leyendo un archivo con
asignación contigua, generará varias solicitudes próximas entre sí, provocando un
movimiento de cabezales mínimo. Por el contrario, si se lee un archivo con
asignación enlazada o indexada puede generar solicitudes que estén muy dispersas
en el disco, debiendo mover los cabezales del disco con mayor frecuencia.
El algoritmo de planificación de disco debe escribirse como módulo

independiente del SO, para poder sustituirlo por otro distinto en caso de ser necesario.
Una observación no poco menor, es que si no tenemos un sistema multiprogramado,
cualquier algoritmo degenera en un FCFS.
11.4 Formateo del disco

Antes de poder almacenar datos en el disco es necesario dividirlo en sectores
que el controlador de disco pueda leer y escribir, a este proceso se lo llama formateo
de bajo nivel o formateo físico.
Este formateo llena el disco con una estructura de datos especial para cada
sector, por lo general consiste en una cabecera y un área de datos y un código de
corrección de errores (ECC). La cabecera tiene información que usa el controlador,
como un número de sector, y el ECC contiene suficiente información como para
detectar y posiblemente corregir errores.
Además, este proceso de formateo deja sectores libres en caso que un sector
se encuentre defectuoso o falle. Cuando se detecta un sector de estas características
se lo marca como inválido y no se vuelve a usar, a menos que se trate de una falla, en
cuyo caso para poder utilizarlo nuevamente se debe formatear a bajo nivel
nuevamente.
Para poder utilizar el disco para almacenamiento de archivos primero hay que
dividirlo en uno o más grupos de cilindros (particiones), tratándose a cada partición
como si fuera un disco individual. El segundo paso es el formateo de alto nivel o
formateo lógico, que se encarga de colocar un sistema de archivos en la partición o
dejarla como RAW para espacio de swap.
203
11.5 Sector de arranque - Boot

Para que un computador empiece a funcionar necesita tener un programa
inicial que ejecutar almacenado en ROM, luego lo carga en memoria y salta a una
dirección inicial para comenzar la ejecución del SO.
Éste programa es sencillo y solamente asigna valores iniciales a todos los

aspectos del sistema desde registro de CPU hasta los controladores de dispositivos y
pone en marcha el SO.
El programa de carga inicial completo, se

almacena en una partición llamada bloque de
arranque, en una posición fija del disco.
En Windows, se coloca el código de

arranque en el primer sector del disco duro
(denominado, MBR - Master Boot Record).
Permite dividir un disco duro en una o más
particiones. Una identificada como la partición de
arranque, que contiene el SO y los controladores
de dispositivos.
El MBR tiene una tabla que numera las particiones del disco, junto con un
indicador que marca desde cuál parición hay que arrancar el sistema. El procedimiento
a seguir es:
 El código de boot es ejecutado en ROM

 Éste trae el MBR a memoria
 Ejecuta el MBR, mira la tabla de particionamiento, aprende la partición boot,
trae y ejecuta la partición de boot.
11.6 Estructuras RAID

Las unidades de disco han ido evolucionando para hacerse más pequeñas y
baratas, resultando más viable conectar múltiples discos en un mismo sistema
informático. Este esquema persigue dos objetivos:
 Mejorar la performance, optimizando los tiempos de respuesta y tasa de

transferencia, siempre y cuando esos múltiples discos operen en paralelo.
 Brindar confiabilidad, introduciendo redundancia de información en ese

conjunto de múltiples discos, de forma de poder reconstruir los datos ante
una falla, siempre y cuando los fallos entre discos sean independientes(28).
28
No aplica si ocurre un terremoto y provocase un aterrizaje de cabezales en los distintos discos, lo cual
provocaría daños en varios de los discos a causa de un “rayón” en la superficie magnética y dejando
sectores defectuosos.
204
Las técnicas RAID (Redundant Array of Inexpensive Disks) son utilizadas para
alcanzar estos objetivos, combinando varios discos físicos en una sola unidad lógica
de disco; el SO solo ve las unidades lógicas, no las físicas. Actualmente la letra “I” de
la sigla RAID significa Independent (“independientes”) en lugar de “inexpensive”
(barato).
Para brindar confiabilidad contamos básicamente con dos técnicas:
- Mirroring (duplicación espejo): Es la más simple y menos económica.

Consiste en duplicar cada uno de los discos, de forma que la información
perdida es fácilmente obtenida a partir de su duplicado.
- Bits de control: Se mantiene de alguna forma la paridad de los datos, de

forma que ante una falla, la información pueda ser reconstruida a partir de
esos bits de paridad.
La mejora de la performance se logra a través de técnicas de striping (o

distribución en banda de los datos) y son utilizadas a nivel de bits, bytes, sectores o
bloques. Por ejemplo, se
pueden dividir los bits de
cada byte entre 8 discos, así
podemos escribir el bit de
cada byte en el disco . Otro
ejemplo podría darse cuando
los bloques de cada archivo
se dividen en múltiples
discos, de esta forma con
discos, el bloque de un
archivo va al disco
. La imagen a
derecha muestra este último
ejemplo (agrupación en
banda de bloque) para
:
Niveles RAID
Las técnicas de mirroring proporcionan fiabilidad, pero es caro; las técnicas de
striping mejoran la performance, pero no mejora la confiabilidad. En consecuencia, hay
una serie de diferentes esquemas que combinan los principios de las técnicas de
mirroring y striping de diferentes maneras, con el fin de equilibrar la
confiabilidad/rendimiento vs. costos.
Estos esquemas se describen por diferentes niveles de RAID, detallados a

continuación. En los diagramas que siguen, C indica una copia y P indica de paridad, y
estamos almacenando una cantidad de datos equivalente a la capacidad total de
cuatro discos físicos y discos adicionales se utilizan para almacenar información
redundante con vistas a la recuperación de fallos.
205
I. RAID 0
La información se agrupa en bandas a nivel de bloque
(striping), pero no se provee ninguna redundancia, por lo que la falla
de un disco provoca la perdida de la información contenida en él.
Vendría a corresponderse con el ejemplo ilustrado anteriormente.
Usualmente se utilizan para aumentar el rendimiento, aunque también se

pueden utilizar como forma de crear grandes discos virtuales de un gran número de
pequeñas unidades físicas.
II. RAID 1
La información puede estar en varios discos, pero además
cada uno de estos discos tiene un mirror, de manera que si se pierde
la información de un disco esta puede ser accedida a través de su
“gemelo”.
Son útiles cuando el rendimiento de lectura o la confiabilidad son más

importantes que la capacidad de almacenar información. El tipo de este arreglo puede
ser tan grande como el disco más pequeño.
III. RAID 2
En este caso, la
redundancia se efectúa
agregando discos que
guardan bits de códigos
correctores de errores.
206
Es la misma idea utilizada en la memoria RAM (algo del estilo de los Códigos
de Hamming). Si un disco falla, su información puede ser restaurada usando el código
corrector de errores (ECC).
IV. RAID 3
En este caso se agrega un único disco extra para
contener la paridad de los bits contenidos en los otros
discos. Se usa una distribución en banda a nivel de bit.
Un disco puede informar cuando un bloque está defectuoso, por lo que sí se

sabe que la paridad fue incorrecta para un bit, se sabe que el bit que ocasiono el error
es el contenido en el bloque defectuoso. Esta configuración es tan potente como la
RAID-2, pero es mucho más barata por utilizar un único disco para almacenar la
paridad, y consecuentemente es más utilizada.
207
V. RAID 4
Es un esquema similar al RAID-3, pero la
distribución en banda en vez de ser a nivel de bit, es a
nivel de bloque, incluyendo también un disco de paridad
pero a nivel de bloque.
Este nivel permite que cada miembro del conjunto funcione independientemente
cuando se solicita un único bloque. Si la controladora de disco lo permite, se puede servir
varias peticiones de lectura simultáneamente, pero no ocurre lo mismo con la escritura, ya
que se cuenta únicamente un bloque de paridad. Por tanto una operación de lectura se
puede realizar en paralelo, mientras que la escritura en forma secuencial.
La gran desventaja que presenta este nivel es que por cada escritura en disco,
se debe escribir el disco que contiene los bloques de paridad. La consecuencia de ello
es que el disco que aloja los bloques de paridad se encuentra sobrecargado en
comparación con el resto, teniendo mayor probabilidad de fallo por su alto uso.
VI. RAID 5
Aplica la misma idea que RAID-4, solo que la
paridad no está guardada en un disco particular sino
que está distribuida rotativamente entre los discos, de
forma de distribuir la carga.
208
Una gran ventaja de este nivel es que permite agregar nuevos discos sin alterar
la paridad, solo basta con escribir ceros en el disco nuevo.
VII. RAID 6
En este nivel se agrega más información
redundante, en vez de mantener un solo bloque de
paridad como en RAID-5, tenemos dos bloques de
paridad P y Q, de manera de estar cubierto contra
fallas simultáneas de más de un disco. Se aplican
códigos de Reed-Solomon.
Este nivel podría ser más adecuando que contar con un RAID 5 y un disco de
reserva (esto se conoce como RAID-5E). Su desventaja es que resulta ineficiente para
una pequeña cantidad de discos.
VIII. Combinaciones de RAIDs

Dependiendo de nuestras necesidades, podemos combinar cualquier esquema
de RAIDs imponiendo un esquema por encima de otro. Algunos ejemplos típicos se
muestran a continuación.
RAID 0+1
Es una combinación de los niveles 0 y 1. Es
eficiente y confiable, pero es muy cara, porque requiere
aumentar mucho la cantidad de discos. Se tienen dos
conjuntos de discos funcionando en modo RAID-0,
espejados entre ellos.
209
RAID 1+0
Es otra configuración de los niveles 0 y 1. En
este caso, se tienen N-discos espejados de a pares
(RAID-1), que se incorporan (como si fueran un
único disco lógico) en una configuración RAID-0. Es
una división de espejos.
Selección de un nivel RAID

Una de las consideraciones principales es la velocidad de reconstrucción, puesto
que en caso de que un disco falle, el tiempo necesario para reconstruir sus datos
puede ser significativo. Esto es sencillo en RAID-1 puesto que pueden copiarse los
datos de un disco a otro, resultando popular para aquellas aplicaciones que requieren
alta confiabilidad con capacidad de recuperación rápida.
En sistemas donde el problema de la confiabilidad de datos no es crítico, pero si la

capacidad de acceso a los datos, se utiliza RAID-0. En cambio, cuando el problema de
la capacidad de acceso a los datos no es crítico, pero sí lo es la confiabilidad, se suele
utilizar RAID-1. Los RAID 0+1 y 1+0 se utilizan cuando son importantes tanto la
performance como la confiabilidad, como por ejemplo en las bases de datos.
Los RAID-5 se utilizan para almacenar grandes volúmenes de datos. Los RAID-6
no está soportado actualmente, pero brinda mayor confiabilidad que RAID-5.
Necesitamos un compromiso entre performance y confiabilidad. Si queremos

confiabilidad tenemos que sacrificar espacio de disco, pero si queremos performance
debemos tener disco disponible.
210
12 Sistema de E/S
Las computadoras interaccionan con una amplia gama de tipos de dispositivos,
por esto establecemos una clasificación en cuatro clases:
 Dispositivos de almacenamiento
 Dispositivos de transmisión
 Dispositivos de interfaz humana
 Dispositivos especializados
Un dispositivo se comunica con un sistema de computación enviando señales a

través de un punto de conexión denominado puerto (como un puerto serial). Si uno o
más dispositivos usan un conjunto común de “cables” la conexión se llama bus. Más
formalmente un bus es conjunto de líneas (wires) con reglas (o protocolo rígidamente
definido) que especifica un conjunto de mensajes que se pueden enviar por ellas.
El siguiente esquema se corresponde con una estructura típica de un bus de

PC, muestra un bus PCI (bus común de los PC) que conecta el subsistema
procesador-memoria con los dispositivos de alta velocidad y un bus de expansión que
conecta los dispositivos lentos. En la parte superior derecha, se pueden ver cuatro
discos conectados en un bus SCSI que se inserta en una controladora SCSI.
Un controlador es una colección de circuitos electrónicos que pueden operar

un puerto, un bus o un dispositivo. Hay distintas complejidades de controladores, por
ejemplo:
 Simple: El controlador del puerto serial es un chip que viene usualmente

incluido en la PC.
211
 Complejo: El controlador de bus SCSI que debido a la complejidad del

protocolo, se implementa con una tarjeta de circuito aparte que contiene
memoria propia.
Otros dispositivos traen integrados sus propios controladores. El procesador se

comunica con un controlador para llevar a cabo una transferencia de E/S a través de
uno o más registros para señales de datos y de control. Esta comunicación se puede
realizar con dos técnicas diferentes:
 I/O Port Adress: Utilizar instrucciones de E/S especiales que se encargan

de especificar la transferencia de bytes a través del bus y cómo mover bits
desde y hacia los registros del dispositivo apropiado.
 Memory-Mapped I/O: Los registros de control del dispositivo están
mapeados en el espacio de direcciones del procesador.
Un puerto de E/S está compuesto típicamente por cuatro registros:
 Registro de estado (status): Son leídos por el equipo informando el estado

del dispositivo.
 Registro de control (control): Pueden ser escritos por el equipo para
generar un pedido, cambiar de modo el dispositivo.
 Registro de entrada de datos (data-in): Son leídos por el equipo para
obtener la entrada.
 Registro de salida de datos (data-out): Son escritos por el equipo para
enviar una salida.
12.1 Operaciones de E/S

Una operación de entrada/salida puede ser realizada de varias maneras, sobre
todo cuando se espera que un dispositivo finalice su ejecución. De esta forma
contamos con tres métodos.
I. E/S Programada (Programmed I/O)

También denominada polling (consulta) o busy wating. El equipo espera a que
el dispositivo se desocupe; cuando lo hace, se ponen los datos necesarios en el
dispositivo y cuando el controlador percibe estos datos procesa la E/S.
Ejemplo: Escribir en una impresora
Si bien permite una programación simple, tiene como gran desventaja el

desperdicio de ciclos de CPU, por lo que es conveniente conmutarla a otro proceso y
así no dejarla ociosa esperando por la finalización.
212
II. Interrupciones (Interrupt- Driven I/O)

El hardware del CPU tiene una línea de solicitud de interrupción (IRQ), de
forma que si la CPU detecta que algún controlador ha generado una interrupción, ésta
guarda contexto (puntero a IP) y despacha la rutina de manejador de interrupción
(interrupt handler) que se encuentra en una dirección fija de la memoria. El manejador
determina la causa de la interrupción, realiza el procesamiento necesario y ejecuta una
instrucción de retorno de interrupción (la CPU vuelve al estado previo a la
interrupción). La siguiente figura muestra dicho funcionamiento:
Este mecanismo permite a la CPU responder a un suceso asincrónico. Sin

embargo, los SO modernos necesitan funciones más sofisticadas, que son
proporcionadas por el Controlador de Interrupciones.
La mayoría de las CPU tiene dos líneas de solicitud de interrupción:
 Interrupción no enmascarable (NMI): Reservada, no pueden ser

desactivadas.
 Interrupción enmascarable: Utilizadas por los controladores de
dispositivos, pueden ser desactivadas antes de ejecutar instrucciones
críticas que no deben interrumpirse.
Generalmente a cada interrupción se le asocia un número que representa un

desplazamiento dentro del vector de interrupciones que contiene las direcciones de
memoria de las rutinas de atención.
Usos habituales de las interrupciones:
 Manejo de excepciones: Por ejemplo, división entre cero, acceder a

memoria protegida o inexistente, intentar ejecutar una instrucción
privilegiada en modo usuario, etc.
 Manejo de memoria virtual: Se producen interrupciones por cada fallo de
página.
213
 Llamadas al sistema: Se solicitan servicios del núcleo, verificando los

argumentos proporcionados por la aplicación, construyendo una estructura
de datos para comunicarlos al núcleo, y luego ejecutando una interrupción
de software o trap. El hardware de interrupciones guarda el estado del
código de usuario, conmuta al modo supervisor y despacha a la rutina del
núcleo que implementa el servicio solicitado.
Dicho esto, cuando el proceso que está ejecutando realiza una solicitud de E/S,
se agrega a la cola de espera del dispositivo, y finalmente invoca al Scheduler para
que asigne la CPU a otro proceso. El controlador del dispositivo es el encargado de
avisar la completitud de la solicitud a través de una interrupción, y el manejador de
interrupción es el encargado de desbloquearlo y colocarlo en la cola de procesos
listos.
La gran ventaja es que el procesador queda disponible para otro proceso que
lo requiera, pero dificulta la programación, además se debe contar con soporte de HW
y se deben codificar los manejadores de interrupciones.
214
III. Acceso Directo a Memoria (Direct Access Memory)

Para aliviar la CPU de estar continuamente atendiendo una larga transferencia
de datos se traspasa parte de este trabajo a un procesador de propósito especial
llamado controlador de acceso directo a memoria (DMA).
Para realizar una transferencia DMA, el equipo escribe un bloque de órdenes

de DMA en memoria, el cual contiene un puntero al origen de una transferencia, otro al
final, y un contador del número de bytes a transferir. La CPU le indica al controlador
DMA la dirección de ese bloque, y prosigue con sus labores.
De esta forma, el controlador opera con el bus de memoria directamente,

transfiriendo los bytes indicados sin la ayuda del CPU (operan en paralelo). Este
apoderamiento del bus, impide momentáneamente el acceso a memoria de la CPU
(aunque si puede acceder a los cachés), haciendo más lentas sus operaciones,
aunque generalmente el DMA mejora el desempeño del sistema.
Este proceso que sigue el DMA se ilustra en el siguiente esquema:
215
12.2 Interfaz de E/S de las aplicaciones

Se puede abstraer las diferencias de los dispositivos de E/S para tratarlos de
una forma uniforme y estandarizada: una interfaz.
Las diferencias reales se encapsulan en módulos llamados device drivers que

internamente se adapta a cada dispositivo, pero que exportan una interfaz estándar.
Hay varios tipos de dispositivos de E/S:
 Dispositivos de flujo de caracteres o bloques: Transfiere bytes/bloques

uno por uno.
 Dispositivos de acceso secuencial o aleatorio: El caso de acceso

secuencial se transfiere datos en un orden fijo y determinado (ej. MODEM).
En cambio, en el caso de acceso aleatorio se puede pedir al dispositivo que
se coloque en cualquiera de las posiciones de almacenamiento de datos
disponibles (ej. CD-ROM).
 Dispositivos sincrónico o asincrónico: El sincrónico realiza

transferencias de datos con tiempo de respuestas predecibles, mientras
que en el asincrónico lo hace en tiempos irregulares.
 Dispositivos compartibles o dedicados: Un dispositivo compartible

puede ser utilizado en forma concurrente por varios procesos, no siendo así
para un dispositivo dedicado.
 Dispositivos bloqueantes o no bloqueantes: En los dispositivos

bloqueantes, cuando un proceso requiere de un servicio de E/S se da a
través de una rutina bloqueante, el proceso se suspende hasta que la
operación haya finalizado. Por otro lado, en los dispositivos no bloqueantes
el llamado al servicio de E/S es devuelto tan pronto como sea posible.
 Lectura y Escritura: Puede ser, lectura/escritura, solo lectura o solo

escritura.
El acceso de las aplicaciones a los dispositivos se realiza usualmente a través

de llamadas al sistema, que agrupan a los dispositivos en categorías.
216
La siguiente figura ilustra cómo se estructuran en niveles de software las partes

del kernel relacionadas con E/S.
12.3 Subsistema de E/S del kernel – Servicios del SO sobre E/S

El kernel del SO brinda varios servicios para el manejo de E/S, que están
desarrollados en la infraestructura de hardware y device drivers.
I. I/O Scheduling (Planificación de E/S)

Se utiliza para mejorar el desempeño global del sistema y reducir el tiempo de
espera promedio de E/S. Se compone de una cola de solicitud para cada dispositivo,
la cual es reacomodada por el planificador implementado por el SO de forma de
mejorar el tiempo de respuesta.
Cuando un kernel soporta mecanismos de E/S asíncrona debe ser capaz de

controlar múltiples solicitudes de E/S al mismo tiempo. Con este fin, el SO pude
asociar la cola de espera con una tabla de estado de dispositivo como la que se
muestra a continuación. La tabla tiene una entrada por dispositivo y cada entrada en la
tabla indica el tipo, la dirección y el estado del dispositivo.
217
II. Buffering (Uso de buffers)

Es el proceso de colocar y consumir datos de un buffer. Un buffer no es más
que un área de memoria en el que se almacenan datos mientras se transfieren entre
dos dispositivos o entre un dispositivo y una aplicación. Existen tres razones para usar
buffering:
 Normalizar las velocidades entre diferentes dispositivos [MODEM -
Disco].
 Adaptarse entre dispositivos que difieren en los tamaños de transferencia
[Redes].
 Mantener la semántica de aplicaciones que realizan E/S. En una
operación write el buffer de usuario es copiado a un buffer del SO. De esa
forma, el sistema logra independizarse de la aplicación.
III. Caching (Uso de chaches)

Es el proceso de escribir y leer datos desde una caché. La caché no es más
que una pequeña, rápida y volátil memoria que contiene copias de datos. La diferencia
entre un buffer y un caché es que el buffer contiene los datos originales mientras que
un caché solo tiene una o varias copias. Apunta a mejorar la eficiencia, pero el caching
produce problemas de inconsistencia (Coherencia de Caché). Por ejemplo, si el kernel
recibe una E/S sobre un archivo, primero accede a caché para ver si ya está
disponible en MP, en caso afirmativo evitamos un acceso a disco para resolver el
problema.
IV. Spooling (Uso de SPOOL)

Es el proceso mediante el cual se introducen datos en un SPOOL. Un SPOOL
(Simultaneous Peripherical Operation On-Line) no es más que un buffer que captura
las salidas dirigidas a los dispositivos de forma que éste pueda procesar los datos sin
intercalar cuando estamos frente a un esquema multiprogramado y el recurso no es
compartido. En otras palabras, hablamos del manejo de colas de dispositivos, donde
el buffer almacena la salida dirigida a un dispositivo.
El SO proporciona una interfaz de control que permite exhibir la cola, eliminar

trabajos, suspender la impresión, etc., y además permiten coordinar salidas
concurrentes en dispositivos que no pueden multiplexar útilmente las operaciones de
E/S de varias aplicaciones concurrentes. Es un mecanismo que permite no quedarse
bloqueado esperando un evento de E/S.
V. Error Handling (Manejo de Errores)

Los dispositivos y las transferencias de E/S pueden fallar de forma transitoria o
permanente. Algunas veces los SO pueden compensar los fallos transitorios, pero
pocas veces pueden con los permanentes. Por lo general una llamada al sistema de
E/S devuelve un bit de información acerca del estado de la llamada, para indicar si
218
tuvo éxito o fracaso. Algunos dispositivos permiten obtener información de la

naturaleza del error con más detalle.
VI. I/O Protection (Protección de E/S)

El sistema de E/S se debe proteger contra errores accidentales o intencionales
ocasionados por los usuarios.
Las aplicaciones de usuario no están

autorizadas a realizar E/S en modo de usuario.
Todas las solicitudes de E/S se manejan a
través de system calls que se deben realizar en
modo kernel, son operaciones privilegiadas.
Áreas de memoria mapeada y puertos

E/S deben ser protegidos por el sistema de
gestión de memoria, pero el acceso a esos
ámbitos no pueden ser totalmente negados a
los programas de usuario. En cambio, el
sistema de protección de la memoria limita el
acceso de forma que sólo un proceso a la vez
puede acceder a partes particulares de la
memoria, tales como la porción de la memoria
de la pantalla que corresponde a una ventana
en particular.
219
13 Protección & Seguridad

Los diversos procesos de un SO se deben proteger de las actividades de los
demás procesos. Existen mecanismos que garantizan que solo los procesos
autorizados por el SO puedan operar con los distintos recursos.
De esta forma:
 La protección refiere a un mecanismo para controlar el acceso de

procesos o usuarios al sistema, realizar controles sobre ellos e imponerlos.
– Es un problema estrictamente interno
 La seguridad refiere a garantizar la autenticación de usuarios, con el fin de

proteger la integridad de la información y los recursos, impidiendo accesos
no autorizados, destrucción/manipulación maliciosa de datos, y la
introducción de incoherencias.
– Considera el entorno externo donde opera el sistema
13.1 Protección
13.1.1 Objetivos
Originalmente se concibió para que los usuarios compartieran recursos sin
peligro en sistemas multiprogramados. Actualmente evolucionaron para aumentar la
confiabilidad de sistemas que usan recursos compartidos.
Razones para dar protección:
 Evitar que usuarios malintencionados violen restricciones de acceso.

 Asegurar que cada componente de un programa use los recursos
respetando las políticas de uso de ellos.
La protección puede detectar errores en las interfaces entre subsistemas,

evitando la contaminación de un subsistema sano con otro que no funciona
correctamente. Existen mecanismos para distinguir entre accesos autorizados y no
autorizados. Tipos de políticas de uso de recursos:
 Determinadas por el diseño del sistema

 Formuladas por los administradores del sistema
 Definidas por usuarios para proteger sus propios archivos o programas
Las políticas pueden cambiar en el tiempo o dependiendo de la aplicación, por

lo tanto el sistema debe proveer de herramientas al programador para que pueda
modificarlas o utilizarlas.
Debemos tener clara la diferencia entre mecanismo de protección y policía de

protección. Los mecanismos determinan el cómo se llevará algo a cabo; las políticas
deciden el qué es lo que hay que hacer.
220
13.1.2 Principios de la protección

Uno de los principios clave y que ha resistido a lo largo del tiempo a la hora de
proporcionar protección es el Principio del Mínimo Privilegio. Este principio dicta que
a los agentes involucrados en el sistema informático (procesos, usuarios, SO) se les
concedan únicamente los suficientes privilegios para llevar a cabo sus tareas.
Un SO que se ajusta a este principio implementará sus características,

programas, system calls y estructura de datos de modo que el fallo o el compromiso
de un componente provoquen un daño mínimo y no permitan realizar más que un daño
mínimo.
La gestión de los usuarios con este principio implica crear cuentas separadas
para cada usuario, con sólo los privilegios que ese usuario necesite.
El principio de mínimo privilegio puede ayudar a obtener un entorno informático

más seguro, aunque establecer ese “mínimo” puede resultar dificultoso y
ocasionalmente se puedan dejar huecos importantes que atenten contra la seguridad
del sistema.
13.1.3 Dominios de protección

Un sistema consta de procesos y objetos, tanto de HW (memoria, periféricos,
etc.) como de SW (archivos, semáforos, etc.). Cada objeto tiene un identificador y se
accede a él con operaciones bien definidas que dependen del objeto(29).
Un proceso debe acceder a los recursos para los cuales está autorizado y en
un momento dado solo puede acceder a aquellos que necesite para llevar a cabo su
tarea. A eso ultimo se lo conoce como el Principio Need to Know, y apunta, al igual
que el Principio de Mínimo Privilegio, a minimizar los riegos antes una violación de
seguridad.
13.1.4 Estructuras de dominio de protección

Un proceso opera dentro de un dominio de protección, que especifica los
recursos a los que puede acceder. El dominio define el conjunto de objetos, y el tipo
de operaciones que se pueden invocar sobre ellos.
La capacidad para ejecutar una operación con un objeto se denomina derecho

de acceso, mientras que un dominio es una colección de derechos de acceso sobre
un objeto, dado por la tupla:
29
En la CPU podemos únicamente ejecutar programas. Sobre la Memoria podemos tener operaciones
de lectura/escritura, etc
221
Tenga en cuenta que algunos dominios pueden ser disjuntos, mientras que
otros se superponen.
En el ejemplo, tenemos tres dominios y . El derecho de acceso

es compartido entre y . Un proceso que se ejecute en el dominio
podrá leer y escribir en el objeto , mientras que el mismo objeto en el dominio
solo podrá ser ejecutado.
La asociación entre procesos y dominio puede darse de dos formas:
 Estática: El conjunto de recursos de un proceso no cambia durante su
ejecución y queremos respetar el need to know, por lo tanto necesitamos
un mecanismo para cambiar el contexto de un dominio para reflejar los
derechos de acceso mínimos necesarios.
 Dinámica: Se cuenta con un mecanismo que cambia de un dominio a otro.

También se podría modificar el contenido del dominio, o en su defecto,
crear un nuevo dominio con el contenido deseado, y cambiando a él.
Contamos con tres formas bien diferenciadas de para establecer dominios de

protección:
 Usuario: El conjunto de objetos a los que se puede acceder depende de la

identidad del usuario. Hay conmutación de dominio cuando se cambia de
usuario, por medio de cierre e inicio de sesión.
 Proceso: El conjunto de objetos a los que se puede acceder depende de la

identidad del proceso. La conmutación de dominio corresponde a que un
proceso envía un mensaje a otro proceso y espera su respuesta.
 Procedimiento: El conjunto de objetos a los que se puede acceder

corresponde a variables locales definidas dentro del procedimiento. La
conmutación de dominio ocurre cuando se invoca a otro procedimiento.
13.1.5 Ejemplos donde se determinan dominios de protección

Modo Dual
Es el caso ya estudiado, donde mediante un bit podemos distinguir entre dos
modos de ejecución: Modo Usuario y Modo Kernel. Este método por sí solo no
alcanza.
222
UNIX
Asocia un dominio a cada usuario, y cambiar de dominio implica cambiar
temporalmente la identificación de usuario.
Cada archivo tiene asociados una identificación de propietario (UID – User

Identificator) y un bit de dominio (sticky bit o setuid bit).
De esta forma, cuando un usuario con comienza a ejecutar un

archivo de propiedad del usuario pueden ocurrir dos situaciones:
 Lo hace con el setuid apagado, por lo que el proceso se ejecuta con
 Lo hace con el setuid prendido, por lo que el proceso se ejecuta con

(igual al del propietario del archivo) hasta que el proceso termina.
Esto se usa para poner a disposición a los usuarios los recursos privilegiados.
Por ejemplo, el usuario puede tomar momentáneamente el UID root para usar un
recurso, pero hay que controlar que no pueda crear un archivo con UID root y el bit
setuid encendido, porque podría convertirse en root y corromper el correcto
funcionamiento en el sistema.
Hay sistemas más restrictivos que no permiten cambiar los identificadores de

usuario. Se deben usar mecanismos especiales para acceder a recursos especiales
como “demonios”.
MULTICS
Los dominios de protección se
organizan jerárquicamente en una estructura
de anillos. Cada anillo corresponde a un
dominio. El proceso que se ejecuta en el
dominio D0 es el que más privilegios tiene.
Tiene un espacio de direcciones

segmentado donde cada segmento es un
archivo y está asociado a un anillo. A cada
proceso se le asocia un número de anillo, y
puede acceder a segmentos asociados a
procesos con menos privilegios (mayor número de anillo), pero no a los segmentos
más privilegiados (menor número de anillo).
Se produce una conmutación de contexto (switch) cuando un proceso invoca

un procedimiento de otro anillo, y esa conmutación es controlada por el SO. Para este
control, el anillo cuenta con los campos:
 Intervalo de acceso: (b1, b2) y b1 b2.

 Limite: b3 tal que b3 > b2
 Lista de puertas: Identifica puertas en las que se pueden invocar
segmentos.
223
Un proceso en el anillo i, puede ejecutar segmentos de un intervalo de acceso

(b1, b2) b1 i b2. Si no se cumple se efectúa una trap en el SO y se realizan
nuevos controles:
 Si i < b1 entonces se permite la llamada porque el anillo que busco es

menos privilegiado.
 Si i > b2 entonces solo se permite la llamada si b3 i. La llamada se destina
a una “puerta”, permitiendo que los procesos con derechos de acceso
limitado, puedan invocar procedimientos más privilegiados, pero de manera
controlada.
Desventaja:
 No cumple el principio Need To Know. En particular, si un objeto debe estar

accesible en el domino pero no en el dominio entonces debemos tener
. Pero este requisito implica que todos los segmentos accesibles en
deben estar accesibles en .
13.1.6 Matriz de acceso

Las decisiones de política relativas a la protección se pueden implementar con
una matriz de acceso, donde:
Fila  Representan dominios

Columnas  Representan objetos
Entrada  Representan un conjunto de derechos de acceso.
De esta forma, define el conjunto de operaciones que un proceso
que se ejecute en el dominio puede invocar sobre el objeto
En este caso, todos los procesos que se ejecutan en el dominio , pueden leer
el archivo , y escribir el . Los que se ejecutan en , pueden leer el archivo , e
imprimir.
Notemos también que en este caso cada celda tiene una única operación, pero
pueden ser más.
Conmutación
Si incluimos también a la matriz como un objeto, podemos darle privilegios solo
a algunos dominios para modificarla. De la misma forma, podemos controlar la
conmutación de dominios. Una conmutación del dominio al dominio estará
permitida sii .
224
En este caso, un proceso en el dominio , puede conmutar al dominio .
Copia
Se puede dar la capacidad de copiar derechos añadiendo un (*) al derecho de
acceso. Se puede copiar el derecho de acceso solo dentro de la misma columna (en el
mismo objeto). Por ejemplo, en la figura (a) un proceso que ejecute en podrá copiar
la operación elegida en cualquier entrada asociada con el archivo , pudiendo
obtener la figura (b).
La copia, a parte de su forma estándar, también puede presentarse en dos

variantes:
 Transferencia: El derecho (R*) se copia del acceso al acceso y

se borra el acceso
 Limitación: El derecho (R*) se copia de a creando el derecho

R, y no R*, por lo tanto un proceso en el dominio i, no puede copiarlo.
También el sistema podría elegir qué derecho darle a la copia (copia,

trasferencia o copia limitada) colocando diferentes valores en la matriz. Se necesita un
mecanismo que permita añadir o quitar derechos. Para eso se le asigna el derecho de
dueño a uno de los dominios que utiliza el objeto y solo él puede asignar o quitar
derechos. Se requiere un mecanismo que cambie derechos en las filas, y es el de
control.
Implementación
En un principio la mayor parte de las entradas de la matriz están vacías.
Contamos con cuatro formas para implementar la matriz de acceso que serán
detalladas a continuación.
225
I. Tabla global
Consiste en implementar la matriz de accesos como un conjunto de
tripletas ordenadas:
Al ejecutar una operación sobre un objeto en el dominio , busco

la entrada . Si no existe, se genera una trap.
Este esquema presenta desventajas,
- La tabla es grande, no puede estar en memoria principal.
- Existe información repetida, ya que si todos los dominios usan de la misma
forma un mismo objeto, debo tener una entrada de la tabla para cada
dominio. Para evitar esto, se podrían buscar mecanismos para agruparlos,
pero es difícil o costoso hacerlo.
II. Lista de acceso para objetos

Busca atacar las desventajas de tener una tabla global. Para ello, cada
columna (objeto) es una lista de acceso, que contiene los pares
siendo . En este caso se puede implementar

un conjunto de derechos por omisión, que contiene todo los objetos a los que
puedo acceder desde cualquier dominio.
Al ejecutar una operación sobre un objeto en el dominio , busco

la entrada en la lista de acceso del objeto una entrada .
Si no existe, se busca la operación en el conjunto de derechos por omisión, en
caso de no estar genera una trap.
III. Lista de capacidades para dominios

Es la idea análoga al caso anterior, pero para los dominios. De esta
forma, cada fila (dominio) es una lista de capacidades, que contiene los pares
siendo . Al ejecutar una operación sobre

un objeto en el dominio , busco la entrada en la lista de capacidades del
dominio una entrada . Si no existe, se genera una trap.
El usuario puede acceder a estas listas indirectamente, ya que están

protegidas por el sistema. La protección de las capacidades se hace a nivel del
SO, de forma que:
o Cada objeto tiene una etiqueta para denotar su tipo (puntero,
booleano, valor no inicializado). No son directamente accesibles al
usuario.
o El espacio de direcciones de un programa se puede dividir en dos,
 Una parte accesible con datos e instrucciones normales.
 Otra parte con la lista de capacidades accesibles
226
IV. Cerradura y llave

Es un término medio entre las dos listas (capacidades y acceso). Cada
objeto tiene una lista de patrones de bit llamada cerradura, y cada dominio
tiene otra llamada llave. Para que un proceso que se ejecuta en un dominio
pueda acceder a un objeto, el dominio debe tener la llave adecuada.
Comparación de las implementaciones

Cuando un usuario crea un objeto, establece sus derechos, pero es
difícil determinar el conjunto de derechos para cada dominio. Las listas de
capacidades son útiles para localizar información de un proceso en particular
pero no se corresponden con las necesidades del usuario.
El mecanismo de cerradura y llave, es un término medio. Puede ser

eficaz y flexible, dependiendo de la longitud de las llaves, y los privilegios de
acceso se pueden revocar para un dominio, simplemente cambiando su llave.
La mayor parte de los sistemas usa una combinación entre listas de

acceso y capacidades.
13.1.7 Protección basada en el lenguaje

Es una alternativa a la matriz de acceso. La protección se logra con la ayuda
del núcleo del SO que valida los intentos de acceso recursos. El gasto de inspeccionar
y validar todos los intentos de acceso a todos los recursos es muy grande, por lo tanto
debe ser apoyada por HW.
Al aumentar la complejidad del SO, se deben refinar los mecanismos de

protección. Los sistemas de protección, no solo se preocupan de si puedo acceder a
un recurso, sino también de como lo accedo, por lo tanto los diseñadores de
aplicaciones deben protegerlos, y no solo el SO.
Los diseñadores de aplicaciones mediante herramientas de los lenguajes de

programación pueden declarar la protección junto con la tipificación de los datos.
Ventajas:
 Las necesidades de protección se declaran sencillamente y no llamando

procedimientos del SO.
 Las necesidades de protección pueden expresarse independientemente de
los recursos que ofrece el SO.
 El diseñador no debe proporcionar mecanismos para hacer cumplir la
protección.
 Los privilegios de acceso están íntimamente relacionados con el tipo de
datos que se declara.
227
Las principales diferencias entre las distintas formas de protección que

podemos encontrar se distinguen en:
 Seguridad: La obligación de cumplimiento por núcleo ofrece un grado de

seguridad que el código de seguridad ofrecido por el compilador.
 Flexibilidad: La flexibilidad de la implementación por núcleo es limitada. Si
un lenguaje no ofrece suficiente flexibilidad, se puede extender o sustituir,
perturbando menos cambios en el sistema que si tuviera que modificarse el
núcleo.
 Eficiencia: Se logra mayor eficiencia cuando el HW apoya la protección.
La especificación de protección en un lenguaje de programación permite

describir en alto nivel las políticas de asignación y uso de recursos.
El programador de aplicaciones necesita un mecanismo de control de acceso

seguro y dinámico para distribuir capacidades a los recursos del sistema entre los
procesos de usuario.
Las construcciones que permiten al programador declarar las restricciones

tienen tres operaciones básicas:
 Distribuir capacidades de manera segura y eficiente entre procesos

clientes.
 Especificar el tipo de operaciones que un proceso podría invocar en un
recurso asignado.
 Especificar el orden en que un proceso dado puede invocar las operaciones
de un recurso.
13.1.8 Revocación de derechos de acceso

La revocación de un derecho de acceso se puede realizar de diversas formas
dependiendo de la situación. Pueden distinguirse en:
 Inmediata o diferida
 Selectiva o general
o General: Al revocar un derecho de acceso afecto a todos los
usuarios con ese derecho.
o Selectiva: Puedo seleccionar usuarios para revocarlo.
 Parcial o total
o Total: Revoco todos los derechos de acceso a un objeto.
o Parcial: Revoco un subconjunto.
 Temporal o permanente
o Temporal: Se puede revocar el derecho y luego obtenerlo
nuevamente.
o Permanente: Si lo revoco, no puedo volverlo a obtener.
Con un sistema de lista de acceso la revocación es fácil, inmediata y puede ser
general, selectiva, etc. Con listas de capacidades debo hallarlas en todo el sistema
antes de revocarlas.
228
Esquemas de revocación:
 Readquisición: Periódicamente se eliminan capacidades de cada dominio.

El proceso tiene que tratar de readquirirla para usarla, y si fue revocada, no
la puede adquirir.
 Retropunteros: Cada objeto tiene punteros asociados a sus capacidades.

Se puede seguir esos punteros para revocar o modificar capacidades. Su
implementación es costosa.
 Indirección: Las capacidades no apuntan directamente al objeto sino a una

entrada única de una tabla global. Para revocar, busco la entrada en la
tabla global y la elimino. No permite revocación selectiva.
 Claves: La clave se define al crear la capacidad y el proceso que posee

dicha capacidad no puede modificarla. Debo cambiar la clave maestra de
cada objeto con un “set_key” para revocar los derechos. No permite
revocación selectiva.
229
13.2 Seguridad
Un sistema es seguro si los recursos se usan y acceden como se espera en
todas las circunstancias.
Esto no siempre es posible, por eso se debe contar con mecanismos que
garanticen que las violaciones de seguridad sean poco comunes. Para ello se
establecen tres requisitos para garantizar la seguridad de un sistema:
 Confidencialidad
 Integridad
 Disponibilidad de la información
Las violaciones de seguridad las podemos clasificar en dos tipos:
I. Accidentales, generalmente son fáciles de tratar
II. Intencionales, que pueden darse por:
o Ruptura de confidencialidad: Lectura no autorizada de datos (robo

de información).
o Ruptura de integridad: Modificación no autorizada de datos.
o Ruptura de disponibilidad: Destrucción no autorizada de datos.
o Ruptura de servicio: Uso no autorizado de recursos
o Denegación de servicio: Impedir el uso legítimo del sistema
Las medidas de seguridad que garanticen el correcto funcionamiento del

sistema se pueden tomar básicamente en cuatro niveles:
1. A nivel Físico: el lugar donde se encuentra el sistema debe estar protegido

físicamente
2. A nivel Humano: autorización cuidadosa a los usuarios. Incluso usuarios

autorizados pueden ser motivados a que otros utilicen su acceso, o bien
pueden ser engañados.
3. A nivel del SO: debe autoprotegerse, entre los problemas a abarcar se

encuentran las contraseñas y prevenir que se inicien procesos no autorizados.
4. A nivel de Red: son muchos los datos que viajan a través de la red, que
deben ser interceptados.
Cualquier debilidad en uno de los niveles altos de seguridad, permitirá puntear

las medidas de seguridad que son estrictamente de nivel más bajo.
Dado que el principal objetivo de los intrusos es obtener el acceso a un

sistema o aumentar el conjunto de privilegios, a continuación presentaremos una serie
de términos que se emplean al hablar de seguridad.
 Hacker: talentos informáticos que entran al sistema por el placer de

recopilar información que utilizan si la necesitan
 Cracker: acceden, y presumen de ello, a los sistemas para los que no

tienen autorización. Suelen cometer daños irreversibles o irreparables en el
sistema.
230
En la actualidad hay un sinfín de términos referidos a estos temas, los más “de
moda” son:
 Script Kiddies: Individuos que sin tener grandes conocimientos, pero con
una potente y estable herramienta de ataque desarrollada por los gurús, es
capaz de dejar fuera de servicio cualquier servidor de información,
simplemente siguiendo instrucciones que le proporciona la herramienta (por
ejemplo, internet).
 Ransomware: Término que hace referencia a una licencia de distribución

de software, donde su autor "secuestra" archivos y piden "rescate" en
dinero por ellos.
Una amenaza es la posibilidad de que exista una violación de seguridad,

mientras que un ataque es un intento de romper la seguridad.
Los atacantes utilizan diversos métodos estándar en sus intentos de romper la

seguridad del sistema. Una comunicación normal se lleva a cabo entre un emisor y un
receptor, y generalmente tenemos a los atacantes en el medio intentando interceptar
los mensajes. De esta manera:
Entre los mecanismos que un atacante puede imponerse en la vía de

comunicación entre estas dos personas encontramos:
 Mascarada: un participante en una comunicación pretende ser otra,

rompiendo así la autenticación con el objetivo de tener privilegios que
normalmente no podría disfrutar.
 Ataque por interposición (Man-In-The-Middle): un atacante se introduce

dentro del flujo de datos de una comunicación, haciéndose pasar por el
emisor a los ojos del receptor, y viceversa. Esta a su vez puede estar
precedida por un secuestro de contraseña (hijacking).
231
13.2.1 Amenazas relacionadas con programas

La clasificación general de las amenazas por software podemos verlo
resumidamente en el siguiente esquema:
Detallando cada una de ellas:
 Puerta Trasera (Trap Door): Punto de entrada secreto e indocumentado

dentro de un programa que permite evitar los procedimientos de seguridad.
Utilizado para conceder accesos sin necesidad de identificación(30).
 Bomba Lógica: Lógica introducida en un programa que, cuando se dan

ciertas condiciones en el sistema, ejecuta alguna función no autorizada.
 Caballo de Troya: Rutina secreta e indocumentada que se inserta dentro

de un programa útil (ej. editor). La ejecución del programa da origen a la
ejecución de la rutina. Otra variante de esta amenaza es el spyware, cuyo
objetivo es descargar anuncios, crear ventanas emergentes o capturar
información del sistema
 Virus: Código incrustado en un programa legítimo que hace que se inserte

una copia de sí mismo en uno o más programas también legítimos,
infectando el sistema. Además, puede realizar una función no deseada.
 Bacteria: Programa que consume recursos del sistema mediante su

reproducción.
 Gusano: Programa que puede reproducirse y enviar copias de sí mismo a

través de la red. Además, puede realizar alguna función no deseada
.
13.2.2 Técnicas para mejorar la seguridad ante amenazas

Contamos básicamente con dos esquemas para mejorar la seguridad en
nuestro sistema.
30
Se ilustra en la película Juegos de Guerra.
232
I. Monitorización
Comprobar si se intenta violar la seguridad del sistema mediante la búsqueda
de patrones de actividad sospechosos. Las técnicas más comunes son:
 Cuenta de las veces que se proporcionan contraseñas incorrectas en el

login.
 Llevar una bitácora de auditoría que registra la hora, el usuario, los tipos
de accesos a objetos y si tuvo éxito o no (archivo log). Una vez que la
seguridad se ha violado, esta información sirve para:
o Determinar cómo y cuándo ocurrió el problema y el daño producido.

o Recuperarse del ataque.
o Desarrollar una seguridad mejor.
Estas bitácoras tienen el inconveniente de que pueden crecer mucho,

ocupando demasiados recursos en el sistema.
 Explorar el sistema periódicamente en busca de “agujeros” de seguridad,

que se pueden realizar en el computador cuando hay poco tráfico, no como
en el caso de las bitácoras. Puede examinar:
o Contraseñas fáciles de adivinar.

o Programas setuid no autorizados (si el sistema maneja el
mecanismo).
o Programas no autorizados en directorios del sistema.
o Procesos cuya ejecución tiene una duración inusual.
o Protecciones inapropiadas de directorios de usuario y sistema.
o Protecciones inapropiadas de archivos de datos, contraseñas,
drivers, o el núcleo del sistema.
o Caballos de Troya.
Los computadores en red son susceptibles a ataques remotos. Una ayuda de

protección en red son los firewalls. Un firewall es un computador que se coloca entre
lo confiable y lo no confiable, limita el acceso por red, y lleva una bitácora.
233
II. Criptografía
Por la red se transmite gran cantidad de información que no se desea que sea
descubierta. Para lograr esto, se sigue el siguiente mecanismo:
 La información se cifra (codifica) de su forma comprensible original (texto

limpio) a una forma interna (texto cifrado). La forma interna se puede leer
pero no es comprensible.
 El texto cifrado se puede almacenar en archivos legibles y enviarse por
canales desprotegidos.
 Para entender el texto, el receptor debe descifrarlo (decodificarlo) para
obtener el texto limpio.
El reto es crear esquemas de cifrado imposibles de romper. Hay varios
métodos, pero uno de ellos consiste en tener un algoritmo de cifrado general , un
algoritmo de descifrado general , y una o más claves secretas. Las funciones y
son los algoritmos para la clave . Para el mensaje pueda ser entregado en
forma correcta se deben cumplir las siguientes tres condiciones:
1.
2. y se calculan de forma eficiente.
3. Se debe mantener en secreto la clave y no los algoritmos
En cuanto a los algoritmos de cifrado, contamos con dos tipos bien
diferenciados:
 Simétrico: Las claves de cifrado y descifrado son las mismas. Tiene el

problema de distribución de claves, ya que hay que enviar secretamente las
claves. Un ejemplo de ello es el DES (Data Encryption Standar).
 Asimétrico: Las claves de cifrado y descifrado son distintas. Aquí vamos a

describir el algoritmo RSA (Rivest, Shamir y Adleman, sus creadores),
donde cada usuario tiene dos claves, una pública y una privada. Para
comunicarse solo basta con saber la pública del usuario al que se desea
enviar un mensaje.
La siguiente figura muestra un ejemplo de dos usuarios que se quieren

comunicar de manera segura por medio de un canal inseguro, donde posiblemente
exista un atacante.
234
Algoritmo RSA:
Clave Pública :
Clave Privada :
El mensaje se representa con un entero y se divide en submensajes de largo
Función de Encriptado :
Función de Desencriptado:
Donde:
se calcula como el producto de dos primos grandes y al azar
( )
es al azar, y satisface
se calcula de forma tal que
Ejemplo: (imagen al final)
 Como dato tenemos p = 7 y q = 13.

 Calculamos n = 7*13 = 91.
 Calculamos (p-1)*(q-1) = 6*12 = 72.
 Elegimos Ke tal que sea coprimo con 72 y <72, por ejemplo 5.
 Ahora calculamos Kd tal que
(Kd*5) mod 72 = 1, o sea, 29.
 Obtenemos:
clave pública (Ke,n) = (5,91)
clave privada (Kd,n) = (29,91)
 Enviamos el mensaje m = 69
 Encriptamos
5
E(69) = 69 mod 91 = 62 = C
 Desencriptamos
29
D(62) = 62 mod 91 = 69 = m
235
13.2.3 Autenticación de usuario

En relación a la exposición anterior, si un sistema no puede autenticar a un
usuario, entonces autenticar un mensaje procedente de dicho usuario no sirve de
nada. Por tanto, un problema de seguridad importante de los SO es la de autenticación
de usuario.
Normalmente, cada usuario se identifica a sí mismo por medio de una

contraseña. Esta autenticación se basa en una o más de las siguientes tres
cuestiones:
 Posesión de algo – clave o tarjeta

 Conocimiento de algo – identificador y contraseña
 Atributo del usuario – huella digital, patrón retinal o firma
El problema radica en la dificultad de mantener la contraseña en secreto para

evitar otorgar acceso a usuarios no autorizados. De esta forma, a grandes rasgos las
contraseñas pueden ser de dos tipos:
- Generadas por el usuario, siendo fáciles de adivinar.

- Generadas por el sistema, pudiendo ser difícil de recordar y obligando al
usuario a anotarla, provocando un potencial riesgo.
Algunos sistemas envejecen las contraseñas, obligando al usuario a cambiarlas

cada determinado tiempo. Se controla que el usuario no vuelva a usar una contraseña
que ya usó antes, guardando un historial de contraseñas.
Para averiguar una contraseña se puede utilizar la fuerza bruta, probando

todas las combinaciones posibles de letras, números y signos de puntuación. También
podría darse el caso de que el intruso estuviera observando al usuario cuando la digita
o esté “husmeando” en la red, o sea, viendo los datos que el usuario transfiere a la
red, incluidos identificadores y contraseñas.
A continuación se detallan los mecanismos de autenticación de usuario más

comunes.
Contraseñas personales
Cuando el usuario se identifica con su identificador, se le pide una contraseña,
y si ésta coincide con la almacenada en el sistema, se supone que el usuario está
autorizado. Se usan cuando no se cuenta con sistemas de protección más completos.
Contraseñas cifradas
Es utilizado para no tener que mantener en secreto su lista de contraseñas.
Cada usuario tiene una contraseña y el sistema contiene una función,
extremadamente difícil de invertir, pero fácil de calcular, que codifica las contraseñas y
las almacena codificadas. Cuando el usuario presenta la contraseña, se codifica y
compara con las ya codificadas. De esta forma no es necesario mantener en secreto el
archivo con contraseñas.
236
Contraseñas de un solo uso

Se pueden usar contraseñas algorítmicas, donde el sistema y el usuario
comparten un secreto. El sistema proporciona una semilla, el usuario con el algoritmo
y la semilla introduce la contraseña, y el sistema la comprueba (ya que conoce el
algoritmo del usuario). La contraseña es de un solo uso, se puede utilizar una única
vez, por lo tanto, cualquiera que la capte, no podría utilizarla luego.
13.2.4 DAC vs MAC

Las políticas de acceso más comunes en el área de la informática son:
 Discretionary Access Control (DAC), es una forma de acceso a recursos

basada en los propietarios y grupos a los que pertenece un objeto. Se dice
que es discrecional en el sentido de que un sujeto puede transmitir sus
permisos a otro sujeto. La mayoría de sistemas Linux ahora mismo usan
este tipo de acceso, estando los permisos orquestados por grupos y
usuarios, pudiendo un usuario normal cambiar los permisos de los archivos
que posee con el comando chmod.
 Mandatory Access Control (MAC), que se basa en políticas. Existen un

conjunto de reglas de autorización (políticas) las cuales determinan si una
operación sobre un objeto realizada por un sujeto esta o no permitida
basándose en los atributos de ambos. En este caso, el Mandatory refleja el
hecho de que las políticas están centralizadas y no pueden ser sobrescritas
por un sujeto.
La diferencia, una vez descritas las dos políticas, salta a la vista. En DAC el
acceso esta descentralizado, siendo el propietario de cada objeto el encargado de
asignar los permisos de los diversos sujetos (grupos en el caso de Unix) que
accederán a ellas. En cambio con el MAC los objetos y los sujetos tan solo tienen
atributos, pero son las políticas las que se encargan de autorizar o denegar una
acción.
13.2.5 Clasificación de seguridad de los computadores

El total de sistemas de computación que obligan al cumplimiento
correcto de políticas de seguridad son llamados Base de Computador
Confiable (TCB- Trusted Computing Base).
El Ministerio de Defensa de EEUU publicó un artículo (conocido

como El Libro Naranja) que mide la fiabilidad y certifica que un sistema es
seguro respecto a un conjunto de criterios de seguridad
La seguridad de un sistema, en este documento, se clasifica en

niveles que detallaremos a continuación.
237
I. Nivel D – Seguridad mínima

Son sistemas evaluados que no satisfacen los requisitos de seguridad de las
otras clases. Ej: MS-DOS y Windows 3.1
II. Nivel C – Seguridad Discrecional

Se contabilizan los usuarios y sus acciones mediante auditorias. Tiene dos
niveles.
Nivel C1 – Protección por Seguridad Discrecional

Permite que los usuarios puedan proteger información privada y evitar
que otros la lean o destruyan. Abarca la mayor parte de las versiones de UNIX.
La TCB de C1 controla el acceso entre usuarios y archivos permitiendo
compartir objetos entre individuos nombrados, o grupos definidos. El usuario
debe identificarse antes de iniciar cualquier actividad que la TCB deba mediar.
Aplica un modelo DAC (Discretionary Access Control).
En este nivel, el usuario tiene un completo control sobre los objetos que
le pertenecen y los programas que ejecuta. Así mismo, el programa ejecutado
por un usuario tendrá (generalmente) los mismos permisos de ese usuario que
lo está ejecutando. Esto implica que la seguridad del sistema depende de las
aplicaciones que se están ejecutando y, por tanto, cuando se produce una
vulnerabilidad de seguridad en una aplicación, esta afecta a todos los objetos a
los que el usuario tiene acceso. Así, si la aplicación es ejecutada por root, el
atacante puede obtener los máximos privilegios en la maquina,
comprometiendo la seguridad global del sistema.
Nivel C2 – Protección por Acceso Controlado

Une a los requisitos de C1, un control de acceso a nivel individual, y el
administrador del sistema puede auditar de forma selecta las acciones de
cualquier usuario conociendo su identidad. Hay algunas versiones de UNIX que
certifican el nivel C2.
III. Nivel B – Seguridad Obligatoria

Tienen todas las propiedades del Nivel C2, y además asocia etiquetas de
confidencialidad a cada objeto y usuario. Tiene tres niveles.
Nivel B1 – Protección por Seguridad Etiquetada

Mantiene la etiqueta de seguridad en cada objeto del sistema la cual es
usada para tomar decisiones relacionadas con el control de acceso obligatorio.
Maneja niveles de seguridad jerárquicos, de manera que usuarios pueden
acceder a cualquier objeto con etiqueta de confidencialidad igual o menor.
Existe una política de seguridad definida por el administrador y que los usuarios
no pueden modificar. Aplica modelo MAC (Mandatory Access Control).
Un ejemplo de esto es el modelo de Bell-Lapadula, pensado para

restringir permisos en un esquema militar. En este modelo, se le asocia a los
238
objetos y a los usuarios dos etiquetas: <Sensibilidad, Categoría>. Sensibilidad

podría ser: , , y .
Categoría es por ejemplo: OTAN, misiles, Afganistán, etc. Un sujeto para poder
acceder a un objeto debe tener una sensibilidad igual o mayor con la que está
clasificado el objeto y tener su misma categoría (esta es la política). Por
ejemplo si el sujeto tiene la clasificación no puede
acceder a los objetos clasificados como ,
pero si puede hacerlo a . Un sujeto no puede cambiar
la etiqueta de un objeto salvo elevar su sensibilidad.
Nivel B2 – Protección Estructurada

Extiende etiquetas de confidencialidad a los recursos del sistema. Se
asignan a los dispositivos físicos, para seleccionar los usuarios que pueden
usarlos.
Nivel B3 – Dominios de Seguridad

Permite crear listas de control de acceso que denotan usuarios a los
que no se concede acceso a un objeto nombrado dado. La TCB contiene un
mecanismo que detecta violaciones de seguridad, avisando al administrador y
finalizando los sucesos.
IV. Nivel A – Seguridad Alta

Funciona arquitectónicamente igual que el Nivel B3, pero contiene técnicas de
verificación con más alto grado que las especificadas por TCB.
“El único sistema auténticamente seguro es el que está desconectado, desenchufado,

y empaquetado en un recipiente hermético de titanio, guardado en un bunker de
hormigón, rodeado de gas nervioso y custodiado por guardias muy bien armados y
magníficamente pagados. E incluso así, yo no me jugaría la vida por él”
Gene Spafford – Experto en seguridad
239
14 Virtualización
Mientras que en un sistema sin virtualización tenemos un
esquema en capas como el presentado a la izquierda, la técnica de
virtualización consiste básicamente en poder compartir un único
hardware entre varias Máquinas Virtuales (VM) funcionando en forma
totalmente independiente entre sí, cada una con su propio SO.
Al SO que se ejecuta en una VM se le denomina guest

(invitado), mientras que aquel SO que corre en la máquina física se lo
denomina host (anfitrión)(31).
Un hypervisor, también llamado virtual machine monitor (VMM), es un

software de virtualización que ejecuta en modo kernel y permite utilizar múltiples SO
en un equipo físico a la vez. Éste es el encargado de crear una capa de abstracción
entre el hardware del host y el SO guest
La condición de virtualización de Popek&Goldberg es suficiente para que una

arquitectura de computadores soporte eficientemente la virtualización. Para formular
esta condición, Popek&Goldberg clasifican las instrucciones en dos tipos:
 Privilegiadas: Aquellas que generan una trap si se ejecutan en modo

usuario, pero no lo hacen si se encuentra en modo kernel.
 Sensibles: Aquellas que deberían generar una trap si se encuentran en

modo usuario. Serían todas las instrucciones que cambian el estado
privilegiado o lo exponen. Estas a su vez pueden ser de dos tipos.
o Sensibles de control: Aquellas que intentan cambiar la configuración

de los recursos en el sistema (ej. Operaciones E/S, Interrupciones).
o Sensibles de comportamiento: Aquellas cuyo comportamiento o

resultado dependen de la configuración de los recursos (ej.
Configuración de la MMU).
De esta forma, Popek&Goldberg establece que para que un sistema pueda

soportar virtualización las instrucciones sensibles deben ser un subconjunto de
las instrucciones privilegiadas. Eso garantiza que todas las instrucciones que
pueden afectar el correcto funcionamiento del VMM (las instrucciones sensibles)
siempre generen un trap y pasen el control al VMM.
Una interrogante que sale a la vista es: ¿existen instrucciones sensibles que no
sean privilegiadas? La respuesta es sí. Un ejemplo de ello es la instrucción POPF de
Intel x86. Supongamos que se carga el registro de flags de la CPU desde el stack
- Si la CPU está en modo kernel  todas las flags son reemplazadas

- Si la CPU está en modo usuario  algunas flags son reemplazadas, las
que no deberían “tocarse” las ignora, sin generar una trap
31
Que puede no estar, y en su lugar solo está el hypervisor
240
Virtualización de CPU
La mayoría de los VMMs implementan una CPU virtual (VCPU) para
representar el estado de la CPU del invitado simulando ser el anfitrión. Cuando se
conmuta el contexto de la CPU del invitado al del anfitrión por parte del VMM,
información de VCPU es cargada y almacenada.
Esta dualidad de CPU implica que el invitado deba ejecutar en modo usuario.
Dado que no es seguro que el Kernel del invitado también corra en modo kernel, la VM
debe diferenciar entre dos modos: Modo Usuario Virtual y Modo Kernel Virtual, ambos
corriendo sobre modo usuario físico.
I. Hypervisor tipo I - Unhosted

Software que se ejecuta en modo kernel sobre el HW real directamente,
alojando en él uno o varios SO guest. Cada VM se ejecuta como un proceso de
usuario en modo usuario, teniendo un modo kernel virtual y un modo usuario virtual. La
situación es la siguiente:
Utilizan la técnica de Trap-

And-Emulate, donde:
 Instrucciones normales se ejecutan

directamente en la CPU.
 Instrucciones sensibles generan

una trap que son analizadas y
procesadas por el VMM.
 El VMM se encarga de emular el

efecto de las instrucciones sensibles
para el SO Guest.
241
II. Hypervisor tipo II - Hosted

Software que se ejecuta en modo usuario sobre un SO host, alojando en él uno
o varios SO guest. De esta forma la virtualización se produce en una capa más alejada
del HW si lo comparamos con los hypervisors tipo I. Permite la virtualización en
arquitecturas que no cumplen con las hipótesis de Popek&Goldberg. La situación es la
siguiente:
Dado que no puede hacer un

Trap-And-Emulate porque el
hypervisor se encuentra corriendo en
modo usuario, utilizan la técnica de
Binary Translation, donde:
 El hypervisor analiza el flujo de
ejecución (bloques de código) y
traduce las instrucciones sensibles por
llamadas al hypervisor.
 Los bloques traducidos son

ejecutados por la CPU directamente y
alojados en caché evitando producir
un cambio de contexto ante la
ejecución de una instrucción sensible.
242
III. Paravirtualización
Los hypervisores tipo I y II funcionan con el SO-Guest sin modificar. Esta
técnica se obtiene si permitimos que el SO Guest se modifique para evitar las
instrucciones sensible, llamando (en cambio) al hypervisor para que el SO Guest sea
consciente que está siendo virtualizado y así optimizar el rendimiento.
A su vez, si el hipervisor solo soporta SO invitados paravirtualizados estamos

ante un microkernel.
IV. Emulación de plataforma

Permite crear MV con un HW distinto del nativo. Es lento ya que debe traducir
todas las instrucciones del hardware destino al nativo, emular periféricos, etc. Un
ejemplo de este tipo de virtualización de CPU es el MAME (Multiple Arcade Machine
Emulator)
Virtualización de aplicaciones
El objetivo de esta virtualización es conseguir que las aplicaciones puedan
funcionar con independencia de las características concretas del entorno en que se
ejecutan. De este modo se eliminan los problemas de compatibilidad entre
aplicaciones, o entre componentes de aplicaciones, y otros errores típicos de la
ejecución concurrente de aplicaciones.
243
Virtualización de la memoria
Se da a través del manejo de Memoria Virtual, por medio de tablas de páginas
multinivel a nivel de la VM, debiendo mapearse dichas tablas a HW real. El obstáculo
que presenta es que el VMM (hypervisor) debe mantener una tabla de páginas
oculta (shadow) porque no puede darle los mismos marcos a dos VMs.
La creación de la tabla de páginas es una acción sensible pues modifica la

MMU, pero la posterior actualización de la tabla no es sensible. Como posible solución
podemos marcar las páginas de tabla como de sólo lectura, de forma que genere una
trap al ser escritas y así dar aviso al hypervisor para que pueda actualizarla.
En caso de un SO paravirtualizado, se cambian las instrucciones de manejo de

MMU por llamadas al hypervisor. Las actualizaciones sobre la tabla de páginas se
puede hacer en modo batch, llamando al hypervisor luego que el SO-Guest ha
realizado todos los cambios.
Virtualización de E/S
Dado que cada VM piensa tener todo el HW disponible, las operaciones de E/S
deben ser sensibles (por lo que son tratadas por el hypervisor).
Para algunos recursos es preferible virtualizar el dispositivo, por ejemplo,

colocando los discos virtuales como archivos en el FS del SO Host. Esto permite
utilizar nuevo HW sobre un SO que no sabe manejarlo.
Otro método consiste en utilizar una MV para que refleje las E/S de todas las
demás MVs. Usualmente a esta MV se la denomina “dominio 0”.
Ventajas de la virtualización
 Compatibilidad: Una VM permite ejecutar aplicaciones destinadas a un SO
particular, aunque no sea real.
 Aislamiento: Las VM se encuentran aisladas una de otras, como si se

trataran de equipos físicamente separados.
 Encapsulamiento: Las VM permiten administrar un conjunto completo de

recursos virtuales y un SO con todas sus aplicaciones.
 Independencia del hardware: Las VM son totalmente independientes del

hardware que las contiene.
244
Bibliografía
[1] Silberschatz, Galvin, Gagne – Operative System Concepts, 8th Edition
(Addison-Wesley, 2005) – ISBN: 9780470128725
[2] Ben-Ari -- Principles of Concurrent and Distributed Programming, 2nd Edition

(Addison-Wesley, 2006) -- ISBN: 0201357526
[3] InCo – Diapositivas y apuntes de Sistemas Operativos (Facultad de

Ingeniería – UdelaR, 2014) – http://www.fing.edu.uy/sistoper
[4] G. Andrews -- Foundations of Multithreaded Parallell and Distributed

Programmin (Pearson, 2000) -- ISBN: 0201357526
[5] W. Stallings – Operative Systems, 2nd Edition (Prentice Hall, 2000) – ISBN:
0201180383
[6] Andrew S. Tanenbaum -- Modern Operating Systems, 2nd Edition (Prentice

Hall, 2001) – ISBN: 0130313580
245
Práctico - Letra & Resolución – En clase

Práctico 2 – Ejercicio 10
Utilizando llamadas al sistema, implementar un programa que lea un archivo,
cuyo nombre recibe como parámetro, y lo imprima en el dispositivo impresora. Dicho
dispositivo cuenta con un buffer de 512 bytes. Cuando la impresora tiene el buffer
vacío, se lo indica al sistema operativo, el cual genera el evento impresora_libre.
El sistema operativo ofrece las siguientes llamadas:
Fin
Indica final exitoso de la ejecución.
Abort
Indica final anormal de la ejecución.
Abrir_archivo(nombre_archivo): Entero
Cerrar_archivo(nombre_archivo): Entero
Abren y cierran un archivo dado su nombre. Devuelven –1 en caso de error.
Leer(nombre_archivo, buffer, n): Entero

Lee n caracteres de un archivo identificado por su nombre, almacenándolos en
el array buffer, y devuelve la cantidad de bytes leídos, o –1 en caso de error.
En caso de que se haya alcanzado el fin del archivo, devuelve 0.
Obtener_recurso(nombre_recurso)
Liberar_recurso(nombre_recurso)
Obtienen y liberan un recurso (que puede ser un dispositivo, memoria, etc.)
dado su nombre. Se bloquean hasta que el recurso sea obtenido o liberado.
Escribir_dispositivo(nombre_dispositivo, buffer, n): Entero

Escribe n bytes del buffer el dispositivo indicado por el nombre, y devuelve la
cantidad de bytes que pudo escribir, o –1 en caso de error.
Esperar_evento(nombre_evento)
Bloquea al proceso hasta que suceda el evento esperado. Retornan el control
inmediatamente si el evento ya ocurre en el momento de invocarlo.
Nota: El sistema es multiprogramado.
246
Resolución: (por Gustavo Brown)
247
Se pide implementar un planificador/despachador de procesos para un sistema
monoprocesador multitarea que cumpla con las siguientes características:
Utilice una planificación basada en colas multinivel y sin retroalimentación.
Los procesos tienen asociada una prioridad discreta, del 0 al 10, siendo la
prioridad 0 la mayor del sistema.
Nunca debe detenerse o retrasarse la ejecución de un proceso con prioridad

Q, si solo existen en el sistema procesos con prioridad P, donde PQ.
El quantum es fijo para todas las colas (quantum = q).
Resolución: (por Mauro Canabe)
Distinguimos tres casos:
1-Rojo. El propio proceso libera la

CPU, teniendo que seleccionarse un
proceso nuevo proceso para ejecutar.
2-Verde. El proceso involuntariamente
deja la CPU teniendo que
seleccionarse un nuevo proceso para
ejecutar
3-Azul. Existe un nuevo proceso en
alguna cola y se debe invocar al
planificador si alguna cola de mayor
prioridad no es vacía
Manejaremos la siguiente estructura:
Una posible invocación al Scheduler, en el caso de la transición ET, sería:
248
Análogamente se pueden ver el resto de los casos. Siempre debemos optimizar todas
las operaciones al máximo. Nos ayudaremos de la variable global al sistema current
que indica qué proceso está siendo ejecutado en la CPU. De esta forma resulta:
249
Cinco programas, A, B, C, D y E, son lanzados a ejecutar en forma simultánea.
Los tiempos de ejecución en un ambiente de monoprogramación se estiman en 10, 6,
2, 4 y 8 minutos respectivamente. Las prioridades son 3, 5, 2, 1 y 4 respectivamente,
siendo 5 la mayor prioridad.
Se desea estimar los tiempos de permanencia en el sistema para cada

programa, ignorando el tiempo de intercambio del procesador entre tareas, para los
siguientes estrategias de despacho:
(a) Round robin
(b) Priority scheduling
(c) First come, first served
(d) Shortest job first
Se asumirá para el primer caso que el ambiente es de multiprogramación con

una distribución equitativa del CPU. Para el segundo y tercer caso se supondrá que
solo ejecutan de a uno por vez, en secuencia. En el tercer caso, asumir en orden de
llegada. Por último todos los programas se supondrán acotados por el CPU o sea que
no realizan entradas y salidas.
Los datos del problema resumidos en la siguiente tabla:
Programa Duración Prioridad

(min)
A 10 3
B 6 5
C 2 2
D 4 1
E 8 4
(a) Para que el usuario piense que tiene la CPU a su entera disposición, el
quantum a elegir debe ser el adecuado. Si elegimos 1min claramente cada
usuario no logra esta meta. En cambio, un rango entre 10ms y 50ms sería
considerable.
Utilizando un quantum de 10ms, tendríamos el siguiente esquema:
250
De esta forma, dado que el primer proceso que termina de ejecutar es C,

tendríamos que:
Razonando análogamente el resto de los procesos, pensando en el quantum,

tendríamos que finalizarían su ejecución D, B, E y A, en ese orden. Por tanto:
(b) Razonando análogamente al caso anterior, siguiendo las pautas
(c) Razonando análogamente al caso anterior, siguiendo las pautas
(d) Razonando análogamente al caso anterior, siguiendo las pautas
251
Sea un sistema monoprocesador que tiene dos procesos que van a comenzar
a ejecutar desde el instante t = 0.
Estos procesos se comportan de la siguiente manera:
 Ejecutan un bucle durante 50ms.

 Se bloquean durante 100 ms (Por ejemplo, con operaciones de E/S).
 Ejecutan un bucle durante 150ms.
Se pide:
a) Dibujar un esquema o diagrama de planificación (tiempo versus procesos),

en el que se indique el estado de cada proceso (listo/ejecutando/bloqueado) en
cada intervalo de tiempo.
b) Calcule el tiempo de espera de los procesos (waiting time).
Nota: El tiempo necesario para realizar un cambio de contexto es 0. Asuma

FCFS y RR con quantum de 100ms
a) FCFS:
RR :
Donde
L : Listo, E : Ejecutando, B : Bloqueado, F : Finalizado
b) FCFS:
RR :
252
Se desea contar el número de veces que es ejecutado un determinado proceso
y para esto se definen dos contadores globales:
var unidades, decenas : integer := 0
que son usados de la siguiente forma:
PROCEDURE Actividad IS
BEGIN
FOR i IN 1..12 LOOP
actividad_propia_del_proceso;
unidades := unidades + 1;
IF (unidades = 10) THEN
unidades := 0;
decenas := decenas + 1;
END IF ;
END LOOP ;
END PROCEDURE ;
Se ejecutan concurrentemente dos copias de actividad:

 Analizar la conducta del algoritmo e indicar algunos los resultados posibles
de los contadores.
 Indicar cómo podría obtenerse siempre el resultado correcto.
Resolución: (por Jorge Merlino)
En primer lugar numeramos las instrucciones relevantes para el problema de la

siguiente manera:
(1) unidades := unidades + 1;

(2) IF (unidades = 10) THEN
(3) unidades := 0;
(4) decenas := decenas + 1;
END IF;
Asumimos que las instrucciones se ejecutan en forma atómica. De esta forma,

a continuación veremos por el Método del Entrelazado ciertas ejecuciones que dan
resultados inconsistentes. Para ello consideraremos “Decenas | Unidades” como el
orden de las variable.
253
Caso 1: En este casó olvido de contar una ejecución.
Caso 2: En este caso la variable unidades queda en 11 y provoca que nunca

más se entre en el IF.
Caso 3: Este es el más extraño porque es el que precisa más cambios de

contexto. En este caso, se cuenta de más.
Para solucionar el problema debemos mutuoexcluir la sección crítica, en este

caso las instrucciones de la (1) a la (4), de forma que no pueda “pisarse” el código. En
otros casos podrían ser menos instrucciones, ya que siempre se busca el mayor grado
de concurrencia posible.
254
Se desea controlar el proceso de llenado y tapado de envases de la Compañía
Algarrobo Cola. Existe una sola cinta transportadora y una máquina para cada acción.
Se dispone de los siguientes procedimientos:
• avanzo_cinta Avanza la cinta un paso (muy pequeño).

• llenar_botella Llena la botella de líquido (finaliza cuando está llena).
• pongo_tapa Comienza la acción de tapado (finaliza cuando la tapa queda
colocada).
Y de las siguientes funciones:
• puedo_llenar Devuelve TRUE si hay un envase bajo la estación de llenado.

• puedo_tapar Ídem para la estación de tapado.
Se pide:
(a) Resolver utilizando semáforos.

(b) Resolver utilizando monitores.
Nota:
Las botellas vienen a intervalos irregulares y no siempre se está en situación

de accionar las dos máquinas a la vez. Se desea conseguir los algoritmos más
sencillos posibles que resuelvan correctamente el problema.
Resolución: (Por Jorge Merlino)
(a)
255
(*) Si dejamos esta línea puede ocurrir que llegue llenar, coloque primero en
true, libere la sección crítica y espere. Luego venga tapar, encuentra primero en false,
entonces mueve la cinta, coloca primero en false, despierta un proceso esperando en
wait y libera la sección crítica. A continuación llega otro tapar, encuentra primero en
true entonces coloca primero en false, libera la sección crítica y espera. O sea, que
puede ocurrir que un proceso “auto proclame” primero.
(b) No se hizo en clase
256
Una tribu de N caníbales come de una gran marmita común con capacidad
para 6 comensales simultáneos.
Cuando un comensal quiere comer, come de la marmita, a menos que no haya

suficiente comida para él. Si no hay suficiente comida en la marmita, el caníbal
despierta al cocinero y espera a que el cocinero haya rellenado la marmita con la
carne de los misioneros capturados (no debe haber notificaciones repetidas). Para
rellenar la marmita el cocinero debe esperar a que todos los comensales que se
encuentran actualmente comiendo terminen. El cocinero, por su parte, vuelve a dormir
cuando ha rellenado la marmita.
Consideraciones:
• No podrán entrar nuevos comensales a la marmita cuando el cocinero está

rellenando o esperando para rellenar.
• Se supone que la marmita llena dispone de comida para más de seis

caníbales.
Se dispone de las siguientes funciones:
• Hay_suficiente_comida (): boolean
Esta función es ejecutada por los comensales y retorna si hay suficiente

comida en la marmita. No puede ser ejecutada por dos o más comensales a la
vez.
• Rellenar ()
Esta función es ejecutada por el cocinero.
• Comer ()
Es ejecutado por los comensales.
• Ocio ()
Ejecutada por los caníbales cuando no están comiendo.
Se pide:
Implementar los procedimientos caníbal y cocinero utilizando monitores.

Especifique la semántica de los mismos en caso de ser necesario.
257
En (*1) debemos ver si el

programa funciona con
ambas semánticas.
- Con SC (Signal &

Continue) vemos que el
Canibal que se dio cuenta
que debe despertar al
Cocinero, hace signal y se
tranca en (*2), liberando el
monitor
- Con SW (Signal &
Wait) vemos que el Canibal
hace signal, pierde el
monitor, pero el Cocinero
hace libera el monitor luego
de (*3)
258
Se desea modelar utilizando mailboxes el siguiente problema:
El taller mecánico “Boxes” tiene capacidad para 20 vehículos en sus

instalaciones. La entrada de los usuarios a las instalaciones debe ser estrictamente en
orden de llegada (la solución no debe permitir bajo ningún concepto “colados”).
El usuario debe ser atendido por el primer mecánico libre de los 5 con que
cuenta el taller. Elmecánico, una vez terminado el arreglo, le indicará a la caja el
monto a cobrar por el arreglo.
El cliente recibirá de la caja el monto a pagar.
• arreglar_auto() :integer
Invocada por un mecánico para arreglar el auto. Retorna el costo del arreglo.
• pagar_arreglo(Monto)
Invocada por el usuario para pagar el monto que le fue indicado por la caja.
Notas:
• Se prohíbe expresamente el busy-waiting.
• Se debe explicitar la semántica de las primitivas de mailbox utilizadas.
• Tener cuidado de que el socio pague el importe correcto del arreglo a la caja.
Consideraciones:
- send – No Bloqueante, de nombrado explícito indirecto
- receive – Bloqueante, de nombrado implícito
- Los mailbox se supondrán de tamaño infinito
259
Notar que el mailbox mec_caja tiene asignados dos mensajes simultáneamente, esto o bien puede
realizarse así o por medio de un struct.
Un problema que surge en general es que, si consideramos:
este esquema no funciona correctamente, ya que si llega una instancia del proceso P1, ejecuta el send y
luego se le expropia la CPU sin llegar a ejecutar el receive; y luego llega otra instancia distinta de P1 y
ejecuta lo mismo incluyendo el receive, y por último se retoma la ejecución de la primer instancia (la que
fue desalojada de la CPU), se recibirán los valores “al revés”. Existen dos soluciones a este problema:
- Mutuoexcluir el send y receive del proceso P1 mediante un mailbox mutex (de tamaño 1).
- Se considera un mailbox particular para ese proceso, similar mailbox “caja_cli” del problema, de
forma que sepa a quién mandarle el mensaje.
260
Sea un consultorio médico, el cual posee una sala de espera en la cual pueden
haber como máximo 10 pacientes. El médico atiende a una sola persona de la sala de
espera por vez, teniendo prioridad los niños. Cuando el médico termina de atender al
paciente deja que el próximo entre. Si no hay ninguno lee durante cinco minutos y
vuelve a ver si hay alguien. Si no lo hay vuelve a leer y así sucesivamente.
• atender()
Invocada por el doctor para atender un paciente.
• leer_diario()
Invocada por el doctor para leer el diario
Se pide:
Representar mediante tareas de ADA los pacientes, el doctor y la sala de

espera.
Nota:
El paciente debe solicitar permiso al portero para entrar a la sala y al médico

para entrar al consultorio.
261
Consideraciones:
- El propósito del select es hacer accepts, por eso cada guarda debe contener uno.
- Otra forma de asignar prioridades a niños sobre adultos en la task Doctor podría ser haciendo
De esta forma siempre acepto niños y en caso que nadie pida por “niños” elijo entre seleccionar
“niño” o “adulto”, el que llegue primero. Notar que esto se complicaría cuando tengo que
seleccionar entre más de dos procesos, puesto que se los selects se van a anidando conforme la
cantidad de procesos.
262
- Si en el select de la task Doctor tuviera
No estaría mal, compila, pero el “accept niño” está habilitado si había niños esperando. Si en el
momento de hacer el select la guarda estaba habilitada se acepta, sino no. Esto carece un poco
de sentido pues siempre acepto niños si es que los hay, por eso no usamos esta semántica.
- Dentro del select de la task Portero podría hacer:
Pero es innecesario puesto que siempre acepto salir.
- Otra semántica del select es:
En este caso, el cuerpo del select contiene unicamente una solicitud de encuentro y una cláusula
ELSE (o podría ser OR DELAY). Se utiliza para que las solicitudes mediante el operador ‘.’ no
sean bloqueantes.
- La rutina “atender()” se coloca dentro del cuerpo del accept puesto que Paciente-Doctor
comparten ese código. Si estuviera por fuera, el Paciente se va sin ser atendido, puesto que solo
Doctor ejecutaría el “atender()”.
263
En un sistema de memoria virtual por paginado con largo de página 512 bytes y
16 marcos de memoria real, se carga una matriz de 64x64 de tipo double (8 bytes), por
filas. Asumiendo una política FIFO de reemplazo de página, cuantos "page fault"
ocurrirán al procesar secuencialmente toda la matriz:
(a) Por filas.
(b) Por columnas.
Hacer el mismo cálculo para la política LRU.
Sabemos por la letra que la matriz es de la siguiente forma:
Y como la matriz se dispone en memoria por filas, tenemos
Dado que cada página es de 512bytes, y tenemos que cada celda ocupa
8bytes, una fila tendría 64x8bytes = 512bytes, entonces toda una fila entraría en una
página. De esta forma, para poder abarcar toda la matriz necesitaríamos 64 páginas,
pero disponemos de 16 marcos para alojar la matriz.
FIFO:
(a) Análisis por filas: Suponiendo que las páginas son cargadas bajo demanda,
al querer acceder a la celda se generaría un fallo de página y se traería
de disco toda la página al primer marco, o sea, toda la fila. De esta forma,
cuando se desea acceder a las celdas desde hasta la página ya
está cargada en memoria por lo que no genera un fallo. Al querer acceder a
la celda ocurriría análogamente lo mismo, y análogamente hasta
acceder a la . Al querer acceder a la celda ya no tendríamos
marcos disponibles (pues consumimos los 16) y debería seleccionarse un
marco víctima. Como estamos aplicando un algoritmo de reemplazo de
página FIFO, la página víctima será la primera que cargamos, o sea, la que
contiene la fila 1. Procediendo análogamente a los casos previos, el acceso
a las celdas desde hasta no reportarían fallo. Como nuevamente
tenemos los 16 marcos ocupados, al acceder a la celda se procedería
de la misma forma que para el caso de acceso a la celda ,
264
reemplazando el marco que contenía la fila 2, y así sucesivamente hasta

completar toda la matriz. En conclusión, tendríamos un total de 64 fallos de
página, al querer acceder al primer elemento de cada fila.
(b) Análisis por columnas: Razonando de forma similar al caso anterior

tendríamos que el acceso a la celda generaría un fallo y se trae toda la
fila 1 hacia el primer marco. Ahora, como el procesamiento es por
columnas, el acceso a también generaría un fallo, y así sucesivamente
hasta haber cargado la fila 16. Luego, como no hay marcos disponibles, se
debe seleccionar una víctima para poder acceder a , en este caso, la
víctima será el marco que contenía la fila 1. Esto ocurrirá con los primeros
64 accesos al primer elemento de cada fila para procesar toda una
columna, generando así 64 fallos de página. Al terminar de procesar la
columna 1, para poder procesar la siguiente se debe cargar nuevamente la
fila 1, pero esta vez para acceder a , y repetir el mismo procedimiento
anterior. Siguiendo esta idea, tendríamos un total de 64x64=4096 fallos de
página, 64 al tener que cargar toda la fila, y una por cada columna, o sea,
64 veces.
LRU:
Obtendríamos exactamente el mismo resultado, dado que para este caso la

elección del marco víctima es el mismo que en el caso de FIFO.
265
Un sistema operativo administra sus archivos en disco utilizando el método de
asignación indexada. Para esto, se dispone de las siguientes estructuras:
A su vez, se sabe que el directorio raíz es el inodo número 0, que la tabla de

inodos y el disco son globales, y que cada bloque de datos de los directorios tiene 32
entradas de tipo dir_entry.
(a) Implementar una función que retorne la cantidad de bytes utilizados por los
archivos (type == file) del sistema de archivos.
(b) Implementar una función que busque un archivo (file o dir) dentro de un directorio
(no búsqueda recursiva).
Donde archivo es el nombre del archivo a buscar, inodo es el número de inodo del
directorio donde buscar el archivo, nro_inodo es para retornar el número de inodo
buscado y ok es para retornar si la operación se concretó con éxito o no. Asumir
que se dispone de una función que lee del disco el bloque pasado como
parámetro:
(c) Implementar una función que dado un camino absoluto (ej.:

/home/sistoper/archivo.txt) retorne el número de inodo correspondiente.
Donde cam es el camino absoluto, nro_inodo es el número de inodo del archivo

referenciado y ok es para devolver si la operación se concretó con éxito o no.
266
(a) Debemos especificar el cabezal de la función y la propia función.
(b) En este caso asumiremos que un directorio tiene todas sus entradas llenas. De
esta forma, según la estructura, tenemos algo por el estilo:
Podría darse el caso que el directorio necesite menos de 32 entradas por

bloque, se podría tener una estructura que indique el tope de entradas válidas o bien
podría realizarse un algoritmo más prolijo que corte la iteración en (*1) en función del
campo size. [ver Examen Marzo 2010 – Ej. 2]
267
(c) El (PB) de la recursión es el directorio raíz, en cuyo caso el camino cam es “”

(string vacío, o bien podría ser “/”). En el (PR) debemos partir el string, para ello se
supone la existencia de dos funciones, basename y dirname, especificadas en el
código.
268
Preguntas teóricas
Las preguntas marcadas en color verde son sobre la primer mitad del curso,
mientras que las naranjas corresponden a la segunda mitad.
1º Parcial
May 2012
1. ¿Cuál es la principal ventaja de la multiprogramación? ¿Qué problemas
nuevos le acarrea al sistema operativo?
Respuesta: La principal ventaja de la multiprogramación es fundamentalmente
el objetivo que persigue, aprovechar al máximo el uso de la CPU. Lo realiza
multiplexando dicho recurso entre varios procesos cargados en memoria,
asegurándose de tener siempre un proceso que ejecutar. Un primer problema
que surge a simple vista de este esquema, es que al multiplexar la CPU entre
varios procesos, se debe dar lugar a algoritmos de Planificación, y la
performance del sistema se ve fuertemente impactada por la política que
apliquen. A su vez, dado que el recurso CPU en este esquema
(multiprogramado) es compartido entre varios procesos, SO debe acarrear el
problema de la concurrencia de procesos, los que compiten por los ciclos de
CPU, y pudiendo dar lugar a inconsistencias si los procesos son de tipo
cooperativo.
2. ¿Para qué sirven los manejadores de dispositivo (device drivers)?

Respuesta: El subsistema de E/S está compuesto por diversos periféricos.
Éstos, están compuestos de dos partes: dispositivo y controlador (parte del
periférico que contiene su inteligencia y por tanto la controla). Los device
drivers son un componente de software implementado por el SO para
comunicarse con todas las interfaces generadas por esos controladores.
Podemos ver a los device drivers como ‘manuales’, de esta forma, ante una
solicitud de E/S, el SO consulta a este ‘manual’ y ve como comunicarse con la
controladora del dispositivo solicitado.
3. Describa brevemente el proceso de invocar un llamado al sistema

(system call). Mencione tres formas posibles de pasaje de parámetros
entre el proceso de usuario y el núcleo (kernel).
Respuesta: Los system call son la interfaz generada por el SO para que las
aplicaciones de usuario puedan consumir los distintos servicios que el SO
brinda. Ante un system call, se deben llevar a cabo las siguientes tareas:
- Cargar los parámetros
- Cargar el número de system call
- Invocar a la trap adecuada (system call handler)
- Pasar a modo monitor
- Verificar que el número de system call sea menor al mayor existente
en el sistema y, en caso de ser válido, invocar a la rutina que
atiende el system call solicitado
- Retornar el resultado de la misma forma de cómo se cargaron sus
parámetros
- Volver a modo usuario
269
Las tres formas posibles para pasar parámetros a un system call son:
- Por medio de registros. Tiene como desventaja que acota el número

de parámetros que se le pueden pasar al system call.
- Por medio de un bloque de memoria apuntado por un registro
- Por medio de un stack. Se colocan mediante operaciones PUSH y el
SO las retira por medio de operaciones POP.
4. Mencione los servicios fundamentales del SO concernientes a la

manipulación del sistema de archivos.
Respuesta: El SO define una abstracción lógica de la información, el archivo.
Para su fácil localización se suelen ubicar dentro de directorios. De esta forma,
el SO se encarga de:
- Crear/Eliminar archivos y directorios
- Proveer primitivas para la manipulación de archivos/directorios
- Establecer la correspondencia entre el archivo y el dispositivo de
almacenamiento
- Resguardar la información.
5. ¿Qué cambios realizaría al bloque descriptor de procesos (PCB – Process

Control Block) de un sistema que no soporta hilos (thread) si se quisiera
que soportara?
Respuesta: El PCB es una estructura de datos que representa al proceso.
Dado que sus principales componentes son el pid (process id), el valor del PC,
el valor de los registros y variables, el estado, entre otros; si quisiéramos que el
sistema soportara hilos deberíamos incluir por cada thread un PC, un espacio
de stack y registros propios. El resto de los componentes sería compartido
entre todos los threads del proceso.
May 2013
1. Indique tres métodos posibles para realizar una operación con una
controladora.
Respuesta: Los tres métodos para que el SO realice una operación con una
controladora de dispositivo de E/S son:
- Polling (Consulta): La CPU envía la solicitud a la controladora, y se
queda en espera activa (o busy-waiting, o en estado ocioso)
consultando si el dispositivo terminó de realizar la operación
- Interrupción: La CPU envía la solicitud a la controladora, y se libera
esperando a ser interrumpido por esta avisando que terminó de
operar.
- DMA (Direct Access Memory): La CPU envía el pedido a la
controladora, y se libera para realizar otras tareas. El dispositivo,
cuando termina de procesar la E/S solicitada, escribe directamente
en la memoria principal por medio de un recurso de hardware
denominado DMA. Este avisa por medio de una interrupción cuando
terminó la escritura de los resultados.
270
2. ¿Para qué sirve la protección de memoria? ¿Quién realiza este control?

Respuesta: La protección de memoria tiene como objetivo establecer el área
de memoria legal a la que un proceso puede acceder, de forma de evitar que el
proceso pueda acceder a áreas restringidas de memoria (como el vector de
interrupciones) y pueda llegar a corromper el funcionamiento del sistema. El
SO tiene acceso irrestricto a la memoria, pudiendo cargar y desalojar a los
procesos en caso de ser necesario. Para establecer el área de memoria válida
de un proceso se incorporan dos registros especiales a su PCB, el registro
base que contiene la dirección más pequeña a la que el proceso pude acceder,
y el registro límite que contiene el tamaño del intervalo. El componente de
hardware encargado de verificar que las direcciones lógicas generadas por el
proceso es la MMU (Memory Magnament Unit), quien compara la dirección
generada en base a los registros base y límite del proceso, y encaso de no
estar dentro del rango genera una trap que es capturada por el SO, llevando a
cabo las acciones pertinentes.
A su vez, las instrucciones que cargan los registros base y límite son
privilegiadas, por lo que solo el SO puede ejecutarlas.
3. Describa brevemente el proceso de cambio de contexto de la CPU.

Respuesta: El cambio de contexto es la tarea que lleva a cabo del SO cuando
un proceso abandona la CPU, ya sea en forma voluntaria o involuntaria (en
caso de tener un planificado expropiativo), debiendo asignar la CPU a otro
proceso que este pronto para ejecutar. El SO ante un cambio de contexto debe
llevar a cabo principalmente dos etapas:
- Respaldo
o Se debe salvar el contexto en el que estaba el proceso, esto
incluye el valor de su PC, registros, etc, en su PCB
o Se debe cambiar el estado del proceso de ejecutando al que
corresponda (Terminado, Esperando o Listo)
- Reanudación
o Se debe cargar el contexto del proceso al que se le fue
asignado la CPU a partir de su PCB, como PC, valor de
registros, etc, de forma que el proceso pueda continuar su
ejecución como si nada hubiese pasado
271
o Se debe cambiar el estado del proceso de pronto a

ejecutando.
4. Describa el modelo de threads MxN (Many-to-Many)

Respuesta: En el modelo de threads MxN tenemos un conjunto de User
Threads asignados a un conjunto de Kernel Threads. Para que el modelo tenga
sentido, la cantidad de Kernel Threads debe ser menor a la cantidad de User
Threads, sino se degeneraría en un modelo 1x1 que podría llegar a tener
kernel threads “de sobra”. En este esquema, el planificado a nivel usuario
asigna los User Threads a los Kernel Threads, y pueden ejecutarse tantos User
Threads como Kernel Threads estén asignados a un procesador (en caso de
tener un sistema multiprocesador). Una gran ventaja de este esquema es que
si un thread realiza una llamada bloqueante al sistema, el proceso entero no se
bloquea (como ocurre en el modelo Mx1), sino que puede planificarse otro
Kernel Thread que tenga asignado un User Thread y ejecutar sin problemas.
5. Indique una posible estrategia de Scheduling para usar en un sistema de

tiempo real estricto (hard) y justifique su respuesta.
Respuesta: En un sistema de tiempo real estricto tenemos un conjunto de
procesos que deben ejecutar y entregar una respuesta al usuario dentro de
cierto margen temporal, de lo contrario el sistema falla. En este caso, no es
necesario tener una estrategia de planificación expropiativa, ya que si un
proceso ejecuta lo hace por un periodo corto de tiempo.
2º Parcial
Jul 2012
1. ¿Qué componente se utiliza para realizar en forma más eficiente la
traducción de direcciones virtuales a físicas? Describa su
funcionamiento.
Respuesta: Una dirección virtual es aquella generada por la CPU por parte de
un proceso, que no tiene por qué corresponderse con la dirección física
(ubicación en MP). El componente encargado de realizar la traducción de
direcciones virtuales a físicas es la MMU (Memory Magnament Unit),
componente de HW que es colocado entre la CPU y la memoria. Cuando la
CPU genera una dirección, la MMU verifica su correctitud y ocasionalmente
aplica un desplazamiento con el fin de proteger área de memoria privilegiada.
Dependiendo del esquema de asignación de memoria que se aplique
(particiones fijas, particiones variables, paginación o segmentación), la MMU
trabajará con:
- Un par de registros, límite y reubicación, para los casos de
particiones fijas y variables
- Una tabla, dado que una dirección se presenta bidimensionalmente,
para los casos de paginación y segmentación.
2. Se desea crear un sistema RAID que tenga el mayor rendimiento posible

sin importar la confiabilidad. ¿Qué sistema RAID utilizaría para este caso?
Justifique
272
Respuesta: Dada la situación, si únicamente interesa aumentar el rendimiento

sin importar la confiabilidad, lo más adecuado sería utilizar un RAID 0. Este
nivel de RAID aplica únicamente técnicas de striping (se distribuye el cómputo
entre varios discos, por ejemplo si se dispone de 8 discos, por cada byte de
datos, podría colocar un bit en cada uno esos discos). De esta forma, se puede
acceder a los datos en forma paralela a un nivel de granularidad dada (byte,
bloque, etc), y no desperdiciar tiempo en acceder al mismo dato en forma
secuencial en un único disco.
3. ¿Qué función tiene el planificador de disco? Describa el planificador

SCAN.
Respuesta: El disco no es más que otro dispositivo de E/S del sistema, cuya
utilidad es persistir datos. De esta forma, en un ambiente multiprogramado,
cuando algún proceso requiera algún dato de disco, o propiamente el SO lo
requiera, las solicitudes pasan a una cola de espera por este dispositivo,
administrado por el kernel. Una buena planificación busca:
- Un gran ancho de banda, definido como la cantidad de bytes transferidos en
el intervalo de tiempo donde se inicia la transferencia hasta el final de la misma
- Un tiempo de acceso breve, determinado por el seek time (tiempo de
posicionamiento del brazo) y el rotation latency (frecuencia de giro del disco).
Un planificador SCAN, también llamado “algoritmo del ascensor”, recorre todas
las pistas de un disco en orden de un extremo a otro, y al llegar a un extremo
invierte su sentido, atendiendo todas las solicitudes que se encuentre en su
camino. Busca minimizar el seek time. La desventaja que presenta es que al
llegar a un extremo, dado que invierte su sentido, es probable que las próximas
solicitudes que atenderá (en ese “sentido inverso”) serán pocas, ya que fueron
atendidas recientemente, y habrán más solicitudes sobre el extremo opuesto,
provocando así un desperdicio de tiempo en atender pocas solicitudes mientras
“barre” los primeros sectores, impactando en la performance del sistema.
4. Describa cómo funciona el método DMA (Direct Access Memory).

Respuesta: El método DMA es un método para comunicarse con una
controladora de E/S. Un DMA es un recurso de HW dedicado a operar en
paralelo a la CPU para realizar una operación de E/S, escribiendo los datos en
memoria sin ayuda de éste. Cuando la CPU decide realizar una operación de
E/S, configura el DMA y prosigue sus labores mientras el DMA se encarga de
realizar el pedido. Al finalizar, el DMA se apodera del bus de memoria
temporalmente para escribir los resultados y mediante una interrupción notifica
cuando terminó de realizarse el pedido. Durante este lapso, la CPU no puede
acceder a memoria, pero si a la caché, generando un impacto en la
performance, aunque generalmente aumenta el rendimiento.
Jul 2013
1. Explique el algoritmo de reemplazo de páginas de segunda chance
mejorado (NRU, Not Recently Used) e indique el soporte de hardware
necesario para una implementación eficiente.
Respuesta: El algoritmo de segunda chance mejorado (NRU), a diferencia del
algoritmo de segunda oportunidad, además de utilizar un bit de referencia (R)
utiliza un bit de modificación (M) – ambos son componentes de HW. De esta
forma, cada vez que una página es accedida para lectura/escritura se setea su
273
bit de referencia en 1, y cuando es escrita se setea su bit de modificación en 1.

Además, se debe contar con un timer (HW) que al interrumpir setee el bit R a 0
para distinguir las páginas que fueron accedidas recientemente. Al ocurrir un
fallo de página, los marcos podemos clasificarlos en cuatro clases, denotando
como (R,M) al par de bits tenemos:
- Clase 0 - (0,0): La página no fue referenciada ni modificada
- Clase 1 - (0,1): La página no fue referenciada pero si modificada
- Clase 2 - (1,0): La página fue referenciada pero no modificada
- Clase 3 - (1,1): La página fue referenciada y modificada
El algoritmo escoge como víctima alguna página que pertenezca a una de las
clases más bajas que no esté vacía. Observemos que la clase-1 se obtiene de
la clase-3 cuando el timer apaga su bit de referencia. A su vez, la elección de
que la clase-1 se encuentre en un nivel más bajo que la clase-2 se debe a que
si una página de la clase-1 se toma como víctima, ésta se envía a un SPOOL
para despacharla a disco, y durante ese lapso aún puede ser referenciada si es
que un proceso pide por ella, reduciendo así el impacto en la performance.
2. Indique ventajas y desventajas de utilizar las estructuras de tablas de

páginas jerárquica y diccionario, para una arquitectura de 64 bits que
utilice paginación y tenga un tamaño de páginas de 4KB
Respuesta: Ambos esquemas, jerárquico y diccionario, buscan atacar el
problema que conlleva alojar toda la tabla de página de un proceso en MP
(puede ser excesivamente grande, incluso mayor a la capacidad de MP). En
una arquitectura de 64 bits (lo que compone una dirección virtual) con un
tamaño de página de 4KB = 2^12B, se reservan los últimos 12bits para
direccionar dentro de una página, y los primeros 52 para direccionar la tabla de
página. En un esquema jerárquico, dependiendo de la cantidad de niveles,
estos 52 bits se “dividen” en tantos campos como niveles tenga (que no tiene
por qué ser equitativo, depende del tamaño de las tablas en los distintos
niveles) e indican el desplazamiento en MP donde encontrar el nivel deseado
de la tabla de página, debiendo acceder tantas veces a MP para encontrar los
números de páginas internas como niveles tenga para encontrar el marco
deseado. En cambio, en un esquema de diccionario, los primeros 52 bits
corresponden a un número de página, que aplicando una función de hash
podemos consultar una tabla de hash abierto (admite colisiones), que contiene
una lista cuyos elementos son el par (nro_página, nro_marco) y así realizar una
búsqueda más óptima (en O(1) promedio).
3. Describa dos razones para utilizar “buffering”.

Respuesta: Es el proceso de colocar y consumir datos de un buffer. Un buffer
es un área de memoria donde se almacenan datos mientras se transfieren
entre dos dispositivos o un dispositivo y un proceso. Existen básicamente tres
razones para utilizar la estrategia de buffering:
- Normalizar velocidades entre los dispositivos, ya que pueden existir
dispositivos muy lentos en comparación con la velocidad de
cómputos de otros. De esta forma, un dispositivo rápido puede
colocar los datos en un buffer y un dispositivo lento puede ir
consumiendo de él, o viceversa.
- Adaptarse entre dispositivos que difieren en los tamaños de
transferencia, como puede ocurrir en una transferencia por medio de
274
una red. En este caso un emisor fragmenta los datos en pequeños

paquetes y los envía por la red, y el receptor los coloca en un buffer
de recomposición para recomponer los datos de origen.
- Mantener la semántica de las aplicaciones que realizar E/S. Por
ejemplo, en una operación write(), el buffer de usuario es copiado en
un buffer del SO, de esa forma, se logra independizar el SO del
proceso.
4. En el contexto de la virtualización, describa qué son las instrucciones

sensibles y qué condición debe cumplir el hardware para soportar
hipervisores tipo 1.
Respuesta: Las instrucciones sensibles son aquellas que cambian el estado
privilegiado o lo expone. Podemos clasificarlas en dos tipos: Sensibles de
Control (intentan cambiar la configuración de los recursos del sistema) y
Sensibles de Comportamiento (cuyo comportamiento dependen de la
configuración del sistema). De esta forma, según Popek&Goldberg, para que
un sistema pueda soportar virtualización (como es el caso de los hipervisores
tipo 1) las instrucciones sensibles deben ser un subconjunto de las
instrucciones privilegiadas. Con este enunciado, la primer pregunta que uno se
hace es “¿existen instrucciones sensibles que no sean privilegiadas?”, la
respuesta es sí, como por ejemplo la instrucción POPF de Intel x86, donde al
ser invocada en modo monitor actualiza el registro FLAGS completamente, en
cambio, si es llamado en modo usuario, solo cambia algunos flags del registro,
y las que “no deberían tocarse” las ignora, sin generar una trap.
5. Explique el mecanismo en un sistema UNIX para permitir que un usuario

ejecute una aplicación con privilegios de administrador.
Respuesta: En sistemas tipo UNIX, a cada usuario se le asocia un dominio y a
los archivos un identificador de propietario (User ID - UID) y un bit de dominio
(setuid). De esta forma, cuando se desea ejecutar una aplicación de otro
usuario, se debe cambiar temporalmente el UID del usuario en cuestión al
usuario propietario de la aplicación a ejecutar. Esto puede, o bien hacerlo con
el bit setuid apagado, y por tanto la ejecución se hace en nombre propio, o bien
puede hacerlo con el bit setuid encendido y se hace en nombre del usuario
propietario hasta que el proceso termine. Para poder ejecutar una aplicación
con privilegios de administrador se debe seguir este protocolo, cambiando el
UID a root temporalmente con el bit setuid apagado, ya que si se encuentra
encendido puede llegar tomar el papel de administrador y apoderarse del
sistema, pudiendo comprometer la seguridad del mismo.
275
Exámenes
Feb 2010
1. ¿Qué es y cuáles son las ventajas que propone un sistema de tiempo
compartido?
Respuesta: En un sistema de tiempo compartido tenemos un conjunto de
trabajos en memoria, y se conmuta la CPU entre ellos a un ritmo tan frecuenta,
imperceptible a ritmo humano. La principal ventaja de esto es que a cada
usuario le da la apariencia que tiene la CPU exclusivamente para él en todo
momento.
2. Realice un esquema con los estados por los que debe pasar un proceso y
sus transiciones.
Respuesta:
Donde, los estados son:

- Nuevo: Durante el proceso de creación del proceso.
- Listo: El proceso se encuentra esperando a ser despachado cuando
el planificador lo seleccione para ejecutar.
- Ejecutando: El proceso se encuentra ejecutando sus instrucciones
en la CPU. Podemos tener tantos procesos en este estado como
procesadores se disponga.
- Esperando: El proceso realizó una llamada bloqueante al sistema,
ya sea por una solicitud de E/S o algún evento en especial, como
puede ser una operación P en un semáforo.
- Terminado: El proceso terminó su ejecución.
Y las transiciones son:
- Admitido: Un proceso luego de ser creado pasa directamente a la

cola de procesos listos, es admitido.
- Despachado por el planificador: El proceso fue seleccionado por el
planificador y el despachador le da el control de la CPU para que
ejecute sus instrucciones
- Fin: El proceso terminó de ejecutar sus instrucciones en la CPU.
- Interrumpido: El proceso que estaba corriendo en la CPU es
desalojado ante un evento de interrupción.
276
- Espera evento: El proceso realizó una llamada bloqueante al

sistema, por lo que pasa a la cola de espera del dispositivo que
solicitó, ya sea físico, como de E/S, o lógico como la cola de un
semáforo.
- Termina evento: El dispositivo, lógico y físico, avisa que terminó de
ejecutar la solicitud pedida, y despacha un proceso de su cola de
bloqueados a la cola de procesos listos.
3. Sea un sistema con paginación bajo demanda y que soporta hilos a nivel
del núcleo y sean los registros Program Counter y Page Table Base
Register
a. Cuáles de los registros anteriores son modificados al realizar un
cambio de contexto entre dos hilos de un mismo proceso.
Respuesta: Únicamente se modifica el PC, ya que el PTBR (registro
que aloja la dirección donde se encuentra la tabla de páginas para el
proceso) es compartido entre todos los threads del proceso. Sin
embargo, el PC no es compartido, ya que cada thread tiene su propio
PC
b. Cuáles de los registros anteriores son modificados al realizar un

cambio de contexto entre dos hilos que pertenecen a procesos
distintos.
Respuesta: En este caso ambos registros son modificados, ya que el
PC de un thread de por si es independiente del resto de los threads
hermanos, y más aún, es independiente de un proceso distinto. El
PTBR debe cambiar, ya que cada proceso tiene su propia tabla de
páginas en memoria.
4. Sea un sistema operativo con planificador de prioridades estáticas.

a. ¿Qué problema presenta este tipo de planificador?
Respuesta: Padece el problema de la posposición indefinida, dado que
si tenemos un proceso de baja prioridad en el sistema pronto para
ejecutar y existe un gran flujo de procesos con prioridad mayor a él,
puede o bien que el proceso se bloquee indefinidamente, o muera por
inanición cuando el sistema falla.
b. Brinde una solución al problema mencionado en la parte anterior.

Respuesta: Como solución al problema anterior se puede contar con
un esquema de planificación dinámica de envejecimiento en vez de
planificación estática. De esta forma, mientras más tiempo el proceso
esté esperando a que se le asigne la CPU, su prioridad aumenta, hasta
el punto de llegar a tener la prioridad suficiente como para pasar a
ejecutar.
5. En general los SO modernos de propósito general dividen el espacio

virtual de los procesos en varios componentes. Mencione estos
componentes y su función.
Respuesta: Cuando el loader asigna un espacio de memoria para alojar al
proceso, éste se carga en diferentes áreas, principalmente Código, Datos,
277
Heap y Stack, conformando el espacio virtual de direccionamiento

del proceso. El área de Código contiene propiamente el código del
proceso, cuyas instrucciones son ejecutadas a partir de la posición
del PC. El área de Datos contiene todas aquellas variables
declaradas en forma estática por parte del proceso. El Heap y
Stack solo consumirá memoria física cuando éstos crezcan. El
Heap se utiliza para reservar memoria que es generada en forma
dinámica por parte del proceso por medio de llamadas tipo malloc() o free().
Este esquema se comporta en forma no predictiva, generando fragmentación
externa de memoria. El Stack, en cambio, se utiliza para preservar el estado de
llamadas a subrutinas conformado básicamente por sus parámetros, variables
locales y dirección de retorno. Se comporta en forma predictiva.
6. Compare un esquema de paginación que utiliza varios niveles de tabla de

página (digamos 4 niveles) contra un sistema de paginación que utiliza
solamente un nivel para la tabla de página.
Respuesta: Si consideramos que tenemos una tabla de página de un único
nivel, la búsqueda del marco dentro de la tabla se realiza directamente,
buscando la entrada correspondiente al número de página (presente en la
dirección virtual). El inconveniente de este esquema es que la tabla puede
llegar a ser excesivamente grande como para alojarla en MP, e inclusive puede
no caber. Para afrontar este problema, un esquema de tabla de página
multinivel tiene como propósito paginar la propia tabla de página. Esto quiere
decir que se mantiene una tabla externa que apunta a bloques que contienen
información sobre un rango de la tabla de página (tabla interna), y esos rangos
son cargados a demanda a fin de ahorrar espacio en la MP. Esta idea se
puede generalizar para cualquier cantidad de niveles. La tabla más interna es
quien contendrá el número de marco buscado. El inconveniente de este
esquema es que se desperdicia tiempo en resolver una dirección lógica, pues
necesita acceder tantas veces a memoria como niveles se tenga, pudiendo
tener alto impacto en la performance del sistema.
7. ¿Qué es la TLB, cuál es su función y qué sucede con ella cuando hay un
cambio de contexto entre dos procesos distintos?
Respuesta: La TLB (Translation Lookaside Buffer) es una caché asociativa, y
como tal, mantiene copias de datos, en nuestro caso, número de marcos. Por
ser una caché asociativa, una dirección se compone de un TAG|WORD, el
TAG se corresponde con el número de página, mientras que el WORD es el
número de marco asociado. De esta forma, al presentarse una dirección virtual,
se busca el número de página en TLB (comparando los TAGs al unísono) y en
caso de TLB-Hit se resuelve la búsqueda del marco por medio de esta, y en
caso de TLB-Miss se busca dentro de la tabla de página y se actualiza la TLB
para futuros accesos. Ante un cambio de contexto la TLB debe ser vaciada, ya
que los datos allí presentes corresponden al proceso que anteriormente estaba
ejecutando en CPU, si no se hiciera se puede llegar a acceder al área de
memoria de otro proceso por error y provocar un mal funcionamiento. Es claro
que vaciar la TLB implica invertir cierto tiempo, y por tanto, puede tener alto
impacto en el rendimiento del sistema. Como solución, la TLB, además de
estar indizada por el número de página, puede contener un ASID (Adress
Space ID), generalmente el PID del proceso. De esta forma, si proceso desea
acceder a cierta página y ésta se encuentra en la TLB, el TAG estaría
278
conformado por el par (ASID,nro_página), evitando así tener que vaciar la TLB
en cada cambio de contexto.
8. ¿Qué entiende por memoria SWAP?

Respuesta: La memoria SWAP es el área de memoria en disco (backing store)
que se utiliza para alojar aquellos procesos que no están en MP, ya sea porque
están esperando a ser cargados, porque se desea evitar el trashing
(hiperpaginación, fenómeno que ocurre cuando existe una gran cantidad de
fallos de página, generando una caída en la tasa de uso de CPU y en un
intento por aumentar el nivel del multiprogramación la situación empeora), o
porque existe una sobrecarga de la memoria virtual (existen área de memoria
que no son utilizados con frecuencia –páginas o segmentos- y se deben
intercambiar). Al proceso de pasaje de MP a disco se lo denomina swap-out, y
al proceso inverso se lo denomina swap-in.
9. En el subsistema de E/S, describa dos métodos que se puede utilizar para

efectuar una E/S.
Respuesta: Para efectuar una E/S, se deben configurar los registros de la
controladora del dispositivo a utilizar (básicamente los registros Estado,
Control, Datos de Entrada, Datos de Salida), ya sea mediante un esquema de
Memory Mapped-IO (el acceso a estos registros se da por medio de áreas
especiales de memoria) o por Direct Instruction-IO (existen instrucciones
especiales para tales propósitos, como IN/OUT). Los métodos de comunicación
son básicamente tres:
- Programmed IO: La CPU envía el pedido, y se queda en espera
activa consultando el registro de estado READY por parte de la
controladora que indica el fin de la operación. Si bien el código es
legible, no es eficiente si se sabe que el procesamiento de la
solicitud es lento, pues consume ciclos de CPU al dejarla ociosa.
- Interrupt Driven-IO: La CPU envía el pedido y se libera a la espera
de una interrupción por parte del controlador avisando que ya
terminó de procesar la solicitud. La CPU realiza este procedimiento
verificando, antes de que cada fetch, si existe una solicitud de
interrupción en su línea IRQ (en HW). Una vez que detecta que se
generó la interrupción, se salva el contexto en que se encontraba la
CPU en ese momento, y por medio de un número de interrupción
(presente en la señal de la interrupción) pasa a ejecutar la rutina de
atención (indicada en el vector de interrupciones) y finalmente
cambia el estado del proceso a listo y retorna el control al usuario.
En este caso, el código es separado en dos, el código que realiza el
pedido y el código de atención a la interrupción, siendo menos claro
que el caso de Programmed IO.
- Direct Access Memory (DMA): La CPU, ente un pedido, configura un
dispositivo de HW denominado DMA. Este dispositivo se encarga de
realizar la solicitud de E/S en su nombre, y la CPU se libera a la
espera de una interrupción por parte de este avisando que terminó
de procesar el pedido. El DMA, cuando termina de procesar la E/S,
se apodera del bus de memoria temporalmente para escribir los
279
datos directamente en la MP, sin intervención de la CPU (operan en

paralelo). La desventaja de este esquema, es que durante ese
apoderamiento del bus de memoria, la CPU no puede utilizar dicho
bus, pero sí puede acceder a la caché. Si bien esto podría generar
un impacto en el rendimiento del sistema, su rendimiento suele ser
mejor que los demás esquemas.
Mar 2010
1. ¿Qué entiende por sistema multiprogramado?
Respuesta: Un sistema multiprogramado es aquel en el que se cuenta con un
conjunto de trabajos cargados en memoria, y se multiplexa la CPU entre ellos a
fin de tener un proceso que ejecutar en todo momento. Una clara consecuencia
de esto, es que se maximiza el uso de la CPU. Dado que la CPU conmuta
entre varios procesos, se da lugar a la planificación, y además se deben
incorporar mecanismos de protección cuando existan procesos cooperativos en
el sistema.
2. Describa 4 de los componentes más importantes de un sistema operativo.

Respuesta: Cuatro de los componentes principales de un sistema operativo
son:
- Administración de procesos: Dado que el proceso es la unidad de
trabajo del SO, se debe contar con estrategias que los administren
en forma adecuada.
- Administración de memoria: Dado que los programas de usuario
para ser ejecutados deben ser cargados en memoria principal
previamente (a fin de “transformarse” en procesos), se debe tener
una adecuada administración de la memoria.
- Subsistema de E/S: Dado que los procesos pueden solicitar
recursos, se debe tener una buena gestión de los mismos.
- Subsistema de archivos: Dado que SO define una perspectiva lógica
del almacenamiento secundario (el archivo), se debe proporcionar
un buen manejo del mismo, incluyendo la organización en
directorios y un control cuando tenemos un sistema multiusuario.
3. ¿Qué permiten los llamados al sistema (system calls)?

Respuesta: Los system call son la interfaz provista por el kernel para que las
aplicaciones de usuario puedan consumir los distintos servicios que
proporciona el SO.
4. Sea un sistema que cuenta con los siguientes cuatro procesos con sus
respectivos tiempos de ejecución (bust time):
Proceso Tiempo de
ejecución
P1 5
280
P2 4
P3 1
P4 6
a. Realice un diagrama de tiempo del uso del procesador para los

siguientes planificadores: FCFS, SJF y RR con quantum 2.
Respuesta:
FCFS
T T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15 T16
P1 P1 P1 P1 P1 P2 P2 P2 P2 P3 P5 P5 P5 P5 P5 P5 -
CPU
SJF
CPU
RR
CPU
b. Calcule el tiempo promedio de espera para los 3 planificadores.

Respuesta:
WTprom (FCFS) = (0+5+8+9)/3 = 22/3
WTprom (SJF) = (5+1+0+10)/3 = 16/3
WTprom (RR) = (9+7+4+10)/3 = 30/3
c. Realice el diagrama para el planificador RR con tiempo de quantum

5 y haga un análisis de cómo se comporta.
Respuesta:
RR q = 5
CPU
En este caso, el planificador RR se degenera en un FCFS por la

elección del quantum y a su vez porque el CPU-burst del proceso P4 es
6, o sea, al ser el último en ejecutar, utiliza sus 5 unidades de tiempo y
se apropia de la CPU nuevamente, puesto que el resto ya ejecutó por
tener un CPU-burst menor o igual a 5.
5. ¿Qué entiende por carga dinámica?

Respuesta: La carga dinámica permite que una rutina no sea cargada en
memoria principal hasta tanto no se utilice. Entre los beneficios se puede
mencionar que no se cargan innecesariamente rutinas que no son invocadas,
sino que se mantiene en disco en formato de carga reubicable. A su vez, los
binarios en el sistema ocupan menos espacio ya que se pueden crear
bibliotecas dinámicas que varios programas referencien
6. ¿Qué son las tablas de página de un proceso?
281
Respuesta: La tabla de página tiene sentido en un esquema de paginación.

Como su nombre lo indica, una tabla de página no es más que una tabla
indizada por el número de página y cuyo contenido es el número de marco
correspondiente. De esta forma, cuando se presenta una dirección virtual, ésta
es entendida por la MMU en dos partes: nro_pag|desp. Con los bits que
corresponden al número de página la MMU busca el número de marco en la
tabla de página del proceso, y con ello se tiene la dirección física del dato
buscado en MP, formado por el par nro_marco|desp.
7. Sea un SO que implementa paginación bajo demanda con una estrategia

de asignación local de marcos. Sea un proceso al cual se le asignaron
cuatro marcos en MP y que realiza la siguiente secuencia de accesos a
sus páginas
7 1 2 7 4 5 6 7 3 3 2 7 1 2 6 4 7
a. Realice un diagrama que muestre en el tiempo el uso de los cuatro

marcos si se utiliza un algoritmo de remplazo LRU (Least Recently
Used) y mencione cuántos fallos de página hubieron.
Respuesta:
7 1 2 7 4 5 7 3 3 2 7 1 2 6 4 7
7 7 7 7 7 7 7 7 7 7 7 7 7 7 4 4
1 1 1 1 5 5 5 5 5 5 1 1 1 1 7
2 2 2 2 2 3 3 3 3 3 3 6 6 6
4 4 4 4 4 2 2 2 2 2 2 2
F F F F F F F F F F F
Cola de menos recientemente usados

7 1 2 7 4 5 7 3 3 2 7 1 2 6 4 7
7 1 2 7 4 5 7 7 3 2 7 1 2 6 4
7 1 2 7 4 5 5 7 3 2 7 1 2 6
1 2 2 4 4 5 5 3 3 7 1 2
Total de fallos: 11
b. Realice un diagrama que muestre en el tiempo el uso de los cuatro

marcos si se utiliza un algoritmo de remplazo Óptimo (Optimal) y
mencione cuántos fallos de página hubieron.
Respuesta:
7 1 2 7 4 5 7 3 3 2 7 1 2 6 4 7
7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
1 1 1 1 1 1 1 1 1 1 1 1 6 6 6
2 2 2 2 2 2 2 2 2 2 2 2 4 4
4 5 5 3 3 3 3 3 3 3 3 3
F F F F F F F F
Total de fallos: 8
8. ¿Qué ventajas brindan los sistemas RAID?

Respuesta: Los sistemas RAID, en cuyos orígenes su sigla era Redundant
Array of Inexpensive Disk (arreglo redundante de discos baratos), persigue dos
282
objetivos: mantener confiabilidad de los datos y optimizar el acceso a ellos. La

confiabilidad se logra por medio de técnicas de mirroring (duplicación espejo de
cada disco, agrega redundancia), de forma que si un disco falla, el dato
permanece persistido en su “gemelo”. Esta técnica se basa en la idea de que
los fallos en los discos son independientes, no aplica si ocurre un terremoto por
ejemplo, pudiendo provocar un aterrizaje de cabezales en todos los discos y
generar pérdidas en todos ellos (los originales, y los espejados). Otra forma de
lograr confiablidad resulta de mantener de alguna forma la paridad de los datos
(agregando redundancia), de forma que ante un fallo (detectado por el SO) se
pueden detectar y posiblemente corregir los datos perdidos. La cantidad de
datos que pueden llegar a ser recuperados depende de cómo es el código de
corrección de errores. Por otro lado, una mejora en el rendimiento del sistema
se logra mediante técnicas de striping (distribución en bandas), cuya
granularidad puede darse a nivel de bit, byte, bloque, sector, etc, albergando
una unidad de transferencia en cada disco, operando en paralelo. Por ejemplo,
supongamos que la granularidad está dada a nivel de byte, y disponemos de 8
discos, entonces podemos tener un bit de cada byte en cada uno de los discos,
que pueden ser accedidos en forma paralela, optimizando el tiempo que se
tendría si se hiciera el mismo acceso pero en forma secuencial.
Jul 2010
1. Responda las siguientes preguntas
a. ¿Qué tarea realiza el planificador de CPU en un sistema
operativo?
Respuesta: El planificador es el modulo del SO encargado de realizar
la elección de qué proceso será el próximo en ejecutar en la CPU. La
prioridad de quién será el proceso a ejecutar depende del algoritmo de
planificación a utilizar y de qué esquema esté utilizando (expropiativo
vs. no expropiativo). Los algoritmos son:
- FCFS (First Come First Served – no expropiativo)
- SJF (Shortest Job First – puede ser expropiativo o no expropiativo)
- por Prioridad (puede ser expropiativo o no expropiativo, de
prioridades extáticas o prioridades dinámicas)
- RR (Round Robin – expropiativo)
En los planificadores de CPU la idea general es favorecer a los

procesos que sean IO-bound (cuyas ráfagas de E/S o IO-burst es mayor
a la CPU-burst), frente a los que sean CPU-bound. Como regla general,
un proceso utilizará un recurso con prioridad inversamente proporcional
al uso que haga de este.
b. Defina dos métricas utilizadas para comparar planificadores de

CPU
Respuesta: Dos de las métricas utilizadas para comparar algoritmos de
planificación son:
- Utilización de CPU: Porcentaje de uso del CPU
- Tiempo de espera: Es la suma de los tiempos en el que el proceso
estuvo en la cola de listos esperando a utilizar la CPU.
283
c. Realice un diagrama y describa el planificador Multi-level feedback

queue.
Respuesta: Los planificadores Mult-level feedback queue se basan en
una cantidad determinada de colas, cada una con su tipo de
planificación, y existe una prioridad (generalmente fija) entre todas las
colas, de forma que se selecciona un proceso de una cola determinada
si y solamente si no existen procesos en las colas de nivel superior. Al
llegar un proceso a la ready queue, se debe especificar cuál de las
colas debe ir (la de mayor prioridad), y a su vez la retroalimentación
implica que ese proceso puede cambiar de cola dependiendo de sus
necesidades o las del sistema, para ello se debe especificar los
protocolos para ascender a una cola de mayor prioridad o descender a
una de menor prioridad. Un esquema que explica su funcionamiento
sería:
Donde el proceso llega a la primer cola, con planificación RR de

quantum 8. Si en esas 8 unidades de tiempo utilizó el procesador
completamente, desciende a la cola inferior que tiene una planificación
RR de quantum 16, cediéndole más tiempo de uso de procesador,
siempre y cuando no existan procesos en la cola de nivel superior. Si
ese proceso consumió sus 16 unidades de tiempo, pasa a una última
cola, con planificación FCFS. Los procesos que lleguen a la cola con
planificación FCFS claramente serán CPU-bound, puesto que agotaron
24 unidades de tiempo de ejecución, y de esta forma se favorece a los
procesos IO-bound. Una desventaja de esta cola, es que si tenemos
procesos CPU-bound en las colas de menor prioridad y existe un gran
flujo de procesos IO-bound puede padecer de posposición indefinida.
Esto podemos remediarlo estableciendo un protocolo para subir a las
colas de mayor prioridad a medida que transcurre el tiempo.
2. ¿Qué tareas tiene asignada el cargador (loader) del SO?

Respuesta: El loader es el módulo del SO que se encarga de colocar el código
binario del programa que fue linkeditado por el ensamblador para luego
colocarlo en lo que se denomina cola de entrada, a la espera de ser
despachado a MP para comenzar a ejecutar.
3. Describa la estructura de tablas de página jerárquica (multilevel).

Mencione sus ventajas y desventajas. A su vez, describa qué
componentes permiten mejorar las desventajas.
Respuesta: (ver Feb 2010 - 6). El componente que permite mejorar las
desventajas es tener una TLB, de forma de evitar esos múltiples accesos a
distintos niveles de tabla de página si es que la dirección se encuentra en TLB,
de forma que ante un TLB hit se ahorra los accesos a memoria para consultar
las diferentes páginas de los distintos niveles.
284
Dic 2010
1. Al implementar un algoritmo de planificación (scheduling) round-robin,
¿qué problema se puede presentar con el tamaño del quantum?
Respuesta: La elección del quantum en un planificador RR puede acarrear dos
problemas:
- Si el quantum es muy pequeño, próximo a lo que se demora en
realizar un cambio de contexto, la CPU pasa más tiempo realizando
cambios de contexto que trabajo útil (ejecutar).
- Si el quantum es demasiado grande, la planificación RR puede
degenerarse en una planificación FCFS.
2. Sea un sistema operativo con un algoritmo de planificación expropiativo

(preemptive) round-robin. Un proceso en ejecución se le expropia el
procesador solo si su quantum expira o si termina su ejecución.
Suponiendo que el quantum es 2 y se dispone del siguiente esquema de
procesos:
Proceso Tiempo de Tiempo de
creación cómputo
1 0 5
2 1 4
3 3 1
¿Cuál es el tiempo de retorno (turnaround time)?

¿Cuál es el tiempo de retorno promedio?
Respuesta: Realizando un diagrama de Grant para este tipo de planificador
tenemos:
T T0 T1 T2 T3 T4 T5 T6 T7 T8 T9
CPU P1 P1 P2 P2 P1 P1 P3 P2 P2 P1
Listo - P2 P1 P1,P3 P3,P2 P3,P2 P2,P1 P1 P1 -
Tiempo_retorno (P1) = 10 – 0 = 10
Tiempo_retorno (P2) = 9 – 1 =8
Tiempo_retorno (P3) = 7 – 3 =4
Tiempo_retornoprom = (10 + 8 + 4)/3 = 22/3
3. Explique el modelo working-set utilizado para evitar la hiperpaginación

(trashing).
Respuesta: El modelo working-set se basa en el hecho de que los procesos
trabajan con un conjunto reducido de sus páginas durante cierto lapso de
tiempo. De esta forma, si se puede calcular el conjunto de páginas activas de
cada proceso periódicamente ( – Working Set Size del proceso-i) y con
ello calcular D= entonces sabiendo que disponemos de m-marcos en
MP, si ocurre en algún momento que D > m entonces el sistema entrará en
hiperpaginación ya la cantidad de páginas activas de los procesos supera la
285
cantidad de marcos disponibles, debiendo suspender algún proceso y

despertarlos una vez que se hayan liberado suficientes marcos.
4. Explique cómo funciona el método de asignación indexada para los

sistemas de archivos.
Respuesta: Los métodos de asignación establecen como distribuir los archivos
(sus datos y no sus atributos) en el disco de forma de aprovechar el espacio. El
método de asignación indexada consiste en mantener por cada archivo un
bloque de disco con los índices que apuntan a los bloques que contienen los
datos del archivo. El principal problema de este esquema, es que si el tamaño
del bloque es demasiado pequeño en comparación con el tamaño del archivo,
no podrá contener los suficientes punteros para archivos de gran tamaño.
Como solución tenemos tres estrategias: esquema enlazado, esquema
multinivel o un esquema combinado. En el esquema enlazado se enlazan
varios bloques índice, mientras que en un esquema multinivel se utiliza un
bloque de primer nivel que apunta a bloques de segundo nivel que contienen
los índices que apuntan a los datos (idea generalizable a varios niveles,
aunque con tres niveles es suficiente para representar archivos de gran
tamaño). El problema que acarrea este último esquema es que si el archivo es
pequeño se desperdicia gran cantidad de índices en los bloques (*). El
esquema combinado intenta atacar este problema del esquema multinivel, de
esta forma, si se utilizan por ejemplo 15 punteros por bloque índice, hacemos
que los primeros 12 apunten a bloques directos (con datos del archivo) y los
siguientes 3 apunten a bloques indirectos (que pueden ser, simple, doble o
triple indirección). Este esquema es el empleado en UNIX, conocidos como i-
nodos.
(*) Supongamos que por cada bloque índice podemos alojar 10 punteros,
entonces para n-niveles podremos direccionar 10^n bloques, y si cada bloque
es de 5 Kb, entonces podemos representar archivos de 5*10^n Kb.
5. Describa dos de los principales servicios del subsistema de E/S.

Respuesta: Entre los servicios que brinda el kernel para el subsistema de E/S
encontramos:
- IO-Scheduling: Determina el orden adecuado para ejecutar
solicitudes sobre un dispositivo entre los existentes en el sistema
con el fin de mejorar la performance. De esta forma, cuando una
aplicación de usuario o del kernel solicitan una E/S, el proceso pasa
a la cola de bloqueados del dispositivo en cuestión a la espera del
mismo, esperando a ser seleccionado por parte del kernel.
- Buffering: Es el proceso de colocar y consumir datos de un buffer.
Un buffer es un área de memoria que almacena datos mientras se
transfieren entre dos dispositivos o un dispositivo y aplicación. Entre
las razones para utilizar técnicas de buffering encontramos:
normalizar las velocidades entre dispositivos, adaptarse a la
transferencia de los dispositivos, y mantener la semántica de las
aplicaciones que realizan una E/S.
- Caching: Es el proceso de escribir y leer datos desde una caché.
Una caché es una memoria rápida y volátil que contiene copias de
los datos originales, cuyo objetivo es acceder a los datos en forma
rápida a fin de mejorar la performance. De esta forma, podemos
286
evitar un acceso al dispositivo si el dato solicitado ya está alojado en

memoria.
- Spooling: Es el proceso de colocar y consumir datos desde un
SPOOL. Un SPOOL (Simultaneous Peripherical Operation On-Line)
no es más que un buffer que captura las salidas dirigidas a los
dispositivos de forma que éste pueda procesar los datos sin
intercalar cuando estamos frente a un esquema multiprogramado y
el recurso no es compartido. Un ejemplo típico de ello es una
impresora.
- Tratamiento de Errores: Los dispositivos o la transferencia a ellos
pueden fallar, ya sea en forma transitoria o permanente. El SO debe
ser capaz al menos de detectarlos (indicándolo por medio de un bit),
y en ciertos casos corregirlo o brindar una mayor información sobre
la naturaleza del error.
- Protección de E/S: Haciendo que las instrucciones de E/S sean
privilegiadas.
Feb 2011
1. ¿Qué son las llamadas al sistema (system calls)? Realice un
dibujo/diagrama que muestre como son usados.
Respuesta: Los system calls son la interfaz provista por el kernel para que las
aplicaciones de usuario puedan consumir los distintos servicios que brinda el
SO. Su funcionamiento sigue el siguiente esquema:
2. Describa las características principales de un sistema con micronúcleo

(microkernel).
Respuesta: En la filosofía de diseño de SOs con micokernel, se eliminan todos
aquellos aspectos no esenciales del sistema del kernel y se implementan como
aplicaciones del sistema a nivel usuario. De esta forma, se logra un kernel
reducido (de allí su nombre), cuyos aspectos más relevantes son la
planificación, administración de memoria y comunicación de procesos. Las
principales ventajas de este enfoque es la poratabilidad y escalabilidad, a su
vez, para incorporar un nuevo servicio no es necesario modificar el kernel, sino
que se implementa como aplicación del sistema a nivel usuario. La desventaja
que tiene es que puede tener un peor rendimiento frente a otros enfoques,
puesto que esa carga extra que implica tener aspectos del sistema
287
implementados como aplicación que corren a nivel usuario deben comunicarse

con el kernel para acceder a otras funcionalidades del sistema.
3. Sea un SO que implementa memoria virtual con paginación bajo

demanda, y con direcciones virtuales de 32 bits. La traducción se realiza
a través de 3 niveles de tabla de página, dónde las tablas de páginas de
primer nivel tiene 512 entradas, las de segundo 512 entradas y la de tercer
nivel 16 entradas.
a. Realice un diagrama que muestre cómo se realiza la traducción de
la siguiente dirección virtual
128 33 5 0
Respuesta:
Que puede verse en MP como:
b. ¿Qué tamaño tienen las páginas y marcos?

Respuesta: Ambos tienen un tamaño fijo e igual (Page Size)
predefinido por el HW. En este caso, como la tabla de primer nivel
ocupa 512=2^9 entradas se reservan 9 bits de los 32 para direccionar la
288
tabla de primer nivel. Análogamente, con la tabla de segundo nivel se

reservan otros 9 bits y con la tabla de tercer nivel se reservan 4 bits
(porque tiene 16=2^4 entradas). De esta forma, el desplazamiento
dentro de una página se realiza por medio de 32-9-9-4=10 bits, por lo
que una página es de 2^10b=1Kb.
c. En un sistema con soporte de HW, ¿quién es el encargado de

realizar esta traducción?
Respuesta: La traducción de páginas a marcos, involucrados en la
traducción de memoria virtual a física, es la MMU. De esta forma, cada
proceso mantiene en su PCB dos registros: un PTBR (Page Table Base
Registar) y un PTLR (Page Table Length Register). Cuando el proceso
está ejecutando, estos registros actualizan la MMU indicándole “cómo
funcionar”. Al presentarse una dirección virtual con el par nro_pag|desp,
la MMU primero verifica que el número de página no exceda el rango
(indicado por el PTLR), y luego con ayuda del PTBR debe buscar
dentro de la tabla de página (indizada por el número de página) el
número de marco correspondiente, generando así la dirección física
nro_marco|desp que brinda el lugar de MP donde reside el dato
solicitado.
4. Describa en qué momento se puede realizar la asignación de direcciones

(adress binding).
Respuesta: La asignación de direcciones, o adress binding, se puede realizar
en tres momentos:
- Tiempo de compilación: El programa será asignado a un lugar
específico y conocido de MP. Las direcciones son referenciadas en
forma absoluta.
- Tiempo de carga: El programa será asignado a un lugar de MP al
momento de la carga. Las direcciones son referenciadas en forma
relativa.
- Tiempo de ejecución: El programa podrá variar su ubicación en MP
durante su ejecución. Las direcciones son traducidas a direcciones
físicas en el momento de ser utilizadas. Requiere soporte de HW.
5. Mencione qué métodos de asignación de bloques de datos tienen:

a. FAT (File Allocation Table)
Respuesta: La FAT utiliza el método de asignación enlazada. En este
caso, los archivos mantienen un puntero al bloque donde comienzan los
datos del propio archivo, y cada bloque contiene un puntero al siguiente
bloque del archivo. Esta es la idea que persigue básicamente una FAT,
tabla global que está indizada por los números de sectores, y cuyo
contenido es o bien el índice al próximo bloque, o bien el valor NIL
indicando que el sector está libre (usualmente -1), o bien un valor
especial denominado EOF (usualmente 0) indicando el fin de archivo.
Entre los problemas que acarrea este esquema, vale mencionar que la
búsqueda dentro de un archivo debe hacerse linealmente siguiendo los
punteros en la FAT. Como solución se pueden agrupar bloques (por ej.
tres bloques) para alivianar la búsqueda, pero produce fragmentación
interna. A su vez, es susceptible a diversas fallas, por ejemplo, se
289
pueden encontrar archivos truncos (que no terminen en EOF, sino en

NIL), pueden generarse cadenas circulares o incluso puede que existan
archivos que compartan la cola.
b. I-Nodos (Index Node)

Respuesta: Los i-Nodos utilizan el método de asignación indexada.
Este método consiste en mantener un bloque que alberga los índices de
los bloques de datos del archivo. No genera fragmentación interna, pero
el esquema así planteado presenta la desventaja que acota el tamaño
de un archivo (por ej. si se disponen de 10 índices en el bloque índice,
solo podrá alojar archivos de tamaño 10*tam_bloque bytes), por ello es
que surgen tres esquemas: enlazado, multinivel o combinado. En un
esquema enlazado se guardan los primeros índices para apuntar a los
datos y el último índice para apuntar a otro bloque índice, mientras que
en un esquema multinivel el bloque índice, denominado de primer nivel,
guarda los índices para apuntar a otros bloques índices (de segundo
nivel), que o bien puede contener datos o bien puede tener otro nivel de
indirección (usualmente con 3 niveles ya se pueden alojar archivos de
gran tamaño), pero si la cantidad de niveles es muy grande se genera
un desperdicio de índices. Por ello, UNIX emplea un esquema
combinado para los i-nodos, por ejemplo, de 15 índices en el bloque
índice, los primeros 12 se reservan para apuntar a bloques directos
(contienen datos) mientras que los otros tres se utilizan para apuntar a
otros bloques índice (de primer, segundo y tercer nivel).
Mar 2011
1. Defina y de ventajas y desventajas entre los sistemas simétricos y
asimétricos.
Respuesta: Los sistemas simétricos y asimétricos refieren un tipo de
clasificación de sistemas paralelos o multiprocesadores en función de cómo
ejecutan los procesos. En los sistemas asimétricos tenemos una jerarquía
entre los procesadores, existe un procesador maestro que planifica y asigna las
tareas a los procesadores esclavos, quienes se encargan de las tareas del SO.
Por otro lado, en los sistemas simétricos todos los procesadores realizan las
diferentes tareas concernientes al SO.
La ventaja de los que presenta un multiprocesamiento asimétrico frente a uno
simétrico, es que al tener una jerarquía de procesadores, el procesador
maestro puede equilibrar la carga de procesamiento cuando existen
procesadores trabajando mucho y otros poco. Dado que cada CPU tiene su
propia caché local, esto puede traer aparejado un problema; si un proceso se
encuentra ejecutando en un procesador, pobló sus datos en la caché, y si el
maestro decide que ese proceso cambia de CPU, se debe invalidar la caché
del procesador en el que estaba ejecutando y rellenarla en la caché del
procesador al que fue asignado para no generar inconsistencia en los datos.
Obviamente esta tarea es muy costosa, e impacta en la performance del
sistema, lo cual es una clara desventaja. Por eso se prefiere que un proceso
corra siempre sobre un mismo procesador, conocido como afinidad de
procesador, de forma de evitar este problema.
En cambio, si se mantiene el equilibrio entre los procesadores, una vez que un
proceso corrió sobre un procesador pobló con sus datos esa caché, y si es
290
desalojado, cuando vuelva es probable que esos datos aún estén en la caché
aumentando así la cantidad de hit caché y por tanto la performance del
sistema.
2.
a. Describa el planificador de colas multinivel con retroalimentación
(multilevel feedback queue)
Respuesta: (ver Jul 2010 – 1.c)
b. Los procesos son generalmente clasificados como CPU-bound o

IO-bound. En un planificador que maneja prioridades, ¿a qué clase
de procesos le daría mayor prioridad?
Respuesta: Como regla general, un proceso hará uso de un recurso
con prioridad inversamente proporcional al uso que haga de este. Si
hablamos de un planificador de CPU, se le da prioridad a los procesos
IO-bound, puesto que son procesos que realizan muchas solicitudes de
E/S y no tanto de CPU. Si hablamos de qué procesos serán los que
ejecuten una E/S, los procesos CPU-bound serán los que tengan mayor
prioridad, puesto que realizan pocas solicitudes a dispositivos de E/S.
Siguiendo esta regla, se mejora la performance del sistema.
3. Describa lo que entiende por memoria virtual.

Respuesta: La memoria virtual es un método de asignación de memoria a los
procesos, donde el proceso es alojado en memoria parcialmente. La principal
ventaja de esta técnica es que permite que los procesos sean más grandes
que la memoria principal. Para implementarlo se utilizan técnicas de paginación
bajo demanda, que a diferencia de la paginación estándar, una página no es
cargada en MP desde el disco hasta el momento que sea utilizada. Para ello se
utiliza un lazy-swapper para swapear esas páginas a demanda desde y hacia
disco.
4. Realice un diagrama de una traducción de direcciones de un sistema de

paginación de dos niveles. Mencione registros, componentes de HW y
caché que participan en la traducción.
Respuesta:
En la traducción participan principalmente:
- PTBR – Page Table Base Register: Registro que contiene el

desplazamiento dentro de la MP donde se encuentra la tabla de
página externa. También se cuenta con un PTLR (Page Table
Length Register) que acota la tabla de página para que no invada el
área de memoria de otros procesos.
291
- MMU: Encargada de realizar la traducción. Conoce que bits se

utilizan para consultar la tabla de primer nivel (P1 es el
desplazamiento dentro de la tabla externa, que contiene la dirección
de memoria donde se encuentra la tabla de segundo nivel), la tabla
de segundo nivel (P2 es el desplazamiento dentro de la tabla
interna, que contiene el número de marco correspondiente en MP) y
el desplazamiento dentro de una página.
- TLB – Translation Lookaside Buffer: Es una caché asociativa que
mantiene copias de las entradas de la tabla de página accedidas
recientemente. De esta forma, cuando se presenta una dirección
virtual primero se verifica que esté en TLB, y si es así, se resuleve
desde la TLB, sino debe buscarse en la tabla de página y luego
actualizar el valor en la TLB para futuros accesos. Si la TLB no
cuenta con un campo ASID (Adress Space ID) presenta el
inconveniente de que se debe vaciar la caché ante un cambio de
contexto, sino se podría acceder a área de memoria de otro proceso
por error.
Jul 2011
1. ¿Qué entiende por sistemas simétricos?
Respuesta: Los sistemas simétricos refieren a un tipo de clasificación de los
sistemas paralelos o multiprocesadores en cuanto a cómo ejecutan los
procesos. En estos sistemas, todos los procesadores ejecutan las diferentes
tareas del SO.
2. Realice un diagrama de estado de los procesos y explique las

transiciones entre ellos para un planificador (scheduler) no expropiativo
(non-preemtive).
Respuesta: (ver Feb 2010 - 2)
3. ¿Qué tareas implica un cambio de contexto (context switch) entre

procesos?
Respuesta: (ver Parciales – May 2013 - 3)
4. ¿Qué entiende por fragmentación interna y externa de la memoria?

Respuesta:
- La fragmentación interna se produce en un esquema de asignación
de memoria de tamaño fijo (por ejemplo en paginación), de forma
que si un proceso necesitara n-unidades (por ejemplo páginas) y un
byte, entonces se necesitaría n+1 unidades de MP (siguiendo el
ejemplo serían marcos) para poder alojar al proceso, lo que
generaría que se desperdicie prácticamente una unidad completa de
MP (marco).
- La fragmentación externa se produce en un esquema de asignación
de memoria de tamaño variable (como por ejemplo en
segmentación), generando pequeños huecos en memoria que no
292
pueden alojar a ninguna unidad (siguiendo el ejemplo sería

segmento), pero vista en forma contigua se ganaría un gran espacio.
5. Generalmente el espacio de direccionamiento virtual de un proceso

(virtual adress space) es dividido en diferentes secciones, ¿cuáles son?
¿Qué funcionalidad tiene cada una?
6. En cuanto a diseño, ¿qué ventajas brinda que un SO presente un sistema

de archivos virtual (virtual file system - VFS)?
Respuesta: Si un SO presenta un sistema de archivos virtual (VFS), permite
manipular varios sistemas de archivos distintos. Para ello, se establece una
división en capas donde los agentes involucrados son:
- Interfaz del sistema de archivos: proveen al usuario un conjunto de
operaciones que son habituales en los sistemas de archivos.
- Interfaz del VFS: permite a los usuarios acceder a información
guardad de diferentes modos.
- Sistemas de archivos específico: implementación específica de un
sistema de archivos.
A continuación se muestra como se comunican las diferentes capas para llevar

a cabo su cometido:
7. Describa dos métodos para saber la disposición de los bloques de datos

de un archivo en un sistema de archivos
Respuesta: Existen básicamente tres métodos de disposición de bloques de
datos en un archivo:
- Asignación contigua: En este método, un archivo ocupa cierta
cantidad de bloques consecutivos en disco. Para ello, se mantiene
una referencia al inicio del bloque y el largo del mismo.
- Asignación enlazada: En este método, un archivo tiene todos sus
bloques desparramados por el disco, y cada bloque se enlaza con
su bloque consecutivamente lógico. Para ello, se mantiene una
referencia al bloque de inicio, y el largo del mismo o una referencia
al final.
- Asignación indizada: En este método, un archivo tiene todos sus
bloques desparramados por el disco, pero sus bloques son
293
referenciados a partir de un bloque índice (contiene una tabla con

los números de bloque que forman parte del archivo).
8. Describa dos servicios que brinda el subsistema e E/S.

Respuesta: (ver Dic 2010 - 5)
Dic 2011
1. ¿Qué es un sistema operativo?
Respuesta: Un sistema operativo es un programa que actúa como
intermediario entre las aplicaciones de usuario y el hardware. Es el programa
que está en continúa ejecución, cargado siempre en memoria, cuya porción
residente se denomina núcleo del sistema o kernel.
2. ¿Cómo expone un sistema operativo sus servicios a las aplicaciones?

Respuesta: Un SO expone sus servicios a las aplicaciones por medio de una
interfaz que ofrece el núcleo, denominado system call. Antiguamente eran
escritos en lenguaje ensamblador, pero actualmente suelen escribirse en
lenguajes de alto nivel (como C o C++) cuya consecuencia inmediata es una
comunicación más directa. Un system call es ejecutado por una aplicación en
modo usuario, ejecuta en modo monitor, y al retornar vuelve a modo usuario.
3. ¿Qué entiende que es un programa? ¿un proceso? ¿un thread?

Respuesta: Un programa es simplemente un archivo ejecutable, una colección
de instrucciones a seguir, una entidad pasiva. Un proceso, en cambio, es una
entidad activa. Un programa se transforma en proceso cuando es cargado en
memoria, y tiene un pid (process id), un PC, un conjunto de recursos asignados
y un conjunto de registros. El proceso es la unidad de funcionamiento de un
SO. Un thread, a diferencia de un proceso, es la unidad básica de utilización de
la CPU. Un proceso puede estar compuesto por uno o varios threads (proceso
multithread). Cada thread está compuesto por un PC, un espacio de stack y un
conjunto de registros propios, y comparte con sus threads hermanos la sección
de código, datos y recursos asignados.
4. Describa el planificador (scheduler) de colas multinivel con

retroalimentación (multilevel feedback queue).
5. ¿Qué entiende por memoria virtual?

Respuesta: (ver Mar 2011 - 3)
6.
a. ¿Cuándo se ejecuta un algoritmo de reemplazo de página?
Respuesta: Un algoritmo de reemplazo de página se ejecuta cuando
ocurre un page fault y no existen marcos disponibles para alojar la
página solicitada, ya sea en un reemplazo global (la víctima se
selecciona entre todas las disponibles) o local (la víctima se selecciona
dentro de los marcos asignados al proceso que provocó el page fault).
294
De esta forma, luego de reemplazar la página se reinicia la instrucción

que generó el fallo.
b. ¿Qué dice la anomalía de Belady?

Respuesta: La anomalía de Belady establece que no siempre se
reducen la cantidad de fallos de página al asignarle más marcos a un
proceso, sino que puede incrementar. El algoritmo de reemplazo FIFO
sufre de esta anomalía.
c. Describa el algoritmo de segunda chance

Respuesta: El algoritmo de segunda chance, o también conocido como
algoritmo del reloj, es un algoritmo de reemplazo de página que utiliza
un bit de referencia por cada marco. Este bit es seteado en 1 cada vez
que se hace referencia a su página asociada. Al momento de
seleccionar una víctima, se recorren todos los marcos circularmente
apagando aquellos bits que estén en 1 hasta encontrar el primero que
tenga el bit en 0. Por eso recibe el nombre de segunda oportunidad, ya
que primero se intenta apagar el bit de referencia ante la búsqueda de
la víctima.
7. ¿Para qué sirve la paginación bajo demanda?

Respuesta: La paginación bajo demanda sirve para implementar un esquema
de memoria virtual. (por más detalle ver Mar 2011 - 3)
8. ¿Qué entiende por RAID 0?

Respuesta: El RAID 0 es uno de los siete niveles de RAID (Redundant Array
of Independient Disks) vistos en el curso. Este nivel se caracteriza por apuntar
a mejorar la performance sin importar la confiabilidad. Para ello utiliza
únicamente técnicas de striping, donde se distribuye el cómputo entre varios
discos a una granularidad dada (byte, bloque, etc). De esa forma, se puede
acceder a un dato leyendo en paralelo todos los discos, ahorrando el tiempo
que se necesitaría si se accediera al mismo dato en forma secuencial.
9. El caching es un servicio que brinda el SO, ¿en qué subsistema se

encuentra? ¿Para qué sirve?
Respuesta: El caching es un servicio que brinda el SO a nivel del subsistema
de E/S. (por más detalle ver Dic 2010 - 5)
Feb 2012
1. ¿Qué es un sistema multiprogramado y cuál es la principal ventaja de
desarrollar un sistema de este tipo?
Respuesta: Un sistema multiprogramado es aquel que cuenta con un conjunto
de tareas en memoria, y se multiplexa la CPU entre ellos a fin de obtener
mejores tiempos de respuesta y maximizar el uso de la CPU. De esta forma,
cuando un proceso realiza una llamada bloqueante al sistema, la CPU no
queda ociosa en espera de una respuesta, sino que se conmuta la CPU a otro
proceso.
2. ¿Qué ventaja tiene un sistema simétrico frente a uno asimétrico?
295
Respuesta: La principal ventaja de los sistemas simétricos frente a los

asimétricos es que los primeros ejecutan todas las tareas referentes al SO
indistintamente. En un sistema con multiprocesamiento asimétrico, estas
tareas son asignadas a los procesadores esclavos por el procesador maestro.
3. ¿Qué es el registro “program counter” de un proceso? ¿y de un hilo

(thread)?
Respuesta: En ambos casos se está hablando de lo mismo. El program
counter (PC) es un registro particular que contiene un puntero a la instrucción
que está siendo ejecutada dentro del código en el procesador. Un proceso
podemos verlo como un proceso single-thread, con un único PC. A nivel de un
proceso multi-thread, existen tantos PCs como threads se hayan creado,
puesto que cada thread contiene su propio PC, espacio de stack y registros, y
comparten con sus hilos pares la sección de código, datos y recursos
asignados.
4. Sea un sistema con paginación, realice un diagrama de una traducción de

una dirección virtual de 32 bits con 2 niveles de tabla de página. Tome en
cuenta que la tabla de página de primer nivel tiene 2048 entradas y las
tablas de página de segundo nivel tienen 1024 entradas.
Respuesta: Dado que la tabla de primer nivel contiene 2048 = 2^11 entradas,
éstas son direccionables con 11 bits. Por otro lado, la tabla de página de
segundo nivel contiene 1024 = 2^10 entradas direccionables con 10 bits, por
tanto el esquema resulta:
5. ¿Cuáles son las ventajas de la segmentación frente a la paginación?

Respuesta: La segmentación es un esquema de asignación de memoria en un
proceso, al igual que la paginación. La segmentación, a diferencia de la
paginación, es un esquema de asignación de tamaño variable, donde las
unidades de asignación son denominados segmentos. Un segmento se
corresponde con la visión que tiene el usuario de los programas, donde
usualmente éste se compone de un programa principal, conjunto de subrutinas
y funciones, etc. Precisamente esta es la ventaja de la segmentación frente a la
paginación, que apoya la visión que tiene el usuario de los programas.
También podemos mencionar que la segmentación no padece fragmentación
interna como la paginación (pero si puede sufrir fragmentación externa).
Además, compartir memoria entre procesos es más simple ya que se comparte
todo un segmento como unidad, y no página a página como en la paginación.
296
6. Sea un sistema de archivos con inodos (tipo UNIX). Describa cómo se

obtiene el número de inodo de archivo.txt siendo su path el siguiente
/a/b/archivo.txt
Respuesta: Partiendo del inodo número 0, que se corresponde con el
directorio raíz, se busca el número de inodo correspondiente al directorio “a”
dentro de la tabla de dir_entry (haciendo una lectura en disco). Análogamente,
se busca el directorio “b” dentro del directorio “a”. Finalmente, y análogamente
a los casos anteriores, se busca el archivo con nombre “archivo” y extensión
“txt” dentro de la tabla de dir_entry, y mediante él se puede obtener el número
de inodo buscado. Cabe mencionar que las búsquedas verifican la existencia
de cada archivo/directorio dentro del directorio en cuestión siguiendo el path y
se asume que una lectura de disco no falla.
7. ¿Hasta cuántos discos se pueden romper en un RAID 5 (Redundant Array

of Inexpensive Disk) sin que el sistema pierda la indespionibilidad? ¿Se
tiene degradación en esa situación?
Respuesta: Se puede romper hasta un disco, ya que RAID 5 ofrece una
mejora de la performance por striping a nivel de bloque y confiabilidad a través
de un único bloque de paridad, distribuido (rotativamente) entre todos los
discos. Particularmente, si fallase una cantidad par de discos simultáneamente
no se detectarían fallas (pues el bloque de paridad no cambiaría), y si fallan
más de dos, no se podrían recuperar los datos a partir del bloque de paridad.
Si falla un único disco, no existe degradación en el sistema, porque los datos
pueden ser recuperados a partir del bloque de paridad.
Mar 2012
1. ¿Qué problema presenta un sistema que no sea multiprogramado?
Respuesta: Si un sistema carece de multiprogramación, cuando un proceso
está siendo ejecutado y realiza una llamada bloqueante al sistema, la CPU se
mantendrá ociosa hasta que se terminé de procesar el pedido, puesto que no
conmuta a otra tarea mientras se está realizando el pedido. La consecuencia
directa de esto, es que la ausencia de multiprogramación genera un alto
impacto en la performance del sistema.
2. Realice un esquema donde se muestre el PCB (Process Control Block) de

dos hilos (threads) de un mismo proceso. Detalle los campos que
considere importante.
Respuesta:
Ambos threads comparten:

- Código
- Datos
- Recursos asignados
Cada uno de ellos posee:
- Registros
- Stack
- PC
297
3. Realice un diagrama de los estados y sus transiciones que los procesos

tiene dentro del sistema operativo. Describa brevemente cada
componente.
4. ¿Qué entiende por planificador expropiativo (preemtive scheduler)? ¿Qué

problema resuelve este tipo de planificador?
Respuesta: Sabemos que el planificador es llamado forzosamente cuando un
proceso realiza las transiciones ExecuteTerminated y ExecuteWaiting. Si
además, el planificador es invocado cuando un proceso atraviesa las
transiciones ExecuteReady y WaitingReady, entonces diremos que el
planificador es expropiativo. Este tipo de planificación resuelve el problema de
las prioridades, dado que si llega un proceso con mayor prioridad y debe ser
atendido con urgencia, se le expropia el procesador al proceso que estaba
corriendo y ejecuta este proceso nuevo, ya sea porque el proceso que llego es
de vital importancia para el sistema o porque es IO-bound.
5. ¿Por cuáles etapas debe pasar un código fuente escrito en lenguaje C

hasta convertirse en un proceso de un SO?
Respuesta: Debe pasar básicamente por tres etapas:
- 1. Compilación: Traducción de código fuente a código objeto. Este
código aún no es ejecutable, pues pueden el código fuente puede
haber incluido bibliotecas u otros módulos, que sin ellos, no podría
funcionar correctamente. El módulo responsable de esta tarea
recibe el nombre de Compilador.
- 2. Linkedición: Se unen varios códigos objetos correspondientes a
varios módulos en un único código objeto. El módulo responsable de
esta tarea es el Ensamblador o Linkeditor. Este código es guardado
en disco como código objeto en binario ejecutable.
- 3. Carga: Coloca el binario ejecutable en la cola de entrada a la
espera de ser cargado en memoria. El módulo responsable de esta
tarea se denomina Loader y forma parte del SO.
6. ¿Cuál método de asignación tiene un sistema de archivos FAT (File

Allocation Table)? ¿Cuál tiene un sistema de archivos con I-Nodos (Index
Node)?
Respuesta: (ver Feb 2011 - 5.a) y (ver Feb 2011 - 5.b)
7. Describa los campos principales de una estructura de datos para

representar un archivo en una FAT.
Respuesta: Par representar archivos en una FAT se mantiene un arreglo en el
FileSystem cuyos elementos son una estructura de datos que debe contener al
menos:
- Nombre del archivo
- Extensión del archivo
- Bit que indique si la entrada está siendo usada
- Bit que indique si la entrada corresponde a un archivo o directorio
298
- Índice de inicio en la fat (indefinido si se trata de un directorio)

- Tamaño del archivo (indefinido si se trata de un directorio)
- Índice dentro del file system (útil para el caso de directorios
anidados)
Resultando así algo del estilo:
8. Describa los métodos de E/S Programada y con Interrupciones, y

mencione la ventaja que presenta el método con interrupciones sobre el
programado.
Jul 2012
1. Describa que entiende por sistema con multiprocesamiento simétrico
(SMP – Symetic Multi-Processing)
Respuesta: (ver Jul 2011 - 1)
2. ¿Cómo se implementa generalmente la protección de CPU?

Respuesta: Para evitar que un proceso entre en loop infinito y nunca devuelva
el control de la CPU, generalmente se dispone de timmer a nivel de hardware
que genera una interrupción, y el SO es el encargado de decidir si cederle más
tiempo al proceso o expropiarle el procesador.
3. ¿Qué estado debe tener un proceso para poder ser seleccionado por el
planificador (scheduler) del sistema operativo?
Respuesta: Para que un proceso pueda ser seleccionado por el planificador
del SO, el proceso debe estar en estado pronto. (ver diagrama de estados y
transiciones en examen Feb 2010 – 2).
4. Describa el planificador de colas multinivel con retroalimentación

(multilevel feedback queue).
5. Dos hilos que pertenecen a diferentes procesos ¿qué cosas comparten?

Justifique.
299
Respuesta: Absolutamente nada. Dos threads de procesos diferentes no

forman parte de un mismo PCB, por tanto, se consideran como hilos de
procesos diferentes.
6. Describa que entiende por memoria virtual.

7. ¿Para qué es utilizado la pila y el heap de un proceso?

8. Describa cómo se representan los datos de un archivo en un sistema

tipo:
a. FAT (File Allocation Table)
Respuesta: (ver Feb 2011 - 5.a)
b. I-Nodo (Index Node)

Respuesta: (ver Feb 2011 - 5.b)
9. ¿Para qué sirve el servicio de buffering que brinda el subsistema de E/S?

Respuesta: (ver Parciales - Jul 2013 - 3)
Dic 2012
1. ¿Cuál es el principal beneficio de la multiprogramación?
Respuesta: El principal beneficio de la multiprogramación es aprovechar al
máximo el uso de la CPU (ver Mar 2010 - 1)
2. ¿Qué es un sistema operativo y qué son las llamadas al sistema (system

call)?
Respuesta: (ver Dic 2011 – 1 y Feb 2011 - 1)
3. Describa lo que entiende por sistemas operativos monolítico y de

micronúcleo.
Respuesta: Un SO monolítico es una filosofía de diseño de SOs que no tiene
una estructura bien definida, donde las interfaces y funcionalidades no están
bien separadas. Se presentan como una colección de procedimientos públicos
que los usuarios pueden invocar. La principal desventaja que presentan es su
depuración y mantenimiento, sin embargo es posible conseguir buenos
diseños. Su principal ventaja es que casi no consumen overhead, puesto que
no necesitan comunicarse con diversas capas para acceder al hardware (como
en un SO en capas).
Por otro lado, los SO de micronúcleo son una filosofía de diseño de SOs que
eliminan todo aspecto no esencial del kernel y lo implementan como
aplicaciones del sistema a nivel usuario. De esta forma, se logra un kernel
reducido (de allí su nombre) encargado principalmente de la Planificación,
Administración de Memoria y la Comunicación entre Procesos. Este esquema
logra una mayor portabilidad y escalabilidad. A su vez, si se desea incorporar
una nueva funcionalidad no es necesario modificar el kernel, sino que se lo
implementa como aplicación a nivel de usuario. La desventaja que presenta es
300
que puede llegar a tener un peor desempeño que otros esquemas, puesto que
las funcionalidades del kernel implementadas “por fuera” necesitan invocar al
kernel.
4. Describa 8 campos del bloque descriptor de un proceso (PCB – Process

Control Block).
Respuesta: El PCB es la estructura con la que el SO representa a los
procesos. Entre sus campos más relevantes encontramos:
- PID (process id)
- Estado, como puede ser listo, ejecutando, bloqueado, terminado
- Valor de PC
- Valor de los registros
- Información acerca la administración de memoria, como registros
base y límite
- Recursos asignados, como la lista de archivos abiertos
- Información contable, como el tiempo que lleva ejecutando
- Puntero al proceso ancestro (padre)
- Lista de procesos descendiente (hijos)
5. ¿Qué entiende por planificador expropiativo (preemptive scheduler)?

6. Describa las tres asociaciones de direcciones de memoria vistas en el

curso.
Respuesta: (ver Mar 2012 – 5)[Compilación, Ensamblaje y Carga] y (ver Feb
2011 - 4)[Tiempos de Compilación, Ejecución y Carga]
7. Describa el problema de la hiperpaginación y un método para

solucionarlo.
Respuesta: La hiperpaginación, o trashing, es un fenómeno que ocurre cuando
existe una alta tasa de fallos de página, generando una caída en el uso de
CPU, y en un intento por aumentar el nivel de multiprogramación la situación
empeora. En el curso vimos dos métodos para solucionarlo:
- Modelo Working-Set: (ver Dic 2010 - 3)
- Modelo Page Fault Frequently: Este modelo se basa en el hecho de
el trashing se produce cuando existe una alta tasa de fallos de
página. Cuando es demasiada alta, sabemos que un proceso
necesita más marcos de los asignados, y cuando es baja puede que
el proceso tenga demasiados marcos asignados. Por lo tanto, la
idea es establecer un umbral acotado superior/inferiormente
(UH/UL), y cuando la frecuencia es mayor/menor a este umbral el
proceso puede necesitar/liberar marcos.
8. Describa dos métodos para la administración del espacio libre en un

301
9. ¿Qué beneficios brinda la planificación de disco y describa dos métodos

de planificación?
Respuesta: (ver Parcial - Jul 2012 - 3). Los métodos de planificación vistos en
el curso son:
- FIFO: Las solicitudes de disco se atienden por orden de llegada.
Este algoritmo no siempre es el mejor, ya que generalmente implica
un mayor movimiento de cabezales.
- SSTF (Shortest Seek Time First): Se atienden todas las solicitudes
cercanas a la posición actual del cabezal. Como todo lo que
empieza por “short”, este método de planificación puede sufrir de
posposición indefinida.
- SCAN/C-SCAN: El método SCAN también es conocido como
“algoritmo del ascensor”. Realiza un movimiento de cabezales de un
extremo a otro, atendiendo todas aquellas solicitudes en su camino,
y al llegar a un extremo invierte su sentido de movimiento. El
inconveniente de este esquema es que al invertir de sentido del
movimiento del cabezal habrán pocas solicitudes que atender
(porque fueron atendidas recientemente) y genera una sobrecarga
en el extremo opuesto. Para ello, C-SCAN es la versión de SCAN
pero circular, de forma que al llegar a un extremo, no invierte el
sentido de movimiento, sino que se desplaza hacia el otro extremo
sin atender solicitudes.
- LOOK/C-LOOK: Estos algoritmos son una variación de SCAN/C-
SCAN, pero que únicamente atienden solicitudes en su recorrida si
es que las hay. Para ello, primero “miran” si hay solicitudes a
continuación, y si no las hay invierte su sentido (LOOK) o busca la
primer solicitud pendiente próxima al otro extremo (C-LOOK).
Feb 2013
1. Describa los sistemas de multiprocesadores simétricos y asimétricos.
Respuesta: (ver Marzo 2011 - 1)
2. ¿Qué es y cuales ventajas propone un sistema de tiempo compartido?

3. ¿Qué permite el modo dual de ejecución que brindan ciertos

microprocesadores?
Respuesta: El modo dual de ejecución, como lo indica su nombre, permite
distinguir entre dos modos de ejecución: Modo Usuario y Modo Monitor. Se
realiza a nivel de hardware mediante un bit de modo llamado MODE BIT. En
Modo Usuario se cuenta con un conjunto reducido de instrucciones que el
usuario puede realizar, mientras que en Modo Monitor todas las instrucciones
están disponibles, incluyendo a las instrucciones que denominamos
“privilegiadas”. El SO es el único que puede ejecutar en modo monitor.
302
4. Dada las características de los procesadores actuales (multi-core) ¿qué

ventaja presenta un sistema operativo que tenga soporte de hilos
(threads) a nivel del sistema operativo frente a otro que no lo tenga?
Respuesta: Si un SO soporta hilos a nivel del kernel, cuando un User Thread
realiza una llamada bloqueante al sistema, no se bloquea todo el proceso, sino
que se planifica otro Kernel Thread, ya que el SO reconoce tantos hilos de
ejecución como Kernel Threads se hayan creado. Esto puede darse en un
esquema 1x1 o MxN. A su vez, si se dispone de un sistema multiprocesador,
se pueden ejecutar tantos threads en paralelo como Kernel Threads haya
creado y procesadores disponga. En un sistema sin soporte de Kernel Threads,
el único esquema aplicable es el Mx1, en este caso el SO reconoce solo un hilo
de ejecución, y si un User Thread realiza una llamada bloqueante al sistema, el
proceso entero se bloquea.
5. ¿De qué se encarga el cargador (loader) del SO?

Respuesta: El Loader del SO es responsable precisamente de realiza la
función de carga, en otras palabras, llevar el programa objeto (guardado en
binario ejecutable en disco) a la memoria para su ejecución. Para ello, el
Loader coloca este archivo en lo que se denomina cola de entrada, a la espera
de ser seleccionado y despachado por el SO para ser cargado en memoria a
fin de empezar su ejecución.
6. En general, los SO modernos de propósito general dividen el espacio

virtual de los procesos en varios componentes. Mencione estos
componentes y su función.
7. Compare un esquema de paginación que utiliza varios niveles de tabla de

páginas (digamos 3 niveles) contra un sistema de paginación que utiliza
solamente un nivel para la tabla de página.
8. ¿Qué es la TLB, cuál es su función y qué sucede con ella cuando hay un
cambio de contexto entre dos procesos distintos?
9. En el subsistema de E/S, describa dos métodos que se pueden utilizar

para efectuar una E/S.
Mar 2013
1. ¿Qué es un sistema operativo?
2. ¿Cómo se implementa y para qué sirve la protección de CPU?

3. ¿Qué entiende por planificador expropiativo?

303
4. Un sistema cuenta con tres tipos de procesos: de tiempo real,

procesamiento por lotes (batch) y de usuario. Desarrolle un algoritmo de
planificación adecuado para este sistema, mencionando las
características más relevantes.
Respuesta: Dado que podemos distinguir a los procesos en tres distintas
categorías, podemos utilizar un esquema de colas multinivel con tres colas.
- La cola de mayor prioridad será para los procesos de tiempo real, ya
que el resultado debe entregarse dentro de cierto margen temporal,
no pueden ser demorados. Esta cola tendrá planificación no
expropiativa, porque cuando estos procesos ejecutan lo hacen por
un tiempo corto.
- La cola intermedia será para los procesos de usuario, ya que estos
si usan el sistema no lo hacen las 24 horas, ni microsegundo a
microsegundo, pero esperan una respuesta rápida del sistema. En el
caso más general, si tenemos un sistema multiusuario lo ideal sería
que la planificación expropiativa, de forma de satisfacen a todos los
usuarios del sistema dependiendo de sus prioridades.
- La cola de menor prioridad será para los procesos batch, ya que
estos pueden llegar a ser de larga duración, y generalmente no
tienen apuro por recibir una respuesta. Por esto, un planificador no
expropiativo sería idea.
5.
a. Describa la etapa de ensamblaje (link-edición) en el proceso de
generar el archivo ejecutable (binario).
b. Compare ventajas/desventajas de usar librerías dinámicas o

estáticas.
Respuesta:
Librerías Estáticas Librerías Dinámicas
Durante el proceso de linkedición
solamente se unirán los módulos
El proceso de linkedición une
objeto del proceso. Durante el
los módulos objetos del
proceso de carga, se guarda lugar
proceso junto con el módulo de
para incorporar las librerías que
la librería en un único módulo
serán cargadas a demanda. La
objeto guardado en disco como
Ventajas consecuencia y ventaja de ello es
archivo binario ejecutable. Esto
que no se reserva memoria para
logra que los procesos
alojar la biblioteca a menos que
independicen estas bibliotecas
sea utilizada y además permite
para su uso, siendo “locales” al
que los procesos que utilicen la
proceso.
librería puedan compartirla,
actualizándola.
Dado que varios procesos
pueden incluir las mismas No logra independizar las
bibliotecas, estas bibliotecas se bibliotecas entre los procesos que
Desventajas encontrarán varias veces en la utilizan, éstas podrían verse
MP al momento de la carga, como “globales”.
ocupando lugar.
304
6. ¿Qué entiende por paginación bajo demanda (demand paging)?

7.
a. ¿Cuándo son ejecutados los algoritmos de reemplazo de marcos?
Respuesta: (ver Dic 2011 – 6.a)
b. Describa el algoritmo de reemplazo LRU.

Respuesta: Esta estrategia, selecciona como marco víctima aquella
que no haya sido utilizada hace más tiempo (de allí su nombre, LRU –
Least Recently Used). Para ello, cada marco debe contener un registro
del tiempo que fue utilizado por última vez. Su implementación no es
sencilla, generalmente utilizan contadores o una pila. Sin embargo, una
idea sencilla es utilizar la idea del algoritmo second chance, pero en vez
de mantener un bit de referencia, se mantiene una palabra de
referencia. En un esquema como este, un acceso a la página apaga el
primer bit y un timmer se encarga de shiftear un lugar a la derecha, de
forma que la palabra de referencia leída como un entero indicaría hace
cuánto tiempo que fue accedida la página.
8.
a. ¿Para qué sirven los servicios del subsistema de E/S que brinda el
SO?
Respuesta: Los servicios del subsistema de E/S expuestas por el
kernel se utilizan para abstraer los dispositivos y utilizarlos de manera
uniforme y estandarizada, teniendo en cuenta el impacto que podría
tener sobre la performance del sistema. Para ello, el SO brinda: (ver Dic
2010 - 5)
b. Describa uno de los principales servicios del subsistema de E/S.

9. ¿Qué ventajas brindan los sistemas RAID?

Jul 2013
1.
a. ¿Cuál es la diferencia entre un sistema multiprocesador de
memoria compartida y uno de memoria distribuida?
Respuesta: En un sistema multiprocesador de memoria compartida los
procesadores se encuentran en un único nodo, y se comunican con la
memoria a través de un bus común. En cambio, en un sistema
multiprocesador de memoria distribuida los procesadores se encuentran
en nodos distintos, cada uno con su memoria, y se comunican entre sí a
través de una red.
305
b. ¿Cuál es la diferencia entre un sistema de tiempo real hard y soft?

Respuesta: En los sistemas de tiempo real, cierto contenido debe
entregarse al usuario dentro de un margen temporal establecido, de lo
contrario el sistema falla. En un sistema de tiempo real tipo hard, las
tareas críticas deben terminar a tiempo, el cumplimiento de los plazos
es estricto, no se pueden retrasar. En cambio, en un sistema de tiempo
real tipo soft, una tarea crítica tiene prioridad respecto a otras, pero no
apoya el cumplimiento estricto de los plazos.
2. Mencione los servicios fundamentales del sistema operativo

concernientes a la administración de procesos.
Respuesta: El SO, referente a la administración de procesos, es responsable
de:
- Crear/Eliminar procesos
- Suspender/Reanudar procesos
- Proveer mecanismos para la Sincronización y Comunicación de
procesos
- Proveer mecanismos para el Tratamiento de Deadlocks
3. ¿Qué entiende por planificador no expropiativo (non-preemtive

scheduler)? ¿Cuál es su principal desventaja respecto a un planificador
expropiativo?
Respuesta: Un planificador no expropiativo es un planificador donde no existe
una transición de ExecuteReady, y a su vez no se invoca al planificador
cuando un proceso atraviesa por la transición de WaitingReady. El
planificador solo es invocado cuando el proceso que corre en la CPU lo
abandona voluntariamente, ya sea porque terminó (ExecuteTerminated) o
porque se bloqueó esperando un evento (ExecuteReady). La principal
desventaja que presenta este tipo de planificador frente a un planificador
expropiativo es que un proceso puede hacer uso de la CPU por el tiempo que
desee.
4. Menciona las tareas que deben realizarse para ejecutar una llamada al
sistema (system call) e indique en cada caso quién realiza dicha tarea
(programador/sistema operativo/ hardware subyacente)
Respuesta: Las tareas que deben realizarse para ejecutar un system call son:
- Colocar los parámetros necesarios – Programador
- Colocar el número de system call – Programador
- Invocar a la trap adecuada (system call handler) – Programador
- Pasar a modo monitor – SO
- Verificar que el número de system call pasado sea menor que el
mayor existente en el sistema – SO
- Invocar al system call correspondiente – SO
- Retornar el valor del system call en algún registro en particular, de la
misma forma en cómo se cargó – Hardware
- Volver a modo usuario -- SO
5. Indique los métodos de asociación de direcciones (adress binding) y

mencione el soporte de HW necesario para su implementación.
306
Respuesta: Los métodos de asignación de direcciones, o adress binding, se

puede dar en tres tiempos:
- Tiempo de compilación: El programa será asignado en un lugar fijo y
conocido de memoria. Las direcciones son referenciadas en forma
absoluta. No requiere soporte especial de HW.
- Tiempo de carga: El programa será asignado en memoria al
momento de la carga. Las direcciones son referenciadas en forma
relativa. No requiere soporte especial de HW.
- Tiempo de ejecución: Un programa puede cambiar su ubicación en
memoria durante su ejecución. Requiere soporte especial de HW, la
MMU, encargada de realizar la traducción de direcciones virtuales a
físicas.
6. Describa y compare los métodos de asignación de datos de archivos

contiguo e indexado.
7.
a. Describa los registros que componen un puerto de E/S e indica
para que son utilizados estos registros
Respuesta: Los registros que componen un puerto de E/S son
básicamente cuatro:
- Estado: Registro leído por el equipo informando el estado del
dispositivo.
- Control: Registro escrito por el equipo para múltiples propósitos.
Entre ellos configurar el dispositivo ante un pedido, cambiar el modo
del dispositivo, etc.
- Datos de Entrada: Registro leído por el equipo para obtener los
datos de entrada.
- Datos de Salida: Registro escrito por el dispositivo para enviar datos
en una salida.
b. Indique dos métodos para efectuar una E/S.

8.
a. Describa dos métodos para mantener el espacio libre en un
Respuesta: Los métodos para mantener el espacio libre en un sistema
de archivos son básicamente cuatro:
- Mapa de bits: Se mantiene un vector de bits indizado por el número
de bloque. De esta forma, podemos diferenciar qué bloques están
siendo usadas o no usadas.
- Lista enlazada de bloques libres: Los bloques libres se enlazan entre
si y se mantiene una referencia al primer bloque libre.
- Agrupación: Se mantiene una referencia a un bloque libre que
almacena las direcciones de n-1 bloques efectivamente libres y la
última dirección hace referencia otro bloque con las mismas
características que éste.
307
- Conteo: Se mantiene una lista enlazada, cuyos elementos apuntan a

unidades libres de almacenamiento y además contienen la cantidad
de unidades libres contiguas a él.
b. Indique qué información mantiene el bloque de control de parición

(Partittion Control Block) en un sistema de archivos.
Respuesta: El bloque de control de partición contiene la cantidad de
bloques de la partición y además brinda información del tamaño de
cada una, si está libre/usada, punteros a FBC y contador de FBC libres,
entre otras.
Dic 2013
1.
a. Indique dos métodos de acceso a los registros de un controlador
de E/S
Respuesta: Los dos métodos de acceso a los registros de un
controlador de E/S son:
- Memory Mapped IO: Se accede a estos registros a través de
direcciones de memoria especiales. Para la lectura/escritura de
estas direcciones se utilizan las mismas instrucciones que un
acceso a memoria convencional. Tiene la ventaja de no tener
instrucciones especiales, pero la desventaja de reducir el rango de
memoria para los procesos, que a su vez debe ser protegida para
que los usuarios no tengan acceso a estos registros directamente.
- Direct Instruction IO: El SO provee instrucciones para tener acceso a
estos registros, generalmente IN/OUT. La ventaja que tiene respecto
al caso anterior es que todo el rango de memoria queda destinado a
los procesos, y la desventaja es que dichas instrucciones deben ser
privilegiadas.
b. Indique dos métodos para efectuar una operación de E/S.

Respuesta: (ver Parcial Mayo 2013 - 1)
2. Mencione los servicios fundamentales del sistema operativo concerniente

a la administración de memoria.
Respuesta: La memoria principal es una gran matriz de palabras o bytes.
Dado que un programa para poder ser ejecutado debe estar previamente
cargado, es preciso que el SO mantenga una administración de la memoria
principal. Para ello el SO se encarga de:
- Ver qué partes de memoria están siendo utilizadas y por quién.
- Decidir qué procesos cargar en memoria cuando se disponga de
espacio
- Asignar y liberar memoria según se necesite
3. Describa y compare los diseños de sistemas operativos monolítico y en

capas.
308
Respuesta: El diseño de SO monolítico no tiene una estructura definida, las

interfaces y funcionalidades no están bien separadas. Se presentan como una
colección de procedimientos públicos que el usuario puede invocar. Tiene la
ventaja que al invocar las operaciones directamente, casi no consume
overhead. La gran desventaja que acarrean es su difícil mantenimiento y
depuración.
El diseño de SO en capas propone, si se cuenta con el hardware apropiado,
modularizar las funcionalidades en capas, de forma si tenemos un SO de N
capas, la capa 0 sea el hardware y la capa N-1 sea la interfaz con el usuario. A
su vez, cada capa es la representación de un objeto abstracto, manipulado por
una serie de operaciones. Dada una capa M, esta puede invocar a funciones
de las capas inferiores, y puede ser invocada desde capas superiores. Sus
principales ventajas son que simplifica la depuración y manutención, e
incorporan abstracción. Entre sus desventajas encontramos la difícil tarea de
seleccionar las capas en forma adecuada, y a su vez el costo extra que se
produce cuando un proceso solicita a la interfaz de usuario un pedido y esta
viaja entre las diversas capas hasta llegar al hardware, en otras palabras,
acarrea un gran overhead que impacta en la performance.
Podemos ver al sistema monolítico como un sistema en capas de una única
capa.
4.
a. Describa y compare los hipervisores tipo I y tipo II:
Respuesta: Tanto los hipervisores de tipo I como los de tipo II son dos
técnicas utilizadas para permitir virtualización. Un esquema de hipervisor
tipo I trabaja bajo las condiciones de Popek&Goldberg, que establece que
las instrucciones sensibles (aquellas que modifican el estado privilegiado o
lo exponen) deben ser un subconjunto de las instrucciones privilegiadas; y
se tiene únicamente un VMM por encima de la capa de HW, sobre el cual
se pueden correr las MVs, cada una con su propio SO (denominados
Guest). Este esquema utiliza técnicas de trap-and-emulate, donde las
instrucciones sensibles provocan una trap, que es emulada por el VMM. En
cambio, los hipervisores tipo II funcionan también sobre aquellas
arquitecturas que no cumplen la condición de Popek&Goldberg, y sobre la
capa de HW encontramos un SO (denominado Host) que corre la VMM
como aplicación de usuario (donde corren las MV, cada una con su SO-
Guest) y además otras aplicaciones sobre ese SO. Este esquema utiliza
usualmente una técnica de traducción binaria, donde el VMM analiza el flujo
de instrucciones y traduce aquellas instrucciones sensibles que son
ejecutadas por la CPU directamente.
b. Indique ventajas y desventajas del uso de máquinas virtuales:

Respuesta: Las principales ventajas del uso de MV son
- Seguridad: los procesos en cada MV son independientes entre si
- Facilidad de desarrollo: se puede correr un SO a modo de test sin
tener perjuicios reales
- Flexibilidad: se puede correr un SO en una arquitectura diferente
- Alta disponibilidad: En caso de una falla en la MV, se puede levantar
otra.
Las principales desventajas
309
- Las operaciones pueden tardar un poco más que en una máquina

real, dado que las instrucciones deben ser interpretadas.
5.
a. Describa las tareas que debe hacer un sistema operativo para
realizar el cambio de contexto de un proceso a otro
Respuesta: (ver Parcial May 2013 - 3)
b. Mencione 3 ventajas en el uso de threads

Respuesta: Tres ventajas del uso de threads son:
- Se logran mejores tiempo de respuesta al tener varios threads en
ejecución
- Los threads de un mismo proceso pueden compartir los recursos,
siendo innecesario el IPC a nivel de threads
- Economía, ya que es más liviano crear un thread pues solo se debe
crear un nuevo PC, un espacio de pila y registros. El cambio de
contexto entre threads también es más liviano que el cambio de
contexto entre procesos. A su vez, es más liviano eliminar un thread,
eliminando únicamente su PC, espacio de pila y registros.
6.
a. Describa el algoritmo de planificación Multilevel Feedback Queue
(Cola multinivel con retroalimentación)
Respuesta: (ver Jul 2010 – 1c)
b. Mencione las tareas que realiza un planificador de largo plazo

Respuesta: El planificador a largo plazo se encarga de decidir qué
programas pueden ejecutar y cuántos a la vez, sin necesidad de
cargarlos en memoria.
7. Describa el algoritmo de reemplazo de segunda oportunidad mejorado

(NRU)
Respuesta: (ver Parciales - Jul 2013 - 1)
8. Describa el nivel 1 de RAID. Indique un escenario donde su uso es

adecuado, y otro donde no lo sea.
Respuesta: Un RAID-1 se compone de una serie de discos (que pueden
operar en paralelo) donde cada uno contiene un duplicado. Esta técnica es
conocida como mirrorirng y apunta a la confiabilidad de los datos. De esta
forma, ante una falla de los discos “anfitriones”, sus datos pueden ser
recuperados a partir de su “gemelo”. Si bien el esquema asegura confiabilidad,
y puede optimizar la performance operando con una serie de discos en
paralelo, trabaja bajo la hipótesis de que la falla entre los discos es
independiente, y a su vez, la cantidad de discos “útiles” para alojar propiamente
la información es la mitad (ya que su duplicado tan solo mantiene información
redundante). Debido a esto, un escenario donde su uso puede ser adecuado
es en sistemas donde la confiabilidad de los datos es primordial frente a la
capacidad de almacenamiento (por tener el doble de discos necesarios para
albergar la información útil), pero no lo es cuando se corrompe la hipótesis de
la falla independiente entre los disco, por ejemplo, en una zona geográfica
310
donde la ocurrencia de terremotos, pudiendo generar un aterrizaje de

cabezales en varios discos, dañando varios de los discos (inclusive los que
actúan de “espejo”, perdiendo información; la confiabilidad no estaría
asegurada).
Feb 2014
1. Describa dos mecanismos implementados a nivel de hardware para
proteger al sistema operativo.
Respuesta: Entre los mecanismos para proteger al SO podemos encontrar:
- Ejecución en modo dual. El SO debe reconocer al menos entre dos
modos de ejecución, modo usuario y modo monitor. En modo
usuario se tiene un conjunto reducido de instrucciones a disposición,
mientras que en modo monitor todas las instrucciones están
disponibles, inclusive las privilegiadas. Todo usuario tiene derecho a
correr en modo usuario, pero solo el SO puede correr en modo
monitor.
- La protección de memoria se logra estableciendo el área de
memoria al que los procesos pueden acceder. Esto se logra
mediante dos registros, base y límite, y por medio de la MMU se
comparan todas las direcciones generadas por los procesos en base
a esos dos registros.
2. Explique el fenómeno de la hiperpaginación (trashing) e indique un

método para detectarlo.
3. Enumere y describa brevemente tres métodos de planificación de disco.

4. Describa tres servicios que debe brindar un sistema operativo

Respuesta: Entre los servicios que brinda un SO encontramos:
- Interfaz de usuario: El SO debe proveer a los usuarios una interfaz
de modo que éstos puedan realizar solicitudes sin la necesidad de
escribir un programa. Generalmente encontramos dos filosofías de
diseño respecto a UI:
o Línea de comandos: el usuario ingresa comando de texto al
SO en espera de una respuesta. Puede ser implementado de
dos formas, o bien el comando propio tiene el código de la
solicitud a ejecutar, o bien carga un archivo conteniendo
dicho código
o Interfaz de comando por lotes: el código se introduce un
archivo, y por medio de una interfaz gráfica de usuario (GUI)
se carga y ejecuta, usualmente mediante un sistema de
ventanas.
- Ejecución de programas: El SO debe poder cargar un programa en
memoria, ejecutarlo y terminarlo, ya sea normal o anormalmente.
311
- Operaciones de E/S: Un programa en ejecución podría requerir E/S.

Por cuestiones de seguridad y eficiencia, los usuarios casi nunca
pueden controlar los dispositivos de E/S directamente, por lo tanto el
sistema debe incluir un mecanismo para realizarlo.
5. Describa el nivel 5 de RAID

Respuesta (ver Feb 2012 - 7)
6. Describa y compare los métodos de E/S Programada y mediante acceso

directo a memoria (DMA)
7.
a. ¿Qué entiende por sistemas de archivos virtual (VFS – Virtual File
System)?
b. Indique dos métodos utilizados para administrar el espacio libre de

un sistema de archivos.
Respuesta: (ver Jul 2013 – 8.a)
8.
a. Describa la anomalía de Belady
Respuesta: (ver Dic 2011 – 6.b)
b. Describa el algoritmo de reemplazo de página Óptimo y justifique

si es posible llevarlo a la práctica.
Respuesta: Esta estrategia selecciona como víctima para reemplazo
aquel marco que no va a ser utilizado dentro de más tiempo. Dado que
se necesita conocimiento a futuro de cuáles páginas serán accedidas,
llevarlo a la práctica no es posible.
Mar 2014
1. Compare los métodos de E/S Programada y por Interrupciones. Indique
ventajas y desventajas de cada método.
2.
a. Describa los algoritmos de planificación de disco SSTF y SCAN.
b. Indique en qué se diferencian el algoritmo SCAN y C-SCAN.

3. En un sistema con memoria virtual, cuando un proceso accede a una

página de memoria no residente genera un fallo de página. Indique los
pasos que debe seguir la rutina de atención de fallos de página cuando lo
anterior ocurre.
312
Respuesta: El procedimiento para atender un fallo de página es el siguiente:

- Se consulta una tabla interna para determinar si se trata de un fallo
de direccionamiento (acceso ilegal). Si lo es, se aborta el proceso.
- Localizar la página referenciada en disco (SWAP).
- Localizar un marco libre
- Si no hay marcos libres se debe seleccionar una víctima para su
reemplazo (que puede ser local –dentro de los marcos asignados al
proceso- o global –dentro de todos los marcos disponibles-). Luego,
se debe swapear la página víctima a disco y actualizar la tabla de
páginas (marcar esa página como inválida).
- Se debe swapear la página referenciada desde disco, actualizando
la tabla de páginas (marcándola como válida).
- Reiniciar la instrucción que generó el fallo de página.
4.
a. Describa la técnica de segmentación de memoria.
b. ¿Qué ventaja brinda esta técnica respecto a la técnica de

paginación?
5. Describa el modelo de Conjunto de Trabajo (working set).

6. Describa dos métodos de acceso a un archivo.

Respuesta: Los dos métodos de acceso a un archivo (vistos en el curso) son:
- Secuencial: Este método está basado en el modelo de cintas, donde
la información se procesa en orden, registro por registro. Las
operaciones de lectura/escritura irán accediendo a los datos en
forma secuencial, incrementando un puntero de archivo.
- Directo: Este método está basado en el modelo de discos, donde la
información se procesa en cualquier orden. Se numeran las
unidades de información que almacenan el archivo (por ejemplo los
bloques), y el propio archivo generalmente contiene un puntero a su
comienzo, a partir del cual se puede posicionar en forma relativa
dentro de cualquier unidad.
7. Describa el método de asignación contigua de almacenamiento de

archivos en disco, indicando ventajas y desventajas.
8. Indique los campos principales del bloque descriptor de proceso (PCB)

313

Teórico, Práctico, Preguntas (Damián Salvia) (1) - 230210 - 001706

Cargado por

Copyright:

Formatos disponibles

Teórico, Práctico, Preguntas (Damián Salvia) (1) - 230210 - 001706

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Teórico, Práctico, Preguntas (Damián Salvia) (1) - 230210 - 001706

Cargado por

Copyright:

Formatos disponibles

Sistemas Operativos, FING - UdelaR Damián Salvia

4.6 Comunicación entre Procesos ................................................................................................. 44

Semáforos → Mensajería ................................................................................... 103

8.2.5 Combinación Paginación - Segmentación ............................................................... 150

11.6 Estructuras RAID.................................................................................................................... 204

13.2.3 Autenticación de usuario .......................................................................................... 236

Jul 2011.................................................................................................................................. 292

Un Sistema Operativo (SO) es un programa que actúa como

Objetivos del SO:

- Comodidad: Facilitar a los programadores la complejidad del hardware.

Tareas del SO:

- Brindar un ambiente donde ejecutar los programas de usuario de forma

A medida que los SO se encontraban con obstáculos, se dio pie a nuevos

2 Evolución histórica de los Sistemas Operativos

2.2 Sistemas por lotes multiprogramados [‘80]

Al escoger un trabajo en memoria,

2.3 Sistemas de tiempo compartido [‘80]

Cada usuario tiene por lo menos un programa individual en la memoria

Al igual que los sistemas por lotes multiprogramados, se necesita mantener

2.4 Sistemas de computador personal [‘80]

2.5 Sistemas paralelos [‘90]

Cuando usamos n-procesadores, esperamos un aumento de n en rendimiento

- Confiabilidad del procesador, ya que si uno falla, no se detiene el sistema,

Encontramos cuatro tipos de clasificaciones de los sistemas

1. Según cómo ejecutan los procesos, se dividen en dos:

- Simétricos (SMP): Cada procesador realiza todas las tareas

- Asimétrico: asignan a cada procesador una tarea específica. Existe un

2. Según cómo se comunican, se dividen en dos grupos:

- Altamente Integrados (tightly coupled): los canales de comunicación entre

- Levemente Integrados (loosely coupled): los canales de comunicación

3. Según la Taxonomía de Flynn3, se divide en cuatro grupos,

- SISD (Single Instruction – Single Data): Se ejecuta una instrucción en cada

- SIMD (Single Instruction – Multiple Data): Se ejecuta una instrucción sobre

- MISD (Multiple Instruction – Single Data): Se utiliza para agregar

- MIMD (Multiple Instruction – Multiple Data): Se ejecutan distintas

Dentro de esta clasificación existen dos variantes:

 Sistemas de memoria compartida: Los procesadores se

 Sistemas de memoria distribuida: Los procesadores se

4. Según el costo con que los procesadores acceden a memoria,

- UMA (Uniform Memory Access): Cada procesador accede a cualquier lugar

- NUMA (Non Uniform Memory Access): Los procesadores tienen un

2.6 Sistemas distribuidos [‘90]

2.7 Sistemas Cluster [‘00]

Los sistemas Cluster se clasifican en:

 Simétricos [Activo-Activo]: Todos los nodos ejecutan tareas y asumen las

2.8 Sistemas de tiempo real [‘00]

Existen dos variantes:

2.9 Sistemas Multimedia

2.10 Sistemas de mano (Handheld)

2.11 Sistemas Interactivos

3 Estructura de los Sistemas Informáticos

El SO debe asegurar el correcto funcionamiento del sistema informático. El

3.1 Componentes Básicos

Se distribuye en tres componentes o subsistemas básicos detallados a

3.1.1 CPU (Central Process Unit)

Existen varias arquitecturas de procesadores, se clasifican en RISC (Reduced

Dentro de estas instrucciones se distingue un conjunto de instrucciones

3.1.2 I/O (Entrada/Salida)

Los device drivers son cargados de diferentes formas: