Post on 07-Apr-2018
8/4/2019 Proiect PATR
1/25
INTRODUCERE
Un executiv de timp real nu difer mult de nucleul unui sistem deoperare multitasking, oferind n plus funcii de timp real i trebuind s asiguretimpi de rspuns performani.
Memoria principal conine la un moment dat mai multe procesecare sunt pregtite pentru execuie. Fiecrui program i se acord o cuant detimp pentru utilizarea procesorului. Exist mai muli algoritmi pentru partajarea
timpului n care unitatea central este alocat unui anumit proces, n cadrulacestui proiect fiind folosit algoritmulRound-Robin.Randamentul unui astfel de sistem este mai ridicat dect al sistemelor
cu prelucrare secvenial. Ele realizeaz o mai bun utilizare a rsurselor iofer posibilitatea execuiei virtuale a mai multor procese (programe) n acelaitimp.
STRUCTURA PROIECTULUI
Clasa RTpr
Clasa de baz n cadrul unui ETR(executiv n timp real) este clasaproces: RTproces.
Structura clasei este urmtoarea:
class RTproces {public:
AdresaProces p_adr_proces;STARI p_stare; //stare proces
char p_nume_proces[9]; //numele procesuluiint p_dim_stiva; //dimensiunea stivei procesuluijmp_buf p_env; //structura pentru salvarea contextuluiint next; //indica urmtorul proces blocat
public:RTproces();RTproces(info_init_proces, info_init);
};
8/4/2019 Proiect PATR
2/25
Adresa procesului se afla printr-o construcie de forma:
typedef void (*AdresaProces)() ;
Strile n care poate ajunge un proces sunt urmtoarele:
typedef enum {Activ=1,Pregatit=2,Suspendat=3,Blocat=4,Intarziat=5,Inexistent=6} STARI;
ACTIV procesul care ruleaz la un moment dat; se va modifica nPlanificator();
PREGTIT un proces se afl n aceast stare dac dispune de toateresursele cu excepia UC, fiind un candidat laalocarea acesteia;
NTRZIAT procesele ce au solicitat executivului serviciul de ntrziere(delay) pentru un numr specificat de cuante;
BLOCAT procesele care au fcut operaia Down asupra unui semafor cuvaloarea
8/4/2019 Proiect PATR
3/25
unsigned j_ss;unsigned j_flag;unsigned j_cs;unsigned j_ip;unsigned j_bp;unsigned j_di;unsigned j_es;unsigned j_si;unsigned j_ds;
} jmp_buf[1];
Conine corespunztoare tuturor regitrilor procesorului (cu excepiacelor 4 de date), deci va fi utilizat pentru a reine contextul procesului. Lainiializarea fiecrui proces aceste cmpuri se iniializeaz cu valorile pe caretrebuie s le aib regitrii procesorului la lansarea n execuie a procesuluirespectiv; cmpurilej_ip ij_cs vor conine adresa de nceput a procesului (ce
se furnizeaz n info_init_proces prin intermediul adresei funciei ceimplementeaz procesul respectiv, iarj_sp ij_ss adresa vrfului stivei asociateprocesului respectiv. Stivele vor fi alocate de executiv, dup crearea obiectelorasociate proceselor i vor avea dimensiunea precizat n info_init_proces, iarvaloarea lui j_flagva nsemna posibilitatea sau nu de ntrerupere a procesului(0x200, respectiv 0x0); restul cmpurilor structurii env se iniializeaz cuvalorile curente ale regitrilor corespunztori.
Modelul de compilare ales va fi small. (SMALL = toate datele se aflntr-un singur segment standard, codul n alt segment standard, oriceinstruciune poate fi accesat prin JMP sau CALL de tip NEAR).
RTproces::RTproces(info_init_proces info_init){next=NEG;strncpy(p_nume_proces,info_init.nume_proces,8);p_nume_proces[8]='\0';p_dim_stiva=info_init.dim_stiva;p_stare=info_init.stare;p_env->j_ds=_DS;p_env->j_es=_ES;p_env->j_bp=_BP;
p_env->j_si=_SI;p_env->j_di=_DI;p_env->j_flag=0x200;p_adr_proces=info_init.adresa_initiala;p_env->j_ip=FP_OFF(p_adr_proces);p_env->j_cs=FP_SEG(p_adr_proces);
}
3
8/4/2019 Proiect PATR
4/25
Clasa RTexStructura clasei executiv este urmtoarea:
class RTexecutiv {public:
static RTproces *tabelaProcese[31]; //tabela de procesestatic int e_nr_procese_null;static int e_nr_procese; //nr. total de procesestatic int e_proces_activ; //indicele procesului activstatic char *e_stiva; //unde ncepe stiva locala alocata proceselor
static jmp_buf retEnv; //structura de salvare a contextului pt. procesul//activ curent
static Semafor ecran; //resursa comunapublic:
RTexecutiv(){};RTexecutiv(int nr_procese, info_init_proces* InitTab);static void interrupt Planificator(...);static void procNULL();static void Exit();static void DoIt();};
Clasa RTexecutiv trebuie s conin tabela proceselor implementat printr-untablou ce conine pointeri la obiectele proces.Cmpul e_nr_procese conine numrul total de procese. Acest numr se vadecrementa pe msur ce procesele sunt terminate.Cmpul e_proces_activ reprezint indicele procesului activ curent.Cmpul e_stiva indic locul de unde ncepe stiva local alocat proceselor.
Constructorul RTexecutiv
Constructorul claseiRTexecutiv trebuie s realizeze urmtoarele operaii:1. alocarea tabelei de procese i iniializarea acesteia cu informaiile
primite prin info_init_procespentru fiecare proces; se va includeaici i procesul null i se va face i pentru acesta iniializareaintrrii corespunztoare n tabela proceselor;
2. calculul dimensiunii stivei totale i alocarea acesteia ;
4
8/4/2019 Proiect PATR
5/25
3. alocarea /eliberarea spaiului rmas liber(coreleft()-stiva_total=aux)
4. iniializarea stivelor proceselor:j_ss=FP_SEG(stiva);j_sp=FP_OFF(stiva+i*tabela_procese[i].dim_stiva);
RTexecutiv::RTexecutiv(int nr_procese,info_init_proces *InitTab){int dim_stiva_totala=0;e_nr_procese=nr_procese;e_nr_procese_null=nr_procese+1;
//1for(int i=0;ip_dim_stiva;
}
info_init_proces proc_nul={procNULL,"ProcesN",DIM,Activ};tabelaProcese[e_nr_procese_null-1]=new RTproces(proc_nul);//2dim_stiva_totala+=tabelaProcese[e_nr_procese_null-1]->p_dim_stiva;
//3char *aux=(char *)malloc(coreleft()-dim_stiva_totala);e_stiva=(char *)malloc(dim_stiva_totala);
//4for(i=0;ip_env->j_ss=FP_SEG(e_stiva);tabelaProcese[i]->p_env->j_sp=FP_OFF(e_stiva+(i)*tabelaProcese[i]->p_dim_stiva);}free(aux);
e_proces_activ=e_nr_procese_null-1;};
Stivelor procesului trebuie s li se aloce spaiu la sfritul memorieidisponibile (a segmentului de date ce coincide cu cel de stiv n modelulsmall),
prin algoritmul: aloc unui pointer aux spaiul disponibil ce va rmnedisponibil dup alocarea stivelor:
(de dimensiune = coreleft() - suma_stivelor); aloc unui pointer stiv spaiul necesar tuturor stivelor;
iniializeaz stivele, deci cmpurile j_sp, n spaiulalocat stivei; elibereaz spaiul rmas dup alocarea stivelor, deci celalocat lui aux.
Gestionarea UC (Planificatorul)
5
8/4/2019 Proiect PATR
6/25
Planificatorul realizeaz alocarea UC, pe rnd, proceselor aflate nstareaPREGTIT, conform unei discipline prestabilite asigurnd execuiaconcurent a proceselor.
Realocarea presupune : salvarea contextului procesului ACTIV i trecerea n PREGTIT; alegere procesului cruia i se va aloca UC (dintre cele aflate n
PREGTIT ) ,acesta devenind ACTIV; lansarea n execuie a noului activ, prin refacerea contextului su.
Realocarea poate avea loc dac: procesului activ i se epuizeaz cuanta de rulare; dup fiecare cuant
elementar se genereaz o ntrerupere de ceas ( ntrerupere fizic denivel 0) ;
procesul activ cedeaz UC printr-o cerere explicit; procesul activ solicit un serviciu de autontrziere (delay), pentru un
timp specificat trecnd n starea ntrziat, UC trebuind a fi relocat ; procesul activ solicit o resurs nedisponibil prinr-o operaie Down
asupra unui semafor , trecnd n starea BLOCAT, iar UC se va reloca.
Planificatorul (Scheduler) este o funcie public a executivului i trebuie sfie nentreruptibil i s salveze contextul (toi regitrii) procesului activ , nstiva proprie acestuia.PrototipulPlanificatorului este:
static void interrupt RTexecutiv::Planificator(...);
La apelul ei din codul unui proces ce dorete cedarea UC sau dintr-o altfuncie a executivului , fiind interrupt se introduc n stiv CS i IP. Dupsalvarea flag-urilor, IF i TF (Interrupt i Trap Flags) sunt automat pui pe0, deci funcia este nentreruptibil (apelul ei se face similar cu intrarea hardntr-o rutin de tratare a unei ntreruperi). nainte de a se trece la execuiacodului propriu-zis al funciei, se salveaz n stiv restul regitrilor
procesului, deci ntregul su context este salvat pe stiv, posibilitatea
refacerii lui necesitnd reinerea vrfului stivei (SS:SP) . Ieirea din funciese realizeaz cu refacerea automat de pe stiv a regitrilor, apoi cuinstruciunea IRET, revenirea la adresa urmtoare apelului Planificatoruluii refacerea indicatorilor.
Execuia Planificatorului trebuie s realizeze:
6
8/4/2019 Proiect PATR
7/25
slavarea contextului procesului activ (se face automat pe stiv,funcia fiind interrupt);
trecerea procesului activ, din starea ACTIV (dac o are) nPREGTIT (s-ar putea ca starea lui s fi devenit anterior BLOCATsau NTRZIAT, cazuri n care nu se modific);
selecia unui proces PREGTIT cruia urmeaz a i se aloca UC; trecerea procesului selectat n ACTIV i completarea informaiilor
referitoare la numrul noului proces activ i adresa sa n tabela deprocese;
refacerea contextului noului proces activ i reluarea sa printr-oinstruciune de forma:
if (setjmp(tabelaProcese[vechi_activ]->p_env))return;
elselongjmp(tabelaProcese[e_proces_activ]->p_env,1);
Operaiile Planificatorului: se genereaz o ntrerupere de ceas; pune vechiul proces, dac a fost ACTIV, n starea PREGTIT; altfel ,
starea procesului rmnnd neschimbat; parcurge circular tabela de procese pn la gsirea primului proces
PREGTIT, pe care l face noul proces ACTIV; salveaz contextul vechiului proces activ i d controlul noului proces
activ (setjmp, longjmp).
Setjmp - salveaz toi regitrii deci i SS, SP ce excepia celor de date, ncmpul env al fostului activ i returneaz 0. Ulterior la un longjmp perechecu acelai env ca parametru, se reia execuia de la adresa urmtoare luisetjmp, deci return(ce reface regitrii ,apoi IRET).
Algoritmul Round-Robin
Algoritmul carusel simplu (engl.: round-robin) aloc cte o cuant detimp (cuantele pot fi egale sau inegale) pe rnd fiecrui proces pn cnd acestai termin sarcinile sau trebuie s intre n ateptare.
Algoritmul are avantajul c un task care tinde s ocupe procesorulpermanent (din greeal), deoarece a intrat ntr-o bucl infinit, nu poate opri
7
8/4/2019 Proiect PATR
8/25
celelalte taskuri s avanseze. Este simplu, ceea ce nseamn un timp de execuiesczut.
Dezavantajul major este c nu ine cont de urgena de realizare a unorsarcini.
Se utilizeaz n sistemele de operare cu divizarea timpului.
Procesul NULL
Acest proces este un proces al executivului, deci un proces sistem; se vacrea la iniializarea executivului, pe ultima poziie a tabelei de procese. Codulsu va fi un ciclu infinit de apelare a executivului (deci va ceda UC imediatdup primire).
void RTexecutiv::procNULL()
{while(1) Planificator();}
Funcia DoIt
Funcia DoIt este funcia din cadrul executivului care lanseaz primulproces n cadrul executivului de timp real i trateaz ntreruperea de ceas; astfelprogramul principal const dintr-un apel al funciei DoIt.
n cadrul acestei funcii trebuie tratat ntreruperea de ceas. Secvena de
mai jos realizeaz acest lucru:
#define CLK 0x08#define OLD_CLK 0x60
vecheintr=getvect(CLK);// se gsete adresa rutinei standard pentru ntreruperea 08H
setvect(OLD_CLK,vecheintr);//se iniializeaz cu aceasta ntrerupere un vector nefolosit
setvect(CLK,Planificator);//rutina de tratare va fi Planificatorul
La fiecare ntrerupere de ceas rutina de tratare a ntreruperii va fiPlanificatorul().
Funcia Exit
Funcia Exit() din cadrul executivului va pune procesul n stareaINEXISTENT i va apela Planificatorul. n aceast funcie se reface adresa
8
8/4/2019 Proiect PATR
9/25
rutinei standard de tratare a ntreruperii de ceas printr-un apel setvect numaidac nu mai exist alte procese care nu i-au terminat execuia. Funcia va fiapelat la sfritul fiecrui proces.
Clasa SemaforStructura clasei Semafor este urmtoarea:
class Semafor {int valoare;int proc_blocate;int prim_proc_bloc;int ultim_proc_bloc;
public:Semafor();
void Down();//cand procesul foloseste resursavoid Up();};
Semafoarele sunt folosite pentru ca mai multe procese s poat folosiresurse comune (ex: ecranul, tastatura...).
Membrii clasei Semafor sunt urmtorii: valoare poate lua orice valoare ntreag pozitiv sau negativ; prim_proces_blocat indicele primului proces blocat;
ultim_proces_blocat- indicele ultimului proces blocat; proc_blocate - numrul proceselor blocate la semafor.
Cmpul nextdin cadrul clasei RTproces va indica spre urmtorul procesblocat aflat n lista de ateptare. Dac valoarea lui nexteste negativ nseamnc nu indic spre alt proces.
Toate operaiile asupra unui semafor se exclud mutual. Pentru aceastaele trebuie s fie nentreruptibile. Practic, un semafor este alctui dintr-ovaloare ntreag i o list n care sunt introduse sau din care sunt scoase
procesele, care ateapt dup acel semafor.
Metodele clasei Semafor sunt: Down procesul folosete resursa; Up procesul elibereaz resursa;
9
8/4/2019 Proiect PATR
10/25
Deoarece operaiile asupra unui semafor trebuie s fie nentreruptibile lanceputul metodelor se vor dezactiva ntreruperile, iar la sfritul acestora sevor activa din nou.
#define DI asm { pushf; cli }//dezactivare ntreruperi
#define EI asm { popf } //activare ntreruperi
Down- dezactivarea ntreruperilor;- decrementeaz valoarea semaforului;- dac valoarea semaforului este negativ(semafor blocat) procesul
activ care a solicitat resursa devin BLOCAT i va fi introdus n listaproceselor blocate pe ultima poziie (ultim_proces_blocat va aveaindicele acestui proces);
- incrementeaz numrul proceselor blocate;
- activare ntreruperi;- apel Planificator();
- dac valoarea semaforului este >=0 procesul obine resursa (seactiveaz ntreruperile).
UP- dezactivarea ntreruperilor;- incrementeaz valoarea semaforului;- dac exist procese blocate
- primul proces blocat din list devine PREGTIT;- se extrage procesul din coada de ateptare;- decrementeaz numrul proceselor blocate;- activare ntreruperi;- apel Planificator();
- dac nu exist procese blocate se activeaz ntreruperile.
Clasa Geam
Cu ajutorul clasei Geam se implementeaz o fereastr prin intermediul
creia se vor afia rezultatele proceselor.
Structura clasei este urmtoare:class wind{
int xss;int yss;int xdj;
10
8/4/2019 Proiect PATR
11/25
int ydj;public:
wind(){}; deschenar(int,int,int,int,int);//deseneaza conturul ferestrei
scriere(char *,int);//scrie in fereastra
initdesstare();//initializeaza fereastra de staredes_stare(int,int,int);//arata starea procesului};
xss,yss,xdj,ydjreprezint coordonatele ferestrei;
GEAM.H
#ifndef _geam_h#define _geam_h#include#include#include#include////extern int a[5][4];class wind{
int xss,yss,xdj,ydj,linie;public: wind();
~wind();deschenar(int, int ,int ,int,int);scriere(char *,int);initdesstare();des_stare(int ,int,int);
};
#endif
GEAM.CPP#include "geam.h"#includesema.hstatic int a[4][4];Semafor sem;wind::wind()
{
11
8/4/2019 Proiect PATR
12/25
linie=0;}
wind::deschenar(int x1,int y1,int x2,int y2,int nrproc){
gotoxy(x1,y1);printf("");gotoxy(x1,y2);
printf("");gotoxy(x2,y1);
printf("");gotoxy(x2,y2);
printf("");gotoxy(x1+1,y1);
for(int i=x1;i
8/4/2019 Proiect PATR
13/25
sem.Down();gotoxy(a[nrproc][0]+1,a[nrproc][1]+1+linie);
printf(cuv);sem.Up();linie++;if (linie==a[nrproc][3]-a[nrproc][1]-1)
linie=0;}
wind::initdesstare(){
for(int i=0;i
8/4/2019 Proiect PATR
14/25
typedef enum {Activ=1,Pregatit=2,Suspendat=3,Blocat=4,Intarziat=5,Inexistent=6} STARI;
typedef struct {AdresaProces adresa_initiala;char nume_proces[9];int dim_stiva;
STARI stare;} info_init_proces;
class RTproces {public:AdresaProces p_adr_proces;STARI p_stare;char p_nume_proces[9];
int p_dim_stiva;jmp_buf p_env;int next; //indica urmatorul proces blocat
public:RTproces();RTproces(info_init_proces info_init);
};
#endif//_rtproces_h
RTPR.CPP#include "rtpr.h"#include #include
14
8/4/2019 Proiect PATR
15/25
RTproces::RTproces(){next=NEG;
};
RTproces::RTproces(info_init_proces info_init){
next=NEG;strncpy(p_nume_proces,info_init.nume_proces,8);p_nume_proces[8]='\0';p_dim_stiva=info_init.dim_stiva;p_stare=info_init.stare;p_env->j_ds=_DS;p_env->j_es=_ES;
p_env->j_bp=_BP;p_env->j_si=_SI;p_env->j_di=_DI;p_env->j_flag=0x200;p_adr_proces=info_init.adresa_initiala;p_env->j_ip=FP_OFF(p_adr_proces);p_env->j_cs=FP_SEG(p_adr_proces);
}
SEMA.H#ifndef _sema_h#define _sema_h#define DI asm { pushf; cli }#define EI asm { popf }#define NEG -10
class Semafor {int valoare;int proc_blocate;int prim_proc_bloc;int ultim_proc_bloc;
public:Semafor();void Down();//cand procesul foloseste resursavoid Up();
15
8/4/2019 Proiect PATR
16/25
};
#endif//_semafor_h
SEMA.CPP#include "sema.h"#include "rtex.h"extern int e_proces_activ;extern RTproces* tabelaProcese[];
Semafor::Semafor(){valoare=1;proc_blocate=0;prim_proc_bloc=ultim_proc_bloc=NEG;
}
void Semafor::Down(){
DI;if ((--valoare)p_stare=Blocat;if (prim_proc_bloc==NEG)prim_proc_bloc=ultim_proc_bloc=RTexecutiv::e_proces_activ;
else {RTexecutiv::tabelaProcese[ultim_proc_bloc]-
>next=RTexecutiv::e_proces_activ;ultim_proc_bloc=RTexecutiv::e_proces_activ;
}proc_blocate++;EI;RTexecutiv::Planificator();
}else EI;
}
void Semafor::Up()
16
8/4/2019 Proiect PATR
17/25
{DI;++valoare;if (proc_blocate)
{RTexecutiv::tabelaProcese[prim_proc_bloc]->p_stare=Pregatit;//extragere din coada de asteptareif (RTexecutiv::tabelaProcese[prim_proc_bloc]->next==NEG)
{prim_proc_bloc=ultim_proc_bloc=NEG;}
else{int aux=prim_proc_bloc;
prim_proc_bloc=RTexecutiv::tabelaProcese[prim_proc_bloc]->next;
RTexecutiv::tabelaProcese[aux]->next=NEG;}
proc_blocate--;EI;RTexecutiv::Planificator();}
else EI;
}
RTEX.H#ifndef _rtex_h#define _rtex_h#include "rtpr.h"#include "sema.h"
#define CLK 0x08 //intrerupere de ceas standard#define OLD_CLK 0x60 //intrerupere neutilizata
#ifdef __cplusplus#define __CPPARGS ...
#else#define __CPPARGS
#endif
17
8/4/2019 Proiect PATR
18/25
void proc0();void proc1();void proc2();void proc3();void proc4();
class RTexecutiv{public:
static RTproces *tabelaProcese[31];static int e_nr_procese_null;static int e_nr_procese;static int e_proces_activ;
static char *e_stiva; //unde incepe stiva locala alocata proceselorstatic char *e_stiva_cur; //pointer asociat stivei programului activstatic jmp_buf retEnv;//structura de salvare a contextului pt. procesul
//activ curentstatic Semafor ecran;
public:RTexecutiv(){};
RTexecutiv(int nr_proces,info_init_proces* InitTab);static void interrupt Planificator(...);
static void procNULL();static void Exit();static void DoIt();static RTproces* GetActive()
{return tabelaProcese[e_proces_activ];};
};#endif //_rtexecut_h
RTEX.CPP
#include "rtex.h"#include #include #include
18
8/4/2019 Proiect PATR
19/25
#include #include #include #define DIM 2000
extern RTexecutiv a;extern int tabc[2][30];extern int lx,ly;extern nr_procese;
int RTexecutiv::e_nr_procese_null;int RTexecutiv::e_proces_activ;RTproces* RTexecutiv::tabelaProcese[31];int RTexecutiv::e_nr_procese;
char* RTexecutiv::e_stiva;char* RTexecutiv::e_stiva_cur;
jmp_buf RTexecutiv::retEnv;Semafor RTexecutiv::ecran;
static void interrupt (*vecheintr)(...);
RTexecutiv::RTexecutiv(int nr_procese,info_init_proces *InitTab){
int dim_stiva_totala=0;e_nr_procese=nr_procese;e_nr_procese_null=nr_procese+1;for(int i=0;ip_dim_stiva;
}
info_init_proces proc_nul={procNULL,"ProcesN",DIM,Activ};
tabelaProcese[e_nr_procese_null-1]=new RTproces(proc_nul);dim_stiva_totala+=tabelaProcese[e_nr_procese_null-1]->p_dim_stiva;
char *aux=(char *)malloc(coreleft()-dim_stiva_totala);e_stiva=(char *)malloc(dim_stiva_totala);
for(i=0;i
8/4/2019 Proiect PATR
20/25
{tabelaProcese[i]->p_env->j_ss=FP_SEG(e_stiva);
tabelaProcese[i]->p_env->j_sp=FP_OFF(e_stiva+(i)*tabelaProcese[i]->p_dim_stiva);}free(aux);
e_proces_activ=e_nr_procese_null-1;};
void RTexecutiv::procNULL(){while(1) Planificator();}
void interrupt RTexecutiv::Planificator(...){static int i;geninterrupt(OLD_CLK);int sw;sw=0;
int vechi_activ=e_proces_activ;i=e_proces_activ;
if (tabelaProcese[vechi_activ]->p_stare==Activ)tabelaProcese[vechi_activ]->p_stare=Pregatit;tabelaProcese[e_nr_procese_null-1]->p_stare=Activ;do{if (i==e_nr_procese_null-1) i=-1;i++;if (tabelaProcese[i]->p_stare==Pregatit)
{tabelaProcese[e_nr_procese_null-1]->p_stare=Pregatit;tabelaProcese[i]->p_stare=Activ;
e_proces_activ=i;sw=1;
}}
while ((sw==0));if (setjmp(tabelaProcese[vechi_activ]->p_env)!=0)
return;
20
8/4/2019 Proiect PATR
21/25
elselongjmp(tabelaProcese[e_proces_activ]->p_env,1);
}
void RTexecutiv::DoIt(){
vecheintr=getvect(CLK);// se gaseste adresa rutinei standard pentru//intreruperea 08H
setvect(OLD_CLK,vecheintr);//se initializeaza cu aceasta intrerupere//un vector nefolosit
setvect(CLK,Planificator);
procNULL();}
void RTexecutiv::Exit(){e_nr_procese--;tabelaProcese[e_proces_activ]->p_stare=Inexistent;tabelaProcese[e_nr_procese_null-1]->p_stare=Activ;e_proces_activ=e_nr_procese_null-1;
if (e_nr_procese==0){setvect(CLK,vecheintr);sleep(5);exit(1);
}else
Planificator();}
MAIN.CPP
#include #include #include "rtpr.h"#include "rtex.h"
21
8/4/2019 Proiect PATR
22/25
#include "geam.h"#include #include #include #include #include #define DIM 2000info_init_proces tab[5]={
{proc0,"Proces0",DIM,Pregatit},{proc1,"Proces1",DIM,Pregatit},{proc2,"Proces2",DIM,Pregatit},{proc3,"Proces3",DIM,Pregatit},{proc4,"Proces4",DIM,Pregatit},};
int nr_procese=4;wind ferestre[5];int stare[4][2];
#define INTR 0x09
#ifdef __cplusplus#define __CPPARGS ...
#else
#define __CPPARGS#endif
void interrupt ( *oldhandler)(/*__CPPARGS*/...);
static int count=0;char ch;static int sw=0;void interrupt handler(/*__CPPARGS*/...){
sw++;oldhandler();
}
void proc0(){char *q;
22
8/4/2019 Proiect PATR
23/25
int val;stare[0][0]=100;for(stare[0][1]=0;stare[0][1]
8/4/2019 Proiect PATR
24/25
val=990-2*stare[2][1];itoa(val,q,10);ferestre[2].scriere(q,2);delay(100);ferestre[2].des_stare(stare[2][0],stare[2][1],2);}ferestre[2].scriere("terminat !!!",2);
RTexecutiv::Exit();};
void proc3(){char *q;int val;
stare[3][0]=100;for(stare[3][1]=0;stare[3][1]
8/4/2019 Proiect PATR
25/25
void main(){clrscr();wind ferestre[4];ferestre[0].deschenar(1,1,25,7,0);ferestre[1].deschenar(55,1,79,7,1);ferestre[2].deschenar(1,19,25,25,2);ferestre[3].deschenar(55,19,79,25,3);ferestre[4].deschenar(26,8,54,18,4);ferestre[4].initdesstare();RTexecutiv a(nr_procese,&tab[0]);RTexecutiv::DoIt();
}