Sunteți pe pagina 1din 51

Cursul 5

5
Sincronizarea proceselor

25 martie 2009
Suport curs 5

 OSC

– Capitolul 6 – Process Synchronization

 Seciunile 6.1-6.5, 6.6.1, 6.6.2, 6.8.2-6.8.4

– Capitolul 7 - Deadlocks

 MOS

– Capitolul 2 – Processes and Threads

 Seciunile 2.3.1–2.3.6, 2.3.9, 2.4.2

– Capitolul 3 - Deadlocks

 Little Book of Semaphores

– Capitolele 1, 2, 3

– Capitolul 4 – Seciunile 4.1, 4.2

25.03.2009 2
Cuprins

 Problematica IPC

 Condiii de curs ; sincronizare


 Regiuni critice

 Semafoare; mutexuri; bariere

 Problema produc tor-consumator


 Problema cititori-scriitori

 Deadlock-uri

25.03.2009 3
Comunicarea între procese (IPC)

 Colaborare

– schimb de informaie

– partajarea informaiei

 
Concuren /competiie

– acces exclusiv (regiuni critice)

 rezultate predictibile

 accesul concurent poate produce inconsistene

 serializarea accesului

 Coordonare

– ordonarea aciunilor unui proces în funcie de aciunile altui proces

– sincronizare

25.03.2009 4
Acces exclusiv i sincronizare

 Un proces (P1) folosete cu resursa R

 Un alt proces (P2) solicit  resursa R prelucrat de P1


 P2 trebuie s  atepte (acces exclusiv) eliberarea resursei R

 P1 folosete R1 i produce R2

  R2
P2 solicit

 P2 trebuie s atepte ca P1 s produc R2 (sincronizare)

 Mecanisme de tip eveniment

– signal/notify – notific  producerea evenimentului/aciunii


– wait – ateapt  producerea evenimentului pentru sincronizare

25.03.2009 5
Acces concurent

 Resurs  comun – fiier, zon de memorie

 Situaie

a = 0 /* initializare */
– dou  instane de execuie ruleaz
if (a == 0)
a++;
– Ce valoare va avea a dup  execuie?

25.03.2009 6
Condiii de curs (race conditions)

proces 1 proces 2
a = 0

if (a == 0)

if (a == 0)
a = 1 a++;

a++; a = 2

25.03.2009 7
Operaii atomice

 Operaii care se execut  într-un singur ciclu de instruciune


 În câte cicluri se execut a++?

 Secven posibil:

thread1 thread2 a reg1 reg2


load a, reg1 0 0 0
inc reg1 0 1 0
load a, reg2 0 1 1
inc reg2 0 1 1
store reg2, a 1 1 1
store reg1, a 1 1 1

25.03.2009 8
Regiuni critice

 Critical sections

 P ri din program care acceseaz resurse partajate


 Pot fi executate în paralel de mai multe instane de execuie

 Exemple

– a++

– parcurgerea/ad ugarea/tergerea unor elemente dintr-o list


 Se pot genera condiii de curs 
– soluie: protejare prin excludere mutual 
 o singur  instan de execuie are acces la regiunea critic
 serializarea accesului

25.03.2009 9
Regiuni critice (2)

25.03.2009 10
Excludere mutual 

 Implementare busy-waiting

– procesul care ateapt  s intre în regiunea critic folosete procesorul


– testare în bucl  a valorii unei variabile

 Implementare blocant 
– procesul care ateapt  s intre în regiunea critic este trecut în starea
BLOCKED

– când regiunea critic  este liber, procesul este trecut în starea


READY/RUNNING

25.03.2009 11
Dezactivarea întreruperilor

 Asigur  protecie doar pe sisteme uniprocesor


– pe un sistem uniprocesor o schimbare de context este iniiat 
numai prin intermediul unei întreruperi

– dezactivare întreruperi = nu mai exist schimbri de context

 Avantaje/dezavantaje

– simplitate

– relativ lent 
– funcioneaz  doar pe sisteme uniprocesor
– poate fi folosit doar din cod kernel

25.03.2009 12
Kernel preemptiv/non-preemptiv

 Codul kernel este cod executat de toate procesele

– structurile de date ale kernel-ului sunt susceptibile la condiii de curs 


 Kernel preemptiv

– un proces poate fi preemptat în timp ce ruleaz  cod kernel


– mai complex de implementat

– timp bun de r spuns


 Kernel non-preemptiv

– procesul care ruleaz  cod kernel nu poate fi preemptat decât la ieirea din
kernel

– mai simplu de implementat

–  mai mare
laten

– pot aprea probleme de sincronizare pe sisteme SMP

25.03.2009 13
Lock-uri

void LOCK(void) void UNLOCK(void)


