2.2.

IMPLEMENTAREA PROCESELOR N UNIX

Structurile de date folosite de nucleu pentru gestiunea proceselor sunt :

structura de proces (1 per proces) care conine cmpuri ce trebuie s fie accesibile
nucleului tot timpul :
parametrii pentru planificare : prioritatea, timpul de UCP consumat recent, timpul
ct a stat n starea suspendat ultima oar; toate acestea sunt folosite pentru a
stabili care proces se selecteaz pentru rulare;
imaginea n memorie : pointeri ctre tabela de pagini asociat procesului, n cazul
n care procesul este rezident n memoria principal sau adresa pe dispozitivul de
swap (disc);
semnale : un cmp pentru semnale care arat semnalele primite de proces dar
netratate nc;
alte informaii : identificatorul de proces, identificatorii de utilizator i grup
efectivi, identificatorul procesului printe, starea curent a procesului,
evenimentul pe care l ateapt.
structura utilizator (1 per proces) care conine cmpuri necesare doar n timpul cnd
procesul se afl n starea de execuie:
pointer spre structura de proces;
toi identificatorii de grup sau de utilizator asociai procesului;
un tablou, fiecare element indicnd modul n care procesul va reaciona la
semnalul corespunztor (ignorare, tratare, terminare proces);
terminalul de control identificat ca "terminalul de login" asociat procesului, dac
exist vreunul;
parametrii i rezultatele/erorile apelurilor sistem;
pointer ctre inodul directorului curent i ctre inod-ul directorului rdcin
(root);
o copie a regitrilor generali, a indicatorului de stiv (SP), a numrtorului de
instruciuni (PC) care este scris n momentul comutrii din modul utilizator n
modul nucleu;
informaii privind tabela de fiiere deschise;

tabela de regiuni (1 per proces), n care fiecare element conine date despre o
regiune:
un pointer ctre inod-ul fiierului care este ncrcat n regiune (n cazul regiunilor
de tip text);
tipul regiunii : text (cod), memorie comun (date comune), date private sau stiv;
localizarea regiunii n memoria fizic;
dimensiunea regiunii (n Ko) i un cmp care indic tipul de acces permis
procesului (read-only, read-write, read-execute);
starea regiunii, care poate s fie o combinaie de :
blocat;
n acces (n cerere);
tocmai se ncarc n memorie;
valid (a fost deja ncrcat n memorie);
adresa tabelei de pagini;
adresa virtual de nceput a regiunii;
Obs. : Regiunile partajate pot avea adrese virtuale diferite n fiecare proces
Fiecare proces are att o faz utilizator (lucreaz n mod utilizator), ct i o faz sistem
(lucreaz n mod sistem, nucleu). Instruciunile obinuite sunt executate n mod utilizator, iar
apelurile sistem n mod sistem. Corespunztor, procesului i sunt asociate dou stive.
Comutarea ntre modul utilizator i sistem se realizeaz n cazurile :
- generare excepie;

- apelurile sistem prin care utilizatorul solicit diverse servicii oferite de sistemul de
operare; cele care realizeaz operaii de intrare/ieire conduc la suspendarea procesului
apelant pe durata transmiterii datelor;
- sosire ntreruperi de la periferice.
Nucleul pstreaz intern o tabel a proceselor active ce conine structurile de proces ale
proceselor active, indiferent dac ele sunt n memorie sau pe disc (n urma procesului de
swapping). De asemenea, pstreaz intern i o tabel de regiuni.
Cu ajutorul apelului sistem fork() se creeaz un nou proces astfel :
- se aloc procesului nou (numit proces fiu) o intrare liber din tabela de procese;
- se asigneaz un ID unic procesului fiu;
- se completeaz cmpurile structurii de proces a procesului fiu (multe sunt copiate
de la procesul printe : grupul printelui, UID-urile real i efectiv, valoare nice a printelui
etc.). Nucleul iniializeaz parametrii pentru planificare : valoarea iniial a prioritii,
folosirea UCP-ului etc.;
- se aloc memorie pentru regiunile de date i stiv, copiindu-se coninutul celor
corespunztoare printelui. n mod obinuit, nu este necesar alocarea unei zone pentru
cod, deoarece se partajeaz cel existent;
- dac sistemul lucreaz cu memorie paginat, vor fi construite noi tabele de pagini
pentru regiunile de date i stiv;
- se aloc memorie pentru structura utilizator i se copiaz informaiile din
structura utilizator a printelui. Astfel, vor fi pstrate valorile descriptorilor fiierelor
deschise.
Tabela de procese
a nucleului

Tabela de regiuni per proces

