PD Stefan Bosse
Universitรคt Bremen - Fachbereich Mathematik und Informatik
SS2020
2020-06-17 sbosse@uni-bremen.de |
Verteilte Datenverarbeitung bedeutet verteilte Kommunikation zwischen Prozessen
Traditionelle verteilte Netzwerke wie das Internet der Dinge (IoT) mรผssen mit einer Vielzahl von Kommunikationsprotokollen und Netzwerkstrukturen umgehen kรถnnen → Stark heterogene Systeme
Datenreprรคsentation ist eine weitere Hรผrde in solchen verteilten Systemen
Hรคufig HTTP basierte Klienten-Server Kommunikation (zentrale Serverinstanz)
Agenten besitzen eine Vielzahl von Fรคhigkeiten, die sie von klassischen Programmen unterscheiden - obwohl Agenten auch Programme sein kรถnnen!
Fรคhigkeit zu eigenstรคndiger Aktivitรคt (Nicht Nutzeraktiviert)
Autonomes, “selbstbestimmtes” Verhalten (Nicht durch zentrale Instanz gesteuert)
Fรคhigkeit zum selbststรคndigen Schlussfolgern (Umgang mit unsicheren Wissen)
Flexibles und rationales Verhalten (Adaptivitรคt an verรคnderliche Weltbedingungen)
Fรคhigkeit zu Kommunikation und Interaktion (Synchronisation)
Kooperatives oder konkurrierendes Verhalten (Lรถsung von Wettbewerbskonflikten)
Fรคhigkeit zur ziel- und aufgabenorientierten Koordination (Kooperation)
Ein Agent in seiner Umgebung nimmt sensorische Eingaben aus der Umgebung auf und produziert Ausgabe-Aktionen, die ihn und die Umgebung beeinflussen.
Die Interaktion ist gewรถhnlich fortlaufend und nicht-terminierend!
Einfachstes Agentenmodell[J] | Beispiel
|
Das Verhalten eines aktivitรคtsbasierten Agenten ist durch einen Agentenzustand gekennzeichnet, der durch Aktivitรคten verรคndert wird.
Aktivitรคten verarbeiten Wahrnehmungen, planen Aktionen und fรผhren Aktionen aus, die den Steuerungs- und Datenzustand des Agenten รคndern.
Aktivitรคten und รbergรคnge zwischen Aktivitรคten werden durch einen Aktivitรคtsรผbergangsgraphen (Activity Transition Graph, ATG) dargestellt.
Die รbergรคnge starten Aktivitรคten in der Regel abhรคngig von der Auswertung von Agentendaten (Kรถrpervariablen), die den Datenzustand des Agenten reprรคsentieren.
Ein Aktivitรคtsรผbergangsgraph, der mit Agentenklassen assoziiert ist, besteht aus einer Menge von Aktivitรคten 𝔸 = {A1, A2, ..} und einer Menge von รbergรคngen 𝕋 = {T1 (C1), T2 (C2), ..}, die die Kanten des gerichteten Graphen darstellen.
Die Ausfรผhrung einer Aktivitรคt, die selbst aus einer Folge von Aktionen und Berechnungen besteht, ist mit dem Erreichen eines Unterzieles oder das Erfรผllen einer Voraussetzung verknรผpft, um ein bestimmtes Ziel zu erreichen, z. B. Sensordatenverarbeitung und Verteilung von Informationen.
Normalerweise werden Agenten verwendet, um komplexe Aufgaben zu zerlegen basierend auf der Zerlegung durch MAS.
Agenten kรถnnen ihr Verhalten basierend auf Lern- und Umgebungsรคnderungen oder durch Ausfรผhren einer bestimmten Unteraufgabe mit nur einer Untermenge des ursprรผnglichen Agentenverhaltens รคndern → Dynamische ATG.
Ein ATG beschreibt das vollstรคndige Agentenverhalten.
Jedes Unterdiagramm und jeder Teil des ATG kann einem Unterklasseverhalten eines Agenten zugeordnet werden.
Daher fรผhrt das Modifizieren der Menge von Aktivitรคten 𝔸 und รbergรคngen 𝕋 des ursprรผnglichen ATG zu mehreren Unter- und Oberverhaltensweisen, die Algorithmen implementieren, um verschiedene unterschiedliche Ziele zu erfรผllen.
Die Rekonfiguration der Aktivitรคten fรผhrt zu einer Menge von Aktivitรคtsmengen 𝔸* = {𝔸i ⊂ 𝔸, 𝔸j ⊂ 𝔸, 𝔸k ⊃ 𝔸, ..}, die von der ursprรผnglichen Menge 𝔸 abgeleitet sind, und die Modifikation oder Rekonfiguration von รbergรคngen 𝕋* = {𝕋1 ⊂ 𝕋, 𝕋2 ⊂ 𝕋, ..} ermรถglicht die dynamische ATG-Zusammensetzung (Komposition) und Agentenunterklassifizierung zur Laufzeit,
ATG eines einfachen Umfrageagenten mit Unterklassen (master, requester, worker)
Eine Agentenklasse beschreibt ein bestimmtes Verhalten eines Agenten mittels eines ATG und einer Menge von Kรถrpervariablen.
Eine bestimmte Agentenklasse ACi bezieht sich auf das zuvor eingefรผhrte ATG Modell, dass das Laufzeitverhalten und die von Agenten ausgefรผhrten Aktion definiert.
Ein Agent interagiert mit seiner Umgebung, indem er eine Datenรผbertragung unter Verwendung eines einheitlichen Tupelraums mit einer koordinierten datenbankรคhnlichen Schnittstelle durchfรผhrt.
Daten aus der Umgebung beeinflussen das folgende Verhalten und die Aktion eines Agenten. Daten, die an die Umgebung (z.B. die Datenbank) weitergegeben werden, beeinflussen das Verhalten anderer Agenten.
Eine Agentenklasse ACi ist daher zunรคchst definiert durch das folgende Mengentupel:
Definition 1.
Es gibt ein Multiagentensystem (MAS), das aus einer Reihe einzelner Agenten besteht (ag1, ag2, ..). Es gibt verschiedene Verhaltensweisen fรผr Agenten, die als Klassen AC = {AC1, AC2, ..} bezeichnet werden. Ein Agent gehรถrt zu einer dieser Klassen.
Jede Agentenklasse wird dann durch das erweiterte Tupel AC = <𝔸, 𝕋, 𝔽, 𝕊, ℍ, 𝕍, ℙ> angegeben.
Definition 2.
In einer spezifischen Situation ist ein Agent agi an einen Netzwerkknoten Nm,n,o,.. (z.B. Mikrochip, Computer, virtueller Simulationsknoten) an einem eindeutigen rรคumlichen Ort (m, n, o, ..) gebunden und wird dort verarbeitet.
Es gibt eine Menge verschiedener Knoten N = {N1, N2, ..}, die z.B. in einem maschenartigen Netzwerk mit einer Nachbarverbindung (z.B. vier in einem zweidimensionalen Gitter) angeordnet sind. Die Knotenverbindung kann dynamisch sein und sich im Laufe der Zeit รคndern. Die Knotennachbarn sind unterscheidbar.
Jeder Knoten ist in der Lage, eine Anzahl von Agenten ni(ACi) zu verarbeiten, die zu einer Agentenverhaltensklasse ACi gehรถren, und mindestens eine Teilmenge von AC' ⊂ AC zu unterstรผtzen.
Ein Agent (oder zumindest sein Zustand) kann zu einem Nachbarknoten migrieren wo er weiter ausgefรผhrt wird.
Tupel-Rรคume stellen ein assoziiertes Shared-Memory-Modell dar, wobei die gemeinsam genutzten Daten als Objekte mit einer Reihe von Operationen betrachtet werden, die den Zugriff der Datenobjekte unterstรผtzen
Tupel sind in Rรคumen organisiert, die als abstrakte Berechnungsumgebungen betrachtet werden kรถnnen.
Ein Tupelraum verbindet verschiedene Programme, die verteilt werden kรถnnen, wenn der Tupel-Space oder zumindest sein operativer Zugriff verteilt ist.
Das Tupelraum Organisations- und Zugangsmodell bietet generative Kommunikation, d.h. Datenobjekte kรถnnen in einem Raum durch Prozesse mit einer Lebensdauer รผber das Ende des Erzeugungsprozesses hinaus gespeichert werden.
Ein bekanntes Tupelraum-Organisations- und Koordinationsparadigma ist Linda [GEL85].
Die Daten sind mit Tupeln organisiert.
Ein Tupel ist eine lose gekoppelte Verbindung einer beliebigen Anzahl von Werten beliebiger Art /Typ/
Ein Tupel ist ein Wert und sobald es in einem Tupelraum gespeichert ist, ist es persistent.
Tupeltypen รคhneln den Datenstrukturtypen, sie sind jedoch dynamisch und kรถnnen zur Laufzeit ohne statische Beschrรคnkungen erstellt werden.
Auf die Elemente von Tupeln kann nicht direkt zugegriffen werden, was รผblicherweise Mustererkennung und musterbasierte Dekomposition erfordert, im Gegensatz zu Datenstrukturtypen, die einen benannten Zugriff auf Feldelemente bieten, obwohl die Behandlung von Tupeln als Arrays oder Listen diese Beschrรคnkung lรถsen kann.
Ein Tupel mit n Feldern heiรt n-stellig und wird in der Notation <v1, v2, ..> angegeben.
function (t:tuple)
function (p:pattern, callback: function (tuple|tuple[]|null),all?:boolean)
Die Ausfรผhrung der Eingabeoperation entfernt ein Tupel t aus dem Tupelraum, der der Mustervorlage p entspricht. Wenn kein passendes Tupel gefunden wird fรผhrt das zu einer Blockierung des aufrufenden Prozesses bis ein passendes Tupel eingestellt wird.
function (p:pattern, cb:function (tuple|tuple[]|null),all?:boolean)
Die Ausfรผhrung der Leseoperation gibt eine Kopie eines Tupels t zurรผck, dass der Vorlage p entspricht, entfernt sie jedoch nicht. Wenn kein passendes Tupel gefunden wird fรผhrt das zu einer Blockierung des aufrufenden Prozesses bis ein passendes Tupel eingestellt wird.
out(["Sensor",1,100]);
out(["Sensor",2,121]);
inp(["Sensor",1,_], function (t) { if (t) v=t[2]; });
inp(["Sensor",_,_], function (t) { if (t) n=t[1],v=t[2] });`
rd(["Sensor",_,_], function (t) { if (t) n=t[1],v=t[2] });`
function (0,p:pattern,callback?:function,all?:boolean) → tuple|tuple[]|null
Nichtblockierende Version von inp/rd. Wird kein passendes Tupel gefunden wird die Operation ergebnislos terminiert.
function (tmo:number,p:pattern,callback:function,all?:boolean) → tuple|tuple[]|null
Teilblockierende Version von try_inp/try_rd, Wird innerhalb einer Zeit von tmo kein passendes Tupel gefunden wird die Operation ergebnislos abgebrochen.
function (pattern) → boolean
Nicht blockierender Test eines Tupels.
function (pattern,function (tuple) → tuple)
Nicht blockierender Test eines Tupels und atomare Verรคnderung eines Tupels, dass der Vorlage p entspricht. Das zweite Argument ist eine Abbildungsfunktion. Das Ergebnistupel ersetzt das ursprรผngliche.
function (p:pattern,all?:boolean)
Entfernung eines oder aller passenden Tupel.
function (tmo:number,t:tuple)
function (pattern [], function (tuple|tuple[]|null),all?:boolean)
Produzent
| Konsument
|
Betrachte das zeitliche Verhalten im obigen Beispiel (Laufzeiteigenschaften)
Was kรถnnte im Produzenten-Konsumenten System mรถglicherweise falsch laufen?
Wie mรผsste der Agentencode geรคndert werden um Laufzeitfehler zu vermeiden?
Tupleraumkommunikation ist
Eignet sich daher fรผr die Kommunikation von lose gekoppelten Ensembles
Neben diesen lose gekoppelten Gruppen gibt es durch Replikation von Kindagenten Gruppen mit starker Kopplung und Kenntnis der Identiรคten
myParent()
erfahren.
Signale sind zielgerichtete Nachrichten mit identifizierbaren Absender und Empfรคnger (wobei es bei Multi- und Broadcastnachrichten viele geben kann)
Ein Signal signal(arg) besteht aus einem Signalnamen oder einer Signalnummer mit einem optionalen Argument.
Signale mรผssen auf Empfรคngerseite mit einem Signalhandler im this.on
Abschnitt des Agentenmodells eingerichtet werden.
function (target:id,signal:string|number,arg?:*)
Sendet eine Signalnachricht signal(arg) an den Empfรคngeragenten target.
function (ac:string,r:number,signal:string|number,arg?:*)
Sendet eine Signalnachricht signal(arg) an alle Empfรคngeragenten der Klasse ac im Radius r.
function (arg,from)
Ein Signalhandler fรผr das Signal signal.
Produzent
| Konsument
|
Ein Agent in Ausfรผhrung wird durch einen Prozess reprรคsentiert.
Der Prozesszustand setzt sich zusammen aus:
Mobile Agenten bedeuten mobile Prozesse!
Bei der Migration muss ein Agentenprozess in einen
Eine Agentenplattform reprรคsentiert einen physikalischen Knoten in einem Virtuellen Netzwerkgraphen
Ports von Plattformen verbinden und stellen Links her
Ein Agent kann auf einen anderen Knoten (Plattform) migrieren indem er die moveto Operation ausfรผhrt (innerhalb einer Aktivitรคt):
DIR.NODE(<nodename>
), eine IP Adresse (DIR.IP(<url>)
), oder bei gerichteten Verbindungen die Richtung sein (z.B. DIR.NORTH
)
{
var connected=link(DIR.IP('%'));
if (connected.length) {
var next = random(connected);
moveto(DIR.NODE(next));
}
}
Vollstรคndig in JavaScript programmiert
Portabel:
Schlank: ca 1M Byte JS Code
AgentJS Code kann direkt ausgefรผhrt werden (nur Sandboxing erforderlich)!
Eine physische JAM kann eine Vielzahl von virtuellen JAM Knoten ausfรผhren (nur sequenzielles Scheduling)
In der realen Welt ist die Anwendungssicherheit ein wichtiges Schlรผsselmerkmal einer verteilten Agentenplattform.
Die Ausfรผhrung von Agenten und der Zugriff auf Ressourcen mรผssen kontrolliert werden, um Denial-of-Service-Angriffe, Agent-Masquerading, Spionage oder anderen Missbrauch zu verhindern.
Daher haben Agenten unterschiedliche Zugriffsebenen (Rollen):
Die unterste Ebene (0) ermรถglicht keine Agentenreplikation, Migration oder das Erstellen neuer Agenten.
Die JAM-Plattform entscheidet รผber die Sicherheitsstufe fรผr neue empfangene Agenten. Ein Agent kann keine Agenten mit einer hรถheren Sicherheitsstufe als die eigene erstellen.
Die hรถchste Stufe (3) hat einen erweiterten AIOS mit Host-Plattform-Gerรคtezugriffsfรคhigkeiten.
Agenten kรถnnen Ressourcen (z.B. CPU-Zeit) aushandeln und ein Level-Raise erreichen, das mit einem Schlรผssel gesichert ist, der die erlaubten Upgrades definiert.
Der Schlรผssel ist knotenspezifisch. Eine Gruppe von Knoten kann sich einen gemeinsamen Schlรผssel teilen (durch einen Server-Port identifiziert der den JAM Knoten identifiziert).
Ein Schlรผssel besteht aus einem Server-Port, einem Rechtefeld und einem verschlรผsselten Schutzfeld das das Rechtefeld enthรคlt, das mit einem zufรคlligen Port generiert wird, der nur dem Server (Knoten) bekannt ist.
Das Rechtefeld ist zentral da es die durch die Capability erlaubten Operationen angibt.
Damit das Rechtefeld nicht manipuliert werden kann ohne dass die Capability ungรผltig wird (und ggf. die Objektnummer) wird ein Schutzfeld erstellt welches die Rechte mit einem privaten Schlรผssel (Port) mittels einer One-way Funktion verschlรผsselt.
JAM Plattformen kรถnnen in beliebigen Netzwerken miteinander verbunden werden.
Eine Vielzahl von Kommunikationsprotokolle sind verwendbar:
Beliebige Netzwerktoplogien kรถnnen gebildet werden (physisch wie logisch):
AMP: Agent Management Port als gemeinsames Protokoll und Interface in heterogenen Systemen
Variablen werden mit dem Schlรผsselwort var
definiert → Erzeugung eines Datencontainers!
Es gibt keine Typdeklaration in JS! Kerntypen:
Tcore={number, boolean, object, array, string, function}
Alle Variablen sind polymorph und kรถnnen alle Werttypen aufnehmen.
Bei der Variabledefinition kann ein Ausdruckswert zugewiesen werden
var v = ε,..; v = ε;
Funktionen kรถnnen mit einem Namen oder anonym definiert werden
Funktionen sind Werte 1. Ordnung → Funktionen kรถnnen Variablen oder Funktionsargumenten zugewiesen werden
Eine Funktion kann einen Wert mit der return
Anweisung zurรผckgeben. Ohne explizite Wertrรผckgabe → undefined
Es wird nur Call-by-value Aufruf unterstรผtzt - jedoch werden Objekte, Funktionen und Arrays als Referenz รผbergeben; Parameter pi sind an Funktionsblock gebunden
function name (p1,p2,..) { statements ; return ε } name(ε1,ε2,..)
Da in JavaScript Funktionen Werte erster Ordnung sind kรถnnen
return
)
Es kรถnnen daher anonyme Funktionen function (..) {..}
definiert werden die entweder einer Variablen als Wert oder als Funktionsargument รผbergeben werden.
var x = function (pi) { ε(pi) }
array.forEach(function(elem,index) { ε(pi) }
In JavaScript sind Objekte universelle Datenstrukturen (sowohl Datenstrukturen als auch Objekte) die mit Hashtabellen implementiert werden. Arrays werden in JavaScript ebenfalls als Hashtabelle implementiert!. D.h. Objekte == Datenstrukturen == Arrays == Hashtabellen.
Es gibt kein nutzerdefinierbares Typensystem in JavaScript.
Eine Datenstruktur kann jederzeit definiert und verรคndert werden (d.h. Attribute hinzugefรผgt werden)
var dataobject = {
a:ε,
b:ε, ..
f:function () { .. }
}
..
dataobject.c = ε
dataobject.attribute
dataobject["attribute"]
array[index]
array["attribute"]
Objekte zeichnen sich in der objektorientierten Programmierung durch Methoden aus mit der ein Zugriff auf die privaten Daten (Variablen) eines Objekts mรถglich wird.
In JavaScript kann auf Variablen eines Objekts (die Attribute) immer direkt zugegriffen werden.
Attribute kรถnnen Funktionen sein - jedoch kรถnnen die Funktionen nicht wie Methoden direkt auf die Daten des Objektes zugreifen.
Daher definiert man Methoden รผber Prototypenerweiterung in JavaScript.
Die Methoden kรถnnen รผber die this
Variable direkt auf das zugehรถrige Objekt zugreifen (also auch auf die Variablen/Attribute)
Es gibt eine Konstruktionsfunktion fรผr solche Objekte mit Prototypendefinition der Methoden
Objekte werden mit dem new
Operator und der Konstruktionsfunktion erzeugt.
function constructor (pi) {
this.x=ε
..
}
constructor.prototype.methodi = function (..) {
this.x=ε;
..
}
...
var obj = new constructor(..);
Agentenklassen werden in JS รผber Konstrukorfunktionen definiert.
Eine Agentenklasse definiert:
next
Attribute initialisiert mit der Startaktivitรคt
this
Objekt als Refernz auf eine Agenteninstanz ist auch in geschachtelten Funktionen gรผltig, d.h., in allen
iter(list,function () { this is agent! }
function ac (p) {
var x; // Wrong!!!
this.y = p; // Correct!!!
this.act = { ax: function () { var a; // is correct
}
Definition 3.
function ac(p1,p2,..) {
// Body Variables
this.x=ε; ..
this.act = { // Activities
a1: function () { .. },
a2: function () { .. },
..
an: function () { .. }
}
this.trans = { // Transitions
a1: function () { return cond?ai:aj },
a2: aj,
..
}
this.on = { // Signal Handler
error: function (err) { .. },
signal1: function (arg) { .. }
}
this.next = a1;
}
function create(class:string,arguments:{},level?:number) → id:string
function fork(arguments?:{},level?:number) → id:string
function kill(id:string|undefined)
Bei der create Operation die einen neuen Agenten der Klasse ac instantiiert werden die Klassenparameter der Instanz mit konkreten Werten mit dem Parameterargument arguments:{p1:v1,p2:v2,..}
initialisiert.
Bei der fork Operation die eine Kopie des aufrufenden Agenten erzeugt werden Klassenattribute (die this.x
Variablen, nicht die Parameter {p}!) mit neuen Werten รผberschrieben, d.h. arguments:{x:v1,y:v2,..}
Die kill Operation ohne Argument fรผhrt zur Terminierung des aufrufenden Agenten (== kill(me())
)
id = create('explorer',{dir:DIR.NORTH,radius:1});
child = fork({x:10,y:20});
kill(child);
kill(me());
Da JavaScript Funktionen als Werte erster Ordnung behandelt werden hรคufig sog. Rรผckruffunktione (callback) an Funktionen als Argumente รผbergeben, die von der aufrufenden Funktion dann aufgerufen werden
Rein synchrone Operationen (z.B. Tupelraumoperation out oder jegliche Berechnung, auch mit Rรผckruffunktionen wie iter) kรถnnen in einer Sequenz innerhalb einer Agentenaktivitรคt ausgefรผhrt werden
Es gibt aber auch asynchrone Operationen ((z.B. Tupelraumoperation rd), die zwar aufgerufen werden, aber erst spรคter (ggfs. nach Durchlauf einer Aktivitรคt) ausgefรผhrt werden.
Definition 4.
B([ L([
function () { .. }, function init () {..},
function () { .. }, function cond () {..},
function () { .. }, function next () {..},
.. [ function () { .. },
]) function () { .. }, ..
]])
I(obj:[]|{},
function next (elem:*) { },
[
function () {..},
function () {..}, ..
],
function finalize () { .. }
)
function alt (pattern [],callback:function,all?:boolean,tmo?:number)
function collect (to:path,pattern) → number
function copyto (to:path,pattern) → number
function evaluate (pattern,callback:function (tuple)) → tuple
function inp (pattern,callback:function(tuple|tuple[]|none),all?:boolean,tmo?:number)
function listen (pattern,callback:function (pattern) → tuple)
function out (tuple)
function mark (tuple,tmo:number)
function rd (pattern,callback:function(tuple|tuple[]|none) ,all?:boolean,tmo?:number)
function rm (pattern,all?:boolean)
function store (to:path,tuple) → number
function test (pattern) → boolean
function ts (pattern,callback:function(tuple) → tuple)
function alt.try inp.try rd.try (tmo:number,..)
out(['MARKING1',1]);
out(['SENSORA',100,true]);
inp(['SENSORA',_,_],function (tuple) {
if (tuple) this.s =tuple[1];
});
rm(['SENSORA',_,_],true);
rd.try(0,['SENSORA',_,_],function (tuple) { .. });
// oder bei Timeout 0 alternativ ohne callback =>
var t = rd.try(0,['SENSORA',_,_]);
ts(['MARKING',_],function (t) { t[1]++ });
alt([
['SENSORA',_,_],
['SESNORB',_],
['EVENT'],
],function (tuple) {
if (tuple && tuple[0]=='EVENT') {..}
else ..
});
function send (to:aid,sig:string|number,arg?:*)
fucntion broadcast (class:string,range,@sig,@arg?)
function sendto (to:dir,sig:string|number,arg?:*)
function sleep (milli:number)
function timer.add (milli:number,sig:string,arg:*,repeat:boolean) → string
function timer.delete (sig:string)
this.on = { SIGNAL : function (arg,from) { .. } }
type aid = string
type range = hops:number|region:{dx:number,dy:number,..}
enum DIR = {NORTH , SOUTH , WEST , EAST , ..
PATH (path:string) , NODE(id:string),
IP (ip:string) ,
CAP {cap:string}
} : dir
this.on
Sektion ausgefรผhrt. Der Objektattributname ist der Signalname.
this.child=none;
this.act = {
a1: function () {
this.child=fork({child:none});
timer.add(500,'QUERY',true);
}
a2: function () {
// Raising of signal
if (this.child) send(this.child,'PARENT',me());
}
}
// Installation of Signal Handler
this.on : {
PARENT : function (arg) {
log('Got signal from my parent '+arg);
},
QUERY: function () { .. }
}
enum DIR = {NORTH , SOUTH , WEST , EAST , ..
PATH (path:string) , NODE{node:string),
IP (ip:string) ,
CAP (cap:string)
} : dir
function moveto (to:dir)
function opposite (dir) → dir
function link (dir) → boolean|string|[]
Fรผr die IP Richtung existiert eine Typkonstruktionsfunktion DIR.IP(ip:string|number)
mit der Angabe einer IP Adresse und einer IP Portnummer im Format "IP:PORT"
, oder bei Verbindungen von JAM Knoten auf den gleichem Hostrechner nur die IP Portnummer.
Die opposite Funktion liefert die entgegengesetzte Richtung, z.B. NORTH → SOUTH. Bei IP Ports i.A. nicht definiert oder bei bereits migrierten Agenten die IP Adresse des letzten Knotens.
Als Ziel kann auch ein JAM Knotenname angegeben werden (DIR.NODE("name")
).
function moveto (to:dir)
function link (dir) → boolean|string|[]
DIR.IP('*')
).Die von der aktuellen Plattform (JAM Knoten) erreichbaren JAM Knotennamen kรถnnen z.B. mit der link(DIR.IP("%"))
Operation als Liste ausgegeben werden.
Nach einer Migration wird die nรคchste folgende Aktivitรคt (definiert durch die รbergangsbedingungen) ausgefรผhrt. Daher muss die moveto Anweisung die letzte in einer Aktivitรคt oder eingebettet in einen Scheduling Block sein!
Die Fusion von virtuellen Simulationswelten mit realen Netzwerken ermรถglicht die Kopplung von virtuellen Welten mit realen Welten und Interaktion mit Menschen!
Chat bots kรถnnen sowohl in virtuellen als auch realen (menschbezogenen) Welten agieren!
Das ermรถglicht das Studium komplexer sozio-technischer Systeme
Human-in-the-loop simulation for Augmented Virtuality besteht daher aus:
Virtueller Simulationswelt und Framework SEJAM2 mit JAM platform unf virtuellen JAM Netzwerken die mit dem Internet verbudnen sind
Mobilen Gertรคten mit JAM Plattform verbunden mit dem Internet oder via Baken (Bluetooth z.B.)
Stationรคre Gerรคte (Sensoren, IoT, und Baken) die รผber das Internet mit der virtuellen Welt verbunden sind
Simulation and investigation of Crowd Interaction with Smart Cities
World consists of streets and buildings
Agents (can) represent:
Mobile Devices using a WEB App with Chat Bot dialog
Additionally, the device sensor data is collected (light, position, ..) if available
Beacons sent out mobile explorer agents performing question-answer dialogs on mobile devices (random walk)
Based on collected crowd data:
Real World | Virtual World |
Fusion of real and virtual worlds can contribute to investigate complex socio-technical systems with ensemble sizes beyond Millions of entities (users, devices, machines)
Using agent-based modelling and simulation with mobile agents create an unified model and representation for:
Augmented Virtuality means the integration and tight coupling of ABM simulation with Crowd Sensing and technical devices interaction
Issues: