DAJ - 1 DAJ A Toolkit for the Simulation of Distributed Algorithms in Java.

Präsentation zum Thema: "DAJ - 1 DAJ A Toolkit for the Simulation of Distributed Algorithms in Java."—  Präsentation transkript:

1 DAJ - 1 DAJ A Toolkit for the Simulation of Distributed Algorithms in Java

2 DAJ - 2 1.Einführung in DAJ 2.Grundsätzlicher Aufbau von DAJ – Anwendungen 3.Beispielanwendung: Broadcast durch Fluten 4.Beispielanwendung: Token Ring 5.Zusammenfassung und Fazit Übersicht

3 DAJ - 3 1. Einführung in DAJ Einführung in DAJ 1.1 Der Autor

4 DAJ - 4 Einführung in DAJ – Wolfgang Schreiner Wolfgang Schreiner derzeit tätig am Institut für symbolisches Rechnen RISC – Johannes Kepler Universität, Linz, Österreich DAJ (1997) Distributed Maple (1998 - ?) Brokering Distributed Mathematical Services (2001-2003)

5 DAJ - 5 Einführung in DAJ 1.2 Definition und Ziel

6 DAJ - 6 DAJ (1997): Definition und Ziel „DAJ is a toolkit for designing, implementing, testing, simulating, and visualizing distributed algorithms in Java.“ (Schreiner) „ The goal of the toolkit is to provide an universally accessible platform for research and education in the area of distributed algorithms.“ (Schreiner)

7 DAJ - 7 Merkmale: bestehend aus einer Java Bibliothek mit einfacher Schnittstelle Nachrichtenbasiertes System Kommunikation zwischen Knoten durch Punkt-zu-Punkt Nachrichten in Kanälen die Knoten verbinden Selbstdefinierte Knotenprogramme werden auf den Knoten ausgeführt lokale Zeitmessungen in den Knoten sowie für die gesamte Applikation DAJ - Anwendungen ausführbar als eigenständige Anwendung oder Java - Applet Definition und Ziel

8 DAJ - 8 Definition und Ziel Ziel: Problem der hohen Abstraktion bei verteilten Systemen praktische Umsetzung der in der Lehre vorgestellten Algorithmen erleichtern schwergewichtige Bibliotheken (z.B. PVM) in der Ausbildung ersetzen leichtgewichtige Variante schaffen Transparenz nach unten schaffen

9 DAJ - 9 Visualisierung 1.2Visualisierung

10 DAJ - 10 Oberfläche

11 DAJ - 11 gleiche Oberfläche bei Applets und eigenständigen Applikationen Darstellung durch gerichteten Graphen Verschiedene Farbkombinationen geben Status wieder 1 Zeitschritt in der Anwendung entspricht einer Sende/Empfangsoperation Tooltips geben ebenfalls Informationen über Status Oberfläche

12 DAJ - 12 Darstellung eines einzelnen Knotens Name des Knotens Aktuelle lokale Zeit Eingehender Kanal Ausgehender Kanal Knoten mit der Bezeichnung „Master“ im initialen Zustand zwei Kanäle zum Senden bzw. Empfangen

13 DAJ - 13 Darstellung eines einzelnen Knotens Knoten „2“ im initialen Zustand und bereit zur Ausführung seines internen Programms Knoten „1“ im Zustand des blockierenden Wartens auf eine Nachricht aus dem linken eingehenden Kanal. Knoten „1“ empfängt eine Nachricht, die über den eingehenden Kanal eintrifft. Knoten „1“ hat die Nachricht aus dem Kanal empfangen und setzt seine lokale Zeit auf 1 Knoten 1 hat die Ausführung seines internen Programms beendet

14 DAJ - 14 Kanal ist leer, und der Knoten auf der Empfängerseite wartet auf eine Nachricht. Der Kanal enthält mindestens eine Nachricht. Darstellung eines Kommunikationskanal

15 DAJ - 15 2. Aufbau von DAJ Aufbau von DAJ

