Sollten Sie Fragen zu Cilk Plus haben, auf Fehler oder Probleme bei der Bedienung stoßen, wenden Sie sich bitt an das Intel Cilk Plus Forum. Dort finden Sie auch Hinweise zu aktuellen Patches wie dem aktuellen Cilk Plus Patch for gcc 4.7 vom 31.8.2011.

Damit festigt Intel das Ziel, allen Programmierern auf Basis von C/C++ eine gleichermaßen einfache und effektive Programmiersprache beziehungsweise Extensions an die Hand zu geben, die dabei hilft, parallelen Code zu entwickeln. Seit 2009 hat Intel die Cilk-Technologie in eigene Produkte integriert und zu Cilk Plus weiterentwickelt, um sein Portfolio mit OpenMP und den Threading Building Blocks abzurunden.

Ähnlich wie bei OpenMP kennt Cilk Plus so genannte Keywords (spawn, sync, inlet, abort), mit deren Hilfe sich ein seriell programmierter Quellcodeabschnitt in ein parallel ablaufendes Konstrukt verwandelt. Ein beliebtes und oft verwendetes Beispiel ist die rekursive Berechnung von Fibonacci-Zahlen. Hier ein Code-Sample:

01 cilk int fib (int n)
02 {
03     if (n < 2) return n;
04     else
05     {
06             int x, y;
07
08             x = spawn fib (n-1);
09             y = spawn fib (n-2);
10
11              sync;
12
13              return (x+y);
14     }
15 }

Die entscheidenden Schlüsselwörter lauten spawn (Zeile 8 und 9) und sync (Zeile 11). Diese Keywords sorgen dafür, dass die Funktion parallel auf zwei oder mehreren Prozessorkernen ausgeführt wird. Den Rest übernimmt die Runtime von Cilk Plus, die sich um das Erstellen von Threads kümmert, um das Synchronisieren derselben und um das richtige Beenden der parallel laufenden Threads. Dies ist auch der große Unterschied zu OpenMP.

Einen sehr guten Grundlagenartikel zu den Unterschieden zwischen OpenMP und Cilk liefert Michaels Beitrag vom Juli 2010: Infos aus erster Hand zu Cilk.

Zudem empfehle ich James Reinders’ Blog-Beitrag Parallelism as a First Class Citizen in C and C++, the time has come, in dem er die Bedeutung von Task-Parallelisierung und Daten-Parallelisierung verdeutlicht und zeigt, wie sich beide Programmieraufgaben mit Cilk Plus realisieren lassen.

Intel-Ausstellungsbereich mit Florian und Monika

Und nun zu den Developer-Tools, die jeder Parallel-Programmierer kennen sollte. Zumindest deren Unterschiede, Stärken und Schwächen, denn so fällt es nicht nur leichter, sich für das richtige Werkzeug zu entscheiden, sondern auch Fehler im Code zu minimieren. Aber natürlich lassen sich die Tools im Einsatz auch kombinieren.

Merken Sie sich auf jeden Fall diesen Namen: Parallel Building Blocks. Denn diese Toolsuite vereint drei der wichtigsten Werkzeuge für Parallel-Programmierer: Cilk Plus, Threading Building Blocks (TBB) und die neuen Intel Array Building Blocks (ArBB), die derzeit noch in der Beta-Phase sind.

Cilk und Intel Array Building Blocks (ArBB) werde ich hier näher vorstellen.

Cilk Plus

Cilk Plus ist unbestritten das einfachste Tool und auch für Einsteiger sicher gut geeignet. Streng genommen sind sich Cilk und OpenMP recht ähnlich. Beide produzieren schnellen, parallelen Code ohne viel Overhead. Und beide werden von Intel Compilern unterstützt. Das gilt im Übrigen auch für OpenMP in der Version 3. Es gibt aber auch gravierende Unterschiede, die Cilk für Entwickler deutlich attraktiver machen als OpenMP.

Das beginnt schon bei der Bedienung. Wer sich jemals mit Cilk auseinandergesetzt hat, wird sich an das Schlüsselwörter-Prinzip erinnern. Mit den drei Kommandos cilk_spawn, cilk_sync, cilk_for erledigen Sie die wichtigsten Aufgaben im Code. Dabei kontrolliert die Cilk Plus Runtime die Threads und deren zeitliche Ausführung. Gerade dieser sehr zuverlässige Cilk Runtime Scheduler hebt sich wohltuend von OpenMP ab. Die Zahl der Threads im Code wird hierbei automatisch den vorhandenen Prozessorkernen angepasst. Der Entwickler kann dies aber auch korrigieren, wenn er das möchte.

