Programmierung von JAM Agenten (Teil 1)

Einführung

Die JavaScript Agent Machine (JAM) ist eine unievrsele Agentenausführungsplattform für AgentJS Agenten. Ein Agent gehört zu einer Klasse die durch eine Konstruktionsfunktion beschrieben wird. Diese muss vier wesentliche Abschnitte definieren:

Körpervariablen: this.x=<init>
Aktivitäten (die Aktionen ausführen): this.act={ .. }
Übergänge zwischen Aktivitäten (transitions): this.trans={ .. }
Signal- und Ereignishandler (optional): this.on

Die JAM Plattform ist als Shell in diese Übung integriert. Es wird keine weitere Software benötigt.

Weitere Informationen finden sich im über die JAM Shell in jamsh.pdf, über JAM in jam2020.pdf, und zusammenfassend in diesem Buch jamabx.pdf.

JAM Plattform Shell

Eine Shell erzeugen. Nur einmal ausführen!

Shell({
  verbose:1
});

▸

✗

≡

Die Plattform beinhaltet u.A.:

AIOS: Das Agent-Input-Output System als Schnittstelle der Agenten zu der Hostplattform und definiert die Funktionen und Variablen die der Agent (neben JS Schlüsselwörtern) verwenden kann;
Einen Prozess Scheduler;
Ressourcenmanagement;
Code Serialisierung und Deserialisierung;
Kommunikationsmodule;
Tupelraumserver.

Plattformkonfiguration und Start der Shell

start()

▸

✗

Programmieren eines Agenten

Das Programmiermodell bildet das ATG Modell direkt ab:

Funktionales Modell
Aktivitäten, Übergänge und Ereignisroutinen werden als anonyme JavaScript Funktionen definiert.
Wichtig: Es müssen klassische Funktionen und keine Lambda Ausdrücke (Arrow Funktionen) verwendet werden. Der Grund liegt im this Objekt, welches bei Lambda Ausdrücken so nicht anwendbar ist bzw. einen anderen Kontext hat.
Innerhalb von Funktionen (teils sogar in Funktionen in Funktionen) kann der Agent sich selber mittels des this Objekts referenzieren, so auch den Zugriff auf Körpervariablen durchführen.
Aktivitäten sind benannt. Der Name darf kein AIOS und JS Schlüsselwort sein.
Es muss eine this.next Körpervariable geben die bei der Erzeugung eines Agentens die erste auszuführende Aktivität bezeichnet. Zur Laufzeit wird diese Variable die aktuell auszuführende Aktivität beinhalten.
Jede Konstruktorfunktion muss von der Agentenplattform unächst geprüft und "übersetzt" werden, u.A. vollständige Serialisierung und Deserialiserung um jegliche Bindungen nach "außen" zu kappen. Weiterhin wird dann die Konstruktorfunktion mit einem AIOS Befehlssatz verbunden.

Zunächst muss grob der ATG definiert werden, d.h. die Aufgabe eines Agenten in Aktivitäten partitioniert werden. Es ist immer sinnvoll eine Start- und eine Endaktivität zu definieren.

Eine einfache Agentenklasse myagent definieren und mit dem ATG füllen. Der Name der Konstruktorfunktion entspricht der Agentenklasse (wird später noch benötigt). Am Ende wird die Funktion von JAM "übersetzt" und die Agentenklasse in JAM publiziert.

function myagent (options) {
  this.x=options.x
  this.y=options.y
  this.z=0

  this.act = {
    start: function () {
      log('I am alive with '+[this.x,this.y])
    },
    compute : function () {
      if (this.x>this.y) this.x=this.x-this.y
      else this.y=this.y-this.x
    },
    result : function () {
      this.z=this.y||this.x
      log("Ergebnis ist "+this.z)
    },
    end : function () {
      log('I am dead');
      kill(me)
    }  
  }

  this.trans = {
    start : "compute",
    compute : function () {
      if (this.x==0) return result;
      else           return compute;
    }
  }

  this.next = start
}
// Die Agentenkosntruktionsfunktion prüfen und in dieser Plattform installieren
compile(myagent,{verbose:1})

