Verteilte Systeme CS5001

Transkript

1 Verteilte Systeme CS5001 Th. Letschert TH Mittelhessen Gießen University of Applied Sciences Wellen- und Traversierungsalgorithmen

2 Verteilte Systeme Wellenalgorithmen Seite 2

3 Wellen-Algorithmen Wellen-Algorithmen Klasse von Algorithmen bei denen Nachrichten nach einem bestimmten Schema versendet werden derart, dass alle Knoten an der Berechnung teilnehmen Wellen-Algorithmen können eingesetzt werden für Broadcast Synchronisation der Knoten Bestimmte verteilte Berechnungen als Bestandteil komplexerer Algorithmen Seite 3

4 Wellen-Algorithmen Definition Wellen-Algorithmen Ein verteilter Algorithmus ist ein Wellen-Algorithmus wenn gilt: (1) Terminierung Jede Berechnung ist endlich (2) Entscheidung Jede Berechnung C enthält mindestens ein Entscheidungsereignis (3) Abhängigkeit In jeder Berechnung C geht jedem Entscheidungsereignis e kausal ein Ereignis f in jedem Prozess q P voraus: C : e C : e ist Entscheidung ( q P : f Cp f : f e ) Bemerkung Bei einem Wellenalgorithmus wird eine endliche Zahl von Nachrichten ausgetauscht und jedes (wichtige / entscheidende) Ereignis wird kausal von einem Ereignis in jedem Prozess beeinflusst. Da kausale Ketten über Nachrichten gehen, werden die Entscheidungen von einer Nachricht und damit eventuell von dem Zustand jedes Prozesses beeinflusst. Seite 4

5 Wellen-Algorithmen Definition Initiator / Nachfolger Initiator (Starter) Ein Prozess, der seinen Algorithmus spontan mit einem internen Ereignis oder einem SendeEreignis beginnt, ist ein Initiator. Nachfolger (Follower, Nicht-Initiator) Ein Prozess der seinen Algorithmus mit einem Empfangs-Ereignis beginnt ist ein Nachfolger. Definition zentralisiert / dezentralisiert Zentralisiert (single-source) Bei einem zentralisierten Wellenalgorithmus wird jede Berechnung von genau einen Initiator initiiert. (Es muss aber nicht jede Berechnung den gleichen Prozess als Initiator haben.) Dezentralisiert (multi-source) Bei einem dezentralisierten Wellenalgorithmus kann eine Teilmenge der Prozesse die Berechnung initiieren. Seite 5

