Sistemas Operativos I

1
S.O.I Temario Curso 04/05

• Horas
• INTRODUCCIÓN 4
• PROCESOS Y THREADS 8
• GESTIÓN DE MEMORIA 8
• ENTRADA/SALIDA 4
• GESTIÓN DE FICHEROS 5

2
Tema 2. Procesos y Threads

• Introducción
• Procesos
• Visión abstracta
• Esbozo de implementación
• Threads (Procesos ligeros)
• Comunicación entre procesos
• Condición de carrera
• Exclusión mutua y región crítica
• Implementación de la exclusión mutua
• Paso de mensajes
• Planificación de procesos
• Criterios
• Políticas

3
INTRODUCCIÓN
Interesa tener máquinas que ejecuten varios
procesos al mismo tiempo
Aprovechar tiempos muertos E/S Soluciones
elegantes concurrentes Más rapidez con más de una
CPU
pseudoparalelismo
Con multiprocesadores también interesa
multiplexar las CPUs
4
PROCESOS (Visión abstracta Recordar sus llamadas)
Dos relaciones típicas entre proceso Padre y
proceso Hijo
fork exec?
fork?

• El código ya está en memoria

Parecido a Threads
5
PROCESOS (Visión abstracta Recordar sus llamadas)
Proceso de arranque y grupos de procesos
init
IBERIAgt
6
Esbozo de implementación
P3
P4
P1.read(disco, )?
P2.sleep(5 )?
P3 mucha CPU?
P1 fin E/S?
P4 read(cinta, )
P3 termina?
Estados de un proceso?
7
Diagrama de transición de estados de un Proceso
F.R.
wait
F.R.
sleep
wait
sleep
F.R.
8
Esbozo de implementación en términos más
informáticos
9
Esbozo de implementación ( Cuántos procesos? )
Procesos ilimitado o un máximo predeterminado?
maxProcesos constant100
Reservado
type idProceso is NATURAL range 0..maxProcesos
Correcto?
ejecutandose idProceso
10
Esbozo de implementación ( Cómo dar los PIDs? )
type descriptorProceso is record pid
idProceso --------------- end record
Problemas?

• 99 procesos en el sistema
• Hago ps y veo un proceso mío (57)
• Me dispongo a kill 9 57
• Mi proceso termina antes del kill y se crea otro
  proceso con el código 57

Mato a otro proceso !
11
Esbozo de implementación ( Estados y su gestión?
)
type unEstado is (ejecutandose,
preparado, espLapso, espFinHijo, zoombie)
CPU queda libre. A qué Pi se la doy?

• Recorro procesos buscando uno que esté preparado

Lento e injusto

• Si decido elegir al Pi que lleva más tiempo
  preparado, lo mejor cola FIFO

12
Esbozo de implementación ( Procesos bloqueados? )
espLapso gt Muy parecido a preparados, sólo que
es necesario indicar cuándo despertarles o
cuánto falta para despertarles, ...

• El campo sig me sigue sirviendo para encadenar
• Otras formas de implementarlo

13
Esbozo de implementación ( Procesos bloqueados? )
espFinHijo gt El fin de un hijo sólo puede estar
esperándolo su Padre. Puede no ser necesaria
una cola.
type descriptorProceso is record pid
NATURAL padre idProceso estado
unEstado sig idProceso lapso NATURAL
end record

• El Padre (P) hace wait (H)

-- Localizar H en procesos gt h if h.estado
zoombie then Liberar recursos del Hijo
y continuar al Padre else -- hijo
vivo p.estadoespFinHijo p.sigh liberar
CPU

• Un Hijo(H) termina exit