▸

✗

Körpervariablen müssen immer initialisiert werden (ggfs. mit null). Alle Aktivitäten (Namen) stehen als Variablen zur Verfügung. Alternativ kann man Aktivitäten durch einen String und deren Name bezeichnen. Die Übergangsfunktion definiert den Übergang von der aktuellen (links) bezeichneten Aktivität zu der nächsten. Wird null oder udnefined zurück gegeben findet kein Übergang statt.

Agent erzeugen und starten

Agent erzeugen und starten

id=create('myagent',{
  x:10,
  y:20
},1);
print('Neuer Agent heisst '+id)

▸

✗

Frage 1. Was geht schief bei der Ausführung unseres Agenten der den GGT berechnen soll und wie reagiert die Plattform? Finde den Fehler (recherchiere den GGt Algorithmus) und korrigiere obigen Agentencode. Es gibt noch einen weiteren Fehler im trans Abschnitt. Korrigiere auch diesen so dass der Agent ein gültiges Ergebnis liefert.

Lösung.

In der Übergangsfunktion compute fehlt die Abfrage this.y==0, was zu einer endlosen Ausführungsschleife compute → computer führt.
Es fehlt der Übergang result → end, der den Agenten terminiert.

Zwei Agenten

Jetzt sollen zwei Agenten (mit zwei Agentenklassen) einmal als Konsument (Klient) und einmal als Produzent (Server) auftreten.

Der Server bietet den Dienst an den GGT zweier Zahlen zu berechnen.
Der Klient fordert die Berechnung an
Die Kommunikation findet über den Tupelraum statt
- Mittels out(['GGT',10,20]) wird eine Anfrage an den Serveragenten gesendet;
- Mittels inp(['GGT',_,_], function (t) { .. }) wird die Anfrage im Serveragenten entgegen genommen;
- Das Ergebnis wird mittels out(['GGT','RESULT',42]) wieder an den Klienten zurück gesendet, der mittels inp(['GGT',*RESULT',_],function (t) { .. } auf das Ergebnis wartet.

Die Callback Funktion der inp Funktion wird als Parameterargument entweder das vollständige Tupel als Array oder null enthalten (d.h. unterbrochen oder kein Tupel gefunden). Die Elemente können mit einem numerischen Index 0,1,2 usw. gelesen werden. Das formale Argument (Wildcard, Platzhalter) ist hier _ was null entspricht. Eine Aktivität wird solange angehalten bis inp terminiert. Wichtig: Es darf pro Aktivität nur eine blockierende Funktion aufgerufen werden. Also kein zwei inp Funktionen in einer Aktivität aufrufen.

Aufgabe 2. Programmiere nachfolgend beide Agentenklassen und teste den Ablauf und das Zusammenspiel der Agenten.

Server und Klientenklassen

function server (options) {

}
function client (options) {

}
compile(server,{verbose:1})
compile(client,{verbose:1})

▸

✗

Lösung.

VEJB

Wenn die Ausführung fehl schlägt können noch Tupel im Tupelraum verbleiben. Man kann statt out(..) auch mark(timeout,..) verwenden. Der Timeout kann auf 100 (ms) gesetzt werden. Oder jeder Agent entfernt alle Tupel die er aussenden würde (z.B. mit rm(['GGT',_,_],true).

Agenten erzeugen und starten

id1=create('server',{
},1);
print('Neuer Agent heisst '+id1)
id2=create('client',{
},1);
print('Neuer Agent heisst '+id1)

▸

✗

Hilfe

Einreichung (Assignment #2025-39929)

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.36.4 (c) Dr. Stefan Bosse (Fri May 16 2025 22:17:37 GMT+0200 (Central European Summer Time))