Czas wirtualny, złożoność algorytmów

Czas wirtualny, złożoność algorytmów Wykład prowadzą: Jerzy Brzeziński Jacek Kobusiński Zegary logiczne skalarne wektorowe Kanały FIFO typu FC Rząd funkcji, funkcja kosztu Plan wykładu Złożoność komunikacyjna i czasowa algorytmu Warunki poprawności algorytmu Czas wirtualny, złożoność algorytmów (2) Czas wirtualny () Czas wirtualny (2) Zegary realizowane w systemach asynchronicznych mają stanowić aproksymację czasu rzeczywistego. Aproksymacja taka uwzględnia jedynie zachodzące w systemie zdarzenia i dlatego czas ten nazywany jest czasem wirtualnym (logicznym). W odróżnieniu od czasu rzeczywistego upływ czasu wirtualnego nie jest więc autonomiczny, a zależy od występujących w systemie zdarzeń i stąd określone wartości czasu wirtualnego mogą nigdy nie wystąpić. Czas wirtualny wyznacza się za pomocą zegarów logicznych (ang. logical clocks). Czas wirtualny, złożoność algorytmów () Czas wirtualny, złożoność algorytmów (4)

Zegar logiczny - definicja Zegary logiczne - właściwości Zegar logiczny systemu rozproszonego jest funkcją T : Λ Y, odwzorowującą zbiór zdarzeń Λ w zbiór uporządkowany Y, taką że: ( a' ) (T()<T(' ) ) (4.) gdzie < jest relacją porządku na zbiorze Y. Należy zauważyć, że w ogólności relacja odwrotna nie musi być spełniona, tzn.t()<t(' ) a'. jeżeli zdarzenie zachodzi przed ' w tym samym procesie, to wówczas wartość zegara logicznego odpowiadającego zdarzeniu jest mniejsza od wartości zegara odpowiadającego zdarzeniu ' w przypadku przesyłania wiadomości M, czas logiczny przyporządkowany zdarzeniu nadania wiadomości M jest zawsze mniejszy niż czas logiczny przyporządkowany zdarzeniu odbioru tej wiadomości Czas wirtualny, złożoność algorytmów (5) Czas wirtualny, złożoność algorytmów (6) Zegar skalarny definicja Realizacja zegarów skalarnych Jeżeli przeciwdziedzina Y funkcji zegara logicznego jest zbiorem liczb naturalnych N lub rzeczywistych R, to zegar nazywany jest zegarem skalarnym. Funkcja T() implementowana jest przez zmienne naturalne clock i, i n, skojarzone z procesami P i (monitorami Q i ). Wartość zmiennej clock i reprezentuje w każdej chwili wartość funkcji T( ik ) odnoszącą się do ostatniego zdarzenia k i jakie zaszło w procesie P i, a tym samym reprezentuje upływ czasu logicznego w tym procesie. Czas wirtualny, złożoność algorytmów (7) Czas wirtualny, złożoność algorytmów (8)

Alg. Lamporta () Alg. Lamporta (2) type PACKT extends FRAM is record of clock : INTGR data : MSSAG end record msgin pcktout clock i d : MSSAG : PACKT : INTGR : INTGR. when e_send(p i, P j, msgout: MSSAG) do 2. clock i := clock i + d. pcktout.clock := clock i 4. pcktout.data := msgout 5. send(q i, Q j, pcktout) 6. end when Czas wirtualny, złożoność algorytmów (9) Czas wirtualny, złożoność algorytmów (0) Alg. Lamporta () Przykład synchronizacji zegarów logicznych 7. when e_receive(q j, Q i, pcktin: PACKT) do 8. clock i := max(clock i, pcktin.clock) + d 9. msgin := pcktin.data 0. deliver(p j, P i, msgin). end when 2. when e_internal(p i, *) do. clock i := clock i + d 4. end when P P 2 P max(0, ) + = + = 2 T ( 0 )=0 T ( 20 )=0 T ( 0 )=0 T ( 2 )= T ( )=2 M T ( 22 )=2 T ( )= T ( 2 )= T ( 2 )=4 M 2 M T ( 24 )=5 M 4 T ( 2 )=2 (a' ) (T ()<T(' )) (T ()<T(' )) (a ' ) Czas wirtualny, złożoność algorytmów () Czas wirtualny, złożoność algorytmów (2)

Relacja między zb. zdarzeń i zb. wartości zegara skalarnego Zegar wektorowy - definicja a T () < = > Zegarem wektorowym jest zegar logiczny, dla którego przeciwdziedzina funkcji T, oznaczana dalej dla odróżnienia przez T V, jest zbiorem n-elementowych wektorów liczb naturalnych lub rzeczywistych. Czas wirtualny, złożoność algorytmów () Czas wirtualny, złożoność algorytmów (4) Realizacja zegarów wektorowych Alg. Matterna () FunkcjaT V implementowana jest przez zmienne tablicowe, i n, skojarzone z poszczególnymi procesami. Zmienna jest tablicą [..n] liczb naturalnych, odpowiadającą pewnej aproksymacji czasu globalnego z perspektywy procesu P i. W efekcie aktualna wartość tablicy odpowiada w każdej chwili wartości funkcji T V ( ik ) odnoszącej się do ostatniego zdarzenia, jakie zaszło w procesie P i. type PACKT extends FRAM is record of vclock : array [..n] of INTGR data : MSSAG end record msgin : MSSAG pcktout : PACKT : array [..n] of INTGR d : INTGR k : INTGR Czas wirtualny, złożoność algorytmów (5) Czas wirtualny, złożoność algorytmów (6)

Alg. Matterna (2) Alg. Matterna (). when e_send(p i, P j, msgout: MSSAG) do 2. [i] := [i] + d. pcktout.vclock := 4. pcktout.data := msgout 5. send(q i, Q j, pcktout) 6. end when 7. when e_receive(q j, Q i, pcktin: PACKT) do 8. [i] := [i] + d 9. for all k {, 2,..., n} do 0. [k] := max( [k], pcktin.vclock[k]). end for 2. msgin := pcktin.data. deliver(p j, P i, msgin) 4. end when 5. when e_internal(p i, *) do 6. [i] := [i] + d 7. end when Czas wirtualny, złożoność algorytmów (7) Czas wirtualny, złożoność algorytmów (8) Zegary wektorowe () Relacje na etykietach wektorowych Twierdzenie 4. W każdej chwili czasu rzeczywistego i,j :: [i] vclock j [i] (4.2) gdzie zmienna [i] reprezentuje skalarny czas lokalny procesu P i, a zmienna vclock j [i], j i, aktualne wyobrażenie procesu P j o bieżącym skalarnym czasie lokalnym procesu P i. = vclock j k [k] = vclock j [k] vclock j k [k] vclock j [k] vclock j k [k] vclock j [k] vclock j k [k] > vclock j [k] < vclock j vclock j vclock j vclock j ( vclock j vclock j ) vclock j vclock j vclock j ) Czas wirtualny, złożoność algorytmów (9) Czas wirtualny, złożoność algorytmów (20)

