Mechanizmy komunikacji

Mechanizmy komunikacji
• spotkania symetryczne (język CSP)
• spotkania asymetryczne (Ada)
• przestrzenie krotek (Linda)
• potoki, komunikaty i kanały (Unix)

Język CSP
Hoare (1978r.) Communicating Sequential Processes
Nowy język do zapisu procesów współbieżnych
• prostota – 4 instrukcje proste (przypisanie, pusta,
wejścia, wyjścia)
• 2 instrukcje strukturalne (alternatywa, pętla)
• mechanizm spotkań symetrycznych
• możliwe równoległe wykonywanie instrukcji w
ramach procesu
• możliwość parametryzowania procesów

Program w CSP
[ P1:: || P2:: || ... ||
Pn:: ]
II – oznacza równoległość procesów
P1, P2, ..., Pn – etykiety procesów
Możliwość parametryzowania procesów:
P(k:1..N)::
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 [] xx:=abs(x)]
Możliwość parametryzowania – przykład:
(p:1..5) x y:=f p (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
task (proces) B
...
entry SQRT(n in:Integer; y: out real);
B.PRW(5,y)
accept PRW(n in:Integer; y: out real);
end;
y:=sqrt(n);
Modelowanie procesów
współbieżnych 14

Problem czytelników i pisarzy
package czytelnia is
(package – pakiet deklaracji danych i procedur
udostępnianych innym)
procedure czytanie(x: out Integer);
procedure pisanie(x: in Integer);
end;
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;
PORTIER.KOŃCZĘ;
end czytanie;
procedure pisanie(x: in Integer) is
PORTIER.PISZĘ(x);
end pisanie;

Problem czytelników i pisarzy cd.
task body PORTIER is
ilu_czyta: Integer:=0;
liczba czytających
begin loop
select
count – liczba procesów
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’)
(‘S’)
INPUT(5, x:real)
(‘a’, true, 1)
(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

Program filozofy;
monitor mon_widelec;
var
Próba 2
widelec:array[0..4] of integer;
można_jesc:array[0..4] of condition;
i:integer;
liczba widelców dostępnych
danemu filozofowi
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 5]);
if widelec[(i-1)mod 5]=2 then signal(można_jesc[(i-1)mod 5]);
end;
Modelowanie procesów
współbieżnych 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);
wait(widelec[i]);
begin
(program główny)
wait(widelec[(i+1)mod 5]); lokaj:=4;
jedz;
signal(widelec[i]);
signal(widelec[(i+1)mod 5]);
signal(lokaj);
forever
end;
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 26