11. Algorytmy równoważenia obciążeń (Load

Transkrypt

11. Algorytmy równoważenia obciążeń (Load-Balancing).
Algorytmy te stosowane są do optymalizacji algorytmów dekompozycji domenowej o zróżnicowanym
obciążeniu zadań i/lub niestrukturalnym charakterze komunikacji.
Wykorzystują metody heurystyczne.
Czas wykonania algorytmu równoważenia nie powinien przewyższać spodziewanych zysków z
optymalizacji.
Rekursywna bisekcja – podział domeny minimalizujący ilość kanałów komunikacyjnych
przecinających granice poddomen.

Podejście Divide-and-Conquer,
Recursive coordinate bisection – cięcie zawsze wzdłuż dłuższej osi współrzędnych,
Unbalanced recursive bisection – redukcja komunikacji poprzez zachowanie stosunku
rozmiarów poddomen (cięcia na P-1 poddomen o obciążeniach n/P i (P-n)/P dla n=1,2,... z
wyborem minimalizującym stosunek rozmiarów.
Recursive graph bisection – siatka traktowana jako graf, wybierane 2 punkty najbardziej
odległe, podział pozostałych na 2 części wg położenia względem krańcowych
Recursive spectra bisection – lepsza w wielu zastosowaniach
Algorytmy lokalne – równoważenie wykonywane w oparciu o informacje
pochodzącą tylko od sąsiednich procesorów:
Porównywanie obciążenia przez sąsiadów na siatce
Przekazywanie nadmiaru obliczeń mniej obciążonemu sąsiadowi
Metody probabilistyczne
Losowe alokowanie zadań z dużej puli pomiędzy procesory
Zaleta: skalowalność i niski koszt
Wada: nielokalna komunikacja
Efektywne gdy jest niewiele komunikacji między zadaniami lub są one
z założenia nielokalne
Mapowanie cykliczne - stosowane jeżeli obciążenie węzła zmienia się i zachodzi skokowa lokalna
poziomu obciążenia. Każdy z P procesorów otrzymuje co P-te zadanie wg określonego schematu.
12. Kryteria odwzorowania (mapowania).

Algorytm z dynamicznym tworzeniem zadań może być prostszy ale nie bardziej wydajny.
Centralny zarządca może podlegać przeciążeniu.
Koszty różnych strategii dynamicznego równoważenia obciążenia.
Metody probabilistyczne i cykliczne wymagają dużej liczby zadań do osiągnięcia dobrego
zrównoważenia (rząd więcej niż dostępna liczba procesorów).
13. Miary efektywności zrównoleglenia.
Miara efektywności zrównoleglenia jest to oszacowanie wzrostu wydajności obliczeń realizowanych w
sposób równoległy w stosunku do rozwiązania sekwencyjnego.
OZNACZENIA:
n – wielkość zadania.
p – liczba procesorów.
T(n,p) – czas wykonania programu realizującego ten sam algorytm dla zadania o wielkości n na maszynie
równoległej z p procesorami.
Współczynnik przyśpieszenia (SpeedUp) zadania o wielkości n – dzięki zrównolegleniu na p
procesorów:
S ( n, p ) =
zachodzi nierówność:
T (n,1)
T ( n, p )
S(n,p) ≤ p
Założenia modelowe - zakładamy że program składa się z kilku części wykonywanych równolegle,
poprzedzielanych częściami które muszą być wykonywane sekwencyjnie.
OZNACZENIA:
β(n) – udział części sekwencyjnej ( część T(n,1) która nie da się zrównoleglić)
Część sekwencyjna (czas): σ(n) = β(n) T(n,1)
Część równoległa: φ(n) = (1- β(n)) T(n,1) może być zrównoleglona idealnie (rozłożona na dowolną liczbę
procesorów).
κ(n,p) – czas zużyty na rzuty na synchronizacje i komunikację międzyprocesową.
Efekt zrównoleglenia:
(1-β)ts
β ts
p
(1-β)ts /p
Czas wykonania zadania o rozmiarze n na maszynie równoległej o p procesorach:
T (n,1) = σ (n) + ϕ (n)
T (n, p ) = σ (n) +
gdzie:
β ( n) =
ϕ ( n)
p
+ κ (n, p )
σ ( n)
σ ( n) + ϕ ( n)
14. Prawo Amdahla.
Czas wykonania na maszynie równoległej o p procesorach (zał. κ(n,p) = 0) wynosi:
T (n, p ) = β (n) ⋅ T (n, 1) +
lub:
S ( n, p ) =
(1 − β (n)) ⋅ T (n, 1)
p
T (n, 1)
1
=
T ( n, p ) β ( n ) + 1 − β ( n )
p
β=0%
p=25
S
p
e
e
d
u
p
β=5%
β=10%
S
p
e
e
d
u
p
β=20%
p=16
liczba procesorów, p
udział części sekwencyjnej, β
PRAWO AMDAHLA:
S ( n, p ) ⎯⎯
⎯→
p→∞
1
β (n)
Nawet przy użyciu dowolnie wielu procesorów, obliczeń nie da się przyspieszyć bardziej, niż wynosi
odwrotność udziału części sekwencyjnej w programie wykonywanym na jednym procesorze.
Jeżeli czas części sekwencyjnych jest stały i równy βs*T(1,1), a czas części równoległej jest proporcjonalny do
rozmiaru n zadania, to:
β ( n) =
βs
β s + n ⋅ (1 − β s )
=
1
1+ n ⋅(
1
β
− 1)
s
Jeżeli czas wykonania części sekwencyjnej jest proporcjonalny do wielkości zadania (Np. n* βs), a czas części
równoległej ~ n2 (Np. n2*(1- βs)), to:
β (n) ⎯⎯⎯⎯
n→∞ → 0
czyli:
S ( n, p ) → p
Efekt Amdahla:
Zwykle narzut komunikacyjny ma mniejszą złożoność obliczeniową niż część idealnie dająca
się zrównoleglić.
Zwiększenie rozmiaru zadania powoduje wzrost czasu obliczeń szybciej niż czas komunikacji.
Dla stałej ilości procesorów, przyśpieszenie jest rosnącą funkcją rozmiaru zadania.
15. Skalowalność i sprawność.
Właściwość systemu (sprzętu i oprogramowania) polegająca na elastycznym dostosowywaniu się do
zwiększonej liczby procesorów tj. zachowującym tę samą sprawność.
η(n,p) – sprawność programu o wielkości n na maszynie o p procesorach:
η ( n, p ) =
S (n, p )
⋅100%
p
Metryka stałej sprawności:
Speedup: S ( n, p ) =
σ ( n) + ϕ ( n)
p(σ (n) + ϕ (n))
=
σ (n) + ϕ (n) / p + κ (n, p ) σ (n) + ϕ (n) + ( p − 1)σ (n) + pκ (n, p)
Niech T0(n,p) – całkowity czas zużyty przez wszystkie procesy wykonujące operacje nie wchodzące w skład
algorytmu sekwencyjnego (narzut). Wtedy:
T0 (n, p ) = ( p − 1)σ (n) + pκ (n, p )
S (n, p) =
p (σ (n) + ϕ (n))
σ (n) + ϕ (n) + T0 (n, p)
η ( n, p ) =
η (n, p) =
σ ( n) + ϕ ( n)
σ (n) + ϕ (n) + T0 (n, p )
1
T (n, p)
1+ 0
σ ( n) + ϕ ( n)
Relacja stałej sprawności:
Skoro T(n,1) – czas zużyty wykonania sekwencyjnego, wtedy:
η (n, p) =
1
1 + T0 (n, p) / T (n, 1)
T (n, 1) =
η ( n, p )
T0 (n, p)
1 − η (n, p)
Niech system równoległy ma sprawność η(n,p). Aby zachować ten sam poziom sprawności ze wzrostem liczby
procesorów, n musi wzrosnąć w stopniu spełniającym zależność (isoefficiency relation):
T (n, 1) = CT0 (n, p)
Funkcja skalowalności:
Aby utrzymać tę samą sprawność, po zwiększeniu liczby procesorów p należy zwiększyć wielkość n
zadania.
- Dla danej liczby p można wyznaczyć wielkość zadania przy której jest zachowana ta sama
sprawność;
- Związek ten określa funkcję stałej sprawności (isoefficiency function), monotonicznie rosnącą.
Jeśli dany system ma relację stałej sprawności n = f(p), a M(n) oznacza ilość pamięci niezbędnej
dla problemu o rozmiarze n, to zależność M(f(p))/p, wyznaczającą ilość pamięci na procesor,
nazywamy funkcją skalowalności.
Dana architektura jest bardziej skalowalna, gdy funkcja ta rośnie wolniej:
- Np. jeśli M(f(n)/p = Θ(1), to system jest w pełni skalowalny.