La presentazione è in caricamento. Aspetta per favore

La presentazione è in caricamento. Aspetta per favore

1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture.

Presentazioni simili


Presentazione sul tema: "1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture."— Transcript della presentazione:

1 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture debolmente connesse architetture in cui n processori (n > 1) hanno ciascuno una propria memoria centrale e un clock

2 2 Primitive di concorrenza in architetture fortemente connesse Scopo: nascondere le primitive di kernel e migliorare la correttezza e la leggibilità del programma -RCC -Monitor -Path expression Scopo: nascondere le primitive di kernel e migliorare la correttezza e la leggibilità del programma -RCC -Monitor -Path expression Scopo: rendere le primitive di kernel più efficaci, combinando il trsferimento di informazioni e la sincronizz. -Scambio di messaggi -Pipes -Sockets -Canali -RPC Scopo: rendere le primitive di kernel più efficaci, combinando il trsferimento di informazioni e la sincronizz. -Scambio di messaggi -Pipes -Sockets -Canali -RPC IPC Primitive di sincronizzazione a basso livello (kernel) Semafori, eventi IPC Primitive di sincronizzazione a basso livello (kernel) Semafori, eventi SO con memoria condivisa SO senza memoria condivisa

3 3 Linguaggi concorrenti: memoria condivisa vs scambio di messaggi zUn programma concorrente scritto in un linguaggio che prevede la memoria condivisa e’ adatto: yquando più processi del linguaggio sono realizzati all’interno di un unico processo di sistema y nei sistemi operativi che forniscono “multithreading” ynei sistemi operativi che permettono la condivisione di moduli (come Unix) ynei sistemi a tempo reale e sistemi di controllo “embedded”

4 4 Linguaggi concorrenti: memoria condivisa vs scambio di messaggi zUn programma concorrente scritto in un linguaggio che prevede la memoria condivisa non e’adatto: yin sistemi multiutente in cui lo spazio degli indirizzi e’ separato e protetto ytra processi residenti su macchine diverse in un’architettura a rete yin sistemi distribuiti in cui e’ desiderabile mantenere un certa flessibilita’ sul loading dei processi (load balancing)

5 5 Concorrenza: hardware e software processi La realizzazione di scambio di comunicazione tra processi puo’ essere effettuata secondo due modalita’ duali: procedurale yin modo procedurale xmonitor (se esiste condivisione di memoria) xrendez-vous-esteso (se non esiste memoria condivisa) scambio di messaggi ycon scambio di messaggi

6 6 Concorrenza: hardware e software zStruttura di un sistema procedurale Dominio chiamante Processo Call monitor-name Procedure 1 Procedure 2 Procedure n MONITOR DATI

7 7 Concorrenza: hardware e software zStruttura di un sistema a scambio di messaggi Process SEND (request) WAIT (reply) Process SEND (request) WAIT (reply) Procedura n Procedura 2 Procedura 1 DATI Procedure interne WAIT call requested procedure SEND reply Process

8 8 Scambio di messaggi: Classificazione I meccanismi di comunicazione si possono classificare in base alle seguenti caratteristiche: ydesignazione sorgente e destinatario xsimmetrica xasimmetrica ytipo di sincronizzazione xsend sincrona asincrona chiamata di procedura xreceive bloccante non bloccante

9 9 Scambio di messaggi: Primitive asincrone asimmetrica yComunicazione asimmetrica non bloccante ySend non bloccante bloccante yReceive bloccante unica coda di messaggi yOgni processo ha una unica coda di messaggi a lui inviati, gestita FIFO Send (mes, proc) proc := Receive (mes) Send (mes, proc) proc := Receive (mes)

10 10 WAIT SEND Processo A Send (B,.. ) Processo B Wait(., bid) Primitive asincrone a scambio di messaggio a livello kernel z Le primitive di scambio di messaggi possono essere realizzate a livello di kernel (anche in un’ architettura a memoria condivisa).