16 DAJ - 16 Unterscheidung von 3 Programmteilen: 1.Anwendung oder Applikation 2.Knotenprogramm 3.Nachrichten Ein Knotenprogramm läuft in einer eigenen Ausprägung auf einem Knoten und kommuniziert mithilfe von Nachrichten mit anderen Knoten (besser: deren Knotenprogrammen). Die Anwendung ist die Zusammenfassung aller Knoten und deren Überwachung. Aufbau von DAJ

17 DAJ - 17 3. Beispielanwendung: Broadcast durch Fluten Broadcast durch Fluten

18 DAJ - 18 Definition des Flutens beliebige Verkettung von Knoten mithilfe von bidirektionalen Verbindungen Broadcast in das Netz mithilfe von Fluten Auslöser sendet an alle Ausgänge die Nachricht Knoten nehmen Nachricht entgegen und senden ebenfalls auf deren Ausgänge die Nachricht (mit Ausnahme an den Knoten der die Nachricht gesendet hat) mögliche Erweiterung durch Einschränken der maximalen Anzahl von Knotenschritten (Hops) Grundlage für den Echo-Algorithmus

19 DAJ - 19 Arbeitsschritte zur Realisierung Erforderliche Arbeitsschritte um die Anwendung zu realisieren: 1. Nachrichten definieren 2. Knotenprogramme implementieren 3. Anwendung / Applikation definieren

