Curs 7

Comunicarea intre procese.

Sincronizarea proceselor

Sisteme de operare
Lect. Dr. Ozten CHELAI

Facultatea de Matematica si Informatica

Universitatea Ovidius Constanta

Curs7 SO - lect. dr. Ozten Chelai, 2009-2010 1

Comunicarea prin semnale

Fie două procese A şi B care se execută în paralel sub sistemul de operare Linux.
Procesul A va trimite un semnal procesului B utilizănd apelul sistem kill(pid, sig).

Lansarea apelului sistem va genera o excepŃie urmată de comutarea controlului către
sistemul de operare.

Sistemul de operare identifică semnalul şi destinatarul acestuia.

Procesul B este « pregătit » pentru acest semnal dacă are definit un cod pentru
sigaction(sig). Acest cod reprezintă rutina de tratare a semnalului, care este apelată de
sistemul de operare.

Daca nu este definită rutina de tratare a semnalului, atunci sistemul de operare va distruge
procesul B.

Semnalul comunicat este “nr_sig”

Procesul A Procesul B
TRAP

Kill (pidB, nr_sig) sigaction(nr_sig)

SO

Comunicare prin semnale în Linux

Comunicarea prin memorie partajata

Două procese pot comunica printr-o zonă de memorie comună în care un proces scrie informaŃia ce
trebuie comunicată şi din care celălalt proces citeşte informaŃia comunicată.

Avantajele comunicării prin zone de memorie comună sunt

realizarea unei comunicari structurată şi eficienŃa rezultată din faptul că nu se utilizează întreruperi.

Reprezinta modul natural de comunicare între firele de execuŃie (fir de executie = logica secventiala ce
paralelizeaza executia unui proces si partajaza resursele procesului) ale aceluiaşi proces.

Problema introdusa de comunicarea prin memorie comună este legată de apariŃia condiŃiilor de
competiŃie între procese(Race conditions)

Apare când două sau mai multe procese execută operaŃii de citire/scriere pe aceleaşi date partajate, iar rezultatul
depinde de ordinea ca şi de viteza de execuŃie a proceselor.

apar în sistemele cu timesharing.

Fie două procese P1 şi P2 care partajează o zonă de memorie M. Apar condiŃii de competiŃie dacă P1
este întrerupt înainte de a încheia operaŃiile asupra zonei partajate (testare şi modificare) şi se predă
controlul procesului P2 care urmează să lucreze în aceeaşi zonă de memorie. Aceasta problema
conduce la informaŃii inconsistente în zona de memorie comună.

Rezolvarea problemei competiŃiei între procese asigură consistenŃa informaŃiilor partajate

Read
Write
Procesul B

Procesul A

Zona de memorie comuna

Comunicarea prin memorie comună

Mecanismul SPOOLING (Simultaneous Peripherial
On-line OperatING)