Auch auf Data Races hat Cilk Plus eine Antwort. Natürlich lassen sich Variablen auch mit der Mutex-Methode schützen, aber Cilk Plus geht hier deutlich eleganter vor, indem es Hyperobjects nutzt. Das sorgt für eine deutliche bessere Performance.

Herauszuheben sind last but not least die Array Notations in Cilk Plus. Darüber freut sich der Compiler, der Vektoranweisungen viel besser verarbeiten kann als Schleifen. Weitere Infos gibt es übrigens auf der sehr guten Seite www.cilk.com.

Intel Threading Building Blocks (TBB)

Die Intel Threading Building Blocks (TBB) bieten eine C++-Laufzeitbibliothek und sind als Open Source oder per Compiler verfügbar. Sie sind plattform- und sprachenunabhängig und adressieren vor allem fortgeschrittene Developer. Mit anfängertauglichen Parallelfunktionen wie „parallel_for“ statt „for“ werden die TBB aber auch zunehmend für Einsteiger interessant.

Intel Array Building Blocks (ArBB)

Die jüngste Sprössling der Parallel Building Blocks heißt Intel Array Building Blocks (ArBB).
Vereinfacht ausgedrückt erledigen die ArBB folgenden Job für Code in C++: Sie parallelisieren und optimieren nativen Code, und zwar genau für die Hardware, für die er konzipiert wurde und geben den Code an den Compiler zurück.

Vorteil für den Entwickler: Er muss den Code auch für unterschiedliche Pattformen nur ein einziges Mal schreiben, kann ihn mit ArBB neu kompilieren und dann automatisch auf die Ziel-Hardware ausrichten. Wer es selber ausprobieren möchte: ArBB steht als Beta zum kostenlosen Download bereit.

So, das war’s aus Köln. In der nächsten Woche werde ich wieder live berichten – dann vom ISN Black Belt Event in München. Schönes Wochenende!

Marcus bietet auf seinen Seiten eine sehr gute Zusammenfassung der wichtigsten Vorträge aus dem Blickwinkel eines C++-Programmierers. In Teil 1 seines Reports widmet er sich unter anderem detailliert den Intel Threading Building Blocks und den Parallel Building Blocks. Teil 2 behandelt die Themen Code-Tuning, Analysen mit dem Intel Inspector XE und Embedded Systems. Klasse geschrieben und sehr empfehlenswert!

Apropos Parallel Building Blocks: Die bekommen mit den Intel Array Building Blocks (Intel ArBB) „Nachwuchs“.  Die Intel Array Buidling Blocks liegen derzeit als Beta-Version vor. Nach Ihrer Registrierung können Sie die Software kostenlos downloaden.

Die Intel Array Building Blocks bieten ein flexibles, vektorbasiertes Parallel-Programmier-Modell für Multicore- und Many-Core Architekturen. Sie bieten C++-Bibliotheken und produzieren skalierbaren, portablen Programmcode und sind damit ideal für Anwendungen, die daten- und ressourcenintensive mathematische Berechnungen durchführen müssen, beispielsweise wissenschaftliche Programme, Finanzanalysen, Datenbanken oder Animationen.

Die Intel Array Building Blocks sind eine Kombination aus Intels Ct-Technologie und der RapidMind Technologie. Nach dem Start der Beta-Phase liegt nun der erste Bug-Report vor. An dieser Stelle vielen Dank an die vielen, weltweiten Beta-Tester, die dazu beitragen, dass das fertige Produkt schlussendlich Ihren Erwartungen entspricht. Die komplette Liste lässt sich hier abrufen.

Sie wollen die Parallel Building Blocks genauer kennenlernen? Dann empfehlen wir Ihnen die Sammlung von insgesamt 100 Videos, Trainings und Blogposts zum Thema PBB, die jetzt auf ISN veröffentlich wurde. Die amerikanischen Kollegen haben eine beeindruckende Auswahl an technisches Trainings, Videos und Background-Artikeln zusammengetragen, die sowohl Einsteiger als auch Experten adressieren. Keine Session dauert länger als 15 Minuten. Und die Liste wird täglich aktualisiert, deswegen dürfen Sie auch gerne mehrmals wöchentlich reinschauen!