Zegary wektorowe (2) Kanały FIFO Twierdzenie 4.2 Niech T V () oraz T V ( ) będą wartościami zegarów wektorowych zdarzeń i. Wówczas: Kanały gwarantujące porządek odbioru wiadomości zgodny z kolejnością wysyłania będziemy nazywać kanałami FIFO (ang. First-In-First-Out). P 2 2 (a ' ) (T V ()<T V (' )) (4.) P 2 M M2 M 2 2 2 2 Czas wirtualny, złożoność algorytmów (2) Czas wirtualny, złożoność algorytmów (22) Alg. Müllender a () Alg. Müllender a (2) type PACKT extends FRAM is record of seqno : INTGR data : MSSAG end record msgin : MSSAG pcktout : PACKT delaybuf i : array [..n] of set of PACKT := seqno i : array [..n] of INTGR := 0 delivno i : array [..n] of INTGR := 0 delivered i : BOOLAN. when e_send(p i, P j, msgout: MSSAG) do 2. pcktout.data:= msgout. seqno i [j]:= seqno i [j] + 4. pcktout.seqno:= seqno i [j] 5. send(q i, Q j, pcktout) 6. end when Czas wirtualny, złożoność algorytmów (2) Czas wirtualny, złożoność algorytmów (24)

Alg. Müllender a () Alg. Müllender a (4) 7. when e_receive(q j, Q i, pcktin : PACKT) do 8. if pcktin.seqno = delivno i [j] + 9. then 0. msgin:= pcktin.data. deliver(p j, P i, msgin) 2. delivno i [j]:= delivno i [j] +. delivered i := True 4. else 5. delaybuf i [j]:= delaybuf i [j] {pcktin} 6. delivered i := False 7. end if 8. while delivered i do 9. delivered i := False 20. for all pckt delaybuf i [j] do 2. if pckt.seqno = delivno i [j] + then 22. msgin:= pckt.data 2. deliver(p j, P i, msgin) 24. delivno i [j]:= delivno i [j] + 25. delivered i := True 26. delaybuf i [j]:= delaybuf i [j]\{pckt} 27. end if 28. end for 29. end while 0. end when Czas wirtualny, złożoność algorytmów (25) Czas wirtualny, złożoność algorytmów (26) Cechy kanałów FIFO Kanały typu FC są pewnym mechanizmem synchronizacji wymaganym przez wiele aplikacji, ułatwiają znalezienie rozwiązania i konstrukcję algorytmów rozproszonych dla wielu problemów, ograniczają, w porównaniu z kanałami nonfifo, współbieżność komunikacji, a tym samym efektywność przetwarzania. Kanały typu FC (ang. Flush Channels), łączą zalety kanałów FIFO i nonfifo, (pewien stopień synchronizacji i współbieżnej komunikacji). mechanizmy (operacje) komunikacji send t (ang. two-way-flush send) send f (ang. forward-flush send) send b (ang. backward-flush-send) send o (ang. ordinary send) zdarzenia wiadomości e_send t e_send f e_send b e_send o M t M f M b M o Czas wirtualny, złożoność algorytmów (27) Czas wirtualny, złożoność algorytmów (28)