If (p.estado espFinHijo) (p.sig h)
then liberar recursos Hijo y continuar
Padre else h.estado zoombie y liberar CPU
14
Esbozo de implementación ( Concluyendo )
maxProcesos constant 100 type idProceso is
NATURAL range 0..maxProcesos type unEstado is
(ejecutandose, preparado, espLapso,
espFinHijo, zoombie) type descriptorProceso is
record pid NATURAL padre idProceso
estado unEstado sig idProceso lapso
NATURAL SP address memoria
---------- ficheros ----------
tiempos ---------- end record
type unaCola is record primero idProceso
0 ultimo idProceso 0 end
record procesos array 1..maxProcesos
of descriptorProceso ejecutandose
idProceso preparados, espLapso unaCola
15
Esbozo de implementación ( Otro ejemplo )

• Campos en una entrada a la tabla de procesos

16
Esbozo de implementación ( El Cambio de Contexto )
Causas?
Supongamos como causa Fin de Rodaja
No hay procesos preparados?
(1) Reconocimiento de la interrupción
(3) 1 Recorrer dormitorio 2 Elegir siguiente
proceso
(2) Salvar reg (Pi) y conmutar de pila
(4) Recuperar reg (Pj) y cederle control
17
Esbozo de implementación ( El Cambio de Contexto )
---------- divu d5,d0 ----------
------- ------- ------- ------- -------
------- ------- ------- ------- -------
---------- ---------- sleep(10) ---------- -------
--- exit(0)
------- ------- ------- ------- ------- ------- --
----- ------- ------- ------- ------- -------
18
Threads ( Visión abstracta )
Modelo de procesos más común ? Espacios de
direcciones disjuntos

• Facilita protección Pi?Pj, pero
• Creación laboriosa
• Cambio de contexto pesado
• (procesador entorno) TLBs, cachés, ...
• Comunicación vía mensajes
• más seguro pero más lento

Y si los procesos son cooperantes?

• Objetivo común
• Colaboración vs agresión
• Protección más laxa
• Pueden desear mantener datos comunes con los
  menores costes de tiempo

19
Threads ( Visión abstracta )
Procesos Ligeros ? Espacios de direcciones no
disjuntos
Servidor de localización de utilidades
Muy eficaz con multiprocesadores !

• Soportados de dos formas
• En el espacio del S.O.
• En el espacio del Usuario

respuesta
Biblioteca
20
Threads ( Linux )
int __clone (int (fn) (void arg), void
child_stack, int flags, void arg)
int pthread_create (pthread_t thread,
atributos, funcion, argumentos) pthread_t
pthread_self (void) int pthread_exit (void
estado) int pthread_join (pthread_t thread, void
estado) ........................................
........... ......................................
.............
fork threads ?
21
Threads ( Ejemplo de uso )
include ltpthread.hgt include ltstdio.hgt int main
(int argc, char argv) pthread_t tA, tB
int datoA0 datoB0
pthread_create(tA, NULL, A, NULL)
pthread_create(tB, NULL, B, NULL)
pthread_join (tA, NULL) pthread_join (tB,
NULL) exit (0)
void B (void basura) datoB 2000
sleep (5) printf (datoAd\n, datoA)
pthread_exit (NULL)
void A (void basura) datoA 1000
sleep (5) printf (datoBd\n, datoB)
pthread_exit (NULL)
22
Threads ( En el espacio de usuario )
pthread_create pthread_join pthread_exit
pthread_self
23
Threads ( En el espacio del S.O. )
24
Comunicación entre Procesos
Los procesos cooperantes necesitan mecanismos
para sincronizarse y comunicarse información de
forma segura
Sincronización ? Ordenación temporal de la
ejecución de procesos A antes que B
Tortilla de patatas Batir Pelar Pelar Huevos Ceb
ollas Patatas
Mezclar, Añadir Sal y Freir
Comunicación ? Paso de información entre
tareas Síncrona o Asíncrona
Filtros Unix who wc sed -e s/ //g
cut -d -f2
25
Condiciones de Carrera

• La falta de sincronismo entre procesos
  cooperantes da problemas
• Canal de Panamá ? Barco encallado
• Tortilla de Patatas ? No hay quien se la coma
• Uso de datos / recursos comunes ? Inconsistencia

