Scrigroup - Documente si articole

Username / Parola inexistente      

Home Documente Upload Resurse Alte limbi doc  

CATEGORII DOCUMENTE





AccessAdobe photoshopAlgoritmiAutocadBaze de dateC
C sharpCalculatoareCorel drawDot netExcelFox pro
FrontpageHardwareHtmlInternetJavaLinux
MatlabMs dosPascalPhpPower pointRetele calculatoare
SqlTutorialsWebdesignWindowsWordXml

SISTEME DE OPERARE DE TIMP-REAL

calculatoare

+ Font mai mare | - Font mai mic







DOCUMENTE SIMILARE

Trimite pe Messenger
NOTIUNI DE SISTEME DE OPERARE
Proiectarea logica
Programul OrCAD generalitati
Sistem informatic privind calculul amortizarii
Semnale
Frecvente cumulate - Biostatistica
Probleme de drum in (di)grafuri
LIMBAJ ARHITECTURAL
COPROCESORUL ARITMETIC 8087 SI APLICATII
Crearea folderelor

SISTEME DE OPERARE DE TIMP-REAL

1. Generalitati



Calculatoarele care sunt inglobate in sisteme de timp-real indeplinesc mai bine cerintele acestora daca sunt inzestrate cu sisteme de operare multitasking. Aceasta categorie de sisteme permite executarea unor operatii de prelucrare a datelor in corelare cu diferite evenimente (in special externe calculatorului), sau in raport cu timpul fizic (care poate si el sa fie interpretat ca un eveniment extern).

Sistemul de calcul 'ia cunostinta' despre producerea unui anumit eveniment extern ''prin intermediut sistemului de intreruperi. Aceasta activitate trebuie sa se realizeze chiar in momentul in care evenimentul are loc. Practic, exista o mica intarziere in efectuarea acestei operatii. In general, sistemul raspunde la evenimentul care a avut loc, emitand o comanda (de ex. spre elementele de executie), transmitand un mesaj (catre operator sau un alt sistem de calcul), sau in general executand o anumita activitate. Timpul de raspuns trebuie sa fie relativ mic in concordanta cu cerintele de timp-real. Din punctul de vedere al unui observator extern, sistemul de calcul apare ca fiind ocupat doar cu supravegherea, tratarea sau generarea unui raspuns la un anumit eveniment. Desi calculatorul are mai multe evenimente de supravegheat carora trebuie sa le raspunda, el pare dedicat in exclusivitate fiecaruia in parte. Cum in multe cazuri sistemul de calcul are un singur procesor, prelucrarea concurenta pentru generarea raspunsurilor este considerata virtuala, deoarece activitatile implicate pentru pregatirea raspunsurilor sunt evident secventiale. Aceeasi chestiune este valabila si in cazul sistemelor multiprocesor care trebuie la un moment dat sa emita mai multe raspunsuri decat numarul procesoarelor disponibile.

Sisteme cu divizarea timpului

O solutie pentru cerintele expuse anterior o ofera sistemele cu divizarea timpului (timesharing). In acest caz, memoria principala contine la un moment dat mai multe programe (sau segmente de program) care sunt pregatite pentru execute. Fiecarui program i se acorda o cuanta de timp pentru utilizarea procesorului. Exista mai multi algoritmi pentru partajarea timpului in care unitatea centrala este alocata unui anumit program. Se formeaza un sir de asteptare al lucrarilor care sunt in faza de executie si al celor care nu au fost executate complet in prima cuanta de timp acordata, fie din cauza unui volum prea mare de calcule, fie din cauza asteptarii efectuarii unor operatii intrare/iesire.

Randamentu! unor astfel de sisteme este mai ridicat decat cel al sistemelor cu prelucrare secventiala. Ele realizeaza o mai buna utilizare a resurselor si ofera posibilitatea executiei virtuale a mai multor programe in acelasi timp. Daca programele pot fi astfel construite incat sa aiba alocate canale de intrare-iesire diferite, ele nu se mai 'stanjenesc' reciproc in executie. Aceste sisteme, daca sunt inzestrate cu elemente pentru sincronizare cu timpul fizic, sau cu evenimente externe, ar putea fi utilizate cu succes la conducerea proceselor industriale, desi prezinta unele inconveniente.

Sisteme de programe concurente

Implementate pe sisteme monoprocesor sau multiprocesor, sistemele concurente efectueaza unele calcule si utilizeaza resurse virtuale in acelasi timp. Aparenta simultaneitate a utilizarii resurselor se obtine prin folosirea de catre programul in executie a serviciiior oferite de catre sistemul de operare. Acesta este o interfata intre programator si masina de baza. Dupa cum se vede si din figura 1, sistemul de operare este un strat software intre programele de aplicatii si hardware.

Programele se descompun in mai multe secvente de instruc$iuni numite taskuri, procese sau sarcini.

Fig. 641. Stratul software dintre programeie de aplicatii si hardware