6 Wellen-Algorithmen Ausführungskontext Topologie Ein Algorithmus kann an eine spezielle Topologie angepasst sein (Ring, Baum, Klicke (jeder kennt jeden), etc. oder für jede Topologie geeignet sein. Initiales Wissen Der Algorithmus kann voraussetzen, dass in jedem Knoten ein bestimmtes Wissen zur Verfügung steht Identität des Prozesses Identität der Nachbarn... etc.... Seite 6

7 Wellen-Algorithmen Eigenschaften von Wellenalgorithmen Vorgänger Jedem Ereignis geht ein Ereignis in einem Initiator voraus, oder es ist ein solches. e C Initia tor p f Cp : f e Spannbaum Jede Berechnung eines Wellenalgorithmus (jede Welle ) mit einem Initiator definiert einen Spannbaum des Netzes, bei dem der Weg zur Wurzel in jedem Prozess durch den Kanal definiert wird, über den die erste Nachricht kam: Sei C eine Welle mit einzigem Initiator p und für jeden Nicht-Initiator q sei fatherq der Nachbar von dem q die erste Nachricht empfangen hat. (Dieser Empfang ist per Definition das erste Ereignis in q.) Der Graph (P, ET) ist Spannbaum des Netzes mit Ausgangspunkt p mit E T ={(q, r ): q r r= father q Seite 7

8 Wellen-Algorithmen Eigenschaften von Wellenalgorithmen Senden vor Entscheiden Jedem Entscheidungs-Ereignis in einem Prozess p geht ein Sende-Ereignis in jedem anderen Prozess voraus. Sei C eine Welle und dp ein Entscheidungs-Ereignis in p dann gilt: q p : f C q :( f d p f ist SendeEreignis) Seite 8

9 Wellen-Algorithmen Raum-Zeit-Diagramm p1 p2 Entscheidung p3 Jedem Entscheidungs-Ereignis geht kausal ein Ereignis in jedem Prozess voraus. Seite 9

10 Wellen-Algorithmen Generizität und Verwendbarkeit von Wellenalgorithmen Wellenalgorithmen zur Lösung fundamentaler Aufgaben Zur Lösung der fundamentalen Aufgaben Broadcast Synchronisation Globale Infimum-Berechnungen können die gleichen Algorithmen verwendet werden. Fundamentale Algorithmen sind Wellenalgorithmen Jeder Algorithmus, der Lösung der fundamentalen Aufgaben Broadcast Synchronisation Globale Infimum-Berechnungen eingesetzt werden kann, ist ein Wellenalgorithmus. Seite 10

11 PIF und Wellen Das PIF-Problem PIF : Propagation of Information with Feedback Eine Teilmenge der Prozessoren in einem Netz kennt eine Nachricht M. Diese Nachricht muss an alle verteilt werden. Einige Prozesse müssen bemerken / darüber benachrichtigt werden, dass die Verbreitung der Nachricht abgeschlossen ist, dass also jeder Prozess M kennt. Der Algorithmus muss in endlicher Zeit terminieren. Bemerkung Die am Anfang informierten Prozesse sind Initiatoren. Das Erkennen des Endes / die Benachrichtigung über das Ende der Verbreitung der Nachricht M ist ein Entscheidungs-Ereignis. Seite 11

12 PIF und Wellen PIF ~ Wellenalgorithmen PIF ~> Wellenalgorithmus Jeder PIF-Algorithmus ist ein Wellen-Algorithmus. Wellenalgorithmus ~> PIF Jeder Wellenalgorithmus kann zur Lösung des PIF-Problems (d.h. als PIF-Algorithmus) eingesetzt werden. Seite 12

13 Synchronisation und Wellen Das Synchronisations-Problem Synchronisation In jedem Prozess q muss ein Ereignis stattfinden und in einem Prozess p muss bemerkt werden, dass dies geschehen ist. Das Ganz muss in endlicher Zeit erfolgen. Bemerkung Das Synchronisationsproblem tritt auf, wenn im Takt erfolgen sollen. Beispielsweise wenn eine Berechnung in Schritten erfolgt und der nächste Schritt erst begonnen werden darf, wenn alle Prozesse den vorherigen abgeschlossen haben. Die Erkennen des Endes eines Takts ist ein Entscheidungs-Ereignis. Seite 13

14 Synchronisation und Wellen Synchronisation ~ Wellenalgorithmen Synchronisation ~> Wellenalgorithmus Jeder Synchronisations-Algorithmus ist ein Wellen-Algorithmus. Wellenalgorithmus ~> Synchronisation Jeder Wellenalgorithmus kann als Synchronisation-Algorithmus eingesetzt werden. Seite 14

15 Infimum und Wellen Infimum Infimum / Supremum: (X, ) ist eine halbgeordnete Menge Infimum (untere Schranke) c = inf(a,b) falls c a, c b, d, d a, d b: d c Supremum (obere Schranke) c = sup(a,b) falls a c, b c, d, a d, b b: c d Wenn Infimum / Supremum immer existiert, dann ist es eindeutig und seine Berechnung ist eine kommutative und assoziative Funktion. Verband (engl. Lattice ~ Gitter) und Halbverband Ein Halbverband (semi-lattice) ist eine Halbordnung in der jedes Paar von Elementen ein Infimum hat Ein Verband ist eine halbgeordnete Menge, in der jedes Paar von Elementen ein Infimum und ein Supremum hat Seite 15

16 Infimum und Wellen Infimum Satz Falls ein binärer Operator in einer Menge X mit folgenden Eigenschaften ist: (1) ist kommutativ x x = y x (2) ist assoziativ x (x z) = (x y) z (3) ist idempotent a a = a dann gibt es eine Halbordnung H = (X, ), derart dass die Infimum-Funktion in H ist. Bemerkung Die GGT-Funktion auf natürlichen Zahlen hat die drei Eigenschaften. Was ist die Halbordnung die kleiner-relation, in der der GGT die Infimum-Funktion ist? Die Mengenvereinigung auf einer beliebigen endlichen Potenzmenge hat die drei Eigenschaften. Was ist die Halbordnung die kleiner-relation, in der die Vereinigung die Infimum-Funktion ist? Seite 16

17 Infimum und Wellen Infimum-Probleme Verteilte Berechnung des Infimums In jedem Prozess p liegt ein Ausgangswert vp vor. Dieser Wert ist ein Element einer halbgeordneten Menge X mit Infimum-Funktion inf. Der Wert inf({vp p ε P) muss berechnet werden und eine Teilmenge der Prozesse muss über das Ergebnis und das Ende der Berechnung informiert sein. Bemerkung Die Kenntnis des Endes der Berechnung und des Ergebnisses ist das Entscheidungsereignis. Seite 17

18 Infimum und Wellen Infimum ~ Wellenalgorithmen Infimum ~> Wellenalgorithmus Jeder Infimum-Algorithmus ist ein Wellen-Algorithmus. Wellenalgorithmus ~> Infimum Jeder Wellen-Algorithmus kann als Infimum-Algorithmus eingesetzt werden. Bemerkung PIF, Synchronisation und Infimum-Berechnungen sind verwandte Problemstellungen die mit äquivalenten Strategien gelöst werden können. Seite 18

19 Beispiele für Wellenalgorithmen Beispiele für Wellenalgorithmen 1. Ring-Algorithmus Zentralisierter Algorithmus Topologie: Ring Initiator: next!token previous?token decide Follower: previous?token next!token Seite 19

20 Beispiele für Wellenalgorithmen 2. Baum-Algorithmus / Version 1 Dezentraler Algorithmus Topologie: Baum, alle Kanäle bidirektional Informal: Der Algorithmus startet mit den Blättern als Initiatoren. Jeder Prozess sendet eine Nachricht (in Richtung Wurzel), wenn er von all seinen Nachbarn bis auf einen eine Nachricht empfangen hat. Das Entscheidungs-Ereignis wird ausgeführt wenn der Nachbar, der nicht informierte, informiert wurde. Initiator / Follower: var recp=false foreach neighbor q do // Blätter haben nur einen Nachbarn, übergehen also die Schleife! number of recq with recq == false > 1 => q?token recq = true od // Von einem Nachbar ist keine Nachricht gekommen: sende an ihn let q0 suchthat rec[q0] == false in q0!token q0?token rec[q0] == true decide Seite 20

21 Beispiele für Wellenalgorithmen 2. Baum-Algorithmus / Version 1 In Version 1 des Baum-Algorithmus' entscheiden einige Knoten, andere nicht. Die die nicht entscheiden, warten ewig auf die letzte Nachricht. Initiator / Follower: var recp=false foreach neighbor q do // Blätter haben nur einen Nachbarn, übergehen also die Schleife! number of recq with recq == false > 1 => q?token recq = true od // Von einem Nachbar ist keine Nachricht gekommen sende an ihn let q0 suchthat rec[q0] == false in q0!token q0?token rec[q0] == true decide Seite 21

22 Beispiele für Wellenalgorithmen 2. Baum-Algorithmus / Version 1 In Version 1 des Baum-Algorithmus' entscheiden einige Knoten, andere nicht. Die die nicht entscheiden warten auf ewig auf die letzte Nachricht. p q p und q entscheiden. Alle anderen warten für immer auf die letzte Nachricht. Seite 22

23 Beispiele für Wellenalgorithmen 2. Baum-Algorithmus / Version 2 Initiator / Follower: var recp=false foreach neighbor q do // Blätter haben nur einen Nachbarn, übergehen also die Schleife! number of recq with recq == false > 1 => q?token recq = true od // Von einem Nachbar ist keine Nachricht gekommen sende an ihn let q0 suchthat rec[q0] == true in q0!token rec[q0] == true q0?token decide // Informiere über die Entscheidung: foreach neighbor q q0 do q!token od Seite 23

24 Beispiele für Wellenalgorithmen 3. Echo-Algorithmus Zentralisierter Algorithmus (ein beliebiger Initiator) Topologie: beliebig, alle Kanäle bidirektional Follower Initiator var rec = 0 var father =? var rec = 0 foreach Neighbor q do q!token od do rec < numberof(neighbors) => q?token rec = rec+1 od decide father?token rec = rec+1 foreach Neighbor q father do q!token od do rec < numberof(neighbors) => q?token rec = rec+1 od father!token Segalls Echo-Algorithmus nach Adrian Segall:Distributed Network Protocols IEEE Transactions on Information Theory, 29, 1 Seite 24

25 Beispiele für Wellenalgorithmen Implementierung des Echo-Algorithmus' (1) import import import import import akka.actor.actor akka.actor.actorref akka.actor.actorsystem akka.actor.props scala.collection.mutable.arraybuffer class var var var sealed abstract class Msg case class Start(neighbors: List[ActorRef]) extends Msg case object Token extends Msg class EchoInitiator extends Actor { var neighbors : List[ActorRef] = List() var rec = 0 def receive = { case Start(n) => { neighbors = n for (q <- neighbors) { q! Token case Token => { rec = rec + 1 if (rec == neighbors.length) { println("decide") Seite 25 EchoFollower(nr: Int) extends Actor { neighbors : List[ActorRef] = List() rec = 0 father : Option[ActorRef] = None def receive = { case Start(n) => { neighbors = n case Token => { if (!father.isdefined) { father = Some(sender) for (q <- neighbors) { if (q!= father.get) { q! Token rec = rec + 1 if (rec == neighbors.length) { println("actor " + nr + " is ready") father.get! Token

26 Beispiele für Wellenalgorithmen Implementierung des Echo-Algorithmus' (2) object WaveExample extends App { val system = ActorSystem("EchoSystem") val actor: List[ActorRef] = Range(0,8).map( i => if (i == 0) system.actorof(props(new EchoInitiator), name = "actor_"+i) else system.actorof(props(new EchoFollower(i)), name = "actor_"+i)).tolist actor(0) actor(1) actor(2) actor(3) actor(4) actor(5) actor(6) actor(7)!!!!!!!! Start(List(actor(1))) Start(List(actor(0), actor(2), actor(6))) Start(List(actor(3), actor(4))) Start(List(actor(2), actor(6))) Start(List(actor(2), actor(5), actor(7))) Start(List(actor(4))) Start(List(actor(7), actor(1))) Start(List(actor(4), actor(6))) Seite 26

27 Beispiele für Wellenalgorithmen 3. Echo-Algorithmus Der Echo-Algorithmus konstruiert einen optimalen Spannbaum der vom Initiator ausgeht. Optimal: Die schnellsten Wege werden bevorzugt in den Spannbaum übernommen. erste Nachricht Echo langsamer Weg schneller Weg Initiator wartet noch auf Nachricht oder Echo X hat Echo gesendet Spannbaum wird Teil des Spannbaums werden Seite 27

28 Anwendung Wellenalgorithmen Anwendung Wellenalgorithmus: verteilte Berechnung der Schnittmenge Problem: Die Knoten p P eines Netzes mit unbekannter Topologie enthalten jeweils eine Teilmenge sp der natürlichen Zahlen N. Berechne die Schnittmenge S = { sp : p P Seite 28

29 Anwendung Wellenalgorithmen Anwendung Wellenalgorithmus : verteilte Berechnung der Schnittmenge Problem ist Infimum-Berechnung: Berechnung der Schnittmenge ist: kommutativ, assoziativ, idempotent ( ist die Teilmengenbeziehung) Topologie beliebig ~> Echo-Algorithmus Seite 29

30 Anwendung Wellenalgorithmen Anwendung Wellenalgorithmus : verteilte Berechnung der Schnittmenge Aufgabe: Implementierung als Variante des Echo-Algorithmus! Seite 30

31 Anwendung Wellenalgorithmen Implementierung verteilte Schnittmenge (1) import import import import import akka.actor.actor akka.actor.actorref akka.actor.actorsystem akka.actor.props scala.collection.immutable.listset sealed abstract class Msg case class Start(neighbors: List[ActorRef], init: ListSet[Int]) extends Msg case class Token(msg : Set[Int]) extends Msg class var var var Initiator extends Actor { neighbors : List[ActorRef] = List() set : ListSet[Int] = ListSet() rec = 0 def receive = { case Start(n, s) => { neighbors = n set = s for (q <- neighbors) { q! Token(set) case Token(s) => { rec = rec + 1 set = set & s if (rec == neighbors.length) { println("decide: " + set) Seite 31

32 Anwendung Wellenalgorithmen Implementierung verteilte Schnittmenge (2) class var var var var Follower(nr: Int) extends Actor { neighbors : List[ActorRef] = List() set : Set[Int] = Set() rec = 0 father : Option[ActorRef] = None def receive = { case Start(n, s) => { neighbors = n set = s case Token(s) => { set = set & s rec = rec + 1 if (!father.isdefined) { father = Some(sender) for (q <- neighbors) yield { if (q!= father.get) { q! Token(set) if (rec == neighbors.length) { father.get! Token(set) Seite 32

33 Anwendung Wellenalgorithmen Implementierung verteilte Schnittmenge (3) object SetCut extends App { val initiator = system.actorof(props[initiator], name = "initiator") val actor: List[ActorRef] = Range(0,8).map(i => if (i == 0) system.actorof(props(new EchoInitiator), name = "actor_"+i) else system.actorof(props(new Follower(i)), name = "actor_"+i)). tolist actor(1) actor(2) actor(3) actor(4) actor(5) actor(6) actor(7) actor(0)!!!!!!!! Start(List(actor(0), actor(2), actor(6)), Start(List(actor(3), actor(4)), Start(List(actor(2), actor(6)), Start(List(actor(2), actor(5), actor(7)), Start(List(actor(4)), Start(List(actor(7), actor(1)), Start(List(actor(4), actor(6)), Start(List(actor(1)), ListSet[Int](2,3,4,5)) ListSet[Int](3,4,5,6)) ListSet[Int](1,2,3,4)) ListSet[Int](3,4)) ListSet[Int](3)) ListSet[Int](3,4,6,7,8)) ListSet[Int](2,3)) ListSet[Int](1,2,3,4)) Seite 33

34 Anwendung Wellenalgorithmen Anwendung Wellenalgorithmus : verteilte Berechnung der Summe Aufgabe: Implementierung als Variante des Echo-Algorithmus! Warum funktioniert das (nicht)? Seite 34

35 Verteilte Systeme Traversierungs-Algorithmen Seite 35

36 Traversierungs-Algorithmen Traversierungs-Algorithmen Klasse von Algorithmen Spezialfall von Wellenalgorithmen bei deren Ausführung alle Prozesse in sequenzielle Folge besucht werden. Sequentielle Folge: Die Folge der Ereignisse ist total geordnet und das erste und das letzte Ereignis erfolgen im gleichen Prozess Zu jedem Zeitpunkt ist entweder gerade ein Prozess mit der Verarbeitung einer Nachricht beschäftigt, oder eine Nachricht ist gerade unterwegs D.h. Eine Marke / ein Token wandert deterministisch durch das Netz Seite 36

37 Traversierungs-Algorithmen Definition Traversierungs-Algorithmus Ein verteilter Algorithmus ist ein Traversierungs-Algorithmus wenn gilt: (1) In jeder Berechnung gibt es einen Initiator der den Algorithmus mit dem Versenden genau einer Nachricht beginnt. (2) Ein Prozess, der eine Nachricht empfängt, sendet entweder eine Nachricht oder entscheidet. (3) Der Algorithmus terminiert im Initiator und wenn dies geschieht, dann hat jeder Prozess mindestens eine Nachricht gesendet. Seite 37

38 Traversierungs-Algorithmen Beispiel Traversierungs-Algorithmus Der Ring-Algorithmus ist ein Traversierungs-Algorithmus. Initiator: next!token previous?token decide Follower: 6 previous?token next!token 4 5 Seite 38

39 Traversierungs-Algorithmen Definition Clique Ein vollständiger Graph, oder eine Clique, ist ein Graph bei dem jedes Knotenpaar durch eine Kante verbunden ist. Eine Clique kann mit dem sequentiellen Polling-Algorithmus traversiert werden. Dabei kontaktiert ( pollt ) der Initiator einen Nachbarn nach dem anderen. I F F F Seite 39

40 Traversierungs-Algorithmen Algorithmus Sequentielles Polling Traversierungs-Algorithmus Topologie: Clique Initiator: var rec=0 do rec < numberof(neighbors) => neighborrec+1!token neighborrec+1?token rec = rec+1 od decide 1 I F 2 3 F F Follower: q?token q!token Bemerkung Für weitere spezielle Topologien gibt es weitere spezielle Traversierungsalgorithmen. Seite 40

41 Traversierungs-Algorithmen Tarrys Algorithmus Traversierungs-Algorithmus Topologie: beliebig (Kanten bidirektional) Prinzip der Weitergabe des Tokens: Ein Prozess gibt das Token nie zweimal über den selben Kanal weiter Ein Prozess, der nicht der Initiator ist, gibt das Token niemals seinem Vorgänger /Vater (der Prozess, von der er das Token erhalten hat) bevor er es nicht jedem anderen Nachbarn gegeben hat. Bemerkung Jede Berechnung definiert einen Spannbaum mit dem Initiator als Wurzel und der Vorgänger/Vater definiert die Richtung zur Wurzel. Seite 41

42 Traversierungs-Algorithmen Tarrys Algorithmus (1) Initiator: var used[q] = false forall neighbors q chooseany neighbor q: used[q] = true q!token do q0?token => if forall neighbors q: used[q] = true then decide else od fi if thereis neighbor q suchthat not used[q] then chooseany neighbor q suchthat not used[q] in { used[q] = true q!token fi Seite 42

43 Traversierungs-Algorithmen Bemerkung Tarrys Algorithmus (2) G. Tarry: Le Problème des labyrinthes Nouvelles Annales de Mathématique, 14 (1894) Follower: var used[q] = false forall neighbors q var father =? do q0?token => if father = undefined then father = q0 fi if forall neighbors q: used[q] = true then decide else od fi if thereis neighbor q suchthat q father and not used[q] then chooseany neighbor q suchthat not q = father and not used[q] in { used[q] = true; q!token else used[father]=true; father!token fi Seite 43

44 Traversierungs-Algorithmen Tarrys Algorithmus Implementierung (1) import import import import akka.actor.actor akka.actor.actorref akka.actor.actorsystem akka.actor.props sealed abstract class Msg case class Start(neighbors: List[ActorRef]) extends Msg case object Token extends Msg class TarryInitiator extends Actor { var neighbors : List[ActorRef] = List() var unused : List[ActorRef] = List() def receive = { case Start(n) => { neighbors = n unused = n val q = unused(0) unused = unused.tail q! Token case Token => { if (unused.length == 0) { println("initiator decide") else { val q = unused(0) unused = unused.tail q!token Seite 44

45 Traversierungs-Algorithmen Tarrys Algorithmus Implementierung (2) class var var var TarryFollower(nr: Int) extends Actor { neighbors : List[ActorRef] = List() father : Option[ActorRef] = None unused : List[ActorRef] = List() def m(i:int) : Int = i+1 def receive = { case Start(n) => { neighbors = n unused = n case Token => { if (!father.isdefined) { father = Some(sender) if (unused.length == 0) { println("follower " + nr + " else { val q : Option[ActorRef] = if (q.isdefined) { unused = unused.filter(_ q.get! Token else { unused = unused.filter(_ father.get! Token decide!") unused.find(_!= father.get)!= q.get)!= father.get) Seite 45

46 Traversierungs-Algorithmen Tarrys Algorithmus Beispiel object Tarry extends App { val system = ActorSystem("TarrySystem") val actor: List[ActorRef] = Range(0,5).map(i => if (i == 0) system.actorof(props(new TarryInitiator), name = "actor_"+i) else system.actorof(props(new TarryFollower(i)), name = "actor_"+i)). tolist actor(1) actor(2) actor(3) actor(4) actor(0)!!!!! Start(List(actor(0), actor(2), actor(4))) Start(List(actor(1))) Start(List(actor(0), actor(4))) Start(List(actor(0), actor(1), actor(3))) Start(List(actor(4), actor(1), actor(3))) Weg des Tokens Rot: Nachricht zum Vorgänger 3 Seite Spannbaum definiert über die Vorgänger

47 Traversierungs-Algorithmen Tiefensuche (Depth-first Search) Traversierungs-Algorithmus Topologie: beliebig (Kanten bidirektional) Prinzip der Weitergabe des Tokens: Ein Prozess gibt das Token nie zweimal über den selben Kanal weiter Ein Prozess, der nicht der Initiator ist, gibt das Token niemals seinem Vorgänger /Vater (der Prozess, von der er das Token erhalten hat) bevor er es nicht jedem anderen Nachbarn gegeben hat. Ein Prozess gibt das Token an den Prozess von dem er es erhalten hat, falls dies nicht den anderen Prinzipien widerspricht. Bemerkung Der Algorithmus ist eine Spezialisierung von Tarrys Algorithmus. Seite 47

48 Traversierungs-Algorithmen Tiefensuche (Depth-first Search) (1) Initiator: var used[q] = false forall neighbors q chooseany neighbor q: used[q] = true q!token do q0?token => if forall neighbors q: used[q] = true then decide else od fi if thereis neighbor q suchthat not used[q] then if not used[q0] then q = p0 else q = chooseany neighbor suchthat not used[q] fi used[q] = true q!token fi Seite 48

49 Traversierungs-Algorithmen Tiefensuche (Depth-first Search) (2) Follower: var used[q] = false var father = undefined do q0?token => if father = undefined then father = q0 fi if forall neighbors q: used[q] = true then decide od else if thereis neighbor q suchthat q father and not used[q] then if not used[q0] and not q0 = father then q = p0 else q = chooseany neighbor suchthat not used[q] and not q = father fi used[q] = true; q!token else used[father]=true; father!token fi Seite 49 Unterschied zu Tarrys Algor.: Das Token wird bevorzugt zurück gesendet.

50 Wellen- und Traversierungs-Algorithmen Quellen-Hinweis Diese Folien basieren im Wesentlichen* auf : Kapitel 6, Abschnitt 1 3 in: G. Tel: Introduction to Distributed Algorithms Cambridge University Press, 2te Auflage, erster Nachdruck 2001 *Die Notation der Algorithmen wurde mit dem Ziel der verbesserten Verständlichkeit leicht modifiziert. Seite 50