TEILWEISE ASYNCHRONE ALGORITHMEN

TEILWEISE ASYNCHRONE ALGORITHMEN FRANK LANGBEIN Literatur: D. Berseas, J. Tsitsilis: Parallel and distributed computatoin, pp. 48 489 URI: http://www.langbein.org/research/parallel/ Modell teilweiser asynchroner Algorithmen Konvergenzverhalten Satz von Lyapunov Modell teilweiser asynchroner Algorithmen Entspricht im wesentlichen dem vollständig asynchroner Algorithmen: X, X,..., X n Teilmengen eulidischer Räume X = X X X n x = (x, x,..., x n ) X mit x i X i für i =,..., n f i : X X i i =,..., n Wir betrachten folgende asynchrone Iteration x i := f i (x), i =,..., n Diese Iteration ist vollständig bestimmt durch (a) Anfangsbedingungen x(t) X für jedes t 0 (b) T i = {t i 0, ti, ti,... } mit 0 ti 0 < ti < ti <..., den Zeitpunten zu denen ein von x i erfolgt (i =,..., n). (c) τ i j (t) für jedes i, j {,..., n} und t T i, welches angibt wie veraltet der Wert von x j ist, der für das von x i zur Zeit t verwendet wurde; 0 τ i j(t) t. Um die Analyse der Algorithmen zu vereinfachen sind für τ i j(t) auch negative Werte erlaubt, deshalb werden Anfangsbedingungen auch für negative t gefordert. Der asyncrhone Algorithmus für t 0 wird beschrieben durch x i (t + ) = x i (t) für t T i x i (t + ) = f i (x (τ(t)), i x (τ(t)), i..., x n (τn(t))) i für t T i Date: Feb-09-996.

FRANK LANGBEIN t ĩ x i f i x j (τ i j ) = x j(t j ) x j t j τj i t j + t Scenario: Spezielle Wahl von T i und τ i j(t) Für jedes festes Scenario ist x(t) für t > 0 eindeutig durch die Anfangsbedingungen bestimmt. Jedoch önnen die Werte von x(t) für verschiedene Scenarien bei gleichen Anfangsbedingungen star voneinander abweichen. Teilweise Asynchronität. Es existiert eine positive ganze Zahl B, so daß (a) für jedes i und t 0 mindestens ein Element der Menge {t, t +,..., t + B } zu T i gehört. (b) t B < τj(t) i für alle i und j und t T i (c) τi i i (t) = t für alle i und t T Zu (a): Jeder Prozessor führt wenigstens ein während eines beliebigen Zeitintervalls der Länge B durch. Zu (b): Jeder Prozessor verwendet Informationen die nicht älter als B Zeiteinheiten sind. Zu (c): Beim von x i zum Zeitpunt t + wird x i (t) verwendet. In Message Passing Systems ist dies automatisch erfüllt, da der i-te Prozessor den Wert der Variablen x i speichert und der einzigste Prozessor ist, der x i verändern ann. In Shared Memory Systems ist dies nicht unbedingt erfüllt, ann aber leicht erreicht werden. Es ann gezeigt werden, daß ein sonst onvergierender Algorithmus nicht mehr onvergiert, wenn (a) und (b) gelten, aber (c) verletzt ist.

TEILWEISE ASYNCHRONE ALGORITHMEN 3 Beispiel Die Zeitvariable t muß den Prozessoren nicht zugänglich sein. Sie muß auch nicht der realen Zeit entsprechen. t ann z.b. ein Index für bestimmt Ereignisse wie s sein. Wir betrachten dazu ein Message Passing System mit n Prozessoren. Jeder Prozessor hat seine eigene loale Uhr. Reale (globale) Zeit, den Prozessoren unbeannt: τ Loale Zeit des Prozessors i zur realen Zeit τ: t i (τ) Positive reelle Konstanten (siehe unten): A, A Loale Zeiteinheiten die ein benötigt: A 3 bis A 4 Maximale idle Zeit in loalen Einheiten: A 5 Maximale loale Zeitdifferenz zwischen zwei s von x i : A 6 Maximale globale Zeit für eine Übertragung: A 7 Die einzelnen Prozessoruhren önnen nicht beliebig schnell oder langsam sein: A τ τ t i (τ) t i (τ ) A τ τ τ, τ, i t sei eine Indexvariable, die um erhöht wird wenn irgendein Prozessor ein ausführt, t(τ) ist der Wert der Indexvariable t zum Zeitpunt τ. t wird hier als Zeitvariable für das Modell verwendet. Unter diese Vorrausetzungen sind (a) und (b) der teilweisen Asynchronität erfüllt. Idle 0 A 5 A 3 A 4 τ τ 0 τ τ Differenz zwischen zwei s A 6 /Idle τ τ 0 τ 3 τ 3 τ 4 τ 5 τ (a): (b): A 7 A 7 st Broadcast nd Broadcast A 3 t i (τ ) t i (τ 0 ) A 4 + A 5 A τ τ 0 t i (τ ) t i (τ 0 ) A τ τ 0 A 3 τ τ 0 A 4 + A 5 A4 + A 5 A 3, U = (n ) s maximal in τ 0 τ A A A t(τ 0 ) + U t(τ ) A (a) τ 5 τ A 7, t i (τ ) t i (τ 0 ) A 6 τ 5 τ 0 A 6 + A 7 A ( ) A6 A t(τ 5 ) t(τ 0 ) + A 7 n (b) A A 3