El empresario y los taxistas
26
Condiciones de Carrera (Modelización en Pascal-FC)
program taxistas const numTaxistas 2 var
cuenta integer process type taxista (t
integer) var taxista1, taxista2
taxista begin cuenta 0 cobegin
taxista1(1) taxista2(2) coend writeln
(Total recaudacion , cuenta 7) end.
Ingreso de Taxista 1 27439 Ingreso de Taxista 2
27092 Total recaudacion 47055
27
Condiciones de Carrera (Modelización en Pascal-FC)
process type taxista (t integer) (
constantes y variables ) begin recaudacion
0 mio 0 repeat for i1 to random
(maxEspera) do null importe random
(maxImporte) mio mio (importe div
ratioTaxista) cuenta cuenta importe
(importe div ratioTaxista)
recaudacion recaudacion importe until mio
gt sueldoDia writeln (Ingreso de Taxista,
t2, , recaudacion mio) end
28
Condiciones de Carrera (El problema)
3 cuenta cuenta importe
problema?
3.1, 3.2
3.3, 3.4
3.1, 3.2
3.3, 3.4
29
Exclusión mutua y Región crítica (La solución)
Los Pi indicarán cuándo EntranEnRC y cuándo
SalenDeRC
30
Exclusión mutua y Región crítica (La solución)
EntrarEnRC cuenta cuenta importe
(importe div ratioTaxista) SalirDeRC

• REQUISITOS
• En una misma Región Crítica no más de un proceso
• Sin supuestos µP, Pi, velocidades relativas,
  .....
• Ningún Pi fuera de su Región Crítica bloqueará a
  otros Pj
• Decisión de quién entra a una Región Crítica en
  un tiempo finito

31
Implementación de la Exclusión Mutua

• Mecanismos
• Inhibición de interrupciones Semáforos
• Cerrojos (espera activa) Monitores

Inhibición de interrupciones
DirecciónGeneralDeTráfico repeat aguardarAgazapad
os y foto! InhibirInterrupciones numeroMultas
PermitirInterrupciones until cubiertoCupo
Taxistas InhibirInterrupciones cuenta cuenta
importe PermitirInterrupciones

• RC muy corta o pueden
• perderse interrupciones

• Exclusión total vs parcial

• Sólo válido en monoprocesador

• Peligroso en manos del usuario

• Útil dentro del propio S.O.

32
Implementación de la Exclusión Mutua ( Cerrojos )
Una variable cerrojo por cada RC distinta que
indica Libre/Ocupada
No funciona !
33
Implementación de la Exclusión Mutua ( El cerrojo
falla )
---------------- ---------------- entrar tst.b R
CT
bnz entrar move.b FF,RCT ---------------- ------
---------- ---------------- ----------------
---------------- ---------------- tst.b RCT bnz en
trar move.b FF,RCT ---------------- ------------
----
T1 también dentro RCT !!
34
Implementación de la Exclusión Mutua ( Un cerrojo
seguro? )
Algoritmos Dekker, Dijkstra, Knuth, Peterson,
.......
Habrá problemas?
35
Implementación de la Exclusión Mutua ( Un cerrojo
seguro! )
T2
T1
---------------- ---------------- tas.b RCT,FF
---------------- ---------------- tas.b RCT,FF b
nz entrar
bnz entrar ------------- ------------- -----------
-- -------------
T2 no puede entrar en RC mientras está T1
T1 en RCT
36
Implementación de la Exclusión Mutua ( TAS
todavía falla! )
TAS ? PedirBus, Leer, PedirBus, Escribir
tas.b RCT,FF bnz entrar
tasl.b RCT,FF bnz entrar --------------------- -
--------------------

• Todavía dos problemas !
• Espera Activa
• Inversión de prioridades