(adrese virtuale)

proces
printeproces fiu

coddatest
iv
coddatest
iv

Memoria fizic
a
b
c
d
e

structura utilizator a
procesului fiu
structura utilizator a
procesului printe
Pentru procesele aflate n starea SUSPENDAT, nucleul folosete o structur pentru
asocierea ntre setul de evenimente i setul de adrese virtuale ale rutinelor ce trateaz evenimentul.
ateapt terminarea unei operaii I/O
proces A
adresa C
proces B

ateapt umplerea buffer-ului

proces C
ateapt datele de la un terminal
adresa D
Dei apare rar, se poate ntmpla ca mai multe evenimente s fie mapate la aceeai adres.

Cnd apare un eveniment, TOATE procesele suspendate pe acel eveniment vor fi trezite i
trecute n starea PREGTIT. Doar unul dintre ele va beneficia de evenimentul recent produs,
celelalte trecnd din nou n starea SUSPENDAT, ateptnd o nou apariie a evenimentului.
n tabela de procese, primele intrri sunt ocupate de procesele nucleului :
- 0 - swapper
- 1 - init
- 2 - page daemon
2.3.

PLANIFICAREA PROCESELOR

Cnd dou sau mai multe procese sunt n starea PREGTIT i deci candideaz pentru
execuie, sistemul de operare trebuie s decid cruia i aloc UCP-ul. Acea parte din sistemul de
operare care se ocup cu luarea acestei decizii se numete planificator , iar algoritmul folosit,
algoritm de planificare.
n cazul sistemelor de prelucrare n loturi (batch systems), algoritmul era foarte simplu : se
executa urmtoarea lucrare de pe band. n cazul sistemelor multiutilizator cu partajarea timpului,
algoritmul este mult mai complex.
Criteriile ce se iau n considerare la definirea performanei unui algoritm de planificare pot
fi :
1. utilizarea UCP-ului;
2. timpul de prelucrare;
3. timpul de ateptare;
4. timpul de rspuns.
Utilizarea UCP-ului reprezint fraciunea din timp ct UCP este ocupat. Uneori se ia n
considerare timpul alocat att pentru programele utilizator ct i pentru cele sistem, alteori numai
pentru programele utilizator (useful work). Scopul este de a ine UCP-ul ct mai mult timp
ocupat, crescnd astfel performana sistemului.
Timpul de prelucrare poate fi definit ca timpul care se scurge ntre momentul cnd
programul este lansat n execuie i momentul terminrii lui.
Timpul de ateptare este timpul ct un program, pe durata execuiei sale, ateapt alocarea
resurselor necesare. Poate fi exprimat ca diferena dintre timpul de prelucrare i timpul efectiv de
execuie.
Timpul de rspuns este utilizat cel mai frecvent de ctre sistemele de operare de timp real
sau cu partajarea timpului. Definiiile difer pentru cele dou tipuri de sisteme. Astfel, la sistemele
cu partajarea timpului poate fi definit, de ex., ca timpul care se scurge din momentul scrierii
ultimului caracter al liniei de comand pn cnd primul rezultat apare la terminal (se mai numete
timp de rspuns la un teminal). La sistemele n timp real, poate fi definit ca timpul dintre
momentul n care apare un eveniment i momentul cnd este executat prima instruciune a rutinei
de tratare (se mai numete timp de rspuns la un eveniment) .
Planificatoarele caut s maximizeze performana medie relativ la un anumit criteriu. Una
dintre problemele ntlnite la proiectarea planificatorului este aceea c unele criterii sunt n
contradicie cu altele. De exemplu,un timp de rspuns ct mai bun poate duce la scderea utilizrii
UCP-ului. Mrind utilizarea UCP-ului i viteza de prelucrare, timpul de rspuns poate avea de
suferit. De aceea, proiectanii ncearc s maximizeze performanele relativ la criteriul cel mai
important pentru mediul de lucru (planificatoarele sunt dependente de mediu). De exemplu,
pentru sistemele cu prelucrare n loturi, intereseaz utilizarea UCP-ului; la sistemele
multiutilizator, timpul de rspuns; la sistemele n timp real, s rspund corespunztor multitudinii
de evenimente externe.
Algoritmii de planificare pot fi preemptivi sau non-preemptivi.
n cazul non-preemptiv, controlul este cedat sistemului de operare n momentul n care n
procesul curent n execuie apare o instruciune de acest gen sau dac procesul ateapt
terminarea unei operaii I/O. Deci procesul curent activ nu poate fi nlocuit cu un alt proces aflat
n starea pregtit avnd prioritate mai mare.