20 DAJ - 20 Nachrichten definieren 1.Schritt (Nachrichten definieren): Vorraussetzung: Jeder eigene Nachrichtentyp muss die Klasse Message erweitern. für diese Anwendung wird nur ein Nachrichtentyp benötigt public class FloodMessage extends Message { // Knoten der die Flutnachricht versendet hat private FloodNode oSender = null; /** * Konstruktor mit Parameter des Absenders * @param oSender - Absender */ public FloodMessage(FloodNode oSender) { this.oSender = oSender; }

21 DAJ - 21 /** * Liefert den Absender der Nachricht * @return - Absender */ public FloodNode getSender() { return this.oSender; } /** * Methode liefert den Text der in * der Visualisierung für die Nachricht * angezeigt werden soll */ public String getText() { return "Aufruf zum Fluten von " + this.oSender.getNodeName(); } Nachrichten definieren

22 DAJ - 22 Knotenprogramme definieren Schritt 2 (Knotenprogramme implementieren): Vorraussetzung: Jedes eigene Knotenprogramm muss die abstrakte Klasse Program erweitern und die Methode main() implementieren. Die main()-Methode muss folgendes leisten: ein ausgezeichneter Knoten muss das Fluten starten Knoten muss eingehende Nachrichten empfangen weiterleiten der Nachricht auf alle ausgehenden Kanäle nicht weiterleiten auf einen Kanal auf dessen Empfängerseite der Absender sitzt den Knoten als geflutet markieren

23 DAJ - 23 Knotenprogramme definieren Definition der main()-Methode: public class FloodNode extends Program { … public void main() { if(this.in().getSize() != 0) { // Überprüfen, ob der Knoten die Flut starten soll if(this.bStartFlood) { // an alle ausgehenden Kanäle senden this.out().send(new FloodMessage(this)); // Knotenflag auf true setzen this.bFlooded = true; } else { - hier Behandlung des ausgezeichneten Knotens zum Starten des Flutens

24 DAJ - 24 Knotenprogramme definieren // den Kanal der eingehenden Nachricht bestimmen int iIndex = this.in().select(); // Nachricht aus dem Kanal abrufen FloodMessage oMsg = (FloodMessage) this.in(iIndex).receive(); // Auf allen ausgehenden Kanälen die Nachricht versenden for(int i = 0; i < this.out().getSize(); i++) { // den Knoten bestimmen der hinter dem Kanal empfängt Node oReceiver = ((Channel) this.out(i)).getReceiver(); //... nur nicht auf den Kanal senden, der Sender war if(!oReceiver.getProgram().equals(oMsg.getSender())) { this.out(i).send(new FloodMessage(this)); } // Flag setzen das Knoten in Flut erfasst wurde this.bFlooded = true; - Teil im else-Zweig, der die Behandlung der normalen Knoten übernimmt

25 DAJ - 25 Anwendung / Applikation definieren Schritt 3 (Anwendung / Applikation definieren): Vorraussetzung: Jede DAJ-Anwendung muss die abstrakte Klasse Application erweitern und die Methode construct() implementieren. public class FloodApplication extends Application { public FloodApplication() { // Fenster erstellen mit Titel und Größe super("Fluten des Netzes",500,400); } public static void main(String[] args) { // eine Applikation erstellen und ausführen (new FloodApplication()).run(); }

26 DAJ - 26 Anwendung / Applikation definieren public void construct() { // Zufallsgenerator konstruieren Random oRand = new Random(); // Feld von Knoten erstellen Node[] aNodes = new Node[7]; // einzelne Knoten erzeugen aNodes[0] = this.node(new FloodNode("Master", true),"Master",300,50); … // zufällige Verbindungen zwischen den Knoten schaffen for(int i = 0; i < aNodes.length; i++) { for(int j = 0; j < aNodes.length; j++) { if(oRand.nextBoolean()) this.link(aNodes[i],aNodes[j]); }

27 DAJ - 27 Die Anwendung ist in diesem Zustand nun ausführbar. Demonstration Das Einbinden der Anwendung als Applet würde folgendermassen aussehen: <APPLET code="Flood.FloodApplication.class" width=200 height=25 archive="daj.jar, awt.jar"> Leider kannst Du das Netz nicht fluten ! Anwendung / Applikation definieren

28 DAJ - 28 4. Beispielanwendung: Token Ring Token Ring

29 DAJ - 29 Zusammenschluss von Knoten in eine Ringstruktur Verbindung der Knoten über unidirektionale Kommunikationskanäle Token symbolisiert Senderecht Besitzer des Tokens sendet seine Nachricht, wartet bis diese einmal durch den Ring gegangen ist und sendet dann den Token an seinen Nachfolger Jeder Knoten der nicht das Senderecht besitzt leitet einkommende Nachrichten an seinen Nachfolger weiter Definition eines Token Ring

30 DAJ - 30 Erforderliche Arbeitsschritte um die Anwendung zu realisieren: 1.Token und Nachrichten definieren 2.Knotenprogramme implementieren 3.Anwendung / Applikation definieren 4.Möglicherweise Zusicherungen integrieren Realisierung mithilfe von DAJ

31 DAJ - 31 Schritt 1 (Token und Nachricht definieren): Token und Nachrichten definieren Vorraussetzung: Jeder eigene Nachrichtentyp muss die Klasse Message erweitern. Token: Der Token ist ein Symbol, er enthält also keine wirklichen Nutzdaten. (ausser man realisiert Piggy-Backing) public class Token extends Message { /** * Diese Methode wird aufgerufen, wenn man den * Tooltip eines Kanals abruft */ public String getText() { return "Token"; }

32 DAJ - 32 (Ring-)Nachricht beinhaltet den Absender und die eigentliche Textnachricht In diesem Fall private Attribute, die über get()-Methoden abfragbar sind Token und Nachrichten definieren public class RingMessage extends Message { private SingleNode oSender = null;// Absender private String sMessage = null;// Nachricht /** * Methode liefert den Inhalt der Nachricht. Wird * beim Tooltip im Kanal aufgerufen. */ public String getText() { return this.oSender.getNodeName() + " " + sMessage; }

33 DAJ - 33 Knotenprogramme definieren Schritt 2 (Knotenprogramme implementieren): Vorraussetzung: Jedes eigene Knotenprogramm muss die abstrakte Klasse Program erweitern und die Methode main() implementieren. Die main()-Methode muss folgendes leisten: eine ausgezeichnete Station muss den Token erzeugen auf eingehende Nachrichten warten unterscheiden ob ein Token oder Nachricht erhalten wurde bei empfangenem Token eigene Nachricht senden bei eigener empfangener Nachricht Token weitersenden bei fremder Nachricht zwischenspeichern und weiterleiten

34 DAJ - 34 Knotenprogramme definieren public class SingleNode extends Program {... public void main() { // Überprüfen, ob dieser Knoten der Master ist if(bMaster) { // Knoten ist der Master, er darf seine Nachricht als // erster senden out(0).send(new RingMessage(this, "Hallo an alle.")); // nun auf die eigene Nachricht warten this.oMessage = (RingMessage) in(0).receive(); // nun den Token weiterschicken out(0).send(new Token()); } Definition der main()-Methode mit Sonderbehandlung eines ausgezeichneten Knotens:

35 DAJ - 35 Knotenprogramme definieren // Schleife wird von jedem Knoten durchlaufen while(true) { // der Knoten wartet auf eine Nachricht Message oMsg = in(0).receive(); if(oMsg.getClass().equals(Token.class)) { // Nachricht ist ein Token, das bedeutet eigene // Nachricht senden... out(0).send(new RingMessage(this, "Hallo an alle.")); //... auf die eigene Nachricht warten... this.oMessage = (RingMessage) in(0).receive(); //... und Token weitersenden out(0).send(new Token()); } else { // Nachricht speichern... this.oMessage = (RingMessage) oMsg; //... und weiterleiten out(0).send(this.oMessage); }

36 DAJ - 36 Anwendung / Applikation definieren Schritt 3 (Anwendung / Applikation definieren): Vorraussetzung: Jede DAJ-Anwendung muss die abstrakte Klasse Application erweitern und die Methode construct() implementieren. public class TokenApplication extends Application { public TokenApplication() { // Titel und Größe des Fensters setzen super("Token-Ring", 500, 400); } public static void main(String[] args) { (new TokenApplication()).run(); }

37 DAJ - 37 Anwendung / Applikation definieren public void construct() { // Knoten erzeugen Node oMaster = this.node(new SingleNode("Master",true), "Master",250,50); Node oNode1 = this.node(new SingleNode("Knoten 1", false), "Knoten 1",400,150); Node oNode2 = this.node(new SingleNode("Knoten 2", false), "Knoten 2",330,270); Node oNode3 = this.node(new SingleNode("Knoten 3", false), "Knoten 3", 170, 270); Node oNode4 = this.node(new SingleNode("Knoten 4",false), "Knoten 4", 100,150); // Verknüpfungen zwischen den Knoten erstellen this.link(oMaster,oNode1); this.link(oNode1, oNode2); this.link(oNode2, oNode3); this.link(oNode3, oNode4); this.link(oNode4,oMaster); }

38 DAJ - 38 Anwendung / Applikation definieren Die Anwendung ist in diesem Zustand nun ausführbar. Demonstration Das Einbinden der Anwendung als Applet würde folgendermassen aussehen: <APPLET code="TokenRing.TokenApplication.class" width=200 height=25 archive="daj.jar, awt.jar"> Leider kannst Du nicht mit dem Token-Ring spielen !

39 DAJ - 39 Zusicherungen integrieren Schritt 4 (Zusicherungen integrieren): Folgende Aussagen können (oder sollen) über den Token-Ring getroffen werden: es befindet sich zu jeder Zeit immer genau ein Token im Ring es sendet immer nur der Knoten der den Token besitzt es befindet sich stets nur eine Nachricht im Ring In Java können solche Zusicherungen durch Einsatz des Schlüsselwortes assert realisiert werden. The assertion statement has two forms. The first, simpler form is: assert Expression1 ; where Expression1 is a boolean expression. When the system runs the assertion, it evaluates Expression1 and if it is false throws an AssertionError with no detail messageAssertionError (Java 1.4 API – Keyword: assert)

40 DAJ - 40 Zusicherungen integrieren Problem: Mithilfe von assert können nur die Programme auf den Knoten lokal, Zusicherungen geben, in einem verteilten, nebenläufigen System muss aber eine Aussage über den Gesamtzustand getroffen werden. Lösung in DAJ: Aussagen über den Gesamtzustand mithilfe der abstrakten Klasse GlobalAssertion. Eine GlobalAssertion erhält den Überblick über den Gesamtzustand des verteilten Systems, in dem es die Knotenprogramme zur Betrachtung benutzt. abstract class GlobalAssertion { abstract boolean assert(Program program[]) String getText() static Message[] getMessages(InChannel c) static Message[] getMessages(OutChannel c) }

41 DAJ - 41 Zusicherungen integrieren Beispiel: Umsetzung der Zusicherung - es befindet sich zu jeder Zeit immer genau ein Token im Ring mithilfe von GlobalAssertions public class SingleTokenAssertion extends GlobalAssertion { // Anzahl der gezählten Tokens private int iTokenCount = 0; /** * Text, der bei einem Fehlverhalten der Applikation ausgegeben * wird */ public String getText() { return "Ungültige Anzahl von Token im Ring enthalten: " + iTokenCount; }

42 DAJ - 42 Zusicherungen integrieren public boolean assert(Program[] aPrograms) { this.iTokenCount = 0; // Alle Programme durchlaufen und überprüfen, // und auf jedem Knoten hasToken aufrufen for(int i = 0; i < aPrograms.length; i++) { SingleNode oNode = (SingleNode) aPrograms[i]; if(oNode.hasToken()) iTokenCount++; // Überprüfen, ob in den Ausgangskanälen ein Token enthalten ist Message[] aMessages = GlobalAssertion.getMessages(oNode.out(0)); for(int j = 0; j < aMessages.length; j++) { if(aMessages[j].getClass().equals(Token.class)) this.iTokenCount++; } return (iTokenCount == 1); }

43 DAJ - 43 Zusicherungen integrieren Einbinden der GlobalAssertion in das Knotenprogramm: // Zusicherungen erzeugen GlobalAssertion oTokenAssert = new SingleTokenAssertion(); // Überprüfen, ob dieser Knoten der Master ist if(bMaster) { // Invariante prüfen assert(oTokenAssert); // Knoten ist der Master, er darf seine Nachricht als // erster senden out(0).send(new RingMessage(this, "Hallo an alle.")); // nun auf die eigene Nachricht warten this.oMessage = (RingMessage) in(0).receive(); // nun den Token weiterschicken this.bToken = false; out(0).send(new Token()); }

44 DAJ - 44 Mögliche Erweiterungen Visualisierung anpassen: Einstellen der Schriftarten Festlegen der Radien der Knoten Kanalbreite definieren Browser einstellen Ausführung anpassen: Scheduler zur Anpassung des Ablaufes von Knotenprogrammen (z.B. zur Implementierung von asynchronen Netzwerken etc.) Message Selector bietet die Möglichkeit die Reihenfolge von Nachrichten zu manipulieren (z.B. zum Simulieren von Duplizieren oder verlorenen Nachrichten)

45 DAJ - 45 Fazit 5.Fazit

46 DAJ - 46 Fazit Vorteile: + Einfache Installation der erforderlichen Pakete + Ebenfalls einfaches Einbinden der Bibliotheken in die IDE (hier mit Eclipse) + Einfach gehaltene Schnittstellen ermöglichen schnelle Implementierung einfacher Systeme + Kein zusätzliches Einarbeiten in eine eigene Definitionssprache + Plattform unabhängig durch Java + Implementierung von komplexen Algorithmen ist möglich Nachteile: - Darstellung wird bei mehr als 5 Knoten unübersichtlich - Darstellung von Abläufen über verschiedene Farbkombinationen unglücklich - kleinere Fehler beim Neuzeichnen nach Tooltips und Minimierung/Maximierung - Umständliches Programmieren zur Realisierung von Multicast/Broadcast - Trennen von Nachricht empfangen und Kanal leeren in zwei Schritten - umständliches Feststellen des Sender und Empfänger eines Kanals - aufwendiges Erstellen des Netzwerkes

47 DAJ - 47 Quellen [Schreiner] DAJ – Documentation, http://www.risc.uni-linz.ac.at/software/daj/http://www.risc.uni-linz.ac.at/software/daj/ [SUN] J2SE 1.4.2 API Specification, http://java.sun.com/j2se/1.4.2/docs/api/http://java.sun.com/j2se/1.4.2/docs/api/ [Schiller] Telematik Skript, Token Ring – Folie 5.208 [Löhr] Verteilte Systeme Skript, Abschnitt Einführung in Verteilte Systeme RISC Linz, Österreich - http://www.risc.uni-linz.ac.at/http://www.risc.uni-linz.ac.at/