4. Administrarea proceselor..................................................................................................................................................

2
4.1. Realizarea excluderii mutuale...................................................................................................................................2
4.1.1. Specificarea problemei.......................................................................................................................................2
4.1.2. Excluderea mutual prin ateptare activ...........................................................................................................2
4.1.2.1. Algoritmul lui Dekker..................................................................................................................................2
4.1.2.2. Ateptarea activ n sisteme multiprocesorale: Test & Set..........................................................................4
4.1.3. Semaforul instrument elementar pentru excluderea mutual..........................................................................4
4.1.3.1. Definiii........................................................................................................................................................4
4.1.3.2. Proprieti....................................................................................................................................................4
4.1.3.3. Realizarea excluderii mutuale cu ajutorul semafoarelor.............................................................................5
4.2. Funcionarea i structura unui nucleu de sincronizare..............................................................................................6
4.2.1. Strile unui proces. Fire de ateptare..................................................................................................................6
4.2.2. Administrarea contextelor i schemele primitivelor...........................................................................................7
4.3. Realizarea unui nucleu de sincronizare.....................................................................................................................8
4.3.1. Organizarea general..........................................................................................................................................8
4.3.1.1. Interfeele.....................................................................................................................................................8
4.3.1.2. Structuri i algoritmi....................................................................................................................................9
4.3.2. Realizarea monitoarelor....................................................................................................................................10
4.3.2.1. Algoritmi de baz......................................................................................................................................10
4.3.2.2. Tratarea ntreruperilor................................................................................................................................11
4.3.2.3. Tratarea erorilor.........................................................................................................................................12
4.3.3. Operaii asupra proceselor................................................................................................................................12
4.3.3.1. Crearea i distrugerea proceselor...............................................................................................................12
4.3.3.2. Suspendarea i reluarea.............................................................................................................................13
4.3.4. Excluderea mutual i alocarea procesorului...................................................................................................14
4.3.4.1. Realizarea pentru cazul monoprocesor......................................................................................................14
4.3.4.2. Realizarea pentru cazul unui sistem multiprocesoral................................................................................15
4.4. Procese i fire n Linux........................................................................................................................................16
4.4.1. Crearea proceselor........................................................................................................................................16
4.4.2. Distrugerea proceselor..................................................................................................................................16
4.4.3. Demoni n Linux...........................................................................................................................................17
4.4.4. Obinerea informaiilor despre procese........................................................................................................17
4.4. Exerciii la capitolul 4.............................................................................................................................................17

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.1

4. Administrarea proceselor
Acest capitol este consacrat implementrii noiunilor proces i sincronizare n cadrul unui sistem de operare.
Mecanismele utilizate sunt bazate pe realizarea principiul excluderii mutuale, studiat n 4.1. Principiile directoare ale
reprezentrii i gestiunii proceselor (contexte, alocarea procesorului) sunt prezentate n 4.2 i ilustrate n 4.3 printr-un
exemplu schematic de realizare a unui nucleu de sincronizare.

4.1. Realizarea excluderii mutuale

Mecanismele care realizeaz excluderea mutual pentru un set de programe sunt bazate pe un principiu comun:
utilizarea mecanismului de excludere mutual existent deja la un nivel inferior. Drept rezultat, sunt utilizate variabile
comune ale proceselor concurente, iar coerena acestor variabile trebuie ea nsi s fie garantat. La nivelul de baz
(cel al resurselor fizice) exist dou mecanisme elementare: excluderea mutual prin accesarea unui amplasament de
memorie (variabila de blocare sau eveniment memorizat) i masca ntreruperilor. Aceste dou mecanisme sunt, n
principiu, suficiente pentru toate necesitile. Dar, din considerente de eficacitate, la nivelul resurselor fizice sau
microprogramelor exist dispozitive mai sofisticate, cum ar fi instruciunea Test and Set sau semafoarele.

4.1.1. Specificarea problemei

Vom preciza mai nti problema excluderii mutuale. Fie {p1, p2,...,pn} o mulime de procese pe care le vom considera
ciclice; programul fiecrui proces conine o seciune critic. Excluderea mutual este asigurat prin dou fragmente de
program (prolog i epilog), care ncadreaz seciunea critic a fiecrui proces. Presupunem, c fiecare proces, care intr
n seciunea critic o prsete ntr-un interval de timp finit.
Soluia trebuie s posede urmtoarele proprieti:
a)

excludere mutual: la fiecare moment de timp cel mult un proces execut seciunea critic,

b) absena blocajelor intempestive (care nu sunt la timpul lor): dac n seciunea critic nu se afl vreun proces,
nici un proces nu trebuie s fie blocat de mecanismul excluderii mutuale,
c)

toleran la defecte: soluia trebuie s rmn valid i n cazul unor defecte n unul sau n mai multe procese,
care se afl n afara seciunii critice,

d) absena privaiunilor: un proces, care a cerut intrarea ntr-o seciune critic nu trebuie s fie privat de acest drept
(adic, s atepte un timp infinit (presupunnd, c toate procesele au aceeai prioritate)),
e)

simetrie: prologul i epilogul trebuie s fie identice pentru toate procesele i independente de numrul lor.

innd cont de aceste specificaii vom construi o soluie de forma:

<iniializare>
<programul procesului pi>:
ciclu
<prolog>
<seciunea critic>
<epilog>
<restul programului>
endciclu

-- comun tuturor proceselor

-- intrare n seciunea critic
-- ieire din seciunea critic

Trebuie s elaborm fragmentele iniializare, prolog i epilog.

4.1.2. Excluderea mutual prin ateptare activ

nainte de a descrie implementarea excluderii mutuale prin operaii elementare de blocare i deblocare a proceselor
prezentm un mecanism, care permite simularea efectului acestor operaii, meninnd procesele n stare activ. Un
proces n ateptare activ simuleaz blocarea efectund o testare repetat a condiiei de depire, care poate fi
actualizat de alte procese.
4.1.2.1. Algoritmul lui Dekker
Pentru nceput considerm cazul a dou procese p0 i p1. O prim abordare const n reprezentarea condiiei de
ateptare (care este complementar condiiei de depire) printr-o variabil boolean c; vom avea atunci:
c = true cnd un proces este n seciunea critic, false n caz contrar.
Putem propune urmtorul program:
iniializare: c := false;

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.2

prolog

: test: if c = false then

go to test
else
c := true
endif;
<seciunea critic>
epilog
: c := false;
La o analiz mai atent observm (v.3.2.2.3), c dac nu vom face nite ipoteze suplimentare, acest program poate s
nu rezolve problema pus. Iat secvena de intrare n seciunea critic, descompus n instruciuni:
1) test0:
2)
br (R0=true)
3)
stz

procesul p0
load R0
test0
c(=true)

11)

c
21)
31)

procesul p1
test1: load R1
br (R1=true)
stz
c

c
test1

(br este operaia de salt condiionat iar stz pune n true amplasamentul lui c). Dac ordinea de execuie este 1, 11, 2, 21,
3, 31 vedem c excluderea mutual este greit. Problema provine de la faptul c procesul p1 poate consulta c ntre
momentul cnd p0 a consultat c (gsindu-l false) i momentul n care p0 l-a pus pe c n true. Altfel spus, este necesar ca
secvenele de aciuni (1, 2, 3) i (11, 21, 31) s fie executate n mod atomar. Anume acest principiu st la baza
instruciunii Test and Set.
O soluie (algoritmul lui Dekker) poate totui fi construit fr a folosi alte mecanisme de excludere mutual, n
afar de indivizibilitatea accesrii n citire sau actualizarea unui amplasament de memorie. Prezentm algoritmul pentru
dou procese, dei el poate fi extins pentru un numr arbitrar de procese.
Programul folosete trei variabile comune celor dou procese:
var c
: array [0..1] of boolean;
tur : 0..1;
iniializare:
c[0]:=c[1]:=false;
tur:=0;
prolog
:
-- pentru procesul i; se va pune j=1-i (cellalt proces)
c[i]:=true;
tur:=j;
test: if c[j] and tur=j then
go to test
endif;
...
epilog
:
-- pentru procesul i
c[i]:=false;
Aceast soluie, demonstrarea validitii creia este propus ca exerciiu, prezint un interes pur teoretic. n practic
sunt utilizate instruciuni speciale care asigur indivizibilitatea secvenelor de testare i modificare.
Ateptarea activ poate fi n egal msur utilizat ca mecanism elementar de sincronizare n cazul unor alte
probleme, diferite de excluderea mutual.
Exemplul 4.1.