n cazul preemptiv, procesul aflat n execuie poate fi nlocuit oricnd cu un alt proces cu
prioritate mai mare. Acest lucru este realizat prin activarea planificatorului ori de cte ori este
detectat un eveniment ce schimb starea global a sistemului.
Indiferent dac algoritmul este preemptiv sau nu, comutarea de procese presupune
salvarea strii procesului fost n execuie, precum i crearea mediului de execuie a noului proces
ales a fi executat, ceea ce necesit mult timp. n general, sistemele de tip preemptiv pot furniza un
timp de rspuns mai bun, dar consum mult timp cu execuia planificatorului i comutarea
proceselor asociate.
Pentru pstrarea consistenei structurilor de date interne ale nucleului, un proces utilizator
rulnd n mod nucleu nu poate fi ntrerupt i nlocuit (preemted) de un alt proces, ci numai cnd
ruleaz n mod utilizator (nucleul ruleaz non-preemtiv).
n plus, nucleul crete nivelul de execuie al procesorului atunci cnd execut regiuni
critice (ex.: modificare pointeri la liste dublu nlnuite, n cazul citirii datelor de pe disc) pentru a
preveni ca anumite ntreruperi s-i cauzeze inconsistene ale datelor.
2.3.1. Mecanismul de planificare round-robin

n cazul sistemelor cu partajarea timpului, prima cerin este ca sistemul s furnizeze un

timp de rspuns rezonabil i, n general, s partajeze echitabil resursele sistemului ntre toi
utilizatorii. Evident, numai disciplinele de planificare preemptive pot fi luate n considerare n
astfel de situaii, una dintre cele mai populare fiind round-robin.
Timpul UCP-ului este mprit n cuante, de obicei ntre 10 i 100 msec., care se aloc
proceselor. Nici un proces nu poate rula mai mult de o cuant, att timp ct mai sunt procese n
sistem ce ateapt s fie executate. Structura de date folosit este o coad a proceselor gata de
execuie (aflate n starea pregtit). Cnd cuanta s-a terminat, UCP-ul este alocat unui alt proces
(primul din coad). Acelai lucru se ntmpl i n cazul cnd procesul este suspendat sau i-a
terminat activitatea naintea expirrii cuantei. Astfel, fiecare proces are alocat 1/N din timpul
UCP-ului, unde N este numrul proceselor din sistem.
Round-robin asigur partajarea echitabil a resurselor sistemului ntre procese. Procesele
scurte se pot termina ntr-o singur cuant, obinndu-se astfel un timp de rspuns bun. Procesele
lungi au nevoie de mai multe cuante de timp, ciclnd n coad pn cnd se termin.
Din punct de vedere hardware, se folosete un timer care genereaz o ntrerupere dup
trecerea unui interval de timp egal cu o cuant. Cnd sosete ntreruperea, sistemul de operare
lanseaz planificatorul pentru comutarea proceselor. Intervalul de timp este resetat naintea
execuiei noului proces ales din coad.
Performana acestui mecanism depinde foarte mult de valoarea cuantei. Astfel, o valoare
mic avantajeaz procesele interactive, dar scade eficiena UCP-ului, acesta ocupndu-se mult
timp cu tratarea ntreruperii sosite de la timer i cu comutarea proceselor. O valoare mare crete
eficiena UCP-ului, dar poate determina un timp de rspuns mare, dezavantajnd procesele
interactive (ex.: mai muli utilizatori apas n acelai timp pe o tast). O cuant de 100 msec.
realizeaz un compromis bun.
Algoritmul de planificare round-robin se recomand a se folosi n cazul sistemelor
multiutilizator, cu partajarea timpului, unde timpul de rspuns conteaz foarte mult.
2.3.2. Mecanismul de planificare bazat pe prioriti

(de tip preemptiv)

Algoritmul round-robin presupune c toate procesele sunt la fel de importante, ceea ce nu
este ntotdeauna adevrat. Pentru departajarea proceselor n funcie de importan, se folosesc
prioriti acordate fiecrui proces n parte, sistemul rulnd ntotdeauna procesul cu cea mai mare
prioritate din sistem.
Pentru a preveni ca procesele cu cea mai mare prioritate s ruleze tot timpul, planificatorul
poate scade prioritatea procesului curent n execuie la fiecare ntrerupere de ceas. Cnd
prioritatea procesului n execuie a devenit mai mic dect prioritatea unui alt proces, sistemul de
operare comut ntre ele.

