1 Tema 7: Concurrencia y Sincronización Sistemas Operativos.

Presentación del tema: "1 Tema 7: Concurrencia y Sincronización Sistemas Operativos."— Transcripción de la presentación:

1 1 Tema 7: Concurrencia y Sincronización Sistemas Operativos

2 2 Índice: 1.Suspensión y Reanudación 2.Semáforos 3.Propiedades y Características de los Semáforos 4.Problemas Clásicos de Concurrencia 2 Tema 7: Concurrencia y Sincronización

3 3 Índice: 1.Suspensión y Reanudación 2.Semáforos 3.Propiedades y Características de los Semáforos 4.Problemas Clásicos de Concurrencia 3 Tema 7: Concurrencia y Sincronización

4 4 1. Suspensión y Reanudación Tema 7: Concurrencia y Sincronización  Primitivas más simples: sleep ()  Bloquea al proceso que la invoca wakeup (int pid)  Reanuda a proceso cuyo PID se indica  ¿Y si dicho proceso no está sleeping? La llamada a wakeup() no tiene efecto Se recuerda la llamada para que el próximo sleep() que haga el proceso no tenga efecto. Se trata como un error.

5 5 1. Suspensión y Reanudación Tema 7: Concurrencia y Sincronización  Implementación: ¡trivial! sleep ()  Nuevo estado proceso llamante: bloqueado  Insertar en lista de procesos bloqueados  Activar bit “sleeping” en PCB para indicar causa de bloqueo wakeup (int pid)  Nuevo estado proceso despertado: preparado  Quitar de lista de procesos bloqueados e insertar en preparados  Desactivar bit “sleeping” en PCB

6 6 1. Suspensión y Reanudación Tema 7: Concurrencia y Sincronización  Aplicando estas primitivas a resolver problemas en la vida real: productor/consumidor. while(true) { producir_elemento(); if (contador==N) sleep(); almacenar_elemento(); contador++; if (contador==1) wakeup(consumidor); } productor 0 1 2 3 tabla N-1 ins ext contador=0 while(true) { if (contador==0) sleep(); retirar_elemento(); contador--; if (contador==(N-1)) wakeup(productor); usar_elemento(); } consumidor contador=1contador=2contador=3contador=N

7 7 1. Suspensión y reanudación Tema 7: Concurrencia y Sincronización  Problemas:  Suspensión es incondicional ¡No hay atomicidad comprobación-acción!  Procesos deben conocerse entre sí  Un único estado de espera por proceso Procesos están “o despiertos o dormidos” Si proceso está dormido, no hay vinculación alguna con la causa por la que está en dicho estado

8 8 Índice: 1.Suspensión y Reanudación 2.Semáforos 3.Propiedades y Características de los Semáforos 4.Problemas Clásicos de Concurrencia 8 Tema 7: Concurrencia y Sincronización

9 9 2. Semáforos Tema 7: Concurrencia y Sincronización 1.Concepto de semáforo 2.Implementación de semáforos 3.Semáforos en la práctica 4.Semáforos binarios

10 10 2. Semáforos Tema 7: Concurrencia y Sincronización 1.Concepto de semáforo 2.Implementación de semáforos 3.Semáforos en la práctica 4.Semáforos binarios

11 11 2.1 Concepto de semáforo Tema 7: Concurrencia y Sincronización  E. W. Dijkstra (1.965)  Semaforo = tipo abstracto de datos, que encapsula:  Un contador entero  Una lista de procesos bloqueados en el semáforo  Operaciones sobre semáforos:  down(s): si contador = 0, proceso se bloquea en semáforo decrementa contador  up(s): Incrementa contador Si había algún proceso bloqueado en semáforo, reanuda uno  ¡Ambas operaciones son atómicas!

12 12 2.1 Concepto de semáforo Tema 7: Concurrencia y Sincronización  Utilidad: proteger acceso a recursos compartidos  A cada recurso compartido, se asocia semáforo con valor inicial 1.  Secciones críticas asociadas al recurso: Protocolo de entrada: down(s) Protocolo de salida: up(s)  Ventajas:  Robustez Comprobación/Acción son atómicas  Procesos que se coordinan no necesitan conocerse entre sí Sólo necesitan conocer semáforos que comparten  Flexibilidad Tanto semáforos como recursos compartidos

13 13 2. Semáforos Tema 7: Concurrencia y Sincronización 1.Concepto de semáforo 2.Implementación de semáforos 3.Semáforos en la práctica 4.Semáforos binarios

14 14 void down(semaforo s) { if (s->contador>0) s->contador--; else { insertar_en_lista (&s->bloqueados, getpid()); sleep(); } } 2.2 Implementación de semáforos Tema 7: Concurrencia y Sincronización struct s_semaforo { int contador; listaproc bloqueados; } typedef s_semaforo *semaforo; struct nodoproc { PID proceso; struct nodoproc *sig; } typedef struct nodoproc *listaproc void up(semaforo s) { if (lista_vacia(s->bloqueados)) s->contador++; else { int pid=sacar_de_lista(s->bloqueados); wakeup(pid); } } semaforo CrearSemaforo(int valor); void DestruirSemaforo(semaforo s);