Wyprzedzanie wiadomości Typy wiadomości w kanałach FC Powiemy, że wiadomość M' wyprzedza wiadomość M w kanale C i,j, jeżeli wiadomość M została wysłana przez P i wcześniej niż M', lecz proces P j najpierw odebrał wiadomość M'. Wiadomość M t typu TF (ang. two-way-flush-send) operacja send t FIFO Wiadomość M f typu FF (ang. forward-flush-send) operacja send f Wiadomość M b typu BF (ang. backward-flush-send) operacja send b Wiadomość M o typu OF (ang. ordinary-send) operacja send o nonfifo Czas wirtualny, złożoność algorytmów (29) Czas wirtualny, złożoność algorytmów (0) Implementacja kanałów FC Relacja binarna poprzedzania Kanały typu FC mogą być implementowane z użyciem różnych mechanizmów: selektywnego rozgłaszania liczników potwierdzeń FL i,j stan kanału FC i,j + i,j binarna relacja poprzedzania typu F, zdefiniowana na zbiorze FL i,j : M + i,j M' (M, M' FL i,j ) (M' nie może być odebrana przed M) (4.4) Czas wirtualny, złożoność algorytmów () Czas wirtualny, złożoność algorytmów (2)

Bezpośrednie poprzedzanie Konstrukcja relacji poprzedzania () Jeżeli zachodzi predykat : M + i,jm' ( M'' :: (M'' M M'' M' M + i,jm'' M'' + i,jm' )) (4.5) W celu implementacji kanałów FC należy rozwiązać problem efektywnego wyznaczenia relacji i,j i przekazywania istotnych jej elementów do monitora odbiorcy. to mówimy, że M bezpośrednio poprzedza M' i fakt ten oznaczamy M i,j M', czyli i,j := { M, M' : (M bezpośrednio poprzedza M' )} Mechanizm sukcesywnej konstrukcji relacji i,j poprzez stosowne uaktualnienie relacji przy wysyłaniu kolejnych wiadomości. Czas wirtualny, złożoność algorytmów () Czas wirtualny, złożoność algorytmów (4) Konstrukcja relacji poprzedzania (2) Konstrukcja relacji poprzedzania () Niech M i,jb oznacza ostatnią wiadomość typu TF lub BF wysłaną kanałem FC i,j Jeżeli M jest typu OF i M i,jb, to i,j := i,j { M i,jb, M } (4.6) Jeżeli M jest typu BF i M i,jb, to i,j := i,j { M i,jb, M } (4.7) Następnie, M i,jb := M. Jeżeli M jest typu FF, to dla wszystkich M', takichże M' nie ma następnika w i,j, i,j := i,j { M', M } (4.8) Jeżeli M jest typu TF, to dla wszystkich M', takichże M' nie ma następnika w i,j, i,j := i,j { M', M } (4.9) Następnie, M i,jb := M. Czas wirtualny, złożoność algorytmów (5) Czas wirtualny, złożoność algorytmów (6)

Przekazywania informacji o relacji poprzedzania Alg. Kearnsa, Campa i Ahuja () W tym celu można zaproponować przesyłanie wiadomości aplikacyjnych w pakietach, zawierających dodatkowo: typ wiadomości (OF, BF, FF, TF) numer sekwencyjny wiadomości M (seqno = seqno i [j]) numer sekwencyjny waitforno wiadomości bezpośrednio poprzedzającej M Czas wirtualny, złożoność algorytmów (7) type PACKT extends FRAM is record of type : enum {OF, BF, FF, TF} seqno : INTGR waitforno : INTGR data : MSSAG end record msgin : MSSAG pcktout : PACKT delaybuf i : array [..n] of set of PACKT:= seqno i : array [..n] of INTGR:= 0 backfp i : array [..n] of INTGR:= 0 delivno i : array [..n] of set of INTGR:= delivered i : BOOLAN k : INTGR Czas wirtualny, złożoność algorytmów (8) Alg. Kearnsa, Campa i Ahuja (2) Alg. Kearnsa, Campa i Ahuja (). procedure TryToDeliver(pcktIn: PACKT) do 2. msgin := pcktin.data. if pcktin.type = OF pcktin.type = BF 4. then 5. if pcktin.waitforno=0 pcktin.waitforno delivno i [j] 6. then 7. deliver(p j, P i, msgin) 8. delivno i [j]:= delivno i [j] {pcktin.seqno} 9. end if 0. else /* pcktin.type = FF pcktin.type = TF */. if k :: k pcktin.waitforno :: k delivno i [j] 2. then. deliver(p j, P i, msgin) 4. delivno i [j]:= delivno i [j] {pcktin.seqno} 5. end if 6. end if 7. end procedure Czas wirtualny, złożoność algorytmów (9) 8. when e_send o (P i, P j, msgout: MSSAG) do 9. pcktout.type:= OF 20. seqno i [j]:= seqno i [j] + 2. pcktout.seqno:= seqno i [j] 22. pcktout.waitforno:= backfp i [j] 2. pcktout.data:= msgout 24. send(q i, Q j, pcktout) 25. end when Czas wirtualny, złożoność algorytmów (40)

Alg. Kearnsa, Campa i Ahuja (4) Alg. Kearnsa, Campa i Ahuja (5) 26. when e_send f (P i, P j, msgout: MSSAG) do 27. pcktout.type:= FF 28. seqno i [j]:= seqno i [j] + 29. pcktout.seqno:= seqno i [j] 0. pcktout.waitforno:= seqno i [j] -. pcktout.data:= msgout 2. send(q i, Q j, pcktout). end when 4. when e_send b (P i, P j, msgout: MSSAG) do 5. pcktout.type:= BF 6. seqno i [j]:= seqno i [j] + 7. pcktout.seqno:= seqno i [j] 8. pcktout.waitforno:= backfp i [j] 9. pcktout.data:= msgout 40. send(q i, Q j, pcktout) 4. backfp i [j]:= seqno i [j] 42. end when Czas wirtualny, złożoność algorytmów (4) Czas wirtualny, złożoność algorytmów (42) Alg. Kearnsa, Campa i Ahuja (6) Alg. Kearnsa, Campa i Ahuja (7) 4. when e_send t (P i, P j, msgout: MSSAG) do 44. pcktout.type:= TF 45. seqno i [j]:= seqno i [j] + 46. pcktout.seqno:= seqno i [j] 47. pcktout.waitforno:= seqno i [j] - 48. pcktout.data:= msgout 49. send(q i, Q j, pcktout) 50. backfp i [j]:= seqno i [j] 5. end when 52. when e_receive(q j, Q i, pcktin: PACKT) do 5. TryToDeliver(pcktIn) 54. if pcktin.seqno delivno i [j] 55. then 56. delivered i := True 57. else 58. delivered i := False 59. delaybuf i := delaybuf i {pcktin} 60. end if Czas wirtualny, złożoność algorytmów (4) Czas wirtualny, złożoność algorytmów (44)

Alg. Kearnsa, Campa i Ahuja (8) Środowisko zachowujące uporządkowanie przyczynowe 6. while delivered i do 62. delivered i := False 6. for all pckt delaybuf i [j] do 64. TryToDeliver(pckt) 65. if pckt.seqno delivno i [j] 66. then 67. delivered i := True 68. delaybuf i := delaybuf i \ {pckt} 69. end if 70. end for 7. end while 72. end when (4.0) (e_send(p i, P j, M) a e_send(p k, P j, M )) (e_receive(p i, P j, M) a j e_receive(p k, P j, M )) P P 2 P 2 M M M 2 2 2 2 M 4 2 M 2 Czas wirtualny, złożoność algorytmów (45) Czas wirtualny, złożoność algorytmów (46) Środowisko zachowujące uporządkowanie przyczynowe Alg. Birmana, Schipera i Stephensona () (e_send(p i, P j, M) a e_send(p k, P j, M )) (e_receive(p i, P j, M) a j e_receive(p k, P j, M )) P P 2 P 2 M M M 2 2 2 2 M 4 2 M 2 type PACKT extends FRAM is record of vsentclock : array [..n] of INTGR data : MSSAG end record msgin : MSSAG pcktout : PACKT vsentclock i : array [..n] of INTGR k : INTGR Czas wirtualny, złożoność algorytmów (47) Czas wirtualny, złożoność algorytmów (48)

Alg. Birmana, Schipera i Stephensona (2) Alg. Birmana, Schipera i Stephensona (). when e_send(p i, P j, msgout: MSSAG) do 2. vsentclock i [i]:= vsentclock i [i] +. pcktout.vsentclock:= vsentclock i 4. pcktout.data:= msgout 5. send(q i, Q \ {Q i }, pcktout) 6. end when 7. when e_receive(q j, Q i, pcktin: PACKT) do 8. wait until (vsentclock i [j]=pcktin.vsentclock[j]-) k {,2,...,n}\{j}::vSentClock i [k] pcktin.vsentclock[k]) 9. if pckin.data.rid = P i 0. then. msgin:= pcktin.data 2. deliver(p j, P i, msgin). end if 4. for all k {, 2,..., n} do 5. vsentclock i [k]:=max(vsentclock i [k],pcktin.vsentclock[k]) 6. end for 7. end when Czas wirtualny, złożoność algorytmów (49) Czas wirtualny, złożoność algorytmów (50) Alg. Schipera, gli, Sandoza () Alg. Schipera, gli, Sandoza (2) type PACKT extends FRAM is record of vsentclock : array [..n] of INTGR vm : set of record of pid: PROCSS_ID vts: array [..n] of INTGR end record data : MSSAG end record msgin : MSSAG pcktout : PACKT vsentclock i : array [..n] of INTGR vp i : set of record of pid : PROCSS_ID vts : array [..n] of INTGR end record delivered i : BOOLAN delaybuf i : set of PACKT := tmpbuf i : set of PACKT vts sup i : array [..n] of INTGR Czas wirtualny, złożoność algorytmów (5) Czas wirtualny, złożoność algorytmów (52)

