Montag, 23. Januar 2012

Star des ersten Tages war unter anderem der Android-Einsteiger-Kurs von und mit Lars Vogel, der von 10 bis 17 Uhr alles Wissenswerte über Android und seine Programmierung verraten hat.

Nicht minder spannend war der Vortrag “Cloud ohne Hype”, in dem Halil-Cem Gürsoy und Eberhard Wolff drei Stunden lang ihre Zuhörer in die Welt der Internet-Dienste entführten und anhand geeigneter Anwenderberichte Nutzen und Stolpersteine des Cloud Computing aufzeigten.

Wer wissen wollte, wie das Google Web Toolkit genau funktioniert, konnte sich von 18:30 bis 20:00 Uhr von Kai Tödter darüber aufklären lassen. Es ging unter anderem um deklarative GUIs mit UI-Binder, GUI-Builder GWT-Designer, Cell-Widgets und Model-View-Presenter Pattern.

Dienstag, 24, Januar 2012

Tag 2 auf der OOP 2012 hatte für alle Mobile-Entwickler den Vortrag “Plattformübergreifende Entwicklung von mobilen Anwendungen” von Peter Friese parat. Der werte Kollege machte klar, dass mobile Apps ganz unterschiedliche Ansätze kennen: von nativ über hybrid bis hin zu mobilen Webanwendungen auf Basis von HTML5.

Dass auf der OOP nicht nur die Technik, sondern auch der Mensch eine Rolle spielt, macht die Entwicklerkonferenz so besonders. So waren wieder zahlreiche Präsentationen am Start, die sich den zwischenmenschlichen Dingen der Software-Entwicklung beschäftigten. Dazu gehörte unter anderem der Vortrag von Jörg Dirbach und Markus Flückiger, die unter dem Titel “Software entwickeln mit Verstand” aufzeigten, wie sich individuelle und Teamprobleme richtig lösen lassen, was jedem Projekt zu gute kommt.

Und wer am Montag nicht die Gelegenheit bekam, den Android-Einsteigerkurs von Lars Vogel zu besuchen, der konnte das von 17:45 bis 18:45 Uhr nachholen. Allerdings in der verkürzten Fassung.

Mittwoch, 25. Januar 2012

Von 9 bis 10:30 referierte Michaël Chaise von Adobe ausführlich darüber, wie sich die unterschiedlichen mobilen Plattform mithilfe eines einzigen Tools adressieren lassen – nämlich mit Adobe Flex. Mit diesem Opensource-Framework können Sie Crossplattform-Apps entwickeln – und zwar für iOS, Android und Blackberry Tablett OS.

Auch sehr beachtenswert (vor allem aus Sicht dieses Blogs) war der Vortrag von Urs Gleim von der Siemens AG, der unter dem zweideutigen Titel “Des Pudels Kerne: was bedeutet Multicore für den Softwarearchitekten?” darüber referierte, warum Mehrkern-Prozessor-Systeme für die Software-Entwicklung wichtig sind und wie dies in der Praxis umgesetzt wird.

Donnerstag, 26. Januar 2012

Neben all den programmierlastigen Referaten werden aber auch Business-Aspekte auf der OOP angesprochen. So wie dies Torsten Winterberg von 11:00 bis 11:45 getan hat, der in seinem Vortrag die Frage stellte, ob mobile Lösungen und BPM (Business Process Management) überhaupt zusammenpassen und welche Lösungen hierfür bereits bestehen.

Wer sich für die Programmiersprache Erlang interessiert, sollte heute Abend zwischen 18:30 und 20 Uhr den Vortrag von Pavlo Baron besuchen, der anhand eines typischen Beispiels zeigt, wie Erlang funktioniert und wie sich diese Programmiersprache richtig einsetzen lässt. Und das alles geschieht live!  Interessante Aspekte dabei sind die Multicore-Entwicklung, die Verteilung, Bitstrings, die funktionale Programmierung, Message Passing und Location Transparency.

Freitag, 27. Januar 2012

Der letzte Tag der OOP 2012 ist traditionell recht kurz, dafür nicht minder interessant. Sehr empfehlenswert ist der Vortrag von Nicolai Josuttis, der von 9 bis 16 Uhr den neuen Standard C++ 11 vorstellen wird. So mit allem Zip und Zap. Dazu gehört zum Beispiel eine Concurrency-Bibliothek, die eine portable Unterstützung von Multithreading bietet.

Am ersten Tag ging es gleich mal sehr animationsmäßig los und wir hatten die Gelegenheit, uns die Havok Physics Engine näher anzusehen, mit deren Hilfe Spieleentwickler recht einfach und schnell bestimmte Effekte in ihre Games einbauen können. Dazu gehören Dinge wie Deformationen, berstende Gegenstände, etc. Und auch vollanimierte Kleidungsstücke lassen sich mit Havok generieren, ohne dass der Entwickler genau wissen muss, wie das funktioniert. Dass es funktioniert, belegen die zugehörigen Videos sehr gut.