Relum problema exemplului din 3.3.1 (comunicarea a dou procese printr-un segment comun). Reprezentm printr-o variabil
boolean c condiia de ateptare:
c=procesul p a terminat scrierea n segmentul a
Valoarea iniial c=false. Programele se vor scrie astfel:
procesul p

procesul q
...
...
test: if c then
go to test
endif;
citire(a)

scriere(a);
c:=true

Putem verifica, c soluia este corect: oricare ar fi ordinea de executare a acestor dou procese, deblocarea lui q este, n cel mai ru
caz, retardat cu un ciclu de ateptare activ. Printre altele, aceast proprietate rmne adevrat dac vom presupune, c mai multe
procese q1, q2,,..., qn ateapt terminarea operaiei de scriere.

Proprietatea, care asigur validitatea schemei de mai sus, const n faptul c modificarea variabilei c este efectuat
de ctre un singur proces. Notm, c aceast schem a fost deja ntlnit n capitolul 2 la administrarea intrrilorieirilor la CDC 6600: un cuplu de procese comunic prin intermediul unei perechi de indicatori, fiecare dintre care este

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.3

actualizat de un proces i consultat de altul. Pentru aceasta este necesar s se poat executa n excludere mutual
instruciunile de testare i modificare.
4.1.2.2. Ateptarea activ n sistemele multiprocesorale: Test & Set
Pentru tratarea cu ajutorul ateptrii active a cazului n care mai multe procese actualizeaz i consult variabile
comune, unele maini au o instruciune, care realizeaz ntr-o manier indivizibil consultarea i actualizarea unui
amplasament de memorie. Aceast instruciune, adesea numit Test And Set (tas), este utilizat n sistemele
multiprocesorale (n sistemele monoprocesor mascarea ntreruperilor este suficient pentru asigurarea excluderii
mutuale).
Fie m adresa amplasamentului de memorie considerat, sau lactul, iar R un registru al procesorului. Prin convenie,
dac lactul este n 0 (n locaiunea cu adresa m avem 0), seciunea critic este liber, iar dac este 1 ea este ocupat.
Efectul lui Test And Set este descris mai jos (Mp[m] desemneaz coninutul amplasamentului de memorie cu adresa m):
tas R, m : <blocare acces la Mp[m]>
R:=Mp[m]
Mp[m]:=1
<eliberare acces la Mp[m]>
Excluderea mutual prin ateptare activ poate fi programat cu ajutorul urmtoarelor secvene:
iniializare : stz
m
prolog
: tas
R, m
br(R0) $-1
seciunea critic
epilog
: stz
m

-- Mp[m]:=0
-- test iterat

4.1.3. Semaforul instrument elementar pentru excluderea mutual

4.1.3.1. Definiii
Un semafor s este constituit prin asocierea unui contor cu valori ntregi, notat c.s., i a unui fir de ateptare, notat
f.s. La crearea semaforului contorului i se atribuie o valoare iniial s0 (s00), i firul de ateptare f.s. este vid. Un
semafor servete la blocarea proceselor ateptnd s se produc o condiie pentru deblocarea lor. Procesele blocate sunt
plasate n f.s. Mai multe procese pot fi sincronizate prin semafoare, care aparin prii comune a contextului lor. Un
procesor poate fi manipulat doar cu ajutorul a dou operaii P(s) i V(s), numite primitive. Valoarea contorului i starea
firului de ateptare sunt inaccesibile, chiar i pentru citire. Fie p un proces care execut P(s) sau V(s), iar q un proces
care se afl n firul de ateptare f.s. Algoritmul primitivelor este urmtorul:
P(s):

V(s):

c.s.:=c.s.-1;
if c.s.<0 then
stare(p):=blocat;
introducere(p,f.s.)
endif

c.s.:=c.s.+1;
if c.s.0 then
extragere(q,f.s.);
stare(q):=activ
endif

Aceste operaii sunt executate n excludere mutual. Modalitatea de realizare efectiv a semafoarelor i a
primitivelor P i V este descris n 4.3. Operaiile introducere i extragere permit inserarea unui proces ntr-un fir de
ateptare sau, respectiv, extragerea. Nu facem aici nici un fel de ipoteze despre politica de gestionare a firului de
ateptare: algoritmii de sincronizare trebuie s fie independeni. Politica aleas n cazul alocrii unui procesor este
discutat n 4.3, la fel i detaliile legate de operaiile de blocare i deblocare.
Exemplul 4.2.

Funcionarea unui semafor poate fi comparat cu lucrul unui magazin accesul n care este admis doar dac la intrare exist couri
libere (sau crucioare) n care cumprtorii i duc marfa (intrarea fr co este interzis). La deschiderea magazinului un anumit
numr de couri libere sunt puse la dispoziia cumprtorilor la intrare. Un cumprtor ia un co liber, intr n magazin i i alege
marfa, iar dac la intrare nu exist un co liber, cumprtorul este obligat s atepte ntr-un fir de ateptare (operaia P). La ieire
cumprtorul pune coul de unde l-a luat (operaia V).

Doar executarea primitivei P poate bloca un proces. Acesta va putea fi deblocat doar de un alt proces, care a
executat primitiva V pe acelai semafor. Executarea operaiei V nu este blocant.
4.1.3.2. Proprieti
Proprietile principale ale sincronizrii cu ajutorul semafoarelor pot fi deduse din cteva relaii invariante: relaii
verificate iniial i care rmn neschimbate dup executarea primitivelor P i V un numr arbitrar de ori.
1) Fie, pentru un semafor s:
np(s) numrul total de execuii a operaiei P(s),

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.4

nv(s) numrul total de execuii a operaiei V(s).

Are loc relaia:
c.s. = s0 np(s) + nv(s)
(1)
deoarece valoarea iniial a lui c.s. este s0, fiecare operaie P(s) scade din aceast valoare o unitate, iar V(s) adaug 1.
Aceste operaii, fiind executate n excludere mutual, nici o modificare nu este pierdut.
2) Fie nbloc(s) numrul proceselor blocate n f.s. Are loc relaia:
nbloc(s) = if c.s. 0 then 0 else c.s. endif
(2)
care poate fi de asemenea scris
nbloc(s) = max(0, c.s.)
(21)
Relaia (2) iniial este adevrat. Tabelul de mai jos, care indic efectul operaiilor P(s) i V(s) asupra valorii
variabilei nbloc, arat c aceste operaii las relaia (2) invariant.
c.s.<0
c.s.=0
c.s.>0
Efectul operaiei P(s)
+1
+1
-Efectul operaiei V(s)
-1
--3) Relaia (2) poate fi scris sub o alt form, care ne va fi util mai departe. Fie nf(s) numrul de treceri de ctre
procese a primitivei P(s), adic suma numrului de executri a lui P(s) fr blocare i a numrului de deblocri realizate
de ctre V(s). Vom avea n acest caz:
nbloc(s) = np(s) nf(s).
Introducnd aceast valoare n (21) obinem:
- nf(s) = max(-np(s), -c.s.-np(s)), sau
nf(s) = min(np(s), c.s.+np(s)).
n fine, utiliznd valoarea lui c.s. din (1), avem:
nf(s) = min(np(s), c.s.+nv(s)).
(3)
4.1.3.3. Realizarea excluderii mutuale cu ajutorul semafoarelor
Prezentm o schem, care rezolv problema excluderii mutuale pentru n procese. n cazul n care nu se fac ipoteze
speciale despre gestionarea firului de ateptare, nu se garanteaz lipsa privaiunilor.
iniializare : semafor mutex init 1
prolog
: P(mutex)
seciunea critic
epilog
: V(mutex).
S ne convingem, c soluia prezentat este n conformitate cu specificaiile din 4.1.1. Trebuie s verificm dac
proprietile a, b i c au loc.
Fie nc numrul de procese, care se afl n seciunea critic la un moment concret de timp. Avem:
nc = nf(mutex) nv(mutex)
(4)
Proprietile n cauz pot fi verificate aplicnd semaforului mutex relaia (3) din 4.1.3.2:
nf(mutex) = min(np(mutex), 1+nv(mutex))
(5)
a) Excluderea mutual
Din (5) avem:
nf(mutex) 1+nv(mutex)
i, utiliznd (4), obinem nc 1: excluderea mutual este asigurat.
b) Absena blocajelor
Presupunem, c nici un proces nu se afl n seciunea critic. Vom avea n acest caz nc = 0, sau
nf(mutex) = nv(mutex) sau nc
nf(mutex) 1+nv(mutex)
Vom avea conform relaiei (5):
nf(mutex) = np(mutex) sau
nbloc(mutex) = 0
Deci, proprietatea b este prezent, ca i proprietatea c, deoarece nu s-a fcut nici o ipotez despre starea proceselor,
dac ele nu se afl n seciunea lor critic.
1). Seciuni critice incorporate. Blocaje
Vom considera dou procese p i q pentru care programul conine dou seciuni critice distincte, corespunztoare
utilizrii a dou resurse critice distincte.
procesul p
procesul q
...
...
(1) P(mutex1)
(11) P(mutex2)
...
...
(2) P(mutex2)
(21) P(mutex1)

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.5

