„Parallele Programmierung“ – Versionsunterschied

Parallele Programmierung ist ein Programmierparadigma. Es umfasst zum einen Methoden, ein Computerprogramm in einzelne Teilstücke aufzuteilen, die nebenläufig ausgeführt werden können, zum anderen Methoden, nebenläufige Programmabschnitte zu synchronisieren. Dies steht im Gegensatz zur klassischen, sequentiellen (oder seriellen) Programmierung. Ein Vorteil der Parallelen Programmierung ist neben möglicher schnellerer Programmausführung (bspw. bei Nutzung mehrerer Prozessorkerne) die Möglichkeit, das typische Alltagsphänomen Nebenläufigkeit direkt in Programmen abzubilden, was zu einfacherem, verständlicherem Quelltext führen kann. Ein Nachteil ist, dass das Laufzeitverhalten paralleler Algorithmen schwieriger nachvollziehbar sein kann als das eines äquivalenten sequentiellen Algorithmus.

Umsetzung

Es ist für eine Parallelisierung theoretisch gleichgültig, ob die einzelnen Programmteile tatsächlich echt gleichzeitig von unabhängigen Ausführungseinheiten bearbeitet werden, oder ob sie nur quasi-parallel ausgeführt werden (siehe Time-Sharing, Multitasking).

Bei der Parallelen Programmierung verwendet man den weniger strengen Begriff der Nebenläufigkeit, bei dem der Programmcode nicht streng hintereinander, sondern parallel ausgeführt wird. Zwei Programmteile sind genau dann parallelisierbar, wenn die parallele, verzahnte oder verdrehte Ausführung zum selben Resultat führt wie das sequentielle Ausführen (Parallelisierbarkeit). Ist dies nicht gegeben, so kann die Ausführung zu einer Race Condition führen.

Die Nebenläufigkeit von mehreren unabhängigen Prozessen bezeichnet man als Multitasking; Nebenläufigkeit innerhalb eines Prozesses als Multithreading. In den Frühzeiten der Computerentwicklung waren auch reine Time-Sharing-Systeme weit verbreitet, die eine Nebenläufigkeit auf Benutzerebene ermöglichten.

Unterstützende Hardware

Meist wird die parallele Ausführung eines Programms hardwareseitig unterstützt; die Programmiersprachen sind dann im Allgemeinen darauf angepasst. So kann Parallele Programmierung zum Beispiel explizit dadurch geschehen, dass der Programmierer Programmteile in separaten Prozessen oder Threads ausführen lässt, oder es geschieht automatisch, so dass kausal unabhängige (parallelisierbare) Anweisungsfolgen „nebeneinander“ ausgeführt werden. Diese automatische Parallelisierung kann durch den Compiler vorgenommen werden, wenn als Zielplattform ein Computer mit Mehrkernprozessor oder ein Parallelrechner zur Verfügung steht, aber auch einige moderne CPUs können solche Unabhängigkeiten (im Maschinencode bzw. Mikrocode eines Programms) erkennen und die Anweisungen so auf verschiedene Teile des Prozessors verteilen, dass sie gleichzeitig ausgeführt werden (Out-of-order execution).

Konflikte

Sobald die einzelnen Prozesse oder Threads aber untereinander kommunizieren, sind sie streng genommen nicht mehr als Ganzes nebenläufig (sie beeinflussen sich ja) – nur noch einzelne Teilabläufe sind zueinander nebenläufig. Wenn nun die Reihenfolge der Ausführung der Kontaktpunkte (oder Kommunikationspunkte) nicht entsprechend vorgegeben ist, können sich daraus Konflikte ergeben, insbesondere eine so genannte Verklemmung (deadlock), wenn zwei Abläufe gegenseitig aufeinander warten (bzw. sich gegenseitig blockieren). Zur Lösung dieser Problematik werden verschiedene Techniken herangezogen:

Der Kontext jedes Programmteils muss vor unerwarteter Veränderung durch andere Teile geschützt werden (Synchronisierung). Soll ein gemeinsamer Zugriff auf Daten realisiert werden, wobei zumindest eine Partei schreibend/verändernd zugreifen möchte, dann muss der Zugriff synchronisiert werden, bspw. durch gegenseitigen Ausschluss (Mutex) unter Benutzung von Monitoren oder von Semaphoren. Alternativ kann auch verlangt werden, dass bestimmte Aktionen von zwei Prozessen gemeinsam ausgeführt werden, mit so genannten Rendezvous. Eine weitere sichere Art der Kommunikation sind Warteschlangen. Diese Techniken lösen das Problem des gleichzeitigen Zugriffs auf Ressourcen, verhindern jedoch keine Verklemmungen (ganz im Gegenteil).

Besonders wichtig sind solche Techniken in verteilten Systemen, vor allem um die Integrität von verteilten Transaktionen zu gewährleisten.