Das Thema Spiele beschäftige uns natürlich weiterhin (sic!). So konnten wir mit Jerome Muffat-Meridol von Intel über seine Techsession reden, in der es um das Thema Multithreading von 3D-Spielen mithilfe von DirectX 11 ging. Dabei zeigte er anhand der so gennanten Nulstein-Demo, dass sich Spiele sehr gut parallelisieren lassen, wenn man den richtigen Taskscheduler und DirectX 11 für die einzelnen Phasen beim Erzeugen von 3D-Bildern dazu einsetzt, das ganze System so gut wie möglich zu parallelisieren. Und das skaliert dann problemlos auf 12 Threads, ohne dass der Entwickler große Dinge vollführen muss.

Weiter ging’s dann mit einem ganz anderen Thema, das auf dem IT-techBlog sehr viel besser aufgehoben wäre: Netbook-Games. Hierzu zerrten wir Leigh Davies vor die Kamera, um ihm drei schlaue Fragen zu stellen. Dabei kam heraus, dass Leigh in seiner Session etwas darüber verraten hatte, wie sich Spiele für Netbooks verkaufen lassen und wie man Netbook-Games für die GPU und CPU optimieren kann.

Natürlich durfe auch der Hinweis nicht fehlen, dass sich Netbooks weiterhin gut verkaufen und dass Intel bis zum Jahr 2013 mit zirka 140 Millionen verkauften Mininotebooks rechnet. Es ging außerdem auch um technische Aspekte wie die eingeschränkte Auflösung (1024*600) und die daraus resultierenden Konsequenzen. So rät Leigh zum Einsatz von Icons statt Text. Darüber hinaus sollte man sich als Spieleentwickler klar machen, dass ein Netbook wegen der guten bis sehr guten Akkulaufzeiten und des geringen Gewichts in höchstem Maße mobil ist. Auch das gilt es beim Gamedesign zu berücksichtigen.

Aber nicht nur Spiele für tragbare Computer standen bei Intel auf de GDCE 2010 auf dem Programm. Auch die neuesten Version des Analysetools Intel Graphics Performance Analyzers wurde vorstellt, und hierum kümmerte sich Steve Hughes von Intel, der uns ein bisschen was über die neuen Features von Intel GPA 3.0 erzählte, wie man damit Flaschenhälse und andere Verklemmungen in 3D-Spielen findet und wie Entwickler die Toolsuite optimal für ihre Zwecke einsetzen können. Besonders begeistert zeigte er sich von der neuen Platform View, die systemübergreifend zeigt, wie gut ein Spiel auf einer Multicore-Maschine skaliert.