Auf den ersten Blick bietet Intel TBB 3.0 zwei wesentliche Verbesserungen: die volle Kompatibilität mit Visual Studio 2010 und .NET 4 sowie die Unterstützung des künftigen ISO/ANSI-Standards für C++, der noch unter dem Arbeitsnamen C++0x geführt wird. Aber auch andere Features wie eine neue Containerklasse und verbesserte Debugger-Merkmale flossen in die neue Version der Intel TBB 3.0 ein. Im Detail sieht das wie folgt aus:

Optionaler C++0x-Support

• die neue Funktion parallel_pipeline() verbessert die alte Warteschlange-Funktion mithilfe von Lambda-Support und anderen Features
• TBB_USE_CAPTURED_EXCEPTION() verbessert das Exception Handling
• verbesserte Synchronisierung auf Basis konditioneller Variablen

Handbuch “Pattern Design”
Dieses von TBB-Entwickler Arch Robison geschriebene Handbuch zeigt, wie Pattern Design funktioniert

Kompatibel mit Microsoft Visual Studio 2010

• Support der Concurrency Runtime
• kompatibel mit der Parallel Pattern Library
• kompatibel mit reader_writer_lock() and critical_section_lock()

Neue Container-Klasse
concurrent_unordered_map() (natürlich C++ 0x-kompatibel)

Verbessertes Debuggen

• Task Scheduling, Vorhersagen und Reaktionszeiten wurden verbessert
• voneinander unabhängiges Verwalten von Tasks für mehrere Masterthreads
• verbesserte Vermeidung von Deadlocks
• weiterentwickelte Hinweise für Parallel Amplifier und Parallel Inspector

Scheduler-Support (task::enqueue)

• unterstützt FIFO-Warteschlagen
• nützlich für das  Emulieren von Task-Prioritäten und die Interaktion mit GUI-basierten Threads

Leistungsverbesserungen

• Beschleunigung der Funktion numerable_thread_specific() und Kombinationen davon
• verbesserte Speicherverteilung bei großen Speicherblöcken

und einiges mehr.

Wer mit Intel Threading Building Blocks Software entwickeln und parallelisieren möchte, kann dies in zweierlei Hinsicht tun: entweder bezahlt man 299 Dollar für die Windows- oder Linux-Variante und erwirbt damit das kommerzielle Paket von TBB 3.0. Dazu gehört auch ein professioneller Support seitens Intel. Oder man begibt sich auf www.threadingbuildingblocks.org, besorgt sich die Open-Source-Variante des Pakets und bekommt damit eine GPLv2-Lizenz. Diese ist natürlich kostenlos.

• Da die parallel arbeitenden Warteschlangen mit der Version 2.2 sowohl begrenzt (bounded) als auch unbegrenzt (unbounded) arbeiten, sollten Programmierer möglichst die begrenzten Warteschlangen benutzen.

• Da sich die Rückgabewerte der Vektor-Funktionen grow_by, grow_to_at_least und push_back geändert haben, ist der Funktionsaufruf ein wenig einfacher geworden. So wird aus std::copy(begin, end, x.begin()+x.grow_by(end-begin)); jetzt std::copy(begin, end, x.grow_by(end-begin));

• In Intel TBB 2.2 ist auto_partitioner() als Standard gesetzt und löst damit simple_partitioner() ab.

• Der Begriff der Task-Tiefe spielt in TBB 2.2 keine Rolle mehr. Daher sind depth_type und die Methoden depth(), set_depth() und add_to_depth().

Mehr Infos und weitere Codebeispiele sind im angegebenen Blogbeitrag erhältlich.

Das soll vor allem Software-Entwicklern die Möglichkeit geben, Intel TBB bei der Programmierung und Optimierung von Multithread-Sourcecode von Anfang an einsetzen zu können. So umfasst beispielsweise die Unreal Engine von Epic Games ab sofort eine kommerzielle Lizenz der Intel TBB, Autodesk stellt in Maya Intel TBB standardmäßig zur Verfügung.

Neben diesen Neuerungen gibt es weitere Dinge, die hinsichtlich mehr Leistung optimiert wurden:

• Der Taks-Scheduler wurde erheblich überarbeitet, sodass optimierte Anwendungen auf Multicore-Plattformen besser skalieren. Dazu gehören eine automatische Initialisierung bei paralleler Ausführung bestimmter Codeabschnitte und das Zusammenfassen mehrerer Tasks zu einer Gruppe.

• Der Memory Allocator wurde ebenfalls verbessert, was den standardmäßigen Allocator des Betriebssystems ersetzen kann. Folge: bessere Skalierbarkeit der vorhandenen Speicherressourcen und weniger Datenkollisionen.

