COSTRUTTI LINGUISTICI COSTRUTTI SPECIFICI PER LA CONCORRENZA

STRUTTURE DATI

DE S C R I T T O R E P R O C E S S O

Typedef struct{

PID nome;

modalita_di_servizio servizio;

tipo_contesto contensto;

tipo_stato stato;

PID padre;

int N_figli;

des_figlio prole[max_figli];

p_des successivo;

} des_processo;

PU N T A T O R E A L L ’E L E M E N T O S U C C E S S I V O

typedef des_processo * p_des;

PID

typedef int PID;

MO D A L I T À D I S E R V I Z I O

typedef struct {

int priorita;

int delta_t;

} modalita_di_servizio;

DE S C R I T T O R E F I G L I O

Typedef struct {

PID figlio;

boolean terminato;

}

C O D A D I D E S C R I T T O R I

Typedef struct{

P_des primo, ultimo;

} des_coda;

FUNZIONI

DISPONIBILI PID assegna_nome();

p_des descrittore(PID x);

void inserimento(p_des pro, des_coda coda);

p_des prelievo(des_coda coda);

IMPLEMENTAZONE

MONOPRO CES SO RE

S A L V A T A G G I O S T A T O

Void salvataggio_stato(){

P_des esec = processo_in_esecuzione;

esec->contesto= //valori dei registri della CPU//

}

R I P R I S T I N O S T A T O

Void Ripristino_stato(){

P_des esec = processo_in_esecuzione;

//valori dei registri della CPU//=esec->contesto;

}

A S S E G N A Z I O N E CPU

void assegnazione_cpu{

int k=0;

p_des p;

while (coda_processi_pronti[k].primo == null)

k++;

p=prelievo(coda_processi_pronti[k]);

}

PIE (P R O C E S S O I N E S E C U Z I O N E )

PID PIE(){

PID nome_processo_in_esecuzione;

p_des esec = processo_in_esecuzione;

nome_processo_in_esecuzione = esec->nome;

return nome_processo_in_esecuzione;

}

AT T I V A

Void attiva(p_des proc){

P_des esec = processo_in_esecuzione;

int pri_esec = esec->servizio.priorita;

int pri_proc = proc->servizio.priorita;

proc->stato = //PROCESSO ATTIVO//;

if(pri_esec>pri_proc){

inserimento(esec,coda_processi_pronti[pri_esec]);

processo_in_esecuzione = proc;

} else {

Inserimento(proc,coda_processi_pronti[pri_proc]);

}

}

F O R K

Risultato fork(des_processo inizializzazione){

P_des p;

int NF;

p_des esec = processo_in_esecuzione;

if (descrittori_liberi.primo == null){

return eccezione;

} else {

p=prelievo(descrittori_liberi);

*p=inizializzazione;

p->nome = assegna_nome();

p->padre = esec->nome;

esec->N_figli++;

NF=esec->N_figli;

esec->prole[NF].figlio=p->nome;

esec->prole[NF].terminato=false;

attiva(p);

return ok;

}

}

JO I N

Void join(PID nome_figlio){

p_des esec = processo_in_esecuzione;

int k = indice_figlio(esec,nome_figlio);

if(esec->prole[k].terminato == false){

esec->stato = //SOSPESO IN ATTESA DEL FIGLIO//

Assegnazione_CPU();

}

}

Q U I T

Void quit(){

P_des esec = processo_in_esecuzione;

PID nome_padre = esec->padre;

p_des p_padre = descrittore(nome_padre);

int k = indice_figlio(p_padre, esec->nome);

p_padre->prole[k].terminato=true;

inserimento(esec, descrittori_liberi);

if(p_padre->stato==//attende che il figlio termini//){

int pri = p_padre -> servizio.priorita;

inserimento(p_padre, coda_processi_pronti[pri]);

p_padre->stato = //processo attivo//;

}

Assegnazione_cpu();

}

IN T E R R U Z I O N E T E M P O R I Z Z A Z I O N E (T I M E S L I C E )

Void interruzione_temporizzazione(){

P_des esec = processo_in_esecuzione;

int k;

k = esec->servizio.priorita;

inserimento(esec, coda_processi_pronti[k]);

assegnazione_cpu();

}

MULTIPRO CESSO R E

Il codice rimane sostanzilmente identico. Tranne per il fatto che l’accesso a

coda_processori_liberi e descrittori_liberi deve essere esclusivo. Inoltre processo in

esecuzione dovrà essere un array.