Procesul (sau taskul) este definit ca o unitate elementara de program care poate fi executata independent de catre un echipament de calcul. El consta dintr-o secventa de instructiuni, logic independenta a unui program, care poate fi executata simultan, concurent cu alte parti componente ale aceluiasi program. Doua sau mai multe procese pot avea o functionare concurenta daca actiunile lor pot fi executate independent unele de altele. Se accepta ca actiunile lor pot fi chiar si simultane, cu exceptia cazurilor cand utilizeaza variabile sau resurse comune.

Procese dependente ierarhic

Un proces B este dependent ierarhic de un proces A daca actiunile lui B pot fi executate numai cand procesul A se afla intr-o anumita stare, numita stare de activare, sau a desfasurat o anumita activitate.

Procese conectate direct

Doua procese sunt conectate direct daca actiunile unuia se desfasoara intr-o sincronizare stransa cu actiunile celuilalt.

Procese independente sau cooperante

Procesele pot fi independente, daca nu interactioneaza cu alte procese din sistemul de programe, sau cooperante in cazul cand interactioneaza intre ele prin intermediul mecanismelor de comunicare sau sincronizare.

Procese elementare

Un proces care nu poate fi descompus mai departe in alte subprocese (sau substaskuri) se numeste proces elementar.

Procese compuse

O situatie mai complexa este aceea in care procesele sunt compuse din mai multe subprocese. Exista mat multe tipuri de astfel de procese:

Procese cu planificare

Un proces este cu planificare (engl.: scheduling processes) daca este compus dintr-un set de subprocese care trebuie sa se execute intr-o anumita ordine.

Procese conditionale

Un proces conditional (engl.: conditionai process) este format din mai multe subprocese care au atasate conditii particulare. Executia unui astfel de proces consta din executia subproceselor. Acestea se executa daca sunt indeplinite conditiile respective.

Procese repetitive

Un proces este repetitiv daca trebuie sa indeplineasca de mai multe ori aceeasi sarcina, dar de fiecare data cu argumente diferite.

Un proces compus poate fi periodic, daca subprocesele care il compun trebuie sa se sincronizeze cu propria lor perioada. Aceste procese sunt un tip de procese conditionale care au conditii temporale atasate subproceselor.

Procese de tip 'indata ce'

Un proces de tip indata ce (engl.: as-soon-as process) are o conditie de startare care trebuie sa fie indeplinita pentru ca subprocesele sale sa fie executate intr-o ordine predefinita.

Procese de tip 'atat timp cat'

Un proces de tip atat timp cat (engl,: as-long as process) este executat pana cand o conditie precizata este indeplinita.

Procese hiperperiodice

Un proces hiperperiodic (engl.: hyperperiodic process) este executat cu perioade variabile, spre deosebire de unul periodic care are o perioada de executie fixa. Pentru procesul hiperperiodic o noua cerere de executie este lansata indata ce precedenta a fost indeplinita. Fiecare cerere trebuie sa fie executata intr-un interval de timp predefmit numit hiperperioada.

Procese sporadice

Un proces sporadic (engl.: sporadic process) poate fi solicitat pentru executie in oricare moment, dar intre doua cereri succesive trebuie sa fie cel putin un interval de timp prestabilit.

Procese antrenate de timp sau de evenimente

Un proces intra in executie, cu alte cuvinte, ocupa procesorul, iar apoi trece in asteptare cand si-a terminat activitatea corespunzatoare raspunsului pe care trebuia sa-1 genereze. Ei este reactivat fie ia expirarea timpului de asteptare (engl.: time driven), fie daca are loc un anumit eveniment (engl.: event driven). Se realizeaza astfel o sincronizare a proceselor cu timpul fizic, respectiv cu anumite evenimente.

Controlul resurselor

Controlul efectiv al resurselor se realizeaza prin intermediul unor secvente de instructiuni. De exemplu, pentru utilizarea unor periferice se pot apela niste subrutine (driver) puse la dispozitie de catre producator. O astfel de subrutina este de asemenea o resursa (soft). Utilizatorii ar putea controla direct resursele, dar aceasta ar implica un efort mai mare de programare si in plus, nu ar fi exploatate eficient.

Sistemul de operare consta dintr-o colectie de module software care primesc cereri pentru alocarea resurselor de la utilizator sau procese si trebuie sa planifice componentele sistemului pentru a satisface aceste solicitari precum

si constrangerile impuse.

O sarcina importanta a unui sistem de operare este gestiunea recurselor sistemului de calcul Resurse ale unui sistem de calcul sunt: unitatea centrala, memoria interna, dispozitivele periferice, fisierele, procedurile etc.

Apeluri de sistem

Serviciile puse la dispozitia programatorului de catre sistemul de operare sunt accesibile prin intermediul unor functii sau apeluri de sistem (engl.: system calls). Printr-un apei de sistem, procesul in executie utilizeaza o procedura a sistemului de operare. In acest mod pot fi utilizate resursele hard sau soft ale sistemului. Procedurile ofera un set de servicii programelor care se executa in sistem. Ele sunt implementate intr-o componenta a sistemului de operare numita nucleu (engl.: kernel).