{ {
while (lock > 0) lock--;
continue; }
lock++;
}

 La intrarea în regiunea critic se apeleaz LOCK


 La ieirea din regiunea critic se apeleaz UNLOCK

 Este implementarea corect?

25.03.2009 14
Alternare strict 

while (TRUE) { while (TRUE) {


while (turn != 0) while (turn != 1)
continue; continue;
critical_region(); critical_region();
turn = 1; turn = 0;
noncritical_region(); noncritical_region();
} }

 Procesul mai lent îl ine lalt


pe loc pe cel

25.03.2009 15
Algoritmul lui Peterson

int turn;
int interested[2];

void enter_region(int process)


{
int other = 1 – process;

interested[process] = 1;
turn = process;
while (turn == process && interested[other] == 1)
continue;
}

void leave_region(int process)


{
interested[process] = FALSE;
}

25.03.2009 16
Hardware de sincronizare

 TestAndSet/TSL (Test and Set Lock)

 TSL RX, LOCK

– se citete variabila LOCK în registrul RX

– se pune valoarea TRUE (activat) în LOCK

– operaia se execut  atomic


 Echivalent cu

boolean TestAndSet(boolean *target)


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

25.03.2009 17
Hardware de sincronizare (2)

 Exemplu de utilizare TestAndSet

do {
while (TestAndSetLock(&lock))
Continue;
/* regiune critica */
lock = FALSE;
/* regiune non-critica */
} while (TRUE);

25.03.2009 18
Spinlock-uri

enter_region: exit_region:
TSL RX, LOCK MOV LOCK, 0
CMP RX, 0
JNE enter_region

 Necesit  suport hardware


 Pe sistemele multiprocesor se folosesc în combinaie


cu acces exclusiv la magistral

 Soluie independent de numrul de procesoare

25.03.2009 19
Excludere mutual  prin blocare

 De ce nu busy-waiting?

– irosire timp procesor

 Când este util busy-waiting?

– când timpul de ateptare este mic

 Excludere mutual  prin blocare


– sleep() -> trece procesul în starea BLOCKED
– wakeup() -> trece procesul în starea READY
– necesit  suportul scheduler-ului

25.03.2009 20
Problema produc tor-consumator

 Dou  tipuri de procese


– procese produc tor
– procese consumator

 Un buffer comun de elemente

 tor nu poate produce dac bufferul este plin


Un produc

 Un consumator nu poate consuma dac bufferul este gol

25.03.2009 21
Problema produc tor-consumator (sleep & wakeup)

void producer(void) void consumer(void)

{ {

int item; int item;


while (TRUE) { while (TRUE) {
item = produce(); if (count == 0)
if (count == N) sleep();
Sleep(); item = remove_item(item);
insert_item(item); count--;
count++; if (count == N-1)
if (count == 1) wake_up(producer);
wake_up(consumer); consume_item(item);
} }
} }

condiie de curs :
se pierde wake-up-ul

25.03.2009 22
Semafoare

 Rezolvarea problemelor cu sleep i wakeup

 Dijkstra 1965

 Semaforul are asociat un contor

 Operaii pe semafor - atomice

– P (proberen = to test) (down/get/acquire)

 contorul este decrementat dac  este strict pozitiv


 altfel, procesul este trecut în starea BLOCKED

– V (verhogen = to increment) (up/post/release)

 contorul este incrementat

 dac  exist procese blocate la semafor sunt trezite

25.03.2009 23
Problema produc tor-consumator (semafoare)

semaphore to_full = N;
semaphore to_empty = 0;

void consumer(void) void producer(void)

{ {

int item; int item;

while(TRUE) { while (TRUE) {

P(to_empty); item = produce_item();


item = remove_item(); P(to_full);
V(to_full); insert_item(item);
consume_item(); V(to_empty);
} }

} }

25.03.2009 24
Mutex-uri

 Semafoare binare

 Dou  stri:
– locked

– unlocked

 Asem ntor unui spinlock fr busy-waiting

P(mutex);
/* regiune critica */
V(mutex)

25.03.2009 25
P-C (semafoare i mutex-uri)

semaphore to_full = N;
semaphore to_empty = 0;
semaphore mutex = 1;

void producer(void) void producer(void)


{ {
int item; int item;
while(TRUE) { while (TRUE) {
P(to_empty); item = produce_item();
P(mutex); P(to_full);
item = remove_item(); P(mutex);
V(mutex); insert_item(item);
V(to_full); V(mutex);
consume_item(); V(to_empty);
} }
} }

Asigurarea excluderii mutuale la lucrul cu bufferul

25.03.2009 26
Implementare posibil  mutex

