Sistemas Operativos Tema 7 Concurrencia y Sincronizacin 1

Sistemas Operativos Tema 7: Concurrencia y Sincronización 1

Tema 7: Concurrencia y Sincronización Í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 Í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 1. Suspensión y Reanudación v 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. 4

Tema 7: Concurrencia y Sincronización 1. Suspensión y Reanudación v 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 5

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

Tema 7: Concurrencia y Sincronización 1. Suspensión y reanudación v 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 7

Tema 7: Concurrencia y Sincronización Í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 2. Semáforos 1. Concepto de semáforo 2. Implementación de semáforos 3. Semáforos en la práctica 4. Semáforos binarios 9

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

Tema 7: Concurrencia y Sincronización 2. 1 Concepto de semáforo v E. W. Dijkstra (1. 965) v Semaforo = tipo abstracto de datos, que encapsula: Ø Un contador entero Ø Una lista de procesos bloqueados en el semáforo v 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 v ¡Ambas operaciones son atómicas! 11

Tema 7: Concurrencia y Sincronización 2. 1 Concepto de semáforo v 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) v 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 12

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

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

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

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

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

Tema 7: Concurrencia y Sincronización 2. 4 Semáforos binarios v Caso particular: semáforos con sólo dos estados: Ø Abierto (true, 1, …) Ø Cerrado (false, 0, …) v 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 v ¿Son más potentes semáforos contadores que semáforos binarios? 18

Tema 7: Concurrencia y Sincronización 2. 4 Semáforos binarios struct s_semaforo { int contador; semaforo_b blqd; /* =abierto */ semaforo_b exc; /* =abierto */ semaforo_b esp; /* =cerrado*/ } 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); } typedef s_semaforo *semaforo; void up(semaforo s) { down_b(s->exc); ++(s->contador); if (s->contador <=0) up_b(s->esp); up_b(s->blqd); } up_b(s->exc); } 19

Tema 7: Concurrencia y Sincronización Í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 3. Propiedades y Características de los Sem. v 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) v Selección proceso desbloqueado por up: Ø No especificado Ø Depende de implementación: • FIFO, aleatorio, prioridad… Ø Los programas nunca deben depender de este detalle! 21

Tema 7: Concurrencia y Sincronización 3. Propiedades y Características de los Sem. v 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: 22

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

Tema 7: Concurrencia y Sincronización Í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 4. Problemas Clásicos de Concurrencia 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)); } } 25

Tema 7: Concurrencia y Sincronización 4. Problemas Clásicos de Concurrencia v ¿Una posible solució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) } } 26

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