• Darüber hinaus gibt es neue und verbesserte Konstrukte. Neu sind parallel_invoke and parallel_for_each, mit deren Hilfe sich parallele Konstrukte noch einfacher erstellen lassen. Zudem wurde das Erstellen der häufig benutzten parallel_for-Konstrukts vereinfacht.

Ach ja: Für ein besseres Verständnis, was es mit den optimierten Lambda-Funktionen auf sich hat, empfehle ich zwei Blogposts (Nummer 1 und Nummer 2) des Kollegen Reinders, in denen er sehr anschaulich erklärt, was es bringt und was sich dadurch ändert.

We need languages that take full advantage of multicore processing

Genau darum geht es heute. Nicht die Hardware ist der Hemmschuh, sondern die Software, sprich die Programmiersprachen, die derzeit zur Verfügung stehen. Oder wie es der Autor passend formuliert:

Computer evolution, however, is now headed down an entirely new path: instead of simply becoming faster, our computer processors are being conjoined to work together. That new computer architecture requires a serious evolution in computer programming. Without it, we can only scratch the surface of what multicore computing can really do.

Das ist die Kernthese, mit der sich auch dieses Blog immer wieder beschäftigt, denn die Zeiten der GHz-Spirale sind endgültig vorbei, und eine neue Ära des “Parallel Computing” ist angebrochen – sogar im Mainstream-Markt. Denn was die HPC-Gemeinde seit Jahren vormacht, ist auf dem gemeinen Desktop-PC und Notebook jetzt auch möglich, wird nur zu selten richtig eingesetzt.

Eine weitere interessante These stellt der TR-Artikel in Sachen “Umdenken” auf: So wie seinerzeit diverse Software-Entwickler den Trend der objektorientierten Programmierung verschlafen haben, droht heute die Gefahr erneut, da das Schreiben von parallel-orientiertem Sourcecode ebenfalls einen völlig neuen Denkansatz erfordert. Dies betrifft vor allem den gemeinsamen Zugriff auf Daten, dessen Koordinierung in parallelen Systemen bedeutend anspruchsvoller ist als im seriellen Universum.

Aber es gibt laut Paul Tyma, dem Autor des zitierten Beitrags, auch gute Nachrichten: Denn Sprachen wie C++ und Java, die von ihrer Anlage her ja seriell sind, haben große Änderungen erfahren und sind mittlerweile durchaus in der Lage, in Multicore-Umgebungen zu skalieren. Dies machen Tools wie die Intel Threading Building Blocks oder die Intel C++ Compiler deutlich, in denen ein ganze Menge an Multithread-Potenzial steckt. Mit diesen Hilfsmitteln gelingt auch weniger erfahrenen Parallel-Programmierern der Einstieg in die Multicore-Welt. Was die Entwickler allerdings nicht davon abhalten sollte, ihre Software-Projekte in Zukunft akribisch vorzubereiten und über bestimmte Dinge gründlich nachzudenken.

Fazit: Mit den gegebenen Tools könnte der Wechsel von der seriellen zur parallelen Programmierung bald in großem Maßstab gelingen. Oder wie es Paul Tyma zusammenfasst:

With these new languages and programmers’ development of new skills, the acceleration of computing power that we’ve almost come to take for granted will soon be back on track.

Übrigens: Paul war früher bei Google, hat sich dort intensiv mit dem Thema Multicore-Programmierung beschäftigt. Er sollte also wissen, worüber er spricht …

Die Intel TBB lassen sich in sechs fundamentale Einzelteile zerlegen:

1. Algorithmen
2. Container
3. Memory Allocator
4. Mutual Exclusion
5. Timer
6. Task Scheduler

1. Die TBB-Algorithmen richten sich vor allem an parallel ausführbare Schleifenkonstrukte, aber auch Sortieralgorithmen lassen sich mithilfe der TBB recht problemlos parallelisieren. Die zugehörigen Funktionen nennen sich parallel_for, parallel_reduce, parallel_scan, parallel_while, parallel_pipeline und parallel_sort. Eine genauere Betrachtung dieser Funktionen findet auf dem Software Dev Blog in einem späteren Beitrag statt.

2. Die Intel TBB setzen sich aus drei Containern zusammen: queue, vector und hash table. Diese Container findet man zwar auch in den Standard Template Libraries von C++ und Fortran, diese sind allerdings weniger thread-sicher als die der Intel TBB.

3. Der Memory Allocator der Intel TBB ist äußerst skalierbar und daher in der Lage, gemeinsam genutzten Speicher auf mehrere Threads so zu verteilen, dass sich diese nicht gegenseitig behindern. Damit kümmert sich der Allocator der TBB um das gleichzeitige Ausführen der wichtigsten Funktionen wie malloc, new und delete.

