1.

Noţiuni şi termeni din domeniul resurselor tehnice

Pentru a trece la noţiunile principale, legate de hardware, vom face cunoştinţă mai întâi cu
funcţiile de bază ale unui calculator. Pot fi evidenţiate cinci funcţii esenţiale : stocarea datelor
şi extragerea rezultatelor:
• iniţializarea implică testarea părţilor importante ale calculatorului, rularea
fişierelor de pornire şi încărcarea altor fişiere necesare, cum ar fi driverele dispozitivelor
periferice;
• introducerea reprezintă transferul datelor dintr-o sursă externă în calculator. Surse
externe pot fi tastatura, mouse-ul, discheta, discul mobil, memory stick-ul, aparatul digital de
fotografiat etc.;
• procesarea se referă la manipularea datelor introduse în scopul producerii unui
rezultat (ieşirea);
• stocarea constituie procesul salvării informaţiilor (date sau programe) într-un
dispozitiv de păstrare, de exemplu discul fix, pentru recuperarea ulterioară.

2. Noţiuni şi termeni din domeniul sistemelor de operare

Un sistem de operare este un ansamblu de programe de control şi de serviciu care ghidează un
calculator în execuţia sarcinilor sale, asistă programele de aplicaţie şi interacţionează cu
utilizatorul prin intermediul anumitor funcţiuni. Natura funcţiilor şi modul în care acestea sunt
realizate determină atributele care caracterizează un sistem de operare: timpul de răspuns-
exprimă durata intervalului delimitat de lansarea unei cereri de serviciu şi achitarea acesteia de
către sistem, simultaneitatea utilizării- măsoară gradul în care un sistem poate să execute în
acelaşi timp mai multe lucrări., eficienţa- măsoară proprietatea unui sistem de a folosi în mod
optim resursele de care dispune, partajarea resurselor şi protecţia informaţiei în calculator.

3. Tipuri de sisteme de operare, obiective şi funcţii

Valorile concrete ale atributelor sistemelor de operare şi combinaţiile acestor atribute
determină diverse tipuri de sisteme şi restricţii de implementare. Conform acestor atribute pot
fi evidenţiate sisteme de operare [3]:
 secvenţiale
 cu multiprogramare
 cu prelucrare multiplă
 în timp real, etc.
Majoritatea sistemelor de operare recunosc programul ca cea mai mică unitate de
prelucrare, căreia i se atribuie o identitate şi pe care un utilizator o poate prezenta spre
execuţie. Unele sisteme permit ca un program să fie considerat ca un ansamblu de sarcini ale
căror execuţii (inclusiv în paralel) contribuie la atingerea obiectivului urmărit de acest
program.
 Un sistem secvenţial (tratare pe loturi, batch processing, traitement par lots) execută la un
moment dat un singur program, care trebuie terminat înainte de a lansa în execuţie un alt
program.
Sistemele cu multiprogramare acceptă la un moment dat mai multe programe în memoria
operativă, acestea aflându-se în diferite stadii de execuţie.
Un sistem de calcul cu prelucrare multiplă dispune de mai multe procesoare, care pot să
execute simultan unul sau mai multe programe. Utilizarea efectivă a prelucrării multiple
solicită atributul de multiprogramare. Execuţia simultană a unui singur program de către mai
multe unităţi presupune existenţa posibilităţii de a descompune acest program în mai multe
sarcini (multitasking) sau procese (fire)..
Sistemele în timp real sunt dedicate, de obicei, funcţionării în cadrul unor sisteme de
comandă şi este necesar ca valorile anumitor atribute să se încadreze în limite destul de
restrictive, dictate de dinamica proceselor comandate.
Tipurile de sisteme de operare enumerate mai sus nu sunt nici disjuncte şi nici exhaustive.
Majoritatea sistemelor existente pot fi încadrate în mai multe clase, atunci când se face o
analiză prin prisma obiectivelor pe care le urmăresc. La capitolul obiective vom aminti în
primul rând maximizarea eficienţei sistemului de calcul şi a satisfacţiei utilizatorilor. Tot
la obiective poate fi trecută şi cererea de minimizare a posibilităţii de apariţie a unor erori
şi de maximizare a transparenţei sistemului de operare, garantarea securităţii datelor,
optimizarea controlului comunicaţiilor în cazul unei reţele de calculatoare. Un obiectiv
foarte important este necesitatea de minimizare a efortului concepţie-realizare a sistemului,
ultim în enumerare, dar poate cel mai important pentru specialişti. Toate aceste obiective sunt
consecinţe ale dezideratului principal: un sistem de operare este destinat să administreze
resursele sistemului de calcul şi anume memoria, procesorul (procesoarele), dispozitivele şi
informaţia.
Un sistem de operare este obligat:
 să păstreze informaţia despre starea fiecărei resurse,
 să ia decizia cărui proces să i se aloce resursa, în ce cantitate şi când,
 să aloce resursa şi la momentul respectiv să o retragă.

4. Exemple de sisteme de operare

5. Cazul calculatoarelor personale

Cea mai simplă configuraţie a unui calculator personal (PC) include o unitate centrală, o
memorie principală, un display, o tastatură şi un mouse. Această configuraţie, de regulă, este
completată de o memorie secundară şi o imprimantă.
Utilizatorul unui astfel de sistem va cere minimum următoarele două tipuri de servicii:
identificarea şi crearea unor fişiere sau mulţimi structurate de informaţii;
stocarea acestor fişiere în memoria secundară; transferarea informaţiilor între fişiere şi
dispozitivele de intrare/ieşire;
execuţia unor programe existente sau introduse sub formă de fişiere în PC;
introducerea datelor necesare pentru execuţia programului (de la tastatură, dintr-un fişier sau
de la alte surse periferice); listarea rezultatelor la display, imprimantă sau copierea lor într-un
fişier.

6. Comanda unor procese industriale

Procesul de producere este comandat de un calculator care îndeplineşte următoarele funcţii:
 Reglare. Pentru o derulare bună a procesului de fabricaţie parametrii de funcţionare
(temperatura, presiunea, concentraţia, etc.) trebuie să se afle într-o plajă de valori predefinite.
Pentru aceasta va fi acţionat debitul de intrare a materiilor prime A sau B. Parametrii de
funcţionare sunt măsuraţi cu ajutorul unor captoare.
 Înregistrare. Rezultatele măsurărilor sunt periodic înregistrate; valorile lor sunt afişate
pe un tablou de bord şi recopiate într-un fişier ("jurnal de bord") în scopul unor prelucrări
ulterioare (date statistice).
 Securitate. În cazul în care unul dintre parametrii măsuraţi depăşeşte o valoare critică
predefinită reactorul trebuie oprit imediat.

7. Sisteme tranzacţionale
Caracteristicile principale:
• sistemul gestionează un set de informaţii sau baze de date, care pot atinge volume
importante de informaţie;
• asupra acestor informaţii pot fi executate un anumit număr de operaţii predefinite sau
tranzacţii, adesea interactive;
• sistemul este dotat cu un mare număr de puncte de acces şi un mare număr de tranzacţii se
pot derula simultan. Caracteristicile obligatorii ale unui astfel de sistem tranzacţional sunt
disponibilitatea şi fiabilitatea; pentru unele sisteme poate fi importantă şi toleranţa la defecţiuni.
O caracteristică importantă ale sistemelor tranzacţionale este multitudinea activităţilor paralele,
iar în multe cazuri şi repartizarea geografică a componentelor.

8. Sisteme în timp partajat

Destinaţia principală a unor astfel de sisteme este furnizarea serviciilor necesare unei mulţimi
de utilizatori, fiecare dintre ei beneficiind de servicii:
• echivalente serviciilor unui calculator individual;
• legate de existenţa unei comunităţi de utilizatori: partajarea informaţiilor, comunicaţii între
utilizatori.
Problemele care apar datorită conceptului de partajare a timpului sunt o combinaţie a
problemelor existente în cazul unui calculator individual cu cele din sistemele tranzacţionale.
Caracteristicile obligatorii ale unui astfel de sistem îmbină, în egală măsură, calităţile unui
sistem de operare al unui calculator individual şi al unui sistem tranzacţional, cum ar fi:
disponibilitatea, fiabilitatea, securitatea, exploatarea optimă a caracteristicilor resurselor fizice,
calitatea interfeţei şi serviciilor utilizatorului, facilitatea adaptării şi extensibilităţii.
9. SISTEMUL DE OPERARE ŞI PROCESELE
Noţiunea de proces este asociată conceptului de lucrare şi poate fi definită ca o suită temporală
de execuţii de instrucţiuni, considerată ca fiind o entitate de bază în descrierea sau analiza
funcţionării unui sistem. Evoluţia în timp a unui proces presupune un consum de resurse, dictat
de natura şi complexitatea instrucţiunilor de execuţie. În particular, rezultă că ori de câte ori se
execută procedurile de sistem, resursele, pe care le utilizează acesta, intră în administrarea
procesului, care a cerut serviciul. Resursele alocate unui proces variază în timp.

10. MAŞINĂ IERARHICĂ ŞI MAŞINĂ EXTINSĂ

Setul de instrucţiuni realizat hardware împreună cu instrucţiunile suplimentare ale sistemului
de operare formează sistemul de comenzi al maşinii extinse.
Nucleul sistemului de operare va fi executat pe maşina “goală”, iar programele utilizatorului
– pe maşina extinsă.

11. ALTE PUNCTE DE VEDERE ASUPRA SISTEMELOR DE OPERARE

Sistemele de operare pot fi abordate din diferite puncte de vedere, cum ar fi SO şi procesele,
SO şi maşina extinsă sau SO şi maşina ierarhică. Există şi alte puncte de vedere asupra
sistemelor de operare pe care un specialist ar trebui să le cunoască.
Abordare funcţională-Pentru un utilizator obişnuit, convins că un calculator este doar un
instrument care îl ajută în soluţionarea unor probleme din domeniul său de activitate, noţiunile,
cum ar fi administrarea memoriei cu paginaţie sau driverele dispozitivelor, nu semnifică prea
multe. Destinaţia principală a unui sistem de operare pentru această categorie de utilizatori este
punerea la dispoziţie a unui set de programe care l-ar ajuta în formularea şi soluţionare
problemelor concrete ce ţin de domeniul său de activitate.
Abordare din punctul de vedere al interfeţei cu utilizatorul
Interfaţa sistemului de operare cu utilizatorul prezintă un interes aparte. Progresul în acest
domeniu este spectaculos, dacă vom lua în consideraţie că în primele sisteme de operare
utilizatorul era obligat să indice în mod explicit şi manual (în regim textual) fiecare pas, oricât
de nesemnificativ ar fi părut. Formularea paşilor cu ajutorul unui limbaj specializat, cum ar fi
Job Control Language (JCL), nu a schimbat substanţial situaţia.