...
V(mutex2)
...
V(mutex1)

...
V(mutex1)
...
V(mutex2)

Dac traiectoria temporal de execuie a proceselor p i q ncepe cu (1, 11, 2, 21), se va ajunge la o situaie n care
ambele procese sunt blocate pentru un timp infinit, deoarece fiecare dintre procese poate fi deblocat doar de ctre
cellalt. Aceast situaie este numit blocare sau mbriare fatal (eng. deadlock, fr. treinte fatale).
2). Ateptare infinit n seciunea critic sau impas
Validitatea soluiei propuse se bazeaz pe presupunerea, c toate procesele prsesc seciunea critic n timp finit.
Numai ce am stabilit, c aceast ipotez poate fi infirmat dac seciunile critice se intersecteaz. Pot fi i alte cauze,
care conduc la o ateptare infinit. Astfel, blocarea, incorectitudini sau ciclri infinite ntr-un proces, care se afl n
seciunea critic, pot paraliza toate procesele concurente cu procesul dat. n cazul unor seciuni critice globale (care
prezint interes pentru toi utilizatorii), realizate pentru un sistem de operare, pot fi propuse urmtoarele soluii:
oricrui proces, care execut o seciune critic global, i se atribuie, pe toat durata acestei execuii, un statut
special, care i confer anumite drepturi particulare: prioritate nalt, protecie contra distrugerii, etc.
un orologiu de gard este armat la intrarea unui proces n seciunea critic; dac procesul nu prsete seciunea
critic dup un interval de timp predefinit, sistemul de operare foreaz ieirea procesului i elibereaz astfel
seciunea critic. Aceast soluie nu este cea mai bun, or datele globale, manipulate n seciunea critic, pot s
devin incoerente. Este necesar s se ofere posibilitatea restabilirii acestor date la o stare anterioar, considerat
valid, ceea ce implic salvri periodice.
3). Privaiune
Algoritmul excluderii mutuale garanteaz intrarea exact a unui proces n seciunea critic, dac mai multe procese
ncearc acest lucru, cnd seciunea critic este liber. Se poate ntmpla ca un proces particular s fie reinut pentru un
interval de timp nedefinit: acest fenomen se numete privaiune, pe care o vom rentlni atunci cnd vom studia
alocarea resurselor. ntradevr, procesele candidate la intrare, ateapt n firul de ateptare mutex.f i ordinea lor de
deblocare (prin V(mutex)) depinde de politica de gestionare a acestui fir, despre care nu s-a fcut nici o ipotez.
Pentru cazul cel mai frecvent, cnd firele de ateptare a semafoarelor sunt gestionate conform ordinii prim sosit
prim servit fr prioritate, riscul de privaiune este eliminat. ntradevr, dac presupunem c execuia unei seciuni
critice dureaz totdeauna un interval finit de timp, orice proces, dup o perioad finit de timp, va deveni cel mai vechi
n firul su de ateptare.

4.2. Funcionarea i structura unui nucleu de sincronizare

Noiunea de proces i operaiile asociate nu fac, de obicei, parte din setul de baz al instruc iunilor calculatorului.
Ele vor fi implementate cu ajutorul unor programe i/sau microprograme, care formeaz nucleul de administrare a
proceselor. n cadrul descrierii unui sistem de operare cu ajutorul mainilor abstracte ierarhice (v. cap.9), nucleul
constituie nivelul cel mai inferior, realizat direct pe maina fizic. Maina abstract, realizat astfel poate fi numit o
main a proceselor, care posed, n afara setului de instruciuni de baz, primitivele care permit crearea, distrugerea i
sincronizarea proceselor. Ca i orice main abstract, maina realizat n acest mod ascunde unele proprieti ale
mainii fizice. Astfel:
noiunea de proces, care este echivalent cu cea de proces virtual, ascunde utilizatorilor nucleului mecanismul
de alocare a procesoarelor fizice. La un nivel superior nivelului nucleului chiar i numrul procesoarelor nu
intervine dect doar asupra performanelor sistemului i nici ntr-un fel asupra structurii sale logice,
primitivele de sincronizare, realizate de nucleu, ascund mecanismele fizice de comutare a contextului, de
exemplu, cele oferite de ntreruperi.
Structura unui nucleu de sincronizare depinde, printre altele, de specificaiile mainii fizice (gestiunea ntreruperilor,
structura cuvntului de stare, sistem mono- sau multiprocesoral, etc.) i de specificaiile mainii abstracte care trebuie
realizate, ndeosebi de mecanismul de sincronizare ales. Este, totui, posibil de evideniat cteva caracteristici comune
ale acestei structuri, pe care le vom prezenta nainte de a descrie o realizare concret.

4.2.1. Strile unui proces. Fire de ateptare

Am considerat pn acuma c un proces se poate afla n dou stri: activ sau blocat. Alocarrea fizic a unui procesor
ne impune s descompunem starea activ n dou stri noi. Un proces activ se numete ales, dac el este n curs de
execuie pe un procesor fizic; el se numete eligibil dac nu poate fi executat din cauza lipsei unui procesor disponibil.
Aceast evideniere este legat doar de disponibilitatea procesorului i nu are vre-un suport logic. Figura 4.1 descrie
strile unui proces i tranziiile lui.
Tranziiile 3 i 4 (blocare i deblocare) sunt tranziiile interne, datorate sincronizrii proceselor. Tranziiile
tehnologice 1 i 2 sunt datorate alocrii procesoarelor fizice proceselor. n particular, tranziia 2 se produce atunci

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.6

cnd algoritmul de alocare retrage procesorul de la un proces, care nc mai are nevoie de el. Aceast operaie este
numit retragere (eng. preemption, fr. rquisition) a procesorului.
Administrarea proceselor face apel la fire de ateptare. Astfel, fiecrei cauze distincte de blocare (semafor, condiie
ntr-un monitor, etc.) i se asociaz un fir de ateptare pentru a stabili o ordine a proceselor blocate. Mai mult, procesele
eligibile sunt meninute ntr-un fir special de ateptare, gestionarea cruia permite implementarea unei politici de
alocare a procesoarelor fizice. Dac presupunem, c viitorul proces ales este totdeauna primul din firul proceselor
eligibile, algoritmul de alocare poate fi definit
cu ajutorul algoritmului de inserare n firul proceselor eligibile,
cu ajutorul algoritmului care determin retragerea procesoarelor fizice.
(1)

eligibil
(ready)

ales
(exe)

(2)

(4)

(3)

blocat
(wait)

Fig.4.1. Strile unui proces

Mulimea programelor, care realizeaz aceti algoritmi se numete planificator (eng. scheduler, fr. ordonnanceur).
Programul, care realizeaz alegerea propriu-zis se numete dispecer (eng. dispatcher, fr. distributeur). Schema
general a firelor de ateptare ale proceselor este prezentat n fig.4.2. Deplasarea proceselor ntre aceste fire
corespunde schimbrii strii.
planificator
fire de procese blocate
dispecer

proces ales

firul proceselor eligibile

Fig.4.2. Fire de ateptare ale proceselor, administrate de nucleul sistemului de operare

4.2.2. Administrarea contextelor i schemele primitivelor