11 11 Semafori vs Scambio di messaggi (per sistemi con memoria condivisa) pool dei buffer code dei messaggi zIn un kernel a scambio di messaggi il kernel deve gestire il pool dei buffer, e le code dei messaggi => ymaggior complessita’ delle primitive di kernel ymaggior memoria a disposizione del kernel livello delle applicazioni zIn un kernel con semafori lo scambio di informazioni tra i processi deve essere fatto a livello delle applicazioni => yl’ onere (di tempo d’ esecuzione e di memoria) e’ a carico dei processi interessati yil kernel e’ piu’ snello

12 12 Implementazione di Scambio di messaggi zDimensione dei messaggi ylunghezza fissa a livello kernel ylunghezza variabile nei linguaggi ad alto livello zBufferizzazione dei messaggi ynumero massimo della lunghezza delle code yproblema del deadlock ymessaggi persi zTecniche di gestione della memoria ymessaggi grandi possono essere tenuti in segmenti o pagine passate da sender a receiveer ytecniche copy-on-write

13 13 Primitive asincrone: Produttori-Consumatori type tipo_messaggio_ricevuto = (dati,pronto) type in_mess = record case specie: tipo_messaggio_ricevuto of dati : (informazione:T) pronto: segnale end type out_mess: T

14 14 Primitive asincrone: Produttori-Consumatori Process buffer; var coda_dati: coda_cons: inf: T cons, proc : process in : in_mess out: out_mess begin while true do begin proc:= Receive (in) case in.specie of dati: trattadato(informazione) pronto: trattasegnale end z

15 15 Primitive asincrone: Produttori-Consumatori trattadato(informazione) begin if then put (informazione, coda_dati) else begin cons :=get(coda_cons) out:= in.informazione Send (out,cons) end

16 16 Primitive asincrone: Produttori-Consumatori trattasegnale begin if then put(proc,coda_cons) else begin inf :=get(coda_dati) out:= inf Send (out,proc) end

17 17 Primitive asincrone: Produttori-Consumatori Process produttore_i var mess: in_mess; contenuto: T; begin mess.specie:=dati while true do begin mess.informazione:= contenuto Send (mess, buffer) end

18 18 Primitive asincrone: Produttori-Consumatori Process consumatore_j var mess1: in_mess; mess2: out_mess; proc: process; begin mess1.specie:=pronto while true do begin Send (mess1, buffer) proc := Receive (mess2) end

19 19 Primitive asincrone: Produttori-Consumatori zVariante primitiva Receive zsi ricevono solo i messaggi che soddisfano la condizione B zse non esiste nessun messaggio che soddisfa la condizione B la Receive e’ bloccante proc : = Receive (mess) when B

20 20 Primitive asincrone: Produttori-Consumatori zProblemi realizzativi delle primitive con la Receive selettiva: yanaloghi a quelli della Regione Critica Condizionale: il processo bloccato in attesa del verificarsi della condizione logica viene svegliato ogni qualvolta un nuovo messaggio viene inserito in coda => busy form of waiting.

21 21 Primitive asincrone: Produttori-Consumatori Process buffer; var proc1, proc2 : process; in1, in2: in_mess; out:= out_mess; begin while true do begin proc1:= Receive (in1) case in1.specie of dati: trattadato(informazione) pronto: trattasegnale end

22 22 Primitive asincrone: Produttori-Consumatori Trattadato (informazione) begin proc2:= Receive (in2) when in2.specie=pronto out:= in1.informazione Send (out, proc2) end

23 23 Primitive asincrone: Produttori-Consumatori trattasegnale begin proc2 := Receive (in2) when in2.specie = dati out:= in2.informazione Send (out,proc1) end

24 24 Variazioni su scambio di messaggio asincrono zPrimitive di domanda e risposta zPiu’ code di messaggi per processo yPorte yCanali: yCanali: mailbox autonoma (detta anche global port) con un suo nome proprio yBroadcast e multicast from anyoneto everyone broadcast xI canali possono fornire una comunicazione “from anyone” e/o “to everyone” a tutti i processi di un gruppo definito al momento della configurazione (broadcast) xMulticast xMulticast : capacita’ di inviare un messaggio a tutti i processi di un dato gruppo