Nucleul sistemului de operare

            Nucleul sistemului de operare este incarcat la startarea sistemului de caicul si se executa in mod privilegiat. El poate controla unitatea de gestionare a memoriei, sau seta registrii procesorului astfel incat mai multe programe sa nu aiba acces simultan la resursele fizice ale sistemului. Nucleul poate stabili spatiul  de  adresa  accesibil   unui  proces  pentru  a-l  proteja de  accesele necontrolate la memorie ale altor procese. Un spatiu de adresa este un set de zone cu locatii virtuale de memorie. Se pot stabili drepturi de acces la memorie, cum ar fi: pentru scriere si pentru citire, numai pentru scriere sau numai pentru citire. Un proces nu are acces in zone de memorie din afara spatiului sau de adresa. Codul nucleului se executa, de obicei, in mod supervizor, iar procesele utilizatorilor se executa in mod utilizator.

Nucleul gestioneaza timpul de utilizare a unitatii centrale de catre procese, prin planificarea acestora pentru executie. Comutarea controlului procesorului de la un proces la altul este una dintre functiile cele mai importante ale sistemului de operare. Cu ajutorul acesteia se poate determina ordinea de executie a proceselor, astfel incat functiile fiecarui proces sa fie realizate in concordanta cu cerintele impuse.

Gestionarea proceselor

Componenta sistemului de operare de timp-real care realizeaza gestionarea proceselor este determinata de:

     mecanismul care realizeaza comutarea executiei intre procese;

     modul in care planifica procesele pentru executie.

Mecanismele de comutare se impart in doua categorii:

a.     mecanisme de comutare bazate pe intreruperi hardware, la care comutarea executiei proceselor (comutarea contextului) este determinata de aparitia unor intreruperi hardware in sistem;



b.     mecanisme de comutare bazate pe intreruperi software, ia care comutarea executiei este determinata de apeluri de sistem. in acest din urma caz, directiva are forma unui apel de subrutina, iar specificarea cererii de servicii se face prin numele subrutinei si prin argumentele acesteia.

Planificatorul

In decursul executarii unui program concurent apar multe situatii cand doua sau mai multe procese sunt din punct de vedere logic executabile. Ca urmare^ nucleul trebuie sa decida pe care sa-1 activeze primul. Partea din nucleu care are aceasta sarcina se numeste planificator (engl.: scheduler), iar algoritmul implementat de aceasta componenta se numeste algoritm de planificare.

2. Cerinte pentru un nucleu de timp-real

Un sistem de operare consta dintr-un set de programe implementate fie software fie firmware (care este o combinatie de hardware si software, in acest caz programele fiind stocate intr-o memorie ROM, de ex. componenta ROM-BIOS in cazul sistemului de operare MS-DOS), care realizeaza interfata intre programele utilizator si partea hardware a calculatorului. De obicei un program de timp-real este compus din mai multe procese care sunt executate concurent. Partea din nucleul de timp-real care se ocupa cu gestionarea proceselor trebuie sa satisfaca urmatoarele cerinte:

a.  Sa ofere facilitati pentru crearea, terminarea, intarzierea si activarea proceselor. Prin urmare, sistemele de operare de timp-real trebui sa fie capabile sa introduca termenele pentru startarea sau activarea proceselor.

b.    Sa realizeze planificarea proceselor pentru executie. Daca un anumit proces care are prioritatea mai mare decat cel aflat in executie devine executabil, el trebuie sa poata fi introdus in executie. Sistemele in care daca un proces detine o resursa (de exemplu, procesorul) o pierde in favoarea altui proces mai prioritar, care a devenit intre timp executabil, se numesc preemptive sau ca rechizitionare. Deseori, politica de planificare a proceselor poate fi aleasa de programator.

c.     Sa fie capabile sa gestioneze dinamic resursele software si hardware.

d.  Sa garanteze tratarea intreruperilor si sa permita emiterea raspunsurilor corespunzatoare. Calculatorul 'ia cunostinta' despre evenimentele externe prin intermediul semnalelor de intrerupere. Se impune o ierarhizare a intreruperilor dupa nivelul lor de prioritate, intreruperile sunt tratate in ordinea sosirii semnalelor corespunzatoare si ale nivelurilor lor de prioritate. Sistemul de operare trebuie sa permita programelor sa raspunda atat la intreruperile hardware cat si la cele software, el fiind reentrant si intreruptibil

e.  Sa ofere facilitati pentru cooperarea intre procese. Pentru a-si realiza sarcinile, procesele trebuie sa poata sa se sincronizeze si sa comunice intre ele. Sunt necesare facilitati pentru realizarea excluderii mutuale, a schimbului de mesaje etc.