1) Coninutul contextului
Operaia de alocare a procesorului fizic impune pstrarea pentru fiecare proces a unei copii a contextului. Aceast
copie a contextului descrie starea procesorului pentru procesul considerat. n acest scop fiecrui proces i se asociaz o
mulime de informaii rezidente n memorie i numit vector de stare, bloc de control al procesului sau blocul
contextului, care conine:
informaiile despre starea procesorului, necesare la realocarea lui (coninutul cuvntului de stare, registrelor),
valorile atributelor procesului (prioritate, drept de acces),
pointeri la spaiul de lucru al procesului (segmentele procedur i date, stiva de execuie),
informaii de gestiune (starea, legturile de nlnuire).
O descriere mai detaliat a blocului contextului unui proces este dat n 4.3.
2) Organizarea nucleului
Execuia programelor nucleului este declanat n dou moduri (fig.4.3):
prin apelarea unei primitive de administrare a proceselor (creare, distrugere, sincronizare, etc.); aceste primitive
sunt realizate sub form de apel al supervizorului,

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.7

 printr-o ntrerupere: programele de tratare a ntreruperilor fac parte din nucleu, deoarece ntreruperile sunt
traduse n operaii de sincronizare i sunt invizibile la nivelurile superioare.
n ambele cazuri, mecanismul de intrare n nucleu conine salvarea automat a cuvntului de stare i, eventual, a
registrelor procesorului, care execut apelul supervizorului sau care trateaz ntreruperea. n dependen de organizarea
calculatorului, aceste informaii sunt salvate ntr-un amplasament fix (legat de nivelul ntreruperii sau de apelul
supervizorului) sau ntr-o stiv (ndeosebi n cazul sistemelor multiprocesorale). Prile contextului, salvate n acest fel,
sunt cele ale proceselor alese pentru procesorul n cauz, n momentul ntreruperii sau apelrii supervizorului.
Programele primitivelor i cele de tratare a ntreruperilor manipuleaz blocurile contextului i firele proceselor.
Pentru asigurarea coerenei informaiilor aceste programe trebuie executate n excludere mutual. Executarea unui
program al nucleului se termin n toate cazurile prin realocarea procesorului sau procesoarelor, adic prin apelarea
dispecerului. Deoarece este posibil ca firul de ateptare a proceselor alese s fi fost modificat de execuia primitivelor,
noul proces ales poate s difere de ultimul proces ales pentru procesorul ntrerupt.
alocare procesor
apelare supervizor
proces
programul
nucleului

periferice,
ceasul

lansare

ntreruperi

Fig.4.3. Comunicarea cu un nucleu de sincronizare

Programul unei primitive a nucleului are urmtoarea schem general:
prolog;
-- salvarea contextului i intrarea n seciunea critic
control;
-- verificarea drepturilor i a parametrilor
<corpul programului>
-- manipuleaz firele proceselor
alocare_procesor;
-- programul dispecer i ieirea din seciunea critic
Secvena prolog, comun tuturor operaiilor, salveaz contextul procesului, care execut operaia, i asigur intrarea
n seciunea critic. Secvena control verific drepturile procesului apelant de a executa primitiva i validitatea
parametrilor transmii. Detaliile depind de primitiv. Secvena alocare_procesor este programul dispecerului: ea
realizeaz realocarea procesorului i ieirea din seciunea critic.
Diferena ntre sistemele mono- i multiprocesorale se manifest n mod esenial la realizarea excluderii mutuale i
alocrii procesorului (secvenele prolog i alocare_procesor).
Tratarea ntreruperilor de ctre nucleu trebuie s fie coordonat cu mecanismele de sincronizare alese. De obicei
sunt considerate dou scheme de baz:
1) Asocierea unui proces, care trateaz fiecare ntrerupere. Doar acest proces se va afla n ateptarea unei
ntreruperi anume, existnd pentru aceasta o instruciune special.
2) Asocierea unei operaii de deblocare (semnalizare asociat unei condiii, V la un semafor, etc.) la o ntrerupere.
Problemele de mascare i de prioritate a ntreruperilor sunt, de obicei, tratate asociind prioriti proceselor.

4.3. Realizarea unui nucleu de sincronizare

Vom prezenta n cele ce urmeaz schema realizrii unui nucleu particular de sincronizare. Descrierea este cu titlu de
ilustrare, fiind posibile multe ameliorri att din punct de vedere al interfeei, ct i n ceea ce privete detaliile de
realizare (v. exerciiile).

4.3.1. Organizarea general

4.3.1.1. Interfeele
a) Gestionarea proceselor
Procesele pot fi create i distruse n mod dinamic, i sunt organizate ierarhic conform relaiei de legtur (v.3.5). Un
proces este creat cu ajutorul primitivei:
creare(p, context iniial, atribute)
Atributele unui proces conin prioritatea (exprimat printr-un ntreg) i drepturile de a executa anumite operaii.
Contextul iniial specific starea iniial a cuvntului de stare i a registrelor procesorului, i a spaiului de lucru asociat
procesului (stiva, date proprii). Procesul este creat n starea eligibil. Numrul su p (numele) este returnat ca rezultat
(valoarea nil, dac crearea este imposibil). O funcie determin_numr_propriu permite unui proces s afle numrul
su propriu.

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.8

Primitivele care urmeaz pot fi aplicate unui proces existent i pot fi executate doar de procesul-printe.
Procedura distrugere poate fi utilizat de ctre un proces pentru a se autodistruge. Deci, distrugere(p) va distruge
toate procesele desemnate de procesul p i toi descendenii acestora.
Procedura suspendare(p) ntrerupe execuia unui proces p, plasndu-l ntr-un fir de ateptare special. Execuia lui p
poate fi reluat doar cu ajutorul primitivei reluare(p). Primitivele suspendare i reluare sunt introduse din considerente
de securitate, n special pentru a permite monitorizarea unui proces de ctre procesul-printe.
Utilizarea primitivelor creare, distrugere, suspendare i reluare este condiionat de un drept, care figureaz n
atributul drepturi al procesului.
b) Sincronizarea
Procesele sunt sincronizate cu ajutorul monitoarelor. Gestiunea ntreruperilor este integrat n mecanismul
monitoarelor: o ntrerupere este asociat unei condiii. Specificarea primitivelor, care difer un pic de cea din 3.3, este
precizat n 4.3.2. Monitoarele sunt declarate n programele proceselor; un monitor este creat la compilarea
programului, unde el este declarat, i este mai apoi utilizat conform regulilor, definite de limbajul de programare utilizat
(care nu este aici specificat).
4.3.1.2. Structuri i algoritmi
Din momentul crerii sale unui proces i se asociaz un numr fix (process handler), care servete la desemnarea lui
i permite accesarea blocului su de context. Blocul de context conine urmtoarele cmpuri:
Csp
Reg
Stare
Prio
Drepturi
Fire, etc.
Suc, etc.

: zona de salvare a cuvntului de stare a procesorului,

: zona de salvare a registrelor generale ale procesorului,
: valoarea strii procesului (eligibil, blocat, ...),
: prioritatea procesului,
: drepturile procesului,
: legturi de nlnuire n ierarhia proceselor,
: legturi de nlnuire n firele de ateptare (FA).

Administrarea proceselor utilizeaz fire de ateptare, ordonate n ordinea de descretere a prioritilor i comandate
de un set de proceduri de accesare, specificate mai jos (p specific un proces, f un fir de ateptare):
introducere(p, f) Introduce p n f, n elementul lui f care corespunde prioritii procesului i n ordinea sosirii pentru
procesele cu aceeai prioritate.
primul(f)

ntoarce numrul (numele) procesului din vrful lui f (nil dac f este vid); nu modific f.

ieire(p, f)

Extrage din firul f primul proces, numrul acestuia fiind pus n p (nil dac f este vid).

extragere(p, f)

Extrage din firul f procesul cu numrul p specificat, oricare ar fi elementul n care acesta se afl;
pune n p valoare nil, dac procesul nu exist n firul f.

vid(f)

Funcie boolean cu valoarea adevrat, dac firul f este vid, fals n caz contrar.

Figura 4.4 prezint schematic organizarea unui fir de ateptare a proceselor.

..
.
Csp[i]

legtur de nlnuire

Reg[i]
Stare[i]

Bloc de
context

Drepturi[i]
Prio[i]

..
.
legturi de nlnuire n FA
context n memorie
blocul contextului i
Fig.4.4. Organizarea unui FA de procese

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.9