Rezolva cererile de imprimare la Linux si care asigură ca un singur periferic (în cazul
nostru imprimanta) este utilizat corect în regim concurenŃial (faptul că solicitările de
imprimare se vor realiza independent pentru procese concurente (adică se vor obŃine
documente distincte pentru fiecare proces şi nu un document în care să fie amestecate
informaŃii transmise de procesele concurente).

un singur proces care evoluează în background si controleaza cererile de imprimare.

Pentru implementarea acestui mecanism se utilizează

o coadă de aşteptare în care procesele vor pune numele fişierelor ce urmează a fi imprimate.
Această coadă de aşteptare este prelucrată de daemonul de imprimare în sensul extragerii numelui
fişierului ce trebuie imprimat şi imprimării propriu-zise a acestuia.

două variabile in şi out în care este păstrat indexul primei poziŃii libere în coada de aşteptare,
respectiv indexul poziŃiei în care se află numele fişierului ce urmează a fi imprimat. Variabila in este
utilizată de procesele A şi B, iar variabila out de daemonul de imprimare.
1 f1
2 f2
3 f3
Procesul A 4 f4
5 f5 OUT=2

6 f6

IN=8 7 f7
8
Procesul B Procesul lp
(daemonul de
imprimare)
9

10
 Exemplu de problema de partajare a memoriei

Procesele A şi B solicită simultan imprimarea fişierului fA, respectiv fB

pentru aceasta află care este prima locaŃie liberă în coada de aşteptare
citind variabila in. În locaŃia corespunzătoare plasează numele fişierului,
după care îşi continuă execuŃia.

Codul executat de fiecare proces va fi următorul :
// PROCES A Citeşte conŃinutul lui in în registrul A
A = in // A=8
//scrie la locaŃia indicată în A numele fişierului fA, locatia 8 conŃine valoarea
«fA»
//incrementează valoarea lui A
A++ //A=9
//actualizează variabila in cu noua valoare
in=A //in=9
// PROCES B Citeşte conŃinutul lui in în registrul A
A = in // A=9
//scrie la locaŃia indicată în A numele fişierului fB, locatia 9 conŃine valoarea
«fB»
//incrementează valoarea lui A
A++ //A=10
//actualizează variabila in cu noua valoare
in=A //in=10

După executarea consecutivă a celor două secvenŃe de cod, locatia 10 este
prima locaŃie liberă iar locaŃiile 8 şi 9 conŃin numele celor două fişiere ce
trebuie imprimate.
Exemplu de problema de partajare a memoriei

Deoarece sistemul funcŃionează în regim de timesharing, întreruperea generată la încheierea
unei cuante de timp poate să apară oriunde în logica proceselor.

Să analizăm cazul în care întreruperea apare după ce procesul A a citit în registrul A valoarea
variabilei in. Urmărind codurile proceselor A şi B se obŃin următoarele rezultate:
// Proces A Citeşte conŃinutul lui in în registrul A
A = in // A=8

În acest moment apare o întrerupere datorată expirării cuantei de timp alocată procesului A.
Sistemul de operare va preda controlul procesului B, salvând în prealabil starea procesului A,
deci şi conŃinutul registrului A=8
//Proces B Citeşte conŃinutul lui in, care nu a fost încă
// modificat de procesul A, în registrul A
A = in // A=8
//scrie la locaŃia indicată în A numele fişierului fB, locatia 8 conŃine valoarea «fB»
//incrementează valoarea lui A
A++ //A=9
//actualizează variabila in cu noua valoare
in=A //in=9

La un moment dat şi procesului B îi expiră cuanta de timp. După un oarecare timp procesul A va fi
din nou planificat pentru execuŃie. În acest moment sistemul de operare reface starea procesului
A, ceea ce va conduce la încărcarea registrului A cu valoarea 8, aşa cum era în contextul
procesului A atunci când acesta a fost întrerupt.
Proces A//scrie la locaŃia indicată în A numele fişierului fA, locatia 8 conŃine valoarea «fA» care se va
scrie peste informaŃia « fB » scrisă de procesul B
//incrementează valoarea lui A
A++ //A=9
//actualizează variabila in cu noua valoare
in=A //in=9

În acest moment locaŃia 9 este prima locaŃie liberă, dar din coada de aşteptare s-a pierdut
solicitarea procesului B. Se observă că rezultatul operaŃiilor asupra zonei comune depinde de

ordinea proceselor

viteza proceselor

Problema a apărut pentru că procesul A nu a încheiat operaŃiile asupra zonei partajate (testare şi
modificare) înainte ca procesul B să fi preluat controlul asupra procesorului. Aceasta a condus la
informaŃii inconsistente în zona de memorie comună.
 Excluderea mutuala

SoluŃia constă în a asigura faptul că procesele A si B nu vor executa
simultan porŃiunea de program în care se accesează zona de memorie
comună pe care o partajează.

DefiniŃii:

SecŃiune critică = porŃiune a unui program în care se accesează memorie partajata.

Excludere mutuala = mecanismul prin care se asigură că două sau mai multe
procese nu vor fi simultan în secŃiunea critică referitoare la o anumită zonă de memorie
partajată de acestea.

Aceasta definitie este doar la nivel logic şi nu este suficientă pentru partajarea corectă a
resurselor comune de către procese ce se execută în paralel pe sisteme de calcul care
pot avea şi mai multe procesoare.

De asemenea, trebuie soluŃionata şi o altă problemă legată de faptul că, încercând să se
asigure excludere mutuală, apare posibilitatea blocării proceselor.

CondiŃiile necesare şi suficiente pentru partajarea corectă a resurselor
comune de către procese paralele sunt următoarele:

exclusivitatea : doar un singur proces se află în secŃiunea critică, referitoare la o
anumită zonă partajată, la un moment dat (excludere mutuală la nivel logic).

uniformitatea soluŃiei : nu se face nici o supoziŃie referitoare la numărul şi viteza
procesoarelor fizice (excludere mutuală la nivel fizic).

evitarea dependenŃei inutile: nici un proces care rulează în afara secŃiunii critice nu
va bloca un alt proces.

evitarea blocajului reciproc: nici un proces nu se va bloca definitiv în aşteptarea
accesului la secŃiune critică.
Metode de realizare a excluderii mutuale - Cu aşteptare activă

În soluŃiile de realizare a excluderii mutuale cu aşteptare activă procesele

rămân în stare ready pe timpul aşteptării eliberării resursei solicitate.

a). Dezactivare întreruperi