Abordare funcţională
Abordare funcţională-Pentru un utilizator obişnuit, convins că un calculator este doar un
instrument care îl ajută în soluţionarea unor probleme din domeniul său de activitate, noţiunile,
cum ar fi administrarea memoriei cu paginaţie sau driverele dispozitivelor, nu semnifică prea
multe. Destinaţia principală a unui sistem de operare pentru această categorie de utilizatori este
punerea la dispoziţie a unui set de programe care l-ar ajuta în formularea şi soluţionare
problemelor concrete ce ţin de domeniul său de activitate.

Abordare din punctul de vedere al interfeţei cu utilizatorul

Abordare din punctul de vedere al interfeţei cu utilizatorul
Interfaţa sistemului de operare cu utilizatorul prezintă un interes aparte. Progresul în acest
domeniu este spectaculos, dacă vom lua în consideraţie că în primele sisteme de operare
utilizatorul era obligat să indice în mod explicit şi manual (în regim textual) fiecare pas, oricât
de nesemnificativ ar fi părut. Formularea paşilor cu ajutorul unui limbaj specializat, cum ar fi
Job Control Language (JCL), nu a schimbat substanţial situaţia.

12. EVOLUŢIA SISTEMELOR DE OPERARE

Primele sisteme erau caracterizate prin prelucrarea secvenţială a taskurilor. Timpul de execuţie
a programelor era relativ mare, instrumentele de depanare – primitive, fiecare programator îşi
încărca în mod individual programul (pachetul de cartele perforate), apăsa butoane, controla
conţinutul locaţiunilor de memorie, etc. (1950 – 1956). Au fost propuse programe de
monitorizare (monitoare), care treceau de la o lucrare la alta în mod automat, utilizatorul fiind
responsabil de organizarea corectă a programelor în cadrul unui pachet – primele încercări de
prelucrare pe loturi (1956 – 1959).
După 1965 au apărut primele sisteme cu partajare a timpului (time sharing), au fost propuse
sisteme sofisticate de administrare a informaţiei Memoria virtuală şi maşinile virtuale sunt nişte
principii care nici până astăzi nu au fost exploatate până la capăt. Progresele ultimilor ani în
domeniul resurselor tehnice au permis implementarea acestor principii nu numai în cadrul
sistemelor de calcul mari, ci şi pentru calculatoarele personale.
De la "poartă deschisă " la tratarea pe loturi
Primele calculatoare nu dispuneau de sisteme de operare. Fiecărui utilizator i se rezerva pentru
un timp determinat calculatorul cu toate resursele acestuia. Interacţiunea era directă, programul
şi datele fiind introduse în mod manual sub formă de zerouri şi unităţi. Utilitele care au apărut
aveau destinaţia de a asista elaborarea programelor (asambloare, compilatoare, etc.) sau de a
facilitata operaţiile de intrare-ieşire.Acest mod de exploatare, numit "poartă deschisă" , era de
o eficacitate minimă. Din această cauză la sfârşitul anilor '50 au apărut primele "monitoare de
înlănţuire" - programe care permiteau executarea secvenţială a unui set de lucrări, pregătite
anticipat, trecerea de la o lucrare la alta fiind automatizată.

13. Multiprogramarea şi partajarea timpului

Utilizarea principiului multiprogramării sau partajarea memoriei între mai mulţi utilizatori a
permis o utilizare şi mai bună a procesorului central. Exploatarea unui calculator conform
principiului timpului partajat oferă utilizatorilor posibilităţi analogice unui calculator
individual, permiţând beneficiul unor servicii comune la un preţ redus.

14. Organizarea intrărilor - ieşirilor în memorii tampon

Pentru excluderea influenţei perifericelor asupra vitezei de lucru a sistemului de calcul s-a
propus să se păstreze în memorie în anumite zone tampon datele de intrare şi rezultatele mai
multor lucrări.Deşi utilizarea memoriilor tampon prezintă o serie de avantaje, totuşi două
momente negative pot fi menţionate:
 atunci când lucrarea în curs de execuţie are nevoie de nişte date unitatea centrală rămâne
inactivă pe toată perioada citirii acestora;
 o lucrare de scurtă durată, sosită în timpul execuţiei unei lucrări "lungi", trebuie să aştepte
terminarea acesteia din urmă.

15. Multiprogramarea
Multiprogramarea este un termen utilizat în cazul unui sistem în care pot exista simultan câteva
procese în stare de execuţie. Un proces se consideră în stare de execuţie, dacă calculele au
început, dar la momentul considerat nu au fost terminate sau întrerupte. Multiprogramarea
permite menţinerea unităţii centrale în stare activă pentru perioada încărcării programelor sau
operaţiilor de intrare-ieşire. Acest mod de funcţionare este adaptat tratării pe loturi pe un
calculator, care nu dispune de un mecanism de reamplasare dinamică.

16. Sisteme cu timp partajat

Destinaţia principală a unor astfel de sisteme este furnizarea serviciilor necesare unei mulţimi
de utilizatori, fiecare dintre ei beneficiind de servicii:
• echivalente serviciilor unui calculator individual;
• legate de existenţa unei comunităţi de utilizatori: partajarea informaţiilor, comunicaţii între
utilizatori.
Problemele care apar datorită conceptului de partajare a timpului sunt o combinaţie a
problemelor existente în cazul unui calculator individual cu cele din sistemele tranzacţionale şi
pot fi clasificate după cum urmează:
• definirea maşinii virtuale oferite fiecărui utilizator;
• partajarea şi alocarea resurselor fizice comune: procesoare, memorii, dispozitive de
comunicaţie;
• gestionarea informaţiilor partajate şi a comunicaţiilor.

17. Windows, Unix şi alte sisteme

Paralel cu evoluţia tehnică şi funcţională a sistemelor de operare a avut loc şi o importantă
evoluţie conceptuală, care a permis o mai bună înţelegere a funcţionării sistemelor de operare
şi a condus la elaborarea unor metode proprii de concepere.
Debutul unei cercetări ştiinţifice a sistemelor de operare poate fi considerat anul 1964, care a
succedat o etapă importantă de dezvoltare tehnică: primele sisteme cu partajare a timpului
(Thor, CTSS). Sistemul de operare UNIX, primul sistem mobil care asigură un mediu fiabil de
dezvoltare şi utilizare a softului de aplicaţie, este fundamentul practic de elaborare a sistemelor
fizico-logice deschise.

18. SО UNIX şi standardele sistemelor deschise

Sistemul de operare UNIX, primul sistem mobil care asigură un mediu fiabil de dezvoltare şi
utilizare a softului de aplicaţie.
Implementarea largă a sistemului de operare UNIX a permis trecerea de la declararea
sistemelor deschise la dezvoltarea practică a acestui concept.
Variantele SO UNIX, propuse de compania SCO şi destinate exclusiv platformelor Intel, sunt
bazate pe modulele iniţiale ale System V 3.2, fiind total compatibile cu toate standardele de
bază

19. OSF-1 şi alte variante UNIX

Open Software Foundation (OSF) a fost prima companie comercială, care a încercat elaborarea
SO UNIX în baza micronucleului Mach. A fost creat sistemul de operare OSF-1, care nu era în
sens de licenţiere „curat”, deoarece folosea o parte a modulelor iniţiale din SVR 4.0.
Nu putem să nu amintim aici şi de realizarea originală a SO UNIX pentru platformele Intel,
propusă de Torvald Linus – LINUX
Prin standard al unei interfeţe al SO subînţelegem un set de proprietăţi, mai mult sau mai puţin
formale, sintactice sau semantice ale componentelor sistemului de operare.

20. Standarde UNIX

Unul dintre primele standarde de-facto a fost cel publicat de USL pentru versiunea SO UNIX
System V Release 4 - System V Interface Definition (SVID).
Mai menţionăm standardul de-facto SPARC Complience Definition, propus de organizaţia
SPARC International,
Pentru lumea UNIX este foarte important şi standardul limbajului de programare C, adoptat
mai întâi de ANSI şi apoi de ISO. În acest standard sunt specificate, în afara limbajului C,
bibliotecile necesare într-o realizare standard. Deoarece chiar de la apariţie limbajul C şi
sistemele de programare respective erau strâns legate de UNIX, componentele bibliotecilor
standard corespundeau exact mediului standard al SO UNIX.

21. Sisteme de operare cu micronucleu

Micronucleul este partea minimă principală a unui sistem de operare, folosită pentru asigurarea
modularităţii şi transportabilităţii.
Noţiunea de micronucleu a fost introdusă de compania Next prin sistemul de operare cu
micronucleul Mach.
Următorul SO cu micronucleu a fost MS Windows NT, în care momentul principal declarat
era, în afara modularităţii, transportabilitatea. Acest sistem de operare poate fi utilizat în
sistemele mono- şi miltiprocesor, bazate pe procesoarele Intel, Mips, şi Alpha
Au aderat la tehnologia „micronucleară” şi companiile Novell/USL, Open Software
Foundation (OSF), IBM, Apple şi altele. Unul din concurenţii principali ai lui NT în domeniul
SO cu micronucleu sunt Mach 3.0, creat în Universitatea Carnegy-Mellon, şi Chorus 3.0 al
companiei Chorus Systems.
22. MODUL SECVENŢIAL DE EXECUŢIE A UNUI PROGRAM. Noţiuni
fundamentale
Un program secvenţial = o mulţime de proceduri, care se pot apela reciproc. Fiecărei proceduri
îi este asociat un segment distinct de procedură. Datele sunt reprezentate prin segmente, pot fi
proprii unei proceduri sau partajate între mai multe proceduri.
Numim activitate fenomenul care rezultă din execuţia neîntreruptă a unei proceduri unice.
!!Execuţia unui program secvenţial constă dintr-un lanţ de activităţi!!!!
Numim context al unei activităţi mulţimea informaţiilor accesibile procesorului în cursul
acestei activităţi. Contextul activităţii este compus din contextul procesorului (registrele
programabile şi interne) şi contextul memoriei (segmentul procedurii şi segmentul datelor).

23. Modul secvential de executie a unui program: Apelare si returul

