Concurrency: concurrent execution1 ©Magee/Kramer const N = 1 intervallo T = 0..N intervallo R =...

Concurrency: concurrent execution 1©Magee/Kramer

const N = 1intervallo T = 0..Nintervallo R = 0..2*N

SUM = (in[a:T][b:T]->TOTAL[a+b]),TOTAL[s:R] = (out[s]->SUM).

FSP - dichiarazione di costanti e di intervalli

L’uso di indici serve per modellare calcoli in.0.0

in.0.1in.1.0

in.1.1

out.0

out.1

out.2

0 1 2 3


SOMMA CON RETI DI PETRI

Se l’ordine di lettura viene considerato nella definizione degli statila coppia (1,0) è diversa dalla coppia (0,1):

Leggo 0,0 Leggo 0,1Leggo 1,0

Leggo 1,1

Stampo 0 Stampo 1 Stampo 2

Leggo 0,0 Leggo 0,1 Leggo 1,0Leggo 1,1

Stampo 0 Stampo 1 Stampo 1 Stampo 2


Capitolo 3

Processi concorrenti


Esecuzione concorrente

Concetti: processi - esecuzione concorrente e alternanza (interleaving).

Interazione di processi.

Modelli: composizione parellela di processi asincroni - interleaving

interazione - azioni condiviselabeling di processi, relabeling di azioni e hidingstructure diagrams

Pratica: programmi Java con Multithread


Definizioni

Concorrenzacomputazioni logicamente

simultanee.Non implica multipli processori Richiede esecuzione “alternata” su un singolo processore

A

Tempo

B

C

Sia la concorrenza sia il parallelismo richiedono un accesso controllato a risorse condivise. Nel libro di testo i termini parallelo e concorrente sono utilizzati come sinonimi.Un azione a è concorrente a un’azione b se il loro ordine di esecuzione è indifferente

Processore condiviso da tre processiParallelismocomputazioni fisicamente

simultanee.Richiede multipli processori


Modellare la concorrenza

Si riesce a modellare la velocità di esecuzione? Velocità arbitraria

(il tempo NON è modellato)

Come si modella la concorrenza? Ordine relativo delle azioni di processi differenti è arbitrario

(alternanza dei processi MA conservazione della sequenza

di azioni in ogni processo)

Qual’è il risultato? Modello generale indipendente dallo scheduling

(modello di esecuzione asincrona)


Composizione parallela - alternanza di azioni

thinktalkscratchthinkscratchtalkscratchthinktalk

Se P e Q sono processi allora (P||Q) rappresenta l’esecuzione concorrente di P e Q. L’operatore || è denominato operatore di composizione parallela.

ITCH = (scratch->STOP).CONVERSE = (think->talk->STOP).

||CONVERSE_ITCH = (ITCH || CONVERSE).

Possibili sequenze di azioni risultanti da un’alternanza dei processi.


Composizione parallela - alternanza di azioni Modello LTS

ITCH

scratch

0 1

2 stati

CONVERSEthink talk

0 1 2

3 stati

2 3 statifrom CONVERSEfrom ITCH

CONVERSE_ITCH

scratch

think

scratch

talk scratch

talk think

0 1 2 3 4 5

(0,0)

(0,1)

(0,2)

(1,2)

(1,1)

(1,0)

Descrizione del“comportamento”


Composizione parallela - alternanza di azioni Modello Reti SA

scratch

ITCH

think

talk

CONVERSE

CONVERSE-ITCH ?

think

talk

scratch

fork

join


Composizione parallela - proprietà algebriche

Commutativa: (P||Q) = (Q||P)Associativa: (P||(Q||R)) = ((P||Q)||R)

= (P||Q||R).


Modellare l’interazione - azioni condivise

MAKER = (make->ready->MAKER).USER = (ready->use->USER).

||MAKER_USER = (MAKER || USER).

MAKER si sincronizza con USER quando ready.

Se due processi che devono essere composti hanno delle azioni in comune, queste azioni sono dette condivise. Per mezzo di azioni condivise si modella l’interazione tra processi. Mentre le azioni non condivise possono essere alternate in modo arbitrario, un’azione condivisa deve essere eseguita nello stesso istante da tutti i processi che vi partecipano


Modelli

make ready use

used

0 1 2 3

make

use

use

LTS

RETI SA

make

ready

MAKER

ready

use

USER

use

Ready

make

MAKER-USER


labeling di processi

a:P pone il prefisso a ad ogni etichetta di azione dell’alfabeto del processo P.

SWITCH = (on->off->SWITCH).

||DOPPIO_SWITCH = (a:SWITCH || b:SWITCH).