Alg. Schipera, gli, Sandoza () Alg. Schipera, gli, Sandoza (4). procedure TryToDeliver(pcktIn: PACKT) do 2. msgin:= pcktin.data. if pid M, vts M pcktin.vm :: pid M = P i vts M vsentclock i 4. then 5. delaybuf i := delaybuf i {pcktin} 6. else 7. deliver(p j, P i, msgin) 8. delivered i := True 9. end if Czas wirtualny, złożoność algorytmów (5) 5. if delivered i then 6. for all pid M,vTS M pcktin.vm pid M P i do 7. if pid, vts vp i :: pid pid M then 8. vp i := vp i { pid M, vts M } 9. else 20. for ( pid, vts) vp i pid = pid M do 2. for all k {, 2,..., n} do 22. vts sup i [k] := max(vts[k], vts M [k]) 2. end for 24. vp i := vp i \ { pid, vts } 25. vp i := vp i { pid, vts sup i } 26. end for 27. end if 28. end for 29. for all k {, 2,..., n} do 0. vsentclock i [k] := max(vsentclock i [k], pcktin.vsentclock[k]). end for 2. end if. end procedure Czas wirtualny, złożoność algorytmów (54) Alg. Schipera, gli, Sandoza (5) Alg. Schipera, gli, Sandoza (6) 6. when e_send(p i, P j, msgout: MSSAG) do 7. vsentclock i [i] := vsentclock i [i] + 8. pcktout.vsentclock := vsentclock i 9. pcktout.vm := vp i 40. pcktout.data := msgout 4. send(q i, Q j, pcktout) 42. for pid, vts vp i pid = P j do 4. vp i := vp i \ { pid, vts } 44. end for 45. vp i := vp i { P j, vsentclock i } 46. end when 47. when e_receive(q j, Q i, pcktin: PACKT) do 48. delivered i := False 49. TryToDeliver(pcktIn) 50. tmpbuf i := 5. while delivered i do 52. tmpbuf i := tmpbuf i delaybuf i 5. delaybuf i := 54. delivered i := False 55. for all pckt tmpbuf i do 56. tmpbuf i := tmpbuf i \ {pckt} 57. TryToDeliver(pckt) 58. end for 59. end while 60. end when Czas wirtualny, złożoność algorytmów (55) Czas wirtualny, złożoność algorytmów (56)