Această metodă utilizează posibilitatea de a dezactiva întreruprile, oferită de sistemul de întreruperi al
procesorului. SecŃiunea critică va fi gardata de instrucŃiuni care dezactivează, respectiv reactivează
întreruperile, astfel :
DI //dezactivare întreruperi
//cod secŃiune critică
EI //activare întreruperi

În urma dezactivării întreruperilor nu se mai poate realiza comutarea între procese deoarece nu mai apare
întreruperea de expirare a cuantei de timp.

În acest caz pot să apară însa anumite probleme.

Dacă procesul se blochează, va bloca întregul sistem.

Metoda nu ajută în cazul sistemelor cu procesoare multiple deoarece blocarea are loc la nivelul unui singur
procesor. De aceea, această metodă este utilizată şi controlata doar de către SO, la nivelul nucleului.

b). Utilizarea variabilei de blocare (restrângerea dimensiunii secŃiunii
critice)

Această metodă realizează accesul protejat la zona partajată prin utilizarea unei variable de blocare
(LOCK).

Mecanismul este următorul :

la solicitarea unui acces la zona partajată are loc testarea variabilei.

Dacă variabila indică faptul că zona este blocată de un alt proces, atunci se executa o buclă de aşteptare pentru
eliberarea zonei.

Când zona este liberă are loc setarea variabilei pentru a indica ocuparea zonei de către procesul solicitant.

Utilizarea variabilei de blocare nu schimbă însă natura problemei deoarece întreruperea pentru replanificarea
proceselor poate să apară între testarea şi setarea variabilei. Ceea ce se realizează este doar reducerea
probabilităŃii de apariŃie a condiŃiilor de competiŃie între procese prin reducerea dimensiunii zonei partajate la
dimensiunea variabilei de blocare.
 Metode de realizare a excluderii mutuale - Cu aşteptare activă

c). AlternanŃa strictă

Aceast procedeu utilizează un mecanism care realizează alternarea strictă a acceselor proceselor concurente la
zona partajată.

Se asigură astfel excluderea mutuală dar nu şi o comunicare corectă între procese deoarece nu se îndeplineşte condiŃia
de evitare a dependenŃei inutile. Astfel, un proces A aflat în afara secŃiunii critice poate sa blocheze alt proces B dacă,
conform alternaŃei stricte, este rândul procesului A să acceseze zona comună, dar el nu execută codul din secŃiunea
critică, pe când procesul B a ajuns să execute secŃiunea critică dar, deşi zona comună este liberă, nu este rândul lui să
o acceseze.

d). Metoda lui Peterson

Metoda lui Peterson implementează un algoritm care combină ideea accesului alternativ cu utilizarea variabilei de
blocare. Metoda defineşte două proceduri, enter_region şi leave_region, ce vor fi utilizate în delimitarea unei secŃiuni
critice. Codul secŃiunii critice va fi gardat cu aceste două proceduri astfel:
enter_region
// cod secŃiune critică
leave_region

Solutia pentru doua procese

Se presupune ca instructiunile LOAD si STORE sunt atomice (nu pot fi intrerupte).

Procesele partajaza doua variabile:
 int turn; // variabila turn indica al cui rand este sa intre in regiunea critica
 Boolean flag[2]; //tabloul flag este utilizat pentru a indica daca un proces este gata sa intre in regiunea critica. flag[i] =
true implica procesul Pi ready!.