4. Die Mutual Exclusions der Intel TBB kümmern sich um konsistente Daten bei der Ausführung paralleler Funktionen. Es geht also um das Sperren und Freigeben von Daten (Lock und Unlock) während der Ausführung verschiedener Threads. Somit ist gewährleistet, dass sich Threads bei der Manipulation von Daten nicht ins Gehege kommen, was zu richtigen Ergebnissen führen soll.

5. Die in den Intel TBB implementierte Timing-Funktion – also das Ermitteln der Programmdauer per Subtraktion zweier Uhrzeiten – ist für viele Entwickler ein wichtiger Aspekt. Von Bedeutung dabei ist aber auch ein Ergebnis, auf das man sich selbst dann verlassen kann, wenn der zugehörige Thread auf mehreren Prozessorkernen parallel ausgeführt wird.

6. Eine Kernfunktion der Intel TBB ist der Task Scheduler, der die Vielzahl unterschiedlicher Aufgaben, die mithilfe der Algorithmen aus Punkt 1 definiert werden, auf die vorhandenen Threads, also Prozessorkerne, optimal verteilt. Um dies zu garantieren, beherrscht der Task Scheduler das Load Balancing, was dazu führt, dass parallele Aufgaben möglichst effizient von den vorhandenen CPU-Cores ausgeführt werden. Folge: Maximale Performance der Anwendung!

Wie gut, dass es für die Parallelisierung solcher Anwendungen die passenden Tools gibt, die Intel unter dem Begriff „Performance Libraries“, also Hochleistungsbibliotheken, anbietet. Dazu gehören die schon besprochenen Intel Threading Building Blocks, aber auch spezielle C++-Bibliotheken namens Intel Integrated Performance Primitives (Intel IPP) und Intel Math Kernel Library (Intel MKL).

Die Intel IPP wenden sich an all diejenigen, die programmierseitig viel mit En- und Dekodern für Audio- und Videoinhalte zu tun haben, aber auch mit Datenkompression, Spracherkennung und Bildbearbeitung. Für all diese (und weitere) Anwendungen bieten die Intel IPP nämlich die passenden Bibliotheken, die sich mit wenig Aufwand in das eigene Softwareprojekt integrieren lassen. Man muss ja schließlich das Rad nicht jedes Mal neu erfinden. Außerdem kann man sicher sein, dass die IPP in höchstem Maße multithreaded sind.

Aber auch die Intel MKL bietet vorgefertigte Bibliotheken, Funktionen und Konstrukte, die sich mit wenigen Anpassungen in eigene Projekte einbinden lassen. Dies betrifft vor allem Wissenschafts-, Entwickler- und Finanzanwendungen. Die Intel MKL setzt hierfür unter anderem auf hoch parallelisierte Fast-Fourier-, Statistik- und LAPACK-Routinen.

Intel IPP und Intel MKL unterstützen Windows, Linux und Mac OS X und lassen sich problemlos in Visual Studio 2003, 2005 und 2008 integrieren. Beide Toolsets sind zudem Teil der Intel C++-Compiler Professional Edition. Außerdem können die Multicore-Bibliotheken zu Evaluationszwecken ausgiebig getestet werden. Hierfür muss man sich nur einmal für die jeweilige Software anmelden, was kostenfrei ist.

Die eine Form der parallelen Programmierung orientiert sich an den zu verarbeitenden Daten, die zur Laufzeit der Anwendung anfallen. Ein gutes Beispiel für die Datenparallelität ist das Rendern eines Bildes, das aus vielen tausend Bildpunkten besteht, die sich unabhängig voneinander berechnen, zeichnen oder mit einem Filter versehen lassen.

Darin steckt also eine Menge an Multicore-Potenzial, wofür sich der Einsatz von OpenMP oder Intel TBB empfiehlt. Ein weiteres gutes Beispiel ist die Rechtschreibprüfung eines Textverarbeitungsprogramms. Hier können sämtliche Wörter simultan überprüft werden, da sie zueinander in keiner Abhängigkeit stehen.

Auf der anderen Seite existiert der Aufgabenparallelismus, der voneinander getrennte Aufgaben betrachtet, die sich vortrefflich parallel ausführen lassen. Ein gutes Beispiel hierfür ist Outlook, das aus unterschiedlichen Modulen besteht (Adressen, Kalender, E-Mail etc.), die sich grundsätzlich unabhängig voneinander ausführen lassen und damit auf separaten Prozessorkernen laufen können.