Funkcje kosztu oznaczenia Funkcja kosztu - definicja δ A zbiór wszystkich poprawnych danych wejściowych δ algorytmu A, Z* A (δ) koszt wykonywania algorytmu A dla danychδ, gdzie δ δ A i Z* A : δ A R µ rozmiar danych wejściowych δ (rozmiar zadania), taki że µ =W(δ), gdziew: δ A N, jest zadaną funkcją. Funkcją kosztu wykonania algorytmu nazywać będziemy odwzorowanie Z A : µ A R (4.) Gdzie µ Ajest zbiorem wszystkich poprawnych danych wejściowych o rozmiarze µ algorytmu A. W praktyce, zamiast kosztu Z * A(δ) stosuje się zwykle jego oszacowanie w funkcji rozmiaru zadania µ =W(δ). Czas wirtualny, złożoność algorytmów (57) Czas wirtualny, złożoność algorytmów (58) Funkcje kosztu wykonania algorytmów Rząd funkcji () Najczęściej stosowane jest odwzorowanie pesymistyczne (najgorszego przypadku), zdefiniowane w sposób następujący: Z A (µ) = sup{z * A(δ) :δ δ A W(δ) = µ } (4.2) Niech f i g będą dowolnymi funkcjami odwzorowującymi N wr. Mówimy, że funkcja f jest co najwyżej rzędu funkcji g, co zapisujemy: f = O( g ) (4.) jeżeli istnieje stała rzeczywista c > 0 oraz n 0 Ntakie, że dla każdej wartości n > n 0, n Nzachodzi: f(n) < c g(n) (4.4) Czas wirtualny, złożoność algorytmów (59) Czas wirtualny, złożoność algorytmów (60)

