Semaforos

Sincronización de Procesos
Semáforos
Emely Arráiz
Ene-Mar 08

Conceptos
 Herramienta de sincronización (provista por el
SO).
 Un semáforo S es una variable de tipo entero, que
además de ser inicializada.
 Puede ser accedida a través de dos operaciones
atómicas y mutuamente excluyentes
– wait(S) o P(S) o down(S)
– signal(S) o V(S) o up(S)
 Para evitar busy-waiting, cuando un procesos
tiene que esperar, se pondra en una cola de
procesos bloqueados esperando un evento.

Conceptos
 Semáforo puede ser implementado como una
estructura con dos campos
– count : integer
– queue: list of processes
 Cuando un proceso debe esperar por un
semáforo S, el es bloqueado (block() ) y colocado
en la cola del semaforo.
 La operación de signal remueve (wakeup() )un
proceso desde la cola y lo coloca en la lista de
procesos ready.

Semáforos binarios y
semáforos generales
• Semáforo binario
– Solo puede tener dos valores, 0 y 1, y
es la forma más común de semáforo.
• Semáforo general
– Son semáforos que pueden tomar
muchos valores positivos.

Semáforos
type semaphore = record
count: integer;
queue: list of process
end;
var S: semaphore;
• Cuando un proceso debe esperar a un semáforo S, se
bloquea y se pone en la cola del semáforo S.
• La operación signal quita (con la política FIFO) un
proceso de la cola y lo pone en la cola de procesos
listos.

Observaciones de Semaforos
(Negativos)
• Si S.count >=0
– El número de procesos que pueden ejecutar
wait(S) sin que se bloqueen = S.count
• Si S.count<0
– el número de procesos que están esperando en S
es = S.count|

