Activities

Eine Activity ist ein leichtgewichtiger Thread ohne eigenen Namen. Asynchrone Activities werden durch den Befehl

at (p) async s

erstellt. Dabei ist p der Place, an dem die Activity ausgeführt werden soll und s der Befehl (engl. Statement). Eine Aktivität wird an einem bestimmten Place erstellt und bleibt dort für die gesamte Lebensdauer. Mit dem Schlüsselwort here kann eine Aktivität auf ihren Place zugreifen.

Places

Ein Place enthält Daten und Activities, die auf diesen Daten arbeiten. Man kann sich einen Place als eigenen Knoten einer verteilten Java Virtual Machine (JVM) mit eigenem Heap und eigenen Threads vorstellen. Dabei kann angenommen werden, dass alle Places geordnet sind. Handelt es sich bei p um einen Place, so kann mit p.next auf den nächsten Place zugegriffen werden.

Es gibt keinen expliziten Befehl um einen neuen Place zu erzeugen, vielmehr wird jede Activity mit einer expliziten Anzahl Places gestartet. Daraus ergibt sich eine fixe Anzahl von Places für das gesamte Programm, die während der gesamten Programmlaufzeit konstant bleibt. Die Places des Programms sind von 0 bis Place.MAX_PLACES-1 nummeriert und werden in einer sortierten Sequenz von Place.places() gespeichert. Auf den Place der aktuellen Activity kann mit dem Schlüsselwort here zugegriffen werden.

Der Zugriff abhängig vom Place wird durch das statische Feld location, das jedes Objekt enthält, geregelt. Nur die Objekte eines Places erhalten Zugriff auf nicht-finale Felder der anderen Objekte dieses Places. Versuche auf nicht-finale Felder von Objekten auf einem anderen Place zuzugreifen scheitern mit einer BadPlaceException (BPE). Man kann jedoch mit dem Ausdruck at einzelne Activitys synchron auf andere Places verschieben. Dabei handelt es sich, wie bei jeder verteilten Operation, um eine sehr teure Operation. Sie bildet jedoch die Grundlage für Multicore Programmierung in X10.

Objekte werden auf dem Place erzeugt, auf dem der Konstruktor-Aufruf läuft. Anschließend kann ein Objekt, im Gegensatz zu Activities, nicht mehr den Place wechseln. Es kann nur auf einen anderen Place kopiert oder über GlobalRef von anderen Places referenziert werden.

Distributions und distributed Arrays

Mit Distributions werden distributed Arrays auf Places verteilt. Dabei ist die Distribution ein Objekt, die jedem Element des Arrays einen Place zuordnet. Auf welchem Place ein Element eines distributed Arrays liegen soll, muss bereits zur Array-Erstellung bekannt sein. Dabei ist zu beachten, dass auf einem Place nur auf diejenigen Elemente des distributed Arrays zugegriffen werden kann, die auch auf diesem Place liegen.

Atomarität

Wie in vielen anderen Programmiersprachen verbergen sich hinter einfachen Befehlen, wie dem Inkrement mehrere Maschinenbefehle, was diese zu einem kritischen Abschnitt macht. Das bedeutet, dass ein solcher Befehl potentiell von einem parallel ausgeführten anderen Befehl unterbrochen werden kann. Um das zu verhindern können in X10 einzelne Befehle mit einem

when(c) S

umgeben werden. Dabei ist c die boolesche Wächterbedingung und S der atomar auszuführende Befehl (engl. statement). Solange c nicht true ist, blockiert die Ausführung. Wenn c true wird, so wird S atomar ausgeführt.

Um ganze Methoden atomar auszuführen, kann man das Schlüsselwort atomic davor schreiben. Die Methode increment wird beispielsweise atomar ausgeführt:

atomic boolean increment() {
   value++;
   return true;
}

Clocks

Viele parallele Algorithmen sind in verschiedene Phasen aufgeteilt, dabei müssen alle Aktivitäten einer Phase abgearbeitet werden, bevor die nächste Phase beginnt. In X10 werden diese Phasen durch sogenannte Clocks getrennt. Um eine Aktivität an einen solchen Clock zu binden, definiert man diese als clocked() mit dem entsprechenden Clock Objekt.

Im folgenden Beispiel werden zwei Aktivitäten A und B durch ein Clock Objekt synchronisiert, so dass zuerst die Ausgaben der ersten Phase beider Aktivitäten ausgegeben werden und anschließend die Ausgaben der zweiten Phase beider Aktivitäten:

//erzeuge ein Clock Objekt
val clock = Clock.make();

//erzeuge Aktivität A und binde sie an clock
async clocked(clock) {
   //gebe parallel zu B Text aus
   print("A: 1st phase. ");
   //warte auf B
   Clock.advanceAll();
   print("A: 2nd phase. ");
}

//erzeuge Aktivität B und binde sie an clock
async clocked(clock) {
   //gebe parallel zu A Text aus
   print("B: 1st phase. ");
   //warte auf A
   Clock.advanceAll();
   print("B: 2nd phase. ");
}

Ein mögliches Ergebnis des Beispiels wäre:

A: 1st phase. B: 1st phase. B: 2nd phase. A: 2nd phase. ,

nicht aber

A: 1st phase. A: 2nd phase. B: 1st phase. B: 2nd phase. .

Felder

Felder spezifizieren Daten, die zu einer Klasse gehören. Dabei unterscheidet man, ob die Felder veränderbar (gekennzeichnet mit dem Schlüsselwort var), oder unveränderbar (gekennzeichnet mit dem Schlüsselwort val) sind. Der Typ eines veränderbaren Feldes muss immer spezifiziert werden. Dieser folgt dem Namen der Variable nach einem Doppelpunkt. Unveränderbare Felder können bereits mit einem Wert initialisiert werden, müssen es aber nicht.

//veränderbares Feld mit dem Namen "population", vom Typ Integer und mit dem initialen Wert 42
var population:Int = 42;
//veränderbares Feld mit dem Namen "growthRate", vom Typ Integer und ohne initialen Wert
var growthRate:Int;

Der Typ eines unveränderbaren Feldes muss nicht explizit angegeben werden. Er kann auch implizit aus dem Initialisierungswert abgeleitet werden. Ein unveränderbares Feld muss nicht initialisiert werden, solange es im Konstruktor der Klasse initialisiert wird.

//unveränderbares Feld mit dem Namen "pi", vom expliziten Typ Double und ohne initialen Wert
val pi:Double;
//unveränderbares Feld mit dem Namen "truth", vom impliziten Typ Integer und mit initialem Wert 42
val truth = 42;

Felder können entweder objektspezifisch oder statisch (mit dem Schlüsselwort static gekennzeichnet) sein. Standardmäßig sind Felder objektspezifisch, das heißt jedes Objekt hat seine eigene Instanz des Feldes. Ist ein Feld statisch, so gibt es für alle Objekte nur eine Instanz dieses Feldes. In X10 müssen statische Variablen immer unveränderbar sein.

//statisches, unveränderbares Feld mit dem Namen "pi", vom impliziten Typ Double und mit initialem Wert
static val pi = 3,141;
//objektspezifisches, unveränderbares Feld mit dem Namen "truth", vom impliziten Typ Integer und mit initialem Wert
val truth = 42;