mutex_lock: mutex_unlock:
TSL RX, MUTEX MOV MUTEX, 0
CMP RX, 0 ...
JZE ok
CALL sched_yield
JMP mutex_lock
ok:

 Similar  cu implementarea spinlock-urilor (non-busy waiting)


 Simpl i eficient (nu necesit trap în kernel dac regiunea

critic este liber)

25.03.2009 27
Implementare semafor

typedef struct {
int value;
struct process *list;
}
void down(semaphore *s)
{
s->value--;
if (s->value < 0) {
add(s->list, current_process);
sleep();
}
}
void up(semaphore *s)
{
if (s->value < 0) {
process = remove_process(s->list);
wakeup(process);
}
s->value++;
}

25.03.2009 28
Probleme de sincronizare

 Deadlock

– dou  procese ateapt la un semafor deinut de cellalt proces


– P0: down(&sem_a); down(&sem_b); ...

– P1: down(&sem_b); down(&sem_a); ...

– P0 este planificat înainte de obinerea lui sem_b

 Starvation

– ad ugarea/eliminarea proceselor din lista de procese a unui


semafor se face în ordinea LIFO

– ateptare nedefinit 
– priorit i statice

25.03.2009 29
Bariere

 Sincronizarea unui grup de procese

 Utile pentru rezolvarea de probleme inginereti

– o matrice conine valori iniiale i mai multe prelucr ri succesive care
trebuie aplicate

– pentru ca un proces s  înceap iteraia n, trebuie ca toate procesele s


încheie iteraia n+1

 Punctul de întâlnire a proceselor/thread-urilor se numete

rendezvous

25.03.2009 30
Bariere (2)

25.03.2009 31
Barier  (3)

#define N_PROCS 10

size_t count = 0; /* UNIX semaphore Z-operation */


semaphore mutex = 1;
semaphore barr_sem = 0; #define N_PROCS 10

void barrier(void) semaphore barr_sem = N_PROCS;


{
down(&mutex); void barrier(void)
count++;
{
if (count == N_PROCS)
down(&barr_sem);
up(&barr_sem, N_PROCS);
wait_for_zero(&barr_sem);
up(&mutex);
}

down(&barr_sem);
}

25.03.2009 32
Barier  reentrant

#define N_PROCS 10

size_t count = 0;
semaphore mutex = 1;
semaphore barr_sem = 0;  Care este problema?

void rbarrier(void)  Procesul care d  drumul


{
barierei este preemptat

 up(&mutex)
down(&mutex);
count++; dup
if (count == N_PROCS) {
up(&barr_sem, N_PROCS);  Primul proces din noua

}
count = 0;
rund  trece de barier
up(&mutex);

down(&barr_sem);
}

25.03.2009 33
Barier  reentrant (2)

#define N_PROCS 10 void rbarrier_phase2(void)


{
size_t count = 0; down(&mutex);
count--;
semaphore mutex = 1;
if (count == 0)
semaphore barr_sem_p1 = 0;
up(&barr_sem_p2, N_PROCS);
semaphore barr_sem_p2 = 0; up(&mutex);

void rbarrier_phase1(void) down(&barr_sem_p2);


{ }
down(&mutex);
count++; /* usage skeleton */
if (count == N_PROCS) for(...) {
up(&barr_sem_p1, N_PROCS); /* rendezvous */
up(&mutex);
rbarrier_phase1();
/* critical section */
down(&barr_sem_p1); rbarrier_phase2();
} }

25.03.2009 34
Problema cititori-scriitori

 Situaia în care diverse instane de execuie solicit 


acces la o resurs  (fiier/memorie/baz de date)
 Acces de citire sau de scriere

 Constrângerile de sincronizare

–  la un moment dat
oricâi cititori pot fi în regiunea critic

– scriitorii trebuie s  aib acces exclusiv la regiunea critic


 Util  în aplicaiile cu muli cititori

25.03.2009 35
Problema cititori-scriitori (2)

do {
down(&mutex);
read_count++;
do { if (read_count == 1)
down(&excl);
down(&excl);
up(&mutex);
... ...
/* do writing */ /* do reading */
... ...
down(&mutex)
up(&excl);
read_count--;
} while (TRUE);
if (read_count == 0)
up(&excl);
up(&mutex);
} while (TRUE);

25.03.2009 36
Problema cititori-scriitori (3)

 Problem  la soluia precedent


– posibil starvation de scriitori

– dac  exist un flux constant de cititori, scriitorii nu mai intr în


regiunea critic

 Încercai

– implementarea unei soluii care s  evite starvation


– implementarea unei soluii cu prioritate pe scriitori

– încercai, în prim  faz, s nu folosii “Little Book of


Semaphores”

25.03.2009 37
P-C (transfer de mesaje)