Algoritmul pentru procesul Pi
while(true) {
flag[i] = TRUE;
turn = j;
while( flag[j] && turn == j);
REGIUNE CRITICA;
flag[i] = FALSE;
REGIUNE necritica;}

Procesul 0 verifica turn, observa ca are valoarea 0 si intra in regiunea critica

Procesul 1 gaseste tot valoarea 0 si de aceea cicleaza intr-o bucla mica, verificand mereu turn pana
devine 1. Verificarea in continuu a unei variabile pana cand are o anumita valoare se numeste asteptare
ocupata. Aceasta trebuie evitata intotdeauna, deoarece iroseste timp pe procesor

Cand procesul 0 paraseste regiunea critica, va seta turn pe 1, pentru a permite procesului 1 sa intre in
regiunea lui critica
 Metode de realizare a excluderii mutuale - Cu aşteptare activă

e). Utilizarea suportului hardware

Nici una din metodele anterioare nu soluŃionează problema competiŃiei între
procese în cazul sistemelor multiprocesor, sisteme cu procesoare multiple şi
memorie comună.

În cazul acestora se utilizează un suport hardware care oferă instrucŃiuni cu
blocarea magistralei pentru accese multiple.

Dintre acestea se folosesc instrucŃiuni de tip TSL (Test and Set Lock) ce presupun
două accese pe magistrală, dar care, datorită mecanismului hardware de blocare a
magistralei, realizează cele două accese în mod indivizibil (atomic).

Acest mecanism permite realizarea unei operaŃii indivizibile de testare şi setare a
unei variabile din memorie care poate fi folosită ca variabilă de blocare (LOCK).

Instructiunea TSL este utilizată în definirea procedurilor enter_region şi leave_region
astfel:
enter_region: TSL adr_lock
JNZ enter_region
RET
leave_region: MOV adr_lock, 0
RET

În concluzie, toate metodele anterioare soluŃionează problema
competiŃiei între procese prin transformarea secŃiunii critice într-o
secvenŃă de cod ce nu poate fi întreruptă, deci care se execută în
mod indivizibil, ca un tot unitar, atomic. În acest caz se asigură faptul
că nu apare situaŃia în care înainte ca un proces A să fi încheiat
operaŃiile asupra zonei partajate (testare şi modificare) un alt proces
B, ce va lucra în zona partajată, preia controlul.
Metode de realizare a excluderii mutuale - Fara aşteptare activă

Dezavantajele metodelor cu aşteptare activă sunt:

Deoarece procesele care asteaptă acces la zona partajată rămân în stare ready, acestea pot fi
replanificate de mai multe ori înainte de a avea loc eliberarea zonei comune. În acest caz se
consumă în mod inutil timp procesor cu comutările de context necesare şi cu consumul cuantei de
timp alocată, timp în care procesul realizează testul referitor la eliberarea zonei comune.

O altă problemă ce poate să apară este cea a inversării priorităŃilor în cazul în care un proces cu
prioritate scăzută se află în secŃiunea critică referitoare la o zonă partajată iar un proces mai prioritar
asteaptă acces la aceeaşi zonă de memorie.

Metode de realizare a excluderii mutuale - Fara aşteptare activă realizează tracerea
proceselor în stare blocat pe timpul aşteptării eliberării resursei solicitate, în cazul
nostru zonei de memorie partajată.

Aceste dezavantaje sunt solutionate de existenŃa a două primitive pentru comunicare
între procese, care realizează blocarea proceselor ce nu au acces la secŃiunea critică.
Aceste primitive sunt SLEEP şi WAKEUP.

a). Utilizarea primitivelor SLEEP şi WAKEUP

Primitiva SLEEP este lansată de procesul care constată că nu are acces la zona partajată
şi conduce la blocarea lui.

Primitiva WAKEUP este lansată de procesul care eliberează zona partajată şi determină
deblocarea unui proces care aşteaptă acces această zonă.

SecvenŃa generală de cod corespunzătoare utilizării primitivelor SLEEP şi WAKEUP este
următoarea:
…
if (lock)
SLEEP()
else
// cod secŃiune critică
WAKEUP()
end if
Metode de realizare a excluderii mutuale - Fara aşteptare activă
P C

Procesul producător Procesul consumator

Testează şi decrementează IN. Testează şi incrementează IN.
Se blochează pe IN=0. IN Se blochează pe IN=MAX.

