Acht nützliche Tipps zum Parallelisieren

Aufmerksamen Lesern des Software Dev Blogs wird es nicht entgangen sein: es war hier in letzter Zeit ein wenig ruhiger, was mit vielen anderen Aktivitäten meinerseits zu tun hatte. Ich war viel unterwegs, hab viele neue Themen recherchiert und gesammelt, saß mit Leuten zusammen, etc. Und der Output wird sich sehen lassen können: Das reicht von Exklusivinfos direkt vom Intel Developer Forum in San Francisco bis hin zu neuesten Beiträge rund um das Thema Cilk und Co, die ich mit dem Kollgen Deilmann von Intel gemeinsam erarbeiten werde.

Den Anfang macht heute ein Online-Artikel des werten Kollegen Edmund Preiss, der es sich mal wieder zur Aufgabe gemacht hat, die Parallelprogrammierung ein wenig näher zu begutachten. Herausgekommen sind acht sehr nützliche Tipps, die ich hier zusammenfassen will. Den kompletten Beitrag findet ihr auf elektroniknet.net.

Tipp 1: In parallelen Strukturen denken und entwickeln — Hiefür bietet sich für C++-Entwickler beispielsweise das Intel-Tool Parallel Advisor an, das dabei hilft, in einem seriellen Programm parallel Strukturen aufzuspüren. Hierzu gibt es nächste Woche mehr Infos direkt vom IDF, die ich mit vielen Bildern garnieren werde.

Tipp 2: Höhrere Abstraktionsgrade erlauben thread-sichere Programme — Hierfür bieten sich spezielle Bibliotheken an, aber auch Programmiermodelle wie OpenMP oder Intel Threading Building Blocks. Ganz neu am Start in diesem Zusammenhang sind die Intel Array Building Blocks. Auch hierzu gibt es nächste Woche dedizierte Infos.

Tipp 3: Denke und programmiere in Tasks, nicht in Threads — Dieser Tipp hilft, die Skalierbarkeit auf mehreren Prozessorkernen deutlich zu verbessern

Tipp 4: Arbeite mit so wenig Locks wie möglich, aber mit so vielen wie nötig — Hier geht es um Data Races, die beim Umgehen von Locks entstehen können. Und mit Tools wie dem Intel Parallel Inspector kann man mögliche Data Races und Dead Locks identifizieren lassen.

Tipp 5: Skalierbare Speicker-Allokatoren helfen, Speicherzuweisung bei parallelen Programmen zu optimieren.

Tipp 6: Erhöhe die parallele Auslastung, um den seriellen Anteil an Code zu verringern — Dies hat mit der Erkenntnis zu tun, dass Anwendungen nur mit ihrem Anteil an parallelen Ausführungen signifikant schneller werden. Daher sollte man mit den passenden Tools nach Programmbereichen suchen, die sich gut multithreaden lassen. Hierzu gehören beispielsweise Schleifenkonstrukte.

Tipp 7: Teste parallelisierte Programmabschnitte im seriellen Modus auf mögliche Bugs hin — Hierzu gibt es zwei Möglichkeiten: Entweder das “Abschalten” parallelisierter Codeabschnitte mithilfe bestimmter Schalter oder der Einsatz der Intel Parallel Debugger Extensions, die Teil des Intel Parallel Composer sind.

Tipp 8: Software-Tools helfen, während der einzelnen Entwicklungsschritte (Design, Kompilieren, Debuggen, Verifikation und Leistungsverbesserung), die richtigen Dinge zu tun. Hierzu gehört die Entwicklersuite Intel Parallel Studio, die Entwicklern nativ programmierter Programme genau dabei hilft.

GDC09: Wie Programmierer von Dualen Zahlen profitieren

Vor einer Woche hatte ich angekündigt, dass wir uns die Session “Dual Numbers: Simple Math, Easy C++ Coding and Lots of Tricks” ansehen werden. Und genau das haben wir heute getan. Nur so viel: Tough stuff!

Damit wir hier nix Falsches erzählen, konnten wir Gino van den Bergen zu einem Interview überreden, damit er uns etwas über Duale Zahlen erzählt: Worum es in seinem Vortrag ging, warum Spieleentwickler auf Duale Zahlen setzen sollten und was das Ganze mit Larrabee zu tun hat.

Nur soviel: Es geht um “Clean Code”, um die Vereinfachung der Differentialrechnung, und andere schöne Dinge, mit denen vor allem Spieleprogrammierer zu tun haben.

Und jetzt: Film ab!

Tipps zum Multithreading von DirectX-Anwendungen

Ein schwieriges, weil für viele Software-Entwickler unbekanntes Terrain ist das der DirectX-basierten Programmierung. Denn nichts ist leistungshemmender als single-threaded Sourcecode, der sich innerhalb einer parallelisierten Entwicklungsumgebung als Flaschenhals entpuppt. Was sollten also Programmierer und ähnliche Experten tun, um ihrem DirectX-Code mit leistungsfördernden Maßnahmen auf die Sprünge zu helfen?

Nun, zunächst einmal gilt es, die gesamte Anwendung auf mögliche Schwachstellen hin zu untersuchen. Hierfür spezialisierte Profiler-Tools wie der Intel VTune Performance Analyzer, der Intel Thread Profiler oder PIX für Windows helfen dabei, entsprechende Engpässe aufzuspüren. Hierbei handelt es sich um zwei wesentliche Bereiche, in denen es immer wieder zu Leistungseinbußen kommt: Nicht-skalierender Quellcode und 3D-Runtimes und Treiber. Allein die zwei letztgenannten verbrauchen bei suboptimaler Programmierung 25 bis 40 Prozent der gesamten Prozessorkapazität. Hier eröffnet sich also eine Menge an Verbesserungsbedarf.

Darüber hinaus fressen Rendering-Prozesse sehr viel CPU-Bandbreite, je mehr an Spezialeffekten wie Regen oder Wind in der Anwendung stecken oder eine Zunahme an AI-Objekten zu verzeichnen ist. Daher ist der Programmierung und Parallelisierung von Render-Einheiten höchste Priorität einzuräumen.

So gilt speziell bei der effizienten Programmierung von multithreaded 3D-Inhalten, die auf DirectX-APIs basieren, vor allem eins: Vergessen Sie die Treiber nicht und fassen Sie häufig genutzte Routinen sinnvoll zusammen, vermeiden Sie das Reservieren zu großer Systemressourcen und ordnen Sie bestimmte Aufgaben nicht einem bestimmten Prozessor zu. Nur dann erstellen Sie optimierte DirectX-Anwendungen, die auf Multicore-Systemen optimal skalieren und zudem überflüssigen Quellcode und Treiber vermeiden.