So, das war`s erstmal, Teil 2 und Teil 3 folgen morgen. Darin wird es um die nächste Version von Intel GPA gehen, um das Parallelisieren von Spielen mithilfe der Intel TBB, um einen selbstgezimmerten Taskscheduler mit Taskstealing und um eine Live-Demo, die anhand von drei Teilen genau zeigt, wie sich Intel GPA einsetzen lässt.

• Intel GPA steht derzeit in der dritten Version kostenlos zum Download bereit, was lediglich mit einer kurzen Registrierung verbunden ist.

• Mit Intel GPA lassen sich DirectX-Spiele untersuchen (DirectX 9 und 10), aber auch das PC-System kann zur Spiele-Laufzeit untersucht werden. Damit lassen sich beispielsweise CPU-Lasten ermitteln und wie das Spiel auf Basis der vorhandenen Ressourcen skaliert.

• Mit Intel GPA lassen sich aber auch einzelne Spielszenen (Frames) untersuchen und herausfinden, wie sich diese in Sachen Funktionsaufrufe, etc. verhalten. Damit weiß man ziemlich genau, an welchen Stellen es “klemmt” und auf dieser Erkenntnis kann man probehalber einzelne Prozessorkerne “abschalten”, neue oder aufwändigere Texturen laden oder den Shader “umschreiben”, um somit eine optimierte Variante der betreffenden Szene zu erhalten. Denn oft sind es Kleinigkeiten, die ein 3D-Game ausbremsen.

• Mit Intel GPA lässt sich zwar nicht nur Intel-Grafikhardware adressieren, aber aufgrund der architektonischen Unterschiede gelingt dies natürlich am besten. Damit kann man genau messen, wieviel Bandbreite die verwendeten Texturen beanspruchen, wie viel Rechenzeit die Shader verbraten, etc. Damit weiß man ganz genau, an welchen Stellen es klemmt – und was man tun sollte, um diese Flaschenhälse zu beseitigen.

Tja, und den Rest schaut ihr euch am besten selbst an. Film ab!

Über eine dieser Sessions habe ich letzten Freitag schon berichtet, und heute erreichte mich die Nachricht, dass es zu den Intel-Aktivitäten eine eigene, kleine Webseite gibt, auf der sich weitere Infos zur Develop 2010 befinden. Dazu gehören unter anderem die Präsentationen in Form von Folien, die die Vorträge kurz und knackig abbilden. Hierunter sind folgende Themen:

1. Building Games for Netbooks
2. PC Profiling Made Easy with Intel Graphics Performance Analyzers (Folien)
3. Vectors of Performance in Gaming (Folien)

Zu Nummer eins habe ich selber schon das ein oder andere gesagt und sogar schon einen eigenen Vortrag gehalten. Zu Nummer zwei gibt es hier auf diesem Blog ebenfalls weiterführende Infos und einen Videobeitrag. Tja, und Nummer drei handelt von solch technischen Dingen wie SIMD, SSE4, Intel AVX und einiges mehr.

Also, ihr Spieleentwickler da draußen, besorgt euch die Präsentationen und schaut, wie ihr das Ganze in eure eigene Arbeit einfließen lassen könnt!

Nach der Keynote-Session von Mario Deilmann (mit dem ich übrigens gestern zusammen saß, neuer Geschichten wegen) waren Bernd Marquardt und Volker Jungbluth an der Reihe, die eine Menge über PPL, TPL und OpenMP zu erzählen hatten.

Bernd begann mit seiner PPL-Session, die sich mit der Parallel Pattern Library beschäftigte. PPL richtet sich an native Programmierer und soll die Parallelprogrammierung deutlich vereinfachen, da sich Entwickler nicht um das Verteilen des parallelisierten Quellcodes auf die zugehörigen Threads kümmern müssen. Dabei sollte man laut Bernd aber trotzdem sicher stellen, dass der seriell erstellte Code fehlerfrei läuft, bevor man sich ans Parallelisieren macht. Ach ja: Die PPL lässt sich nur mit Visual Studio 2010 einsetzen.

Die PPL besteht vor allem aus thread-sicheren Algorithmen, Containern, Objekten und der Task-Parallelisierung. Ein wesentlicher Bestandteil dabei sind sogenannte Lambda-Funktionen, mit denen Code als Parameter in einem Methodenaufruf übergeben werden kann. Dies geschieht mithilfe spezieller Funktionen wie parallel_for() und parallel_for_each(). Besonders interessant ist die Funktion parallel_invoke(), mit der sich bis zu 10 Lambda-Funktionen parallelisieren lasssen, die allerdings alle möglichst gleich lang sein sollten.

Es gibt darüber hinaus Methoden wie try() und throw(), mit denen parallele Schleifen unterbrochen werden können. Und mit der combinable-Klasse erlaubt die PPL den gemeinsamen Zugriff auf eine Variable, ohne dass Data Races entstehen. Schließlich machte Bernd noch darauf aufmerksam, dass die Task-Parallelität das asynchrone Ausführen von Anwendungen erlaubt, indem Task-Gruppen definiert werden. Und ein wichtiger Tipp lautete abschließend: Fehlerfreie Parallelprogrammierung hat sehr viel mit lokalen Variablen zu tun, auf die man nicht von außen zugreifen darf.

Anschließend gab Volker Jungbluth sein Wissen ins Sachen Task Pattern Library (TPL) zum Besten. TPL entspricht in vielen Aspekten der PPL, ist allerdings für die Parallelisierung von Managed Code entwicklelt worden. Ein wichtiger Bestandteil des .NET4-4-Frameworks ist übrigens PLINQ, mit dem man sich als Programmierer laut Volker unbedingt beschäftigen sollte. So sind beispielsweise mit der Methode AsParallel() parallele Abfragen auf Datenstrukturen recht einfach möglich. Interessant fand ich auch die Feststellung, dass Parallel_for-Konstrukte mit dem Partitioner deutlich schneller laufen als ohne.

Weitere Erkenntnisse der Jungbluth’schen Techsession:

• Mit parallel_invoke() lassen sich mehrere Aufgaben auf Threads verteilen, ohne dass man sich explizit darum kümmern muss

• Mit Futures lassen sich task-basierte Ergebnisse im Hintergrund berechnen

• Mit continuation() lassen sich Task-Ketten erstellen, die dank der Lambda-Funktionen Ergebnisse übergeben können.

Nach soviel Parallelprogrammierung unter .NET 4 kam Bernd nochmals auf OpenMP zu sprechen, dass sich zwar am Thread-Konzept orientiert, aber gerade für das Parallelisieren von einfachen Schleifenkonstrukten prima geeignet ist. Daher ist OpenMP vor allem für mathematische Algorithmen eine gute Alternative zu TPL oder PPL, die in der Anwendung doch recht kompliziert sind.

Das Gute an OpenMP ist der Schalter /openmp, der beim Compileraufruf verwendet wird – oder auch nicht. Das erleichtert das Parallelisieren von seriellem Code erheblich, da beim Auftreten von Problemen der OpenMP-Schalter einfach nicht zum Einsatz kommt und die Anwendung zu Testzwecken seriell ausgeführt wird. Ach ja: Auf Basis des Intel-C++-Compilers lassen sich mit dem richtigen Switch fehlerhafte OpenMP-Konstrukte aufspüren.

Toll an OpenMP sind aber auch andere Aspekte:

• Für nicht-ausgewogene Schleifen verteilt OpenMP mit der Mehtode parallel_for_schedule() ganze Schleifenteile gleichmäßig auf auf jeden Thread. Das garantiert eine effiziente Ausführung von parallelen Schleifen.

• Mithilfe der OpenMP-API open_set_num_threads(int) wird die Anzahl der vorhandenen Thread-Ressourcen bestimmt und somit optimal genutzt.

• OpenMP-Variablen sind standardmäßig “shared”. Private-Variablen müssen daher explizit deklariert werden.

• Was für die TPL/PPL der Invoke-Befehl ist, heißt bei OpenMP “sections”.

• Mit dem OpenMP-Pragma omp parallel for if(Anweisung) lassen sich bedingte OpenMP-Schleifen bauen.

Der Multicore-Programmierungs-Track auf den dotnetpro.powerdays 2010 wurde von Mario Deilmann eröffnet, der sich bei Intel u.a. um das Thema Compiler kümmert. Aber nicht nur das: Mario weiß auch eine Menge zu erzählen über die passenden Multithreading-Konzepte, was er auf der Entwicklertageskonferenz auch tat.

Seine Keynote fing mit einem grundsätzlichen Statement an: Die Multicore-Programmierung unterscheidet sich unter anderem in Sachen Abstraktionsebenen Das beginnt bei den eher komplizierten Thread-APIs, geht über OpenMP und Intel TBB und endet bei Tasks und den zugehörigen parallel-tauglichen Architekturen. Dabei gilt festzuhalten, dass je nach Abstraktionsgrad das Parallelisieren mithilfe der jeweiligen Methode mal mehr oder mal weniger kompliziert ist. So stellt sich das Parallelisieren mithilfe von POSIX-Threads kompliziert und fehleranfällig dar und skaliert darüber hinaus sehr schlecht.

Daneben sind Konzepte wie OpenMP ein guter Schritt in die richtige Richtung, allerdings basiert OpenMP immer noch auf expliziten Threads, was möglichst unter allen Umständen vermieden werden sollte. Jedoch konnten die Anwesenden später von Bernd Marquardt lernen, dass OpenMP vor allem für mathematische Anwendung oftmals eine gute, weil einfach anzuwendende Alternative ist.

Die beste Methode ist in vielen Fällen allerdings das Abstrahieren von Threads auf Basis von Tasks. Dies erfordert aber den Einsatz des passenden Frameworks inklusive der entsprechenden Entwicklungsumgebung. Solch ein Framework ist .NET 4 samt Visual Studio 2010, das ja noch recht jung ist. So hilft .NET 4 mithilfe von speziellen Funktionen, Klassen und Methoden, Anwendungen zu parallelisieren, ohne dass der Entwickler sich um das Erstellen, Verwalten und Anhalten/Löschen von Threads kümmern muss. Zudem helfen Thread-Pools beim optimalen Verteilen der Tasks auf die erforderlichen Threads. Dabei kommen Techniken wie Thread Stealing zum Einsatz, was ein effizientes Ausnutzen der vorhandenen Ressourcen garantiert.

Ein weiteres in Frage kommendes Parallel-Konzept befindet sich derzeit im Beta-Status und nennt sich Cilk, es ist einem Projekt des MIT entsprungen. Cilk wird Teil der nächsten C++-Compiler-Version von Intel sein. Mit Cilk bekommen Programmierer und Software-Entwickler ein mächtiges Tool zum nahezu automatisierten Parallelisieren von Anwendungen an die Hand. Cilk lässt sich laut Mario an einem Nachmittag erlernen und erfordert keine Änderungen am vorliegenden Quellcode. Allerdings sollte man sich vor dem Parallelisieren ein paar Gedanken darüber machen, wie der vorhandene Code möglichst effizient strukturiert werden kann, so dass Cilk seinen Job optimal erledigt.

Natürlich bietet Cilk Konstrukte wie parallel_for-Loops und beherrscht auch das Worker Stealing. Daneben reduzieren Hyperobjects die Gefahr von Data Races, ohne dass der Quellcode per Locks “serialisiert” werden muss. Sehr cool ist auch der Einsatz eigener Reducer, die deutlich flexibler als unter OpenMP und Intel TBB arbeiten Zudem generiert das Erstellen von Tasks mithilfe von Cilk deutlich weniger Overhead als das Erstellen von Threads bei vergleichbaren Konzepten wie OpenMP.

So, und wen Cilk jetzt so richtig neugierig gemacht hat, sollte dieses Blog in den nächsten Tagen immer wieder besuchen. Denn ich werde kommenden Dienstag mit Mario zusammensitzen und alles über Cilk aus ihm herausquetschen. Und die nächsten Teile meiner Multicore-Miniserie anlässlich der dotnetpro.powerdays gibt es natürlich auch sehr bald. See you then!

Sein Titel (also der des Buches): “Parallel Computing in .NET”. Sein Autor: Marc André Zhou. Sein Umfang: rund 360 Seiten. Seine ISBN: 978-3-86802-038-0. Seine Mission: Wie mache ich dotNET-Entwicklern klar, dass sie von der sequentiellen Programmierung umsteigen sollten auf die parallele. So gesehen finde ich den Titel ein wenig unglücklich gewählt, wenngleich es in dem Buch natürlich auch um Parallel Computing geht. Doch zuvorderst sollen die Leser dieses gedruckten Leitfadens etwas über Multithreaden und Co. lernen.

Und hierfür hat der Autor wirklich sehr viel an Informationen zusammengetragen. Das beginnt mit einer kleinen Aufklärungsrunde in Sachen Parallel Computing (sic!), die sogar die parallelen Programmiermodelle betrachtet. Anschließend wird es ein wenig theoretisch, indem Zhou so Dinge wie das Amdahlsche und das Gustafson-Gesetz betrachtet. Das hilft auf jeden Fall für ein grundsätzliches Verständnis, wann die Parallelprogrammierung sinnvoll ist – und wann nicht.

Nach weiteren allgemeinen Informationen rund um die Regeln des Parallel Computing, aber auch des Projektmanagement und den Modellierungsmöglichkeiten geht es dann nahtlos über in das Basiswissen rund um Threads unter .NET. Dies ist jedoch schon wieder fast veraltet, denn mit der Einführung von .NET 4.0 wird kein Mensch mehr von .NET-Threads und deren manuellem Erstellen reden.

Dies weiß aber auch der Autor, und so betrachtet er natürlich auch die kommenden Techniken und Tools wie die CLR-Threadpools, die Task Parallel Library, PLINQ,  Parallel Computing/Programming mithilfe von Visual Studio 2010 und die Concurrency and Coordination Runtime im Detail. Und den Abschluss des Buches bildet eine genauere Betrachtung möglicher zukünftiger Programmiermodelle: Axum und Software Transaction Memory.

Fazit: “Parallel Computing in .NET” ist sicherlich eine gute Quelle für alle, die mehr wissen wollen zum Thema Parallelprogrammierung mithilfe des .NET-Frameworks. Es zeigt anschaulich und sehr detailliert, wohin die Reise gehen wird und was künftige Parallelprogrammierer erwartet, vor allem mit .NET 4.0. Anhand geeigneter Codebeispiele werden wohl selbst unerfahrene Multithread-Entwickler einen Zugang zu diesem nicht ganz trivialen Thema finden. Und für alle, die mehr wissen wollen zu diesem Buch, gibt es auf der zugehörigen Webseite die passenden Infos.

Surftipp: Falls ihr euch für die Quellcodebeispiele des Buches interessiert, solltet ihr mal auf diesen Link klicken.

Am 4. November ging es mit der ersten Vorfreude los, die einen Tag später in einem Ausblick mündete, was es auf der TechEd Europe 2009 alles zum Thema Parallelprogrammierung zu sehen gibt. Diese Frage habe ich tags drauf konkretisiert und mir mal einen Teil des TechEd-Programms angesehen. Da wurde schnell klar: Das Thema Parallelprogrammierung und Multithreading erfährt endlich die Wertschätzung, die notwendig ist, um den ein oder anderen Software-Entwickler wachzurütteln und zu sagen: Leute, denkt parallel!

Am 9. November war es dann soweit: Die Microsoft TechEd Europe 2009 öffnete ihre Pforten und wir waren mittendrin. Da war es natürlich mehr recht als billig, mit ein wenig Orgakram darauf hinzuweisen, wo der Intel-Stand liegt und was es alles dort zu sehen gibt. Tom hat sich währenddessen mit seiner Videokamera auf die Suche nach ersten Eindrücken gemacht – und wurde fündig.

Am zweiten Tag habe ich diverse Techsessions besucht, aus denen zum einen Live-Twittering resultierte und zum anderen ein sehr interessantes Videointerview mit Steve Teixeira von Microsoft, in dem er mir erzählt hat, was Software-Entwickler von .NET 4 in Sachen Parallelprogrammierung erwarten können. Am selben Tag gab es übrigens die erste von drei Parallel-Studio-Sessions, die Ralph direkt neben dem Intel-Stand gehalten hat. Anschließend fand die von vielen (und ich meine: viele!) sehnlichst erwartete Netbook-Verlosung statt, die natürlich einen glücklichen Gewinner ermittelte.

Am selben Tag saß ich mit ein paar anderen Bloggern in einer Telefonkonferenz, in der Intel neueste Infos rund um das Intel Atom Developer Program (IADP) verraten hat. Und um IADP ging es auf der TechEd Europe 2009 seitens Intel schließlich auch.

Tag drei begann sehr pünktlich und sehr technisch, und das in Form einer Präsentation von Rami Radi, der sich bei Intel um das Thema Parallelprogrammierung kümmert. Ramis Techsession dauerte 75 Minuten und war vollgepackt mit interessanten Einsichten, was Software-Entwickler alles tun sollten, um ihre Anwendungen multicore-tauglich zu machen. Und das gilt natürlich für alle: für native Programmiersprachen und für managed Code.

Auf Basis seiner Session entstand übrigens die Idee, einen Video-Workshop online zu stellen, mit dem .NET-Entwickler lernen können, wie sich ihre Anwendungen mithilfe des Intel-Tools VTune Performance Analyzer beschleunigen lassen.

Am 11. November besuchte ich die sehr lebhafte Diskussion mit Tiberiu Covaci, in der es um die Zukunft der Parallelprogrammierung ging. Hinterher haben wir Tiberiu vor die Kamera gezerrt und ein wenig mit ihm geplaudert. Den Abschluss unserer TechEd-Reise stellte dann eine höchst unterhaltsame und informative Präsentation von Ralf Westphal dar, der mithilfe der Concurrency Coordination Runtime (CCR) gezeigt hat, wie sich asynchrones Programmieren höchst positiv auf das Laufzeitverhalten von .NET-Anwendungen auswirkt. Hinterher haben wir Ralf noch ein paar Fragen gestellt.

Los ging das Bloggen für Intel am 11. August 2008, und zwar anlässlich der Spieleentwickler-Konferenz GCDC’08, die voriges Jahr noch im schönen Leipzig stattfand. Aufgrund der guten Erfahrungen und des Erfolgs vor, während und nach dieser Veranstaltung habe ich gemeinsam mit Intel das Software Dev Blog ins Leben gerufen. Die Ausrichtung war von Anfang eindeutig: Was muss ich als Software-Entwickler alles dafür tun, damit meine leistungshungrigen Anwendungen optimal auf Multicore-Prozesssoren laufen?

Dafür habe ich erst einmal die wichtigsten Tools vorgestellt, die Intel hierfür in petto hat. Namentlich sind dies Parallel Studio, VTune Performance Analyzer, Thread Checker, Intel TBB, Intel Compiler, Concurrency Checker, Thread Profiler und andere Werkzeuge. Dann kam Event Nummer 2 schon des Wegs: Microsoft Tech-Ed 2008, wo wir live gebloggt und Videos gedreht haben.

Ab Mitte Februar warf Parallel Studio dann weitere Schatten an die Wand, die ich zum Anlass nahm, mir die angekündigte Multicore-Suite genauer anzusehen. Am 27. Mai kam das Tool dann übrigens zur Welt.

Selbst Grundlagen der parallelen Programmieren kamen und kommen hier nicht zu kurz. So kann man Multithread-Konzepte kennen lernen, von fünf Multicore-Programmierregeln lernen, Programmiermethoden erforschen, mögliche Fehler umgehen, OpenMP begutachten und viele andere Dinge mehr.

Das Software Dev Blog prangert auch schon mal an, so wie die Ausbildungslücken in Sachen Multicore-Programmierung, oder loben Unis, wenn sie sich dieses Themas annehmen.

Im Laufe des zurückliegenden ersten Jahres habe ich immer wieder wichtige Menschen der Entwicklerszene zu Wort kommen lassen, so wie die Vertreter von DivX, Crytek, Nik Software, Microsoft, Cakewalk, Maxon und andere.

Natürlich begab ich mich zwischendurch einige Male auf längere und kürzere Reisen, um live von passenden Veranstaltungen zu berichten. Dazu gehörte die OOP in München (aus der sich ein .NET-Vierteiler ergab), Eurographics 2009 (auch aus München), Intel Software Conference in Salzburg, prio.powerday in München, die Exasol-Roadshow, das Gamescamp zu München, TechTalks mit Intel und Microsoft, Game Developers Conference 2009 zu Köln und kürzlich das Intel Developer Forum in San Francisco, auf dem es eine Menge Infos zu Moblin gab. Dieses Thema wird mich hier übrigens in nächster Zeit noch öfter beschäftigen.

Gefeiert wird der erste Geburtstag übrigens auf dem morgigen Intel (B)logger Day, der in … genau, München stattfindet. Happy Birthday, Blog!

Sodala, die Game Developers Conference 2009 ist Geschichte und wir präsentieren nochmals die schönsten Bilder der Entwicklerkonferenz. Ob CryEngine 3 samt Interview mit Cevat Yerli, Techsessions zu CPU-Fragen, Larrabee, Parallel Studio, Intel Graphics Performance Analyzer oder Duale Zahlen – wir hatte unseren Spaß und haben eine ganze Menge gelernt.

Und die Entwickler hatten auch etwas davon – na, mal vor allem die, die eines der vier Netbooks gewonnen haben. Alle anderen hoffentlich auch. Also, wir sehen uns (wieder) im nächsten Jahr. Gleiche Stelle, gleich Welle. Tschö und macht et jut!

>> Los ging es mit den bekannten Multithreading-Konzepten OpenMP, APIs und Intel Threading Building Blocks und der Frage, welche der drei Methoden sich zum Threaden am besten eignet.

>> Dann folgten fünf Multicore-Programmierregeln, die zeigen sollen, mit welchen Anforderungen Programmierer und Software-Entwickler konfrontiert werden, wenn sie sequenziellen Code in parallele Anwendungen überführen wollen. Ich sage nur: Denke parallel!

>> Ein wichtiges, weil fundamentales Konzept der Multicore-Programmierung ist der Unterschied zwischen Daten- und Aufgabenparallelität. Diesen zu verstehen ist die erste Programmiererpflicht, wenn es darum geht, skalierbare Multithread-Anwendungen zu erstellen.

>> Wie viele Schritte muss man gehen, um aus seriellem Quellcode parallel ablaufenden zu machen? Genau vier. Rein abstrakt betrachtet zumindest. Auch hierfür habe ich den passenden Workshop parat, der die vier Stufen der Parallelprogrammierung genauer beleuchtet.

>> Was aber, wenn ich zwar weiß, wie ich parallel programmieren soll, ich aber keinen Schimmer davon habe, welche Stolperfallen dabei auf mich warten? Da heißt es dann meinen Beitrag lesen, welche Fehler bei der Parallelprogrammierung der Entwicklergemeinde drohen und wie sich diese (die Fehler, nicht die Entwickler) umgehen lassen.

>> Von OpenMP war hier zwar schon mal die Rede, aber nur ganz oberflächlich. Wie gut, dass der Kollege Preiss einen kompletten Artikel zu dem Thema verfasst hat, den ich freundlicherweise aufgreifen und in Teilen online stellen durfte. Das Ergebnis: der Workshop “Parallel Programmieren mit OpenMP”. Sehr anschaulich, sehr lehrreich, sehr beispielhaft.

>> Was ist eigentlich ein Threadmodus und welche Zustände kann dieser annehmen? Mit dieser Frage beschäftigt sich ein Workshop, den ich Ende Februar veröffentlicht habe. Nur mal so vorab: Bereit, Wartend, Beendet.

>> Von der OOP 2009 und dem Vortrag Klaus Bodes von Microsoft inspiriert, wagte ich mich Anfang März an einen Vierteiler, der den Titel “”Alles über .NET-Threads” trägt. Genauer gesagt: Unter .NET 4. Im ersten Teil geht es um das Erzeugen von Threads, der zweite beschäftigt sich mit der Thread-Verwaltung, der dritte steht ganz im Zeichen von Threadpools und der vierte handelt vom Synchronisieren mehrerer Threads und atomarer Aktionen.

Dann folgten Mitte April zwei weitere, detaillierte Workshops zum Thema OpenMP: fünf Bedingungen für parallele Schleifen und Schleifen anpassen für Multithreading-Ausführung. Beide Tutorials sind randvoll mit nützlichen Infos und praktischen Tipps. Eben ganz nach meinem Geschmack …

Los ging’s mit der Eurographics 2009, auf der ich live von der Techsession Larrabee und Raytracing gebloggt habe. Richtig komplexe Themen, aber auch sehr interessant. Nach dem Wochenende hab ich dann ein Video online gestellt, das die Vorzüge des Concurrency Checker verdeutlicht. Das ist sogar für C#-Entwickler relevant. Den Tag drauf habe ich auf eines der vielen Webinars in Sachen Parallel Studio verwiesen, die Intel bis Mitte des Jahres anbietet. In diesem Fall ging es um den Parallel Inspector, das Debugger-Tool des C++-Plugins für Visual Studio.

Am 8. April begegnete mir eine News, die mich als Apple-Anwender besonders interessierte: Apple hat es geschafft, die Multithread-Leistung seines XServe zu erhöhen, indem der Server ab sofort Nehalem-basierte Prozessoren nutzt, die pro Kern zwei Threads parallel verarbeiten können.

Nach einer systembedingten Pause ging es dann weiter mit den fünf Bedingungen, die ein Schleifenkonstrukt erfüllen muss, um per OpenMP parallelisiert zu werden. Tags drauf fuhr ich fort mit meinen OpenMP-Betrachtungen; diesmal waren die Aufgaben an der Reihe, die man als Entwickler erledigen muss, damit Schleifen überhaupt parallelisierbar sind. Und klar, dass mir gemeinsame Workshops von Microsoft und Intel in Sachen parallele Programmierung eine Meldung wert waren.

Bevor dann mein Konferenz-Marathon losging, habe ich noch auf einen Wettbewerb hingewiesen, an dem alle Spieleentwickler teilnehmen sollten, die ihre Games multicore-tauglich gemacht oder für integrierte Intel-Grafikchips optimiert oder mobile Features eingebaut haben. Und die einzuheimsenden Preise sind wirklich nicht von schlechten Eltern.

Ja, und dann begann sie, meine Euro-Konferenz-Tour: Auftakt war am 20. in Salzburg, wo die Intel Software Conference 2009 stattfand, auf der es vor allem um Parallel Studio ging. Teilaspekte davon sind der Parallel Composer, Parallel Inspector und der Parallel Amplifier. Natürlich kamen auch geladene Gäste von Nero oder Microsoft zu Wort. Und klar, dass es auch um zukünftige Dinge ging.

Tja, es folgte Teil zwei meiner Tour de Multicore-Conference, die mich von Salzburg wieder nach München führte, wo im Rahmen des prio.powerday die Multicore-Programmierung im .NET-Umfeld auf der Tagesordnung stand. Dort gab es Folgendes zu bewundern: eine Einführung in das Thema seitens Intel und dann ein paar Grundlagen von Ralf Westphal und Bernd Marquardt. Anschließend gingen Ralf und Bernd näher auf Multithreading mit .NET-Bordmitteln ein, um dann jeder für sich über die parallele Programmierung unter .NET 3.5 und die Microsoft Concurrency Coordination Runtime zu sprechen.

Und was folgt am Ende eines Monats? Nun, ein weiterer Webinar-Hinweis und ein Tipp, wie sich Intel-Entwicklertools kostenlos nutzen lassen.

Quelle: pixelio.de

Was macht man als guter Blogger am letzten Tag des Jahres?! Genau, man hält Rück- und Vorschau. Also, was war und was kommt alles auf uns zu.

Retrospektiv lässt sich erst mal eine Zahl nennen: 50. So viele Beiträge haben wir hier nämlich seit 20. Oktober verfasst, also seit dem Geburtstag des Software Dev Blogs. In diesen 5×10 Artikeln ging es vor allem um eine Thema: Wie holt man als Anwendungsentwickler das Optimum aus seiner Software heraus, damit sie auf Multicore-Plattformen wie dem Core i7 von Intel am besten läuft.

Daher haben wir uns natürlich die passenden Tools angesehen, die man für das Optimieren der Multithread-Software einsetzen kann. Dazu zählen: der Parallel Composer, für den man sich immer noch als Beta-Tester anmelden kann; der Thread Checker zum Aufspüren von Fehlern im Parallel-Code; Software-Bibliotheken zum Optimieren von bestehendem oder neuem Quellcode; Threading Building Blocks zum parallelen programmieren; C++- und Fortran-Compiler mit hohem Multicore-Potenzial und VTune Performance Analyzer zum Aufspüren von Schwachstellen im Quellcode.

Zwischendurch waren wir auf der Microsoft Tech-Ed Developers 2008 in Barcelona, um vor Ort mit Intel-Spezialisten über das Thema Multicore-Programmierung Videochats zu führen, aber auch um mit Steve Teixeira von Microsoft über die Redmonder Bemühungen hinsichtlich paralleler Programmierung zu reden.

Und sonst? Ansonsten haben wir unter anderem über die Multithreading-Konzepte OpenMP, APIs und Intel TBB geredet, fünf Multicore-Programmierregeln aufgestellt, Apple Mac OS X 10.6 ein hohes Multicore-Potenzial attestiert, zwei Programmiermethoden vorgestellt, Ausbildungslücken bei der Multicore-Programmierung bemängelt, vier Schritte zum optimimalen Multicore-Quellcode vorgestellt, beliebte Fehler bei der Parallelprogrammierung aufgezeigt und die Forderung aufgestellt, dass das Land neue resp. multicore-taugliche Programmiersprachen braucht.

Und wie sieht es mit 2009 aus? Nun, für das kommende Jahr haben wir uns eine Menge vorgenommen. Dazu zählen nutzwertige Tipps rund ums parallele Programmieren, aber auch Software-Entwickler werden wir zu Wort kommen lassen. Damit wir von ihnen lernen können, wie sich professionelle Anwendungen multicore-optimieren lassen. Und der ein oder andere Multicore-Event ist bestimmt auch wieder dabei.

Darüber hinaus wünschen wir Ihnen und uns einen guten Wechsel ins nächste Jahr. Und falls es etwas gibt, was Sie hier gerne mal lesen würden, haben Sie jetzt per Mausklick einen Wunsch frei!