15 15 2. Semáforos Tema 7: Concurrencia y Sincronización 1.Concepto de semáforo 2.Implementación de semáforos 3.Semáforos en la práctica 4.Semáforos binarios

16 16 2.3 Semáforos en la práctica Tema 7: Concurrencia y Sincronización Productor/Consumidor con semáforos while(true) { producir_elemento(); down(vacias); down(excmut); almacenar_elemento(); up(excmut); up(llenas); } productor 0 1 2 3 tabla N-1 ins ext contador=0 while(true) { down(llenas); down(excmut); retirar_elemento(); up(excmut); up(vacias); consumir_elemento(); } consumidor excmut=1 vacias=N llenas=0 down(excmut); down(vacias);

17 17 2. Semáforos Tema 7: Concurrencia y Sincronización 1.Concepto de semáforo 2.Implementación de semáforos 3.Semáforos en la práctica 4.Semáforos binarios

18 18 2.4 Semáforos binarios Tema 7: Concurrencia y Sincronización  Caso particular: semáforos con sólo dos estados:  Abierto (true, 1, …)  Cerrado (false, 0, …)  Operaciones sobre semáforos binarios:  down(s): si estado=cerrado, proceso se bloquea en semáforo estado=cerrado  up(s): estado=abierto Si había algún proceso bloqueado en semáforo, reanuda uno  ¿Son más potentes semáforos contadores que semáforos binarios?

19 19 void up(semaforo s) { down_b(s->exc); ++(s->contador); if (s->contador esp); up_b(s->exc); } void down(semaforo s) { down_b(s->blqd); down_b(s->exc); --(s->contador); if (s->contador >=0) up_b(s->exc); else { up_b(s->exc); down_b(s->esp); } up_b(s->blqd); } 2.4 Semáforos binarios Tema 7: Concurrencia y Sincronización struct s_semaforo { int contador; semaforo_b blqd; /* =abierto */ semaforo_b exc; /* =abierto */ semaforo_b esp; /* =cerrado*/ } typedef s_semaforo *semaforo;

20 20 Índice: 1.Suspensión y Reanudación 2.Semáforos 3.Propiedades y Características de los Semáforos 4.Problemas Clásicos de Concurrencia 20 Tema 7: Concurrencia y Sincronización

21 21 3. Propiedades y Características de los Sem. Tema 7: Concurrencia y Sincronización  Reglas generales:  Si un semáforo controla sección crítica, Cerrar lo más tarde posible Abrir tan pronto como sea posible  Secciones críticas anidadas: Evitar en la medida de lo posible down(a) y despues down(b)→ admisible si proceso que hace up(b) no hace down(a)  Selección proceso desbloqueado por up:  No especificado  Depende de implementación: FIFO, aleatorio, prioridad…  Los programas nunca deben depender de este detalle!

22 22 3. Propiedades y Características de los Sem. Tema 7: Concurrencia y Sincronización  Granularidad: nº de recursos controlados por cada semáforo  Granularidad fina: un recurso por semáforo  Granularidad gruesa: un semáforo para todos los recursos:

23 23 3. Propiedades y Características de los Sem. Tema 7: Concurrencia y Sincronización Granularidad fina:  Ventajas:  mayor grado de paralelismo P1 P2  Inconvenientes:  mayor número de semáforos  ¡Posibilidad de interbloqueo! Granularidad gruesa:  (inversa)

24 24 Índice: 1.Suspensión y Reanudación 2.Semáforos 3.Propiedades y Características de los Semáforos 4.Problemas Clásicos de Concurrencia 24 Tema 7: Concurrencia y Sincronización

25 25 4. Problemas Clásicos de Concurrencia Tema 7: Concurrencia y Sincronización Los Filósofos Comensales void filosofo (int i) { while(true) { pensar(); coger_tenedor(derecho(i)); coger_tenedor(izquierdo(i)); comer(); soltar_tenedor(derecho(i)); soltar_tenedor(izquierdo(i)); } }

26 26 4. Problemas Clásicos de Concurrencia Tema 7: Concurrencia y Sincronización void filosofo (int i) { while(true) { pensar(); down (s); coger_tenedor(derecho(i)); coger_tenedor(izquierdo(i)); comer(); soltar_tenedor(derecho(i)); soltar_tenedor(izquierdo(i)); up (s) } }  ¿Una posible solución?

27 27 4. Problemas Clásicos de Concurrencia Tema 7: Concurrencia y Sincronización excmut f[0]f[1] f[2] f[3]f[N] void filosofo (int i) { while(true) { pensar(); coger_tenedores(i); comer(); soltar_tenedores(i); } } void coger_tenedores(int i) { down(excmut); estado[i]= HAMBRIENTO; probar(i); up(excmut); down(f[i]); } void soltar_tenedores(int i) { down(excmut); estado[i]= PENSANDO; probar(izquierdo(i)); probar(derecho(i)); up(excmut); } void probar (int i) { if ((estado[i]==HAMBRIENTO) && (estado[izquierdo(i) != COMIENDO) && (estado[derecho(i)] != COMIENDO) { estado[i]= COMIENDO; up(f[i]) } }