4.3.2. Realizarea monitoarelor

Monitorul, descris mai jos, este inspirat de realizarea folosit n limbajul Mesa [12], care a fost validat de o vast
experien de utilizare. n raport cu noiunea clasic de monitor (3.3.3), aceast realizare prezint urmtoarele diferene:
1) Semantica primitivei semnalizare. Specificarea iniial a primitivei c.semnalizare precizeaz c unul din
procesele care sunt n ateptarea condiiei c (dac exist) este imediat deblocat, ceea ce implic trecerea temporar n
starea blocat a procesului care execut semnalizare. n specificarea prezent procesul deblocat este simplu trecut n
starea eligibil i trebuie s intre n monitor; el se afl, deci, n competiie cu alte procese, care ateapt s intre n
monitor, i nu este garantat c va fi imediat ales. Condiia, care provocase deblocarea, poate fi modificat nainte ca
procesul deblocat s-i reia execuia n monitor. Pentru aceast nou interpretare trebuie s fie modificat forma punerii
n ateptare. O construcie de forma
if continuare_non_posibil then
c.ateptare
endif
devine n acest caz
while continuare_non_posibil do
c.ateptare
endwhile
Dei aceast construcie introduce un risc de privaiune, ea prezint o serie de avantaje de ordin practic. Ea evit o
comutare a contextului, cu preul unei evaluri suplimentare a condiiei. Dar principalul este c ea permite definirea
simpl a unor posibiliti suplimentare utile (deblocare multipl, ntrzieri de control sau de gard), precizate mai jos. n
fine, trebuie s notm, c verificarea validitii monitorului este simplificat, deoarece condiia de depire
(continuare_posibil) este consultat n timpul deblocrii: procesul care execut semnalizare poate s se mulumeasc
cu garantarea unei condiii mai slabe dect condiia de depire.
2) Deblocare multipl. Problema deblocrii multiple poate fi rezolvat uor introducnd o primitiv nou
c.difuzare_semnal efectul creia se exprim astfel:
while c.non_vid do
c.semnalizare
endwhile
Fiind dat, c toate procesele deblocate vor testa din nou condiia i cer din nou acces la monitor, aceast primitiv va
avea evident efectul ateptat.
3) ntrziere de gard. Din probleme de securitate, n special pentru tratarea blocajelor, poate fi util s se asocieze o
ntrziere de gard condiiei unui monitor. Aceast ntrziere este egal cu durata maxim de blocare a unui proces ntrun fir de ateptare asociat condiiei date. La expirarea ntrzierii de gard va fi efectuat o tratare specificat. Aceast
tratare poate consta n simpla deblocare a procesului (care va testa din nou condiia de depire) sau transferul su ntrun fir de ateptare special (v.4.3.2.3).
Fie M.c.ntrziere ntrzierea de gard asociat unei condiii c n monitorul M. Se presupune disponibil un ceas habs,
care pune la dispoziie timpul absolut. Trebuie s adugm n programul primitivei c.semnalizare instruciunea
urmtoare:
hdeblocare[p]:=habs+M.c.ntrziere
unde hdeblocare[p] este un cmp nou al blocului de context al procesului p. Un proces, numit gardian, deblocat la
intervale regulate de timp parcurge mulimea contextelor i efectueaz tratamentul specificat proceselor pentru care
hdeblocare[p]>habs.
4.3.2.1. Algoritmi de baz
Programul monitorului trebuie s asigure dou funcii:
excluderea mutual pentru procedurile monitorului,
blocarea i deblocarea asociate primitivelor ateptare i semnalizare.
Fiecrui monitor M i sunt asociate urmtoarele structuri de date:
un dispozitiv de excludere mutual M.disp (lact), care poate lua dou valori liber i ocupat, i un fir de
ateptare M.fir asociat acestui dispozitiv. Iniial M.disp=liber, M.fir=<vid>.
fiecrei condiii c de M i este asociat un fir M.c.fir, un contor de gard M.c.ntrziere i, pentru condiiile
asociate unei ntreruperi, un indicator boolean M.c.ntr_sosit.
Firul proceselor eligibile este determinat de f_eligibil.

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.10

Pentru un monitor M vom cerceta programul a patru secvene intrare, ieire, c.ateptare i c.semnalizare (secvenele
intrare i ieire sunt inserate de compilator i ncadreaz execuia procedurilor externe ale monitorului). S definim mai
nti procedurile de gestiune a dispozitivului:
cerere_disp(M, p):
if M.disp=ocupat then
intrare(p, M.fir);
stare[p]:=blocat
else
M.disp := ocupat;
intrare(p, f_eligibil);
stare[p]:=eligibil
endif
Cele patru secvene se vor scrie utiliznd urmtoarele proceduri:
intrare(M):
prolog;
p:=<proces apelant>;
cerere_disp(M, p);
alocare_procesor;

eliberare_disp(M):
if vid(M.fir) then
M.disp:=liber
else
ieire(q, M.fir);
intrare(q, f_eligibil);
stare[q]:=eligibil
endif

ieire(M):
prolog;
p:=<proces apelant>;
eliberare_disp(M);
intrare(p, f_eligibil);
alocare_procesor;

c.ateptare:
prolog;
p:=<proces apelant>;
intrare(p, M.c.fir);
stare[p]:=blocat;
eliberare_disp(M);
alocare_procesor;

c.semnalizare:
prolog;
p:=<proces apelant>;
if non_vid(M.c.fir) then
ieire(q, M.c.fir);
cerere_disp(M, p);
cerere_disp(M, q);
eliberare_disp(M)
else
intrare(p, f_eligibil)
endif
alocare_procesor;

S ne amintim, c secvena prolog asigur salvarea contextului i intrarea n seciunea critic, iar secvena
alocare_procesor asigur alocarea procesorului i prsirea seciunii critice (v.4.3.4).
Notm, c n primitiva semnalizare, procesul apelant p i procesul deblocat q sunt introduse (cu ajutorul primitivei
cerere_disp) n firul de ateptare pentru a intra n monitor. Procesul activat prin intermediul primitivei este primul
proces din acest fir. Nu am ncercat s reducem numrul transferurilor ntre fire pentru a realiza o implementare
optimal.
4.3.2.2. Tratarea ntreruperilor
Pentru asigurarea uniformitii mecanismelor de sincronizare fiecrei ntreruperi i se asociaz:
o condiie ntr-un monitor,
un proces ciclic care realizeaz tratarea ntreruperilor, n stare de repaus acest proces este n ateptarea condiiei.
O condiie poate fi asociat unui singur nivel de ntrerupere. Sosirea unei ntreruperi provoac executarea funciei
semnalizare pentru condiia asociat. Prioritatea relativ a ntreruperilor este tradus n prioritatea proceselor, care
trateaz ntreruperile.
Mecanismul descris mai sus nu este absolut perfect. De exemplu, excluderea procedurilor monitorului nu poate fi
aplicat ntreruperilor. Se poate ntmpla ca o ntrerupere s fie cerut atunci cnd procesul, care trateaz ntreruperile,
este nc activ, din care cauz ntreruperea va fi pierdut. Evitarea acestui fenomen se va face cu ajutorul unui indicator
boolean, care memorizeaz sosirea unei ntreruperi. Vom avea:
<proces de prelucrare a ntreruperii>
test

ciclu
if nonM.c.ntr_sosit then
c.ateptare;
go to test
endif;

-- evitarea pierderii unei ntreruperi

Cu excepia dac se va utiliza pentru asigurarea blocrii mascarea ntreruperilor. Aceast soluie (folosit n Modula-2) este aplicabil doar pentru
cazul monoprocesor i nu poate fi acceptat, dac exist restricii la ntrzierea unei ntreruperi.

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.11