Due istanze di un processo “switch”:

||SWITCHES(N=3) = (forall[i:1..N] s[i]:SWITCH).||SWITCHES(N=3) = (s[i:1..N]:SWITCH).

Un array di istanze del processo switch :

a:SWITCHa.on

a.off

0 1b:SWITCH

b.on

b.off

0 1


process labeling by a set of prefix labels

{a1,..,ax}::P sostituisce ogni etichetta n di azione nell’alfabeto di P con le etichette a1.n,…,ax.n. Inoltre, ogni transizione (n->X) nella definizione di P è sostituita dalle transizioni ({a1.n,…,ax.n} ->X).

Il prefisso di processi è utile per modellare risorse condivise:RISORSA = (riserva->rilascia->RISORSA).

UTENTE = (riserva->usa->rilascia->UTENTE).

||CONDIVISIONE DI RISORSE = (a:UTENTE || b:UTENTE || {a,b}::RISORSA).


Prefissi di processi per risorse condivise

a:USERa.acquire a.use

a.release

0 1 2a:UTENTE

a:riserva a:usa

a:rilascia

b:USERb.acquire b.use

b.release

0 1 2

b:UTENTEb:riserva b:usa

b:rilascia

RESOURCE_SHARE

a.acquire

b.acquire b.use

b.release

a.use

a.release

0 1 2 3 4

a:riserva

a:usa

a:rilascia

b:rilascia

b:usab:riserva

CONDIVISIONE DI

RISORSE

{a,b}::RESOURCEa.acquireb.acquire

a.releaseb.release

0 1

a:riservab:riserva

a:rilasciab:rilascia

RISORSA


Prefissi di processi per risorse condivise

riserva

non disponibile

rilascia

disponibile

riserva

usa

rilascia

riserva

usa

rilascia

disponibile

non disponibile

riserva

usa

rilascia


relabeling di azioni

Queste funzioni assicurano che processi composti possano essere sincronizzati su azioni particolari

Le funzioni di relabeling sono applicate ai processi per rinominare le azioni. La forma generale di una funzione di relabeling è la seguente: /{newlabel_1/oldlabel_1,… newlabel_n/oldlabel_n}.

CLIENT = (call->wait->continue->CLIENT).SERVER = (request->service->reply->SERVER).



||CLIENT_SERVER = (CLIENT || SERVER) /{call/request, reply/wait}.

CLIENTcall reply

continue

0 1 2SERVER

call service

reply

0 1 2

CLIENT_SERVERcall service reply

continue

0 1 2 3



wait

call

continue

request

service

reply

call

continue

service

reply


relabeling di azioni - etichette prefisso

SERVERv2 = (accept.request ->service->accept.reply->SERVERv2).CLIENTv2 = (call.request ->call.reply->continue->CLIENTv2).

||CLIENT_SERVERv2 = (CLIENTv2 || SERVERv2) /{call/accept}.

Una formulazione alternativa del sistema client server è descritta sotto per mezzo di etichette qualificate o prefisso :


hiding di azioni - astrazione per ridurre la complessità

Applicato a un processo P, l’operatore di hiding \{a1..ax} rimuove i nomi di azioni a1..ax dall’alfabeto di P e rende queste azioni celate "silenti". Le azioni silenti sono etichettate tau. Azioni silenti in processi distinti NON sono condivise.

Applicato a un processo P, l’operatore di interfaccia @{a1..ax} nasconde tutte le azioni nell’alfabeto di P che NON appaiono nell’insieme a1..ax.

Talvolta è più appropriato specificare l’insieme di azioni che devono essere mostrate .... (operatore complementare)


Hiding di azioni

UTENTE = (riserva->usa->rilascia->UTENTE) \{usa}.

UTENTE = (riserva->usa->rilascia->UTENTE) @{riserva,rilascia}.

Le seguenti definizioni sono equivalenti:

La minimizzazione rimuove azioni tau nascoste per produrre un LTS con comportamento osservabile equivalente.

acquire tau

release

0 1 2

riserva usa

rilascia

acquire

release

0 1

riserva

rilascia


structure diagrams

P a

bProcesso P conalfabeto {a,b}.

P a b Qm

Composizione Parallela(P||Q) / {m/a,m/b,c/d}c dc

x xx

P Qa

S

yxComposite process||S = (P||Q) @ {x,y}

Concurrency: concurrent execution1 ©Magee/Kramer const N = 1 intervallo T = 0..N intervallo R =...

Documents

Transcript of Concurrency: concurrent execution1 ©Magee/Kramer const N = 1 intervallo T = 0..N intervallo R =...