Numim context al unei activităţi mulţimea informaţiilor accesibile procesorului în cursul
acestei activităţi. Contextul activităţii este compus din contextul procesorului (registrele
programabile şi interne) şi contextul memoriei (segmentul procedurii şi segmentul datelor).
Trecerea de la o activitate la alta este realizată de instrucţiuni speciale: apelarea şi returul din
procedură, care realizează comutarea contextului.
Mecanisme de execuţie secvenţială
Vom descrie un mecanism general pentru execuţia programelor secvenţiale, formate dintr-
o suită de activităţi, rezultate din execuţia unei proceduri sau corutine. Acest mecanism
realizează funcţiile următoare:
 Salvarea şi restabilirea contextului la apelare şi retur,
 Transmiterea parametrilor între procedurile apelantă şi apelată,
 Administrarea unei zone de lucru proprii fiecărei proceduri, cu permisiunea
apelurilor recursive.
Cazul procedurilor.
Structura de date utilizată în acest caz este o stivă de execuţie. Sunt utilizate diverse
variante, care diferă în mod esenţial prin specificarea detaliată a contextului şi prin modul de
comutare a acestuia la apelare sau retur. Schema execuţiei poate fi programată direct (de
exemplu, în limbajul de asamblare) sau determinată de structura mecanismului de execuţie,
definit de un limbaj de programare. În ultimul caz prin context înţelegem mulţimea variabilelor
accesibile conform regulilor de vizibilitate definite în limbaj (structura blocurilor, modulele,
etc.). Descriem o organizare foarte apropiată schemei de execuţie din limbajul de programare
C, presupunând respectarea următoarelor ipoteze:
 Parametrii unei proceduri sunt transmişi prin valori; la retur un singur rezultat este
returnat,
 Procedurile pot fi apelate recursiv (direct sau indirect)
La fiecare apelare a procedurii o structură de date numită regiune a mediului (sau simplu
mediul procedurii) este creată în vârful stivei de execuţie, care va dispare la returul respectiv.
O procedură apelată recursiv are în stivă atâtea medii câte execuţii neterminate există pentru
această procedură. La un moment concret de timp mediul din top-ul stivei corespunde
procedurii q în curs de execuţie (procedura activă), mediul imediat următor este al procedurii
p, care a apelat procedura q, etc. Stiva este administrată prin intermediul a doi pointeri (fig.2.1.):
baza pointerul care indică baza mediului procedurii active,
top pointerul care indică primul amplasament liber pentru a crea un nou mediu.

top
q
top
baz
a
p
p
baz
a Mediul
Stivă procedurii
Stivă
Înainte de apelarea
procedurii q de către După apelarea
procedura p procedurii q
Fig.2.1. Stiva de execuţie

Mediul conţine următoarele informaţii:

a) informaţii de salvare şi legăturile de retur
 un pointer la baza contextului procedurii apelante
 adresa returului
 un amplasament pentru rezultat
b) parametri
 n+1 amplasamente, primul conţinând numărul de parametri, iar următoarele - valorile
acestora
 variabilele locale şi spaţiul de lucru al procedurii.
Aceste informaţii, cu excepţia spaţiului de lucru, sunt păstrate în amplasamente pentru care
deplasarea în raport cu originea mediului este cunoscută şi fixă, fiind posibilă adresarea relativă
a lor (faţă de baza mediului). Spaţiul de lucru este adresat din vârful stivei.
Operaţiile executate la apelarea şi returul procedurii sunt următoarele:
Apelare
1) alocarea unei zone în stiva de execuţie pentru mediul procedurii apelate (dimensiunea
acestei zone, cu excepţia spaţiului de lucru, este cunoscută anticipat)
temp:=baza
baza:=top
top:=top+dimensiunea mediului
 2) salvarea informaţiilor de retur
baza_veche:=temp
memorizarea adresei de retur
3) ordonarea parametrilor
4) executarea unei ramificaţii la procedura apelată.
Retur
1) salvarea rezultatului într-un amplasament stabilit
2) restabilirea informaţiilor de retur şi eliberarea mediului
temp:=adresa de retur
top:=baza
baza:=baza_veche
3) returul
ramificare *temp ramificare indirectă
O eventuală salvare şi restabilire a registrelor sunt lăsate în seama procedurii apelante.

24. Activităţi asincrone si protectia reciproca intre activitati

Pentru cazuri mai generale sunt necesare mecanisme suplimentare, cum ar fi conceptele de
asincronism sau de protecţie reciprocă între activităţi.
Prin asincronism înţelegem efectul care îl pot avea asupra derulării unei activităţi anumite
evenimente exterioare.
Numim protecţie reciprocă între activităţi o modificare mai profundă a contextului, atunci când
se trece de la o activitate la alta, în comparaţie cu ceea ce are loc în cazul unei simple apelări
de procedură.
Un caz tipic de asincronism este executarea intrărilor-ieşirilor simultan cu execuţia unui
program. Trebuie să fie asigurată posibilitatea informării programului despre terminarea unui
transfer de informaţii.

25. Mecanisme de comutare a contextului.

Comutarea contextului unui procesor permite executarea într-o manieră indivizibilă (atomară)
a următoarelor două operaţii:
trecerea cuvântului de stare într-un amplasament specificat al memoriei,
încărcarea în cuvântul de stare a conţinutului unui alt amplasament specificat al memoriei.
Comutarea contextului poate fi necesară din mai multe cauze distincte. Presupunem că fiecărei
cauze i-a fost asociat un număr de ordine. Pot fi întâlnite două scheme de comutare a
contextului.
1. Salvare în amplasamente fixe.
2. Salvare într-o stivă.

26. Întreruperi
Întreruperea este un mecanism care impune procesorul să observe anumite evenimente. Pot
exista mecanisme care permit să nu se acorde atenţie unei anume întreruperi – întrerupere
mascată. Resursele hardware de întrerupere permit sistemului de operare să coordoneze
operaţiile simultane; pot fi utilizate şi pentru a schimba ordinea de execuţie a programelor.

27. Devieri şi apelarea supervizorului

O deviere semnalizează o anomalie în derularea unei instrucţiuni, care prohibitează executarea
instrucţiunii. Originile pot fi diverse:
date incorecte, instrucţiune neexecutabilă . Devierile pot fi clasificate, ca şi întreruperile,
conform cauzelor care le generează. O deviere poate fi suprimată, dar nici intr-un caz retardată.
Un apel al supervizorului (supervisor call, prescurtat SVC, eng., appel au superviseur, fr.) este
o instrucţiune chemată să provoace o comutare a contextului procesorului. Acest efect este
analogic apelării unei proceduri, însă modificarea contextului este mai profundă,
Destinaţia unui apel al supervizorului este de a permite apelarea unei proceduri a sistemului de
operare, pretinzând la drepturi mai mari

28. Exemple de sisteme de întreruperi

Sistemul de întreruperi are 5 nivele (în ordinea de descreştere a priorităţilor): eroare hardware,
deviere, apelare supervizor, extern şi intrare-ieşire. Fiecărui nivel îi corespunde în memoria
operativă un cuplu de amplasamente rezervate cuvintelor de stare vechi şi nou. Fiecare nivel
conţine mai multe cauze de întrerupere.

29. Utilizarea devierilor şi apelării supervizorului

Simularea instrucţiunilor lipsă. Unele instrucţiuni din setul de bază de instrucţiuni ale
procesorului pot fi opţionale şi, deci, pot lipsi în unele configuraţii ale calculatorului.
Tentativa executării unei instrucţiuni opţionale lipsă generează o drivere de tipul instrucţiune
inexistentă. Mecanismul devierilor poate fi utilizat pentru a realiza prin program instrucţiunea
inexistentă în setul de bază. De exemplu, pentru o configuraţie în care operaţiile aritmetice în
virgulă mobilă nu sunt disponibile ele pot fi simulate prin apelarea procedurilor
corespunzătoare. Aceste proceduri trebuie executate în mod slave pentru a permite tratarea
explicită a erorilor: ele sunt apelate prin încărcarea cuvântului de stare respectiv. O adresă de
retur trebuie să fie pregătită de către programul de tratare a devierii în top-ul stivei pentru a
asigura returul la instrucţiunea care urmează instrucţiunii de operaţie aritmetică simulată.

30. Exemple de utilizare a întreruperilor

Principala utilizare a întreruperilor este măsurarea timpului şi administrarea operaţiilor de
intrare-ieşire. Prezentăm mai jos câteva exemple de utilizare a ceasului calculatorului.
procedura iniţializare;
 intr_ceas_nou:=<activ,master,mascat,adr intr_ceas>;
svc_nou :=<activ,master,mascat,adr tratare_svc >;
dezarmare(intr_ceas);
procedura tratare_svc;
save(zonă);
case cod of
…
apel_lim_timp_ex: -- parametrii p, q, tratare_eroare
ceas:=q;
cspretur:=svc_vechi; -- salvare pentru retur
csplucrare:= <activ,slave,demascat,adr p>;
csperoare:= <activ,slave,demascat,adr tratare_eroare>;
armare(intr_ceas);
restabileşte(zonă);
încarcă_csp(csplucrare);
…
retur: -- datorat terminării procedurii p
dezarmare(intr_ceas);
încarcă_csp(cspretur);
…
endcase
procedura intr_ceas; -- expirarea timpului limită
dezarmare(intr_ceas);
încarcă_csp(csperoare);

31. PROGRAMAREA OPERAŢIILOR DE INTRARE-IEŞIRE

Prin noţiunea de intrare-ieşire
numim orice transfer de informaţii din sau spre nucleul calculatorului. Operaţiile de I/E
semnifică:
transferurile de informaţii dintre diferite nivele ierarhice ale memoriei,
transferurile de informaţii din sau spre mediul exterior (organe periferice locale sau la distanţă,
captoare sau dispozitive de acţionare, alte calculatoare, etc.).
Organizarea generală
Un organ de intrare-ieşire este un dispozitiv capabil să transfere informaţii între procesorul sau
memoria calculatorului şi un suport extern de informaţie. Acest transfer este comandat de către
procesorul central.
Un canal
este un procesor specializat în operaţiile de intrare-ieşire. El poate fi lansat doar de un procesor
central, nu posedă întreruperi, dar poate întrerupe un procesor central.
Un contróler este un dispozitiv de comandă adaptat la un tip concret de echipament periferic.
Autonomia sa este limitată de operaţii foarte elementare. Destinaţia principală a unui controler
este de a permite conectarea a mai multor periferice de acelaşi tip la un singur controler.
Un periferic este un organ capabil să transfere informaţii din sau spre un suport extern.
Controlerul este legat de periferic printr-o interfaţă, care conţine un set de funcţii
şi o linie de comunicaţie, care serveşte la transferul informaţiilor.