25 25 Variazioni su scambio di messaggio zPiu’ code di messaggi per processo yporte multiple per processo Porta 0 Porta 1 Porta 2 Porta n Op. 1 Op. 2 Op. n Dati Procedure interne Risposte per il processo P Messaggi per P, porta 1 Messaggi per P, porta 2 Messaggi per P, porta n

26 26 Variazioni su scambio di messaggio yPorte di input e di output con controllo dei tipi Porta di output Porta di input Mittente Send(m) Ricevente Wait(m) Verifica di tipo a tempo di compilazione Verifica di tipo a tempo di compilazione Binding e verifica di tipo a tempo di configurazione

27 27 Variazioni su scambio di messaggio zUna sola porta di input e molte di output Porta di input Ricevente Wait(m) Porta di output Mittente Send(m) Porta di output Mittente Send(m) Porta di output Mittente Send(m)

28 28 Variazioni su scambio di messaggio Ricevente Wait(m) Mittente Send(m) Mittente Send(m) Ricevente Wait(m) Mittente Send(m) Global Port

29 29 Primitive asincrone: porte multiple porte zPiu’ porte di ingresso: port x: T; Send (m) to x; proc := Receive (m) from x; port x: T; Send (m) to x; proc := Receive (m) from x;

30 30 Primitive asincrone: Comandi con guardia Comandi con guardie -----> guardia: espressione logica + (guardia logica) primitiva Receive (guardia di input)

31 31 Primitive asincrone: Comandi con guardia La guardia viene valutata quando il comando viene eseguito; si possono avere i seguenti risultati: fallita guardia fallita valida guardia valida ritardata guardia ritardata La guardia viene usata all’interno di comandi alternativi e di comandi ripetitivi.

32 32 Primitive asincrone: Comandi con guardia comando alternativo if B1 --> istruzione1 B2 --> istruzione2. B n -->istruzione n end Se esistono guardie valide ne viene scelta (in modo non deterministico) una Se tutte le guardie sono fallite il comando viene abortito Se tutte le guardie non fallite sono ritardate il processo si blocca in attesa dell’input. ze di comandi ripetitivi.

33 33 Primitive asincrone: Comandi con guardia comando ripetitivo do B1 --> istruzione1 B2 --> istruzione2. B n -->istruzione n end Il comando viene ripetuto fino a che tutte le guardie falliscono. In questo caso il comando termina.

34 34 Primitive asincrone: Comandi con guardia Problemi realizzativi delle primitive con porte multiple (e/o guardie): ysupporto run time deve fornire tante code quante sono le porte ycomandi con guardia richiedono la realizzazione di risveglio di un processo in attesa su un insieme di porte yun processo deve sospendersi su un insieme di porte

35 35 Primitive asincrone: Produttori-Consumatori porte multiple Process buffer port p-dati:T p-controllo: signal var inf: T pronto:signal produttore, consumatore:process begin do produttore:= Receive(inf) from p-dati;  consumatore:= Receive(pronto) from p-controllo; Send (inf) to consumatore.inport consumatore:= Receive(pronto) from p-controllo;  produttore:= Receive(inf) from p-dati; Send (inf) to consumatore.inport od end

36 36 Primitive asincrone: Produttori-Consumatori porte multiple Process consumatore_j port inport: T; var pronto:signal; inf: T; buffer: process; begin while true do begin Send (pronto) to buffer.p-controllo; buffer:= Receive (inf) from inport; end

37 37 Primitive asincrone: Produttori-Consumatori porte multiple Process produttore_i var inf: T; begin while true do begin inf:= contenuto Send (inf) to buffer.p-dati end

38 38 Send asincrona: Produttori-Consumatori con buffer limitato Process buffer port p-dati:T p-ctrl-p: signal p-ctrl-c: signal var inf: T ok-p,ok-c,ok-s: signal produttore, consumatore:process contatore: integer (init. 0) begin do (contatore < N); produttore:= Receive(ok-p) from p-ctrl-p;  contatore:= contatore + 1 Send (ok-s) to produttore.okport (contatore >0); consumatore:= Receive(ok-c) from p-ctrl-c; _  produttore:= Receive(inf) from p-dati; contatore:= contatore - 1 Send (inf) to consumatore.inport od end