Parallele Programmiersprachen

Die meisten Programmiersprachen bieten Möglichkeiten zur Parallelisierung von Abläufen. Einige Sprachen sind jedoch von Grund auf für paralleles Programmieren entworfen oder besitzen diese Fähigkeit inhärent:

• Newsqueak – in den 1980er Jahren veröffentlichte Sprache zur Implementierung grafischer Benutzeroberflächen
• Occam – 1985 veröffentlichte imperative Programmiersprache, die auf Communicating Sequential Processes aufbaut
• Scratch – 2007 veröffentlichte bildungsorientierte visuelle Programmiersprache. Eine erstaunliche Eigenschaft von Scratch ist, dass das eigentlich komplexe Programmierparadigma ‚Parallele Programmierung‘ quasi nebenbei eingeführt wird. Im Gegensatz zu traditionellen bildungsorientierten Programmiersprachen wird dieses in Scratch auch von Anfängern intuitiv sofort genutzt, so dass sie sich später ggf. wundern, dass „Profi-Programmiersprachen“ zunächst nur sequentiell arbeiten.
• X10 – entwickelt bei IBM zur Programmierung massiv paralleler Systeme
• Erlang – wurde bei Ericsson von Joe Armstrong und anderen entwickelt
• Chapel – Konkurrent zu X10; von Cray
• Unified Parallel C – eine Erweiterung von C99; vom UPC-Konsortium
• Rust – 2015 entwickelte Programmiersprache von Mozilla Research Group, welche C und C++ ablösen soll
• Go

Effizienz

Das gleichzeitige Abarbeiten der Berechnungen verkürzt im Allgemeinen die Ausführungszeit eines Programms. Bezüglich der verbrauchten CPU-Zeit ist ein paralleler Algorithmus jedoch fast immer schlechter als ein serieller, da die Synchronisierung der Abläufe zusätzlichen Verwaltungsaufwand erzeugt.

Auf einem Einkernsystem sind somit nur Parallelisierungen sinnvoll, bei denen ein Ausführungsstrang „weiterarbeiten“ kann, während ein anderer warten muss/soll – ohne Parallelisierung würde dieser Warte-Zwang das „Hintergrund-Weiterrechnen“ blockieren. Meistens muss darauf gewartet werden, dass das Betriebssystem einen Auftrag des Programms erledigt hat, oder der Ausführungsstrang soll auf weitere Benutzereingaben warten, während im Hintergrund Abarbeitungen (z. B. zuvor ausgelöster Benutzeraufträge) berechnet werden.

Um Parallele Programmierung voll auszunutzen, sind mehrere Ausführungseinheiten nötig. Techniken dafür sind Simultaneous Multithreading (SMT), z. B. Hyper-Threading Technology (HTT), Symmetrisches Multiprocessing (SMP), z. B. mittels Multicore-Prozessor oder mehrerer CPUs. Den Extremfall bildet das Massively Parallel Processing (MPP) mit zum Teil mehreren tausend Prozessoren. Verbreitet ist auch, ganze Verbünde von Einzelrechnern zum parallelen Berechnen einzusetzen (Computercluster).

Auf der anderen Seite sollte möglichst wenig Kontrollcode zur Koordination der Threads vorhanden sein, falls dieser nur sequentiell ausgeführt werden kann. Dieser Sachverhalt ist Ergebnis des Amdahlschen Gesetzes über die Parallelisierungseigenschaften von Programmen.

Siehe auch

• Paralleler Algorithmus
• Synchrone Kommunikation
• Asynchrone Kommunikation
• Sequentialisierung
• Graphpartitionierung
• OpenMP, MPI
• Vektorprozessor

Literatur

• Peter Ziesche: Nebenläufige & verteilte Programmierung, W3L, 2004, ISBN 3-937137-04-1
• Douglas Schmidt, Michael Stal, Hans Rohnert, Frank Buschmann: Pattern-orientierte Softwarearchitektur, Muster für nebenläufige und vernetzte Objekte, dpunkt 2002, ISBN 3-89864-142-2
• M. Ben-Ari: Grundlagen der Parallel-Programmierung, 1984, ISBN 3-446-14155-3
• Dietrich Boles: Parallele Programmierung spielend gelernt mit dem Java-Hamster-Modell – Programmierung mit Java-Threads (PDF; 4,1 MB). Vieweg+Teubner-Verlag, 2008, ISBN 978-3-8351-0229-3
• Wolfgang W. Baumann: Parallel-Computing als Hilfsmittel im technisch-wissenschaftlichen Höchstleistungsrechnen – Eine Einführung, 2000 pdf
• Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes: Java Concurrency in Practice. Addison-Wesley Longman, 2006, ISBN 978-0-321-34960-6.