<tratarea ntreruperii>
endciclu
<sosirea unei ntreruperi asociate lui M.c>
M.c.ntr_sosit := true;
c.semnalizare;
4.3.2.3. Tratarea erorilor
Principiul de tratare a erorilor const n blocarea procesului care a provocat eroarea i expedierea unui mesaj
procesului printe, care va putea lua msurile necesare (corectarea erorii i relansarea sau distrugerea procesului, care a
generat eroare). Pentru aceasta este folosit un fir special f_eroare (n conformitate cu organizarea sistemului, poate fi
prevzut un fir unic sau un fir pentru fiecare utilizator, pentru fiecare subsistem, etc.).
Presupunem c o eroare care are loc n cursul execuiei unui proces provoac o deviere, tratarea creia se va scrie
astfel:
prolog;
p:=<proces apelant>;
intrare(p, f_eroare);
<tratare specific>;
stare[p]:=suspendat;
alocare_procesor;
Am definit o stare nou (suspendat), care se aplic unui proces activitatea cruia a fost ntrerupt de un eveniment,
considerat anormal (eroare de execuie sau aciunea primitivei suspendare, v.4.3.3).
Nu detaliem aici <tratare specific>, care trebuie s fie specificat de ctre procesul printe la momentul crerii
procesului descendent. Acest program conine, evident, codul de diagnosticare (identitatea procesului generator de
eroare, natura erorii), care trebuie transmis procesului printe ntr-un mod special, conform gradului de urgen
(actualizarea unui indicator, deblocare, etc.).

4.3.3. Operaii asupra proceselor

4.3.3.1. Crearea i distrugerea proceselor
Problema principal, condiionat de gestiunea dinamic a proceselor, este alocarea contextelor i numelor
proceselor. Pentru aceasta sunt utilizate dou metode principale:
pentru blocurile contextelor sunt rezervate un numr fix de amplasamente; amplasamentele neutilizate sunt
determinate de o valoare special (nil) a cmpului stare al lor; fiecare bloc este desemnat printr-un numr, care
este numrul utilizat pentru desemnarea procesului asociat;
amplasamentele rezervate blocurilor de context sunt alocate dinamic n memorie; numerele sunt alocate
proceselor de asemenea n mod dinamic i un tabel de coresponden, asociaz numrului fiecrui proces adresa
n memorie a blocului su de context.
n ambele cazuri vom presupune disponibil o procedur alocare_context(p), care realizeaz alocarea contextului
(blocul de context i spaiul de lucru) i ntoarce ca rezultat un numr p al procesului (nil, dac crearea este imposibil,
de exemplu, din cauza lipsei de spaiu suficient n memorie). Metodele de alocare a spaiului de lucru nu sunt precizate
aici. Numrul procesului creat este ntors drept rezultat al primitivei:
creare(p, context iniial):
prolog;
control;
-- verificarea drepturilor
alocare_context(p);
if p nil then
iniializare_context(i);
intrare(p, f_eligibil)
endif;
intrare(proces apelant, f_eligibil);
alocare_procesor;
-- este ntors p drept rezultat
Contextul iniial este specificat de ctre procesul creator: el trebuie s defineasc valoarea iniial a registrelor i a
cuvntului de stare a procesului creat, starea iniial a spaiului de lucru, atributele, cum ar fi prioritatea i drepturile.
Unele cmpuri ale cuvntului de stare sunt predefinite i nu pot fi modificate (modul, mascarea ntreruperilor, etc.).
Pentru elementele legate de protecie (drepturile de acces), procesul creat nu poate avea drepturi superioare drepturilor
procesului creator; n caz contrar atributele de protecie sunt declarate defecte.

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.12

Distrugerea unui proces trebuie s implice eliberarea resurselor, care i fuseser alocate. Printre aceste resurse, doar
numele i contextul sunt gestionate direct de nucleu; celelalte resurse, cum ar fi fiierele, sunt preluate de mecanisme
specifice.
Distrugerea unui proces, care se afl n seciunea critic poate conduce la o blocare. Seciunile critice ale
monitoarelor sunt gestionate direct de nucleu. Este posibil s se asocieze unui proces numrul dispozitivului de blocare,
care se afl n posesia procesului dat (el poate fi angajat n mai multe apeluri incorporate), i s difereniem distrugerea
procesului pn cnd valoarea acestui numr nu va fi 0. O alt soluie const n examinarea periodic a fiecrui
dispozitiv de blocare i s eliberm dispozitivul de blocare, dac procesul care l posed a fost distrus.
Principiul primitivei distrugere este dat n schema de mai jos:
distrugere (p):
prolog;
control;
-- verificarea drepturilor
eliberare_context(p);
intrare(proces apelant, f_eligibil);
alocare_procesor;
Procedura eliberare_context trebuie s asigure eliberarea resurselor ocupate de procesul distrus i de descendenii
acestuia:
eliberare_context(p):
list:=<lista firelor procesului p>;
restituire_bloc_context(p);
restituire_memorie(p);
for q list do
eliberare_context(q)
endfor;
4.3.3.2. Suspendarea i reluarea
Primitiva suspendare permite procesului-printe s controleze activitatea unui proces descendent, ntrerupnd n
mod forat execuia acestuia. O utilizare curent este suspendarea unui proces, angajat ntr-o bucl infinit. Procesul
ntrerupt n acest mod este transferat ntr-un fir de ateptare special, care poate fi firul f_eroare, utilizat pentru devieri.
Efectul primitivei suspendare poate fi ca i al unei devieri i programul de tratare poate fi analogic. Suspendarea
unui proces pune o problem analogic celei de distrugere, dac procesul se afl n seciunea critic ntr-un monitor.
suspendare(p):
prolog;
control;
< tratare seciune critic>;
f:=<fir care conine p>;
extragere(p, f);
intrare(p, f_eroare);
stare[p]:=suspendat;
intrare(proces apelant, f_eligibil);
alocare_procesor;
Primitiva reluare permite unui proces s deblocheze un fir suspendat, dup modificarea eventual a contextului su.
reluare(p):
prolog;
control;
extragere(p, f_eroare);
stare[p]:=eligibil;
intrare(proces apelant, f_eligibil);
intrare(p, f_eligibil);
alocare_procesor;

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.13

4.3.4. Excluderea mutual i alocarea procesorului

4.3.4.1. Realizarea pentru cazul monoprocesor
n acest caz excluderea mutual este realizat prin mascarea ntreruperilor. Pentru aceasta trebuie pregtit masca
ntreruperii n cuvntul de stare, care ar specifica programele asociate primitivelor de tratare a ntreruperilor. Dac
notm prin proces_ales o variabil global, care conine numrul procesului ales, iar prin salv_csp locaiunea n care a
fost salvat cuvntul de stare a procesorului la apelarea supervizorului sau la ntrerupere, prologul va fi de forma:
prolog:
<mascarea ntreruperilor>
-- masca n cuvntul de stare
csp[proces_ales] := salv_csp;
salv_registre(Reg[proc_al]);
Programul dispecerului, care de asemenea realizeaz ieirea din seciunea critic, are grij s aloce procesorul
primului proces din firul de procese eligibile. Pentru simplificarea manipulrii acestui fir este binevenit s fie introdus
aici un proces special cu prioritate joas, care rmne tot timpul n coada firului i nu poate fi blocat. Acest proces, care
poate fi ales doar atunci cnd el este unicul eligibil, execut o activitate de fond, care nu este urgent sau o simpl bucl
de ateptare. El garanteaz, deci, c firul proceselor eligibile nu este niciodat vid.
f_eligibil
Cuvnt de stare
Registre

proc_al

Csp
Reg
Prio=6
p1

Csp
Reg
5

p2

Procesor

p3

p4

c.fiier

(a) nceputul executrii c.ateptare

p5

p6
Cuvnt de stare
Registre

proc_al

f_eligibil

Procesor

6
c.fiier

p1

5
p3

p2

(b) sfritul executrii c.ateptare

5
p5

2
p4

1
p6
Fig.4.5. Alocarea procesorului

Programul dispecerului este de forma:

alocare_procesor:
ieire(proces_ales, f_eligibil);

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.14

ncrcare_registre(Reg[proc_al]);
ncrcare_csp(csp[proces_ales]);
Figura 4.5 ilustreaz principiul de funcionare a nucleului, exemplificnd efectul global al unei realocri a
procesorului dup blocarea procesului ales.
4.3.4.2. Realizarea pentru cazul unui sistem multiprocesoral
Descrierea, care urmeaz este inspirat din [13]. Vom specifica mai nti organizarea fizic a sistemului. Avem n
procesoare identice, care acceseaz o memorie comun. Fiecare procesor, desemnat printr-un numr (de la 0 la n-1), i
cunoate numrul propriu. Regimului de funcionare multiprocesor i sunt specifice dou instruciuni:
Test and Set(R, m)
ntrerupere(k)

:
:

asigur excluderea mutual (4.1.1.2)

provoac o ntrerupere a procesorului k.