39 39 Send asincrona: Produttori-Consumatori con buffer limitato Process produttore_i port okport: signal var inf: T; ok-p, ok-s: signal buffer: process begin while true do begin inf:= contenuto Send (ok-p) to buffer.p-ctrl-p; buffer:= Receive (ok-s) from okport Send (inf) to p-dati end

40 40 Send asincrona Sistema Pipelining Tre processi provvedono alla: zlettura di N record da un file zelaborazione dei record zcreazione di un nuovo file con i record modificati INPUT ELABORA OUTPUT

41 41 Send asincrona Sistema Pipelining Program pipeline var file1, file2: file of T; Process Input; var buf: T; begin reset (file1); for i := 1 to N do begin Read (file1, buf) Send (buf,Elabora) end

42 42 Send asincrona Sistema Pipelining Process Elabora; var bufin, bufout: T; proc: process; begin for i := 1 to N do begin proc := Receive (bufin) bufout :=Elabora (bufin) Send (bufout,Output) end

43 43 Send asincrona Sistema Pipelining Process Output; var buf: T; proc: process; begin rewrite (file2) for i := 1 to N do begin proc := Receive (buf) write(file2, buf) end

44 44 Primitive sincrone a scambio di messaggio a livello kernel SEND WAIT Processo A Send (B,.. ) Processo B Wait(., bid) z

45 45 Primitive sincrone Rendez-vous zStato di un processo che esegue la Send (BO: bloccato per output) z Stato di un processo che esegue la Receive (BI: bloccato per input) E BO E BI Invocazione Send Trasmissione messaggio Invocazione Receive Ricezione messaggio

46 46 Primitive sincrone Rendez-vous Mitt E BO E Ric BI E Posso mandarti un messaggio? OK! manda messaggio

47 47 Primitive sincrone a scambio di messaggio a livello kernel zLe primitive sincrone a livello di kernel non richiedono la gestione dei buffer, ma non sono adatte a tutti i tipi di sincronizzazione tra processi (ad esempio client/server). Cliente Send(request) Wait (replay) SERVIZIO SERVIZIO Server Wait (request) Send(reply) Processo di Interfaccia

48 48 Primitive sincrone Rendez-vous asimmetrica yComunicazione asimmetrica bloccante ySend bloccante bloccante yReceive bloccante code di messaggi yNon esistono code di messaggi associati ai processi gestiti dal meccanismo di comunicazione Send (mes, proc) proc := Receive (mes) Send (mes, proc) proc := Receive (mes)

49 49 Primitive sincrone Produttore- Consumatore Process buffer; varcoda: queue of T; proc : process; ccpronto, ppronto: boolean (init. false); dati: T; pronto: signal begin while true do begin proc:= Receive (pronto) case proc of produttore: trattaprod consumatore: trattacons end

50 50 Primitive sincrone Produttore- Consumatore trattaprod begin if then ppronto := true else begin proc := Receive (dati) if cpronto then begin Send (dati, cons) cpronto := false end else put(dati,coda) end

51 51 Primitive sincrone Produttore- Consumatore trattasegnale begin if then cpronto := true else begin dati:=get(coda) Send (dati,cons) if ppronto then begin proc: =Receive (dati) put(dati, coda) ppronto := false end

52 52 Primitive sincrone Produttore- Consumatore Process produttore var dati: T; pronto: signal begin while true do begin Send (pronto, buffer) Send (dati, buffer) end

53 53 Primitive sincrone Produttore- Consumatore Process consumatore var dati: T; pronto: signal; proc: process; begin while true do begin Send (pronto, buffer) proc := Receive (dati) end