32. Metode de comandă a perifericelor

Programul, care controlează funcţionarea elementară a unui dispozitiv periferic se numeşte
driver. Driverul gestionează în mod direct interfaţa controlerului perifericului, tratează
întreruperile generate de acesta, detectează şi tratează cazurile de eroare. Modurile principale
de control ale perifericelor
Intrări-ieşiri programate pe canal sau acces direct la memorie
Intrări-ieşiri asincrone cu întreruperi
Intrări-ieşiri sincrone

33. Intrări-ieşiri buferizate în memorie

Diferenţa considerabilă dintre viteza de lucru a unităţii centrale şi cea a organelor periferice
impune "buferizarea" intrărilor-ieşirilor, adică introducerea unei zone-tampon de memorie între
periferic şi programul utilizatorului. Scopul este de a reduce timpul de inactivitate a unităţii
centrale, dezlegând funcţionarea acesteia de periferice.
Programul utilizatorului va transfera informaţiile din sau spre zona-tampon, iar această zonă-
tampon va servi, în mod paralel, drept sursă sau destinaţie la schimbul de date cu perifericul.
Dezlegarea unităţii centrale de periferic este cu atât mai bine realizată cu cât este mai mare
capacitatea zonei-tampon. Adesea, pentru a nu supraîncărca memoria principală, zona-tampon
este situată pe discul fix.

34. Încărcarea iniţială

La primele calculatoare, un program de câteva instrucţiuni, introdus manual în memorie cu
ajutorul unor comutatoare ale pupitrului de comandă la o adresă fixă, permitea încărcarea
unui program de citire mai elevat capabil să citească versiunea completă a sistemului de
operare. Acest proces era numit încărcare (bootstrapping, eng.).
În calculatoarele contemporane, programul de iniţializare se află permanent într-o memorie
constantă (BIOS). Execuţia acestui program este declanşată odată cu punerea sub tensiune a
calculatorului (autoîncărcare).

35. Administrarea tamponată a intrărilor-ieşirelor

Analiza acestui mod de funcţionare (fig.3.1) pune în evidenţă patru activităţi, care pot avea loc
simultan:
primitiva scriere_linie SL (unitatea centrală)
scriere pe disc SD (canal 1)
citire de pe disc CD (canal 2)
imprimare fizică IF (canal 3)
Pot fi evidenţiate două tipuri de condiţii, care trebuie respectate:
Condiţii, care stabilesc posibilitatea existenţei unor activităţi
Condiţii de validitate a informaţiilor partajate.

36. Comanda unui proces industrial

D2 segmentele procedurilor şi datelor pentru comanda
celor două reactoare R1 şi R2, memoria principală având capacitatea necesară pentru păstrarea
acestor segmente.
Programele P1 şi P2 sunt executate pe rând de procesor. Relaţia 2t<T trebuie să fie respectată.
Dacă acesta va fi cazul, funcţionarea reactoarelor pentru un observator extern pare identică
pentru ambele soluţii. Trebuie, totuşi să subliniem, că soluţia doi impune restricţii mai severe
în ceea ce priveşte performanţele calculatorului
Modalităţile de implementare a soluţiei doi.
1) Partajarea procesorului
2) Partajarea programului

37. NOŢIUNE DE PROCES SECVENŢIAL

Executarea unui program se traduce într-o suită de acţiuni a1, a2,..., ai,..., cu
început(ai)<sfârşit(ai) **
O astfel de suită este numită proces secvenţial sau simplu proces.
Un proces poate, deci, fi descris cu ajutorul succesiunii evenimentelor început(a 1), sfârşit(a1),
început(a2), sfârşit(a2),...
Proces unic. Context
Noţiunea de proces pune la dispoziţie un model pentru reprezentarea unei activităţi, care rezultă
din executarea unui program pe calculator.
, contextul unui proces rezultant din executarea unui program conţine:
Contextul procesorului (cuvântul de stare şi registrele),
Un context în memorie, sau spaţiul de lucru (segmente procedură, date, stivă de execuţie),
O mulţime de atribute ataşate procesului şi care specifică diferite proprietăţi:
Nume. Numele unui proces, care serveşte pentru identificarea lui. Prioritate. Prioritatea
proceselor permite ordonarea lor pentru alocarea procesorului. Dacă toate procesele au aceeaşi
prioritate, alocarea se face conform ordinii “primul sosit, primul servit”.
Drepturi. Drepturile unui proces specifică operaţiile care îi sunt permise, în scopul asigurării
protecţiei informaţiei .

38. Relaţii între procese

Vom cerceta în continuare execuţia unei mulţimi de procese şi interacţiunea reciprocă a
acestora. Noţiunile, introduse mai sus, pot fi extinse pentru o mulţime de procese:
traiectoria temporală a unei mulţimi de procese este şirul evenimentelor formate de începuturile
şi sfârşiturile acţiunilor rezultante din executarea programelor acestor procese.
contextele unor procese diferite pot avea părţi comune. Două procese, contextele cărora sunt
disjuncte, se numesc independente; ele nu pot avea interacţiuni reciproce. Partea contextului,
care aparţine unui singur proces, se numeşte context privat al procesului dat.
Mulţimi de procese. Paralelism
Să considerăm două programe distincte P şi Q, fiecare având în memorie un segment cod şi un
segment de date. Numim p şi q procesele rezultante din executarea respectivă a acestor două
programe. Executarea setului (p, q) poate să se producă în diferite
moduri, caracterizate de forma particulară a traiectoriei sale temporale.
(1) p q

(2) p q p q p
q
(3) p q
Fig. 3.2. Executarea unei

schema 3 are loc un paralelism real, iar în schema 2 – un pseudo-paralelism. Paralelismul real
necesită două procesoare distincte. Două observaţii importante sunt necesare:
Diferenţa acestor scheme de execuţie este legată de alegerea nivelului de observare. Astfel, la
nivelul de bază, diferenţa dintre schemele 1 şi 2 dispare: ambele sunt secvenţiale.

39. Concurenţa proceselor. Resurse virtuale

Funcţionarea corectă a unei mulţimi de procese, care participă la îndeplinirea unei lucrări
comune, implică relaţii logice de cooperare. Este comod să se separe această cooperare de
concurenţa pentru resursele fizice cu scopul de a simplifica înţelegerea şi aplicarea celor două
tipuri de relaţii. Pentru aceasta este folosită noţiunea de resurse virtuale:
fiecărei resurse fizice critice i se asociază tot atâtea copii imaginare (sau virtuale) ale
acestei resurse câte procese concurente solicită utilizarea ei.

40. Excludere mutuală

Excluderea mutuală constă în extinderea pentru secvenţa de acţiuni a proprietăţii de
indivizibilitate a acţiunilor nivelului de bază (acţiuni atomare). Posibilitatea executării unor
acţiuni atomare se află la baza mecanismelor care realizează sincronizarea.

41.Sincronizarea proceselor
Exprimarea şi implementarea restricţiilor de succesiune
Introducem două exemple, care ne vor ajuta la formularea restricţiilor logice impuse de
cooperare.
 Exemplul 3.4. Procesul p transmite informaţii procesului q scriind într-un segment a,
consultat de q (se presupune că această transmitere are loc o singură dată). Este necesar să se
verifice condiţia:
sfârşit(scriere(a)) < început(citire(a))
Această relaţie exprimă restricţia, că citirea lui a de către q nu poate începe înainte de
terminarea scrierii lui a de către p. ◄
Exemplul 3.5. Rendez-vous. Fie N procese p1,..., pN. Definim în programul fiecărui
proces un punct, numit rendez-vous, pe care procesul nu-l poate trece înainte ca alte procese
să ajungă la punctul lor propriu de rendez-vous. Dacă programul procesului pi are forma
<debut_i>;
<rendez-vous>
<continuare_i>;
atunci restricţiile de sincronizare se vor exprima după cum urmează:

Restricţiile de sincronizare pot fi exprimate prin următoarele două forme echivalente:

1. Se va impune o ordine de succesiune în timp logic pentru unele puncte ale
traiectoriei temporale ale procesului,
2. Se va impune unor procese o condiţie de autorizare a depăşirii acestor puncte ale
traiectoriei lor temporale.
Punctele privilegiate astfel se vor numi puncte de sincronizare.
Expresia (2) arată, că restricţiile de sincronizare pot fi satisfăcute impunând un proces
“să aştepte” să execute o acţiune până când o oarecare condiţie va fi satisfăcută. Această
noţiune de aşteptare nu poate fi exprimată cu ajutorul instrumentelor introduse până acum.
Pentru aceasta vom introduce o nouă stare pentru un proces, stare în care procesul se zice în
aşteptare sau blocat, prin opoziţie stării activ, considerate până acum în mod implicit. Un
proces, care intră în starea de aşteptare, plecând de la un punct observabil t, opreşte
progresarea începând cu acest punct şi stopează executarea acţiunilor. În momentul în care
procesul revine în starea activ, el reia execuţia sa şi contextul său privat restabileşte starea pe
care procesul o avea în punctul t (partea neprivată a contextului poate fi modificată de
execuţia altor procese).

are pentru specificarea sincronizării proceselor.

Această specificare se va produce în două etape:
1) definirea punctelor de sincronizare pentru fiecare proces,
 2) asocierea unei condiţii de depăşire fiecărui punct de sincronizare, condiţie exprimată
prin intermediul variabilelor de stare a sistemului.
Vom ilustra acest mod de specificare pentru cele două exemple precedente. Notăm un punct de
sincronizare prin ps, iar condiţia de depăşire asociată prin aut(ps).

42. Exprimarea şi implementarea restricţiilor de precedare

sfârşit(scriere(a)) < început(citire(a))
Această relaţie exprimă restricţia, că citirea lui a de către q nu poate începe înainte de
terminarea scrierii lui a de către p. Dacă programul procesului pi are forma
<debut_i>;
<rendez-vous>
<continuare_i>;
atunci restricţiile de sincronizare se vor exprima după cum urmează:
" pentru orice i, j din [1..N]: sfârşit(debut_i) < început(continuare_j) ◄
Restricţiile de sincronizare pot fi exprimate prin următoarele două forme echivalente:
1. Se va impune o ordine de succesiune în timp logic pentru unele puncte ale traiectoriei
temporale ale procesului,
2. Se va impune unor procese o condiţie de autorizare a depăşirii acestor puncte ale
traiectoriei lor temporale.