Probleme treten hier vor allem dann auf, wenn die unterschiedlichen Programmteile auf denselben Datenbestand zugreifen, was zu ungewollten, falschen oder nicht vorhersagbaren Datenkonflikten führen kann. Gerade hier sind passende Tools wie die Intel Threading Building Blocks von großer Bedeutung, da diese zum einen Aufgaben in Threads verwandeln und sich zum anderen um die parallele Speicherverwaltung kümmern.

In der Praxis trifft man natürlich sehr häufig auf eine Mischform von Aufgaben- und Datenparallelismus, das so genannte Pipelining. Hierbei ist die Anwendung in viele unterschiedliche Aufgaben unterteilt, innerhalb derer Daten parallel verarbeitet werden können. Ein bekanntes Beispiel hierfür ist wieder die Bildbearbeitung: Ein Bild wird geöffnet, mit einem Filter versehen, in eine andere Auflösung skaliert und abschließend gespeichert.

In allen genannten Fällen werden jeweils viele tausend Pixel berechnet, und die Aufgaben können teilweise parallel, teilweise aber nur sequenziell ausgeführt werden. Außerdem ist die Gefahr von Datenkonflikten recht hoch. Gerade im Falle des Pipelining ist die Wahl der besten Programmiermethode von entscheidender Bedeutung. Denn in den allermeisten Fällen ist eine 100-Prozent-Parallelisierung von Software weder möglich noch sinnvoll.

Multicore-Regel Nummer 1: Denke parallel! Am allerbesten ist ein paralleles Konzept von Anfang an. Dies vermeidet ein nachträgliches Implementieren parallelen Quellcodes, wie das beispielsweise mit den Intel Threading Building Blocks möglich ist. Optimalerweise legen Sie sich eine Strategie zurecht, wie Sie Schritt für Schritt zu einer multicore-optimierten Anwendung kommen.

Multicore-Regel Nummer 2: Entwickle task-orientiert! Parallel programmierter Code skaliert am besten, wenn er nicht für eine bestimmte Zahl an Prozessoren programmiert wurde, sondern sich an der bestmöglichen Zahl an parallel ausführbaren Aufgaben orientiert. Denken Sie daher nicht in Threads, dass erledigen Tools wie die Intel TBB für Sie. Deren Scheduler verteilt die auszuführenden Aufgaben auf die vorhandenen Prozessorkerne. Und je mehr davon zur Verfügung stehen, desto paralleler läuft die Anwendung.

Multicore-Regel Nummer 3: Auf die Tools kommt es an! Parallele Threads auf Basis von POSIX oder Windows-APIs programmieren zu wollen, ist ein hartes Brot, denn Sie müssen sich selbst um die Parallelisierung des Quellcodes kümmern. Viel einfacher ist es, mit den richtigen Tools der Anwendung paralleles Leben einzuhauchen.

Sie entwickeln bevorzugt mathematisch-orientierte Software? Dann werfen Sie mal einen Blick auf die Intel Math Kernel Library. Sie programmieren MPEG-Encoder? Fein, dann kommen am ehesten die Integrated Performance Primitives in Frage, die mithilfe der vorhandenen Funktionen das Parallelisieren von Multimediaanwendungen erleichtern. Und die Intel TBB habe ich ja bereits erwähnt, die dank ihrer eingebauten Multithread-Funktionen vor allem Schleifenkonstrukte mit wenigen Programmzeilen parallelisieren.

Multicore-Regel Nummer 4: Multithread-Code muss sequenziell laufen! Das klingt zunächst einmal kontraproduktiv, stellt sich aber gerade beim Debuggen als großer Vorteil heraus, da die Fehlersuche im sequenziellen Quellcode wesentlich einfacher ist. Stellen Sie also sicher, dass Ihre Anwendung auf einem Thread fehlerfrei läuft. Wenn Sie dann beim Umstellen auf zwei, vier oder mehr Threads Fehler feststellen (zum Beispiel mithilfe des Thread Checkers), können Sie sich ziemlich sicher sein, dass im Parallel-Code etwas nicht stimmt. Übrigens: Ein vollständig parallelisiertes Programm ist keine gute Idee!