54 54 Primitive sincrone Produttore- Consumatore con guardie Process buffer type p-pronto = signal c-pronto= signal var coda: queue of T datipronti: p-pronto datirichiesti: c-pronto proc: process dati : T begin do (coda nonpiena); proc:= Receive(datipronti) _  proc:= Receive(dati) put (dati, coda); (coda nonvuota); proc:=Receive(datirichiesti)  get(dati,coda) Send (dati, consumatore) od end

55 55 Primitive sincrone Produttore- Consumatore con guardie (senza uso del segnale datipronti) Process buffer var coda: queue of T proc: process dati : T cpronto:signal begin do (coda nonpiena); proc:= Receive(dati) ;  put (dati, coda); (coda nonvuota); proc:=Receive(cpronto)  get(dati,coda) Send (dati, consumatore) od end

56 56 Primitive sincrone Produttore- Consumatore Process produttore var dati: T; begin while true do begin Send (dati, buffer) end

57 57 Primitive sincrone Produttore- Consumatore guardie di input/output Comandi con guardie per primitive sincrone -----> guardia: espressione logica (guardia logica) + primitiva Receive (guardia di input) oppure primitiva Send (guardia di output)

58 58 Primitive sincrone Produttore- Consumatore con guardie di input/output Process buffer var coda: queue of T proc: process dati : T begin do (coda nonpiena); proc:= Receive(dati) ;  put (dati, coda); (coda nonvuota); Send (first(coda), consumatore)  aggiorna coda od end

59 59 Primitive sincrone Produttore- Consumatore con guardie di input/output Le guardie di output sono utili nel caso di sistemi client/server con piu’ di un server. if Send (richiesta, server1) --> ………; Send (richiesta, server2) --> ………; : Send (richiesta, serverN) --> ………; end proc := Receive (risposta)

60 60 Primitive sincrone Produttore- Consumatore con guardie di input/output Att!! difficili da realizzare deadlock. Le guardie di output sono difficili da realizzare e possono portare a deadlock. La validita’ di una guardia di output non garantisce che venga scelta l’istruzione associata alla guardia stessa

61 61 Primitive sincrone Problema del deadlock con guardie di input/output Process P var x1,x2:T1; proc: process begin x1:= valore if Send (x1,Q) --> …; proc:= Receive(x2) - > …; fi end Process Q var x:T1; y : T2; proc: process begin y:= valore if proc:= Receive(x) -> Send (y,R) --> …; fi end Process R var x:T1; y : T2; proc: process begin y:= valore if Send (x,P) --> …; proc:= Receive(y) -> …; fi end

62 62 Primitive sincrone Produttore- Consumatore con buffer parallelo Process produttore var dati: T; begin while true do begin Send (dati, buffer1) end Process consumatore var dati: T; proc: process; begin while true do begin proc := Receive (dati) end

63 63 Primitive sincrone Produttore- Consumatore con buffer parallelo Process produttore var dati: T; begin while true do begin Send (dati, buffer1) end Process consumatore var dati: T; proc: process; begin while true do begin proc := Receive (dati) end

64 64 Primitive sincrone Produttore- Consumatore con buffer parallelo Process buffer-i var dati: T; proc: process; begin while true do begin proc := Receive (dati) Send (dati, buffer-(i+1)) end Process buffer-N var dati: T; proc: process; begin while true do begin proc := Receive (dati) Send (dati, consumatore) end

65 65 Primitive sincrone canali uno-uno xSend (mes, proc) xReceive (mes, proc) xSend (mes, proc) xReceive (mes, proc) simmetricaComunicazione simmetrica bloccanteSend bloccante bloccanteReceive bloccante Mittente e ricevente devono conoscere il nome del processo con cui vogliono comunicare

66 66 Send sincrona Sistema Pipelining Program pipeline var file1, file2: file of T; Process Input; var buf: T; begin reset (file1); for i := 1 to N do begin Read (file1, buf) Send (buf, Elabora) end

67 67 Send sincrona Sistema Pipelining Process Elabora; var bufin, bufout: T; proc: process; begin for i := 1 to N do begin Receive (bufin,Input) bufout :=elabora (bufin) Send (bufout,Output) end