43. Probleme de realizare a sincronizării

Un eveniment memorizat este o variabilă, care poate lua două valori: sosit şi non_sosit,
valoarea iniţială este non-sosit. Asupra evenimentului memorizat sunt posibile două operaţii,
care sunt acţiuni indivizibile:
e:=<valoare> -- atribuirea imediată a unei valori
aşteptare(e).
Operaţia aşteptare(e), executată de un proces p, are următoarea specificaţie:
if e = non_sosit then
starea(p) := blocat -- p este trecut în “aşteptarea lui e”
endif
Când e ia valoarea sosit, toate procesele care aşteptau e trec în starea activ.

44. Monitorul – mecanism de sincronizare

Un monitor este constituit dintr-o mulţime de variabile de stare şi o mulţime de proceduri, care
utilizează aceste variabile. Unele dintre aceste proceduri, numite externe, sunt accesibile
utilizatorilor monitorului; numele acestor proceduri sunt numite puncte de intrare ale
monitorului. Procesele, care utilizează monitorul pentru a se sincroniza, nu au acces direct la
variabilele de stare. Monitorul poate fi utilizat doar prin apelarea procedurilor sale externe;
acestea permit blocarea sau deblocarea proceselor conform specificaţiilor problemei.
. Un monitor conţine un fragment de cod de iniţializare, executat o singură dată la crearea
monitorului.
Exemple de utilizare a monitorului
Monitorul este utilizat după cum urmează:
procesul p procesul q
scriere(a); <debut_q>
sinc.terminare_scriere; sinc.debut_citire;
<continuare_p> citire(a);

45. IMPLEMENTAREA SINCRONIZĂRII

Experienţa demonstrează, că problemele de sincronizare logică întâlnite în practică pot fi
reduse, în marea lor majoritate, la combinaţia unui număr mic de situaţii elementare, schemele
de soluţionare ale cărora sunt cunoscute.
Probleme-tip
Problemele-tip sunt următoarele:
accesarea de către o mulţime de procese a unei resurse partajate comune,
comunicarea între procese,
gestionarea perifericelor şi intrărilor-ieşirilor tamponate,
sincronizare temporală.

46. Administrarea unei resurse partajate

Considerăm o resursă (fizică sau logică) partajată de o mulţime de procese. Utilizarea acestei
resurse trebuie să respecte nişte reguli de utilizare, destinaţia cărora constă în garantarea unor
proprietăţi specificate sau restricţii de integritate. Aceste restricţii sunt specificate pentru
fiecare resursă.
O modalitate de garantare a respectării regulilor de utilizare a unei resurse constă în adoptarea
următoarei scheme:
modul de folosire a resursei presupune utilizarea obligatorie a procedurilor de acces asociate
resursei; orice tentativă de utilizare, care nu respectă acest mod este detectată automat,
procedurile de accesare sunt grupate într-un monitor, sau mai multe, programul căruia impune
respectarea restricţiilor de integritate.

47. Alocarea resurselor banalizate

Considerăm o resursă pentru care există un număr fix de N exemplare. Un proces poate
accesa la cerere n unităţi din cele N, le poate utiliza şi apoi elibera. Toate unităţile sunt
echivalente din punctul de vedere al proceselor utilizatoare, se mai zice că resursa este
banalizată.
Utilizarea resursei are loc conform schemei de mai jos.
ps:resurse.cerere(n); -- cerere pentru n unităţi
-- aşteptare în caz de eşec
<utilizarea unităţilor primite>
 resurse.eliberare(n) -- eliberarea resurselor
Condiţia de sincronizare se va scrie pentru orice proces:
aut(ps) : n  nlibere

48. Modelul cititorului şi redactorului

Să considerăm un fişier manipulat de procese din două clase diferite: cititori, care consultă
fişierul fără a modifica conţinutul lui şi scriitori, care pot modifica acest conţinut. Fie pentru
un moment arbitrar de timp ncit şi nscr numărul de cititori şi de scriitori, respectiv, care
folosesc o procedură de acces la fişier. Cererea de asigurare a coerenţei fişierului ne impune
să respectăm următoarele restricţii:
(nscr=0) şi (ncit0) -- fişier în citire
sau (nscr =1) şi (ncit=0) -- fişier în scriere

49. Comunicarea între procese

Procesele pot comunica prin accesarea unei mulţimi de variabile comune. Acest mod de
comunicare este slab structurat şi ineficient - cere excluderea reciprocă a variabilelor.
Comunicarea prin mesaje - modelul producătorului şi consumatorului, realizată cu ajutorul
monitoarelor . O altă posibilitate, constă în a considera operaţiile de comunicare ca un fel de
mecanisme primitive de sincronizare.

50. Modelul producătorului şi consumatorului

Un proces (producătorul) trimite mesaje unui alt proces (consumatorul), utilizând o zonă
tampon în memoria comună. Mesajele sunt de lungime fixă şi capacitatea tamponului este de
N mesaje.
Specificaţiile comunicaţiei:
un mesaj dat poate fi preluat doar o singură dată după ce a fost depozitat în tampon,
un mesaj nu poate fi pierdut; dacă tamponul conţine N mesaje nepreluate, nu pot fi
depozitate alte mesaje,
o operaţie “imposibilă” blochează procesul, care încearcă să o execute.

51. Primitive de comunicare

Operaţiile de schimb de mesaje pot fi definite ca nişte mecanisme primitive şi să le utilizăm
pentru sincronizarea proceselor.
Primitivele de bază în comunicarea prin mesaje sunt:
emitere(mesaj,destinaţie)
recepţie(mesaj,origine)
Specificările acestor primitive trebuie să precizeze:
natura şi forma mesajelor,
modul de adresare a proceselor emiţătoare şi destinatare,
modul de sincronizare a acestor procese,
tratarea erorilor.
52. Aplicaţii : relaţia client-server
O aplicaţie curentă a comunicărilor între procese este relaţia client-server. Un proces server are
în şarjă îndeplinirea unor servicii (executarea unor programe predefinite) proceselor client.
Pentru aceasta este utilizată următoarea schemă:
Procesul server este asociat unei porţi, unde clienţii îşi depun cererile; el este blocat atâta timp
cât nu există cereri de servicii în aşteptare.
modelul client-server sunt reprezentative pentru două scheme de obţinere a unui serviciu cu
ajutorul proceselor într-un sistem de operare: apelarea unei procedure de monitor sau activarea
unui proces server ciclic prin emiterea mesajelor. Alegerea între aceste două scheme este
dictată de considerente de eficacitate.

53. Administrarea intrărilor-ieşirilor

Pentru un proces care execută o intrare-ieşire apelând o procedură de schimb a acestui monitor,
totul se petrece ca şi cum schimbul este sincron: la returul din procedură, informaţia a fost
efectiv transferată (sau o eroare a fost detectată şi semnalizată). Mecanismul de blocare evită
aşteptarea activă şi procesorul poate fi utilizat în timpul transferului de un alt proces.

54. Administrarea unui periferic

Fiecărui periferic îi este asociat un monitor procedurile externe ale căruia permit
executarea intrărilor-ieşirilor la acest periferic. Acest monitor are următoarea formă generală
(pentru un sistem mono-utilizator):
perif: monitor;
var ..., sfr_schimb_i,...: condiţie;
<declaraţiile variabilelor de stare ale perifericului>
...

55. Buferizarea imprimării

Trei zone-tampon tm1 şi tm2 de capacitate N1 şi N2 în memoria centrală şi unul pe disc, td,
de lungime Ndisc. Pentru simplitate presupunem, că transferurile se fac cu blocuri constante
egale cu o linie. Fiecare bufer este comandat de un monitor cu aceeaşi structură care are rolul
de a asigura excluderea mutuală şi sincronizarea condiţiilor tampon plin şi tampon vid.
Definind tm1, tm2 şi td ca tablouri de elemente de lungimea unei linii şi pointerii top şi coadă
locali fiecărui monitor, procedurile de depozitare şi preluare pot fi:
<pentru tm 1> <pentru tm 2>
procedura intrare(l:linie); procedura intrare(l:linie);
tm1[coadă] := l; tm2[coadă] := l;
coadă := coadă+1 mod N1 coadă := coadă+1 mod N2
procedura ieşire(var l:linie); procedura ieşire(var l:linie);
l := tm1[top]; l := tm2[top];
top := top+1 mod N1 top := top+1 mod N2

56. Sincronizare temporală

Sincronizarea temporală face ca timpul să intervină nu numai ca mijloc de ordonare a
evenimentelor, dar şi ca măsură de durată absolută. Acest mod de sincronizare este utilizat în
aplicaţiile de timp real, care conţin interacţiuni cu organe externe (comanda proceselor
industriale, de exemplu).
Sincronizarea temporală solicită folosirea unui ceas, realizat prin intermediul generatorului de
sincronizare, care emite impulsuri la intervale regulate. Aceste impulsuri pot fi utilizate
pentru a declanşa o întrerupere
la fiecare impuls sau
pentru a decrementa în mod automat conţinutul unui registru contor, o întrerupere este
declanşată atunci când conţinutul acestui registru atinge valoarea 0.

57. GESTIONAREA DINAMICĂ A PROCESELOR

În sistemele performante, mai ales în cele interactive, procesele sunt comandate dinamic.
Crearea unui proces presupune alocarea resurselor şi iniţializarea contextului. Distrugerea
unui proces eliberează toate resursele care i-au fost alocate. Primele primitive, propuse pentru
gestionarea dinamică a proceselor, au fost fork şi join. Istoric şi cronologic, aceste operaţii au
fost introduse pentru organizarea executării paralele a programelor pe un sistem
multiprocesoral, noţiunea de proces nefiind încă clară.
58. SINCRONIZAREA ÎN WINDOWS
Platforma pe 32 de biţi pune la dispoziţia programatorului instrumente evoluate pentru
multiprogramare, atât la nivelul unei mulţimi de lucrări, cât şi a unei lucrări singulare. Poate
să apară întrebarea CÂND să fie utilizată multiprogramarea în cadrul unei singure aplicaţii.
Răspunsul este foarte simplu: atunci când dorim ca mai multe fragmente de cod să fie
executate simultan. De exemplu, dacă dorim ca unele activităţi să fie îndeplinite în regim de
fond sau programul să continue să reacţioneze la unele evenimente exterioare în timpul
îndeplinirii unor calcule foarte „costisitoare”
Procese şi fire in Windows
Numim proces în Windows o instanţă (un exemplar) a programului, încărcat în memoria
operativă. Această instanţă poate crea fire (thread) - secvenţe de instrucţiuni, care urmează a
fi executate
În cadrul sistemului de operare Windows există două tipuri de fire – fire interactive, care
execută un ciclu propriu de prelucrare a mesajelor (de exemplu, firul principal al unei
aplicaţii) şi fire de lucru, care sunt funcţii simple. În ultimul caz execuţia firului se încheie
atunci când calculele, generate de funcţia respectivă, iau sfârşit.