4 FRANK LANGBEIN Wir betrachten die lineare Iteration Beispiel : Konvergenz für beliebiges B x := f(x) = Ax, A = ( Die Fixpunte von f(x) sind X = {(x, x ) : x = x }. Die synchrone Iteration x(t + ) = Ax(t) onvergiert gegen x = (y, y), y = x (0)+x (0) in einem Schritt. Asynchrone Iteration Wir verwenden zwei Prozessoren i =,. Zu jedem Zeitschritt erfolgt ein der Variablen x i, also T i = {,, 3,... }. Zu bestimmten Zeiten t, t, t 3,... überträgt jeder Prozessor den atuellen Wert von x i. Dabei nehmen wir an, daß eine Kommuniationsverzögerung auftritt. Somit erhalten wir Also x (t + ) = x (t) + x (t ) x (t + ) = x (t ) + x (t) x (t + ) = x (t + ) = x (t + ) + + x (t ) ( + ) x (t ) ) t t < t + =... ( ) t+ t ( = x (t ) + + ) + + x t (t ) + t ( ) ( t+ t ( ) ) t+ t = x (t ) + x (t ) ( ) ( t+ t ( ) ) t+ t x (t + ) = x (t ) + x (t ) x (t + ) x (t + ) = ( ( ) ) t+ t x (t ) x (t ) = ( ɛ ) x (t ) x (t ) mit ɛ = ( ) t+ t Damit nimmt x (t ) x (t ) ab. Hieraus folgt aber noch nicht die Konvergenz gegen ein Element aus X, denn hierzu muß = ( ɛ ) = 0 erfüllt sein. Es gilt z.b. ( ) = = ( = ) ( + = ) ( 3 3 ) ( 4 3 3 4 ) 5 = 4 > 0 Wählt man also t + t groß genug, so daß ɛ <, dann onvergiert x nicht (vgl. Fig.). Hieraus folgt, daß die Iteration im vollständig asynchronen Fall nicht onvergiert.

TEILWEISE ASYNCHRONE ALGORITHMEN 5 t 0 t = 3 4 5 t = 6 7 x (t) 4 0 3 0 8.5 7.75 7.375 0 x (t) 6 0 7 0.5.5.65 0 Für die teilweise asynchrone Iteration muß t + t B sein. Also ɛ > ( B ) und damit ( 0 ( ɛ ) < ) ( = lim ) n = 0 B n B = = Damit onvergiert x (t ) x (t ) gegen 0 und somit auch x(t ) gegen ein Element aus X. Obige Iteration is ein Beispiel für einen Algorithmus der nicht vollständig asynchron onvergiert, aber für jedes B teilweise asynchron onvergiert. Für solche Algorithmen gibt es normalerweise eine Funtion, die den Abstand von X mißt und mit der Zeit leiner wird. Der Fator mit dem diese Abstandsfuntion abnimmt hängt jedoch von den Kommuniationsverzögerungen ab. Wir müssen daher annehmen, daß diese begrenzt sind um zu garantieren, daß die Abstandsfuntion mit einer festen Rate fällt.