Prioritile pot fi asignate static sau dinamic. Static, se acord de ctre utilizator sau de
ctre sistem, la creare. Dinamic, se asigneaz de ctre sistemul de operare, pentru realizarea unui
anumit scop. De exemplu, unele procese lucreaz foarte mult cu sistemul I/O. Ori de cte ori un
astfel de proces cere UCP, ar trebui s i se acorde imediat, pentru a lansa urmtoarea cerere I/O,
care astfel se va executa n paralel cu execuia unui alt proces de ctre UCP (altfel ocup memoria
prea mult timp). Un algoritm simplu pentru a oferi un serviciu bun proceselor orientate spre I/O
este de a seta prioritatea la 1/f, unde f reprezint fraciunea de timp ocupat cu UCP din ultima
cuant.
Se recomand n sisteme de timp real i alte sisteme care presupun rspuns ntr-un interval
de timp (time-critical requirements).
2.3.3. Mecanismul de planificare utiliznd cozi multiple

Algoritmii descrii mai sus caracterizeaz aplicaii particulare, fiind n general ineficieni n
alte situaii. Considerm, de ex., un sistem n care avem evenimente care cer tratare ntr-un anumit
interval de timp (time-critical events), o multitudine de utilizatori interactivi i unele programe
lungi i neinteractive. n acest caz, se recomand combinarea algoritmilor de planificare. Rezult
astfel planificarea cu cozi multiple, n care fiecare coad corespunde unui algoritm de planificare.
Pentru exemplul de mai sus vom obine trei cozi, ca n figur : (fig2_8.bmp)

Cozile pot fi gestionate prin round-robin sau bazat pe prioriti.

n cazul gestionrii bazate pe prioriti, sunt servite mai nti procesele din coada cu
prioritatea cea mai mare, folosind algoritmul de planificare corespunztor cozii respective. Cnd
aceasta devine vid, se trece la urmtoarea coad ca nivel de prioritate. Un proces n execuie
poate fi ntrerupt de un alt proces ce sosete ntr-o coad cu prioritate mai mare.
O variant a acestui algoritm este algoritmul cu cozi multiple i reacie negativ
(multiple-level queues with feedback). Un proces poate trece dintr-o coad n alta (schimbndu-ise astfel prioritatea), pe baza comportrii n timpul execuiei din cuanta anterioar. De exemplu,
fiecare proces ncepe cu prioritate maxim (este trecut automat n coada cu prioritate maxim).
Procesele ce au nevoie de mai mult de o cuant pentru terminare, sunt mutate ntr-o coad de
nivel mai mic. Dac procesul nu s-a terminat dup cteva rulri n aceast coad, este mutat ntr-o
coad de nivel i mai mic. Pe de alt parte, dac procesul cedeaz voluntar controlul sistemului de
operare, este mutat ntr-o coad de nivel mai nalt.
Ideea este de a acorda un tratament preferenial proceselor scurte i de a scufunda
procesele consumatoare de resurse n cozi de nivele din ce n ce mai mici, fiind folosite pentru a
umple timpul UCP-ului i deci pentru a menine un grad nalt de utilizare a UCP-ului.
n cazul sistemelor n timp real, nucleul trebuie s fie capabil s furnizeze rspuns imediat
unor evenimente externe, adic s fie capabil s ruleze un anumit proces ntr-un anumit interval de
timp de la apariia evenimentului. Ex.: un calculator ce asigur supravegherea unor sisteme de
meninere a vieii ntr-un spital.

O alt caracteristic a sistemelor n timp real este c nucleul este non-preemptiv (nu poate
fi lansat n execuie un alt proces asociat unui eveniment care tocmaia aprut pn cnd procesul
curent, asociat unui eveniment asociat anterior, nu se va termina).
De aceea, algoritmii de planificare prezentai mai sus nu pot fi utilizai n sisteme n timp
real.
2.3.4. Implementare n UNIX