Qué hacer ?
37
Implementación de la Exclusión Mutua ( RC POSIX )
int pthread_mutex_lock (pthread_mutex_t
regionCritica) int pthread_mutex_unlock (pthread_
mutex_t regionCritica)
Posible implementación (sin espera activa)?
lock (RCT) inhibir interrupciones salvarEstado(
ejecutandose) if RCT.libre then RCT.libre
FALSE else meter (ejecutandose,
RCT) ejecutandose planificar()
recuperarEstado(ejecutandose) rte /Se
habilitan interrupciones/
type pthread_mutext_t is record libre
BOOLEAN cola unaCola end record
tasl
38
Implementación de la Exclusión Mutua ( Semáforos )
Soportado por el S.O. garantiza exclusión mutua
sin espera activa
type Semaforos is private Inicializar (S
Semaforos Valor NATURAL) Bajar (S) -- Puede
bloquear al proceso (Si Valor 0) Subir (S) --
Puede desbloquear a UN proceso
Dar soporte a RC con semáforos es fácil
Inicializar (S_RCT, 1) Inicializar (S_RCGC, 1)
--------------- --------------- Bajar
(S_RCT) Bajar (S_RCGC) Cuenta Cuenta
Importe numeroMultas Subir (S_RCT) Subir
(S_RCGC) --------------- ---------------
39
Implementación de la Exclusión Mutua ( Semáforos )
Precisando la semántica P.Bajar (S) ? IF
Valor(S) gt 0 THEN Valor (P.Bajar(S)) Valor(S)
1 ELSE P deja UCP y se bloquea esperando
P.Subir(S) P.Subir(S) ? IF Hay_algun_Pi_esperand
o_en (S) THEN Sacar a uno de ellos de
espera INDETERMINISMO Proceso
continuado Proceso que coge
UCP JUSTICIA ELSE Valor (P.Subir(S))
Valor (S) 1
40
Implementación de la Exclusión Mutua ( Semáforos )
Esbozo de implementación
private type Semaforos is record valor
NATURAL cola unaCola end record
Hacen falta operaciones del estilo crear,
conectarse, destruir
procedure Inicializar (S out
Semaforos valor NATURAL) is begin S.valor
valor end Inicializar
41
Implementación de la Exclusión Mutua ( Semáforos )
procedure Bajar (S in out Semaforos) is
begin if S.valor 0 then encolar
(ejecutandose, S.cola) planificar else
S.valor S.valor - 1 endif end Bajar
procedure Subir (S in out Semaforos) is
begin if S.cola.primero / 0 then encolar
(sacarProceso(S.cola), preparados) planificar
else S.valor S.valor 1 endif end Subir
42
Implementación de la Exclusión Mutua ( Semáforos
POSIX )
int sem_init (sem_t S, int global, unsigned
int valor) int sem_wait (sem_t S) int
sem_post (sem_t S) int sem_destroy (sem_t S)
43
Paso de mensajes

• Debilidades del Sincronismo Memoria Común
• Primitivas de bajo nivel (Inhibir Interrupciones,
  TASL, Semáforos)
• Inviable en sistemas débilmente acoplados sin
  memoria común

----- ----- -----
----- ----- -----
11
----- ----- -----
11
Primera aproximación a la sintaxis
void enviar ( int Pdestino, void recibir ( int
Porigen, char msj ) char msj )
Puede fallar enviar/recibir?
44
Paso de mensajes (muchas semánticas)
Bloqueo?

• Bloqueo?

? msj ? Se le entrega a Pd y continua
Independencia del enlace de comunicación
?

• Bloquear
• Bloquear un máximo
• No Bloquear

7
45
Paso de mensajes (Cuestiones de Diseño)

• Mensajes de longitud fija vs variable
• Capacidad de almacenamiento 0 .. ?
• Envío por copia vs referencia
• Comunicación Directa vs Indirecta

46
Paso de mensajes (Mensajes de longitud fija vs
variable)

• Longitud Fija

El S.O. siempre envía el total
Simplifica la gestión de la capacidad de
almacenamiento del canal

• Longitud Variable

El S.O. envía lo que diga la aplicación
47
Paso de mensajes (Capacidad de almacenamiento
0..?)
Nunca Bloqueo!
Siempre Bloqueo!
Espera a Pd.recibir
Hueco ? Sin Bloqueo
No hay Hueco!
48
Paso de mensajes (Envío por copia vs referencia)
2 copias extra por cada envío/recepción !