Multicore-Regel Nummer 5: Denke an die Speicherverwaltung! Die Zuweisung von benötigtem Speicher ist vor allem bei parallel ausführbaren Programmen eine echte Herausforderung, da je nach Anzahl der verfügbaren Prozessoren und der damit maximalen Anzahl von Threads der richtigen Speicherverwaltung zur Laufzeit eine enorm wichtige Bedeutung zukommt. Daher sollten Sie beim Entwickeln von Multithread-Code unbedingt auf einen skalierenden Memory Allocator setzen, der den notwendigen Speicher automatisch verwaltet. Die Intel TBB setzen solch einen dynamischen Speicherzuweiser ein …

OpenMP: Diese Threading-Methode ist relativ simpel zu handhaben, da in den Quellcode sogenannte Pragmas eingebaut werden, die der jeweilige Compiler richtig interpretieren kann – oder auch nicht. OpenMP eignet sich vor allem für die Parallelisierung einfacher Schleifenkonstrukte und prozeduraler Datenstrukturen. Aufgrund seiner Historie lässt sich OpenMP gut in nativen Programmierumgebungen (C++ und Fortran) einsetzen, dafür leider gar nicht in managed Code (C#, .NET).

Threading-APIs: Spezielle Threading-APIs wie Win32- oder POSIX eignen sich nicht so gut zum Implementieren von Parallel-Code. Dabei werden die Multithreading-Konstrukte in eigenen Funktionen verpackt. Die Ergebnisse werden dann als Pointer übergeben, und hier steckt die Schwierigkeit bei der Arbeit mit Threading-APIs: Funktionsprototypen und Datenstrukturen müssen aufwendig modifiziert werden, was häufig die Abstraktion des Codes und das Programmdesign zerstört. Außerdem muss man sich als Programmierer selbst um das Erzeugen, Verwalten und Synchronisieren der Threads kümmern, was sehr mühsam ist. Daneben unterstützen Threading-APIs C++ nur sehr schlecht und oft gar nicht.

Intel Threading Building Blocks: Hierbei handelt es sich um eine C++-Bibliothek, die ähnlich wie die Standard Template Library eines herkömmlichen Compilers aufgebaut ist. Die Intel TBB stellen hochentwickelte Abstraktionsmodelle zur Verfügung, um eine flexible Programmierung zu ermöglichen. Das bedeutet, dass beispielsweise Iteratoren, die in Container verpackt sind, mithilfe der Intel TBB relativ einfach parallelisiert werden können.

Die Idee hierbei ist recht simpel: Anstatt Threads spezifiziert man einzelne Aufgaben (Tasks), die der TBB Scheduler auf die vorhandenen Hardware-Threads abbildet. Man muss sich also nicht mehr um die Synchronisation der Threads und ähnliches kümmern. Außerdem skaliert eine mithilfe der Intel TBB parallelisierte Anwendung sehr gut, da je nach verfügbaren Prozessorkernen und damit verbundenen Threads die Software um ein Vielfaches schneller ausgeführt werden kann.

Finden Sie zum Beispiel mit dem Concurrency Checker heraus, ob Ihre Software tatsächlich parallel programmiert wurde und wie sich der Multicore-Code zur Laufzeit verhält. So spüren Sie relativ einfach Fehler im Quellcode auf. Anhand der Ergebnisse wissen Sie dann schon mal ziemlich genau, wo es bei Ihrer Software in Sachen Multithreading hakt. Anschließend können Sie mithilfe der Intel Threading Analysis Tools die Fehler beheben und aus Ihren Anwendungen echte Multicore-Anwendungen machen.

Aber auch kostenlose Entwickler-Werkzeuge für nicht-kommerzielle Softwareprojekte finden Sie dort. Dazu gehören beispielsweise die Intel-Compiler (C++ und Fortran) für Linux sowie der VTune Performance Analyzer für Linux. Aber auch die C++-Multithread-Bibliothek Intel Threading Building Blocks lässt sich für nicht-kommerzielle Zwecke gratis nutzen.

Oder wie wäre es mit Software, die sich im Alpha-Stadium befindet und an deren Weiterentwicklung Sie sich beteiligen können? Hierfür hat Intel die Webseite Whatif eingerichtet, auf der man immer wieder interessante Projekte und Tools findet. Wie zum Beispiel mathematische Bibliotheken für Fließpunktberechnungen oder statistische Funktionen.

Sogar eine komplette Sammlung von C++-Routinen finden man auf der Whatif-Seite. Diese kostenlose Concurrent Collections für C/C++ hilft Software-Entwicklern dabei, Multicore-Anwendungen zu programmieren, ohne dabei auf eine explizite Parallelisierung achten zu müssen. Diese Bibliothek funktioniert unter Windows (32 und 64 Bit), erfordert die Opensource-Variante von Intel TBB und lässt sich nur in Verbindung mit Microsoft Visual Studio 2005 SP1 oder Microsoft Visual Studio 2008 einsetzen.

Sie sehen also: Die Code & Download-Seite ist immer einen Besuch wert und gehört in jede gut sortierte Bookmark-Liste.

Dazu zählt beispielsweise der C++-Compiler, den es in einer Professional und Standard Edition gibt. Vor allem die Profi-Variante hat es in sich: Volle Multithread-Unterstützung für paralleles Programmieren, was zum Beispiel automatisches Multithreading umfasst, aber auch Vektorisierung, OpenMP oder Loop Unrolling. Darüber hinaus bietet die Compiler-Suite leistungsstarke C++-Bibliotheken für noch mehr Parallelismus, mathematische Funktionen und Multimediaanwendungen.

Aber nicht nur den Mac-kompatiblen C++-Compiler hat Intel zu bieten, sondern auch Intel Threading Building Blocks, Intel Integrated Performance Primitives und Intel Math Kernel Library, die allesamt perfekt auf den Intel C++-Compiler für Mac OS X abgestimmt sind.

Das Beste daran ist jedoch die volle Integration der Intel-Tools in die Apple-eigene Entwicklerumgebung Xcode, mit der sich Mac-Programme sehr intuitiv und sehr elegant schreiben lassen. Darüber hinaus kann man sich als Entwickler sicher sein, dass die eigenen Anwendungen optimal auf Intel-basierten Apple-Rechnern laufen und das Multithread-Potenzial bestmöglich ausschöpfen.

Übrigens: Neben dem C++-Compiler bietet Intel auch einen Fortran-Compiler für die Mac-OS-X-Entwicklergemeinde. Damit diese nicht zu kurz kommt.

Falls Sie sich jetzt fragen, ob Sie das Ganze erst mal ausprobieren können, bevor Sie die Intel-Mac-Dev-Tools kaufen – ja, Sie können. Hierfür brauchen Sie sich lediglich für den kostenlosen Intel Premier Support anzumelden und können anschließend das entsprechende Tool aus dem Evaluation Center auf Ihren Mac laden und dort ausgiebig testen. Kommerzielle Anwendungen lassen sich damit aber nicht erstellen!

Diese Seite nennt sich go-parallel.com und berichtet in regelmäßigen Abständen über das parallele Multicore-Universum der Software-Entwicklung. Zu diesem Zweck ist die Seite in fünf Bereich unterteilt:  „Getting Started“, „Concurrent Programming“, „Community and Opinion“, „Tools and Tips“ und „Advanced Concepts“.

So findet man in „Getting Started“ hilfreiche Anleitungen, wie man beispielsweise eine komplette TBB-Umgebung unter Windows einrichtet und wie die Programmierung einer TBB-kompatiblen Anwendung funktioniert. Aber auch Themen wie OpenMP werden dort behandelt.

„Concurrent Programming“ führt dann das fort, was unter „Getting Started“ begonnen wurde. So lernt man Teile der Intel TBB besser kennen und wie man diese für seine eigenen Projekte schneller einsetzen kann. Wie zum Beispiel den Algorithmus „parallel_scan“, mit dessen Hilfe sich einzelne Programmabschnitte in ihre Einzelteile zerlegen lassen, damit diese parallel ausgeführt werden können, was natürlich die Leistung der Anwendung erhöht. Vor allem, wenn dies rekursiv geschieht.

Die Sektion „Community and Opinion“ lässt echte Profis zur Wort kommen. Wie Claire Cates, die für das Software-Unternehmen SAS arbeitet und die über ihre Erfahrung mit den Intel-Tools Thread Checker und Thread Profiler spricht, die ja beide Teil des VTune Performance Analyzer sind.

„Tools and Tips“ ist eine echte Fundgrube, wenn es um all die Intel-Tools geht, die Software-Entwicklern bei ihrer Arbeit helfen sollen. So erfährt man eine Menge über Intel Compiler und die Bibliothekssammlung Intel TBB, aber auch OpenMP ist Gegenstand dieses Abschnitts.

Mit „Advanced Concepts“ geht go-parallel.com noch einen Schritt weiter und stellt neue Technologien und Projekte vor, die Programmierer in der Zukunft unterstützen sollen. Aber auch von der Gegenwart ist die Rede: Wie man Software für Multicore-Plattformen schreibt, Programme auf Intel-Rechnern testet und wie sich bestehende Windows-Anwendungen auf Mac OS X migrieren lassen. All das und vieles mehr lernt man auf go-parallels.com.