IN = Numărul de locaŃii libere

Problema producător-consumator cu buffer de dimensiune limitată

Pentru exemplificare utilizăm o problema clasică, problema Producător-

Consumator în varianta cu zonă de transfer de dimensiune limitată. Aceasta
presupune existenŃa a două procese care partajează o zonă de memorie de
dimensiune fixă în care procesul producător P pune informaŃii şi din care
procesul consumator C extrage informaŃii.

Gestionarea situaŃiilor speciale se face în modul următor. Procesul P va fi blocat
când zona comună este plină, iar procesul C se va bloca atunci când aceasta este
goală. Pentru aceasta se utilizează o variabilă IN care conŃine numărul de locaŃii
libere. Procesul P va decrementa numărul de locaŃii libere (conŃinutul variabilei IN) de
câte ori pune informaŃii, iar procesul C va incrementa numărul de locaŃii libere de
câte ori va extrage informaŃii.

Procesul P testează variabila IN în raport cu valoarea 0 care indică faptul că zona
comună este plină. Dacă IN = 0, P nu are acces la zona comună, deci nu poate intra
în secŃiunea critică referitoare la această zonă, şi lansează apelul sistem SLEEP.
Când procesul C eliberează o locaŃie din zona comună el lansează apelul sistem
WAKEUP, ceea ce va determina deblocarea procesului P.

Procesul C testează variabila in în raport cu valoarea MAX (dimensiunea zonei
comune) care indică faptul că zona comună este goală. Dacă IN = MAX, C nu are
acces la zona comuna, deci nu poate intra în secŃiunea critică, şi lansează SLEEP.
După ce procesul P completează prima locaŃie în zona comună el lansează
WAKEUP, ceea ce va determina deblocarea procesului C.
Metode de realizare a excluderii mutuale - Fara aşteptare activă

Codul corespunzător celor două procese este următorul:
Procesul P
. . .
// Citeşte conŃinutul variabilei comune IN într-o variabilă locală procesului P, varP
varP = IN
if (varP == 0)
S-a completat prima locaŃie din zona comună, deci anterior
SLEEP() zona comună fusese goală ceea ce a determinat blocarea
else { procesului C. Trebuie lansat semnalul de deblocare.
// produce
varP--
if (varP == MAX-1)
WAKEUP()
IN = varP
}

Procesul C
. . .
// Citeşte conŃinutul variabilei comune IN într-o variabilă locală procesului C, varC
varC = IN
Anterior zona comună fusese plină, ceea ce a determinat
if (varC == MAX) blocarea procesului P. Procesul C a eliberat o locaŃie din
SLEEP() zona comună deci trebuie lansat semnalul de deblocare.
else {
// consumă
if (varC == 0)
WAKEUP()
varC ++
IN = varC
}
Metode de realizare a excluderii mutuale - Fara aşteptare activă

Deoarece sistemul functionează în regim de timesharing, întreruperea generată de
încheierea unei cuante de timp poate să apară oriunde în logica proceselor.

Sa analizăm cazul în care întreruperea apare după ce procesul P a citit valoarea
variabilei IN şi aceasta a fost 0.

Urmărind codurile proceselor P şi C se obŃin următoarele rezultate:
. . .Proces P
// Citeşte conŃinutul variabilei comune IN într-o variabilă locală procesului P, varP
varP = IN

Dacă în acest moment apare întreruperea datorată expirării cuantei de timp alocată
procesului P, sistemul de operare va salva contextul procesului P, deci şi conŃinutul
variabilei locale varP = 0. La un moment ulterior va preda controlul procesului C care
va executa următoarea secvenŃă de cod :
. . .Proces C
// Citeşte conŃinutul variabilei comune IN care nu a fost încă modificat de procesul
P
varC = IN //varC=0
if (varC == MAX)
SLEEP()
else {// consumă
if (varC == 0)
WAKEUP() //Se lansează semnalul de deblocare fără ca în
prealabil procesul P să fi lansat semnalul de blocare.
varC ++
IN = varC }

La un moment dat şi procesului C îi expiră cuanta de timp.
Metode de realizare a excluderii mutuale - Fara aşteptare activă