68 68 Rendez- vous esteso Remote Procedure Call rimane sospeso fino al completamento del servizio. zMeccanismo di tipo sincrono in cui il processo che richiede un servizio ad un altro processo rimane sospeso fino al completamento del servizio. mittentericevente chiamata attesa accept Inizio rendez-vous Fine rendez-vous Parametri input Parametri output

69 69 Rendez- vous esteso Remote Proceure Call cliente zPrimitiva dal lato cliente: call (input, output) servitore Primitiva dal lato servitore : remote procedure (in out )) var …; begin … end accept (in out )) --> S1, …,Sn

70 70 Rendez-vous esteso Produttore- Consumatore Process buffer var buff: array[0..N-1] of T testa, coda :0..N-1 (init. 0) cont: 0..N (init. 0) begin do (cont < N); accept inserisci (in dato:T) --> buff[coda]:= dato; end cont := cont +1 coda := (coda +1) mod N; (cont > 0); accept preleva(out dato:T) _--> dato:= buff[testa]; end cont := cont - 1 testa := (testa +1) mod N; od end

71 71 Rendez-vous esteso Produttori- Consumatori Process produttore-i var dati: T; begin while true do begin call buffer.inserisci (dati) end

72 72 Rendez-vous esteso Produttori- Consumatori Process consumatore-j var dati: T; begin while true do begin call buffer.preleva(dati) end

73 73 Rendez-vous esteso Segnalazione di sveglia Process allarme var tempo: integer tempo-di-sveglia: array[1..N} of record risveglio:integer intervallo:integer end begin do accept tick  tempo := tempo + 1; accept richiesta-sveglia (in intervallo:integer)  (tempo = tempo di sveglia[1].risveglio); accept svegliami [tempo di sveglia[1].intervallo];  od end

74 74 Rendez-vous esteso Pipeline Process Input; var buff: T;... call Elabora.ricezione (buff)... end Process Elabora; var buff: T;... accept.ricezione (buff)  … call Output.ricezione (buff) … end Process Output; var buff: T;... accept ricezione (buff) ... end

75 75 Linguaggi di programmazione a scambio di messaggi CSP Communicating Sequential Processes znon e’ un vero e proprio linguaggio ma piuttosto un modello di interazione tra processi znotazione per la specifica di concorrenza zcomunicazione sincrona zricezione selettiva dei messaggi

76 76 Linguaggi di programmazione a scambio di messaggi CSP zProcessi :: :: zComando parallelo [ // //…// ] [ // //…// ] (Send) zInvio di messaggi (Send) ! ! (Receive) zRicezione di messaggi (Receive) ? ?

77 77 Linguaggi di programmazione a scambio di messaggi CSP Schema di sincronizzazione La comunicazione puo’ essere stabilita se e solo se: a) P contiene un comando di uscita e Q contiene un comando di ingresso, ognuno specificante il nome del rispettivo partner () (comunicazione simmetrica) b) la variabile del comando di input e’ compatibile con l’ espressione del comando di output c) la sincronizzazione e’ a rendez-vous esteso P :: … ;Q:: … ; … ;… ; Q! ;P? ; … ;… ; (comandi corrispondenti) (comandi corrispondenti)

78 78 Linguaggi di programmazione a scambio di messaggi CSP Schema di comunicazione zTra i due processi si individua un canale, definito dalla terna: –nome mittente –nome ricevente –tipo del messaggio alternativi ripetitivi zLa sequenzializzazione tra processi e’ data dai comandi alternativi e ripetitivi con guardie: yalternativo: [ --> … --> ] yripetitivo: * [ --> … --> ]

79 79 Linguaggi di programmazione a scambio di messaggi CSP Linguaggi ispirati dai CSP OCCAM (transputer) zprocessi comunicano tramite canali zad ogni canale è associato un tipo di dato zun canale connette due soli processi: un processo di output ed un processo di input zcomunicazione di tipo rendez-vous esteso zprocessi statici

80 80 Linguaggi di programmazione a scambio di messaggi CSP Linguaggi ispirati dai CSP OCCAM (sintassi) zogni statement è considerato un processo zil programmatore deve esplicitare l’esecuzione parallela o sequenziale: SEQPAR stat1 stat2 stat3 zcomunicazione denotata con ? e ! channel ? varchannel ! value

