View
123
Download
0
Category
Preview:
Citation preview
Gestión de Procesos 1
Horas
1 INTRODUCCIÓN
4
2 PROCESOS Y THREADS
10
3 GESTIÓN DE MEMORIA
8
4 ENTRADA / SALIDA
2
5 SISTEMA DE FICHEROS
6
sisOpe TemarioCurso: 14/15
Gestión de Procesos 2
sisOpe 2. Procesos y Threads Curso: 14/15
• 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
Gestión de Procesos 3
INTRODUCCIÓNInteresa tener máquinas que ejecuten varios procesos al mismo tiempo
18
T1
T2
T3
t
Aprovechar tiempos muertos E/S
Soluciones elegantes concurrentes
Más rapidez con más de una CPU
T1
T2
T3
t13
CPU1
CPU2Con multiprocesadores
también interesa multiplexar las CPU’s
pseudoparalelismo
Gestión de Procesos 4
PROCESOS (Visión abstracta: Recordar sus llamadas)
Dos relaciones típicas entre proceso Padre y proceso Hijo:
1. Procesos independientes: La “shell” crea un proceso para ejecutar un programa de usuario “ls”
ls.exe
shellPa. Debe cargarse el ejecutable
en memoria lsb. Dotarle de registros, pila, etc.
H
a. El código ya está en memoria
2. Procesos cooperantes: Un servidor Web crea un proceso para atender una petición de un cliente
web
P
b. Dotarle de registros, pila, etc.H Parecido a
Threads
¿fork + exec?
¿fork?
Gestión de Procesos 5
PROCESOS (Visión abstracta: Recordar sus llamadas)
Proceso de arranque y grupos de procesos
P1
P2 P3
P4
P5
P6
P7init
id:rlevel:action:process
/etc/inittab
xinetd
/etc/rc5.d
/etc/rc.d/rc 5loginlogin
login as:Password:
bashpcarazo:........:/bin/bash
/etc/passwd
PC1>
grupo de procesos
RedRed
putty?
gdm
0 Halt
1 Monousuario
2 MultiSinRed
3 MultiConRed
5 X11
6 Reboot
rlevel
Gestión de Procesos 6
PROCESOS (Visión abstracta: Recordar sus llamadas)
Gestión de Procesos 7
Esbozo de implementación¿Cómo es el ciclo de vida de un proceso?
CPUCreación
P1P2P3
P1
¿P1.read(disco, )?¿P2.sleep(5 )?
P2P3
P2
P3P4
¿P3 mucha CPU?Expulsión
P3 P4P3
¿P1 fin E/S?
P1
¿P4 read(cinta, )
P4
P3P1
¿P3 termina?
TerminaciónP1P2P4
¿Estados de un proceso?
• EnEjecución
• Preparado
• EnEspera o Bloqueado
Activo
Ejecu.
Prep. Espera
Gestión de Procesos 8
Diagrama de transición de estados de un Proceso
Preparado
EnEjecución
EnEspera
forkh
forkp
exit
exit
exit
wait
wait
wait sleep
sleep
F.R.
F.R.
F.R.
F.R.
¿forkp?
¿forkh?
Gestión de Procesos 9
El contexto de un proceso está distribuido en varias zonas
CPU
MP
MSec
S.O.
Esbozo de implementación en términos más informáticos
• Contexto de memoria (Código y Datos)MP/MSec• Bloque de control (descriptor) del Proceso MP (S.O.)• Contexto del procesador Reg/MP/MSec
Ejecutándose
Bloqueado
pila
Gestión de Procesos 10
Esbozo de implementación ( ¿Cuántos procesos? )
¿#Procesos ilimitado o un máximo predeterminado?
maxProcesos: constant:=100;
type idProceso is NATURAL range 0..maxProcesos;
Reservado
procesos : array[1..maxProcesos] of descriptorProceso;
1 2 3 4 97 98 99 10050
type descriptorProceso is record pid: ----------; --------------- end record;
584
ejecutandose : idProceso;
¿Correcto?
Gestión de Procesos 11
Esbozo de implementación ( ¿Cómo dar los PID’s? )
type descriptorProceso is record pid: idProceso; --------------- end record;
1 2 3 4 97 98 99 10050
1..100
¿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 !
Mejor espaciar más los códigos
pid: NATURAL; 1..65535...
Algo más complejodar PID’s
0 Descriptor libre
¿ejecutandose?
Gestión de Procesos 12
Esbozo de implementación ( ¿Estados y su gestión? )
type unEstado is (ejecutandose, preparado,espLapso, espFinHijo, zombie);
Gestión de Procesos 13
Esbozo de implementación ( ¿Estados y su gestión? )
type unEstado is (ejecutandose, preparado,espLapso, espFinHijo, zombie);
type descriptorProceso is record pid: NATURAL; estado: unEstado; end record;
1 2 3 4 97 98 99 10050
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
type unaCola is record primero: idProceso := 0; ultimo: idProceso:= 0;end record;
preparados: unaCola;
sig: IdProceso;
ejecutandose: idProceso;
Gestión de Procesos 14
Esbozo de implementación ( ¿Procesos bloqueados? )
espLapso => Muy parecido a preparados, sólo que es necesario indicar cuándo despertarles o cuánto falta para despertarles, ...
1 2 3 4 97 98 99 10050
type descriptorProceso is record pid: NATURAL; estado: unEstado; sig: idProceso; lapso: NATURAL; end record;
espLapso : unaCola;
105 25
• El campo sig me sigue sirviendo para encadenar
• Otras formas de implementarlo:
55 15
4 5097
Gestión de Procesos 15
Esbozo de implementación ( ¿Procesos bloqueados? )espFinHijo => 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 => hif h.estado = zombie then
Liberar recursos del Hijo ycontinuar al Padre
else -- hijo vivop.estado:=espFinHijo; p.sig:=h;liberar CPU;
• Un Hijo(H) termina exit:
If (p.estado = espFinHijo) & (p.sig = h) thenliberar recursos Hijo y continuar Padre
elseh.estado := zombie y liberar CPU
Gestión de Procesos 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;
type unaCola isrecord primero: idProceso := 0; ultimo: idProceso := 0;end record;
procesos : array [1..maxProcesos] ofdescriptorProceso;
ejecutandose: idProceso;preparados, espLapso: unaCola;
¿ fork y exec ?
Gestión de Procesos 17
Campos en una entrada a la tabla de procesos
Esbozo de implementación ( Otro ejemplo )
Gestión de Procesos 18
Esbozo de implementación ( El Cambio de Contexto )
Causas?
• Llamada al Sistema• Fin de Proceso
Bien/Mal
• Interrupción
Trap
(E/S, F.R.)
Mecanismo similar
Supongamos como causa “Fin de Rodaja”
ejecu-tándose Pi
Hw
(1)
(1) Reconocimiento de la interrupción
S.O. Pj
Ens.
(2)
(2) Salvar reg (Pi) y conmutar de pila
C/Modula/Ada
(3)
(3) 1 Recorrer dormitorio2 Elegir siguiente proceso
Ens.
(4)
(4) Recuperar reg (Pj) y cederle control
Planificador
Dispatcher
¿No hay procesos
preparados?
Gestión de Procesos 19
Vector de Interrupciones
S.O.
Esbozo de implementación ( El Cambio de Contexto )
--------------------sleep(10)--------------------exit(0)
------------------------------------------------------------------------------------
TRAP #0
-----------------------------------
INT 3
----------divu d5,d0---------- -------
----------------------------
DIV 0
Se salva el SR y PC
--------------------------------------------------------
Cambio de contexto
Gestión de Procesos 20
Threads ( Visión abstracta )Modelo de procesos más común Espacios de direcciones disjuntos
RegistrosCódigo
Datos, PilaFicheros
Pi
RegistrosCódigo
Datos, PilaFicheros
Pj
fork execls.exe
Facilita protección PiPj, pero:
• Creación laboriosa
• Cambio de contexto pesado
(procesador + entorno) TLB’s, 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
Gestión de Procesos 21
BD utilidades
Threads ( Visión abstracta )Procesos Ligeros Espacios de direcciones no disjuntos
RegistrosPila
RegistrosPila
Código, DatosFicheros
Ti Tj Servidor de localización de utilidades
C1C2
Cn
Sconsultaalta
consulta
petición
respuesta
peticiónpetición
¡ Muy eficaz con multiprocesadores !
• Soportados de dos formas:
• En el espacio del S.O.
• En el espacio del UsuarioBiblioteca
Gestión de Procesos 22
Threads ( “Linux” )
int __clone (int (*fn) (void *arg), void *child_stack, int flags, void *arg)
Como fork sólo que crea un Thread “Específico de Linux”
Thread soportado como tal por el S.O. (no portable)
Biblioteca pthread (API POSIX 1003.1c)
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 ?
Gestión de Procesos 23
Threads ( Ejemplos de uso: tonto.c )#include <pthread.h>
#include <stdio.h>
int main (int argc, char *argv[]){
pthread_t tA, tB;
int datoA=0; datoB=0;
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 (“datoA=%d\n”, datoA);
pthread_exit (NULL);
}
void *A (void *basura) {
datoA = 1000;
sleep (5);
printf (“datoB=%d\n”, datoB);
pthread_exit (NULL);
}
datoC=0;
int datoC; int datoC;
?
Threads ( Ejemplos de uso: cuentaPar.c )
• cuentaPar.c: Número de apariciones de un número en un vector
6 2 0 7 4 9 3 4 9 8 0 6 7 9 6 0 6 7 9 8 6 2 5 2 6 4 7 9 3 5 2 1 7 3 2 6 6 4 4 0
const N = 40; objetivo = 6; numCPUs = 4;var vector array[1..N] of integer;
¿ Algoritmo paralelo ?
T0 T1 T2 T3
1 3 2 2
+8
Gestión de Procesos 24
int longRodaja, numVecesLocal[MAX_ESCLAVOS], *vector;
void *esclavo (void *parametro) { ..... }
int main (int argc, char *argv[]) { int i, numVeces, cardinalidad = atoi (argv[1]); int numEsclavos = atoi (argv[2]); pthread_t pids[MAX_ESCLAVOS];
// Pedir memoria e inicializar vector
// Crear esclavos y esperar a que terminen su trabajo for (i = 0; i < numEsclavos; i++) pthread_create (&pids[i], NULL, esclavo, (void *) i); for (i = 0; i < numEsclavos; i++) pthread_join (pids[i], NULL);
// Sumar los valores de todos e informar del resultado numVeces = numVecesLocal[0]; for (i = 1; i < numEsclavos; i++) numVeces = numVeces + numVecesLocal[i]; printf (“Veces que aparece = %d\n”, numVeces);}
%cuentaPar 1000000 4
Threads ( Ejemplos de uso: cuentaPar.c )
25Gestión de Procesos
// Variables globalesint longRodaja, numVecesLocal[MAX_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 < fin; i++) if (vector[i] == NUM_BUSCADO) numVeces++; numVecesLocal[yo] = numVeces; pthread_exit (NULL);}
Gestión de Procesos 26
Threads ( Ejemplos de uso: cuentaPar.c )
5 1,286 4,26 0,85
6 1,127 4,86 0,81
7 1,113 4,92 0,70
8 0,998 5,49 0,69
cuentaPar 400.000.000 1..8 // Recorriéndolo diez veces
2 Xeon E5520 Quad2,26GHz • 8ML3 • 12GB • 500GB
Threads ( Ejemplos de uso: cuentaPar.c )
Gestión de Procesos 27
Esclavos Tiempo Aceleración Eficiencia
1 5,480
2 2,721 2,01 1,01
4 1,408 3,89 0,97
An = T1 / Tn En = An / n
• sortPar.c: Ordenar un vector en memoria
3 8 15 2 4 1 7 10 6 14 13 5 11 9 12 16
T0 T1 T2 T3
2 3 8 15 1 4 7 10 5 6 13 14 9 11 12 16
ordenar
1 2 3 4 7 8 10 15 5 6 9 11 12 13 14 16
T0 T2mezclar
T0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
mezclar
Threads ( Ejemplos de uso: sortPar.c )
Gestión de Procesos 28
• sortPar.c: Ordenar un vector en memoria [Refinamiento]
A B C D
E F
G
0 1 2 3
0 2
0
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;
?
1. La mezcla es destructiva => vector auxiliar
Va
Va
Vb
Va
2 Mezclar requiere haber ordenado … => semáforos
Threads ( Ejemplos de uso: sortPar.c )
Gestión de Procesos 29
• sem_init
• sem_wait
• sem_post
#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 (i=0; i<cardinalidad; i++) { printf ("%6d ", vector[i]); if ((i%10) == 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 < jTope; iDst++) { if (i == iTope ) vDst[iDst] = vOrg[j++]; else if (j == jTope ) vDst[iDst] = vOrg[i++]; else if (vOrg[i] < vOrg[j]) vDst[iDst] = vOrg[i++]; else vDst[iDst] = vOrg[j++]; }}
Threads ( Ejemplos de uso: sortPar.c )
Gestión de Procesos 30
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 < fin; i++) { imenor = i; menor = vector[i]; for (j = i; j < fin; j++) if (vector[j] < menor) { imenor = j; menor = vector[j]; } vector[imenor] = vector[i]; vector[i] = 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);}
Threads ( Ejemplos de uso: sortPar.c )
Gestión de Procesos 31
int main( int argc, char *argv[] ) { int i, numEsclavos; pthread_t pids[MAX_ESCLAVOS];
cardinalidad = atoi(argv[1]); numEsclavos = MAX_ESCLAVOS; longRodaja = cardinalidad / numEsclavos;
// Pedir memoria e inicializar el vector vector = malloc(cardinalidad * sizeof(int)); vectorBis = malloc(cardinalidad * sizeof(int)); for (i=0; i<cardinalidad; i++) vector[i] = 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 (i=0; i<numEsclavos; i++) pthread_create (&pids[i], NULL, esclavo, (void *) i); for (i=0; i<numEsclavos; i++) pthread_join (pids[i], NULL);
imprimir(vector); return (0);}
sort 200000 => 8:350sortPar 200000 => 2:100
Threads ( Ejemplos de uso: sortPar.c )
Gestión de Procesos 32
Gestión de Procesos 33
pthread_create pthread_join
pthread_exit pthread_self
Threads ( En el espacio de usuario )
• El S.O. no los soporta
• Cambio contexto rápido
• Distintos planificadores
• read, … ¡ Bloqueantes !
• Falta de página
• ¡Planificación expulsora!
Gestión de Procesos 34
Threads ( En el espacio del S.O. )
?
Gestión de Procesos 35
Comunicación entre ProcesosLos 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
Canal de Panamá Tortilla de patatas
Batir Pelar PelarHuevos Cebollas Patatas
Mezclar, Añadir Sal y Freir
Comunicación Paso de información entre tareas
Síncrona o AsíncronaFiltros Unix:
who | wc | sed -e ‘s/ [ ]*/:/g’ | cut -d: -f2
Gestión de Procesos 36
Condiciones de CarreraLa 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
¡Que buen negocio!
¡Me tangan!
Gestión de Procesos 37
Condiciones de Carrera (Modelización con threads)
Ingreso de Taxista 1 = 80729Ingreso de Taxista 2 = 80618Total recaudacion = 161096
+ 161347
int cuenta;
void *taxista(void *parametro) { ..... }
int main( int argc, char *argv[] ) { int i, numEsclavos; pthread_t pids[MAX_ESCLAVOS];
numEsclavos = atoi(argv[1]); cuenta = 0; // Crear esclavos y esperar a que terminen su trabajo for (i=0; i<numEsclavos; i++) pthread_create (&pids[i], NULL, taxista, (void *) i); for (i=0; i<numEsclavos; i++) pthread_join (pids[i], NULL);
printf ("Total recaudacion = %d\n", cuenta); return (0);}
Gestión de Procesos 38
Ingreso
Condiciones de Carrera (Modelización con threads)void *taxista (void *parametro) {
// Variables
recaudacion = 0; mio = 0; do { espera = random() % MAX_ESPERA; for (i=1; i<espera; i++); importe := random (maxImporte); mio := mio + (importe / RATIO_TAXISTA); cuenta := cuenta + importe – (importe / RATIO_TAXISTA); recaudacion := recaudacion + importe; } while (mio < SUELDO_DIA); printf (“Ingreso de Taxista %d = %d\n”, yo, recaudacion – mio); pthread_exit (NULL);}
Hacer Carrera
Buscar Cliente
Gestión de Procesos 39
Condiciones de Carrera (Modelización con threads)
Threads pc1:4Cores pc9:8Cores
2
4
8
16
32
Fallos x 1.000
7
64
230
533
830
207
926
1.000
1.000
1.000
Gestión de Procesos 40
3: cuenta := cuenta + importe
Condiciones de Carrera (El problema)
3.1: PUSH importe
3.2: PUSH cuenta
3.3: ADDP
3.4: POP cuenta
3.1, 3.2T1
T2
5.000cuenta
10.000T1.importe
3.35.00010.000
T1.SP
3.1, 3.2
1.500T2.importe
3.35.0001.500
T2.SP
3.3, 3.4
15.000
15.000cuenta
3.3, 3.4
6.500cuenta
6.500¿problema?
Gestión de Procesos 41
Exclusión mutua y Región crítica (La solución)
RC
RC
Aquí comomáximo un Pi
ExclusiónMutua
Integridad Datos
Comunes
Aquí cero,uno o más Pi
Los Pi indicarán cuándo EntranEnRC y cuándo SalenDeRC
Gestión de Procesos 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
Gestión de Procesos 43
Implementación de la Exclusión Mutua
Mecanismos:
• Inhibición de interrupciones • Semáforos
• Cerrojos (espera activa) • Monitores
Hw Sw
Lenguaje
S.O.
Inhibición de interrupciones
TaxistasInhibirInterrupciones
cuenta := cuenta + importePermitirInterrupciones
RC muy corta o puedenperderse interrupciones
Exclusión total vs parcial
DirecciónGeneralDeTráficorepeat
aguardarAgazapados y ¡foto!InhibirInterrupciones
numeroMultas++PermitirInterrupciones
until cubiertoCupo
Sólo válido en monoprocesador Peligroso en manos del usuario Útil dentro del propio S.O.
Gestión de Procesos 44
Implementación de la Exclusión Mutua ( Cerrojos )
Una variable “cerrojo” por cada RC distinta que indica Libre/Ocupada
TaxistasEntrar (RCTaxistas)
cuenta := cuenta + importeSalir (RCTaxistas)
Guardia CivilEntrar (RCDGT)
numeroMultas++Salir (RCDGT)
while RCT = ocupada do null;RCT := ocupada
cuenta := cuenta + importe;
RCT := libre
entrar tst.b RCTbnz entrarmove.b#$FF,RCTpushimportepush cuentaaddppop cuenta
salir move.b#$00,RCT
RCT dc.b 0
¡ No funciona !
Gestión de Procesos 45
Implementación de la Exclusión Mutua ( El cerrojo falla )
T1
T2
00RCT
--------------------------------
entrar tst.b
RCT
--------------------------------tst.b RCTbnz entrarmove.b #$FF,RCT--------------------------------
T1.SRZ
1
FFRCT
T2 dentro RCT
bnz entrarmove.b #$FF,RCT----------------------------------------------------------------
FFRCT
¡¡ T1 también dentro RCT !!
Gestión de Procesos 46
Implementación de la Exclusión Mutua ( Un cerrojo seguro? )
El Hw ayuda con una instrucción atómica que consulta y cambia valor
tas.b cerrojo, valortst.b cerrojo
move.b valor,cerrojo
Algoritmos: Dekker, Dijkstra, Knuth, Peterson, .......
entrar tas.bRCT,#$FFbnzentrarpushimportepushcuentaaddppopcuenta
salir move.b#$00,RCT
RCT dc.b 0
F.R. ¿Habrá problemas?
No funciona en multiprocesador ya que TAS es ininterrumpible dentro de un procesador, pero supone dos accesos al bus:
1 Lectura del cerrojo
2 Modificación del cerrojo
¡SI!
Gestión de Procesos 47
Implementación de la Exclusión Mutua ( Un cerrojo seguro! )
T1
T2
00RCT
--------------------------------tas.b RCT,#$FF
--------------------------------tas.b RCT,#$FFbnz entrar
T1.SRZ
1
FFRCT
FFRCT
bnz entrar----------------------------------------------------T1 en RCT
FFRCT
T2 no puede
entrar en RC
mientras está T1
tas.b RCT,#$FFbnz entrar
Gestión de Procesos 48
Implementación de la Exclusión Mutua ( TAS todavía falla! )
TAS PedirBus, Leer, PedirBus, Escribir
P1 T1 PB, L1, PB, E1P2 T2 PB, L2, PB, E2
???
P1 P2
RCT
L1, E1, L2, E2
T1 T2
L2, E2, L1, E1
T2 T1
L1, L2, E1, E2
T1 T2
tas.b RCT,#$FFbnz entrar
PHtasl.b RCT,#$FFbnz entrar------------------------------------------
¡ Todavía dos problemas !• Espera Activa• Inversión de prioridadesPL
deadLock ¿ Qué hacer ?
TASL “TAS with Lock” BusLock, Leer, Escribir, BusRelease
( El Hw nos ayuda )
Gestión de Procesos 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)?
type pthread_mutext_t is
record
libre : BOOLEAN;
cola : unaCola;
end record;
FRCT Pi Pj
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*/
Multiprocesador
?tasl¡ Ojo !
Gestión de Procesos 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
Operaciones
Atómicas
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)--------------- ---------------
Gestión de Procesos 51
Implementación de la Exclusión Mutua ( Semáforos )
Precisando la semántica:
P.Bajar (S) IF Valor(S) > 0 THENValor (P.Bajar(S)) = Valor(S) – 1
ELSEP deja UCP y se bloquea esperando P’.Subir(S)
P.Subir(S) IF Hay_algun_Pi_esperando_en (S) THENSacar a uno de ellos de espera
INDETERMINISMOProceso continuadoProceso que coge UCP
JUSTICIAELSE
Valor (P.Subir(S)) = Valor (S) + 1
Gestión de Procesos 52
Implementación de la Exclusión Mutua ( Semáforos )
private type Semaforos is record
valor : NATURAL;
cola : unaCola;
end record;
procedure Inicializar (S : out Semaforos;
valor : NATURAL) is
begin
S.valor := valor;
end Inicializar;
Esbozo de implementación:
0S Pi PkPj
¿Dónde están los semáforos?
Hacen falta operaciones del estilo: crear, conectarse, destruir
Exclusión mutua, Salvado estado Pi
Dispatcher
Gestión de Procesos 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;
Gestión de Procesos 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)
Gestión de Procesos 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
Solución: Envío y recepción de mensajes
Porg Pdst
Enviar (Pdst, msj) Recibir (Porg, msj)
---------------
Escribe
11---------------
--------------- 11
Lee
Primera aproximación a la sintaxis:void enviar ( int Pdestino, void recibir ( int Porigen,
char * msj ); char * msj );
¿Puede fallar enviar/recibir?
?
?int int
Paso de mensajes ( Ejemplos de uso: cuentaParMsj.c )
• ¿Cómo podría ser cuentaPar.c si no hay memoria común?
1 3 2 2
6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …
+8
esclavo1 esclavo2 esclavo3 esclavo4
maestro6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …
• El vector lo tiene un proceso “maestro”
• El maestro: reparte “envía” trabajo a los “esclavos” y
recoge “recibe” resultados
6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …
13 2 2
Gestión de Procesos 56
Gestión de Procesos 57
Paso de mensajes ( Ejemplos de uso: cuentaParMsj.c )
#define longRodaja (N/4)int vector[N], iRodaja;int veces, vecesLocal;
// Repartir trabajo iRodaja = 0; for e in 1..4 { enviar (e, &vector[iRodaja], longRodaja); iRodaja += longRodaja; }
// Recoger resultados veces = 0; for e in 1..4 { recibir (e, &vecesLocal, 1); veces += vecesLocal; }
#define longRodaja (N/4)
int rodaja[longRodaja];int veces;
recibir (0, rodaja, longRodaja); veces = contarEn (rodaja); enviar (0, &veces, 1);
maestro
esclavo
Gestión de Procesos 58
Paso de mensajes (muchas semánticas)
---------------rec (Po, msj)---------------
---------------env (Pd, msj)---------------
Pd ¿Bloqueo?
El bloqueo dependerá de la | de mensajes msj Se le entrega a Pd y continua
msj Se bloquea a Pd hasta
No siempreTiempo Real
Tolerancia a Fallos
• Bloquear
• Bloquear un máximo
• No Bloquear
int recibir ( int Porg, char * msj,int TmaxEsp)
70
?
?Po
• ¿Bloqueo?
• ¿Recibió Pd?
Po
Independencia del enlace de
comunicación
Gestión de Procesos 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
Pi B PjPi Pj
Simétrica vs Asimétrica Unidireccional vs Bidireccional
Gestión de Procesos 60
Paso de mensajes (Mensajes de longitud fija vs variable)
• Longitud Fija
El S.O. siempre envía
el total
La aplicación distingue
distintos msj.
Simplifica la gestión de la capacidad de almacenamiento del canal
• Longitud Variable
El S.O. envía lo que diga la
aplicación
¿Cómo?
110 Mensaje de 110 bytes
En el propio mensaje
enviar (Pdest, msj, 110)
En la llamada
61
Paso de mensajes (Mensajes de longitud fija vs variable)
MINIX 3
typedef struct {
int m_source;
int m_type;
union {
mess_1 m_m1;
mess_2 m_m2;
mess_3 m_m3;
mess_4 m_m4;
mess_5 m_m5;
mess_7 m_m7;
mess_8 m_m8;
} m_u;
} message;
m_source
m_type
m1_i1
m1_i2
m1_i3
m1_p1
m1_p2
m1_p3
m_source
m_type
m2_i1
m2_i2
m2_i3
m2_l1
m2_l2
m2_p1
m_source
m_type
m3_i1
m3_i2
m3_p1
m3_ca1
m_source
m_type
m4_i1
m4_i2
m4_i3
m4_i4
m4_i5
Práctica 4: Nueva llamada SO
Proceso70.if (proceso_vivo(84)
705784
# Llamada 57
Gestión de Procesos 62
Paso de mensajes (Capacidad de almacenamiento 0..)
Ilimitada ()
Po Pd
Po Pd¡Nunca Bloqueo!
Limitada (8)
Po Pd
Po PdHueco Sin Bloqueo
¡No hay Hueco!• Bloqueo
• Sin BloqueoEstado = Lleno
Comunicación Asíncrona
Nula (0)
Po Pd¡Siempre Bloqueo!
Po PdEspera a Pd.recibir
Po PdCita “Rendez-vous”
Po Pd
Comunicación Síncrona
Po sabe que Pd recibió
¿Y aquí?
Gestión de Procesos 63
Po Pd
Paso de mensajes (Envío por copia vs referencia)
Escribir---------------env (Pd, msj)
1
rec (Po, msj)
2
¡ 2 copias extra por cada envío/recepción !
Leer---------------
Envío por referencia
Po Pd
pedirBufferEscribir---------------env (Pd, msj) rec (Po, msj)
Leer---------------liberarBuffer
• Complejidad pedir/liberar Buffer
• ¿Y si no hay memoria común?
• ¿Seguridad?
Gestión de Procesos 64
Paso de mensajes (Comunicación Directa)
Indicación explícita• A qué proceso se desea enviar
• De qué proceso se desea recibir
Cliente Servidor¿15.731 es primo?
SÍ
repeat repeat
read (msjp.num); recibir ( Pc, &msjp);
enviar (Ps, &msjp); enviar ( Pc,
recibir (Ps, &msjr); respuesta(msjp))
imprimir (msjr.esPrimo) forever
forever
Simétrica
Simétrica
Gestión de Procesos 65
Paso de mensajes (Comunicación Directa “Características”)
• Creación automática del enlace Po Pd
• Necesidad de conocer los Pid’s de los procesos
• De Pi a Pj SÓLO un enlace en cada sentido
Cliente ServidoresPrimo?
Hora?Cliente Servidor?
15.7310
1
Tipo de mensaje
¿Todo resuelto?
Cliente ServidorPPPPPPPH
• Un enlace asocia SÓLO a dos procesos
Gestión de Procesos 66
Paso de mensajes (Un enlace asocia SÓLO a dos procesos)
C1
C2S
C1
C2S
repeat
if recibir (PC1, &msjp ) then
enviar (PC1, respuesta (msjp));
elsif recibir (PC2, &msjp ) then
enviar (PC2, respuesta (msjp));
forever
Servidor
• Inanición
• Espera Activa
, 1
, 1Mitigada?
• 50 Clientes????
! Demasiadas pegas ¡
Gestión de Procesos 67
Paso de mensajes (Comunicación Directa Asimétrica)Mejor admitir un recibir de cualquier proceso (no uno concreto)
C1
C2S
int recibir (char * msj)
Pid del proceso remitente
int recibir (int * remitente, char * msj)
equivalentes
repeat
remitente := recibir (&msjp);
enviar (remitente, respuesta (msjp));
forever
Servidor• ¿Más de un servidor?
int enviar (char * msj)
Pid del proceso que recibió???
CS1
S2
Gestión de Procesos 68
Paso de mensajes (Comunicación Indirecta)
bPetiPC PS
1 1
bPetiPC
PS1
PSm1 M
bPeti
PC1
PCn
PS1
PSmN M
¿Quién recibe?• Indeterminismo• Justicia• Integridad
bPeti
PC1
PCn
PS
N 1
¿De quiénrecibí?
PCn
enviar (buzon, msj) recibir (buzon, msj)
int recibir (buzon, msj)
PCn
Gestión de Procesos 69
Paso de mensajes (Comunicación Indirecta)Los enlaces pueden ser Unidireccionales o Bidireccionales
PC PS
¿ Problemas ?
PC1PS
PC2 ¿ Y aquí ?
Lo normal Unidireccionales:
bPeti
PCPS1
PS2bResp
¿ Código del Cliente y de los Servidores ?
Lo más general:
B1
P2P4
P5B2P3
P1
• Varios Procesos
• Varios Buzones
• Todo dinámico
Gestión de Procesos 70
Paso de mensajes (Comunicación Indirecta)
type Buzones is private;
function Crear (nombreB: Nombres ) return Buzones;
function Conectarse (nombreB: Nombres) return Buzones;
procedure Enviar (b: in out Buzones; msj: Mensajes);
procedure Recibir (b: in out Buzones; msj: out Mensajes);
procedure Destruir (b: in out Buzones);
Un modelo: Capacidad
*
* Propietario* Excepción buzonInexistente, ...
¡ Problemática Destrucción !• Mensajes en el buzón
• Procesos bloqueados
• Referencias a buzones destruidos
mqd_t mq_open (const char *name, int oflag, …)
int mq_send (mqd_t mqid, const char *msgptr, size_t msgsz, unsigned msgprio)
ssize_t mq_receive (mqd_t msid, char *msgp, size_t msgsz, unsigne *msgprio)
int mq_close (mqd_t mqid)
POSIX
Gestión de Procesos 71
Planificación de Procesos ( Criterios )Planificar Elegir el siguiente Pi a ejecutar
• JUSTICIA
• EFICIENCIA
• RENDIMIENTO
• MINIMIZAR TIEMPOS
Criterios
Carga
Sin CPU
Ejecutándose
Pi
Tiempo de
Retorno
CPU
Tiempo útil
Tiempo inútil
Tiempo de Espera¿Tiempo de Respuesta?
Pi
<cr>
Criterios difícilmente alcanzables:
Favorecer Pi Perjudicar Pj
Gestión de Procesos 72
Planificación de Procesos ( PCPU vs PE/S )
PCPU
PE/S
Periodos largos de CPUPeriodos cortos de CPU ?
¿Cómo reconocerlos?
Abandona voluntariamente la UCP
Gestión de Procesos 73
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
Planificación de Procesos ( Políticas )
Gestión de Procesos 74
Planificación de Procesos ( Por niveles )
Planificación amedio plazo
Memoria
Planificación acorto plazo CPU
CPU
IT2
T2
T3
T5
T1, T2, T3, T4, T5, T6
S.O.
Entrada al sistema
frecuencia alta frecuencia baja
Gestión de Procesos 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 AB A D BCD BC
A E/S
Sencillo, pero Ausencia de política
D C B A
4 4 4 8
D C BA
8 4 4 4
Tesp
Tret
9
14
Tesp
Tret
6
11 “Efecto convoy”
{PE/S}n PUCP
PE/S {PE/S}n-1
PUCP
E/S
T >>T <
Gestión de Procesos 76
Planificación de Procesos ( Efecto convoy )
PUCP = {10UCP + 2E/S}* PE/S = {1UCP + 2 E/S}*
PUCP
PE/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
PUCP
PE/S
??
Gestión de Procesos 77
Planificación de Procesos ( El más corto primero SJF )
Objetivo: Minimizar Tesp/ret 85
43 CPU
3458
¿Óptimo?¿Dónde esperan los procesos?
CPUpreparados
¿Aplicable SJF en planificación a largo y a
corto plazo?
¿Más corto?
• Tiempo total de CPU
• Lo declara el usuario
• Si engaña KILL
¿Más corto? Sistemas interactivos
Contraejemplo
0 1 2 3 4
A(2)B(4)
C(1)D(1)E(1)
Gestión de Procesos 78
• 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
0 1 2 3 4 5 6 7
A(2)B(4)
C(1)D(1)E(1)
¿Tiempo medio de espera?
Planificación de Procesos ( Tiempo restante menor SRTN )
Gestión de Procesos 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
a La consume totalmente y se le expulsa
Pi
rodaja
b La usa parcialmente y abandona voluntariamente la UCP
Pi
sleep, wait, exit
• Política FIFO de gestión de la cola de preparados
• Dos cuestiones de diseño:
1 ¿Cómo elegir el tamaño de la rodaja?
2 ¿Cómo determinar el fin de rodaja?
Ley del 80%
Gestión de Procesos 80
Planificación de Procesos (Round Robin)1 ¿Cómo elegir el tamaño de la rodaja? Sea Tcc = 5 mseg (mucho)
a Rodaja pequeña 20 mseg => Burocracia del 20%
b Rodaja grande 500 mseg => Burocracia del 1%
UCP útilRespuesta lenta ausuarios interactivos
¿Degenera en FCFS?Mejor
interactividad
• Ejemplo: P1, P2, P3 => 24, 3 y 3. Rodajas 4 vs 12 y Tcc = 0,5
P1 P2 P3 P1 P1 P1 P1 P1
33,5
P1 P2 P3 P1
31,5
Valores comunes:
20..50 mseg
Gestión de Procesos 81
Planificación de Procesos (Round Robin)2 ¿Cómo determinar el fin de rodaja?
a Una interrupción periódica
P1 P2 P3 P4
sleep
¿Somos justos con P3?
¿viable? F(int) en 68901 [1µseg..20mseg]
• Dar 2 rodajas• Resetear interrupción
b Sumar ticks de una interrupción más frecuente
P1 P2
sleep
P3 P4
Gestión de Procesos 82
Planificación de Procesos (Prioridades)“Unos más importantes que otros”: Cada Pi prioridad explícita
0 N
N 0mín
máx
expulsora
P3
P7
P1
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
Sencillo pero inaniciónP3
P7
P1
P9
¿ tiempo real ?
no expulsora
P3
P7
P1
Gestión de Procesos 83
Planificación de Procesos (Prioridades dinámicas)
a 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 ?
b PE/S vs PUCPFavorece a los Pi ligados a E/S
• ¿Cuáles son PE/S?
• ¿Todo el tiempo será PE/S?
PE/S aquellos que usen una parte menor de la rodaja de UCP
Ejemplo con rodajas de 100 mseg:
P1 usa 2 mseg de UCP PE/S
P2 usa 25 mseg de UCP PUCP
Prio (P1) = 100/2 = 50
Prio (P2) = 100/25 = 4
¿Rango de prioridades [0..N]?Estáticas muy bajo 16
Dinámicas muy variable
Gestión de Procesos 84
Planificación de Procesos (Múltiples colas)
“Mezcla de políticas”: Cada Pi asociado a una cola de forma estática
Prioridad
3
2
1
0
FCFS
RoundRobin
Quantum
4
8
16
Dos elecciones:
1 Seleccionar cola
2 Seleccionar proceso dentro de la cola
¿Expulsora?
Gestión de Procesos 85
Planificación de Procesos (Múltiples colas realimentadas)
“Mezcla de políticas”: Cada Pi asociado a una cola de forma dinámica
a Menos Cambios de Contexto
Prioridad
4
3
2
1
0
1
+ Rodajas Variables
2
4
8
16
Rodajas para Pi 1, 2, 4, 8, 16
b Favorecer selectivamente PE/S
Prioridad
3 Terminal
2 E/S
1 Rodaja corta
0 Rodaja larga
Consumir rodajas:Bajar de prioridad
86
Planificación de Procesos (MINIX 3)
/usr/src/kernel/proc.h
Pi
SI consumió su rodaja Nueva rodaja Prioridad++ ¡Menor! Encolar_Al_FinalSINO Encolar_Al_Principio
sched
Preparados
MaxPrioridad
MinPrioridad
RoundRobin
proc[log].p_nextready
Gestión de Procesos 87
Planificación de Procesos ( Pi más corto siguiente SPN )
CPUpreparados
¿Más corto? ¿Más corto?SJF SPN
Tiempo de próxima posesión de UCP
?
¿Predicción? (i) i+1 = F (ti, i)
i+1 = ti + (1- ) i y = 1/2
Predicción
ti i 10
6
8
4
6
6
6
4
5
13
9
13
11
13
12
Gestión de Procesos 88
1
1m
i
i i
C
P
Dado
• m eventos periódicos
• evento i ocurre en el periodo Pi y precisa Ci segundos
El sistema es planificable si
Hard real time vs Soft real time
Eventos: periódicos vs aperiódicos
(Leer las secciones 7.4.2, 7.4.3 y 7.4.4)
Planificación de Procesos ( Sistemas de Tiempo Real )
Gestión de Procesos 89
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
Planificación de Procesos ( Política vs Mecanismo )
pthread_attr_setschedpolicy(…) => FIFO, RR, OTHERS
Gestión de Procesos 90
Quantum por proceso de 50 msegCada thread ejecuta 5 mseg de ráfaga de CPU
Planificación de Threads ( Espacio de usuario )
Gestión de Procesos 91
Planificación de Threads ( Espacio de kernel )
Quantum por proceso de 50 msegCada thread ejecuta 5 mseg de ráfaga de CPU
Gestión de Procesos 92
Sistemas multiprocesador
µP1 µP2 µP3 µP4 Cada µP su cola
Peligro de carga desequilibrada
µP1 µP2 µP3 µP4
¡ Ojo ! Spin Lock
Planificar ¿Qué thread? ¿En qué núcleo?
1. Tiempo compartido Threads independientes Cola única
No escalable con aumento núcleos
Espera activa si FR Spin Lock
¡Estoy en RC! Alarga rodaja
Problemática caches Afinidad
Gestión de Procesos 93
Sistemas multiprocesador Ordenando 128.000 claves “burbuja” en Intel Core 2 Quad Q6600 2,46GHz
µP0
4MB L2
µP1 µP2
4MB L2
µP3
sched_setaffinity
Gestión de Procesos 94
Sistemas multiprocesador
2. Espacio compartido Threads cooperantes Apropiarse {µP}n
Núcleo ocioso cuando Pi.bloqueado
Sin multiprogramación ¡Menos burocracia!
Sin “n” núcleos libres no me ejecuto
Servidor Web con {threads} variable
Gestión de Procesos 95
Sistemas multiprocesador
3. Planificar por pandillas Threads cooperantesTiempo/Espacio
Espacio compartido
Tiempo compartido FIN
Recommended