1 concorrenza: hardware e software zarchitetture fortemente connesse architetture in cui n...
TRANSCRIPT
![Page 1: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/1.jpg)
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
![Page 2: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/2.jpg)
3
Linguaggi concorrenti: Linguaggi concorrenti: memoria condivisa vs memoria condivisa vs scambio di messaggiscambio di messaggi
Un programma concorrente scritto in un linguaggio che prevede la memoria condivisa e’ adatto:
quando più processi del linguaggio sono realizzati all’interno di un unico processo di sistema
nei sistemi operativi che forniscono “multithreading”
nei sistemi operativi che permettono la condivisione di moduli (come Unix)
nei sistemi a tempo reale e sistemi di controllo “embedded”
![Page 3: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/3.jpg)
4
Linguaggi concorrenti: Linguaggi concorrenti: memoria condivisa vs memoria condivisa vs scambio di messaggiscambio di messaggi
Un programma concorrente scritto in un linguaggio che prevede la memoria condivisa non e’adatto:
in sistemi multiutente in cui lo spazio degli indirizzi e’ separato e protetto
tra processi residenti su macchine diverse in un’architettura a rete
in sistemi distribuiti in cui e’ desiderabile mantenere un certa flessibilita’ sul loading dei processi (load balancing)
![Page 4: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/4.jpg)
5
Concorrenza: hardware e software
La realizzazione di scambio di comunicazione tra processiprocessi puo’ essere effettuata secondo due modalita’ duali:
in modo proceduraleprocedurale monitor (se esiste condivisione di
memoria) rendez-vous-esteso (se non esiste
memoria condivisa)
con scambio di messaggiscambio di messaggi
![Page 5: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/5.jpg)
6
Concorrenza: hardware e software
Struttura di un sistema procedurale
Dominio chiamante
Processo
Call monitor-name
Procedure 1
Procedure 2
Procedure n
MONITOR
DATI
![Page 6: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/6.jpg)
7
Concorrenza: hardware e software
Struttura di un sistema a scambio di messaggi
Process
SEND (request)
WAIT (reply)
Process
SEND (request)
WAIT (reply)
Procedura n
Procedura 2
Procedura 1 DATI
Procedureinterne
WAIT
call requested procedure
SEND reply
Process
![Page 7: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/7.jpg)
8
Scambio di messaggi:Classificazione
I meccanismi di comunicazione si possono classificare in base alle seguenti caratteristiche: designazione sorgente e
destinatariosimmetricaasimmetrica
tipo di sincronizzazionesend
• sincrona• asincrona• chiamata di procedura
receive• bloccante• non bloccante
![Page 8: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/8.jpg)
9
Scambio di messaggi:Primitive asincrone
Comunicazione asimmetricaasimmetrica Send non bloccantenon bloccante Receive bloccantebloccante Ogni processo ha una unica unica
coda di messaggicoda di messaggi a lui inviati, gestita FIFO
Send (mes, proc)proc := Receive (mes)
Send (mes, proc)proc := Receive (mes)
![Page 9: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/9.jpg)
10
WAITSEND
Processo A
Send (B,.. )
Processo B
Wait(., bid)
Primitive asincrone a scambio di Primitive asincrone a scambio di messaggiomessaggio
a livello kernela livello kernel
Le primitive di scambio di messaggi possono essere realizzate a livello di kernel (anche in un’
architettura a memoria condivisa).
![Page 10: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/10.jpg)
11
Semafori vs Scambio di Semafori vs Scambio di messaggimessaggi
(per sistemi con memoria (per sistemi con memoria condivisa)condivisa)
In un kernel a scambio di messaggi il kernel deve gestire il pool dei bufferpool dei buffer, e le code dei messaggicode dei messaggi => maggior complessita’ delle primitive
di kernel maggior memoria a disposizione del
kernel
In un kernel con semafori lo scambio di informazioni tra i processi deve essere fatto a livello delle applicazionilivello delle applicazioni => l’ onere (di tempo d’ esecuzione e di
memoria) e’ a carico dei processi interessati
il kernel e’ piu’ snello
![Page 11: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/11.jpg)
12
Implementazione di Scambio di messaggi
DimensioneDimensione dei messaggi dei messaggi lunghezza fissa a livello kernellunghezza fissa a livello kernel lunghezza variabile nei linguaggi ad lunghezza variabile nei linguaggi ad
alto livelloalto livello
BufferizzazioneBufferizzazione dei messaggi dei messaggi numero massimo della lunghezza numero massimo della lunghezza
delle codedelle code problema del deadlockproblema del deadlock messaggi persimessaggi persi
TecnicheTecniche di gestione della di gestione della memoria memoria messaggi grandi possono essere messaggi grandi possono essere
tenuti in segmenti o pagine passate tenuti in segmenti o pagine passate da sender a receiveerda sender a receiveer
tecniche copy-on-writetecniche copy-on-write
![Page 12: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/12.jpg)
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
![Page 13: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/13.jpg)
14
Primitive asincrone:Produttori-Consumatori
Process buffer;var coda_dati: <coda di elementi di tipoT>
coda_cons: <coda di nomi di processo>inf: Tcons, proc : processin : in_messout: out_mess
beginwhile true do
beginproc:= Receive (in)case in.specie ofdati: trattadato(informazione)pronto: trattasegnaleend
end
![Page 14: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/14.jpg)
15
Primitive asincrone:Produttori-Consumatori
trattadato(informazione)
begin
if <coda_cons vuota>
then
put (informazione, coda_dati)
else begin
cons :=get(coda_cons)
out:= in.informazione
Send (out,cons)
end
end
![Page 15: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/15.jpg)
16
Primitive asincrone:Produttori-Consumatori
trattasegnale
begin
if <coda_dati vuota>
then put(proc,coda_cons)
else
begin
inf :=get(coda_dati)
out:= inf Send (out,proc)
end
end
![Page 16: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/16.jpg)
17
Primitive asincrone:Produttori-Consumatori
Process produttore_i
var mess: in_mess; contenuto: T;
begin
mess.specie:=dati
while true do
begin
<produci dato>
mess.informazione:= contenuto
Send (mess, buffer)
end
end
![Page 17: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/17.jpg)
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)
<consuma mess2 >
end
end
![Page 18: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/18.jpg)
19
Primitive asincrone:Produttori-Consumatori
Variante primitiva Receive
si ricevono solo i messaggi che soddisfano la condizione B
se non esiste nessun messaggio che soddisfa la condizione B la Receive e’ bloccante
proc : = Receive (mess) when Bproc : = Receive (mess) when B
![Page 19: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/19.jpg)
20
Primitive asincrone:Produttori-Consumatori
Problemi Problemi realizzativi delle realizzativi delle primitive con la primitive con la ReceiveReceive selettiva:selettiva:
analoghi 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.
![Page 20: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/20.jpg)
21
Primitive asincrone:Produttori-Consumatori
Process buffer;var proc1, proc2 : process;
in1, in2: in_mess;out:= out_mess;
beginwhile true do
begin proc1:= Receive (in1)case in1.specie of dati: trattadato(informazione) pronto: trattasegnaleend
end
![Page 21: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/21.jpg)
22
Primitive asincrone:Produttori-Consumatori
Trattadato (informazione)
begin
proc2:= Receive (in2)
when in2.specie=pronto
out:= in1.informazione
Send (out, proc2)
end
![Page 22: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/22.jpg)
23
Primitive asincrone:Produttori-Consumatori
trattasegnale
begin
proc2 := Receive (in2)
when in2.specie = dati
out:= in2.informazione Send (out,proc1)
end
![Page 23: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/23.jpg)
24
Variazioni su scambio di Variazioni su scambio di messaggio asincronomessaggio asincrono
Primitive di domanda e rispostaPrimitive di domanda e risposta Piu’ code di messaggi per Piu’ code di messaggi per
processoprocesso PortePorte Canali: Canali: mailbox autonoma (detta anche
global port) con un suo nome proprio Broadcast e multicastBroadcast e multicast
I canali possono fornire una comunicazione “from anyonefrom anyone” e/o “to everyoneto everyone” a tutti i processi di un gruppo definito al momento della configurazione (broadcastbroadcast)
MulticastMulticast : capacita’ di inviare un messaggio a tutti i processi di un dato gruppo
![Page 24: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/24.jpg)
25
Variazioni su scambio di Variazioni su scambio di messaggiomessaggio
Piu’ code di messaggi per Piu’ code di messaggi per processoprocesso porte multiple per processoporte 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
![Page 25: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/25.jpg)
26
Variazioni su scambio di Variazioni su scambio di messaggiomessaggio
Porte di input e di output con Porte di input e di output con controllo dei tipicontrollo dei tipi
Porta di output Porta di input
Mittente
Send(m)
Ricevente
Wait(m)
Verifica di tipoa tempo di compilazione
Verifica di tipoa tempo di compilazione
Binding e verifica di tipoa tempo di configurazione
![Page 26: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/26.jpg)
27
Variazioni su scambio di Variazioni su scambio di messaggiomessaggio
Una sola porta di input e molte di outputUna 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)
![Page 27: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/27.jpg)
28
Variazioni su scambio di Variazioni su scambio di messaggiomessaggio
Ricevente
Wait(m)
Mittente
Send(m)
Mittente
Send(m)
Ricevente
Wait(m)
Mittente
Send(m)Global
Port
![Page 28: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/28.jpg)
29
Primitive asincrone:porte multiple
Piu’ porteporte 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;
![Page 29: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/29.jpg)
30
Primitive asincrone:Comandi con guardia
Comandi con guardieComandi con guardie
<guardia> -----> <istruzione>
guardia: espressione logica +
(guardia logica)primitiva Receive (guardia di input)
![Page 30: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/30.jpg)
31
Primitive asincrone: Comandi con guardia
La guardia viene valutata quando il comando viene eseguito; si possono avere i seguenti risultati:
guardia fallitafallitaguardia validavalidaguardia ritardataritardata
La guardia viene usata all’interno di comandi alternativi e di comandi ripetitivi.
![Page 31: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/31.jpg)
32
Primitive asincrone: Comandi con guardia
comando alternativo
if B1 --> istruzione1�B2 --> istruzione2... � Bn --> istruzionenendSe 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.
e di comandi ripetitivi.
![Page 32: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/32.jpg)
33
Primitive asincrone: Comandi con guardia
comando ripetitivo
do B1 --> istruzione1 � B2 --> istruzione2... � Bn --> istruzionenend
Il comando viene ripetuto fino a che tutte le guardie falliscono. In questo caso il comando termina.
![Page 33: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/33.jpg)
34
Primitive asincrone: Comandi con guardia
Problemi realizzativi Problemi realizzativi delle primitive con porte delle primitive con porte multiple (e/o guardie):multiple (e/o guardie):
supporto run time deve fornire tante supporto run time deve fornire tante code quante sono le portecode quante sono le porte
comandi con guardia richiedono la comandi con guardia richiedono la realizzazione di risveglio di un realizzazione di risveglio di un processo in attesa su un insieme di processo in attesa su un insieme di porteporte
un processo deve sospendersi su un un processo deve sospendersi su un insieme di porteinsieme di porte
![Page 34: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/34.jpg)
35
Primitive asincrone:Produttori-Consumatori
porte multiple
Process bufferport p-dati:T
p-controllo: signalvar inf: T
pronto:signalproduttore, consumatore:process
begindo 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
![Page 35: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/35.jpg)
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;
<consuma inf >
end
end
![Page 36: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/36.jpg)
37
Primitive asincrone:Produttori-Consumatori
porte multiple
Process produttore_i
var inf: T;
begin
while true do
begin
<produci contenuto>
inf:= contenuto
Send (inf) to buffer.p-dati
end
end
![Page 37: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/37.jpg)
38
Send asincrona:Produttori-Consumatori
con buffer limitato
Process bufferport p-dati:T
p-ctrl-p: signal p-ctrl-c: signal
var inf: Tok-p,ok-c,ok-s: signalproduttore, consumatore:processcontatore: integer (init. 0)
begindo
(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.inportodend
![Page 38: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/38.jpg)
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
<produci contenuto>
inf:= contenuto
Send (ok-p) to buffer.p-ctrl-p;
buffer:= Receive (ok-s) from okport
Send (inf) to p-dati
end
end
![Page 39: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/39.jpg)
40
Send asincronaSistema Pipelining
Tre processi provvedono alla:
lettura di N record da un file
elaborazione dei recordcreazione di un nuovo file
con i record modificati INPUT
ELABORA
OUTPUT
![Page 40: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/40.jpg)
41
Send asincronaSistema Pipelining
Program pipelinevar file1, file2: file of T;
Process Input;var buf: T;begin
reset (file1);for i := 1 to N do
beginRead (file1, buf)Send (buf,Elabora)end
end
![Page 41: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/41.jpg)
42
Send asincronaSistema Pipelining
Process Elabora;var bufin, bufout: T;
proc: process;
beginfor i := 1 to N do begin
proc := Receive (bufin)bufout :=Elabora (bufin)Send (bufout,Output)end
end
![Page 42: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/42.jpg)
43
Send asincronaSistema Pipelining
Process Output;var buf: T;
proc: process;
beginrewrite (file2)for i := 1 to N do begin
proc := Receive (buf)write(file2, buf)end
end
![Page 43: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/43.jpg)
44
Primitive sincrone a scambio di Primitive sincrone a scambio di messaggiomessaggio
a livello kernela livello kernel
SENDWAIT
Processo A
Send (B,.. )
Processo B
Wait(., bid)
![Page 44: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/44.jpg)
45
Primitive sincroneRendez-vous
Stato di un processo che esegue la Send(BO: bloccato per output)
Stato di un processo che esegue la Receive (BI: bloccato per input)
E
BO
E
BI
Invocazione
SendTrasmissione
messaggio Invocazione
Receive
Ricezione
messaggio
![Page 45: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/45.jpg)
46
Primitive sincroneRendez-vous
Mitt
E
BO
BO
E
Ric
BI
BI
BI
E
Posso mandarti un messaggio?
OK! manda
messaggio
![Page 46: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/46.jpg)
47
Primitive sincrone a scambio di Primitive sincrone a scambio di messaggiomessaggio
a livello kernela livello kernel
Le 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).
ClienteCliente
Send(request)
Wait (replay)
SERVIZIOSERVIZIO
Server
Wait (request)
<Do request>
Send(reply)
Processo di Interfaccia
![Page 47: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/47.jpg)
48
Primitive sincroneRendez-vous
Comunicazione asimmetricaasimmetrica Send bloccantebloccante Receive bloccantebloccante Non esistono code di code di
messaggimessaggi associati ai processi gestiti dal meccanismo di comunicazione
Send (mes, proc)proc := Receive (mes)
Send (mes, proc)proc := Receive (mes)
![Page 48: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/48.jpg)
49
Primitive sincroneProduttore- Consumatore
Process buffer;var coda: queue of T;
proc : process;ccpronto, ppronto: boolean (init. false);dati: T;pronto: signal
beginwhile true do
begin proc:= Receive (pronto)case proc of produttore: trattaprod consumatore: trattaconsend
end
![Page 49: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/49.jpg)
50
Primitive sincroneProduttore- Consumatore
trattaprodbegin
if <coda piena>
then ppronto := true
else begin
proc := Receive (dati)
if cpronto then begin
Send (dati, cons)
cpronto := false
end
else put(dati,coda)
end
end
![Page 50: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/50.jpg)
51
Primitive sincroneProduttore- Consumatore
trattasegnale
begin
if <coda vuota>
then cpronto := true
else begin
dati:=get(coda)
Send (dati,cons)
if ppronto then
begin
proc: =Receive (dati)
put(dati, coda)
ppronto := false
end
end
end
![Page 51: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/51.jpg)
52
Primitive sincroneProduttore- Consumatore
Process produttore
var dati: T;
pronto: signal
begin
while true do
begin
<produci dato>
Send (pronto, buffer)
Send (dati, buffer)
end
end
![Page 52: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/52.jpg)
53
Primitive sincroneProduttore- Consumatore
Process consumatore
var dati: T;
pronto: signal;
proc: process;
begin
while true do
begin
Send (pronto, buffer)
proc := Receive (dati)
<consuma dati >
end
end
![Page 53: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/53.jpg)
54
Primitive sincroneProduttore- Consumatore
con guardie
Process buffertype p-pronto = signal
c-pronto= signalvar coda: queue of T
datipronti: p-prontodatirichiesti: c-prontoproc: processdati : T
begindo
�(coda nonpiena); proc:= Receive(datipronti) _ proc:= Receive(dati)
put (dati, coda);
�(coda nonvuota); proc:=Receive(datirichiesti) get(dati,coda)
Send (dati, consumatore)
odend
![Page 54: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/54.jpg)
55
Primitive sincroneProduttore- Consumatore
con guardie (senza uso del segnale datipronti)
Process buffervar coda: queue of T
proc: processdati : Tcpronto:signal
begindo
�(coda nonpiena); proc:= Receive(dati) ; put (dati, coda);
� (coda nonvuota); proc:=Receive(cpronto) get(dati,coda)
Send (dati, consumatore)
odend
![Page 55: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/55.jpg)
56
Primitive sincroneProduttore- Consumatore
Process produttore
var dati: T;
begin
while true do
begin
<produci dato>
Send (dati, buffer)
end
end
![Page 56: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/56.jpg)
57
Primitive sincroneProduttore- Consumatoreguardie di input/output
Comandi con guardieComandi con guardie
per primitive sincroneper primitive sincrone
<guardia> -----> <istruzione>guardia: espressione logica
(guardia logica) +primitiva Receive (guardia di input)
oppure primitiva Send (guardia di output)
![Page 57: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/57.jpg)
58
Primitive sincroneProduttore- Consumatore
con guardie di input/output
Process buffervar coda: queue of T
proc: processdati : T
begindo
(� coda nonpiena); proc:= Receive(dati) ; put (dati, coda);
�(coda nonvuota); Send (first(coda),
consumatore) aggiorna coda
odend
![Page 58: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/58.jpg)
59
Primitive sincroneProduttore- 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) --> ………;
endproc := Receive (risposta)
![Page 59: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/59.jpg)
60
Primitive sincroneProduttore- Consumatore
con guardie di input/output
Att!!Att!!
Le guardie di output sono difficili da realizzaredifficili da realizzare e possono portare a deadlock.deadlock.
La validita’ di una guardia di output non garantisce che venga scelta l’istruzione associata alla guardia stessa
![Page 60: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/60.jpg)
61
Primitive sincroneProblema del deadlock
con guardie di input/output
Process Pvar x1,x2:T1; proc: processbegin x1:= valore if
Send � (x1,Q) --> …;� proc:= Receive(x2) -
> …;fi
end
Process Qvar x:T1; y : T2; proc:
processbeginy:= valore if
� proc:= Receive(x) -> Send � (y,R) --> …;fi
end
Process Rvar x:T1; y : T2; proc: processbeginy:= valore if
Send � (x,P) --> …;� proc:= Receive(y) -> …; fi
end
![Page 61: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/61.jpg)
62
Primitive sincroneProduttore- Consumatore
con buffer parallelo
Process produttorevar dati: T;begin
while true dobegin
<produci dato>Send (dati, buffer1)
endend
Process consumatorevar dati: T;
proc: process;begin
while true dobegin proc := Receive (dati)<consuma dati >
endend
![Page 62: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/62.jpg)
63
Primitive sincroneProduttore- Consumatore
con buffer parallelo
Process produttorevar dati: T;begin
while true dobegin
<produci dato>Send (dati, buffer1)
endend
Process consumatorevar dati: T;
proc: process;begin
while true dobegin proc := Receive (dati)<consuma dati >
endend
![Page 63: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/63.jpg)
64
Primitive sincroneProduttore- Consumatore
con buffer parallelo
Process buffer-ivar dati: T;
proc: process;begin
while true dobegin proc := Receive (dati)Send (dati, buffer-(i+1)) end
end
Process buffer-Nvar dati: T;
proc: process;begin
while true dobegin proc := Receive (dati)Send (dati, consumatore) end
end
![Page 64: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/64.jpg)
65
Primitive sincronecanali uno-uno
Send (mes, proc)Receive (mes, proc)Send (mes, proc)Receive (mes, proc)
•Comunicazione simmetricasimmetrica•Send bloccantebloccante•Receive bloccantebloccante•Mittente e ricevente devono conoscere il nome del processo con cui vogliono comunicare
![Page 65: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/65.jpg)
66
Send sincronaSistema Pipelining
Program pipelinevar file1, file2: file of T;
Process Input;var buf: T;begin
reset (file1);for i := 1 to N do
beginRead (file1, buf)Send (buf, Elabora)end
end
![Page 66: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/66.jpg)
67
Send sincronaSistema 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
end
![Page 67: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/67.jpg)
68
Rendez- vous estesoRemote Procedure Call
Meccanismo di tipo sincrono in cui il processo che richiede un servizio ad un altro processo rimane sospeso rimane sospeso
fino al completamento del serviziofino al completamento del servizio..
mittente ricevente
chiamata
attesa
accept
Inizio rendez-vous
Fine rendez-vous
Parametri input
Parametri output
![Page 68: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/68.jpg)
69
Rendez- vous estesoRemote Proceure Call
Primitiva dal lato clientecliente:call <servizio> (input, output)call <servizio> (input, output)
Primitiva dal lato servitoreservitore:
remote procedure <servizio> (in <…>out <…>)) var …; begin … end
accept <servizio> (in <…>out <…>))
--> S1, …,Sn
![Page 69: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/69.jpg)
70
Rendez-vous estesoProduttore- Consumatore
Process buffervar buff: array[0..N-1] of T
testa, coda :0..N-1 (init. 0)cont: 0..N (init. 0)
begindo
�(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;
odend
![Page 70: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/70.jpg)
71
Rendez-vous estesoProduttori- Consumatori
Process produttore-i
var dati: T;
begin
while true do
begin
<produci dato>
call buffer.inserisci (dati)
end
end
![Page 71: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/71.jpg)
72
Rendez-vous estesoProduttori- Consumatori
Process consumatore-j
var dati: T;
begin
while true do
begin
call buffer.preleva(dati)
<consuma dati>
end
end
![Page 72: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/72.jpg)
73
Rendez-vous estesoSegnalazione di sveglia
Process allarmevar tempo: integer
tempo-di-sveglia: array[1..N} of recordrisveglio:integerintervallo:integerend
begindo
� accept tick tempo := tempo + 1;
� accept richiesta-sveglia (in intervallo:integer) <inserimento tempo + intervallo
e intervallo in tempo di sveglia>
�(tempo = tempo di sveglia[1].risveglio);accept svegliami [tempo di sveglia[1].intervallo]; <riordinamento di tempo-di-sveglia>
odend
![Page 73: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/73.jpg)
74
Rendez-vous estesoPipeline
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
![Page 74: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/74.jpg)
75
Linguaggi di programmazione a scambio di messaggi
CSP
Communicating Sequential Communicating Sequential ProcessesProcesses
non e’ un vero e proprio linguaggio ma piuttosto un modello di interazione tra processi
notazione per la specifica di concorrenza
comunicazione sincrona
ricezione selettiva dei messaggi
![Page 75: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/75.jpg)
76
Linguaggi di programmazione a scambio di messaggi
CSP
Processi
<identificatore> :: <lista comandi><identificatore> :: <lista comandi>
Comando parallelo [<processo> [<processo>
//<processo>//…//<processo>]//<processo>//…//<processo>]
Invio di messaggi (Send) (Send)<destinatario> ! <espressione><destinatario> ! <espressione>
Ricezione di messaggi (Receive)(Receive)<sorgente> ? <variabile><sorgente> ? <variabile>
![Page 76: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/76.jpg)
77
Linguaggi di programmazione a scambio di messaggi
CSP
Schema di sincronizzazioneSchema di sincronizzazioneLa comunicazione puo’ essere stabilita se e La comunicazione puo’ essere stabilita se e solo se:solo se:
a) P contiene un comando di uscita e Q contiene a) P contiene un comando di uscita e Q contiene un comando di ingresso, ognuno specificante un comando di ingresso, ognuno specificante il nome del rispettivo partner il nome del rispettivo partner ((comunicazione simmetrica))
b) la variabile del comando di input e’ b) la variabile del comando di input e’ compatibile con l’ espressione del comando di compatibile con l’ espressione del comando di outputoutput
c) la sincronizzazione e’ a c) la sincronizzazione e’ a rendez-vous estesorendez-vous esteso
P :: P :: … ;… ; Q:: Q:: … ;… ;… … ;; … ;… ;Q!<exp>;Q!<exp>; P?<var> ;P?<var> ;… … ;; … ;… ;
(comandi corrispondenti)(comandi corrispondenti)
![Page 77: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/77.jpg)
78
Linguaggi di programmazione a scambio di messaggi
CSP
Schema di comunicazioneSchema di comunicazione Tra i due processi si individua un canale,
definito dalla terna:– nome mittentenome mittente– nome riceventenome ricevente– tipo del messaggiotipo del messaggio
La sequenzializzazione tra processi e’ data dai comandi alternativi alternativi e ripetitiviripetitivi con guardie: alternativo:
[ <guardia 1> --> <lista comandi1> …
<guardia � n> --> <lista comandi n>]
ripetitivo: * [<guardia 1> --> <lista comandi1> … <guardia � n> --> <lista comandi n>]
![Page 78: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/78.jpg)
79
Linguaggi di programmazione a scambio di messaggi
CSP
Linguaggi ispirati dai CSPLinguaggi ispirati dai CSPOCCAM (transputer)
processi comunicano tramite canali ad ogni canale è associato un tipo di
dato un canale connette due soli
processi: un processo di output ed un processo di input
comunicazione di tipo rendez-vous esteso
processi statici
![Page 79: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/79.jpg)
80
Linguaggi di programmazione a scambio di messaggi
CSP
Linguaggi ispirati dai CSPLinguaggi ispirati dai CSPOCCAM (sintassi)
ogni statement è considerato un processo
il programmatore deve esplicitare l’esecuzione parallela o sequenziale:
SEQ PARstat1 stat1stat2 stat2stat3
comunicazione denotata con ? e ! channel ? var channel ! value
![Page 80: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/80.jpg)
81
Linguaggi di programmazione a scambio di messaggi
CSP
Linguaggi ispirati dai CSPLinguaggi ispirati dai CSPOCCAM
Prodotto di matrici
1 2 3
4 5 6
7 8 9
1 0 2
0 1 2
1 0 0
4 2 6
10 5 18
16 8 30
*
=
![Page 81: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/81.jpg)
82
Linguaggi di programmazione a scambio di messaggi
CSP
Linguaggi ispirati dai CSPLinguaggi ispirati dai CSPOCCAM
Prodotto di matrici
44
11
77 88 99
SINKSINK
RISRIS
RIS
RIS
SRC SRC SRC
1,0,2 0,1,2 1,0,0
ZERO
ZERO
ZERO
2 3
5 6
SINK 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
![Page 82: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/82.jpg)
83
Linguaggi di programmazione a scambio di messaggi
CSP
Linguaggi ispirati dai CSPLinguaggi ispirati dai CSPMoltiplicatore per matrici:
Prendere un elemento da NORDPassarlo a SUDMoltiplicarlo per valPrendere il valore somma parziale da ESTSommare aggiornare il valoreMandare il risultato OVEST
SSSS
val
NN
EEOO
![Page 83: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/83.jpg)
84
Linguaggi di programmazione a scambio di messaggi
CSP
Moltiplicatore in OCCAMa) WHILE TRUE
SEQnorth ? xsouth ! xeast ?sumsum := sum + a * xwest ! sum
b) north ? x WHILE TRUE
SEQ PAR
south ! xeast ? sumtmp := a * x
PARwest ! sum + tmpnorth ? x
![Page 84: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/84.jpg)
85
Linguaggi di programmazione a scambio di messaggi
DP
Distributed ProcessesDistributed Processes
linguaggio basato su RPC
proposto per applicazioni in tempo reale
un sistema e’ visto come un insieme di processi concorrenti che “vivono insieme” per tutta la durata del sistema
![Page 85: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/85.jpg)
87
Linguaggi di programmazione a scambio di messaggi
ADA
linguaggio studiato soprattutto per applicazioni in tempo reale
notazione per la specifica di concorrenza: task
comunicazione asimmetrica e sincrona
remote procedure call
![Page 86: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/86.jpg)
88
Linguaggi di programmazione a scambio di messaggi
ADA
Schema di comunicazioneSchema di comunicazionedalla parte del server:
accept <servizio> (in <…>out <…>))
do S1, …,Sn end
l’ accept puo’ essere selettiva:
selectaccept entry1 do, …, end
or accept entry2 do, …, end… or accept entryn do, …, endend select
![Page 87: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/87.jpg)
89
Linguaggi di programmazione a scambio di messaggi
ADA
si possono usare guardie logiche:
selectwhen B1 ---> accept
entry1 …, or when B2 --->accept entry2 …, …or when Bn ---> accept entryn …, end select
![Page 88: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/88.jpg)
90
Linguaggi di programmazione a scambio di messaggi
ADA
Schema di comunicazioneSchema di comunicazionedalla parte del client:
le chiamate alle entry del server sono effettuate con la notazione “.”
server. Entryname
e’ possibile una chiamata condizionale: select
<chiamata di una entry>else <comandi>
end select
la chiamata viene effettuata solo se il server e’ in attesa su quella entry
![Page 89: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/89.jpg)
91
Linguaggi di programmazione a scambio di messaggi
ADA
Esempio : Implementazione semaforo
task body SEMAPHORE is count : integerbegin
accept Init (N:integer) do count := Nloop
selectwhen count >0 =>
accept WAIT do count := count -1
endor
accept SIGNAL do count := count +1end
end select end loop
end SEMAPHORE
![Page 90: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/90.jpg)
92
Linguaggi di programmazione a scambio di messaggi
ADA
Moltiplicatore
task body MULTIPLIER isX, Sum: array[1. .n] A: integerNord, Sud, Est, Ovest: task
beginaccept Init (I:integer; N,S,E,O:channel) do
A:= INord:= N; Sud:= S; Est:= E; Ovest:= O
endloop
accept Input (Nord) (I: array[1. .n] ) do X:= IendSud.Output (X)accept Input (Est) (I: array[1. .n] ) do Sum := IendSum := Sum + A*XOvest.Output (Sum)
endend
![Page 91: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/91.jpg)
93
Linguaggi di programmazione ADA
Implementazione del Rendez-vous
selectwhen 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)
![Page 92: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/92.jpg)
94
Linguaggi di programmazione a scambio di messaggi
Linda
Linda è un linguaggio concorrente radicalmente diverso di precedenti
Nei linguaggi tipo Ada e Occam, i processi comunicano mediante un rendez-vous sincrono; essi sono accoppiati nel tempo e nello spazio:
tempo: sincronia spazio: indirizzo del canale
Linda 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):
(1, “A”) (integer, character) (1, 2) (integer, integer)
![Page 93: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/93.jpg)
95
Linguaggi di programmazione a scambio di messaggi
Linda
Le primitive di Linda sono: Output (T): aggiunge la tupla t allo
spazio di tuple Input (T): rimuove dallo spazio di
tuple una tupla matching con T, se tale tupla non esiste il processo viene sospeso
Read (T): come il precedente, ma senza rimozione
Try-Input (T): versione non bloccante dell’ Input (T)
Try-Read (T): versione non bloccante della Read (T)
![Page 94: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/94.jpg)
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
![Page 95: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/95.jpg)
97
Linguaggi di programmazione a scambio di messaggi
Linda
Esempio1: Richiesta di uno specifico servizio da parte
di un processo. Le tuple hanno tre elementi: stringa che identifica richiesta di servizio intero che identifica il tipo di servizio identificativo 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/
![Page 96: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/96.jpg)
98
Linguaggi di programmazione a scambio di messaggi
Linda
Esempio2: Rendez-vous (tipo ADA):
accept Proc (I: in integer,
C: in character, B: out Boolean)
….
end
call Proc (65, “X”, B) Le tuple hanno i seguenti campi:
stringa contenente il nome del servizio nome del processo chiamante due 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)
![Page 97: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/97.jpg)
99
Linguaggi di programmazione a scambio di messaggi
Linda
Moltiplicatore in Lindamain 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.
matriceOutput (‘B’, 2, (1,2,1))Output (‘B’, 3, (1,1,1))
Output (“Next”,1) Next job counter
for I in 1. .3 loopfor J in 1. .3 loop
Input (‘C’, I, J : integer, C: integer)Print C(I,J)
end loopend loop
![Page 98: 1 Concorrenza: hardware e software zArchitetture fortemente connesse architetture in cui n processori (n > 1) condividono memoria centrale e clock zArchitetture](https://reader036.vdocuments.pub/reader036/viewer/2022070313/5542eb76497959361e8dfc72/html5/thumbnails/98.jpg)
100
Linguaggi di programmazione a scambio di messaggi
Linda
Moltiplicatore in Lindaworker processes
task body Workers is-----dichiarazioni dati locali -----begin
loopInput (“Next”, Element)Output (“Next”, Element +1)exit when Element > 3*3I := (Element -1)/3 +1 J := (Element -1) mod 3 + 1Row-tuple := Read (`A`, I, V1)Col-tuple := Read (`B`, J` V2)X := prodotto_interno (V1, V2)Output (`C`, I, J, X)
end loopend Workers