81 81 Linguaggi di programmazione a scambio di messaggi CSP Linguaggi ispirati dai CSP OCCAM Prodotto di matrici * =

82 82 Linguaggi di programmazione a scambio di messaggi CSP Linguaggi ispirati dai CSP OCCAM Prodotto di matrici SINK RIS SRC 1,0,2 0,1,2 1,0,0 ZERO SINK 4,2,6 3,2,4 3,0,0 10,5,18 6,5,10 6,0,0 16,8,30 9,8,16 9,0,0

83 83 Linguaggi di programmazione a scambio di messaggi CSP Linguaggi ispirati dai CSP Moltiplicatore per matrici: Prendere un elemento da NORD Passarlo a SUD Moltiplicarlo per val Prendere il valore somma parziale da EST Sommare aggiornare il valore Mandare il risultato OVEST SS val N E O

84 84 Linguaggi di programmazione a scambio di messaggi CSP Moltiplicatore in OCCAM a)WHILE TRUE SEQ north ? x south ! x east ?sum sum := sum + a * x west ! sum b)north ? x WHILE TRUE SEQ PAR south ! x east ? sum tmp := a * x PAR west ! sum + tmp north ? x

85 85 Linguaggi di programmazione a scambio di messaggi DP Distributed Processes zlinguaggio basato su RPC zproposto per applicazioni in tempo reale zun sistema e’ visto come un insieme di processi concorrenti che “vivono insieme” per tutta la durata del sistema

86 86 Linguaggi di programmazione a scambio di messaggi DP Processi Process Process begin … end Comandi con guardia if B1 : S1 / B2 : S2 /…end do B1 : S1 / B2 : S2 /…end Varianti sospensive Varianti sospensive when B1 : S1 / B2 : S2 /…end cycle B1 : S1 / B2 : S2 /…end Rendez-vous esteso

87 87 Linguaggi di programmazione a scambio di messaggi ADA zlinguaggio studiato soprattutto per applicazioni in tempo reale znotazione per la specifica di concorrenza: task zcomunicazione asimmetrica e sincrona zremote procedure call

88 88 Linguaggi di programmazione a scambio di messaggi ADA Schema di comunicazione dalla parte del server: accept (in out )) do S1, …,Sn end l’ accept puo’ essere selettiva: select accept entry1 do, …, end or accept entry2 do, …, end … or accept entryn do, …, end end select

89 89 Linguaggi di programmazione a scambio di messaggi ADA si possono usare guardie logiche: select when B1 --->accept entry1 …, or when B2 --->accept entry2 …, … or when Bn --->accept entryn …, end select

90 90 Linguaggi di programmazione a scambio di messaggi ADA Schema di comunicazione dalla parte del client: le chiamate alle entry del server sono effettuate con la notazione “.” server. Entryname e’ possibile una chiamata condizionale: select else end select la chiamata viene effettuata solo se il server e’ in attesa su quella entry

91 91 Linguaggi di programmazione a scambio di messaggi ADA Esempio : Implementazione semaforo task body SEMAPHORE is count : integer begin accept Init (N:integer) do count := N loop select when count >0 => accept WAIT do count := count -1 end or accept SIGNAL do count := count +1 end end select end loop end SEMAPHORE

92 92 Linguaggi di programmazione a scambio di messaggi ADA Moltiplicatore task body MULTIPLIER is X, Sum: array[1..n] A: integer Nord, Sud, Est, Ovest: task begin accept Init (I:integer; N,S,E,O:channel) do A:= I Nord:= N; Sud:= S; Est:= E; Ovest:= O end loop accept Input (Nord) (I: array[1..n] ) do X:= I end Sud.Output (X) accept Input (Est) (I: array[1..n] ) do Sum := I end Sum := Sum + A*X Ovest.Output (Sum) end

