Nach dem Willen der Prozessorherstellern müssen nun alle umlernen: Parallelprogrammieren wird das Paradigma der Zukunft. Dass das auch einfach geht, zeigt Kamaelia, ein Komponenten-Framework in Python. Eben ist die Version 0.6 erschienen.

Multicore-Ausstattung wird bei neuen Computern immer mehr zur Normalität. Prozessoren mit zwei, vier oder gar 80 Kernen sind bereits auf dem Markt. Die Hersteller schicken ihre neuen Produkte mit der Devise auf die Reise, dass die Programmierer schlauer werden müssen, um diese neue Architektur auch ausnutzen zu können.

Gleichzeitiges

Dabei machen genau die gleichen Programmierer im richtigen Leben jeden Tag hunderte von Sachen gleichzeitig. Selbst im Internet programmierern sie Mashups von mehreren Websites, die auch funktionieren, obwohl die Webservices parallel laufen.

Kamaelia wurde von der Forschungsabteilung des britischen Rundfunks BBC mit diesen Problemen und Ideen im Hintergrund entwickelt. Das wesentliche Ziel ist, den Aufbau großer paralleler Systeme dem Problem angemessen, einfach, und leicht wartbar zu machen. Oft genug ist die am besten zu einem Problem passende Lösung hoch parallel und eignet sich deshalb auch gut für Multicore-Systeme. Einige Hinweise zur Kamaelia-Installation gibt der gleichnamige Kasten.

python setup.py install

Das Anwendungsfeld von Kamaelia ist von Haus für parallele Verarbeitung prädestiniert, weil es bei der BBC oft um die Verteilung von Multimediainhalten im Netz geht, zum Beispiel 20 Millionen Menschen, die gleichzeitig dasselbe Programm ansehen. Kamaelia ist einerseits ein Experimenti erkasten, um Lösungen für Probleme dieser Art auszuprobieren, aber es ist auch für hohe Performance entworfen.

Wie Unix-Pipes

Prinzipiell folgt Kamaelia dem Unix-Pipes-Ansatz, aktualsiert ihn aber für die objektorientierten, modernen Zeiten. Kamaelias Grundsätze sind (mit einer Entschuldigung an Doug McIlroy): Schreibe Komponenten, die

• eine Sache tun, und sie richtig tun,

• gut zusammenarbeiten,

• als allgemeine Schnittstelle Python-Objekte verarbeiten.

Ein einfaches Beispiel eines Kamaelia-Systems zeigt Listing 1. Die erste Pipeline realisiert mit zwei Komponenten einen kleinen Server. Die erste liest ein Videodatei im freien BBC-Codec Dirac, die zweite stellt den Server selbst zur Verfügung. Die zweite Pipeline setzt aus einem TCP-Client, einem Dirac-Decoder, einer Regelungs- und einer Anzeige-Komponente einen Streaming-Client zusammen. Ein solches Netzwerk verschalteter Komponenten zeigt Abbildung 1.

01 Pipeline(
02   ReadFileAdaptor( filename = 'video.drc',
03                    bitrate = 400000 ),
04   SingleServer(),
05 ).activate()
06 
07 Pipeline(
08     TCPClient( host = "127.0.0.1",
09                port = 1601 ),
10     DiracDecoder(),
11     MessageRateLimit( messages_per_second = 15,
12                       buffer = 15 ),
13     VideoOverlay(),
14 ).run()

Um zu verstehen, was eine Komponente ist, zuerst ein einfaches Beispiel. Die folgenden Zeilen lesen in einer Schleife Strings von der Standardeingabe und geben sie über die Standardausgabe aus:

import sys
eol = "\n"
while 1:
  line = raw_input(">>> ")
  line = line + eol
  sys.stdout.write(line)
  sys.stdout.flush()

Kamaelia ersetzt die Standardausgabe durch eine so genannte Outbox und packt den Code in die Main-Methode einer Klasse. Diese erbt von »threadedcomponent«, damit die blockierende Methode »raw_input« nicht das ganze Programm zum Halten bringt. Zum Ausgeben genügt eine Methode ohne Threads, die die Ausgabewerte über ihre Inbox erhält. Eine Pipeline verbindet wieder Ein- und Ausgabemodul. Listing 2 zeigt beide Klassen und die Pipeline.

01 from Axon.ThreadedComponent import threadedcomponent
02 from Axon.Component import component
03 from Kamaelia.Chassis.Pipeline import Pipeline
04 import sys
05 
06 class ConsoleReader(threadedcomponent):
07    def main(self):
08       eol = "\n"
09       while 1:
10          # this blocks so we use a thread
11          line = raw_input(">>> ")
12          line = line + eol
13          self.send(line, "outbox")
14 
15 class ConsoleEchoer(component):
16    def main(self):
17       while 1:
18           while self.dataReady("inbox"):
19               data = self.recv("inbox")
20               sys.stdout.write(str(data))
21               sys.stdout.flush()
22           yield 1
23 
24 Pipeline( ConsoleReader(),
25            ConsoleEchoer(),
26         ).run()

Wichtig ist Zeile 22 mit der Anweisung »yield 1«. Sie zeigt an, dass es sich bei dieser Methode -- wie bei den meisten Kamaelia-Methoden -- um einen Generator handelt.

Dass Parallelverarbeitung in der echten Welt so gut funktioniert, haengt unter anderem damit zusammen, dass jedes Ding zu einer Zeit nur an einem Ort sein kann. Ähnlich funktionieren die In- und Outboxes von Kamaelia. Wer etwas über seine Inbox erhält, kann damit tun, was er will, und es dann in die eigene Outbox stecken. An dieser Stelle hat man das Objekt praktisch freigegeben. Dieses Modell vermeidet von Anfang an, dass mehrere Programmteile sich konkurrierend um einen Objektzustand bemühen: Etwas aus einer Inbox zu nehmen bedeutet implizit, ein Lock für das Objekt zu erhalten. Etwas in eine Outbox zu stecken, gibt das Lock implizit wieder frei. Gleichzeitig bedeutet das, dass jedes Datum zu einer bestimmten Zeit nur je einen Leser und Schreiber besitzt. Diese Grundprinzipien machen den sicheren Aufbau von Kamaelia-Systemes verhältnismäßig leicht.

Nach dem Willen der Prozessorherstellern müssen nun alle umlernen: Parallelprogrammieren wird das Paradigma der Zukunft. Dass das auch einfach geht, zeigt Kamaelia, ein Komponenten-Framework in Python. Eben ist die Version 0.6 erschienen.