imported>Aka: falsches Komma entfernt

2024-12-04T11:52:03Z

falsches Komma entfernt

Neue Seite

{{Infobox Programmiersprache
| Name = X10
| Logo =
| Beschreibung =
| Paradigma = [[Objektorientierte Programmierung|Objektorientierte Programmiersprache]]
| Betriebssystem = [[AIX]], [[Linux]], [[macOS]], [[Windows]]/[[Cygwin]]
| Lizenz = [[Eclipse Public License]] 1.0
| Erscheinungsjahr = 2004
| Entwickler = Kemal Ebcioğlu, Vijay Saraswat und Vivek Sarkar ([[IBM]])
| AktuelleVersion = 2.6.2<ref name="Spec">{{Literatur |Autor=Vijay Saraswat, Bard Bloom, Igor Peshansky, Olivier Tardieu, David Grove, |Titel=X10 Language Specification Version 2.6.2 |Datum=2019 |Seiten=1–303 |Online=http://x10.sourceforge.net/documentation/languagespec/x10-262.pdf |Format=PDF |KBytes=1500 |Abruf=2019-01-04}}</ref>
| AktuelleVersionFreigabeDatum = 8. Januar 2019
| Typisierung = [[Starke Typisierung|stark]], [[Statische Typisierung|statisch]]
| Implementierung =
| Dialekte =
| Standardisierungen =
| Beeinflusst_von = [[Java (Programmiersprache)|Java]], [[C++]], [[Scala (Programmiersprache)|Scala]]
| Beeinflusste =
| Website = http://x10-lang.org/
}}

'''X10''' ist eine [[Parallele Programmierung|parallele]], [[Objektorientierung|objektorientierte]] [[Programmiersprache]], für high-end Hardware mit bis zu 10000 Hardware-[[Thread (Informatik)|Threads]]<ref name="Spec" />. Sie wurde 2004 bei [[IBM]] am [[Thomas J. Watson Research Center|Forschungszentrum Thomas J. Watson]] als Teil des [[PERCS]]-Projekts entwickelt. Zielplattformen der Programmiersprache sind Cluster-Systeme mit unterschiedlichen Berechnungseinheiten (Non-Uniform Cluster Computing). Die Programmiererproduktivität solcher Systeme soll mit X10 um den Faktor zehn erhöht werden, was zu dem Namen X10 geführt hat.<ref>{{Literatur |Autor=Philippe Charles, Christian Grothoff, Vijay A. Saraswat et al. |Titel=X10: An Object-Oriented Approach to Non-Uniform Cluster Computing |Sammelwerk=OOPSLA |Band= |Nummer= |Datum=2005 |Seiten=519–538 |DOI=10.1145/1094811.1094852}}</ref> Die Entwicklung von X10 wurde durch das [[High Productivity Computing Systems]] (HPCS) Programm der [[DARPA]] finanziert.

X10 wurde speziell zur parallelen Programmierung nach dem [[PGAS|Partitioned Global Address Space]] (PGAS) Modell entworfen. X10 erweitert dieses sogar noch um [[Asynchronität]], was zu einem APGAS Modell führt. Eine Berechnung ist auf verschiedene Places aufgeteilt. Diese enthalten Daten und eine oder mehrere Activities, die mit diesen Daten arbeiten. X10 hat ein beschränktes Typsystem für [[objektorientierte Programmierung]]. Außerdem hat es noch andere Eigenschaften wie benutzerdefinierte primitive ''struct''-Typen, global verteilte [[Feld (Datentyp)|Arrays]] und strukturierten und unstrukturierten Parallelismus.<ref name="Spec" />

== Grundkonzepte ==
=== Activities ===
Eine Activity ist ein leichtgewichtiger Thread ohne eigenen Namen. Asynchrone Activities werden durch den Befehl
<syntaxhighlight lang="java">
at (p) async s
</syntaxhighlight>

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.<ref name="Saraswat2005">{{Literatur |Autor=Vijay Saraswat, Radha Jagadeesan |Titel=Concurrent Clustered Programming |Sammelwerk=Lecture Notes in Computer Science |Band=3653 |Verlag=Springer |Ort=Berlin Heidelberg |Datum=2005 |Seiten=353-367 |DOI=10.1007/11539452_28}}</ref>

=== 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 [[Dynamischer Speicher|Heap]] und eigenen [[Thread (Informatik)|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.<ref name="Saraswat2005" />

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.<ref name="Spec" />

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)''.<ref name="Saraswat2005" /> 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 [[Mehrkernprozessor|Multicore]] Programmierung in X10.<ref name="Spec" />

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.<ref name="Spec" />

=== 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.<ref name="Saraswat2005" />

=== Atomarität ===
Wie in vielen anderen Programmiersprachen verbergen sich hinter einfachen Befehlen, wie dem [[Inkrement]] mehrere Maschinenbefehle, was diese zu einem [[Kritischer Abschnitt|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
<syntaxhighlight lang="java">
when(c) S
</syntaxhighlight>
umgeben werden. Dabei ist ''c'' die [[Boolesche Variable|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.<ref name="Saraswat2005" />

Um ganze Methoden atomar auszuführen, kann man das Schlüsselwort ''atomic'' davor schreiben. Die Methode ''increment'' wird beispielsweise atomar ausgeführt<ref name="Saraswat2005" />:
<syntaxhighlight lang="java">
atomic boolean increment() {
value++;
return true;
}
</syntaxhighlight>

=== Clocks ===
Viele parallele [[Algorithmus|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.<ref name="Spec" />

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<ref group="Anmerkung">Aktivitäten haben in X10 keine Namen, im Beispiel werden die Aktivitäten nur aus didaktischen Gründen benannt.</ref>:

<syntaxhighlight lang="java">
//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. ");
}
</syntaxhighlight>

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

== Klassen ==
Eine [[Klasse (Objektorientierung)|Klasse]] enthält, analog zu Java, Daten und Code. Eine Klasse kann verschiedene Felder, Eigenschaften, [[Methode (Programmierung)|Methoden]], [[Konstruktoren und Destruktoren|Konstruktoren]] enthalten. Außerdem spezifiziert eine Klasse maximal eine oder keine Elternklasse. Eine Klasse kann mehrere [[Schnittstelle#Softwareschnittstelle|Interfaces]] implementieren.

Eine Klasse kann als ''final'' markiert werden. Von einer solchen Klasse kann nicht mehr [[Vererbung (Programmierung)|geerbt]] werden.

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

<syntaxhighlight lang="java">
//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;
</syntaxhighlight>

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.

<syntaxhighlight lang="java">
//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;
</syntaxhighlight>

Felder können entweder objektspezifisch oder [[Static (Schlüsselwort)|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.

<syntaxhighlight lang="java">
//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;
</syntaxhighlight>

== Implementierungen ==
Es gibt zwei Implementierungen von X10: ''Native X10'' und ''Managed X10''. Native X10 basiert auf C++ und bildet einen Place auf einen [[Prozess (Informatik)|Prozess]] ab. Es ist für folgende Betriebssysteme verfügbar: [[Linux]], [[AIX]], [[Mac OS]], [[Cygwin]] und [[Blue Gene]]. Managed X10 ist JVM basiert. Es bildet einen Place auf einen JVM-Prozess ab. Da es auf Java basiert, läuft es unabhängig vom Betriebssystem mit jeder Version ab Java 6.<ref name="X10Tut">{{Literatur |Autor=David Grove, Vijay Saraswat, Olivier Tardieu |Titel=Developing Scalable Parallel Applications in X10 |Datum=2012 |Seiten=1–85 |Online=[http://x10.sourceforge.net/tutorials/x10-2.2/SC_2012/SC12_X10_Tutorial.pdf online] |Format=PDF |KBytes=1300 |Abruf=2013-08-26}}</ref>

== Einzelnachweise ==
<references />

== Anmerkungen ==
<references group="Anmerkung" />

== Weblinks ==
* [http://x10-lang.org/ X10 Website]

[[Kategorie:Programmiersprache für die Java Virtual Machine]]

X10 (Programmiersprache) - Versionsgeschichte

imported>Aka: falsches Komma entfernt