Sistemas Operativos I

1
sisOpe Temario Curso 15/16

• Horas
• INTRODUCCIÓN 4
• PROCESOS Y THREADS 10
• GESTIÓN DE MEMORIA 8
• ENTRADA / SALIDA 2
• SISTEMA DE FICHEROS 6

2
sisOpe 2. Procesos y Threads Curso 15/16

• 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
• Sistemas multiprocesador

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?

1. 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
PC1gt
6
PROCESOS (Visión abstracta Recordar sus llamadas)
7
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?
8
Diagrama de transición de estados de un Proceso
F.R.
wait
F.R.
sleep
wait
sleep
F.R.
F.R.
9
Esbozo de implementación en términos más
informáticos
10
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
11
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 !
ejecutandose?
12
Esbozo de implementación ( Estados y su gestión?
)
type unEstado is (ejecutandose,
preparado, espLapso, espFinHijo, zombie)
13
Esbozo de implementación ( Estados y su gestión?
)
type unEstado is (ejecutandose,
preparado, espLapso, espFinHijo, zombie)
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

14
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

15
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
zombie 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 zombie y liberar CPU
16
Esbozo de implementación ( Concluyendo )
maxProcesos constant 100 type idProceso is
NATURAL range 0..maxProcesos type unEstado is
(ejecutandose, preparado, espLapso,
espFinHijo, zombie) type descriptorProceso is
record pid NATURAL padre idProceso
estado unEstado sig idProceso lapso
NATURAL SP address memoria
---------- ficheros ----------
tiempos ---------- end record
fork y exec ?
type unaCola is record primero idProceso
0 ultimo idProceso 0 end
record procesos array 1..maxProcesos
of descriptorProceso ejecutandose
idProceso preparados, espLapso unaCola
17
Esbozo de implementación ( Otro ejemplo )

• Campos en una entrada a la tabla de procesos

18
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
19
Esbozo de implementación ( El Cambio de Contexto )
---------- divu d5,d0 ----------
------- ------- ------- ------- -------
------- ------- ------- ------- -------
---------- ---------- sleep(10) ---------- -------
--- exit(0)
------- ------- ------- ------- ------- ------- --
----- ------- ------- ------- ------- -------
20
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

21
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
22
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 ?
23
Threads ( Ejemplos de uso tonto.c )
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)
24
Threads ( Ejemplos de uso cuentaPar.c )

• cuentaPar.c Número de apariciones de un número
  en un vector

Algoritmo paralelo ?
25
Threads ( Ejemplos de uso cuentaPar.c )
26
Threads ( Ejemplos de uso cuentaPar.c )
// Variables globales int longRodaja,
numVecesLocalMAX_ESCLAVOS, vector void
esclavo (void parametro) int yo, inicio,
fin, i, j, numVeces yo (int) parametro
inicio yo longRodaja fin inicio
longRodaja // Buscar en mi parte del vector
numVeces 0 for (i inicio, i lt fin i)
if (vectori NUM_BUSCADO) numVeces
numVecesLocalyo numVeces pthread_exit
(NULL)
27
Threads ( Ejemplos de uso cuentaPar.c )
28
Threads ( Ejemplos de uso sortPar.c )

• sortPar.c Ordenar un vector en memoria

29
Threads ( Ejemplos de uso sortPar.c )

• sortPar.c Ordenar un vector en memoria
  Refinamiento

?
esclavo (yo integer) ordenarRodaja(yo) case
yo of 0 mezclar(A,B,E) mezclar(E,F,G) 1
2 mezclar(C,D,F) 3 end

• sem_init
• sem_wait
• sem_post

• Mezclar requiere haber ordenado gt semáforos