Rząd funkcji (2) Rząd funkcji () Niech f i g będą dowolnymi funkcjami odwzorowującymi N wr. Mówimy, że funkcja f jest dokładnie rzędu funkcji g, co zapisujemy: jeżeli f = O(g) g = O(f). f = Θ ( g ) (4.5) Niech f i g będą dowolnymi funkcjami odwzorowującymi N wr. Mówimy, że funkcja f jest co najmniej rzędu funkcji g, co zapisujemy: jeżeli g = O(f). f = Ω ( g ) (4.6) Czas wirtualny, złożoność algorytmów (6) Czas wirtualny, złożoność algorytmów (62) Złożoność czasowa Czasy przetwarzania lokalnego i transmisji W wypadku algorytmów rozproszonych, złożoność czasowa jest funkcją kosztu wykonania, wyrażoną przez liczbę kroków algorytmu do jego zakończenia przy założeniu, że: czas wykonywania każdego kroku (operacji) jest stały kroki wykonywane są synchronicznie czas transmisji wiadomości jest stały W analizie złożoności czasowej algorytmów rozproszonych przyjmuje się też na ogół, że czas przetwarzania lokalnego (wykonania każdego kroku) jest pomijalny (zerowy) czas transmisji jest jednostkowy Czas wirtualny, złożoność algorytmów (6) Czas wirtualny, złożoność algorytmów (64)