• Complejidad pedir/liberar Buffer
• Y si no hay memoria común?
• Seguridad?

Leer ----- ----- -----
49
Paso de mensajes (Comunicación Directa)
repeat repeat read (msjp.num) recibir ( Pc,
msjp) enviar (Ps, msjp) enviar
( Pc, recibir (Ps, msjr) respuesta(msjp)) im
primir (msjr.esPrimo) forever forever
50
Paso de mensajes (Comunicación Directa
Características)

• Necesidad de conocer los Pids de los procesos

• De Pi a Pj SÓLO un enlace en cada sentido

?
Todo resuelto?
P
P
P
P
P
P
P
H

• Un enlace asocia SÓLO a dos procesos

51
Paso de mensajes (Un enlace asocia SÓLO a dos
procesos)

• Inanición

• Espera Activa

• 50 Clientes????

! Demasiadas pegas
52
Paso de mensajes (Comunicación Directa Asimétrica)
Mejor admitir un recibir de cualquier proceso (no
uno concreto)

• Más de un servidor?

53
Paso de mensajes (Comunicación Indirecta)
enviar (buzon, msj) recibir (buzon, msj)
De quién recibí?

• Indeterminismo
• Justicia
• Integridad

Quién recibe?
54
Paso de mensajes (Comunicación Indirecta)
Los enlaces pueden ser Unidireccionales o
Bidireccionales
Problemas ?
Y aquí ?
Lo normal Unidireccionales
Lo más general

• Varios Procesos
• Varios Buzones
• Todo dinámico

55
Paso de mensajes (Comunicación Indirecta)
Excepción ? buzonInexistente, ...
Problemática Destrucción !
56
Planificación de Procesos ( Criterios )
Planificar ? Elegir el siguiente Pi a ejecutar
Tiempo de Respuesta?
Criterios difícilmente alcanzables Favorecer Pi
? Perjudicar Pj
57
Planificación de Procesos ( PCPU vs PE/S )
?
Cómo reconocerlos?
58
Planificación de Procesos ( Políticas )

• Sistemas Batch
• No expulsores o expulsores con un quantum grande
• Reducen cambios de contexto y mejoran el
  rendimiento
• Por niveles,
  
  Primero en llegar primero en servir FCFS,
  Más corto el siguiente SJF,
  
  Tiempo restante menor SRTN
• Sistemas interactivos
• Expulsores evita la monopolización de la CPU
• Round-Robin, prioridades, múltiples colas,
  Más corto el siguiente SPN
  (envejecimiento)
• Sistemas de tiempo real
• Monotónico en frecuencia
• Deadline más próximo el siguiente

59
Planificación de Procesos ( Por niveles )
60
Planificación de Procesos ( Primero en llegar
FCFS )
Sólo cuando un proceso abandona voluntariamente
la CPU, la misma se asigna al proceso que lleva
más tiempo preparado (FIFO)
D
C
Sencillo, pero ? Ausencia de política
Efecto convoy
61
Planificación de Procesos ( Efecto convoy )
PUCP 10UCP 2E/S PE/S 1UCP 2 E/S
CPU al 100, pero tan sólo 30 unidades de tiempo
en E/S
CPU al 100 y además, 55 unidades de tiempo en E/S
62
Planificación de Procesos ( El más corto primero
SJF )
3
4
5
8
Óptimo?
Aplicable SJF en planificación a largo y a corto
plazo?

• Tiempo total de CPU

• Lo declara el usuario

• Si engaña ? KILL

63
Planificación de Procesos ( Tiempo restante menor
SRTN )

• Variante expulsora del SJF.
• Cuando llega un trabajo nuevo, comparar su
  petición de tiempo
• con el tiempo que le queda al actual.
  Seleccionar el menor.
• Favorece a los trabajos nuevos