După un oarecare timp procesul P va fi din nou planificat pentru execuŃie. În acest moment
sistemul de operare reface contextul procesului P, context care conŃine şi variabila varP = 0.
//Proces P
if (varP == 0)
SLEEP() ///varP = 0 deci P consideră că nu există locaŃie liberă în zona comună a.î.
se va bloca
else {// produce
varP--
if (varP == MAX-1)
WAKEUP()
IN = varP}

Ca rezultat al acestor operaŃii procesul P este blocat. Semnalul WAKEUP lansat anterior de către
procesul C s-a pierdut în sensul că nu a condus la deblocarea procesului P deaorece a fost lansat
înainte ca P să se blocheze. În continuare, la planificarea proceselor va participa doar C care va
consuma toate locaŃiile zonei comune până când IN = MAX.
//Proces C Citeşte conŃinutul variabilei comune IN asupra căreia procesul P, blocat, nu
mai poate acŃiona şi care, după MAX accese ale procesului C devine 0
varC = IN
if (varC == MAX)
SLEEP() //varC = MAX deci mai nu există locaŃie ocupată în zona comună a.î. C se
va bloca, nemaiavând informaŃii de “consumat
else {// consumă
if (varC == 0)
WAKEUP()
varC ++
IN = varC}

Când IN redevine MAX ambele procese sunt blocate, astfel încât nu există posibilitatea
lansării unui semnal WAKEUP care să le permită deblocarea. Problema a aparut pentru că
P nu a încheiat operaŃiile asupra variabilei comune IN (testare şi modificare) înainte ca
procesul C să fi preluat controlul procesorului. Aceasta a condus la pierderea semnalului
WAKEUP lansat de procesul C.

SoluŃia constă în a Ńine evidenŃa semnalelor SLEEP şi WAKEUP.
Metode de realizare a excluderii mutuale - Fara aşteptare activă
SEMAFORUL

EvidenŃa semnalelor SLEEP şi WAKEUP este Ńinută cu ajutorul unei variabile de

tip SEMAFOR (definită de Djikstra). Aceasta este destinată să păstreze
semnalele WAKEUP.

Variabila semafor S este un întreg pozitiv asupra căruia se definesc două
operaŃii atomice UP şi DOWN (respectiv P şi V, după cum au fost denumite de
Djikstra) .

Proprietatea esenŃială a operaŃiilor atomice este aceea că sunt indivizibile, astfel încât
desfăşurarea unei astfel de operaŃii nu poate fi întreruptă ca urmare a apariŃiei
întreruperii datorate expirării cuantei de timp alocată procesului.

Semaforul are carateristicile unui obiect care are o proprietate de tip întreg şi
două metode UP şi DOWN.

ApariŃia unui semnal WAKEUP va lansa operaŃia UP iar apariŃia unui semnal SLEEP
va lansa DOWN. Daca S este strict mai mare ca zero, operaŃia UP va realiza o
incrementare a valorii sale, iar operaŃia DOWN o decrementare, consumând astfel un
semnal WAKEUP pentru deblocarea proceselor ce au generat SLEEP.

Semnale SLEEP apărute după ce S a devenit 0 vor conduce la blocarea proceselor
care le-au generat. Deci operaŃia DOWN asupra unui semafor cu S=0 conduce la
blocarea procesului ce a lansat SLEEP şi păstrarea valorii 0 în semafor. Asta
înseamnă că dacă S=0 atunci pot exista unul sau chiar mai multe procese blocate în
aşteptarea unui semnal WAKEUP.

OperaŃia UP asupra unui semafor cu S=0 este complexă, constând în testarea faptului
că există procese blocate şi deblocarea unuia dintre acestea, valoarea lui S rămânând
0 în acet caz. Dacă nu există procese blocate atunci S devine 1.

Este esenŃial să reŃinem că operaŃiile UP şi DOWN, indiferent de complexitatea lor, se
execută în mod atomic.
Metode de realizare a excluderii mutuale - Fara aşteptare activă

c). Numaratorul de evenimente

Numărătorul de evenimente este un tip special de obiect E ce are ca proprietate o
variabilă pozitivă asupra cărei se definesc trei operaŃii: READ, ADVANCE şi AWAIT.

READ este operaŃia de citire a valorii variabilei E.

ADVANCE realizează incrementarea valorii variabilei E.

AWAIT(k) determină aşteptarea apariŃiei unei valori specificate, k, în variabila E.