59. Necesitatea sincronizării în Windows

În realitate, din cauza multitaskingului controlat se poate întâmpla ca un fir să nu fi terminat
încă lucrul cu o resursă comună oarecare, iar sistemul să treacă la un alt fir, care utilizează
aceeaşi resursă. Rezultatele pot fi imprevizibile. Asemenea conflicte se pot produce şi în
cazul unor fire, care aparţin chiar unor procese diferite. Problema poate să apară întotdeauna
când două sau mai multe fire folosesc o resursă comună. Este necesar un mecanism de
coordonare a lucrului firelor cu resurse comune. În Windows acest mecanism se numeşte
sincronizarea firelor .

60. Structura mecanismului de sincronizare în Windows

Mecanismul de sincronizare este un set de obiecte ale sistemului de operare Windows, create
şi gestionate program, comune pentru toate firele sistemului
şi utilizate pentru coordonarea accesului la resurse. În calitate de resurse pot fi toate obiectele,
care pot fi accesate de două şi mai multe fire – un fişier pe disc, un port, un articol al unei
baze de date, o variabilă globală a unui program
Sensul mecanismelor de sincronizare constă în faptul, că fiecare poate să fie în starea set.
Pentru fiecare mecanism de sincronizare această stare poate să aibă sens propriu. Firele pot să
testeze starea curentă a mecanismului de sincronizare şi/sau să aştepte modificarea acestei
stări, coordonându-şi în acest fel acţiunile proprii
Mecanismele de sincronizare nu pot interzice accesul nedorit la o resursă, ele doar indică
firului momentul când acesta poate accesa resursa, sau când acesta trebuie să aştepte .

61. Administrarea obiectelor de sincronizare în Windows

Crearea unui obiect de sincronizare se produce prin apelarea unei funcţii speciale din WinAPI
de tipul Create… (de exemplu, CreateMutex). Acest apel returnează descriptorul obiectului
(handle), care poate fi folosit de toate firele procesului dat. Un obiect de sincronizare poate fi
accesat şi dintr-un alt proces, dacă acest proces a moştenit descriptorul obiectului dat, sau
folosind funcţia de deschidere a unui obiect (Open…).
Dacă în parametrul timp este indicată constanta simbolică INFINITE, funcţia va aştepta până
când starea obiectului va deveni set, fără vre-o restricţie
Starea mai multor obiecte poate fi aflată cu ajutorul funcţiei WaitForMultipleObjects. Pentru
încheierea lucrului cu un obiect de sincronizare şi eliberarea descriptorului se apelează
funcţia CloseHandle. Este important de ştiut, că apelarea unei funcţii de aşteptarea blochează
firul curent, adică atâta timp cât un fir se află în starea de aşteptare el nu are acces la procesor.

62. Excluderea mutuală

Mecanismele de excludere mutuală (mutex-ele, de la MUTual EXclusion) permit
coordonarea accesului la o resursă partajată. Starea set a obiectului corespunde momentului
de timp în care obiectul nu aparţine nici unui fir şi poate fi „utilizat”, iar starea reset –
momentului când un fir oarecare controlează deja mutex-ul. Accesarea va fi permisă doar
după eliberare.
Pentru a lega mutex-ul de firul curent trebuie apelată una din funcţiile de aşteptare. Firul,
căruia îi aparţine mutex-ul, îl poate „ocupa” de mai multe ori, fără autoblocare, însă mai apoi
acesta va trebui eliberat tot de atâtea ori cu ajutorul funcţiei ReleaseMutex.

63. Evenimentele
Obiectele-evenimente sunt utilizate pentru a informa firele, care sunt în aşteptare, despre
producerea unui eveniment. În Windows există două tipuri de evenimente – cu resetare
manuală şi automată. Resetarea manuală se execută cu funcţia ResetEvent. Aceste
evenimente sunt folosite pentru informarea mai multor fire, iar evenimentele cu resetare
automată sunt utilizate pentru informarea unui anumit fir, celelalte rămânând în aşteptare.
Funcţia CreateEvent crează un obiect-eveniment, funcţia SetEvent setează evenimentul în
starea set, iar funcţia ResetEvent resetează evenimentul. Funcţia PulseEvent setează
evenimentul, iar după semnalizarea firelor, care erau în aşteptare
resetează obiectul

64. Semafoarele
Un obiect-semafor este în ultimă instanţă un mutex cu contor. Acest obiect permite să fie
„ocupat” de un număr anume de fire, după care „ocuparea” va fi posibilă numai dacă unul din
fire va „elibera” semaforul. Semafoarele sunt utilizate pentru a limita numărul de fire, care
lucrează simultan cu resursa.

65. Secţiunile critice

Obiectul-secţiune critică permite programatorului să evidenţieze un fragment de cod în care
firul obţine acces la o resursă partajată, preîntâmpinând utilizarea resursei de mai mulţi
utilizatori. Pentru a utiliza resursa firul va intra mai întâi în secţiunea critică (apelarea funcţiei
EnterCriticalSection).
Diferenţa de mutex constă în faptul că secţiunea critică este utilizată numai pentru firele unui
singur proces.
Cu ajutorul funcţiei TryEnterCriticalSection se poate stabili, dacă secţiunea critică este liberă.

66. Protejarea accesării variabilelor

Există o serie de funcţii, care permit lucrul cu variabilele globale ale tuturor firelor, fără a ne
preocupa de sincronizare, deoarece aceste funcţii singure rezolvă problema sincronizării.
Aceste funcţii sunt InterlockedIncrement, InterlockedDecrement, InterlockedExchange,
InterlockedExchangeAdd şi InterlockedCompareExchange. De exemplu, funcţia
InterlockedIncrement incrementează valoarea unei variabile pe 32 biţi cu o unitate.

67. Sincronizarea în Microsoft Fundation Classes

Biblioteca MFC conţine clase speciale pentru sincronizarea firelor (CMutex, CEvent,
CCriticalSection şi CSemaphore). Aceste clase corespund obiectelor de sincronizare WinAPI
şi sunt derivate de la clasa CSyncObject. Pentru utilizarea acestor clase trebuie consultaţi
constructorii şi metodele lor – Lock şi Unlock.
Obiectul de sincronizare MFC este inclus în această clasă în calitate de membru privat şi toate
funcţiile clasei, care realizează accesarea resursei, îşi coordonează lucrul cu acest membru.
Utilizând funcţiile Lock şi Unlock clasele de sincronizare MFC pot fi utilizate direct, iar în
mod indirect – prin funcţiile CSingleLock şi CmultiLock.

68. Exemplu de sincronizare în Windows

#include <windows.h>
#include <iostream.h>

void main()
{
DWORD res;
HANDLE mutex = CreateMutex(NULL, FALSE, "NUME_APLICATIE-
MUTEX01");
cout<<"Încerc să ocup obiectul...\n"; cout.flush();
res = WaitForSingleObject(mutex,20000);
if (res == WAIT_OBJECT_0)
{
cout<<"L-am prins! Aşteptare 10 secunde...\n"; cout.flush();
Sleep(10000);
cout<<"Acum eliberăm obiectul\n"; cout.flush();
ReleaseMutex(mutex);
}
CloseHandle(mutex);
}

69. Utilizarea secţiunilor critice în Windows

În acest caz secţiunile critice sunt utilizate pentru a permite la un moment de timp dat accesul
la unele date importante unui singur fir al aplicaţiei, celelalte fire fiind blocate
Secţiunile critice nu sunt obiecte ale nucleului sistemului de operare. Practic, tot lucrul cu
secţiunile critice are loc in procesul care le-a creat. Din aceasta rezultă, că secţiunile critice pot
fi utilizate numai pentru sincronizare în cadrul unui proces.

70. Structura RTL_CRITICAL_SECTION

Este definită după cum urmează:
typedef struct _RTL_CRITICAL_SECTION
{
PRTL_CRITICAL_SECTION_DEBUG DebugInfo; // Folosit de sistemul de operare
 LONG LockCount; // Contorul de utilizări
LONG RecursionCount; // Contorul accesării repetate din firul utilizatorului
HANDLE OwningThread; // ID firului utilizatorului (unic)
HANDLE LockSemaphore; // Obiectul nucleului folosit pentru aşteptare
ULONG_PTR SpinCount; // Numărul de cicluri goale înaintea apelării nucleului
}
RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
Într-adevăr, secţiunile critice sunt destinate să protejeze datele la accesarea din câteva fire.
Utilizarea multiplă a uneia şi aceeaşi secţiuni critice de un singur fir nu va genera eroare, ceea
ce este normal.

71. Funcţii API pentru secţiunile critice

Mai întâi funcţiile BOOL InitializeCriticalSection(LPCRITICAL_SECTION
lpCriticalSection) şi BOOL
InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection,
DWORD dwSpinCount).
Funcţia DWORD SetCriticalSectionSpinCount(LPCRITICAL_SECTION lpCriticalSection,
DWORD dwSpinCount) setează valoarea câmpului SpinCount şi returnează valoarea
precedentă a acestuia.
VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection) eliberează
resursele, ocupate de secţiunea critică.
VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection) eliberează
secţiunea critică.

72. Clase de secţiuni critice