C(1) D(1) E(1)
A(2) B(4)
Tiempo medio de espera?
0 1 2 3 4 5 6 7
64
Planificación de Procesos (Round Robin)
Todos iguales Turno Rotatorio o Rodajas de
Tiempo

• A cada Pi que pasa a ejecución se le dá una
  rodaja cuanto de tiempo

Ley del 80

• Política FIFO de gestión de la cola de preparados

• Dos cuestiones de diseño
• Cómo elegir el tamaño de la rodaja?
• Cómo determinar el fin de rodaja?

65
Planificación de Procesos (Round Robin)

• Cómo elegir el tamaño de la rodaja?

Sea Tcc 5 mseg (mucho)

• Rodaja pequeña 20 mseg gt Burocracia del 20

• Rodaja grande 500 mseg gt Burocracia del 1

P1
P2
P3
P1
Valores comunes 20..50 mseg
66
Planificación de Procesos (Round Robin)

• Cómo determinar el fin de rodaja?

• Una interrupción periódica

• Dar 2 rodajas
• Resetear interrupción

F(int) en 68901 1µseg..20mseg

• Sumar ticks de una interrupción más frecuente

67
Planificación de Procesos (Prioridades)
Unos más importantes que otros Cada Pi
prioridad explícita
UCP siempre ejecuta Pi más prioritario
UCP libre ? ejecutar Pi más prioritario

• Igualdad de prioridad ? FCFS, Round Robin

• Prioridades estáticas vs dinámicas

68
Planificación de Procesos (Prioridades dinámicas)

• Evitar la inanición
• Disminuir la prioridad a medida que se usa la UCP
• Aumentar la prioridad si se está tiempo en
  preparados

Favorece a los trabajos cortos ?
Favorece a los Pi ligados a E/S

• Cuáles son PE/S?
• Todo el tiempo será PE/S?

Ejemplo con rodajas de 100 mseg P1 usa 2 mseg
de UCP ? PE/S P2 usa 25 mseg de UCP ? PUCP
Rango de prioridades 0..N?
69
Planificación de Procesos (Múltiples colas)
Mezcla de políticas Cada Pi asociado a una
cola de forma estática

• Dos elecciones
• Seleccionar cola
• Seleccionar proceso dentro de la cola

70
Planificación de Procesos (Múltiples colas
realimentadas)
Mezcla de políticas Cada Pi asociado a una
cola de forma dinámica

• Menos Cambios de Contexto

• Favorecer selectivamente PE/S

2
4
8
16
Consumir rodajas Bajar de prioridad
Rodajas para Pi ? 1, 2, 4, 8, 16
71
Planificación de Procesos ( Pi más corto
siguiente SPN )
?
Predicción
?i1 F (ti, ?i)
?i1 ? ti (1- ?) ?i y ? 1/2
10
8
6
4
72
Planificación de Procesos ( Sistemas de Tiempo
Real )
Hard real time vs Soft real time Eventos
periódicos vs aperiódicos

• Dado
• m eventos periódicos
• evento i ocurre en el periodo Pi y precisa Ci
  segundos
• El sistema es planificable si

(Leer las secciones 7.4.2, 7.4.3 y 7.4.4)
73
Planificación de Procesos ( Política vs Mecanismo
)

• Separar qué se puede hacer de cómo hacerlo
• Un proceso puede saber cuáles de sus threads
  hijos son los más importantes y asignarles
  prioridad
• Algoritmo de planificación parametrizado
• Mecanismo en el kernel
• Los procesos de usuario ponen el valor de los
  parámetros
• Los procesos de usuario indican la política

pthread_attr_setschedpolicy() gt FIFO, RR, OTHERS
74
Planificación de Threads ( Espacio de usuario )
Quantum por proceso de 50 mseg Cada thread
ejecuta 5 mseg de ráfaga de CPU
75
Planificación de Threads ( Espacio de kernel )
FIN
Quantum por proceso de 50 mseg Cada thread
ejecuta 5 mseg de ráfaga de CPU