f.     Sa permita conectarea unor dispozitive periferice si sa ofere facilitati pentru transferul datelor la/de la acestea. Aplicatiile de timp-real necesita, de obicei, comunicarea cu un numar mare de dispozitive periferice, sistemul de operare trebuind sa ofere proceduri pentru controlul acestora. Operatiile de intrare/iesire trebuie sa se execute

concurent cu celelalte activitati ale programelor si ale sistemului de operare.

g.    Sa permita tratarea erorilor de calcul aparute in timpul executiei programelor.

Portabilitatea

Utilizarea unor sisteme de operare de timp-real destinate (special) unor aplicatii date, au avantajul cresterii functionalitatii si performantelor. De asemenea, acestea contribuie la reducerea costurilor hardware-uiui si software-ului. Utilizarea lor are dezavantajul ca programele aplicatiilor nu mai sunt portabile. Pentru cresterea portabilitatii, utilizatorii sunt fortati sa foloseasca sisteme de operare de timp-real cu destinatii generale. Sistemele de operare din aceasta categorie nu pot satisface cerintele tuturor categoriilor de sisteme de conducere. Implementarea diferitelor niveluri ale unui sistem de conducere necesita sisteme de operare de timp-real diferite. Dar, utilizarea unor sisteme de operare diferite nu este comoda (din cauza ca utilizatorii trebuie sa cunoasca mai multe tipuri de sisteme de operare) si nici practica (din cauza costurilor).

Dimensionalitatea

Sistemele de operare cu destinatie generala nu sunt potrivite pentru marea varietate a setului cerintelor de calcul si de conducere. Utilizatorii constata ca aceste sisteme de operare nu indeplinesc toate cerintele.

in concluzie, aplicatiile ierarhizate (cum este structura din capitolul 1 a unui sistem de timp-real) au nevoie de sisteme de operare de timp-real care pot avea dimensiuni diferite in functie de nivel sau de aplicatie. Dimensiunea variabila a unui sistem de operare implica o structura modulara si posibilitatea adaptarii acesteia ia aplicatii. Prin urmare, la cerintele prezentate anterior, s-ar mai putea adauga urmatoarele: sistemele de operare de timp-real sa fie adaptabile, modulare, sa poata fi utilizate la dimensiuni diferite, si sa fie capabile sa impuna constrangeri de timp-real soft si hard.

3. Comutarea proceselor

Starea proceselor

„. Starea unui proces reprezinta totalitatea informatiei care trebuie salvata cand procesul este intrerupt din executie, pentru a putea fi lansat din nou fara ca aceasta sa afecteze comportamentul lui. Pe parcursul executiei unui program, procesele trec prin mai multe stari.

Comutarea unui proces dintr-o stare in alta este realizata de catre nucleu astfel incat sa nu afecteze lansarea urmatoare a procesului curent, dar nici evolutia altor procese. Starea unui proces dintr-un calculator consta din:

a. continuturile tuturor registrilor accesibili programatorului, inclusiv contorul de instructiuni, indicatorii de stare, drepturile de acces etc;

b.   adresele tuturor zonelor de memorie accesibile procesului;

c.   informatii (nume, drepturi de acces etc.) despre toate fisierele deschise de proces;

d.   timpul de executie folosit atunci cand procesul trebuie sa-si intrerupa executia pentru o perioada de timp. Daca anumite zone de memorie accesibile unui proces trebuie sa fie evacuate, dupa intreruperea lui din executie, pentru a fi utilizate in alte scopuri, continutul acestor zone este salvat in memoria externa (disc). Procesul care efectueaza aceasta operatie poarta denumirea de swapper. La reluarea executiei procesului, continutul zonelor respective trebuie restabilit. Fisierele deschise de proces trebuie sa ramana nemodificate pana la revenirea lui in executie.

Blocul de control al procesului

Nucleul  salveaza contextul  unui proces intr-un bloc de control al procesului (engl:. process control block) sau prescurtat BCP.                 '

Blocul de control ai unui proces are structura urmatoare:

typedef struct

BCP;

Blocurile de control pentru toate procesele sunt reunite intr-un tablou al proceselor:

BCP   tab_procese [MAX__PROCESE]

care este o structura globala ce apartine nucleului.

Comutarea contextului

intreruperea din executie a unui proces urmata de introducerea in executie a procesului urmator se numeste comutarea contextului (engl.: context switching). Aceasta comutare a contextului este realizata la tratarea unei intreruperi (hardware sau software) si la revenirea din aceasta. intreruperile hardware sunt consecinta unor evenimente externe, in timp ce cele software au ca si cauze efectuarea de catre procese a unor apeluri de sistem. Revenirea dintr-o intrerupere este asemanatoare cu revenirea dintr-o procedura. in general, la tratarea unei intreruperi hardware, nu se salveaza intregul context al procesului curent. Uzual, procesoarele sunt concepute sa salveze numai informatia minimala pentru acest scop. De obicei, la aparitia unei intreruperi hardware se salveaza in stiva (si nu in blocul de control al procesului) numai registrii procesului. Prin urmare, acest mecanism de tratare a unei intreruperi hardware rezolva numai o parte a problemei schimbarii contextului. Cealalta parte trebuie efectuata de catre nucleu.

