Mechanizmy komunikacji

Mechanizmy komunikacji
spotkania symetryczne (język CSP)
z spotkania asymetryczne (Ada)
z przestrzenie krotek (Linda)
z potoki, komunikaty i kanały (Unix)
z
Język CSP
Hoare (1978r.) Communicating Sequential Processes
Nowy język do zapisu procesów współbieżnych
z prostota – 4 instrukcje proste (przypisanie, pusta,
wejścia, wyjścia)
z 2 instrukcje strukturalne (alternatywa, pętla)
z mechanizm spotkań symetrycznych
z możliwe równoległe wykonywanie instrukcji w
ramach procesu
z możliwość parametryzowania procesów
Program w CSP
[ P1::<treść procesu P1> || P2::<treść P2> || ... ||
Pn::<treść Pn> ]
II – oznacza równoległość procesów
P1, P2, ..., Pn – etykiety procesów
Możliwość parametryzowania procesów:
P(k:1..N):: <treść zależna od zmiennej związanej k>
daje w wyniku N procesów P(1),...,P(N).
Instrukcje języka CSP (1)
Instrukcja przypisania
• zwykła
x := n
• jednoczesna (x,y,z) := (2a+1, b+c, a-2c)
Instrukcja pusta – słowo kluczowe skip
(niezbędna przy wykorzystaniu alternatywy)
Instrukcje języka CSP (2)
Alternatywa – uogólnienie instrukcji warunkowej
[ D1->I1 [] D2->I2 [] ... [] Dn->In ]
•
•
Di – dozory (ciągi warunków logicznych oddzielonych średnikami –
operator and)
Ii – niepuste ciągi instrukcji oddzielone średnikami – operator następstwa
Wykonanie:
- równoczesne obliczenie wszystkich dozorów
- wybranie jednego z dozorów spełnionych (niedeterministyczne)
- wykonanie następujących po nim instrukcji
Brak spełnionych dozorów zatrzymuje wykonywanie programu (błąd)
Instrukcja alternatywy
Przykład:
[x=1->x:=x+3 [] x>4->y:=2x [] x<0->x:=abs(x)]
Możliwość parametryzowania – przykład:
(p:1..5) x<2*p -> y:=fp(x)
Efekt instrukcji warunkowej if w then I:
[ w -> I [] not w -> skip ]
Instrukcje języka CSP (3)
Instrukcja pętli - *alternatywa
*[ D1->I1 [] D2->I2 [] ... [] Dn->In ]
Wykonywana tak długo, aż nie będzie spełniony żaden dozór
Wykonanie równoległe instrukcji
I1 || I2 || ... || In
comment – słowo kluczowe oznaczające komentarz
Komunikacja między procesami
Mechanizm spotkania symetrycznego:
nadawca A – instrukcja wyjścia B!X(y1...yn)
• odbiorca B – instrukcja wejścia A?X(z1...zn)
•
Procesy muszą wzajemnie znać swoje nazwy.
Pominięcie wyrażeń y i z w instrukcjach daje mechanizm
synchronizacji
Idea spotkania
Proces A
Proces B
B!paczka(5,3,6,8)
A?paczka(x1,x2,x3,x4)
Instrukcje wykonywane tylko wspólnie (czekanie na drugiego)
Problem producenta-konsumenta
(bez bufora)
[ PRODUCENT::
p:porcja;
*[true -> produkuj(p); KONSUMENT!p];
|| KONSUMENT::
p:porcja;
*[PRODUCENT?p -> konsumuj(p);]
]
porcja – typ przekazywanego elementu
Instrukcja wejścia Q?.. w dozorach procesu P:
• true – jeśli Q czeka na wykonanie odpowiedniej instrukcji wyjścia P!...
• false – jeśli Q nie istnieje
• zawiesza P do chwili, gdy Q dojdzie do instrukcji wyjścia
W jednym dozorze może wystąpić tylko jedna instrukcja wejścia i
musi być to ostatnia instrukcja dozoru!
Problem producenta-konsumenta
(z buforem jednoelementowym)
[ PRODUCENT::
p:porcja;
*[true -> produkuj(p); BUFOR!p];
|| BUFOR::
p:porcja;
*[PRODUCENT?p -> KONSUMENT!p;]
|| KONSUMENT::
p:porcja;
*[BUFOR?p -> konsumuj(p);]
]
W CSP procesy nie mogą komunikować się przez wspólną pamięć –
konieczne wprowadzenie procesu BUFOR
Bufor N-elementowy?
ćwiczenie
Modelowanie procesów
współbieżnych
11
Język Ada
Język programowania głównie systemów czasu
rzeczywistego (przeważnie współbieżnych)
Bardzo rozbudowany, złożona skrajnia
Brak pełnego kompilatora dla PC (kłopotliwa realizacja
współbieżności)
Standard zapisu programów współbieżnych w publikacjach
naukowych
Mechanizm spotkań asymetrycznych
Wzorowane na spotkaniach z CSP
Dodatkowe obliczenia wykonywane w jednym z procesów
(proces obsługujący – serwer)
Serwer udostępnia procesowi obsługiwanemu (klientowi)
różne miejsca spotkań, widoczne w postaci wejść
(entries).
Klient musi znać nazwę serwera, serwer nie zna klientów.
Przykład – serwer liczący pierwiastek
task (proces) A
B.PRW(5,y)
task (proces) B
...
entry SQRT(n in:Integer; y: out real);
accept PRW(n in:Integer; y: out real);
y:=sqrt(n);
end;
Modelowanie procesów
współbieżnych
14
Problem czytelników i pisarzy
(package – pakiet deklaracji danych i procedur
udostępnianych innym)
procedure czytanie(x: out Integer);
procedure pisanie(x: in Integer);
end;
package czytelnia is
package body czytelnia is
książka: Integer;
task PORTIER is
(task definiuje proces)
entry ZACZYNAM;
entry KOŃCZĘ;
entry PISZĘ(x: in Integer);
end;
procedure czytanie(x: out Integer) is
PORTIER.ZACZYNAM;
x:=książka;
procedure pisanie(x: in Integer) is
PORTIER.KOŃCZĘ;
PORTIER.PISZĘ(x);
end czytanie;
end pisanie;
Problem czytelników i pisarzy cd.
task body PORTIER is
ilu_czyta: Integer:=0;
liczba czytających
begin loop
count – liczba procesów
select
czekających na spotkanie
when PISZĘ’count = 0 =>
w tym wejściu
accept ZACZYNAM;
ilu_czyta:=ilu_czyta+1;
or
accept KOŃCZĘ;
ilu_czyta:=ilu_czyta-1;
or
when ilu_czyta = 0 =>
accept PISZĘ(x: in Integer) do
książka := x;
end PISZĘ;
loop
select
accept ZACZYNAM;
ilu_czyta:=ilu_czyta+1;
else exit;
end select;
end loop; end select; end loop; end PORTIER;
Przestrzeń krotek w Lindzie (1)
Linda – idea komunikacji, której realizację można włączyć
do dowolnego języka programowania
Podstawowe pojęcia:
krotka – ciąg danych, z których każdy ma określony typ.
Dane nie muszą być określone.
sygnatura krotki – ciąg typów poszczególnych elementów
krotki
Procesy realizują się w środowisku – przestrzeni krotek.
operacje INPUT, OUTPUT, READ, TRY_INPUT, TRY_OUTPUT
Nie narzuca powiązań czasowych ani w przestrzeni
adresowej (procesy nie muszą się znać)
Przestrzeń krotek w Lindzie (2)
Proces A
Przestrzeń krotek
Proces B
(4, 2)
(6, 1.3)
OUTPUT(‘A’)
(‘B’)
(‘a’, true, 1)
INPUT(5, x:real)
(‘S’)
(5, 2.71)
Problem 5 filozofów
Próba 1
Program filozofy;
var
widelec:array[0..4] of (*binary*) semaphore;
i:integer;
procedure filozof(i:integer);
begin
repeat
myśl;
wait(widelec[i]);
wait(widelec[(i+1)mod 5]);
jedz;
signal(widelec[i]);
signal(widelec[(i+1)mod 5]);
forever
end;
begin
(program główny)
for i:=0 to 4 do widelec[i]:=1;
cobegin
filozof(0); filozof(1); filozof(2); filozof(3); filozof(4);
coend
end.
Modelowanie procesów
współbieżnych
20
Próba 1 – komentarz
Semafory zapewniają wzajemne wykluczanie przy
dostępie do widelców
Zapewnione bezpieczeństwo (jedzenie po
zakończeniu oczekiwania na 2 widelce-semafory)
Możliwość blokady
Jeśli filozofowie się zsynchronizują i równocześnie biorą
lewe widelce
Próba 2
Program filozofy;
liczba widelców
monitor mon_widelec;
danemu
var
widelec:array[0..4] of integer;
można_jesc:array[0..4] of condition;
i:integer;
procedure weź_widelec(i:integer)
begin
if widelec[i]<>2 then wait(można_jesc[i]);
widelec[(i+1)mod 5]:=widelec[(i+1)mod 5]-1;
widelec[(i-1)mod 5]:=widelec[(i-1)mod 5]-1;
end;
procedure odłóż_widelec(i:integer)
begin
widelec[(i+1)mod 5]:=widelec[(i+1)mod 5]+1;
widelec[(i-1)mod 5]:=widelec[(i-1)mod 5]+1;
if widelec[(i+1)mod 5]=2 then signal(można_jesc[(i+1)mod
if widelec[(i-1)mod 5]=2 then signal(można_jesc[(i-1)mod
end;
Modelowanie procesów
współbieżnych
dostępnych
filozofowi
5]);
5]);
22
Próba 2 cd.
procedure filozof(i:integer);
begin
repeat
myśl;
weź_widelec[i];
jedz;
odłóż_widelec[i];
forever
end;
begin
(program główny)
for i:=0 to 4 do widelec[i]:=2;
cobegin
filozof(0);
filozof(1);
filozof(2);
filozof(3);
filozof(4);
coend
end.
Modelowanie procesów
współbieżnych
23
Próba 2 – komentarz
Zastosowanie monitora
Filozof bierze widelce, gdy oba są dostępne
Zapewnione wzajemne wykluczanie i bezpieczeństwo
Niemożliwa blokada
Możliwe zagłodzenie
Jeśli dwaj filozofowie „zmówią się” i nie dopuszczą
siedzącego między nimi do jedzenia
Rozwiązanie poprawne
Oparte na pierwszej próbie
Dodatkowy semafor odgradzający lokaj gwarantuje,
że co najwyżej czterech filozofów próbuje wziąć
widelce.
Rozwiązanie nie dopuszcza blokady i zagłodzenia
Rozwiązanie poprawne - kod
Program filozofy;
var
widelec:array[0..4] of (*binary*) semaphore;
lokaj: semaphore;
i:integer;
procedure filozof(i:integer);
begin
repeat
myśl;
wait(lokaj);
begin
(program główny)
wait(widelec[i]);
lokaj:=4;
wait(widelec[(i+1)mod 5]);
for i:=0 to 4 do widelec[i]:=1;
jedz;
cobegin
signal(widelec[i]);
filozof(0);
signal(widelec[(i+1)mod 5]);
filozof(1);
signal(lokaj);
filozof(2);
forever
filozof(3);
end;
filozof(4);
coend
end.
Modelowanie procesów
współbieżnych
26