Semáforos sin busy-waiting
wait(S):
S.count- -;
if (S.count < 0) {
colocar este proceso en S.queue
block este proceso (block), o sleep el proceso
{
signal(S):
S.count++;
if (S.count < = 0){
remover el proceso de la cola
colocar este proceso en lista de ready (wakeup(P))
}
La magnitud del valor negativo es el numero de procesos en
waiting.

Operaciones
 Atomicidad y exclusión mutua implica que dos
procesos NO pueden estar en wait(S) y signal(S)
al mismo tiempo sobre el mismo S.
 Los bloques de código definidos por wait (S) y
signal (S) son secciones críticas.
 Las secciones críticas definidas por wait (S) y
signal (S) son muy cortas, típicamente 10
instrucciones.

Exclusión Mutua
 N procesos. S inicializado en 1.
 Un solo proceso le es permitido entrar en la SC.
 Proceso Pi:
repeat
wait(S)
SC
signal(S)
RS
until false

Sincronización
 Sea P1 y P2 dos procesos. La instr. S1 de P1
necesita ser ejecutada antes que la instr. S2 de
P2.
 Definimos un semáforo synch, el cual
inicializamos en cero. synch=0
 La sincronización la obtenemos
P1: S1;
signal(synch);
P2: wait(synch);
S2;

Synchronizing with SemaphoresSynchronizing with Semaphores
♥Mutual Exclusion:Mutual Exclusion:
wait(mutex);
critical section
signal(mutex);
♥Synchronization:Synchronization:
requirement: S2 executed after S1 is
completed
Synch = 0
P1: S1; P2: wait(Synch);(Synch);
signal(Synch);(Synch); S2;

deadlocks with Semaphores...deadlocks with Semaphores...
♥Two processes p0 and p1
♥Two semaphores QQ and SS
p0 : p1:
wait(S);(S); wait(Q);wait(Q);
wait(Q);wait(Q); wait(S);wait(S);
…….. …..…..
signal(S);signal(S); signal(Q);signal(Q);
signal(Q);signal(Q); signal(S);signal(S);
♥ p0 does the first line, then p1 and so on...

More on Synchronization...More on Synchronization...
Three processes p1; p2; p3
semaphores s1 = 1, s2 = 0s1 = 1, s2 = 0;
p1p1 p2p2 p3p3
wait(s1s1); wait(s2s2); wait(s2s2);
.. code .. .. code .. .. code ..
signal(s2s2); signal(s2s2); signal(s1s1);
the ordering of the processes isthe ordering of the processes is
((p1(p2*(p3)))*p1(p2*(p3)))*

What’s wrong with busy waitingWhat’s wrong with busy waiting
♥Wastes cpu time by waiting
♥Side effects:
♦Two processes with different priorities arrive
at their critical section in an order inverse to
their priorities
♦The higher priority process gets time-slices
♦The lower priority process cannot complete its
processing of its critical section and leave !
Priority Inversion

Semaforos Binarios
 Los semaforos que hemos estudiado son
llamados contadores o enteros.
 Tenemos tambien semáforos binarios.
– Similar a los anteriores solo que count tiene valor
boolean

Spinlocks
 Son semáforos enteros que usan busy waiting,
en lugar de blocking.
 Util sobre multiprocesadores …..
 Se gasta tiempo de CPU pero salvamos switch
entre procesos
wait(S): S--;
while S< 0 do{}
signal(S): S++;

Problemas Clásicos.
Sincronización
 Bounded- Buffer
 Readers and Writers
 Dining - philosophers

Bounded - Buffer
N :buffer de un items cada uno.
mutex :semáforo inicializado en 1.
Full : semáforo inicializado en 0. (contador)
Empty : semáforo inicializado en N. (contador)
La estructura del proceso
Productor
while (TRUE) { (Obs: el productor por Empty >0
produce item; para poder anadir items.
wait(Empty);
wait(mutex);
añade item al buffer;
signal(mutex);
signal(Full);
}

Bounded- Buffer (cont)
consumidor
while (TRUE) { (Obs: El consumidor espera por Full>0)
wait(Full);
wait(mutex);
remueve item del buffer;
signal(mutex);
signal(Empty);
consume item;
}

Readers - Writers
Data es compartida entre diferentes procesos concurrentes.
Lectores: leen solamente. No ejecutan modificaciones.
Escritores: leen y escriben
Problema: permitir múltiples lectores pero solamente un escritor.
Procesos lectores nunca esperan a menos que un escritor esté en su
sección crítica.
Data compartida
Conjunto de datos.
mutex :semáforo inicializado en 1.
wrt : semáforo inicializado en 1.
readcount : entero inicializado 0.

Readers-Writers (cont.)
Writer[1..n]
escritor
while (TRUE) {
wait(wrt);
escribo;
signal(wrt);
}

Readers-Writers (cont.)
La estructura del proceso. Reader[1..m]
lector
while (TRUE) {
wait(mutex);
readcount++;
if (readcount == 1) wait(wrt);
signal(mutex);
ejecuta lectura;
wait(mutex);
readcount-- ;
if (readcount == 0) signal(wrt);
signal(mutex);
}

Dining Philosophers
Clásico
Problema
de
Sincroniza
ción.
Datos compartidos
1 bowl de Rice
semaforos tenedor[5]
inicializado 1
1 semaforo
5
4
3

Problema
 Cada filósofo es un proceso.
 Un semáforo por tenedor
fork: array[0..4] of semáfores.
Para todo i inicializar fork[i].count=1

Filósofos - Solución
Process Pi
repeat
think;
wait(fork[i]);
wait(fork[(i+1) mod 5]);
eat;
signal(fork[(i+1) mod 5]);
signal(fork[i]);
until false
Problema : Deadlock

Filósofos - Solución
#define N 5
#define RIGHT(i) (((i)+1) %N)
#define LEFT(i) (((i)== N) ? 0 : (i)+1)
Typedef enum { THINKING, HUNGRY, EATING } phil_state;
phil_state state [N] ;
Semaphore mutex = 1;
Semaphore s [N] ;
void test (int i) {
if (state [i] == HUNGRY &&
state [LEFT(i)] != EATING &&
state [RIGHT(i)] != EATING ) { state [i] == EATING; signal(s[i]); }
}
void get_forks(int i) {
wait(mutex);
state [i] == HUNGRY;
test(i);
signal(mutex);
wait(s[i]);
}

Filósofos – Solución (cont.)
void put_forks(int i) {
wait(mutex);
state [i] == THINKING;
test(LEFT(i));
test(RIGHT(i));
signal(mutex);
}
void philosopher(int i) {
while(1) {
think();
get_forks(process);
eat();
put_forks(process);
}
}

Problemas con Semáforos
 Semáforos son herramientas poderosas para
exclusión mutua y coordinación de procesos.
 Difícil entender sus efectos cuando los wait(S) y
signal(S) están esparcidos entre varios
procesadores.
 Uso debe ser correcto en todos los
procesadores. Es fácil cometer errores en la
programación de los semáforos
 El tiempo durante el cual un proceso está
bloqueado en un semáforo no está limitado.

Semaforos

Más contenido relacionado

La actualidad más candente (7)

Similar a Semaforos (20)

Más de David Lilue (11)

Semaforos