Nucleul, procesele si rutinele de tratare a intreruperilor utilizeaza in mod concurent (sau pseudoconcurent) proce­soarele (sau procesorul). Aceasta se poate vedea si din diagrama din figura 2.  Initial procesorul executa secvente de instructiuni ale nucleului. Componenta nucleului numita dispecer (engl.: dispatcher) sau distribuitor lanseaza pe rand in executie cate un proces gata de executie.

Un   apel   de   sistem   (care  este   o intrerupere   software),   adica  apelul   unei        diagrama de comutare proceduri  sau  functii  a nucleului,  poate determina o schimbare a contextului, adica procesul care realizeaza apelul poate pierde procesorul care va fi atribuit apoi altui proces. Controlul procesorului mai poate fi pierdut de catre procesul curent sau de catre nucleu, in cazul aparitiei unei intreruperi hardware. in cazul din urma, procesorul isi continua activitatea cu executia rutinei de tratare a intreruperii. Dupa terminarea rutinei de tratare a intreruperii se revine fa executia codului procesului curent sau nucleului.

Fig 2 Diagrama de comutare

Figura 3 descrie modul de executie (pseudoconcurent) a doua procese si a nucleului.

In intervalul de timp cuprins intre 1 si 2 procesul J are procesorul si prin urmare se executa instructiunile lui. De la 2 la 3, o intrerupere software deter­mina cedarea procesorului nucleului. intre 3 si 4, se executa codul nucleului, iar 4-5 reprezinta cedarea procesorului procesului 2. Se observa executia intretesuta a proceselor si nucleului.

 

Fig 3                                                                Fig

Figura 4 prezinta executia concurenta a unui proces, a nucleului si a doua rutine pentru intreruperi hardware.

Intreruperea hardware aparuta in 2 determina executia rutinei corespunzatoare de tratare a intreruperii (secventa 3-4). La terminarea ei se revine in procesul intrerupt. Spre deosebire de acest caz, intreruperea aparuta in 18 va cauza executia rutinei, dar nu se va reveni in procesul intrerupt ci se va continua cu executia nucleului. Prin urmare, va trebui salvat contextul procesului intrerupt inainte de a se continua cu executia nucleului. Pentru aceasta rutina de intrerupere 2 va apela o functie a nucleului.

Diagrama de stare a proceselor

Diagrama din figura 5 reprezinta starile si tranzitiile pe care le pot efectua procesele.

Semnificatia starilor este urma­toarea:

S - suspendat sau blocat;

G - gata de executie;  

E - in executie;

A - in asteptare;

Fig. 5. Diagrama de stare a proceselor




Exista   mai    multe    variante   ale     diagramelor de stare ale proceselor, dar cea prezentata este suficient de detaliata pentru a explica activitatea unui sistem de operare multitasking de timp-real. In unele masini de stare se considera in loc de starea S o stare in care procesul este inexistent.

In cadrul nucleului, fiecarei stari ii este atasata o lista (cu exceptia starii A careia ii corespund mai multe liste) simplu inlantuita care va contine procesele care se gasesc in acea stare. Prin urmare, exista cate o lista pentru fiecare dintre starile S, G, E, o lista in care se vor afla procesele care asteapta scurgerea unui interval de timp si alte liste in care procesele asteapta indeplinirea unor conditii.

Un proces se afla in starea S daca sistemul de operare este informat despre existenta lui (uzual prin comenzi lansate de catre operator sau prin utilizarea unor directive ale sistemului de operare apelate intr-un proces in executie). El se poate afla in memoria principala (interna), sau poate fi rezident in memoria externa. Un proces aflat in aceasta stare nu este executat.

Procesele pot trece din starea S in starea G numai in urma unor comenzi lansate de catre operator, sau daca sunt lansate de catre alte procese (prin apelarea unor directive). Un proces aflat in starea G este executat daca unitatea centrala devine libera, iar ei se afla in capul listei proceselor 'gata de executie' (uneori are cea mai mare prioritate dintre toate cele aflate in aceasta stare).

Un proces aflat in starea E (in executie) paraseste aceasta stare daca:

  • si-a terminat activitatea si solicita prin utilizarea unor directive ale sistemului de operare ca sa fie trecut in starea S;
  • este  intrerupt  temporar  (de   catre  o  rutina  de  tratare   a  unei intreruperi) si trece in starea G prin intermediului sistemului de operare;
  • solicita o asteptare (deci trece in starea A) pana are loc un anumit eveniment  cum  ar  fi   trecerea  unui   anumit  interval  de timp, terminarea unei activitati, eliberarea unei anumite resurse etc.

Procesele trec din starea A in starea G daca a disparut motivul asteptarii. Ele sunt reactivate de catre sistemul de operare daca:

     a trecut intervalul de timp solicitat,

     a fost eliberata resursa solicitata;

     s-a terminat operatia intrare-iesire solicitata;

     un alt proces solicita reactivarea lui.