Złożoność komunikacyjna Przykład () - bariera Złożoność komunikacyjna jest funkcją kosztu wykonania algorytmu wyrażaną przez: liczbę pakietów (wiadomości) przesyłanych w trakcie wykonywania algorytmu do jego zakończenia sumaryczną długość (w bitach) wszystkich wiadomości przesłanych w trakcie wykonywania algorytmu Topologia połączeń graf w pełni połączony Koordynator rozgłasza komunikat początku bariery Wszyscy uczestnicy odbierają komunikat i odsyłają potwierdzenia Po otrzymaniu potwierdzeń od wszystkich procesów, koordynator rozsyła komunikat końca bariery W konsekwencji wyróżniamy złożoność pakietową i bitową. Czas wirtualny, złożoność algorytmów (65) Czas wirtualny, złożoność algorytmów (66) Przykład () - rysunek Przykład (2) - bariera P 5 P 4 komunikatów typu BARRIR : n- komunikatów typu ACK : n- komunikatów typu ND : n- P * (n-) Topologia połączeń pierścień logiczny Koordynator wysyła komunikat początku bariery Wszyscy uczestnicy odbierają komunikat i przesyłają go dalej Po otrzymaniu komunikatu rozpoczynającego operację bariery, koordynator przesyła komunikat końca bariery P 6 P 2 P ( koordynator ) Początek Koniec bariery bariery Czas wirtualny, złożoność algorytmów (67) Czas wirtualny, złożoność algorytmów (68)

Przykład (2) - rysunek Warunki poprawności P 5 P 4 komunikatów typu BARRIR : n komunikatów typu ND : n P 2 * n Analizę poprawności algorytmu rozproszonego (procesu rozproszonego) dekomponuje się zwykle na analizę jego bezpieczeństwa iżywotności. właściwość bezpieczeństwa (ang. safety, consistency) P 6 P ( koordynator ) P 2 właściwość żywotności (postępu) (ang. liveness, progress) Początek Koniec bariery bariery Czas wirtualny, złożoność algorytmów (69) Czas wirtualny, złożoność algorytmów (70)