Proiect PATR

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);

};


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


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


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


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


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


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/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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


23/25

int val;stare[0][0]=100;for(stare[0][1]=0;stare[0][1]


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]


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();

}

Documents

Proiect PATR