Procesele pot fi trecute din oricare stare in starea S fie prin comenzi ale operatorului, fie prin utilizarea unor directive de catre procesele aflate in executie.

In concluzie, trecerea unui proces dintr~o stare in alta se face fie atunci cand procesul face un apel de sistem, care este efectul unei intreruperi software, fie cand apare o intrerupere hardware (de la ceasul de timp-real, de la un dispozitiv periferic etc).

Crearea si startarea proceselor

Un program (compus din mai multe procese) trebuie sa fie mai intai compilat. Procesele trebuie sa fie incarcate in memorie pentru a putea fi executate. Ele pot fi in cod executabil pe disc, in memoria (interna) fixa sau create in mod dinamic in timpul executiei programului. in unele aplicatii destinate conducerii unor procese tehnice, deoarece procesele (software) trebuie sa se execute mereu, se prefera sa fie incarcate intr-o memorie fixa (adica permanent). in acest mod se reduce timpul necesar crearii proceselor si in plus creste fiabilitatea sistemului. Sistemele de operare UNIX creeaza procesele dinamic.

Daca procesele sunt in memorie, nu se mai pune problema crearii proceselor, ci numai a startarii lor. Functia de instalare (incarcare) a unui proces (install) are descrierea:

void install (nume process)

;

  • S-a presupus ca procesul se afla pe disc avand numele fisierului numeproces.

Pentru startarea proceselor se poate utiliza o functie sau o comanda start. Aceasta are descrierea:

void start(nume__proces) ;

 Intreruperi software

Un nucleu de timp-real trebuie sa furnizeze proceselor un numar minim de facilitati pentru realizarea cooperarii (sincronizarea, excluderea mutuala si comunicarea) intre procese precum si sincronizarea acestora cu timpul fizic. Functiile puse la dispozitie de catre nucleu sunt utilizate de catre procese prin efectuarea unor apeluri sistem echivalente unor intreruperi software.

Evenimente

Variabilele de tip eveniment sunt variabile logice speciale. Asupra lor pot actiona numai urmatoarele operatii: set, reset, wait. Un eveniment este compus dintr-o valoare care poate fi numai TRUE sau FALSE si o lista in care sunt introduse sau din care sunt scoase procesele care asteapta pentru acel eveniment.

Descrierea celor trei operatii este:

typedef struct

event;

/* Operatia set*/

void Set(event ev)

/* Operatia reset*/

void reset(event ev)

/* Operatia wait*/

 #define FALSE=0;

#define TRUE=t;

void wait(event ev)

Variabilele de tip eveniment sunt folosite, de obicei, pentru realizarea sincronizarii intre procese. In acest scop, se asociaza fiecarui eveniment exterior cate o variabila de tip eveniment. Semnalizarea aparitiei unui eveniment se realizeaza cu operatia set, iar asteptarea unui eveniment se face prin apelul operatiei wait. Operatia reset se foloseste pentru setarea explicita a unui eveniment la valoarea FALSE.

Semafoare

Semafoarele ofera un mecanism de sincronizare independent de arhitectura calculatorului, eliminand deficientele metodelor de sincronizare folosite anterior.

Semafoarele pot fi impartite in doua categorii, in functie de valorile pe

care le pot lua:

·        semafoare binare sau logice, care pot lua doar doua valori 0 sau 1;

·        semafoare  numerice  sau   generale,   care   pot   lua  orice   valoare intreaga pozitiva sau negativa.

Semafoarele sunt structuri de date speciale, asupra carora in afara operatiei init de initializare a acestora, mai pot actiona doua operatii numite p (de la cuvantul olandez passeren care inseamna a trece pe langa) si v (de la cuvantul olandez vriegeven care inseamna a elibera). Acestea au fost introduse de E. W. Dijkstra in 1965.

Toate operatiile asupra unui semafor se exclud mutual. Pentru aceasta ele trebuie sa fie neintreruptubile (indivizibile).

Un semafor este alcatuit dintr-o valoare (logica sau intreaga) si o lista in care in care sunt introduse, sau din care sunt scoase procesele, care asteapta dupa acel semafor.

Descrierea operatiilor care se pot aplica semafoarelor binare este urmatoarea:

typedef  sem bool  

 semaphore;

/*Initializarea semaforului sem la valoarea logica b*/

void init(semaphore sem, bool b)

;

/*Operatia p*/

void p(semaphore sem)

else (sem.valoare==0);

};

/* Operatia v*/

void v(semaphore sem)

;

};

};

Semafoarele binare sunt suficiente pentru a rezolva problema sincronizarii intre procese, dar pentru o rezolvare mai eficienta sunt recomandate semafoarele numerice.

Luand valoarea structurii semaforului o marime intreaga, descrierea operatiilor init, p si v pentru semafoarele numerice este:

/*Initializarea semaforului sem la valoarea intreaga n */