Acest obiect este utilizat, de asemenea, pentru sincronizarea proceselor paralele şi a
acceselor concurente ale acestora la zone de memorie partajate.

d). Monitorul

Monitorul este un mecanism oferit de unele limbaje de programare pentru
sincronizarea acceselor la zone partajate.

Un monitor este compus dintr-o colecŃie de proceduri şi o colecŃie de structuri
de date accesibile doar prin intermediul procedurilor. Monitorul asigură
excluderea mutuală prin faptul că mecanismul permite accesul unui singur
proces în monitor, la un moment dat.

Monitorul este un tip special de obiect pus la dispoziŃia programatorului de către
un limbaj de programare. Pentru a asigura consistenŃa zonelor de memorie
parajată pentru comunicarea între procese, programatorul trebuie să izoleze
secŃiunile critice şi să le includă în procedurile monitorului. Compilatorul
limbajului care oferă mecanismul de tip monitor, va ataşa instrucŃiunile ce
asigură excluderea mutuala.

Limbajul Java oferă acest mecanism prin faptul ca permite definirea de obiecte
monitor. Acestea se declară ca fiind syncronized. De asemenea, se pot declara
ca fiind synchronized doar anumite proceduri ale unui obiect.
Tranzactii atomice

Modelul sistemului

Refacerea bazata pe log-uri

Puncte de verificare (Checkpoints)

Tranzactii atomice
Modelul sistemului

Asigura executia tuturor operatiilor intr-o unitate
logica de executie sau nici o operatie executata

Utilizata intai in SGBD-uri

Atomicitate indiferent de caderile sistemului

Tranzactie= colectie de operatii ce se executa
atomic

Operatii de schimbare a datelor stocate - R/W

Se termina cu COMMIT (executie cu succes) sau ABORT
(esec executie)

La ABORT se aduce renunta la operatiile din tranzactie si
se aduce sistemul in starea dinaintea tranzactiei (ROLL
BACK)
Tipuri de medii de stocare

Stocare volatila – informatia nu supravietuieste
caderilor sistem

Exemple: memoria principala, cache

Stocare nevolatila – informatia suravietuieste
caderilor sistem

Disc si banda

Stocare stabila – informatia nu se pierde niciodata

Nu e posibil deocamdata, dar aproximativ se poate realiza
prin replicare
Scop – de a asigura atomicitatea tranzactiilor atunci
cand caderile sistem cauzeaza pierderea informatiei
in mediile de stocare volatile.
Refacerea


bazata pe log-uri
Inregistrarea informatiilor modificate intr-o tranzactie pe un mediu de
stocare stabil (logging)

Tehnica write-ahead logging

Log-uri pe mediul de stocare stabil, cu fiecare operatie de scriere ce cuprind:
 Numele tranzactiei
 Nume date
 Valoare veche
 Valoare noua

<Ti start> scris la incererea tranzactiei

<Ti stop> scris la terminarea tranzactiei

Intrarea in log trebuie sa se realizeze inaintea operatiei asupra datelor

Algoritmul de refacere bazat pe log

Folosinf log-ul se pot manipula erorile memoriei volatile

Undo(Ti) reface toate datele modificate de Ti

Redo(Ti) salveaza datele tranzactiei Ti in noile valori

Undo(Ti) si Redo(Ti) trebuie sa fie idempotente

Mai multe executii trebuie sa aiba acelasi rezultat cu o executie

Daca sistemul cade, se restaureaza toate datele modificate dupa log

Daca log-ul contine <Ti start> fara <Ti stop> se face undo(Ti)

Daca log-ul contine <Ti start> cu <Ti stop> se face redo(Ti)
Puncte de verificare (Checkpoints)

Micsoreaza timpul de refacere deoarece log-urile

pot fi mari, iar timpul necesar refacerii corespunzator

Schema

Stocarea tuturor log-urilor din memoria volatila in cea
stabila

Stocarea tuturor datelor modificate in memoria stabila

Stocarea unui log checkpoint in memoria stabila

acum refacerea include doar Ti-urile incepute
inaintea celui mai recent checkpoint si dupa,
celelalte fiind deja stocate
BIBLIOGRAFIE

Cristina Mindruta, Sisteme de operare -
suport de curs, www.univ-ovidius.ro/math