Captulo 6: Sincronizacin entre

Procesos

Captulo 6: Sincronizacin entre Procesos

Introduccin
El problema de la seccin-crtica
La solucin de Peterson
Sincronizacin en Hardware
Semforos
Problemas clsicos de sincronizacin
Monitores
Ejemplos de sincronizacin

Introduccin

El acceso concurrente a datos compartidos puede resultar en

inconsistencias
Mantener la consistencia de los datos requiere el uso de
mecanismos que aseguren la ejecucin ordenada de procesos
que cooperan
Suponga que queremos proporcionar una solucin al problema
de productor-consumidor con buffer limitado
Podemos hacerlo teniendo un entero count que registra el #
elementos en el buffer
Inicialmente, count = 0
El productor incrementa count luego de producir un
elemento
El consumidor decrementa count luego de consumir del
buffer

Productor
while (true) {
/* produce an item and put in nextProduced */
while (count == BUFFER_SIZE)
; // do nothing
buffer [in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
count++;
}

Consumidor
while (true) {
while (count == 0)
; // do nothing
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
count--;
/* consume the item in nextConsumed
}

Condiciones de Carrera

count++ puede ser implementado como:

register1 = count
register1 = register1 + 1
count = register1
count- - puede ser implementado como:
register2 = count
register2 = register2 - 1
count = register2
Considere este entrelazado de la ejecucin en el cual,
inicialmente count = 5:
S0: productor ejecuta register1 = count {register1 = 5}
S1: productor ejecuta register1 = register1 + 1 {register1 = 6}
S2: consumidor ejecuta register2 = count {register2 = 5}
S3: consumidor ejecuta register2 = register2 - 1 {register2 = 4}
S4: productor ejecuta count = register1 {count = 6 }
S5: consumidor ejecuta count = register2 {count = 4}

Condiciones de Carrera

Problema
Las condiciones de carrera se dan cuando varios
procesos accesan y manipulan los mismos datos
concurrentemente, y el resultado final depende del
orden particular en que los accesos se llevaron a
cabo
Solucin
Usar mecanismos de sincronizacin para que
solamente un proceso pueda manipular los datos a la
vez

Problema de la Seccin-Crtica
1.

2.

3.

Exclusin mutua: Si el proceso Pi est ejecutando su

seccin crtica, ningn otro proceso puede estar
ejecutando la suya
Progreso: Si ningn proceso est ejecutando su
seccin crtica y existe algn otro proceso que desea
entrar a la suya, entonces ese proceso no puede
posponerse indefinidamente
Espera limitada: Debe haber un lmite en el nmero
de veces que otros procesos pueden entrar a sus
secciones crticas despus de que un proceso a
solicitado entrar a la suya, y antes de que se le
otorgue el acceso a ese proceso

Problema de la Seccin-Crtica (cont.)

1.

2.
3.
4.

Condicin de carrera: Cuando hay acceso

concurrente a datos compartidos y el resultado
final depende del orden de ejecucin
Seccin crtica: Seccin de cdigo en donde se
accesa a los datos compartidos
Seccin de entrada: Cdigo que solicita el
permiso para entrar a su seccin crtica
Seccin de salida: Cdigo que se ejecuta al
salir de la seccin crtica

Estructura de un Proceso Tpico

10

Solucin de Peterson

Solucin para dos procesos

Asuma que las instrucciones LOAD y STORE son
atmicas (no pueden ser interrumpidas)
Los procesos comparten dos variables:
int turn;
Boolean flag[2]
turn indica a quin le toca el turno para entrar a su
SC
El arreglo flag es usado para indicar si un proceso
est listo para entrar a su SC
flag[i] = true implica que el proceso Pi est listo

11

Algoritmo para el Proceso Pi

P0

while (true) {

P1

while (true) {

flag[0]=TRUE;

flag[1]=TRUE;

turn=1;

turn=0;

while (flag[1] && turn==1);

while (flag[0] && turn==0);

//seccion critica P0

//seccion critica P1

flag[0]=FALSE
}

flag[1]=FALSE
}

12

Sincronizacin en HW: Candados

Cmo se implementan los locks en HW?

13

Sincronizacin en HW: Detalles

Muchos sistemas proporcinan soporte de HW para SC

Uniprocesadores se puede desabilitar las
interrupciones
El cdigo siendo ejecutado se ejecutara sin ser
apropiado
Generalmente es muy ineficiente en sistemas
multiprocesador
S.O.s que hagan esto no seran muy escalables
Mquinas modernas proporcionan instrucciones
atmicas especiales en HW
Se prueba la palabra en memoria y setea su valor
O se hace un swap de los contenidos de dos
palabras de memoria

14

TestAndSet

La funcin no es interrumpida y si se llama al mismo tiempo cada proceso

la ejecuta de forma sequencial.

boolean TestAndSet (boolean *target)

{
boolean rv = *target;
*target = TRUE;
return rv:
}

15

Usando TestAndSet
Lock =Variable typo bool compartida e inicializada a falso
do {
while ( TestAndSet (&lock ))
; // do nothing
//

critical section

lock = FALSE;
//

remainder section

} while (TRUE);

16

Sincronizacin en HW: Usando Swap

Intercambia el valor de dos variables, las misma consideraciones de

TestAndSet() se aplican:

void Swap (boolean *a, boolean *b)

{
boolean temp = *a;
*a = *b;
*b = temp:
}

17

Sincronizacin en HW: Usando Swap

Lock =Variable typo bool compartida e inicializada a falso, cada

proceso tiene una copia local de key

do {
key = TRUE;
while ( key == TRUE)
Swap (&lock, &key );
//

critical section

lock = FALSE;
//

remainder section

} while (TRUE);
18

Exclusin mutua con multiples procesos

Waiting y Lock compartidos,inicializados a falso.

La variable i indica el proceso
do {
waiting[i] = TRUE;
key = TRUE;
while (waiting[i] && key)
key = TestAndSet(&lock);
waiting[i] = FALSE;
// critical section
j = (i + 1) % n;
while ((j != i) && !waiting[j])
j = (j + 1) % n;
if (j == i)
lock = FALSE;
else
waiting[j] = FALSE;
// remainder section
} while (TRUE);
19

Sincornizacion Librerias:Semforos

Semforo S variable entera

Dos operaciones estndar modifican S: wait() y
signal()
Menos complicados de usar que soluciones de HW
Pueden ser accesados via dos operaciones atmicas
wait (S) {
while S <= 0 ; // no-op
S--;
}
signal (S) {
S++;
}
20

Semforos como una Herramienta de

Sincronizacin General

Semforo contador valor entero que puede

cambiar dentro de un dominio no restringido
Semforo binario valor entero cuyo valor puede
ser 0 o 1; ms sencillo de implementar
Tambin llamados mutex locks
Semaphore mutex;

// initialized to 1

do {
wait (mutex);
// Critical Section
signal (mutex);
// remainder section
} while (TRUE);

21

Implementacin de Semforos

Se debe garantizar que dos procesos no puedan ejecutar

wait() y signal () en el mismo semforo, al mismo tiempo
Por lo tanto, implementar un semforo se torna el problema de
la SC, en donde el cdigo de wait y signal se colocan en la SC
Se puede tener una implementacin con busy waiting
Tambin llamado spinlock
No es muy grave si se entra poco seguido a la SC
Pero en ocasiones se puede desear usar la SC muy seguido
ineficiente

22

Implementacin de Semforos sin BW

Cada semforo se asocia con una cola de

espera; cada entrada en la cola tiene dos datos:
valor (entero)
puntero al sgt. registro en la lista
Dos operaciones:
block colocar el proceso que invoca la
operacin en la cola de espera apropiada
wakeup eliminar uno de los procesos de la
cola de espera y colocarlo en la cola de listos

23

Implementacin de Semforos sin BW (cont.)

Implementacin de wait():
wait(semaphore *S) {
S->value--;
if (S->value < 0) {
add this process to S->list;
block();
}
}

Implementacin de signal():
signal(semaphore *S) {
S->value++;
if (S->value <= 0) {
remove a process P from S->list;
wakeup(P);
}
}

24

Interbloqueo e Inanicin

Interbloqueo dos o ms procesos esperan indefinidamente por un

evento que puede ser causado solamente por uno de los procesos
que est esperando
Si S y Q son semforos inicializados en 1
P0
P1
wait(S);
wait(Q);
wait(Q);
wait(S);
.
.
.
.
signal(Q);
signal(S);
signal(S);
signal(Q);
Inanicin bloqueo indefinido. Un proceso puede nunca ser
removido de la cola del semforo en la que est esperando

25

Problemas Clsicos de Sincronizacin

Problema del Buffer-Limitado
Problema de los Lectores-Escritores
Problema de la Cena de Filsofos

26

Problema del Buffer-Limitado

Buffer de tamao N
Semforo mutex inicializado en 1
Semforo full inicializado en 0
Semforo empty inicializado en N

27

Problema del Buffer-Limitado (cont.)

Productor

do {

Consumidor
do {

// produce an item

wait (full);

wait (empty);

wait (mutex);

wait (mutex);

// remove an item

// add the item

signal (mutex);

signal (mutex);

signal (empty);

signal (full);

// consume the item

} while (TRUE);

} while (TRUE);

Empty=indica si hay espacios en el buffer donde colocar datos

Mutex=da acceso a la seccion critica
Full=indica si hay datos que leer en el buffer
28

Problema de los Lectores-Escritores

Un conjunto de datos se comparte entre un #

concurrente de procesos
Lectores solo leen datos
Escritores pueden leer y escribir
Problema permitir que mltiples lectores lean al
mismo tiempo; solo un escritor puede tener
acceso a los datos a la vez
Datos compartidos
Conjunto de datos
Semforo mutex inicializado en 1
Semforo wrt inicializado en 1
Entero readerCount inicializado en 0

29

Estructura

Escritor

do {

Lector
do {

wait (wrt) ;

wait (mutex) ;
readcount ++ ;
if (readcount == 1)
wait (wrt) ;
signal (mutex)

// writing is performed
signal (wrt) ;

// reading is performed

} while (TRUE);

wait (mutex) ;
readcount - - ;
if (readcount == 0)
signal (wrt) ;
signal (mutex) ;
} while (TRUE);

30

Problema de la Cena de Filsofos

Datos compartidos
Tazn de arroz (conjunto de datos)
Semforo chopStick [5] inicializado en 1
Filsofos pueden comer o pensar

31

Problema de la Cena de Filsofos (cont.)

Estructura del filsofo i:

do {
wait ( chopstick[i] );
wait ( chopStick[ (i + 1) % 5] );
// eat
signal ( chopstick[i] );
signal (chopstick[ (i + 1) % 5] );
// think
} while (TRUE);

32

Problemas con Semforos

Incorrecto uso de operaciones:

wait (mutex) wait (mutex)

Omitir un wait (mutex) o signal (mutex) (or ambos)
signal (mutex) . wait (mutex)

33

Monitores

Abstraccin de alto nivel que proporciona un

mecanismo efectivo y conveniente para la
sincronizacin entre procesos.
Solo un proceso puede estar activo dentro del monitor
en un momento dado.

34

Sintaxis de un Monitor

35

Esquema de un Monitor

36

Monitores

SO provee semforos o mutexes.

Lenguaje provee enunciados para monitores.
Compilador usa primitivas del SO para traducir los
procedimientos del monitor de tal manera que se
considere la exclusin mutua.
Programador no se preocupa de codificar semforos
Programador slo debe incluir las secciones crticas
como parte de un procedimiento de monitor.

37

Variables de Condicin

Condition x, y;
Dos operaciones en una variable de condicin:
x.wait () un proceso que invoca la operacin
es suspendido
x.signal () se contina a uno de los procesos
que invocaron x.wait ()

38

Variables de condicin

Los procedimientos en un monitor se pueden llamar

siempre considerando la exclusin mutua.

Existe acceso coordinado a buffers y variables

compartidos.

Pero como un proceso puede ir a sleep si no pudiera

continuar?
Si necesitara que se complete un evento
Tal vez este evento debe ser generado por otro
proceso.

39

Variable de condicin

Solucin:
Uso de variables de condicin, y
Uso de operaciones wait() y signal() en esas
variables

Si un proceso necesita bloquearse:

(Por ejemplo, buffer est lleno y productor no debe
colocar ms informacin)
Proceso llama wait() en alguna variable de condicin
x.

40

Variable de condicin

Cuando otro proceso quiere desbloquear al proceso que

est durmiendo:
(por ejemplo?).
El proceso llama signal() en la misma variable de
condicion x.

Las variables de condicin NO SON CONTADORES.

No almacenan seales signal.
signal() debe ser llamado despus de wait().

41

Monitor con Variables de Condicin

42

Solucin al Problema de la Cena de Filsofos

monitor DP
{
enum { THINKING; HUNGRY, EATING) state [5] ;
condition self [5];
void pickup (int i) {
state[i] = HUNGRY;
test(i);
if (state[i] != EATING) self [i].wait;
}
void putdown (int i) {
state[i] = THINKING;
// test left and right neighbors
test((i + 4) % 5);
test((i + 1) % 5);
}

43

Solucin al Problema de la Cena de Filsofos

void test (int i) {
if ( (state[(i + 4) % 5] != EATING) &&
(state[i] == HUNGRY) &&
(state[(i + 1) % 5] != EATING) ) {
state[i] = EATING ;
self[i].signal () ;
}
}
initialization_code() {
for (int i = 0; i < 5; i++)
state[i] = THINKING;
}
}

44

Solucin al Problema de la Cena de Filsofos

(cont.)

Cada filsofo invoca las operaciones pickup(i) y

putdown(i) en la siguiente secuencia:
DiningPhilosophters.pickup (i);
//comer
DiningPhilosophers.putdown (i);

45

Implementacion de Monitor usando

semaforo

Variables
semaphore mutex; // (inicializado = 1)
semaphore next; // (inicializado = 0), proceso que sigue
int next-count = 0; //numero de procesos

Cada procedimiento F es reemplazado por

wait(mutex);

body of F;

if (next_count > 0)
signal(next)
else
signal(mutex);

Exclusion mutua esta garantizada

46

Monitor Implementacion

Para cada variable de condicion X, tenemos:

semaphore x_sem; // (inicializado = 0)
int x-count = 0;

La operacion x.wait puede ser implementada:

x-count++;
if (next_count > 0)
signal(next);
else
signal(mutex);
wait(x_sem);
x-count--;

47

Monitor Implementation
La operacion x.signal puede ser implementada asi:

if (x-count > 0) {
next_count++;
signal(x_sem);
wait(next);
next_count--;
}

48

Un Monitor para compartir recursos

monitor ResourceAllocator
{
boolean busy;
condition x;
void acquire(int time) {
if (busy)
x.wait(time);
busy = TRUE;
}
void release() {
busy = FALSE;
x.signal();
}
initialization code() {
busy = FALSE;
}
}

49

Ejemplos de Sincronizacin

Solaris
Windows XP
Linux
Pthreads

50

Solaris

Varios locks diferentes:

Mutexes adaptivos (eficientes) para segmentos
pequeos de cdigo
Usa condition variables y locks lectoresescritores para segmentos ms largos de
cdigo

51

Windows XP

Mscaras de interrupcin para proteger acceso a

recursos globales en sistemas uniprocesador
Usa spinlocks en sistemas multiprocesador
Proporciona dispatcher objects que pueden
actuar como mutexes y semforos
Proporcionan eventos
Muy similares a variables de condicin

52

Linux

Linux:
Desabilita interrupciones para SC cortas
Proporciona:
semforos
spinlocks

53

Pthreads

API de es independiente del S.O.

Proporciona:
Mutex locks
Variables de condicin
Extensiones no portables incluyen:
read-write locks
spinlocks

54

Fin del Captulo 6