30
Threads ( Ejemplos de uso sortPar.c )
define MAX_ENTERO 10000 define
MAX_ESCLAVOS 4 // Solo funciona con 4
esclavos //-------------- VARIABLES GLOBALES
------------------------------- int
cardinalidad, longRodaja int vector,
vectorBis sem_t S1a0, S3a2, S2a0 void
imprimir (int vector) int i printf
("Contenido del vector\n") printf
("\n") for (i0
iltcardinalidad i) printf ("6d ",
vectori) if ((i10) 0) printf ("\n")
printf ("\n") void mezclar (int i, int
longRodaja, int vOrg, int vDst) int iDst,
iTope, j, jTope iTope i longRodaja j
iTope jTope j longRodaja for (iDst
i iDst lt jTope iDst) if (i
iTope ) vDstiDst vOrgj else if
(j jTope ) vDstiDst vOrgi
else if (vOrgi lt vOrgj) vDstiDst
vOrgi else
vDstiDst vOrgj
31
Threads ( Ejemplos de uso sortPar.c )
void esclavo(void parametro) int yo,
inicio, fin, i, j, imenor, menor int unCuarto,
unMedio yo (int) parametro inicio yo
longRodaja fin inicio longRodaja
unMedio cardinalidad / 2 unCuarto
cardinalidad / 4 // Ordenar por insercion
directa for (i inicio i lt fin i)
imenor i menor vectori for (j i j
lt fin j) if (vectorj lt menor)
imenor j menor vectorj
vectorimenor vectori vectori
menor // Fase de mezclas. Solo valida
para 4 esclavos switch (yo) case 0
sem_wait (S1a0) mezclar(0, unCuarto, vector,
vectorBis) sem_wait (S2a0)
mezclar(0, unMedio, vectorBis, vector)
break case 1 sem_post (S1a0) break
case 2 sem_wait (S3a2) mezclar(unMedio,
unCuarto, vector, vectorBis)
sem_post (S2a0) break case 3 sem_post
(S3a2) break default printf ("Error\n")
break pthread_exit(NULL)
32
Threads ( Ejemplos de uso sortPar.c )
int main( int argc, char argv ) int i,
numEsclavos pthread_t pidsMAX_ESCLAVOS
cardinalidad atoi(argv1) numEsclavos
MAX_ESCLAVOS longRodaja cardinalidad /
numEsclavos // Pedir memoria e inicializar el
vector vector malloc(cardinalidad
sizeof(int)) vectorBis malloc(cardinalidad
sizeof(int)) for (i0 iltcardinalidad i)
vectori random() MAX_ENTERO
imprimir(vector) // Inicializar semaforos
para sincronizar sem_init (S1a0, 0, 0)
sem_init (S3a2, 0, 0) sem_init (S2a0, 0,
0) // Crear esclavos y esperar a que terminen
su trabajo for (i0 iltnumEsclavos i)
pthread_create (pidsi, NULL, esclavo, (void )
i) for (i0 iltnumEsclavos i)
pthread_join (pidsi, NULL)
imprimir(vector) return (0)
sort 200000 gt 8350 sortPar 200000 gt 2100
33
Threads ( En el espacio de usuario )
pthread_create pthread_join pthread_exit
pthread_self
34
Threads ( En el espacio del S.O. )
35
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
36
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
37
Condiciones de Carrera (Modelización con threads)
Ingreso de Taxista 1 80729 Ingreso de Taxista
2 80618 Total recaudacion 161096
38
Condiciones de Carrera (Modelización con threads)
void taxista (void parametro) // Variables
recaudacion 0 mio 0 do espera
random() MAX_ESPERA for (i1 iltespera
i) importe random (maxImporte) mio
mio (importe / RATIO_TAXISTA) cuenta
cuenta importe (importe /
RATIO_TAXISTA) recaudacion recaudacion
importe while (mio lt SUELDO_DIA) printf
(Ingreso de Taxista d d\n, yo,
recaudacion mio) pthread_exit (NULL)
39
Condiciones de Carrera (Modelización con threads)
40
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
41
Exclusión mutua y Región crítica (La solución)
Los Pi indicarán cuándo EntranEnRC y cuándo
SalenDeRC
42
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

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

44
Implementación de la Exclusión Mutua ( Cerrojos )
Una variable cerrojo por cada RC distinta que
indica Libre/Ocupada
No funciona !
45
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 !!
46
Implementación de la Exclusión Mutua ( Un cerrojo
seguro? )
Algoritmos Dekker, Dijkstra, Knuth, Peterson,
.......
Habrá problemas?
47
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
48
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 ?
49
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
50
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) --------------- ---------------
51
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
52
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
53
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
54
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)
55
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?
56
Paso de mensajes ( Ejemplos de uso
cuentaParMsj.c )

• Cómo podría ser cuentaPar.c si no hay
  memoria común?

• El maestro reparte envía trabajo a los
  esclavos y
• recoge recibe resultados

57
Paso de mensajes ( Ejemplos de uso
cuentaParMsj.c )
58
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
59
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

60
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
61
Paso de mensajes (Mensajes de longitud fija vs
variable)
Práctica 4 Nueva llamada SO Proceso70.if
(proceso_vivo(84)
62
Paso de mensajes (Capacidad de almacenamiento
0..?)
Nunca Bloqueo!
Siempre Bloqueo!
Espera a Pd.recibir
Hueco ? Sin Bloqueo
No hay Hueco!
63
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 ----- ----- -----
64
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
65
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

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

• Inanición

• Espera Activa

• 50 Clientes????

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

• Más de un servidor?

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

• Indeterminismo
• Justicia
• Integridad

Quién recibe?
69
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

70
Paso de mensajes (Comunicación Indirecta)
Excepción ? buzonInexistente, ...
Problemática Destrucción !
71
Planificación de Procesos ( Criterios )
Planificar ? Elegir el siguiente Pi a ejecutar
Tiempo de Respuesta?
Criterios difícilmente alcanzables Favorecer Pi
? Perjudicar Pj
72
Planificación de Procesos ( PCPU vs PE/S )
?
Cómo reconocerlos?
73
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

74
Planificación de Procesos ( Por niveles )
75
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
76
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
77
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

78
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
79
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?

80
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
81
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

82
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

83
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?
84
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

85
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
86
Planificación de Procesos (MINIX 3)
87
Planificación de Procesos ( Pi más corto
siguiente SPN )
?
Predicción
?i1 F (ti, ?i)
?i1 ? ti (1- ?) ?i y ? 1/2
6
4
10
8
88
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)
89
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
90
Planificación de Threads ( Espacio de usuario )
Quantum por proceso de 50 mseg Cada thread
ejecuta 5 mseg de ráfaga de CPU
91
Planificación de Threads ( Espacio de kernel )
Quantum por proceso de 50 mseg Cada thread
ejecuta 5 mseg de ráfaga de CPU
92
Sistemas multiprocesador
Cada µP su cola
Planificar ? Qué thread? En qué núcleo?

1. Tiempo compartido Threads independientes Cola
   única

Ojo ! ? Spin Lock
93
Sistemas multiprocesador
Ordenando 128.000 claves burbuja en Intel Core
2 Quad Q6600 2,46GHz
sched_setaffinity
94
Sistemas multiprocesador

1. Espacio compartido Threads cooperantes Apropiarse
   µPn

95
Sistemas multiprocesador

1. Planificar por pandillas Threads
   cooperantes Tiempo/Espacio

FIN