void init(semaphore sem,  int n )

;

/*Operatia p*/

void p(semaphore sem)

};

/* Operatia v*/

void v(semaphore sem)



;

};

Procesul aflat in executie care efectueaza operatia p asupra unui semafor se blocheaza daca valoarea semaforului este egala cu zero si isi continua executia daca este mai mare decat zero.

In urma blocarii procesului la efectuarea operatiei p, nucleul va da controlul procesorului altui proces aflat in starea 'gata de executie'. Procesul care urmeaza sa fie executat este ales de planificator. Operatia v descrisa anterior este folosita in cazul sistemelor preemptfve. in cazul sistemelor nepreemptive, operatia v nu poate duce la blocarea procesului aflat in executie, prin urmare aceasta nu mai trebuie sa salveze starea procesului curent si sa cedeze controlul procesorului altui proces.

Dupa ordinea in care sunt scoase din asteptare procesele care asteapta dupa semafoare exista:

  • 'semafoare slabe' - la care ordinea de asteptare este nespecificata (chiar aleatoare);
  • 'semafoare tari' - la care ordinea de asteptare este de tip FIFO, adica procesele sunt reactivate in ordinea in care au efectuat operatia p.

Pentru realizarea excluderii mutuale de la utilizarea unei resurse cu ajutorul semafoarelor si a operatiilor p si v se va atasa un semafor sem acelei resurse. Procesele care folosesc acea resursa sunt obligate sa efectueze operatia p(sem) inainte de a incepe sa foloseasca resursa si operatia v(sem) dupa terminarea utilizarii resursei.

Temporizari

Functiile pentru sincronizarea cu timpul-real ofera proceselor posibilitatea de a-si intarzia executia pentru o anumita perioada de timp. Un set minimal de functii oferit de nucleu pentru sincronizarea proceselor cu timpul-real consta din functiile: tdelay, tawake si twait. Diferenta dintre primele doua este ca una accepta timpul ca interval, iar cealalta ia valoarea absoluta a acestuia.

Functia tdelay (timp t) (prescurtare din engl. de la: time delay) este folosita cand un proces trebuie sa astepte o anumita perioada de timp t, transmitand nucleului perioada de asteptare. Functia tawake(«'mp t) este similara, dar t reprezinta o valoare absoluta a timpului, tawake (prescurtare din engl. de Ia: time awake) este folosita cand un proces trebuie sa astepte pana la un anumit moment r, transmitand nucleului, momentul la care doreste sa fie trezit. Descrierea lor este:

void tdelay)timp t)

;

Functia twait (prescurtare din engl. de la: time waii) determina efectiv intrarea in asteptare a procesului care a apelat anterior tdelay sau tawake.

void twait()

else

Revine cu executia in procesul apelant;

};

5. intreruperi hardware

Un proces este intrerupt daca sistemul de intreruperi este activat si apare o cerere de intrerupere din exterior. In acest caz, procesul aflat in executie pierde temporar procesorul. El ramane in aceasta stare pana cand rutina pentru tratarea intreruperii isi termina activitatea si renunta la procesor.

Desi intreruperile 'deranjeaza' activitatea normala a proceselor, existenta lor este necesara pentru sincronizarea sistemului de procese cu evenimentele externe, pentru functionarea ceasului soft, pentru realizarea unor operatii de intrare-iesire etc. Sistemul de intreruperi nu trebuie sa fie blocat complet sau pe un interval de timp mai lung, deoarece astfel sistemul de calcul ar fi impiedicat sa 'ia cunostinta' de aparitia evenimentelor exterioare procesului in executie. Notiunea de sincronizare presupune doar 'luarea la cunostinta' si nu cuprinde raspunsul care urmeaza evenimentului care a avut loc.

Rutinele pentru tratarea intreruperilor pot fi considerate ca niste procese

degenerate.

La aparitia unei intreruperi se executa operatiile:

  • se termina instructiunea in curs de executie;
  • se salveaza starea procesului aflat in executie;
  • se determina cauza care a produs intreruperea;
  • se dezactiveaza sistemul de intreruperi (unele procesoare isi dezactiveaza sistemul de intreruperi la acceptarea unei intreruperi), sau se mascheaza anumite niveluri de intrerupere, (de obicei cele cu prioritate mai mica);
  • se salveaza registrii procesorului, celelalte informatii ale starii, contorul de program, indicatorul stivei, indicatorii de conditii etc;
  • este cedat controlul procesorului rutinei pentru tratarea intreruperii, pana la terminarea acesteia;
  • se reincarca, la revenirea din procedura care a tratat intreruperea, registrii procesorului cu continuturile anterioare intreruperii, ale registrilor generali, indicatorului stivei, indicatorilor de conditii etc;
  • se  reactiveaza  sistemul  de  intreruperi,  sau  se  elimina mastile anumitor niveluri;
  • se da din nou controlul procesorului procesului intrerupt, dupa ce in prealabil s-a incarcat starea lui.

