Esercitazione sui grafi di precedenza, fork/join, cobegin/coend.

Transcript

1 Esercitazione sui grafi di precedenza, fork/join, co/coend. Esercizio 1. Realizzare mediante il costrutto fork/join il seguente grafo di precedenze. Risposta. cont5 := 2; cont6 := 3; cont7 := 2; S1; fork(l1); fork(l2); S2; L1: S3; L2: S4; fork(l4); goto L3; fork(l4); goto L3; goto L4;

2 L4: join(cont6); S6; goto L5; L3: join(cont5); S5; goto L5; L5: join(cont7); Spiegazione. S7; Nel grafo di precedenze sono presenti 7 statement (o attività). E possibile notare che 3 di questi (nello specifico S5, S6 e S7) dipendono dal termine di più attività (S5 dipende dal termine di S2 ed S3; S6 dipende dal termine di S2, S3 ed S4; infine S7 dipende dal termine di S5 ed S6). Per questo motivo sarà necessario sincronizzare queste 3 attività tramite 3 diverse istruzioni di join(cont). Una istruzione di join (punto di unione) viene effettuata prima di eseguire una attività che ha più di un ingresso; cont è un contatore (inizialmente > 0) che viene decrementato ogni volta che un flusso di esecuzione cerca di passare attraverso l attività con più di un ingresso; quando il contatore si azzera, allora l istruzione join non è più bloccante e permette di proseguire eseguendo l attività successiva. Quindi, nel nostro caso, occorre definire tre contatori per le tre join che devono essere eseguite prima di S5, S6 ed S7 nel modo seguente: cont5 := 2; /* perché S5 dipende da 2 attivita */ cont6 := 3; /* perché S6 dipende da 3 attivita */ cont7 := 2; /* perché S7 dipende da 2 attivita */ Dopo la definizione dei contatori, inizia il processo principale e viene eseguita la prima attività S1. S1; Da S1 è possibile seguire 3 rami di esecuzione concorrenti; scegliendo come ramo principale quello di sinistra (che va verso S2) occorre creare gli altri due percorsi paralleli. A tal fine si creano delle etichette chiamate label che identificano il punto d inizio dei nuovi flussi di esecuzione. Nel nostro caso, il flusso di esecuzione che partirà da S3 viene associato alla label L1 mentre quello che partirà da S4 viene associato alla label L2. A questo punto è possibile creare due processi che saranno concorrenti a quello principale: fork(l1); fork(l2);

3 I due processi appena creati cominceranno l esecuzione a partire dalla prima istruzione (attività) indicata nella rispettiva etichetta, che si vedrà più avanti. Dopo aver creato i due flussi di esecuzione paralleli identificati da L1 ed L2, il flusso di esecuzione principale può proseguire eseguendo S2. A questo punto si ripropone una situazione in cui dopo S2 è possibile eseguire in parallelo due diverse attività; una seguirà il flusso principale (da S2 verso S5), l altra dovrà essere inserita in un processo parallelo (da S2 verso S6) e quindi dobbiamo definire una label L4 per specificare da dove partirà l esecuzione del nuovo processo creato. S2; fork(l4); Il flusso principale dovrebbe proseguire verso S5, però questa attività non può essere eseguita fintanto che tutti i flussi di esecuzione in ingresso a S5 non siano sincronizzati (perché S5 dipende sia dall attività S2 che dall attività S3). Ogni volta che uno statement (o attività) presenta una confluenza di archi in ingresso sarà necessario creare un punto di unione. Anche in questo caso viene creata un etichetta, L3, che ci permetterà di chiamare l istruzione di join anche dagli altri processi che confluiscono in quel nodo. Quindi, a questo punto, il ramo principale deve saltare all istruzione di join che verrà in seguito descritta dalla label L3: goto L3; Ora bisogna cominciare a descrivere le istruzioni associate ad ogni label che abbiamo precedentemente introdotto, a partire dalla prima che abbiamo scritto, cioè L1. Quando viene chiamata l etichetta L1 deve essere eseguita l attività S3; da questa attività deve essere creato un ramo parallelo che va verso S6 (la cui esecuzione è già identificata dalla label L4 introdotta precedentemente); dopo aver creato questa biforcazione con una fork, il processo corrente deve proseguire la sua esecuzione verso S5, che però è un punto d unione (quindi S5 non può essere subito eseguito, bisogna prima passare attraverso la join identificata dalla label L3), pertanto il processo corrente deve saltare all istruzione di join che verrà descritta dalla label L3. Quindi L1 è definita dalle istruzioni che seguono: L1: S3; fork(l4); goto L3; Dopo aver descritto L1, si passa a descrivere la seconda label introdotta. Quando viene chiamata l etichetta L2 l attività che deve essere eseguita è S4; l attività successiva, S6, non può essere subito eseguita perché è un punto d unione. Quindi bisogna saltare all etichetta L4 che descrive il punto d unione prima di eseguire l attività S6. L2: S4; goto L4;