6 FRANK LANGBEIN Beispiel 3: Konvergenz für leine B Wir betrachten nun die Iteration für den Gradienten Algorithmus zur Minimierung von xt Ax mit der Schrittweite γ. x := x γax, A = + ɛ + ɛ = ɛi + ee T, 0 < ɛ < + ɛ Die synchrone Iteration onvergiert für leine γ. Die vollständig asynchrone Iteration onvergiert nicht. Teilweise Asynchrone Iteration Pro Zeiteinheit wird von jedem Prozessor ein ausgeführt. Die Variablen werden alle B Zeiteinheiten übertragen, also t = B. Dies ergibt und damit x (t + ) = ( γ( + ɛ))x (t) γ(x (t ) + x 3 (t )) x (t + ) = ( γ( + ɛ))x (t) γ(x (t ) + x 3 (t )) x 3 (t + ) = ( γ( + ɛ))x 3 (t) γ(x (t ) + x (t )) x (t + ) = ( γ( + ɛ))x (t + ) γ(x (t ) + x 3 (t )) t t < t + = ( γ( + ɛ)) x (t + ) (γ( γ( + ɛ)) + γ)(x (t ) + x 3 (t )) = = ( γ( + ɛ)) B x (t ) γ ( γ( + ɛ))b γ( + ɛ) (x (t ) + x 3 (t )) = ( γ( + ɛ)) B x (t ) + ( γ( + ɛ))b (x (t ) + x 3 (t )) + ɛ Analoge Gleichungen ergeben sich für x und x 3. Damit x(t + ) = Cx(t ) C = α β β β α β = (α β)i + βee T β β α α = ( γ( + ɛ)) B, β = ( γ( + ɛ))b + ɛ Die Eigenwerte von C sind α + β und α β mit der Vielfacheit (ee T hat die Eigenwerte 3 und 0, wobei 0 die Vielfacheit besitzt). Sei nun γ lein genug gewählt, so daß γ( + ɛ) < gilt. Dann α 0 β +ɛ Für große B gilt also für B α + β + ɛ ρ(c) > womit die Iteration nicht onvergiert. Ist B lein und γ sehr lein, dann gelten die Abschätzungen Dies ergibt für die Eigenwerte von C α = Bγ( + ɛ) + O(γ ) Bγ( + ɛ), α + β Bγ(3 + ɛ), α + β > für große B α β Bγɛ β Bγ

TEILWEISE ASYNCHRONE ALGORITHMEN 7 Sei γ so lein gewählt, daß Bγ(3 + ɛ) <. Dann folgt, daß ρ(c) < womit die Iteration für obiges Scenario onvergiert. Die Konvergenz läßt sich auch noch auf eine andere Weise zeigen, die leichter zu verallgemeinern ist. Dazu betrachten wir für leine B und γ (wie oben) und für t t < t + x (t) = ( γ( + ɛ)) t t x (t ) + ( γ( + ɛ))t t (x (t ) + x 3 (t )) + ɛ x (t ) (t t )γ(( + ɛ)x (t ) + x (t ) + x 3 (t )) Damit ist x (t) x (t ) = O(γB) und analog x 3 (t) x 3 (t ) = O(γB). Somit unterscheidet sich der x (t + ) x (t) = γ(( + ɛ)x (t) + x (t ) + x 3 (t )) vom synchronen γ(( + ɛ)x (t) + x (t) + x 3 (t)) durch einen Fator der Ordnung O(γ B). Also haben die veralteten Daten, die bei dem von x (t+) verwendet wurden, nur einen Einfluß der Ordnung O(Bγ ). Solange also Bγ wesentlich leiner als ist, sind die Auswirungen der Asynchronität gering. Dies heißt, daß der teilweise asynchrone Algorithmus und der synchronen nährungsweise bis zur Ordnung O(γ) das selbe Ergebnis liefern. Wir wissen aber, daß der synchrone Algorithmus onvergiert, also onvergiert auch der teilweise asynchrone. Ist Bγ dagegen größer als, dann liegt der asynchrone Fehler in der Größenordnung des s selbst und ist damit groß genug um Divergenz zu erzeugen. Obige Iteration ist ein Beispiel für einen Algorithmus der teilweise asynchron onvergiert, wenn B lein ist und für große B divergiert. Wenn die Verzögerungen lein sind, dann sind die Auswirungen der Asynchrnonität zu vernachlässigen. Große Verzögerungen haben dagegen eine staren Einfluß auf die Konvergenz. Dies tritt bei Iterationen auf, die eine leine Schrittweite benötigen.

