Borg

Praktisch

De volgende reeks oefeningensessies is vooral gericht op Borg, een gedistribueerde pico variant ontwikkeld op PROG. Er zijn versies runnende onder Windows NT, 98, 95 en Linux (De linux versie is ontwikkeld door Koen Bailleul, contacteer hem hiervoor indien nodig). Documentatie in verband met pico kan u vinden online op http://pico.vub.ac.be.

Info

Onderstaand is een beschrijving van de gedistribueerde pico interpreter, genaamd Borg, dewelke op Prog ontwikkeld is. Het is een interpreter waarbinnen verschillend processen een eigen code en data space hebben. Alle natives steken in de wortel-omgeving van de interpreter. Elk proces dat gecreeerd wordt word in een eigen environment gestart.

Elke window die gecreeerd wordt instantieert twee ‘agents’. De eerste agent is de user interface agent. (blijft vast op de gegeven machine), de tweede agent is de ‘denk’ agent. Deze agent kan migreren naar andere plaatsen (die een Borg agent systeem draaien).

Objecten

Objecten worden in dit systeem gecreeerd als volgt

Makepoint(x,y)::
  {
  Getx()::x;
  Gety()::y;
  Setx(nx)::x:=nx;
  Sety(ny)::y:=ny;
  Clone()
  }

Afstammen van objecten gebeurt als volgt (de code spreekt voor zich)

Makepoint(x,y)::
  {
  Getx()::x;
  Gety()::y;
  Setx(nx)::x:=nx;
  Sety(ny)::y:=ny;
  MakeSquare(w)::
    {
    GetW()::w;
    SetW(nw)::w:=nw;
    Clone()
    };
  Clone()
}

Agents

Een proces kan gecreeerd worden (in de grafische werkomgeving althans) door op new te klikken of door een file open te doen en een agentname in te tikken (Voor de duidelijkheid een agent is bij ons een proces met eigen code en data space. Dus in dit geval refereren naar een proces of naar een agent is hetzelfde.)

Bij de creatie van een proces wordt een naam geassigned aan het proces. Deze naam wordt gebruikt om te refereren naar het proces. Bv: "tecra/ses1". Achter elke Borg interpreter steekt een module die berichten van het ene proces naar het andere kan doorgeven. Deze module (router) wordt bij het starten van het systeem geinitialiseerd met een ini file. Deze ini file bevat de naam van de interpreter en eventueel een referentie naar een forwarding router zodat men een interconnectie van interpreters kan maken.

Message handling

Messages kunnen van proces tot proces gestuurd worden door eerst te refereren naar de communicatiepartner en een call te doen alsof men tegen een object praat. Bijvoorbeeld: Om een bericht te sturen naar een proces genaam "tecra/ses2":

A:remotedict("tecra/ses2")

A.display(200)

Gelieve op te merken dat calls naar remote processen altijd asynchroon zijn. Als de selector van een message send een remote dictionary is zal de call onmiddelijk void retourneren. De pararamters die meegegeven worden aan dergelijke call worden automatiusch geserialiseerd en gedeserialiseerd. Aangaande het serializeren van berichten tussen agents:

Callbacks & Continuation Passing Style

Aangezien alle functie calls asynchroon zijn: leg uit hoe men toch antwoorden kan terugsturen… Geef een voorbeeld in de praktijk.

Zoals in de opgave van de nameserver al gebleken is hebben we vaak een probleem met het terugsturen van berichten in een asynchrone omgeving. Hoe kunnen we dit opvangen op een ietwat mooiere methode ? Wat zijn de problemen daarvan ? (CPS)

Answer: Callbacks:

Agent Tecra/ses1
----------------

Calculate(...,callback)::
  {
  <some calculation>;
  callback.Answeris(...)
  }
  
Agent Tecra/ses2
----------------

Answeris(...)::
  { 
  display("The answer is: ");
  display(result) 
  };

agent: remotedict("Tecra/ses1");
agent.Calculate(#,agentself())

Nameserving

Zoals reeds duidelijk is moeten we telkens als we refereren naar een ander proces zelf een remote dictionary maken. Dit is iets wat straight forward gebeurt doch toch zijn nadelen heeft. Als we bijvoorbeeld onze code op een andere machine (met een andere naam starten) moeten we deze referentie aanpassen. Daarom zou het handig zijn een nameserver te gebruiken aan wie we steeds het adres van een agent kunnen vragen. Schrijf dergelijke nameserver in Borg.

Bespreek hoe we de bovenstaande nameserver kunnen integrereren in de Borg infrastructuur zodat we weer wat minder code moeten schrijven.

• bespreek hoe de name lookups automatisch kunnen gebeuren

• bespreek hoe het registreren van processen verloopt

Calcul(pars)::
  { 
  <some calculation>;
  display("before moving");
  agentmove(remotedict("otherplace.tecra"));
  display("after moving") 
  }

main(pars,callback)::
  callback.Answeris(calcul(pars))

http://werner.yellowcouch.org/ werner@yellowcouch.org