Clasele CLock şi CAutoLock sunt utilizate, de obicei, pentru sincronizarea accesării
variabilelor clasei, iar CScopeLock este destinat, în special, pentru a fi utilizată în proceduri.
Compilatorul singur va avea grijă să apeleze ::LeaveCriticalSection() prin intermediul
destructorului. Urmează un exemplu de folosire a CScopeLock.
class CLock
{
friend class CScopeLock;
CRITICAL_SECTION m_CS;
public:
void Init() { ::InitializeCriticalSection(&m_CS); }
void Term() { ::DeleteCriticalSection(&m_CS); }

void Lock() { ::EnterCriticalSection(&m_CS); }

BOOL TryLock() { return ::TryEnterCriticalSection(&m_CS); }

73. Depanarea secţiunilor critice

Depanarea secţiunilor critice este o ocupaţie foarte interesantă, dar şi dificilă. Poţi căuta ore şi
chiar zile în şir cauza apariţiei unei probleme. Erorile, legate de secţiunile critice sunt de două
tipuri: de realizare şi de arhitectură. Erorile de realizare pot fi depistate relativ uşor şi, de
regulă, sunt generate de utilizarea incorectă (lipsa perechii) a apelurilor
::EnterCriticalSection() şi ::LeaveCriticalSection().
Dintre erorile de arhitectură cea mai frecventă este îmbrăţişarea fatală , când două fire
încearcă să acceseze două şi mai multe secţiuni critice.
-secţiunile critice sunt executate relativ repede şi nu cer multe resurse de sistem;
-pentru sincronizarea accesării a mai multor variabile independente este mai bine să fie
utilizate câteva secţiuni critice
-nu este recomandat să fie apelate metode ale unor obiecte “străine” dintr-o secţiune critică.
-codul unei secţiuni critice va fi redus la minimum;

74. ADMINISTRAREA PROCESELOR

Acest capitol este consacrat implementării noţiunilor proces şi sincronizare în cadrul unui
sistem de operare. Mecanismele utilizate sunt bazate pe realizarea principiul excluderii
mutuale. Principiile directoare ale reprezentării şi gestiunii proceselor (contexte, alocarea
procesorului)
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 coerenţa
acestor variabile trebuie ea însăşi să fie garantată. La nivelul de bază există două mecanisme
elementare: excluderea mutuală la accesarea unui amplasament de memorie şi masca
întreruperilor. Aceste două mecanisme sunt, în principiu, suficiente pentru toate necesităţile.
Specificarea problemei
Vom preciza mai întâi problema excluderii mutuale. Fie {p1, p2,...,pn} o mulţime de procese
pe care le vom considera ciclice; programul fiecărui proces conţine o secţiune critică.
Excluderea mutuală este asigurată prin două fragmente de program (prolog şi epilog), care
încadrează secţiunea critică a fiecărui proces.Soluţia trebuie să posede următoarele
proprietăţi:
-excludere mutuală: la fiecare moment de timp cel mult un proces execută secţiunea critică,
absenţa blocajelor intempestive
dacă în secţiunea critică nu se află vreun proces, nici un proces nu trebuie să fie blocat de
mecanismul excluderii mutuale,
toleranţă la defecte: soluţia trebuie să rămână validă şi în cazul unor defecte în unul sau în
mai multe procese, care se află în afara secţiunii critice,
absenţa privaţiunilor: un proces, care a cerut intrarea într-o secţiune critică nu trebuie să
aştepte un timp infinit
simetrie: prologul şi epilogul trebuie să fie identice pentru toate procesele şi independente de
numărul lor.
75. Excluderea mutuală prin aşteptare activă
Înainte de a descrie implementarea excluderii mutuale prin operaţii elementare de blocare şi
deblocare a proceselor prezentăm un mecanism, care permite simularea efectului acestor
operaţii, menţinând procesele în stare activă. Un proces în aşteptare activă simulează blocarea
efectuând o testare repetată a condiţiei de depăşire, care poate fi actualizată de alte procese.

76. Algoritmul lui Dekker

O soluţie (algoritmul lui Dekker) poate totuşi fi construită fără a folosi alte mecanisme de
excludere mutuală, în afară de indivizibilitatea accesării în citire sau actualizarea unui
amplasament de memorie. Prezentăm algoritmul pentru două procese, deşi el poate fi extins
pentru un număr arbitrar de procese. Programul foloseşte trei variabile comune celor două
procese:
var c : array [0..1] of boolean;
tur : 0..1;
iniţializare: c[0]:=c[1]:=false;
tur:=0;
prolog :- pentru procesul i; se va pune j=1-i (celălalt proces)
c[i]:=true;
tur:=j;
test: if c[j] and tur=j then
go to test
endif;
...

77. Aşteptarea activă în sisteme multiprocesorale: Test & Set

Pentru tratarea cu ajutorul aşteptării active a cazului în care mai multe procese actualizează şi
consultă variabile comune, unele maşini au o instrucţiune, care realizează într-o manieră
indivizibilă consultarea şi actualizarea unui amplasament de memorie. Această instrucţiune,
adesea numită Test And Set (tas), este utilizată în sistemele multiprocesorale
Efectul lui Test And Set este descris mai jos (Mp[m] desemnează amplasamentul de memorie
cu adresa m):
tas R, m : <blocare acces la Mp[m]>
R:=Mp[m]
Mp[m]:=1
<eliberare acces la Mp[m]>

78. Semaforul – instrument elementar pentru excluderea mutuală. Definiţii.

Proprietăţi
Un semafor s este constituit prin asocierea unui contor cu valori întregi, notat s.c., şi a unui fir
de aşteptare, notat s.f. La crearea semaforului contorului i se atribuie o valoare iniţială s0
(s0≥0), şi firul de aşteptare s.f. este vid. Un semafor serveşte la blocarea proceselor aşteptând
să se producă o condiţie pentru deblocarea lor; procesele blocate sunt plasate în s.f.
Proprietăţile principale ale sincronizării cu ajutorul semafoarelor pot fi deduse din câteva
relaţii invariante: relaţii verificate iniţial şi care rămân neschimbate după executarea
primitivelor P şi V un număr arbitrar de ori.
s.c. = s0 – np(s) + nv(s) (1)
nbloc(s) = if s.c. ≥ 0 then 0 else –s.c. endif (2)
nf(s) = min(np(s), s.c.+nv(s)). (3)

74. Semaforul – Proprietăţi

Un obiect-semafor este în ultimă instanţă un mutex cu contor. Acest obiect permite să fie
„ocupat” de un număr anume de fire, după care „ocuparea” va fi posibilă numai dacă unul din
fire va „elibera” semaforul. Semafoarele sunt utilizate pentru a limita numărul de fire, care
lucrează simultan cu resursa.
Proprietăţile principale ale sincronizării cu ajutorul semafoarelor pot fi deduse din câteva
relaţii invariante: relaţii verificate iniţial şi care rămân neschimbate după executarea
primitivelor P şi V un număr arbitrar de ori.
1) Fie, pentru un semafor s:
np(s) – numărul total de execuţii a operaţiei P(s),
nv(s) – numărul total de execuţii a operaţiei V(s).
Are loc relaţia:
c.s. = s0 – np(s) + nv(s) (1)
deoarece valoarea iniţială a lui c.s. este s0, fiecare operaţie P(s) scade din această valoare o
unitate, iar V(s) adaugă 1.
Aceste operaţii, fiind executate în excludere mutuală, nici o modificare nu este pierdută.
2) Fie nbloc(s) numărul proceselor blocate în f.s. Are loc relaţia:
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)
Relaţia (2) iniţial este adevărată. Tabelul de mai jos, care indică efectul operaţiilor P(s) şi
V(s) asupra valorii variabilei nbloc, arată că aceste operaţii lasă relaţia (2) invariantă.
c.s.<0
c.s.=0
c.s.>0
 Efectul operaţiei P(s)
+1
+1
--
Efectul operaţiei V(s)
-1
--
--
3) Relaţia (2) poate fi scrisă sub o altă formă, care ne va fi utilă mai departe. Fie nf(s)
numărul de “treceri” de către procese a primitivei P(s), adică suma numărului de executări a
lui P(s) fără blocare şi a numărului de deblocări realizate de către V(s). Vom avea în acest
caz:
nbloc(s) = np(s) – nf(s).
Introducând această valoare în (21) obţinem:
- nf(s) = max(-np(s), -c.s.-np(s)), sau
nf(s) = min(np(s), c.s.+np(s)).

79. Realizarea excluderii mutuale cu ajutorul semafoarelor

Fie nc numărul de procese, care se află în secţiunea critică la un moment concret de timp.
Avem:
nc = nf(mutex) – nv(mutex) (4)
Proprietăţile în cauză pot fi verificate aplicând semaforului mutex relaţia (3) din 4.1.3.2:
nf(mutex) = min(np(mutex), 1+nv(mutex)) (5)
Excluderea mutuală
Din (5) avem:
nf(mutex) ≤ 1+nv(mutex)
şi, utilizând (4), obţinem nc ≤ 1: excluderea mutuală este asigurată.

80. FUNCŢIONAREA ŞI STRUCTURA UNUI NUCLEU DE SINCRONIZARE

În cadrul descrierii unui sistem de operare cu ajutorul maşinilor abstracte ierarhice (v. cap.9),
nucleul constituie nivelul cel mai inferior, realizat direct pe maşina fizică. Maşina abstractă,
realizată astfel poate fi numită o maşină a proceselor, care posedă, în afara setului de
instrucţiuni de bază, primitivele care permit crearea, distrugerea şi sincronizarea proceselor.
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 specificaţiile maşinii fizice şi
de specificaţiile maşinii abstracte care trebuie realizate, îndeosebi de mecanismul de
sincronizare ales.
Stările unui proces. Fire de aşteptare
Am considerat până acuma că un proces se poate afla în două stări: activ sau blocat. Luarea în
consideraţie a alocării fizice a unui procesor ne impune să descompunem starea activă în
două stări noi. Un proces activ se numeşte ales, dacă el este în curs de execuţie pe un
procesor fizic; el se numeşte eligibil dacă nu poate fi executat din cauza lipsei unui procesor
disponibil.
Administrarea proceselor face apel la fire de aşteptare. Astfel, fiecărei cauze distincte de
blocare i se asociază un fir de aşteptare pentru a stabili o ordine a proceselor blocate. Mai
mult, procesele eligibile sunt menţinute într-un fir special de aşteptare

81. Administrarea contextelor şi schemele primitivelor

Conţinutul contextului
Operaţia de alocare a procesorului fizic impune păstrarea pentru fiecare proces a unei copii a
contextului. Această copie a contextului descrie starea procesorului pentru procesul
considerat. În acest scop fiecărui proces i se asociază o mulţime de informaţii rezidente în
memorie şi numită vector de stare, bloc de control al procesului sau blocul contextului,
Organizarea nucleului
Execuţia programelor nucleului este declanşată în două moduri
prin apelarea unei primitive de administrare a proceselor (creare, distrugere, sincronizare,
etc.); aceste primitive sunt realizate sub formă de apel al supervizorului,printr-o întrerupere:
programele de tratare a întreruperilor fac parte din nucleu, deoarece întreruperile sunt traduse
în operaţii de sincronizare şi sunt invizibile la nivelurile superioare.
În ambele cazuri, mecanismul de intrare în nucleu conţine salvarea automată a cuvântului de
stare şi, eventual, a registrelor procesorului
Programul unei primitive a nucleului are următoarea schemă generală:
prolog; - salvarea contextului şi intrarea în secţiunea critică
control; -- verificarea drepturilor şi a parametrilor
<corpul programului>-- manipulează firele proceselor
alocare_procesor; -- programul dispecer şi ieşirea din secţiunea critică

82. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Organizarea generală

Procesele pot fi create şi distruse în mod dinamic şi sunt organizate ierarhic conform relaţiei
de paternitate. Un proces este creat cu ajutorul primitivei: creare(p, context iniţial,
atribute)
Atributele unui proces conţin prioritatea
şi drepturile de a executa anumite operaţii. Contextul iniţial specifică starea iniţială a
cuvântului de stare, a registrelor procesorului şi a spaţiului de lucru asociat procesului.
Procesul este creat în starea eligibil.

83. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Interfeţele

Procesele sunt sincronizate cu ajutorul monitoarelor. Gestiunea întreruperilor este integrată în
mecanismul monitoarelor: o întrerupere este asociată unei condiţii.
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.
Procesele pot fi create şi distruse în mod dinamic şi sunt organizate ierarhic conform relaţiei
de paternitate. Un proces este creat cu ajutorul primitivei: creare(p, context iniţial,
atribute)
Utilizarea primitivelor creare, distrugere, suspendare şi reluare este condiţionată de un drept,
care figurează în atributul drepturi al procesului.

84. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Structuri şi algoritmi

Din momentul creării sale unui proces i se asociază un număr fix (nume intern, process
handler), care serveşte la desemnarea lui şi permite accesarea blocului său de context. Blocul
de context conţine următoarele câmpuri:
Csp: zona de salvare a cuvântului de stare a programului,
Reg : zona de salvare a registrelor generale ale procesorului,
Stare : valoarea stării procesului (eligibil, blocat, ...),
Prio : prioritatea procesului,
Drepturi : drepturile procesului,
Fire : legături de înlănţuire în ierarhia proceselor,
Suc : legături de înlănţuire în firele de aşteptare (FA).

85. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Realizarea monitoarelor

Monitorul, descris mai jos, în raport cu noţiunea clasică de monitor, prezintă următoarele
diferenţe: Semantica primitivei semnalizare. Specificarea iniţială a primitivei c.semnalizare
precizează că unul din procesele care sunt în aşteptarea condiţiei c (dacă există) este imediat
deblocat, ceea ce implică trecerea temporară în starea blocat a procesului, care execută
semnalizare. Verificarea validităţii monitorului este simplificată, deoarece condiţia de
depăşire este consultată în timpul deblocării: procesul care execută semnalizare poate să se
mulţumească cu garantarea unei condiţii mai slabe decât condiţia de depăşire.

86. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Algoritmi de bază

Programul monitorului trebuie să asigure două funcţii:
excluderea mutuală pentru procedurile monitorului,
blocarea şi deblocarea asociate primitivelor aşteptare şi semnalizare.
Fiecărui monitor M îi sunt asociate următoarele structuri de date:
un dispozitiv de excludere mutuală M.disp (lacăt), care poate lua două valori liber sau
ocupat, un fir de aşteptare M.fir asociat acestui dispozitiv. Iniţial M.disp=liber,
M.fir=<vid>.
Fiecărei condiţii c de M îi este asociat un fir M.c.fir, un contor de gardă M.c.întârziere şi,
pentru condiţiile asociate unei întreruperi, un indicator boolean M.c.într_sosită.. Firul
proceselor eligibile este determinat de f_eligibil.

87. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Tratarea întreruperilor

Pentru asigurarea uniformităţii mecanismelor de sincronizare fiecărei întreruperi i se
asociază: o condiţie într-un monitor, un proces ciclic care realizează tratarea întreruperilor, în
stare de repaus acest proces este în aşteptarea condiţiei. O condiţie poate fi asociată unui
singur nivel de întrerupere. Sosirea unei întreruperi provoacă executarea funcţiei semnalizare
pentru condiţia asociată. Prioritatea relativă a întreruperilor este tradusă în prioritatea
proceselor, care tratează întreruperile.

88. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Tratarea erorilor

Principiul de tratare a erorilor constă în blocarea procesului care a provocat eroarea şi
expedierea unui mesaj procesului părinte, care va putea lua măsurile necesare. Pentru aceasta
este folosit un fir special f_eroare
Presupunem că o eroare care are loc în cursul execuţiei unui proces provoacă o deviere,
tratarea căreia se va scrie astfel:
prolog;
p:=<proces apelant>;
intrare(p, f_eroare);
<tratare specifică>;
stare[p]:=suspendat;
alocare_procesor;

89. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Crearea şi distrugerea

proceselor
Problema principală, condiţionată de gestiunea dinamică a proceselor, este alocarea
contextelor şi numelor proceselor. Pentru aceasta sunt utilizate două metode principale:
pentru blocurile contextelor sunt rezervate un număr fix de amplasamente; amplasamentele
neutilizate sunt determinate de o valoare specială (nil) a câmpului stare al lor; fiecare bloc
este desemnat printr-un număr, care este numărul 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ă
numărului fiecărui proces adresa în memorie a blocului său de context.
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 fişierele, sunt preluate de mecanisme specifice.
Distrugerea unui proces, care se află în secţiunea critică poate conduce la o blocare.
Suspendarea şi reluarea
Primitiva suspendare permite procesului-părinte să controleze activitatea unui proces
descendent, întrerupând în mod forţat execuţia acestuia. O utilizare curentă este suspendarea
unui proces, angajat într-o buclă infinită. Procesul întrerupt în acest mod este transferat într-
un fir de aşteptare special,
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. Primitiva
de reluare permite unui proces să deblocheze un fir suspendat, după modificarea eventuală a
contextului său.

90. REALIZAREA UNUI NUCLEU DE SINCRONIZARE. Excluderea mutuală şi

alocarea procesorului
Excluderea mutuală este realizată prin mascarea întreruperilor. Pentru aceasta trebuie
pregătită masca întreruperii în cuvântul de stare, care ar specifica programele asociate
primitivelor de tratare a întreruperilor. Dacă notăm prin proces_ales o variabilă globală, care
conţine numărul procesului ales, iar prin salv_csp locaţiunea în care a fost salvat cuvântul de
stare a procesorului la apelarea supervizorului sau la întrerupere, prologul va fi de forma:
prolog:
<mascarea întreruperilor> -- masca în cuvântul de stare
csp[proces_ales] := salv_csp;
salv_registre(Reg[proc_al]);

91. REALIZAREA UNUI NUCLEU DE SINCRONIZARE pentru cazul

monoprocesor
Excluderea mutuală este realizată prin mascarea întreruperilor. Pentru aceasta trebuie
pregătită masca întreruperii în cuvântul de stare, care ar specifica programele asociate
primitivelor de tratare a întreruperilor. Dacă notăm prin proces_ales o variabilă globală, care
conţine numărul procesului ales, iar prin salv_csp locaţiunea în care a fost salvat cuvântul de
stare a procesorului la apelarea supervizorului sau la întrerupere, prologul va fi de forma:
 prolog:
<mascarea întreruperilor> -- masca în cuvântul de stare
csp[proces_ales] := salv_csp;
salv_registre(Reg[proc_al]);

92. Realizarea pentru cazul unui sistem multiprocesoral

Regimului de funcţionare multiprocesor îi sunt specifice două instrucţiuni:
Test and Set(R, m) :asigură excluderea mutuală
Întrerupere(k) :provoacă o întrerupere a procesorului k.
O întrerupere sau un apel de supervizor provoacă introducerea cuvântului de stare şi a
registrelor procesorului în cauză într-o stivă în memorie, proprie acestui procesor.

93. Procese şi fire în Linux

În Linux procesele „se înmulţesc” prin clonare: apelul de sistem, care crează un proces nou,
se numeşte clone, iar procesul fiu este o copie aproape exactă a procesului părinte, doar că
mai departe va executa codul său, iar procesul părinte – ceea ce este scris după apelarea lui
clone.

94. Unix. Crearea proceselor

Procesele sunt create prin utilizarea funcţiilor din familia exec ale bibliotecii Linux standard:
execl, execlp, execle, execv, execve, execvp. Deşi formatul de apelare este diferit, în ultimă
instanţă execută acelaşi lucru: înlocuiesc codul din procesul curent cu codul, care se află în
fişierul indicat. Fişierul poate fi un fişier binar executabil Linux, un script al interpretorului
limbajului de comandă, un fişier binar de un alt format.
Unix. Distrugerea proceselor
La terminarea execuţieia unui proces , el este distrus eliberând toate resursele, care fusese
alocate anterior. Dacă procesul părinte se termină înaintea procesului descendent, ultimul
devine “orfan” . Toţi “orfanii” sunt “înfiaţi” în mod automat de programul init, executat de
procesul cu numărul 1, care duce evidenţa terminării execuţiei lor. Dacă a fost terminată deja
execuţia procesului descendent, iar procesul părinte nu este gata să recepţioneze de la sistem
semnalul despre acest eveniment, descendentul nu dispare total, ci este transformat în
Zombie; în câmpul Stat aceste procese sunt notate cu litera Z.
Demoni în Linux
Demon în Linux este numit procesul predestinat să lucreze în regim de fond fără terminal şi
care execută anumite operaţii pentru alte procese
De obicei, demonii îşi îndeplinesc în linişte lucrul şi ne amintim de ei doar în cazul unor
situaţii ieşite din comun: spaţiu insuficient – demonul singur informând utilizatorul despre
aceasta, sau refuz să lucreze şi sunteţi întrebat de şef când se vor termina problemele cu
imprimantă .
Unix. Obţinerea informaţiilor despre procese
Pentru obţinerea informaţiilor despre procese, vizualizate de programele ps şi top, Linux-ul
utilizează un sistem special de fişiere, numit procfs. În majoritatea distributivelor el este
iniţializat la lansarea sistemului de operare cu titlul de catalog /proc. Datele despre procesul
cu numărul 1 se află în subcatalogul /proc/1, despre procesul cu numărul 182 - în /proc/182,
etc. Toate fişierele, deschise de un proces, sunt reprezentate sub forma unor referinţe
simbolice în catalogul /proc/<pid>/fd, iar referinţa la catalogul rădăcină este păstrată ca
/proc/<pid>/root.