Semforos
Cecilia Hernndez 2013
Semforos
Primitiva de Sincronizacin propuesta por Dijkstra en 1968
Como parte de sistema THE Usados para exclusin mutua y planificacin De nivel ms alto que locks Wait(semaforo)
Decrementa semforo Bloquea hebra/proceso si el semforo es menor que cero, sino entonces permite a hebra/proceso continuar Operacion tambien llamada P(semaforo) o down(semaforo)
Variable atmica manipulada por dos operaciones
Signal(semforo)
Incrementa semforo en uno y si hay algn proceso/hebra esperando lo despierta Tambin llamada V(semaforo) o up(semaforo)
Valor de semforo puede ser mayor que 1
Inicializado en 1 es como lock.
Usado para exclusin mutua
Inicializado en N
Usado como contador atmico
Implementacin de Semforos
typedef struct { int value; struct hebra *L; } semaphore; void wait(semaphore S) { S.value--; if (S.value < 0){ agregar hebra a S.L; block(); } } void signal(semaphore S){ S.value++; if (S.value <= 0){ remover hebra T de S.L; wakeup(T); } }
Exclusin mutua vs planificacin
Exclusin mutua - Slo una hebra a la vez en SC - Puede ser cualquier hebra lock Seccin crtica unlock
Planificacin - Requerimiento de orden en ejecucin de hebras.
tiempo
Ejemplo planificacin
tiempo H1. imprime A
sem S1 = 0, S2 = 0 H1: H2: print A; wait(S1); signal(S1); print B; signal(S2);
H3: wait(S2); print C;
H2. imprime B H3. imprime C
Tipos de Semforos
Binarios (mutex) Garantizan exclusin mutua a recurso Slo una hebra/proceso puede accesar seccin crtica a la vez Contador de semforo inicializado en 1 Contadores Representan recursos con ms de una unidad disponible Permiten accesar recursos de acuerdo al nmero de recursos disponibles Contador es inicializado en N, donde N es la cantidad de unidades disponibles del recurso
Ejemplos Clsicos de Sincronizacin
Problema Productor/Consumidor
Un buffer en memoria con N slots disponibles
Necesita llevar cuenta de temes en buffer
Productor produce temes a ingresar al buffer Consumidor consume temes del buffer
C
Productor Agrega item usando puntero in out in
Consumidor Remueve item usando puntero out
Algoritmo Productor/Consumidor
int contador = 0; //indica nmero de items en buffer Tipo buffer[N]; int in = 0; int out = 0; Productor while (true) { /* produce un item en proxProd */ while (contador == N); //espera buffer[in] = proxProd; in = (in + 1) % N; contador++; } Consumidor while (true) { while (contador == 0); //espera proxCons = buffer[out]; out = (out + 1) % N; contador--; /* consume prodCons */ }
Cmo resolver problema?
Identificar restricciones inherentes al problema
Estado
compartido?
contador (consumidores y productores) Buffer
in ( productores) . Productores no pueden insertar en buffer lleno out ( consumidores). Consumidores no pueden extraer de buffer vaco
Posible resolver con locks? Si Posible resolver con semforos? Si
Cmo resolver problema?
Identificar estado compartido y restricciones de problema
Buffer de tamao limitado compartido entre productores y consumidores Productor escribe en buffer[in], in indica posicin de escritura en buffer Consumidor extrae de buffer[out], out indica posicin de extraccin de buffer Contador indica el nmero de elementos actuales en el buffer Mltiples productores deben manipular in, buffer[in] y contador atmicamente. Mltiples consumidores deben manipular out, buffer[out] y contador atmicamente Mltiples consumidores y productores deben manejar contador atmicamente
Solucin Productor/Consumidor usando locks
int contador = 0; //indica nmero de items en buffer char buffer[N]; int in = 0; int out = 0; lock_t mutex; Consumidor Productor while (true) { /* produce un item en proxProd */ lock(mutex); while(contador == N){ unlock(mutex); yield(); lock(mutex); } buffer[in] = proxProd; in = (in + 1) % N; contador++; unlock(mutex); } While(true){ lock(mutex); while(contador == 0){ unlock(mutex); yield(); lock(mutex); } proxCons = buffer[out]; out = (out + 1) % N; contador--; unlock(mutex); /* consume proxCons */ }
Solucin usando semforos
Identificar estado compartido y restricciones de problema
Ya presentadas Cuando buffer est lleno productores deben esperar a que exista una posicin vaca (generada por un consumidor) Cuando buffer esta vaco consumidores deben esperar a que exista un elemento en el buffer (generado por un productor) Acceso a buffer y contador debe realizarse atmicamente Mutex (inicializado en 1): para exclusin mutua de buffer, in, out y contador. Full (inicializado en 0). Para indicar cuntas posiciones llenas hay en el buffer Empty (inicializado en N). Para indicar cuantas posiciones vacas hay en el buffer
Especificar condiciones de espera y sealizacin
Identificar semforos para proveer sincronizacin
Proporcionar algoritmos
Solucin usando semforos
int contador = 0; //indica nmero de items en buffer char buffer[N]; int in = 0; int out = 0; sem mutex=1; sem vacio = N; sem lleno = 0; Productor while (true) { /* produce un item en proxProd */ wait(vacio); wait(mutex); buffer[in] = proxProd; in = (in + 1) % N; contador++; signal(mutex); signal(lleno); } Consumidor While(true){ wait(lleno); wait(mutex); proxCons = buffer[out]; out = (out + 1) % N; contador--; signal(mutex); signal(vacio); /* consume proxCons */ }
Ejemplos
Productor/consumidor usando pthreads y locks Productor/consumidor usando pthreads y semforos
http://www.inf.udec.cl/~chernand/so/ejemplos/prodconsLocks.cpp
http://www.inf.udec.cl/~chernand/so/ejemplos/prodconsSem.cpp
Problema lectores/escritor
Caso base de datos
Varios
lectores pueden accesar registro datos simultaneamente Slo un escritor puede escribir
L E Registro BD L
Cmo resolver problema?
Identificar estado compartido y restricciones de problema
Base de datos compartida
Mientras haya un lector un escritor no puede accesar base de datos Mientras exista un escritor en base de datos ningn otro escritor o lector puede accesarla
Identificar condiciones de espera y sealizacin
Si existe un escritor en BD otro escritor o lector debe esperar Cuando un escritor termina debe sealizar escritor o lector que espera Si podemos tener varios lectores debemos contarlos, para saber cuando existe uno
Si hay uno leyendo y llegan otros, otros tambien pueden leer Si solo hay uno y sale puede haber un escritor esperando accesar BD
Qu semforos necesitamos
Uno inicializado en 1 como mutex para manejar contador de lectores Uno tipo mutex para escritor y primer lector
Algoritmo usando semforos
sem mutex=1; sem escribir = 1; Int contadorLectores = 0; Escritor: wait(escribir); espera por escritor o lector Escritor_escribe; Escribe objeto signal(escribir); permite leer y/o escribir a otros, escritura completada Lector: wait(mutex); asegura acceso exclusivo a contador de lectores contadorLectores++; incrementa lectores if(contadorLectores == 1) then wait(escribir); Si es el primer lector espera si hay escritor signal(mutex); Lector_lee; wait(mutex); asegura acceso exclusivo a contador de lectores contadorLectores--; lector termin de leer if(contadorLectores == 0) then signal(escribir); no mas lectores por si escritor esperaba signal(mutex)
Notas sobre Lectores/Escritores
Primer lector se bloquea si hay un escritor activo cualquier otro escritor se bloquea tambin Si un escritor espera porque existen lectores activos, el ltimo lector lo despierta cuando sale pueden otros lectores entrar cuando el escritor est esperando? Cuando un escritor sale, si hay un escritor y un lector esperando quien entra?
Otro ejemplo clsico
Problema de Filsofos comensales
Cada filsofo tiene su plato de arroz, con 5 palitos 5 filsofos se sientan a la mesa. Piensan por un rato y cuando les da hambre comen Hay slo 5 palitos en la mesa (cada persona necesita 2 palitos para comer arroz a la manera china) Para poder comer cada filsofo tiene que obligatoriamente conseguir dos palitos
Problema es importante porque introduce posibles problemas de Deadlock(bloqueo mortal) y Starvation(inanicin)
Problema de Filsofos comensales
Problemas que pueden surgir con mala sincronizacin
Deadlock Hebras/Procesos estn en deadlock cuando
2 o ms hebras o procesos estn esperando por una condicin que slo puede ser causada por una hebra que tambien est esperando. Puede darse con 2 o ms hebras en la lista de espera de un mismo semforo?
Starvation o espera indefinida Hebras/Procesos esperan indefinidamente para poder accesar un recurso.
Ejemplo, una hebra en la lista de espera de un semforo de la cual estn entrando y saliendo continuamente hebras y la lista de espera de semforo es LIFO
Ejemplo deadlock con productor/consumidor
int contador = 0; //indica nmero de items en buffer char buffer[N]; int in = 0; int out = 0; sem mutex=1; sem vacio = N; sem lleno = 0; Productor while (true) { /* produce un item en proxProd */ wait(mutex); wait(vacio); buffer[in] = proxProd; in = (in + 1) % N; contador++; signal(mutex); signal(lleno); } Que sucede aqu? Consumidor While(true){ wait(lleno); wait(mutex); proxCons = buffer[out]; out = (out + 1) % N; contador--; signal(mutex); signal(vacio); /* consume proxCons */ }
Problemas con Semforos
A pesar que se pueden usar para resolver cualquier problema de sincronizacin Son variables globales por lo tanto pueden ser accesadas de cualquier hebra directamente
no es buena tcnica de ingeniera de software
No hay conexin entre el semforo y el recurso para el cual se quiere controlar acceso Usados como mutex (ingreso a seccin crtica) y para coordinacin (planificacin, eleccin quien tiene acceso al recurso) No se puede controlar su uso, no hay garanta que el programador los use adecuadamente (fcil de cometer errores)
Resumen
Semforos primitivas de sincronizacin de ms alto nivel que locks No relacin entre semforo y recurso que controla Fcil de cometer errores que pueden producir deadlock y starvation
Importante
entender bien problema antes de
utilizarlos
Prxima semana Monitores