93 93 Linguaggi di programmazione ADA Implementazione del Rendez-vous select when B1 --->accept entry1 …, or when B2 --->accept entry2 …, … or when Bn --->accept entryn …, end select ad ogni accept si associa una coda di processi in attesa (eventualmente un semaforo)

94 94 Linguaggi di programmazione a scambio di messaggi Linda zLinda è un linguaggio concorrente radicalmente diverso di precedenti zNei linguaggi tipo Ada e Occam, i processi comunicano mediante un rendez-vous sincrono; essi sono accoppiati nel tempo e nello spazio: ytempo: sincronia yspazio: indirizzo del canale zLinda permette un disaccoppiamento nel tempo e nello spazio; concetto fondamentale è lo spazio delle tuple (TS), che può essere visto come un insieme di sequenze tipate di dati (tupla): y(1, “A”) (integer, character) y(1, 2)(integer, integer)

95 95 Linguaggi di programmazione a scambio di messaggi Linda Le primitive di Linda sono: yOutput (T) : aggiunge la tupla t allo spazio di tuple yInput (T) : rimuove dallo spazio di tuple una tupla matching con T, se tale tupla non esiste il processo viene sospeso yRead (T) : come il precedente, ma senza rimozione yTry-Input (T): versione non bloccante dell’ Input (T) yTry-Read (T): versione non bloccante della Read (T)

96 96 Linguaggi di programmazione a scambio di messaggi Linda Le tuple di Linda possono contenere parametri formali o attuali e, in maniera analoga alla chiamata di procedura, l’accoppiamento di due tuple corrispondenti, provoca il trasferimento dei valori attuali di una tupla nei parametri formali dell’altra. Es. lo statement di input Input (I: integer, C: character) sarà sospeso sino a che lo statement di output Output (1, “A”) avrà inserito la sua tupla a TS

97 97 Linguaggi di programmazione a scambio di messaggi Linda Esempio1: zRichiesta di uno specifico servizio da parte di un processo. Le tuple hanno tre elementi: ystringa che identifica richiesta di servizio yintero che identifica il tipo di servizio yidentificativo di un processo Input (“job”, J: job_id, 24) / Il processo 24 aspetta di servire/ Output (“job”, 17, 24) / richiesta inviata al processo 24/ Output (“job”, 17, p: Process_id) / richiesta inviata a qualsiasi processo/

98 98 Linguaggi di programmazione a scambio di messaggi Linda Esempio2: zRendez-vous (tipo ADA): accept Proc (I: in integer, C: in character, B: out Boolean) …. end call Proc (65, “X”, B) zLe tuple hanno i seguenti campi: ystringa contenente il nome del servizio ynome del processo chiamante ydue parametri di input (intero e carattere) Codice per la chiamata di procedura Output (“Proc”, 24, 65, “X”) Input (24, B: boolean) Codice per l’accept Input (“Proc”, Caller: p-id, I: integer, C: character) Proc (I, C, B) Output (Caller, B)

99 99 Linguaggi di programmazione a scambio di messaggi Linda Moltiplicatore in Linda main process Output (‘A’, 1, (1,2,3)) righe prima matrice Output (‘A’, 2, (4,5,6)) Output (‘A’, 3, (7,8,9)) Output (‘B’, 1, (1,0,2)) colonne sec. matrice Output (‘B’, 2, (1,2,1)) Output (‘B’, 3, (1,1,1)) Output (“Next”,1) Next job counter for I in 1..3 loop for J in 1..3 loop Input (‘C’, I, J : integer, C: integer) Print C(I,J) end loop

100 100 Linguaggi di programmazione a scambio di messaggi Linda Moltiplicatore in Linda worker processes task body Workers is -----dichiarazioni dati locali begin loop Input (“Next”, Element) Output (“Next”, Element +1) exit when Element > 3*3 I := (Element -1)/3 +1 J := (Element -1) mod Row-tuple := Read (`A`, I, V1) Col-tuple := Read (`B`, J` V2) X := prodotto_interno (V1, V2) Output (`C`, I, J, X) end loop end Workers


Scaricare ppt "1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture."

Presentazioni simili


Annunci Google