void consumer(void) void producer(void)


{ {

int item, i; int item, i;


message m; message m;

while(TRUE) { while (TRUE) {


receive(producer, &m); item = producer_item();
item = extract_item(m); build_msg(&m, item);
consume_item(); send(consumer, &m);
} }
} }

25.03.2009 38
Deadlock - modelare

 Num r finit de resurse (memorie, I/O, CPU)


– pot exista instane de resurse (2 CPU, 5 imprimante etc.)

 Set de procese care solicit  concurent accesul la resurse


– cerere (request) de folosire a resursei

 poate fi furnizat  imediat sau trebuie s atepte eliberarea resursei de alt proces
 malloc/open

– folosire (use)

– eliberare (release)

 free/close

25.03.2009 39
Deadlock – condiii necesare

 Excludere mutual 
– o resurs  este deinut în mod non-partajat
 Deine i ateapt  (hold & wait)
– un proces deine o resurs  i ateapt obinerea altor resurse deinute de
alte procese

 F r preemptare
– resursele nu pot fi preemptate – un proces elibereaz  o resurs doar
voluntar

 Ateptare circular  (circular wait)


– exist  o mulime {P0, P1, ..., Pn} de procese
 P0 ateapt  o resurs deinut de P1
 P1 ateapt o resurs deinut de P2

 ... Pn ateapt o resurs deinut de P0

25.03.2009 40
Graful de alocare a resurselor

 Nodurile reprezint 
– resurse – p trate
– procese – cercuri

 Arcele reprezint 
– resurs deinut – arc de la resurs la proces
– resurs dorit – arc de la proces la resurs

 Se poate demonstra c 
– dac nu exist ciclu în graf, atunci nu exist deadlock
– dac exist ciclu în graf, este posibil s existe deadlock

25.03.2009 41
Graful de alocare a resurselor (2)

(a) procesul A deine resursa R

(b) procesul B solicit  resursa S


(c) deadlock

25.03.2009 42
Detectare deadlock

 Se analizeaz  graful de alocare a resurselor


 Se descoper ciclurile din graf

 Este posibil s existe ciclu dar nu deadlock

 Exist algoritmi formali care pot detecta deadlock-urile din sistem

 Algoritmul struului (UNIX, Windows)

– “nu-mi pas ” (laissez-faire)

25.03.2009 43
Evitare deadlock

 Se cunoate ordinea în care un proces solicit  resursele


 Pe baza acestor cunotine se poate planifica accesul la resurse

 Secven  sigur
– o secven  de proces <P1, P2, ..., Pn>
– solicitrile lui Pi pot fi satisfcute cu resursele actuale libere sau cele

deinute de Pj (j < i)

 Stare sigur  (safe state) a sistemului


– exist  o secven sigur pentru procesele sistemului
 Stare nesigur  - deadlock

25.03.2009 44
Prevenire deadlock

 Una din cele 4 condiii necesare pentru existena unui

deadlock nu este satisf cut

 Excludere mutual 
– greu de eliminat

– o bun  parte din resurse sunt intrinsec non-partajabile

 Hold and wait

– se cer toate resursele de la început

25.03.2009 45
Prevenire deadlock (2)

 No preemption

– dac  un proces solicit resurse ocupate, elibereaz resursele


proprii

 Ateptare circular 
– ordonare a resurselor (R1 < R2 < ... < Rn)

– dac un proces solicit Ri trebuie s solicite i Rj (j < i)


– dac un proces elibereaz Rj trebuie s elibereze Ri (j < i)

25.03.2009 46
Recuperare din deadlock

 Terminarea procesului

– toate procesele care “particip ” la deadlock


– câte un proces pân  la dispariia deadlock-ului

 Preemptarea resurselor

– preemptare resurse de la anumite procese

– se ofer  resursele altor procese

25.03.2009 47
Cuvinte cheie

 condiie de curs   barier


  barier reentrant
acces exclusiv

  productor-consumator
sincronizare

 regiune critic   cititori-scriitori

 TSL
 deadlock

 spinlock
 graf de alocare a

resurselor
 semafor
 prevenire/evitare
 mutex
deadlock

25.03.2009 48
Exerciiu 1

 Descriei o situaie în care un proces poate fi planificat într-un

kernel non-preemptiv în momentul în care execut  cod kernel.

 De ce folosirea de priorit i statice poate conduce la starvation?

25.03.2009 49
Exerciiu 2

 Care din urm toarele operaii apeleaz planificatorul de


procese/thread-uri?

– citirea dintr-un fiier

– deschiderea unui fiier

– operaia P pe un semafor

– operaia V pe un semafor

25.03.2009 50
Întreb ri

?
25.03.2009 51