O ntrerupere sau un apel de supervizor provoac introducerea cuvntului de stare i a registrelor procesorului n
cauz ntr-o stiv n memorie, proprie acestui procesor.
Orice primitiv a nucleului poate fi executat de oricare din procesoare. Vom mpri ntreruperile n ntreruperi,
destinate unui procesor specific (ceasul procesorului, instrucia ntrerupere(k)) i ntreruperi banalizate (intrri-ieiri, de
exemplu), care sunt tratate de orice procesor. n acest caz pentru a fi retras se va alege procesorul, care execut procesul
cu cea mai mic prioritate. Numrul acestui proces se afl ntr-un amplasament rezervat de memorie kmin i vom
considera, c un dispozitiv fizic ndreapt ntreruperile banalizate spre procesorul cu numrul kmin. Vom utiliza acelai
principiu de alegere i n cazul unei alocri a procesoarelor.
Pentru ca firul proceselor eligibile s nu fie vid vom aduga aici n procese de prioritate joas. Numrul procesului
ales pentru a fi executat de procesorul k vom nota proc_al[k].
Excluderea mutual a primitivelor nucleului utilizeaz un dispozitiv de blocare, consultat i actualizat cu ajutorul
instruciunii Test And Set.
prolog:

-- procesorul k

<mascare ntreruperi>;
Csp[proc_al[k]]:=top(stiv_csp);
Reg[proc_al[k]]:=top(stiv_reg);
test: Test And Set(R, dispozitiv de blocare);
if R 0 then
go to test
-- ateptare activ
endif
Dispecerul va asigura ca cele n procese alese s fie la orice moment de timp cu prioritatea cea mai nalt printre
procesele eligibile. Deoarece executarea primitivei curente poate modifica firul proceselor eligibile, prioritatea primului
proces eligibil este comparat cu prioritatea procesului ales pentru procesorul kmin. Dac aceasta este superioar
procesorul dat este retras cu ajutorul instruciunii ntrerupere.
alocare_procesor:

-- pentru procesorul cu numrul k

