DAJ
This presentation is the property of its rightful owner.
Sponsored Links
1 / 47

DAJ PowerPoint PPT Presentation


  • 63 Views
  • Uploaded on
  • Presentation posted in: General

DAJ. A Toolkit for the Simulation of Distributed Algorithms in Java. Übersicht. Einführung in DAJ Grundsätzlicher Aufbau von DAJ – Anwendungen 3.Beispielanwendung: Broadcast durch Fluten 4.Beispielanwendung: Token Ring 5.Zusammenfassung und Fazit. Einführung in DAJ.

Download Presentation

DAJ

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Daj

DAJ

A Toolkit for the Simulation of Distributed Algorithms in Java


Daj

Übersicht

  • Einführung in DAJ

  • Grundsätzlicher Aufbau von DAJ – Anwendungen

    3.Beispielanwendung: Broadcast durch Fluten

    4.Beispielanwendung: Token Ring

    5.Zusammenfassung und Fazit


Daj

Einführung in DAJ

1. Einführung in DAJ

1.1 Der Autor


Daj

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)


Daj

Einführung in DAJ

1.2 Definition und Ziel


Daj

Definition und Ziel

DAJ (1997):

„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)


Daj

Definition und Ziel

  • 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


Daj

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


Daj

Visualisierung

1.2Visualisierung


Daj

Oberfläche


Daj

Oberfläche

  • 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


Daj

Name des Knotens

Eingehender Kanal

Aktuelle lokale Zeit

Ausgehender Kanal

Darstellung eines einzelnen Knotens

  • Knoten mit der Bezeichnung „Master“ im initialen Zustand

  • zwei Kanäle zum Senden bzw. Empfangen


Daj

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


Daj

Darstellung eines Kommunikationskanal

Kanal ist leer, und der Knoten auf der Empfängerseite

wartet auf eine Nachricht.

Der Kanal enthält mindestens eine Nachricht.


Daj

Aufbau von DAJ

2. Aufbau von DAJ


Daj

Aufbau von DAJ

  • Unterscheidung von 3 Programmteilen:

    • Anwendung oder Applikation

    • Knotenprogramm

    • 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.


  • Daj

    Broadcast durch Fluten

    3. Beispielanwendung: Broadcast durch Fluten


    Daj

    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


    Daj

    Arbeitsschritte zur Realisierung

    Erforderliche Arbeitsschritte um die Anwendung zu realisieren:

    1. Nachrichten definieren

    2. Knotenprogramme implementieren

    3. Anwendung / Applikation definieren


    Daj

    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;

    }


    Daj

    Nachrichten definieren

    /**

    * Liefert den Absender der Nachricht

    * @return - Absender

    */

    public FloodNode getSender() {

    returnthis.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();

    }


    Daj

    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


    Daj

    Knotenprogramme definieren

    Definition der main()-Methode:

    - hier Behandlung des ausgezeichneten Knotens zum Starten des Flutens

    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 {


    Daj

    Knotenprogramme definieren

    - Teil im else-Zweig, der die Behandlung der normalen Knoten übernimmt

    // 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 warif(!oReceiver.getProgram().equals(oMsg.getSender())) {

    this.out(i).send(new FloodMessage(this));

    }

    }

    // Flag setzen das Knoten in Flut erfasst wurde

    this.bFlooded = true;


    Daj

    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();

    }


    Daj

    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]);

    }

    }

    }


    Daj

    Anwendung / Applikation definieren

    Die Anwendung ist in diesem Zustand nun ausführbar.

    Demonstration

    Das Einbinden der Anwendung als Applet würde folgendermassen aussehen:

    <APPLETcode="Flood.FloodApplication.class"width=200 height=25

    archive="daj.jar, awt.jar">

    <paramname=buttonLabel value="Klick mich zum Fluten">

    <paramname=fontName value="Arial">

    <param name=fontStylevalue="Bold">

    <param name=fontSizevalue=12>

    Leider kannst Du das Netz nicht fluten !

    </APPLET>


    Daj

    Token Ring

    4. Beispielanwendung: Token Ring


    Daj

    Definition eines Token Ring

    • 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


    Daj

    Realisierung mithilfe von DAJ

    Erforderliche Arbeitsschritte um die Anwendung zu realisieren:

    1.Token und Nachrichten definieren

    2.Knotenprogramme implementieren

    3.Anwendung / Applikation definieren

    • Möglicherweise Zusicherungen integrieren


    Daj

    Token und Nachrichten definieren

    Schritt 1 (Token und Nachricht 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)

    publicclass Token extends Message {

    /**

    * Diese Methode wird aufgerufen, wenn man den

    * Tooltip eines Kanals abruft

    */

    public String getText() {

    return"Token";

    }

    }


    Daj

    Token und Nachrichten definieren

    • (Ring-)Nachricht beinhaltet den Absender und die eigentliche Textnachricht

    • In diesem Fall private Attribute, die über get()-Methoden abfragbar sind

    publicclass 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() {

    returnthis.oSender.getNodeName() + " " + sMessage;

    }

    }


    Daj

    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


    Daj

    Knotenprogramme definieren

    Definition der main()-Methode mit Sonderbehandlung eines

    ausgezeichneten Knotens:

    publicclass SingleNode extends Program {

    ...

    publicvoid 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());

    }


    Daj

    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(newToken());

    } else {

    // Nachricht speichern ...

    this.oMessage = (RingMessage) oMsg;

    // ... und weiterleiten

    out(0).send(this.oMessage);

    }

    }


    Daj

    Anwendung / Applikation definieren

    Schritt 3 (Anwendung / Applikation definieren):

    Vorraussetzung: Jede DAJ-Anwendung muss die abstrakte Klasse

    Application erweitern und die Methode construct()

    implementieren.

    publicclass TokenApplication extends Application {

    public TokenApplication() {

    // Titel und Größe des Fensters setzen

    super("Token-Ring", 500, 400);

    }

    publicstaticvoid main(String[] args) {

    (new TokenApplication()).run();

    }


    Daj

    Anwendung / Applikation definieren

    publicvoid 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(newSingleNode("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);

    }


    Daj

    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">

    <param name=buttonLabel value="Klick mich für den Token-Ring">

    <param name=fontName value="Arial">

    <param name=fontStylevalue="Bold">

    <param name=fontSizevalue=12>

    Leider kannst Du nicht mit dem Token-Ring spielen !

    </APPLET>


    Daj

    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 message

    (Java 1.4 API – Keyword: assert)


    Daj

    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)

    }


    Daj

    Zusicherungen integrieren

    Beispiel:

    Umsetzung der Zusicherung

    - es befindet sich zu jeder Zeit immer genau ein Token im Ring

    mithilfe von GlobalAssertions

    publicclass SingleTokenAssertion extendsGlobalAssertion {

    // Anzahl der gezählten Tokens

    privateint iTokenCount = 0;

    /**

    * Text, der bei einem Fehlverhalten der Applikation ausgegeben

    * wird

    */

    public String getText() {

    return"Ungültige Anzahl von Token im Ring enthalten: " + iTokenCount;

    }


    Daj

    Zusicherungen integrieren

    publicboolean 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);

    }


    Daj

    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());

    }


    Daj

    Mögliche Erweiterungen

    • 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)

    • Visualisierung anpassen:

    • Einstellen der Schriftarten

    • Festlegen der Radien der Knoten

    • Kanalbreite definieren

    • Browser einstellen


    Daj

    Fazit

    5.Fazit


    Daj

    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


    Daj

    Quellen

    • [Schreiner] DAJ – Documentation, 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/

    • [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/


  • Login