8 FRANK LANGBEIN Betrachte die teilweise asynchrone Iteration Satz von Lyapunov x i (t + ) = x i (t) für t T i x i (t + ) = f i (x (τ i(t)), x (τ i(t)),..., x n(τn i (t))) i für t T Aus der teilweisen Asynchronität folgt, daß x(t + ) nur von x(t), x(t ),..., x(t B + ) abhängt und nicht von irgendeinem x(τ), τ t B. Da Informationen älter als B nicht verwendet werden führen wir den Vetor z(t) = (x(t), x(t ),..., x(t B + )) ein. Der Wert von x(t + ) ann nun aus z(t) berechnet werden und damit ann auch z(t + ) aus z(t) ermittelt werden. Indutiv folgt nun daß für jedes Scenario und jede positive ganze Zahl s der Wert von z(t + s) eindeutig durch z(t) bestimmt wird. Ist f stetig, dann ist z(t + s) eine stetige Funtion von z(t) für jedes s > 0 bei festem Scenario. Wir bezeichnen die Menge der Fixpunte von f mit Weiter sei und Für jedes Scenario gilt X = {x X : x = f(x)} Z = X B Z = {(x,..., x ) Z : x X} z(t) = z Z s > 0z(t + s) = z Satz von Lyapunov. Wir betrachten eine teilweise asynchrone Iteration. f sei stetig. Weiter existiere eine positive ganze Zahl t und eine stetig Funtion d : Z [0, ) mit den folgenden Eigenschaften (a) Für alle z(0) Z und für jedes Scenario gilt d(z(t )) < d(z(0)) (b) Für alle z(0) Z, für jedes t 0 und für jedes Scenario gilt d(z(t + )) d(z(t)) Dann ist jeder Grenzwert z Z der Folge {z(t)} ein Element von Z. Bemerungen: d(t) mißt den Abstand von z(t) zur Menge Z d(z(t)) fällt monoton Obiger Satz ist zu allgemein um sinnvolle Konvergenzraten zu liefern. Man jedoch zeigen, daß für lineare iterative teilweise asynchrone Algorithmen die Konvergenz geometrisch ist. Beweis. Da f stetig ist folgt, daß z(t ) eine stetige Funtion von z(0) für jedes Scenario ist. Da auch d stetig ist, ist d(z(t )) eine stetige Funtion von z(0) für jedes Scenario. Definiere h : Z, h(z(0)) = max{d(z(t )) d(z(0))} wobei daß Maximum über alle möglichen Scenarien angenommen wird. Obwohl es unendlich viele Scenarien gibt, betrachten wir nur ein Zeitintervall der Länge t. Damit gibt es nur endliche viele Möglicheiten, denn wird haben nur eine endliche Zahl von Variablen τ i j(t), 0 t t und jede dieser Variablen an nur B verschiedene Werte annehmen. Also wird das Maximum in der Definition von h über eine endiche Anzahl von Elementen gebildet. Für jedes Scenario ist d(z(t )) d(z(0)) eine stetige Funtion von z(0). Man sieht leicht, daß das

TEILWEISE ASYNCHRONE ALGORITHMEN 9 Maximum über eine endliche Zahl stetiger Funtionen wieder stetig ist. Also ist h stetig. Weiter gilt für jedes Scenario und jedes z(0) Z d(z(t )) d(z(0)) < 0 Also z Z h(z) < 0 Beachte, daß aus der Existenz eines Scenarios, daß mit z(0) = z startet und ein z(t ) = z erzeugt auch die Existenz eines Scenarios folg, daß mit z(t) = z zur Zeit t startet und z(t + t ) = z zur Zeit t + t erzeugt. Natürlich gilt dies aus umgeehrt. Deshalb ist obige Funtion h auch gegeben durch h(z(t)) = max{d(z(t + t )) d(z(t))} wobei das Maximum wieder über alle möglichen Scenarien gebildet wird. Sei nun das Scenario und z(0) fest gewählt. Aus (b) folgt, daß die Folge {d(z(t))} nicht wächst. Weiter ist sie nach unten durch 0 beschränt. Also onvergiert sie gegen ein d. Sei nun z Z ein Grenzwert von {z(t)}. Weiter sei {t } eine Folge, so daß {z(t )} gegen z onvergiert. Dann folgt d = lim d(z(t + t )) lim d(z(t )) + lim h(z(t )) = d + h(z ) Für alle z Z gilt h(z) < 0, also folgt z Z E-mail address: langbein@mathemati.uni-stuttgart.de