4 Continuando a descrivere le etichette, si passa ad L4. In realtà, visto che ora descriveremo l etichetta L4 e l istruzione precedente era proprio un salto a questa etichetta, l ultima istruzione si rivela superflua, quindi è possibile eliminarla. goto L4; L etichetta L4 è legata ad un nodo con tanti punti di ingresso, quindi la prima operazione da eseguire è una join che sincronizzi i diversi flussi di esecuzione in ingresso. Visto che gli archi in ingresso sono tre, il contatore della join deve essere inizializzato a 3. Quindi il contatore che dobbiamo usare è quello che all inizio abbiamo dichiarato con il nome cont6. In questo modo l operazione di join aspetterà che i tre flussi di esecuzione in ingresso siano pronti, dopodichè si sbloccherà e verrà eseguita l attività S6. A questo punto, il flusso di esecuzione che stiamo analizzando dovrebbe portare verso S7 che è un altro punto d unione; quindi bisogna definire una nuova label L5 e quindi saltare a questa etichetta. L4: join(cont6); S6; goto L5; L etichetta successiva è L3. Questa etichetta è legata ad un nodo con 2 punti di ingresso, quindi la prima istruzione sarà una join su un contatore che era stato inizializzato a 2. Quando il contatore si azzera deve essere possibile eseguire l attività S5; da S5 si andrà verso il punto d unione descritto all etichetta L5. L3: join(cont5); S5; goto L5; Non ci rimane che descrivere, per ultima, l etichetta (L5) associata all ultimo nodo; come prima, questo fa sì che l istruzione di salto appena scritta sia superflua (può essere omessa). La prima istruzione da eseguire è il punto d unione, dopo il quale può essere eseguita l ultima attività del grafo di precedenza, cioè S7. goto L5; L5: join(cont7); S7;

5 Esercizio 2. Realizzare mediante il costrutto fork/join il seguente grafo di precedenze. Risposta. contg := 3; A; fork(lc); B; fork(le); D; LC: C; F; LE: E; LG: end join(contg); G; Spiegazione. Nel grafo di precedenze è presente una sola attività (G) che possiede più archi di ingresso; quindi definiamo un contatore per l istruzione di join che verrà effettuata prima di eseguire l attività G. contg := 3; La prima attività che deve essere eseguita è A, dopo la quale possono partire due attività concorrenti. Se scegliamo come ramo principale quello di sinistra, dobbiamo creare una

6 label che descriva il processo che partirà dall attività C. Chiamiamo questa label LC ed eseguiamo una fork. A; fork(lc); Il ramo principale proseguirà eseguendo l attività B, dopo la quale è nuovamente possibile dividere l esecuzione creando un nuovo processo concorrente che partirà dall attività E; chiamiamo LE la label associata al nuovo processo e eseguiamo una fork. B; fork(le); Il ramo principale proseguirà eseguendo l attività D; successivamente cercherà di entrare nello statement G che però è un punto d unione, quindi prima di essere eseguito deve essere sincronizzato. E necessario creare una label per questo statement che chiamiamo LG. Il ramo principale deve saltare alle istruzioni descritte nella label LG. D; Ora è possibile cominciare a descrivere le istruzioni appartenenti ad ogni label introdotta. La prima label è LC. Quando ci si riferisce ad LC, la prima attività che deve essere eseguita è C; il flusso d esecuzione porta subito ad eseguire l attività F; prima di entrare nell attività G occorre sincronizzarsi con gli altri flussi d esecuzione quindi occorre raggiungere con un istruzione di salto il punto d unione che verrà descritto nella label LG. LC: C; F; La seconda label introdotta è stata LE. La prima attività che deve essere eseguita è E; come per gli altri statement, da E bisogna saltare al punto d unione descritto dalla label LG. LE: E; Infine, l ultima label che rimane da descrivere è LG. Si tratta della label associata al punto d unione che deve essere eseguito prima dell attività G, che ha 3 archi in ingresso; quindi occorre eseguire una join che blocchi l esecuzione finchè tutti e tre i flussi di esecuzione in ingresso non siano pronti. Nota: l istruzione precedente goto LG è diventata superflua perché LG viene descritta immediatamente dopo. LG: join(contg);