ieire(proces_ales[k], f_eligibil);
pr1:=Prio[primul(f_eligibil)];
pr2:=Prio[proc_al[kmin]];
if Prio[proc_al[k]] < pr2 then -- actualizarea lui kmin
kmin:=k
endif;
disp_de_blocare:=0;
-- terminarea seciunii critice
if pr1 > pr2 then
ntrerupere(kmin)
-- retragere
endif;
ncrcare_registre(Reg[proc_al[k]];
ncrcare_csp(Csp[proc_al[k]];
-- demascarea ntreruperilor
Tratarea ntreruperii de retragere (instruciunea ntrerupere) a procesorului se reduce la realocarea procesorului
ntrerupt:
<tratarea ntreruperii de retragere a procesorului k>
prolog;
intrare(proc_al[k], f_eligibil);
alocare_procesor;

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.15

4.4. Procese i fire n Linux

4.4.1. Crearea proceselor
n Linux procesele se nmulesc prin clonare: apelul de sistem, care creaz un proces nou, se numete clone, iar
procesul fiu este o copie aproape exact a procesului printe, doar c mai departe va executa codul su, iar procesul
printe ceea ce este scris dup apelarea lui clone. Diferenele pot deveni foarte mari i dac dorim s evitm
diferenierea, apelarea lui clone permite s definim urmtorii indicatori (flags), care vor specifica momentele comune
ale fiului i printelui:

Spaiul de adrese (Clone_VM);

Informaiile despre sistemul de fiiere (Clone_FS);
Tabelul fiierelor deschise (Clone_FILES);
Tabelul programelor de tratare a semnalelor (Clone_SIGHAND);
Printele (Clone_PARENT) n acest caz, evident, va fi creat un proces frate.

Firele sunt realizate n biblioteca standard de susinere a programelor cu mai multe fire ca i procesele, generate cu
indicatorul Clone_VM, i, din punctul de vedere al nucleului sistemului, nu se deosebesc de alte procese. ns n unele
biblioteci de alternativ pot exista diferene.
Mai exist fire, numite handicapate, generate de funcia kernel_thread pentru necesiti interne ale sistemului.
Acestea nu au parametri pentru linia de comand, de obicei nu au fiiere deschise, etc. Deoarece aceste fire (procese) de
asemenea figureaz n lista lucrrilor, adesea n literatur poate fi ntlnit noiunea de proces propriu-zis, creat din
spaiul utilizatorului (userspace), i noiunea de lucrare, prin aceasta nelegndu-se toate procesele, inclusiv
procesele interne ale nucleului.
Procesele sunt create prin utilizarea funciilor din familia exec ale bibliotecii Linux standard: execl, execlp,
execle, execv, execve, execvp. Dei formatul de apelare este diferit, n ultim instan execut acelai lucru:
nlocuiesc codul din procesul curent cu codul, care se afl n fiierul indicat. Fiierul poate fi un fiier binar executabil
Linux, un script al interpretorului limbajului de comand, un fiier binar de un alt format (de exemplu, o clas java, un
fiier executabil DOS). n ultimul caz modalitatea de prelucrare va fi determinat de modulul de adaptare a nucleului
binfmt_misc. Din aceast cauz, operaia de lansare a unui program, care n DOS i Windows formeaz un tot ntreg, n
Linux (i n Unix, n general) este mprit n dou: mai nti are loc lansarea propriu-zis, iar apoi se va determina care
program va fi executat. Are oare aceasta sens i care sunt cheltuielile suplimentare? Doar crearea copiei unui proces
presupune copierea unui volum semnificativ de informaii!
n mod sigur putem afirma c are sens aceast abordare. Foarte frecvent un program trebuie s ndeplineasc unele
aciuni nainte de nceperea propriu-zis a execuiei lui. De exemplu, lansm dou programe, care-i transmit reciproc
date prin intermediul unui canal fr nume. Astfel de canale sunt create prin apelarea de sistem pipe, care returneaz o
pereche de descriptori de fiiere de care pot fi legate, de exemplu, fluxul standard de intrare (stdin) al unui program i
de ieire (stdout) al celuilalt program. Aceasta este posibil deoarece mai nti sunt create procesele, apoi vor fi
executate manipulrile necesare cu descriptorii fiierelor i doar dup toate acestea este apelat funcia exec.
Aceleai rezultate pot fi obinute n Windows NT ntr-un singur pas, dar ntr-un mod mult mai complicat. Ct despre
cheltuielile suplimentare ele sunt n majoritatea cazurilor minime, deoarece dac este creat copia unui proces datele
proprii ale acestuia nu sunt fizic copiate. i aceasta din cauza c este utilizat procedeul copy-on-write: paginile datelor
ambelor procese sunt marcate ntr-un anumit mod i doar atunci cnd un proces va ncerca s modifice coninutul uneia
din paginile sale aceasta va fi duplicat.
Primul proces este lansat n sistem la iniializarea nucleului. Fragmentul de cod de mai jos este partea de ncheiere a
procedurii de iniializare a nucleului sistemului de operare Linux:
if (execute_command)
execve(execute_command,argv_init, envp_init);
execve("/sbin/init",argv_init,envp_init);
execve("/etc/init",argv_init,envp_init);
execve("/bin/init",argv_init,envp_init);
execve("/bin/sh",argv_init,envp_init);
panic("No init found. Try passing init= option to kernel.");}
Este fcut ncercarea de comutare a procesului la fiierul, indicat n linia de comand a nucleului, apoi la fiierele
/sbin/init, /etc/init, /bin/init i, n sfrit, la fiierele din /bin/sh.
4.4.2. Distrugerea proceselor
La terminarea execuieia unui proces (normal, forat sau accidental), el este distrus elibernd toate resursele, care
fusese alocate anterior. Dac procesul printe se termin naintea procesului descendent, ultimul devine orfan

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.16

(orphaned process). Toi orfanii sunt nfiai n mod automat de programul init, executat de procesul cu numrul 1,
care duce evidena terminrii execuiei lor.
Dac a fost terminat deja execuia procesului descendent, iar procesul printe nu este gata s recepioneze de la
sistem semnalul despre acest eveniment, descendentul nu dispare total, ci este transformat n Zombie; n cmpul Stat
aceste procese sunt notate cu litera Z. Procesele Zombi nu cer timp de procesor, dar n tabelul proceselor este pstrat
linia lor i structurile respective ale nucleului nu sunt eliberate. Dup terminarea execuiei procesului printe, procesul
Zombi orfan devine pentru o perioad scurt de timp descendentul lui init, ca mai apoi s moar definitiv.
Un process poate s cad n hibernare, fr a putea fi scos din aceast stare: n cmpul Stat acest eveniment se va
nota prin litera D. Procesele aflate n hibernare nu reacioneaz la cererile de sistem i pot fi distruse doar prin
rencrcarea sistemului.
4.4.3. Demoni n Linux
Demon (daemon) n Linux este numit procesul predestinat s lucreze n regim de fond fr terminal i care execut
anumite operaii pentru alte procese (nu obligator pe calculatorul Dumneavoastr). De obicei, demonii i ndeplinesc n
linite lucrul i ne amintim de ei doar n cazul unor situaii ieite din comun: spaiu insuficient demonul singur
informnd utilizatorul despre aceasta, sau refuz s lucreze i suntei ntrebat de ef cnd se vor termina problemele cu
imprimant .
Pentru multe calculatoare demonii, care servesc procesele altor calculatoare, sunt rar utilizai din care cauz nu
trebuiesc pstrai constant n memorie cu cheltuieli neraionale ale resurselor sistemului. Pentru coordonarea lucrului
acestora a fost creat un superdemon inetd (Internet daemon).
n fiierul de configurare inetd (/etc/inetd.conf) este indicat care demon acceseaz un serviciu anume de Internet.
De obicei, cu ajutorul lui inetd sunt apelate programele pop3d, imap4d, ftpd, telnetd (exerciiu - determinai serviciul
pus la dispoziie), etc. Aceste programe nu sunt n mod constant active, n rezultat, ele nu pot fi considerate demoni n
adevratul sens al cuvntului, dar, deoarece ele sunt create de un demon adevrat, sunt numite demoni.
4.4.4. Obinerea informaiilor despre procese
Pentru obinerea informaiilor despre procese, vizualizate de programele ps i top, Linux-ul utilizeaz un sistem
special de fiiere, numit procfs. n majoritatea distributivelor el este iniializat la lansarea sistemului de operare cu titlul
de catalog /proc. Datele despre procesul cu numrul 1 (de obicei /sbin/init) se afl n subcatalogul /proc/1, despre
procesul cu numrul 182 - n /proc/182, etc. Toate fiierele, deschise de un proces, sunt reprezentate sub forma unor
referine simbolice n catalogul /proc/<pid>/fd, iar referina la catalogul rdcin este pstrat ca /proc/<pid>/root.
Sistemului de gestiune a fiierelor procfs i sunt asociate i alte funcii. De exemplu, cu ajutorul comenzii echo
100000>/proc/sys/fs/file-max un superuser poate indica, c se permite deschiderea unui numr de pn la 100000 de
fiiere, iar comanda echo 0>/proc/sys/kernel/cap-bound va retrage proceselor din sistem toate drepturile
suplimentare, adic va priva sistemul de noiunea superuser.
Informaii utile pune la dispoziie programul lsof. Acesta returneaz lista tuturor fiierelor, utilizate la momentul
curent de ctre procese, inclusiv cataloagele folosite de ctre unele procese n calitate de catalog curent sau catalog
rdcin, bibliotecile dinamice, ncrcate n memorie, etc.

4.4. Exerciii la capitolul 4

Exerciiul 1 [14]. O mulime de procese, care coopereaz pentru executarea unei lucrri comune, poate fi reprezentat
printr-un graf orientat n care fiecare arc reprezint evoluia complet a unui proces. Graful obinut n aa mod este
numit graful proceselor lucrrii considerate. Introducem dou reguli de compunere S(a, b) i P(a, b), n care a i b
desemneaz procese, astfel nct:
S(a, b) reprezint execuia secvenial a proceselor a i b,
P(a, b) reprezint execuia lor paralel.
Folosind doar funciile S i P, descriei atunci cnd este posibil, urmtoarele grafuri:
p1
p2
p3
p4

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.17

(1)
Exerciiul 2. n cazul cnd nu se cere respectarea strict a ordinii executrii unor subexpresii n cadrul unei expresii
aritmetice, valorile subexpresiilor pot fi calculate ntr-o ordine relativ arbitrar, fiind posibil evaluarea paralel, dac
exist un numr suficient de procesoare.
Fie expresia:
(a+b)*(c+d) (e/f)
1) Elaborai structura arborelui corespunztor.
2) Folosind conveniile exerciiului 1, elaborai un graf al proceselor corespunztoare unei evaluri paralele a acestei
expresii. Se va ncerca s se exploateze la maximum paralelismul.
3) Aducei o descriere a acestui graf, utiliznd n exclusivitate funciile S i P, introduse n exerciiul 1.
Exerciiul 3. Problema excluderii mutuale pentru procesele paralele cu ajutorul variabilelor comune [15]. Acest
exerciiu are drept scop demonstrarea dificultii programrii excluderii mutuale pentru cazul proceselor paralele, dac
unicele operaii de care dispunem sunt modificarea i testarea valorii unei variabile (operaii de tipul TAS, ca i
semafoarele sunt excluse). Principiul soluiei cutate const n definirea unei mulimi de variabile de stare, comune
contextelor diferitor procese; autorizarea intrrii n seciunea critic se va face prin teste asupra acestor variabile, iar
ateptarea eventual va fi programat ca o ateptare activ, adic prin repetarea ciclic a testelor.
1) Ne vom limita pentru nceput la cazul a dou procese, notate p1 i p2 i vom ncerca s construim o soluie, folosind
o variabil boolean unic c, cu valoarea true, dac unul din procese se afl n seciunea sa critic i false n caz
contrar.
Artai, c excluderea mutual nu poate fi programat utiliznd numai aceast unic variabil.
2) Construii o soluie, utiliznd o variabil comun unic t, cu urmtoarea condiie: t = i (i=1, 2), atunci i numai
atunci cnd pi este autorizat s intre n seciunea sa critic.
Scriei programul procesului pi,
Verificai, care din caracteristicile excluderii mutuale sunt prezente.
3) Pentru a fi ndeplinite toate caracteristicile excluderii mutuale, introducem cte o variabil boolean pentru proces;
fie variabila c[i] ataat procesului pi cu urmtorul sens:
c[i]=true dac procesul pi este n seciunea sa critic sau cere s intre acolo,
c[i]=false dac procesul pi este n afara seciunii sale critice.
Procesul pi poate s citeasc i s modifice c[i] i numai s citeasc c[j] (ji).
Scriei programul procesului pi,
Verificai, care din caracteristicile excluderii mutuale sunt prezente.
4) Combinnd 2) cu 3) putem obine o soluie corect, adic, completnd soluia 3) prin introducerea unei variabile
suplimentare t, care va servi la reglarea conflictelor la intrarea n seciunea critic. Aceast variabil poate fi
modificat doar la ieirea din seciunea critic. Principiul rezolvrii este urmtorul: n caz de conflict (adic, dac
c[1]=true i c[2]=true) cele dou procese trec ntr-o secven de ateptare n care t pstreaz o valoare constant.
Procesul pi cu it anuleaz cererea sa (c[i]=false), permind celuilalt proces s intre n seciunea sa critic; pi
ateapt ntr-o bucl ca t s fie pus n i nainte de repetarea cererii sale de intrare prin c[1]=true.
Scriei programul procesului pi,
Verificai, care din caracteristicile excluderii mutuale sunt prezente.
5) Generalizai soluia 4) pentru i>2.
Exerciiul 4. Descrierea unui sistem simplu de ntrerupere.
Considerm un sistem de ntrerupere, utiliznd dou bistabile: o masc m i un indicator de ntrerupere t. ntreruperea
este mascat, dac m=0 i autorizat, dac m=1. Sosirea unui semnal de ntrerupere se manifest prin tentativa de a
pune pe t n 1: t := 1. Dac ntreruperea este demascat, t trece imediat n 1; n caz contrar, t trece n 1 n momentul
demascrii. Punerea lui t n 1 conduce la deblocarea unui proces ciclic de tratare a ntreruperii.
Descriei, cu ajutorul semafoarelor, logica acestui dispozitiv cablat i a procesului ciclic de tratare.

/var/www/apps/conversion/tmp/scratch_6/338333058.doc

p.18