ntr-un sistem cu partajarea timpului, nucleul aloc UCP unui proces pentru o anumit
perioad de timp, numit cuant de timp, cuprins ntre 0 i 1 s; de obicei, n sistemul Unix este
de 100 ms. Funcia de planificare din sistemul Unix folosete timpul de execuie pentru a
determina procesul ce va fi lansat n execuie la o comutare de context. Procesele au asociate
prioriti, valorile mari corespunznd prioritilor sczute.
La expirarea cuantei procesului curent n execuie, se va alege procesul aflat n starea
PREGTIT cu prioritatea cea mai mare. Nucleul recalculeaz prioritatea unui proces cnd acesta
revine din modul nucleu n modul utilizator i, periodic, ajusteaz prioritile proceselor aflate n
starea PREGTIT i n modul utilizator.
Pentru planificare se folosete mecanismul cu cozi multiple. Fiecare coad este asociat cu
un nivel de prioritate. Alegerea n cadrul cozii se face fie utiliznd mecanismul round-robin, fie va
fi ales procesul care a stat cel mai mult timp n starea PREGTIT (adic n funcie de ct de mult
a ateptat alocarea UCP-ului).
Dac n sistem nu exist nici un proces n starea PREGTIT, procesorul st (starea idle)
pn la urmtoarea ntrerupere (adic cel mult pn la urmtoarea ntrerupere de ceas). Dup
tratarea ntreruperii, nucleul verific dac sunt procese de rulat.
Parametrii folosii la planificare. Fiecare structur de proces conine un cmp de
prioritate folosit la planificare. Prioritatea unui proces n mod utilizator este n funcie de ct timp
a utilizat UCP ultima dat : cu ct utilizeaz mai mult UCP-ul, cu att prioritatea scade => asigur
un serviciu bun pentru procesele interactive. Domeniul de valori al prioritilor poate fi mprit n
dou clase :

prioritile proceselor ce ruleaz n mod utilizator;

prioritile proceselor ce ruleaz n mod nucleu.

Prioritile nucleu sunt subdivizate. Procesele cu prioriti nucleu mici pot fi trezite la
recepionarea unui semnal, n timp ce procesele cu prioriti nucleu mari vor fi trezite doar cnd sa produs evenimentul pe care s-au blocat (eliberarea resursei).
Nucleul calculeaz prioritatea unui proces n anumite stri ale procesului :
nucleul atribuie o prioritate unui proces cnd trece n starea SUSPENDAT;
prioritatea are o valoare fix, depinznd de motivul pentru care procesul este
suspendat;
nucleul ajusteaz prioritatea unui proces ce revine din modul nucleu n modul
utilizator. Anterior, procesul a trecut n starea SUSPENDAT, avnd prioritatea n
domeniul prioritilor nucleu (deci mai mare). Cnd revine n modul utilizator,
prioritatea i va fi modificat (va scade) att pentru a trece n domeniul prioritilor
utilizator ct i pentru a permite i altor procese utilizator accesul la resursele
sistemului;
de prioritate
rutina de tratare aNivele
ntreruperii
de ceas va ajusta prioritile
tuturor proceselor
Procese
Prioriti n
utilizator la interval de 1s (la System V), prevenind astfel ca un proces s
SwapperAteapt terminarea unei op.I/O cu
mod nucleu
monopolizeze UCP-ul.
Nentreruptibile

ntreruptibile

Prioritate de prag

Prioriti n
mod utilizator

disculAteapt alocarea unui inodAteapt

citirea datelor de la un terminalAteapt
scrierea datelor la un terminalAteapt
terminarea procesului fiuPrioriti utilizator
de nivel 0Prioriti utilizator de nivel 1.
.Prioriti utilizator de nivel n

Ceasul poate ntrerupe un proces aflat n execuie de mai multe ori pe parcursul unei
cuante. La fiecare ntrerupere de ceas, pentru procesul aflat n execuie este incrementat un cmp
din structura de proces corespunztoare, cmp ce exprim folosirea UCP-ului. n plus, la fiecare
secund, pentru toate procesele din sistem rutina de ceas ajusteaz acest cmp (s-l notm ucp)
astfel :
ucp = ucp/2;
(la System V)
i recalculeaz prioritatea fiecrui proces aflat n starea PREGTIT :
prio = ucp/2 + prio_prag
unde prio_prag este valoarea prioritii care desparte prioritile nucleu de prioritile
utilizator.
n urma acestei recalculri cozile cu procese utilizator vor fi modificate.
Procesele interactive, deoarece lucreaz puin cu UCP, vor fi mutate n cozi cu prioritate
mare, asigurndu-li-se astfel o bun servire.
Unele implementri ale mecanismului de planificare modific dinamic cuanta de timp, n
funcie de ncrcarea sistemului. Avantajul este c procesele pot fi rulate mai des. Dezavantaj :
cresc cheltuielile de regie (comutrile de context sunt mai dese).
Controlul prioritii unui proces se face prin apelul sistem :
int nice (int valoare);
Argumentul valoare poate fi pozitiv sau negativ.
n acest caz prioritatea procesului se calculeaz :
prio = ucp/2 + val_prag + valoare_nice
Doar utilizatorul root (superuser) poate folosi valori negative pentru argumentul valoare
(adic s creasc prioritatea procesului).
Procesele fiu motenesc valoarea nice de la printe (n cadrul apelului sistem fork). Apelul
sistem nice are efect doar pentru procesul care l apeleaz; un proces nu poate modifica valoare
nice a altui proces.