Exista mai multe posibilitati pentru rezolvarea problemelor implicate de intreruperi.

1.        O posibilitate ar fi ca rutinele pentru tratarea intreruperilor sa cuprinda ele insele toate activitatile implicate de cauzele care au generat intreruperile. Trebuie rezolvata situatia in care soseste o cerere de intrerupere pe un nivel prioritar celui servit la un moment dat. Rutina care trateaza o noua intrerupere nu 'stie' daca intrerupe un proces, sau o rutina pentru tratarea unei intreruperi. Rutina pentru tratarea unei intreruperi ar putea fi de forma:

void rutina_intrerupere()

;

Cele descrise in procedura precedenta pot fi cuprinse intr-un apel de sistem.

Un caz special al intreruperilor hardware apare in cazul operatiilor de intrare/iesire. Un proces realizeaza o operatie de intrare/iesire cu un anumit dispozitiv periferic prin apelul unei rutine numita driver de dispozitiv (engl.: device driver). Aceasta este specifica dispozitivului periferic si tipului operatiei de intrare/iesire. Unele sisteme de operare (de ex., Unix) trateaza perifericele ca dispozitive de tip caracter sau dispozitive de tip bloc. Un dispozitiv de tip caracter (de ex., tastatura sau imprimanta) este accesat in unitati de cate un caracter, iar unul de tip bloc ca si cum ar fi un tablou de caractere. Accesul direct la un bloc este realizat prin transmiterea indexului sau in tablou. Un dispozitiv de tip bloc poate fi utilizat prin folosirea unui buffer aflat in nucleu pentru memorarea blocului accesat, fara folosirea bufferelor prin transferul direct al continutului blocului intre dispozitiv si spatiul de adresa al procesului. Structura unui driver de dispozitiv este urmatoarea:

Initializari si verificari;

Dezactiveaza intreruperile;

while(coada este plina)

;

Pune cererea la coada;

if(dispozitivul nu este ocupai)                                                                       »

initiaza operatia de I/O;

while(cererea nu este terminata)

;

if(coada nu este plina)

;

}

else Realizeaza actiunea corespunzatoare;

/*de ex., incearca din nou transferul esuat*/

Revine in procesul curent;

Aceasta rutina este apelata atunci cand dispozitivul genereaza o intrerupere la sfarsit de transfer sau o intrerupere de eroare (indicand esuarea transferului). Rutina pentru tratarea intreruperii va determina mai intai motivul intreruperii, prin citirea registrului de stare al controlerului dispozitivului. in cazul unei intreruperi de sfarsit de transfer se va semnaliza terminarea cererii trezindu-se procesul care a emis cererea. Se va initia transferul urmator, iar apoi in cazul in care coada cererilor nu este plina se va semnaliza aceasta trezindu-se eventualele procese care asteapta dupa evenimentul CoadaNeplina. Dezacti­varea intreruperilor nu este continuta in rutina deoarece este uzual ca partea hardware sa dezactiveze intreruperile automat la primirea unei intreruperi. Reactivarea intreruperilor se va face automat in secventa de instructiuni prin care se revine in procesul curent.

O intrerupere hardware foarte importanta intr-un nucleu de timp-reai este intreruperea de ceas. Structura simplificata a rutinei care trateaza intreruperea de ceas este urmatoarea:

Incrementeaza variabilele globale care contin timpul fizic si data;

Furnizeaza informatii de temporizare rutinelor din nucleu;

Decrementeaza valorile 'timp' din BCP ale fiecarui proces care are acel camp diferit de zero;

if (valoarea 'timp ' a devenit 0)

Activeaza procesul eliminandu~l din lista proceselor care asteapta expirarea unui interval de timp;

if (procesul curent si-a terminat cuanta de timp alocata)

;

Revine in procesul curent;

Daca sistemul este preemptiv, la o intrerupere de ceas, daca sunt reactivate unele procese, trebuie sa fie salvata starea procesului curent, urmand sa fie lansat in executie procesul aflat in prima pozitie din lista 'gata de executie'.

Partea hardware (ceasul de timp-real) trebuie setata in asa fel incat sa genereze intreruperi de ceas cu o anumita perioada sau cuanta de timp care depinde de implementare. Rutina anterioara trebuie sa fie executata la fiecare intrerupere de ceas. Alegerea frecventelor ceasului hardware pentru generarea intreruperilor se face printr-un compromis intre precizia de masurare a timpului (care se urmareste sa fie cat mai buna) si cresterea supraincarcarii procesorului determinata de timpul necesar prelucrarii rutinei care implementeaza ceasul software.








Politica de confidentialitate

DISTRIBUIE DOCUMENTUL

Comentarii


Vizualizari: 831
Importanta: rank

Comenteaza documentul:

Te rugam sa te autentifici sau sa iti faci cont pentru a putea comenta

Creaza cont nou

Termeni si conditii de utilizare | Contact
© SCRIGROUP 2019 . All rights reserved

Distribuie URL

Adauga cod HTML in site