7 G; Esercizio 3. Realizzare mediante il costrutto co/coend il seguente grafo di precedenze. Risposta. Spiegazione. A; co co G; B; co co C; F; D; E; In un costrutto di questo tipo tutte le attività che vengono descritte all interno di un blocco co/coend vengono eseguite in parallelo, mentre tutte le attività descritte in un blocco /end vengono eseguite in serie.

8 Da un analisi grafica ci si accorge che il grafo di precedenze in oggetto può essere semplificato come segue, raggruppando due insiemi di attività B1 e B2 che possono essere eseguiti in modo concorrente dopo l esecuzione dell attività A. In questa situazione quindi avremo che la prima attività che deve essere eseguita è A, dalla quale si diramano due flussi di esecuzione paralleli B1 e B2 che poi devono essere ricongiunti per eseguire l attività G; il che si traduce nel seguente pseudo-codice: A; co co G; B1; B2; che significa: all inizio () viene eseguita l attività A, al termine della quale vengono eseguite contemporaneamente (co) le macroattività B1 e B2; quando entrambe sono terminate (coend), allora viene eseguita l attività G. Infatti il costrutto co/coend permette di sospendere il processo padre fino alla terminazione di tutti i processi attivati. D altra parte, il costrutto /end descrive delle operazioni sequenziali. Ora dobbiamo descrivere i macroblocchi B1 e B2, che abbiamo artificialmente introdotto, in termini di attività del grafo di precedenze. Il macroblocco B1 è dato dall esecuzione in sequenza () dell attività B, dopo la quale possono iniziare in parallelo (co) le due attività D ed E. Quindi, nel codice precedente possiamo sostituire il blocco B1 con la sua descrizione:

9 B1: B; co D; E; co Il macroblocco B2 è semplicemente dato dall esecuzione in sequenza () delle attività C ed F. Quindi possiamo sostituire il blocco B2 con la sua descrizione: B2: C; F; Esercizio 4. Realizzare, se possibile, mediante i costrutti fork/join e co/coend il seguente grafo di precedenze.

10 Risposta. Realizzazione mediante costrutto fork/join: contg := 2; conti := 2; A; fork(le); B; fork(ld); C; H; LE: E; goto LI; F; LD: D; LG: LI: end join(contg); G; goto LI; join(conti); I; Realizzazione mediante costrutto co/coend: NON è possibile realizzare questo grafo di precedenze con il costrutto co/coend. Spiegazione. FORK/JOIN: Definiamo un contatore per ogni nodo che presenta più di un ingresso, inizializzato al numero di ingressi di quel nodo: contg := 2; conti := 2; Viene eseguita la prima attività A, dopo la quale si può creare un nuovo processo parallelo per eseguire il ramo di destra (viene creata appositamente la label LE): A;

11 fork(le); Il ramo principale (è stato scelto quello a sinistra) prosegue ed esegue l attività B. A questo punto si presenta un altra biforcazione che permette di creare un nuovo processo che andrà ad eseguire il ramo verso D (viene creata appositamente la label LD): B; fork(ld); Il ramo principale (ancora una volta viene scelto a sinistra) puo proseguire e vengono eseguite in sequenza le attività C ed H. Dopo l attività H è necessario sincronizzare i flussi di esecuzione prima di eseguire l attività I, quindi viene introdotta un istruzione di salto all etichetta LI (dove verrà effettuata una join). C; H; goto LI; A questo punto si può passare a descrivere le label. La label LE prevede l esecuzione in serie delle attività E ed F, poi dovrà saltare al punto d unione LG prima di entrare nell attività G. LE: E; F; La label LD prevede l esecuzione dell attività D, poi dovrà saltare al punto d unione LG prima di eseguire l attività G. LD: D; La label LG descrive il punto d unione per sincronizzare i flussi di esecuzione prima dell attività G. Viene effettuata una join sul contatore che era stato previsto all inizio per questo punto d unione, poi viene eseguita l attività G ed infine si salta all ultimo punto d unione, descritto dalla label LI. L istruzione precedente (goto LG) diventa superflua. LG: join(contg); G; goto LI; L ultima label descrive l ultimo punto d unione che sincronizza i due flussi di esecuzione che arrivano dalle attività H e G. Dopo la join, l ultima attività può essere mandata in esecuzione. L istruzione precedente (goto LI) diventa superflua. goto LI; LI: join(conti); I;

12 COBEGIN/COEND: Non è possibile in alcun modo raggruppare le attività in modo tale da poter usare il costrutto co/coend.