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.

Das neue Konferenzformat für Parallelprogrammierer: parallel 2012

Entwicklerkonferenzen gibt es viele. Ob dass die OOP in München ist, die Game Developers Conference in Köln oder die Intel-eigene Software Conference, die heuer im schönen Dubrovnik stattfand – stets geht es um zahlreiche Aspekte der Software-Entwicklung, aber selten um ganz spezielle Themen wie beispielsweise die Parallelprogrammierung.

Dieses Manko haben jetzt der Heise Verlag und der dpunkt.Verlag erkannt und ein neues Konferenzformat ins Leben gerufen, das sich genau diesem Spezialthema der Software-Entwicklung widmen wird. Hierbei ist der Name Programm: parallel 2012 nennt sich die erste Ausgabe dieser Fachveranstaltung und bezeichnet sich selbst als Softwarekonferenz für Parallel Programming, Concurrency und Multicore-Systeme. Die parallel will sich mit folgenden Dinge auseinandersetzen:

• Es sollen typische Fallstricke bei der Entwicklung für Multicore-Architekturen aufgezeigt und Methoden zur Lösung von zu erwartenden Problemen vorgestellt werden.

•  Die Vorträge sollen auf Basis konkreter Projektbeispiele Konzepte und Techniken erläutern, die im Rahmen spezifischer Anwendungsfelder vorgestellt werden.

• Die Teilnehmer der parallel 2012 sollen wertvolle Ratschläge über den Einsatz von Produkten, Techniken und Mechanismen zum Ausschöpfen des Potenzials parallelisierter Softwarearchitekturen in ihren Unternehmen erhalten.

• Aber auch um Tools und Dienstleistungen soll es auf der Konferenz gehen. Und klar, dass genug zum Zeit zum Networken, Kontakten und Wissen austauschen zur Verfügung stehen wird.

Falls Sie oder Ihr Unternehmen als Sprecher auf der parallel 2012 aktiv werden wollen, können Sie ab sofort Ihre Vortragsvorschläge auf der zugehörigen Webseite einreichen. Der Stichtag ist hierfür der 31. Dezember 2011. An diesem letzten Tag des Jahres endet die Call-for-Paper-Frist. Gesucht werden übrigens Langvorträge mit einer Dauer von 90 Minuten und Kurzsessions, die 40 Minuten nicht überschreiten sollten. Darüber hinaus sind Ganztags-Workshops geplant.

Ach ja: die parallel 2012 findet am 23. und 24. Mai 2012 in Karlsruhe in den Räumen der Industrie- und Handelskammer statt. Wir halten Sie auf dem Laufenden.

Die Teilnahme ist kostenlos aber es sind nur 50 Plätze verfügbar!

Unter anderem erwarten Sie die folgenden Sessions:

Keynote: Visual Studio 11 and Windows – Powering the Next Wave of Innovation
Visual Studio C++ Program-Manager Boris Jabes und Visual Studio Architect Jean-Pierre Duplessis stellen die neuesten Entwicklungen und Ausblicke für C++ in Visual Studio und auf der Microsoft-Plattform vor.

Effective C++ Programming with Visual Studio 11 Ultimate
Programmer productivity in the era of agile development is no longer something we can count with lines of code. Visual Studio brings together a slew of lifecycle management tools—from architecture analysis to unit testing—that dramatically improve the productivity of C++ developers everywhere. Come learn how the next version Visual Studio will help you embrace agile methodologies like never before!

Unleash Parallel Performance with C++ in Visual Studio 11
Parallelism is everywhere. The upcoming version of Visual C++ enables native developers to remain the kings of performance across all form-factors. With new compiler technology, we will show how every developer can take advantage of multi-core CPUs. With C++ AMP, we bring the cheap & awesome power of GPUs to every C++ programmer. Finally, we bring it all together with enhancements to the debugging and profiling experiences across VS.

Graphics & Game development tools in Visual Studio 11
Visual Studio 11 brings the most significant set of improvements for developing graphics-intensive apps in over a decade. Whether you are just getting started with 2D/3D games or a self-proclaimed “Guru”, there’s something for you in this talk. We will walkthrough a slew of new tools integrated into Visual Studio that will make your life better.

Für Intel ist Bev Bachmayer am Start, Senior Software Engineer der Software and Solutions Gruppe. Nutzen Sie die Gelegenheit, mit einer erfahrenen Entwicklerin über aktuelle Trends und Herausfoderungen der C++-Programmierung zu diskutieren.

Melden Sie sich umgehend an, um das Event nicht zu versäumen.

Heute stelle ich die beiden Dienstags-Sessions in den Vordergrund.

Dienstag, 16.8.2011: Ab 9:30 Uhr spricht Levent Akyil zum Thema “Hotspot Flops & uOps”.  Levent wird verdeutlichen, wie sich seriell und parallel programmierte Anwendungen durch eine recht simple Optimierung auf Registerebene weiter beschleunigen und Fehler wie Bottlenecks in Quellcode aufspüren und beheben lassen. Dabei geht Levent detailliert auf die Möglichkeiten der aktuellen Sandy Bridge-Architektur mit AVX ein – von der sowohl Programmierer als auch Spieler erheblich profitieren.

Wenn Sie sich zuvor über die Advanced Vector Extension, eine verbesserte Vektorisierung von Gleitkomma- und Ganzpunktzahlen, informieren möchten, empfehlen wir Ihnen unseren Grundlagenartikel „Sandy Bridge: Schnellere Apps dank breiteren AVX-Registern“.  Zudem lohnt ein Streifzug durch diesen Blog, denn AVX im Zusammenhang mit der Programmierung und der verbesserten Grafikleistung von 3D-Games war sehr häufig Thema bei uns.

Levent habe ich übrigens im Mai beim Black Belt Event in München getroffen, wo er die aktuellen Programmier- und Analyse-Tools vorgestellt hat, allen voran natürlich Intel Parallel Studio XE mit dem Composer, dem Inspector und dem VTune Amplifier. Anhand der Amplifier-Werkzeuge zeigte Levent, wie sich typische Speicherprobleme im Code ausfindig machen lassen und wie Entwickler feststellen können, wo sich im Code Performance-Schwachstellen verbergen.

Hierzu empfehle ich auch meinen Report von der Intel Software Conference in Dubrovnik vom April dieses Jahres: Intel Software Developer Conference 2011 (II): Intel VTune Amplifier XE in Action.
Levent ist nicht nur ein hervorragender Redner, sondern auch sehr sympathisch. Sie sollten die Chance nutzen, seine Session zu besuchen und vielleicht auch ein paar Worte mit ihm am Intel-Stand zu wechseln.

Die offizielle Ankündigung zu seiner Session können Sie auf der GDCE-Seite abrufen.

Dienstag, 16.8.2011: Ab 17:40 Uhr kommt dann Philipp Gerasimov zu Wort. Er wird in seiner Session zeigen, wie sich der Action-RPG-Titel Darkspore mit Hilfe des Analyse-Toolsets Intel GPA für Notebooks optimieren lassen konnte. Hierzu gehört detailliertes Wissen über die Version 4.0 des Tools, aber auch die Neuerungen der Version 4.1 wie der verbesserte Platform Analyzer und das In-Game-HUD werden vorgestellt. Im Einzelnen wird Philipp auf den Frame Analyzer näher eingehen und außerdem zeigen, wie sich mit dem Platform Analyzer der eigene Spieletitel auf die Multicore-Fähigkeiten hin untersuchen lässt.

Die offizielle Ankündigung zu seiner Session können Sie auf der GDCE-Seite abrufen.

Intel GPA war und ist ebenfalls immer wieder Thema dieses Blogs, so dass Sie über diese Seiten sehr gut vorbereiten oder auch einiges nachlesen können. Empfehlenswert auf jeden Fall die Beiträge: „Das sagen bekannte Spieleentwickler über Intel Graphics Performance Analyzers“ und „Wie LEGO Univers mithilfe von Intel GPA optimiert wurde“ . Letzter Tipp für alle, die die neue Version GPA 4.1 selbst ausprobieren möchten: Auf dieser Seite finden Sie eine kostenlose Download-Option.

Intel als Sponsor und Veranstaltungs-Partner übernimmt dabei eine zentrale Rolle. Auf den Info-Stand und die Techsessions habe ich bereits gestern hingewiesen. Heute und morgen möchte die Inhalte der Vorträge kurz anreißen und Ihnen die Möglichkeit geben, sich im Vorfeld der Konferenz bereits über den technischen Background der wichtigsten Sessions zu informieren. Das wird keine Schnitzeljagd durchs Internet. Alle Facts finden Sie auf dieser Seite und bei ISN.

Montag 15.8.2011: Ab 17.40 Uhr erläutert Leigh Davies unter dem Titel „Efficient Scaling in a tasked based Game Engine“, wie sich task-basierte Spieletitel so optimieren lassen, dass sie auf einem Multicore-System die vollen Performancemöglichkeiten ausschöpfen. Dafür sind unter Umständen Änderungen im Code notwendig. Leigh wird aber verdeutlichen, dass das kein Hexenwerk ist.

Zur Person: Leigh ist derzeit bei Intel beim Intel Visual Computing Software Enabling Team und berät Programmierer, die ihre Spiele hinsichtlich Grafik und Multithreading auf den aktuellen Stand der Möglichkeiten bringen wollen. Er verfügt über eine langjährige Erfahrung als Entwickler von 3D-Spielen und kann Ihnen vermutlich jeden Rendering-Trick verraten.

Der Name kommt Ihnen bekannt vor? Auch im letzten Jahr war Leigh als Intel-Experte und Speaker auf der GDCE. Damals erklärte er, wie sich PC-Games für Netbooks optimieren lassen. Den ganzen Artikel dazu lesen Sie hier. Und mein Vorgänger Michael hatte damals die Möglichkeit genutzt, Leigh zu interviewen. Das YouTube-Video ist immer noch sehenswert, denn seine Aussagen und Prognosen haben nichts an Aktualität und Gültigkeit verloren.

Mehr Infos zur kommenden Session von Leigh erhalten Sie von ihm selbst. Auf der ISN-Seite erläutert er kurz, warum alle Entwickler task-basierter Games die Session nicht verpassen sollten und ermöglicht einen Download des im Vortrag verwendeten Code-Beispiels.

Abschließend lohnt sicherlich auch ein Blick auf die offizielle GDCE-Seite, wo Sie alle Speaker-News, die genauen Orte und Zeiten finden.

Morgen werde ich über die weiteren Sessions berichten!

Levent Akyil während der Intel Software Developer Conference 2011

Levent demonstrierte am Beispiel des Simulations- und Aufbauspiels „Total War: Empire“, wie Developer mit Hilfe des VTune Amplifier XE die beiden wesentlichen Ziele der Spieleprogrammierung sicherstellen: Performance und Skalierbarkeit.

Hierzu bietet der Amplifier sowohl statistische als auch visuelle Daten und Analysen, um Hotspots und Locks sehr schnell im Quellcode aufzuspüren und damit die wichtige Frage zu beantworten: „Wo verschwendet meine Anwendung wichtige Rechenzeit und Ressourcen?“

Amplifier identifiziert die „faulen“ Threads sehr schnell (und dank intuitiver Bedienung auch sehr komfortabel) und ermöglicht eine schnelle Navigation im Sourcecode.

Dafür misst das Tool:

• CPU-Nutzung

• gleichzeitiger Zugriff mehrerer Threads (Thread Concurrency)

• Frame-Rate

Vor allem die neue Frame-Analyse ist herauszuheben: Spiele-Entwickler können damit bestimmen, welche Frames im Einzelnen die Performance verringern. VTune Amplifier ermittelt selbstverständlich auch, welche Funktionen diesen Frame initiieren und welche davon als Blockade wirken.

Das ist angesichts des Farbcodes in der sehr übersichtlichen grafischen Darstellung selbst für Einsteiger ohne weiteres machbar: Grüne Balken bedeuten, dass die Threads bereits das volle Parallelisierungspotenzial ausgeschöpft haben, bei roten oder orangenen Markierungen sollte der Code geprüft und ausgebessert werden. Als Entwickler haben Sie die Option, in die grafische Darstellung hineinzuzoomen, um die betroffenen Frames und deren Start- und Endzeitpunkte exakt zu bestimmen.

In der Folge lassen sich die Threads optimal aufeinander ausrichten. Das beschleunigt nicht nur das Game, sondern ermöglicht auch eine höhere Detailtiefe bei der grafischen Darstellung. Levent führte aus, dass „Total War:Empire“ mit Hilfe der Thread-Optimierung pro Frame bis zu 10.000 Spielfiguren detailliert rendern kann – und das nahezu ohne Performanceverlust.

Ein wesentlicher Erfolgsfaktor waren dabei die Intel Threading Building Blocks, die mit ihren C++-Bibliotheken die Skalierbarkeit des parallelen Codes verbessern und damit Threads in Tasks verwandeln. Hierzu ein Zitat eines Spieleprogrammierers von „War Total“:

Ohne den Einsatz von Intel TBB hätten wir das Spiel niemals rechtzeitig veröffentlichen können.

Übrigens: Detaillierte Informationen zum VTune Amplifier und den Threading Building Blocks finden Sie natürlich auch in diesem Blog!

Nun aber zum Inhalt der Konferenz: Zu Beginn hat Aaaron Coday, Intel-Experte für Visual Computing, Graphics and Gaming, einen erweiterten Überblick zu den aktuellen Prozessorgenerationen gegeben und die Vorteile für Entwickler verdeutlicht. Eine kleine “Überraschung” zu Beginn: Von „Sandy Bridge“ will Intel künftig nicht mehr sprechen, sondern nur noch von der offiziellen Bezeichnung „2nd Generation Intel Core Processor Family“. Das finde ich ein „bisschen“ sperrig und bleibe dann doch lieber bei der geläufigen Bezeichnung „Sandy Bridge“.

Sandy Bridge ist zu Beginn des Jahres mit den Zielen gestartet, energieeffizienter zu arbeiten, mehr Leistung bereitzustellen (nicht nur, aber vor allem für grafisch anspruchsvolle Anwendungen) und Multimedia-Inhalte wie Videos schneller und besser zu en- und dekodieren, indem das Preprocessing und Encoding nicht mehr software-basiert, sondern von der Hardware vorgenommen wird.

Aus Developer-Sicht ist in diesem Zusammenhang auch die Bedeutung des Intel Media SDK hervorzuheben. Es gibt Codeschreibern die Möglichkeit, über nunmehr nur noch eine API auf die optimierten Libraries des Intel Compilers zuzugreifen und Videos damit schneller und vor allem einfacher zu berechnen.

Aaron verdeutlichte, dass der SSE-Nachfolger AVX mit der doppelten Registerbreite (nun 256 Bit gegenüber 128 Bit bei SSE 4.0) sowohl Spielern als auch Game-Programmierern deutlich mehr Komfort und Möglichkeiten eröffnet. So lassen sich grafisch sehr anspruchsvolle Spiele auch auf ressourcenschwachen Netbooks flüssiger abspielen, weil dank AVX die einzelnen Bilder schneller geladen und synchronisiert werden. Zu diesem Thema habe ich ja in der Vergangenheit ebenfalls sehr ausführlich berichtet.

Interessant in diesem Zusammenhang: Aaron prophezeite, dass schon im übernächsten Jahr die Zahl der Single-Core-Systeme fast auf null sinken werde, hingegen werde jeder zweite, weltweit eingesetzte PC vier oder mehr Prozessor-Kerne besitzen.

Einen Blick in die Zukunft wagte auch James Reinders in seinem Vortrag über „Software Ecosystems“. Im kommenden Jahr werde Intel eine Reihe neuer Tools veröffentlichen, die den aktuellen und kommenden technischen Standard der Prozessortechnologie berücksichtigen und damit bereits auf Knight Ferry/Knighs Corner ausgerichtet werden. Dazu gehören:

• Intel Cilk Plus für weitere Compiler

• Intel Array Building Blocks

• Intel Threading Building Blocks 4.0

Am morgigen Mittwoch werde ich ein Video-Interview mit James Reinders führen und sicherlich noch das eine oder andere Detail zu den künftigen Tools erfahren.

Update: Das Videointerview mit James steht ab sofort zum Anschauen bereit.

Für ISVs und Software-Entwickler ist dieser Termin eine gute Gelegenheit, sich vor Ort detailliert über aktuelle Entwickler-Tools zu informieren, in Trainings, Workshops und Schulungen das eigene Wissen zu erweitern und Lösungen für typische Programmierprobleme zu finden. Und da das Ganze in einer der der schönsten Regionen Deutschlands stattfindet, lässt sich der Termin prima mit einem Kurzurlaub in die bayerischen Alpen verbinden.

Die Advanced Developers Conference bietet 20 (zumeist deutsche) Vorträge hochkarätiger C++-Experten von Intel, Microsoft und weiteren Firmen. Das Motto der Veranstaltung lautet “aus der Praxis für die Praxis“ und verknüpft die traditionellen Vorteile von C++ mit den heutigen Anforderungen in Entwicklungsprojekten.

Zu den Topthemen zählen das Erstellen leistungsstarker Software mit nativem C++-Code, Performancesteigerung sowie Möglichkeiten der Fehlersuche und -behebung in C++-Programmen. Weitere Schwerpunkte bilden Design und Einsatz von MFC-Anwendungen und die Frage, wie sich durch die Ausnutzung der seriellen und parallelen Prozessoreigenschaften eine maximale Leistung erzielen lässt. Ein Highlight wird dabei sicherlich die Session “Parallelprogrammierung mit native C++ und OpenMP 3.0” von und mit Bernd Marquardt sein.

Übrigens: Am Vortag der Veranstaltung (4.5.) vermittelt Dr. Michael Klemm von Intel in dem ganztägigen Hands-on-Training  “C/C++ Code-Performanceoptimierung für Intel-Prozessoren“ tiefgreifendes Wissen mit praktischen Beispielen an bereitgestellten PCs mit Multicore-CPUs.

Hier die weiteren Infos zur Veranstaltung:

• Überblick der Workshops

• Überblick der Sessions

• Überblick der Speaker

Sichern Sie sich bis 8. April Ihre Teilnahme und sparen Sie dabei bis zu 250 Euro, indem sie sich den Frühbucherrabatt mit dem Promocode „Cpp-i0411X“ sichern. Bei gleichzeitiger Anmeldung zur Konferenz mit zwei weiteren Kollegen bekommen Sie auch noch einen 10-prozentigen Kollegenrabatt on top!

Und hier geht es zur Anmeldung. Wir sehen uns…

Das Erfolgsgeheimnis: Eine Handvoll Software-Entwickler setzen sich zusammen und organisieren eine Konferenz, die sie selbst gerne besuchen würden.

Diesen Satz habe ich auf der Webseite der Entwicklerkonferenz dotnet Cologne 2011 gefunden. Der sagt wohl eine Menge aus über das Konzept und die Absicht, eine Veranstaltung “von Entwicklern für Entwickler” zu konzipieren und umzusetzen. Und da das Ganze letztes Jahr schon ziemlich gut geklappt hat, kann man für die diesjährige Ausgabe der dotnet Cologne Ähnliches erwarten.

So wird es wohl nicht bei den 300 Teilnehmern vom letzen Jahr bleiben. Daher hat sich das Orga-Team rund um Albert Weinert, Stefan Lange und Roland Weigelt um eine neue Location umgesehen und wurde im Mediapark zu Köln fündig (es handelt sich dabei um das Komed). Und da auch einige neue Leute erwartet werden, gibt es diesmal auch 300- und 400-Level-Vorträge, die noch tiefer in diverse Themen einsteigen. Aber natürlich kommen auch fundierte Einführungen nicht zu kurz.

Toll ist auch die Idee, zwischen den einzelnen Sessions (von denen es immerhin 25 geben wird, aufgeteilt in fünf parallel laufende Tracks) etwas längere Pausen zu machen. Damit hat man auch mal die Gelegenheit, nach einem Vortrag mit den Referenten zu reden, einen der Sponsorenstände zu besuchen oder sich einfach einen Kaffee zu holen. Das reduziert den Stress und erhöht sicherlich die Zufriedenheit der Teilnehmer während der dotnet Cologne 2011.

Auf der zugehörigen Webseite gibt es auch schon erste Vorträge zu bewundern, und erfreulicherweise wird es auch etwas zu Windows Phone 7 geben (Peter Nowak erzählt etwas über Silverlight für mobile Geräte). Das hatte ich ja erst kürzlich hinsichtlich der .NET DevCon 2011 etwas bemängelt.

So, und worauf warten Sie jetzt noch, sich anzumelden? Hierbei ist vor allem Schnelligkeit oberstes Gebot, denn die ersten hundert Anmelder erhalten einen Rabatt von 30 Euro und bezahlen schlappe 25 Euro. Die nächsten 100 Konferenzwilligen werden aber auch noch belohnt und zahlen 15 Euro weniger, also 40 Euro. Alle anderen müssen leider den Standardpreis von 55 Euro zahlen. Aber auch das ist für eine Eintages-Konferenz für Software-Entwickler immer noch ein ziemlich gutes Angebot. Allerdings können Sie sich erst ab dem 14.3. um 14:00 Uhr anmelden.

Dass dieser sehr faire Eintrittspreis überhaupt möglich ist, hat auch mit den zahlreichen Sponsoren zu tun, die auch dieses Jahr die dotnet Cologne finanziell und sonstwie unterstützen. Zu ihnen gehört auch Intel, für die ich auf die dotnet Cologne fahren werde, um vor Ort über die wichtigsten Dinge zu berichten. Also schon mal vormerken: 6. Mai, Berichterstattung von der dotnet Cologne 2011 auf dem Software Dev Blog.

Zunächst einmal gilt festzuhalten, dass die Programmverantwortlichen acht Themenschwerpunkte definiert haben, vier am ersten Tag und vier am zweiten. Tag 1 umfasst die Rubriken “Sprachen”, “Architektur”,  ”SharePoint & Daten” sowie “ALM/Produktion”, an Tag 2 geht es um “Visual Studio & Add-Ins”, “Code & UI”, “Web-Ready Desktop” sowie “Soft Skills & Agile Methoden”. Zu meinen persönlichen Highlights zählen folgende Sessions:

• The absolutely minimum every developer should know about C# & Die Vielfalt der Programmiersprachen unter .NET (Rubrik Sprachen)
• Parallelprogrammierung – Eine Einführung & Die Task Parallel Library (Rubrik Architektur)
• SharePoint als Entwicklungsplattform & Alternative Datenbanken (Rubrik Sharepoint & Daten)
• Vertrauen ist gut – Source Control ist besser! & Buildserver, Continuous Integration und Continuous Deployment (ALM/Produktion)
• Mit ReSharper die Code-Qualität verbessern & Produktivitätssteigernde Visual Studio-Add-Ins (Visual Studio & Add-Ins)
• UI für Entwickler und andere Nicht-Designer & Code Design Guidelines in der Praxis (Code & UI)
• WPF, Silverlight, HTML 5 – die Qual der Wahl & HTML5: Der Browser als Plattform (Web-Ready Desktop)
• Was bringt mir Agil? & Agil 2.0 – Das Agile Development Framework (ADF) (Software Skills & Agile Methoden)

Was mir noch ein wenig fehlt, ist das Thema Windows Phone 7, da es auf eine ordentliche .NET-Veranstaltung durchaus passt (immerhin hat die dotnetpro WP7 schon einen kompletten Schwerpunkt spendiert). Außerdem kann ich keinen Slot für eine Keynote-Session entdecken. Das wäre wirklich schade, schließlich gibt solch eine Eröffnungsrede die Richtung für die gesamte Veranstaltung vor. Na, mal sehen, ob es sich die Verantwortlichen der .NET DevCon – Tilman Börner und Florian Bender – in dieser Sache noch einmal anders überlegen.

Falls Sie das Ganze auch ohne Keynote interessant finden, können Sie sich natürlich gleich mal anmelden. Wenn Sie das noch bis zum 19. April erledigen, sparen Sie 100 Euro und zahlen nur 690 Euro. Danach sind für zwei Tage .NET-Konferenz 790 Euro fällig. Hierin enthalten ist ein gemütliches Get-together am ersten Abend und ein separater Ausstellungsbereich, in dem diverse Firmen ihre Lösungen und Produkte in Sachen Software-Entwicklung präsentieren werden. Für das passende Socializing ist also auch gesorgt.

Arti Gupta hat im Rahmen des Intel Software Network-TV eine neue Folge der Reihe „Visualize this!“ eingestellt. Das Thema ist erneut AVX Cloth. Stan Melax, ein erfahrener Graphics Software Engineer, erläutert hier seine Erfahrungen bei der Code-Entwicklung, spricht über Stolpersteine und gibt Tipps zur Grafikprogrammierung in 3D-Spielen. Sehenswert!

In der kommenden Woche werde ich von der OOP 2011 berichten – teilweise auch live!

Die internationale Messe für Softwarearchitekten und Entscheider findet vom 24. – 28. Januar 2011 zum nunmehr 20. Mal im Kongress Center München statt. Hier werden zahlreiche Experten Vorträge und Tutorials zu aktuellen und praxisnahen Software-Themen halten. Multicore-Programming ist dabei eines der Schlüssel-Themen.

Und natürlich gibt es eine Ausstellung mit Messe-Ständen. Von Dienstag bis Freitag können Sie sich zu Sandy Bridge und neuen Dev-Tools auf dem Intel-Stand 7.1 informieren.

Übrigens können wir uns da auch gerne auf einen Kaffee treffen, wenn Sie über Ihre Erfahrungen als Entwickler berichten möchten, interessante Projekte zu Visual Computing oder Multicore-Programmierung vorstellen wollen oder auch einfach nur Ihre Meinung zum Software Dev Blog loswerden möchten. Mailen Sie mir doch einfach Ihre Kontaktdaten und einen Terminvorschlag: Ich setze mich dann gerne mit Ihnen in Verbindung: ibelshaeuser[at]text-vision.com, Stichwort: OOP.

Unabhängig davon sollten Sie sich schon jetzt folgende Termine auf der OOP reservieren:

• Intel-Keynote: Software entwickeln für die Many-Core-Zukunft
  Montag, 24.1.2011; 16:45 – 17:30 (Ralph de Wargny)

• Introducing parallelism into legacy code: Three case studies
  Dienstag, 25.1.2011; 14:15 – 15:00 (Stephen Blair-Chappell)

• Multi-core und Echtzeit – Böse Überraschungen vermeiden
  Dienstag, 25.1.2011; 16:30 – 17:30 (Fridtjof Siebert)

Wir sehen uns…

So, und jetzt gibt’s noch ein kleines Wochenend-Bonbon: Viel Spaß mit dem Video zu Sandy Bridge, das die Rendering- und Grafikfeatures sehr eindrucksvoll belegt. Wetten, dass Sie sich den Clip mehr als einmal anschauen werden?

An der Namensgebung der bisherigen Baureihen Core i3, Core i5 und Core i7 wird sich nichts ändern. Dafür aber an der Leistung. Einen Geschwindigkeitszuwachs garantieren die Intel Turbo Boost Technik 2.0. Und die Intel Hyper-Threading Technik wird das Multitasking weiter verbessern, da ja jeder Prozessorkern zwei Aufgaben verarbeiten kann.

Das Besondere aber ist die neue Grafikleistung: Prozessor und Grafikprozessor (GPU) sitzen auf einem Chip und sind so direkt mit dem PCI-Controller verbunden. Die Verbesserung von Rechenleistung und Darstellungsqualität sind enorm – vor allem beim Video-Encoding. Wenn Sie die Gelegenheit haben, dann schauen Sie mal einen HD-Film auf einem Sandy-Bridge-PC. Gestochen scharfe Bilder ohne Aussetzer und Wartezeiten – selbst wenn Sie die Filme vom PC auf den Fernseher streamen. Dafür verantwortlich ist eine Reihe integrierter Grafiktechnologien wie Clear Video HD, HD-Grafik und Intel InTru. Kein Wunder, dass schon jetzt die Unterhaltungsindustrie reges Interesse zeigt.

Ein paar kritische Stimmen gibt es aber auch zur GPU – diese habe maximal die Leistung einer Grafikkarte aus dem unteren Preissegment und ersetze für Spieler keine externe Grafikkarte mit einem höheren Datendurchsatz. Das stimmt nur teilweise. In einem meiner nächste Beiträge werde ich gezielt auf Mythen und Fakten zu Sandy Bridge eingehen. Denn in diesen Tagen wird auch viel Unsinn zu den Intel Core-Prozessoren der zweiten Generation verbreitet.

Und noch ein Thema von der CES, das Software-Entwickler interessieren dürfte:

Während seiner Keynote hat Microsoft-Chef Steve Ballmer angekündigt, dass die nächste Windows-Generation, also der Nachfolger von Windows 7, nicht mehr nur für x86-Prozessoren designt werde, sondern auch für System-on-a-Chip (SOC)-Plattformen. Hintergrund: Die „Ein-Chipsysteme“ integrieren möglichst alle Teile der Systemfunktionen auf einem einzigen Prozessor und werden deshalb bislang vor allem als Embedded Systems in der Steuerungselektronik oder auch in portablen Devices mit begrenztem Funktions- und Speicherumgang eingesetzt.

Hierzu zeigte Steven Sinofsky, President, Microsoft Windows and Windows Live Division, dass auch Windows künftig mit den „kleinen“ Chips zufrieden sein wird und ließ eine Vorabversion des neuen Windows auf unterschiedliche System-on-a-Chip-Prototypen von Intel, Qualcomm, Texas Instruments, Nvidia und AMD laufen – inklusive hardware-beschleunigter Grafik-Unterstützung, Web-Funktionalität, USB-Treiber-Support und Druckerunterstützung. Spannende Sache! Zumal Micorosoft den Ball gleich weiterspielt: Jetzt sind die Hardware-Hersteller gefragt, neue clevere Formfaktoren für Mobile Computing zu finden. Auch für Software-Entwickler ergeben sich dadurch natürlich neue Chancen und Anforderungen. Wir bleiben dran.

In wenigen Tagen wird Intel während der CES in Las Vegas die neue Prozessorgeneration Sandy Bridge offiziell vorstellen. Vor Ort werden dann auch gleich ein paar Hardware-Hersteller erste Notebooks mit den neuen Recheneinheiten zeigen.

Die Prozessor-Architektur von Sandy Bridge wird vor allem in puncto Multimedia-Performance alle Vorgänger der Nehalem-Bauweise in den Schatten stellen. Sandy Bridge integriert den Grafikkern (GPU) in die CPU bei einer Strukturbreite von 32 Nanometern. Dank der integrierten Encoding-Einheit lassen sich Videos wesentlich schneller konvertieren als beispielsweise mit bekannten Core-i5-Prozessoren.

Die technologischen Neuerungen von Sandy Bridge und die daraus resultierenden, erweiterten Möglichkeiten für Parallel-Computing sind Anlass genug, dieses Blog wiederzubeleben. Ich werde Sie ab sofort regelmäßig mit News, technischem Background und Veranstaltungshinweisen versorgen, die Ihnen den Programmieralltag etwa erleichtern.

Zunächst aber darf ich Ihnen zwei neue, sehr nützlich Tools empfehlen, die Intel im Rahmen der Partnerprogramme veröffentlich hat und vor allem Entwickler von Media- und Videoanwendungen adressieren.

Das Intel Media Software Development Kit in der Version 1.5 ist ein plattformübergreifendes SDK, das Ihnen hilft, auf einfache Weise leistungsstarke und schnelle Videoanwendungen zu entwickeln.  Das Tool-Paket bietet Ihnen drei Highlights:

• Codecs für Hardwarebeschleunigung: Sie greifen auf Video-Codecs zu, die für Intel Multicore-Prozessoren und Intel HD Graphics optimiert wurden und bestmögliche Performance bieten
• Einheitliches API für unterschiedliche Plattformen: Weniger Code und weniger Komplexität durch ein universelles API, das viele PC-Plattformen unterstützt, darunter selbstverständlich auch die zukunftsträchtigen Intel Graphics- und Multicore-Architekturen.
• Support und Add-Ons: Schneller optimale Ergebnisse erzielen dank nützlicher Features wie Video-Pre-Processing, Decodieren und Encodieren

Sie können das Media Software Development Kit kostenlos laden und installieren. Sinnvoll ergänzt wird das SDK durch das Intel Media Checker Software Assessment Tool. Zugegeben, eine grauenhafte Bezeichnung, aber das Tool ist überaus nützlich. Denn damit stellen Sie beispielsweise sicher, dass Sie das SDK korrekt in die Anwendungen einbinden. Zudem fungiert es als Tutorial, indem es die Funktionen und Technologien des SDK erläutert. Also für die ersten Schritte mit dem SDK sicherlich genau richtig. Und kostenlos ist es natürlich auch. Viel Erfolg damit!

Die erste Intel Techsession hielt Steve Hughes, der über Intel Graphics Performance Analyzers sprach. Diese Toolsuite hilft Entwicklern, ihre Spiele und Anwendungen zu analysieren und mögliche Flaschenhälse und andere nervige Dinge aufzuspüren und zu eliminieren. Steve sprach auch über die neuen Features vin Intel GPA 3.0, zeigte, wie sich die drei Werkzeuge (System Analyzer, Frame Analyzer, Platform View) richtig einsetzen lassen und wie man mit diesen Tools Veränderungen an einzelnen Frames unmittelbar sehen kann

Darüber hinaus haben wir gelernt, dass Intel GPA ein SDK und ein Capture-Tool umfasst, dass Intel GPA als Client-Server-Anwendung läuft, um die Testplattform so wenig wie möglich mit den notwendigen Berechnungen zu belasten und dass man mit Intel GPA einfach und schnell ganz tief in sein Spiel blicken kann.

Techsession Nummer zwei hielt Leigh Davies, der ebenfalls für Intel arbeitet. Sein Vortrag nannte sich “Building Games for Netbooks” und war randvoll mit interessanten Erkenntnissen wie diesen:

• Ad-hoc-Gaming für Netbooks ist mit dem Intel Laptop TDK ziemlich einfach.
• So aktiviert man die APIs des Intel Laptop TDK.
• So maximiert man die Rechenleistung des Intel Atom Prozessor mithilfe von Threading und SSE-Befehlen.
• Diese Vektorisieringsoptionen können für den Intel Atom-Prozessor angewendet werden.
• Mit den richtigen Compiler-Einstellungen optimiert man seine Spiele für die Intel Atom-CPU.
• Und vieles mehr

Darüber hinaus hatten wir die Gelegenheit, mit den Jungs von Havok zu reden, die sich den Demostand mit Intel teilen. Zu diesem Zweck haben wir unsere Videokamera aufgebaut und uns die Havok-Demo zeigen lassen, die aus drei Teilen besteht: die Havok Physics im Allgemeinen, zu “Zerstörungszwecken” und für das Rendern von Kleidung und Ähnlichem in Echtzeit. So, dann einfach nur auf den jeweiligen Link geklickt und das Video angeschaut. Viel Spaß dabei!

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!

• Parallel-Programmierung – wie geht’s und das bringt’s
• Parallelisierung von nativem Code
• Parallelisierung mit Managed Code
• Parallelisierung im OLTP-Alltag
• Parallelisierung von Berechnungen mit OpenMP
• Abschlussdiskussion | CUDA – Die etwas andere Art schnell zu rechnen

Also, ich freu’ mich drauf! Dann bis morgen…

Das Geld scheint wohl ziemlich gut angelegt zu sein, denn es werden wieder rund 370 Techsessions und  mehr als 150 so genannte Hand-on-Workshops angeboten, also mehr als 100 Sessions pro Tag. Da sollte schon das eine oder andere dabei sein, was für euch relevant und interessant ist. Aber natürlich ist solch eine Konferenz auch zum Netzwerken gut und zum Kennenlernen und zum Feiern am Abend.

Und falls ihr wissen wollt, mit welchen Themen wir uns hier auf dem Software Dev Blog während der letztjährigen Tech-Ed Europe beschäftigt haben: ein Mausklick genügt.

So, und was gibt es abschließend noch zu Olivers und Bernds Vorträgen zu sagen? Nun, beide waren (a) sehr unterhaltsam und (b) sehr informativ. Aber gut, das war ja auch nicht anders zu erwarten.

Oliver Sturm ist bestimmt vielen von euch ein Begriff: er ist unter anderem C#-MVP, betreibt ein eigenes Blog und twittert sogar ab und an. Seine Session trug den Titel “Parallelisierung mit funktionalen Ansätzen in C#”. Dabei ging es – grob gesagt – um den Multicore-Shift (“Wie übersetzt man das eigentlich?!”), um das Parallelisieren von Quellcode mithilfe der Parallel Extensions in .NET und um entsprechende funktionale Ansätze, demonstriert anhand zweier Beispiele (das Filtern von Namenslisten und die parallelisierte Erzeugung von Mandelbrotbäumen). Interessant fand ich übrigens Olivers Versuch, die Begriffe “Multithreading”, “Concurrency” und “Parallelism” voneinander abzugrenzen, da diese im englischen Sprachraum äußerst oft synonym verwendet werden. Tja, und den Rest seiner Präse schaut ihr euch am besten selbst an.

Bernd Marquardt beschäftigte sich dann mit einem ganz ähnlichen Thema, wenngleich aus einer anderen Richtung kommend: “Parallelprogrammierung mit der TPL”. TPL steht für Task Parallel Library, mit deren Hilfe das Parallelisieren von Managed Code vereinfacht werden soll. Natürlich zeigte auch Bernd zunächst einmal, dass die Prozessoren nicht mehr schneller werden, sondern “nur” noch mehr. Und dass Software-Entwickler aus diesem Grund eine ganze Menge Hirnschmalz auf die Optimierung ihrer Anwendungen verwenden müssen, damit diese auch optimal skalieren (die Anwendungen, nicht die Entwickler!).

Bernd stellte einstiegsweise die verschiedenen Parallelisierungsmodelle vor, über die Mario ja schon gut zwei Stunden vorher geredet hatte. Das erste praktische Beispiel war die parallele Erweiterung von LINQ, also PLINQ, die Microsoft seinem .NET-4-Framework spendiert hat. Damit lassen sich parallel ausführbare Datenbankabfragen generieren, die automatisch auf die vorhandenen Prozessorkerne und Threads verteilt werden. Aber auch das Parallelisieren von Schleifenkonstrukten mit neuen Funktionen wie Parallel.For() und Parallel.ForEach() waren Bernd ausführliche Erläuterungen wert.

Und so ging es dann lustig weiter: Codeblöcke parallelisieren mit Parallel.Invoke(), Task-Klassen einsetzen (vergleichbar mit der Threadpool-Klasse), Concurent Exceptions verwenden, Synchronisierungsprobleme erkennen und einiges mehr. Und wer das alles genauer wissen will, sollte sich einfach die Folien von Bernds Session auf seinen Rechner laden.

Dr. Mario Deilmann (so sein vollständiger Name) ist bei Intel für Compiler und ähnlich geartete Software-Tools zuständig. Mit seiner Lunch-Session ging er der Frage nach, welches Programmier- bzw. Thread-Modell für skalierende Anwendungen das beste sei. Skalierend bedeutet in diesem Zusammenhang, dass parallelisierter Quellcode nicht nur optimal auf zwei Prozessorkerne verteilt wird, sondern auch auf vier, sechs, acht oder 256 Kernen läuft – und zwar ohne Leistungseinbußen.

Hierfür ist laut Mario zunächst einmal ein passendes Profiling-Tool wie der Intel VTune Performance Analyzer erforderlich, mit dem man diejenigen Funktionen, Module und andere Stellen des Quellcodes aufspürt, die für die meiste Rechenleistung und -zeit verantwortlich sind. Denn das sind oft die Stellen, an denen man als Software-Entwickler ansetzen sollte. In vielen Fällen sind das zum Beispiel Schleifenkonstrukte, die sich bestens zum Parallelisieren eignen.

Eine der passenden Programmiermodelle wusste Mario natürlich gleich darzustellen: OpenMP. Allerdings weist diese pragma-basierte Parallelisierung von seriellen Anwendungen auch diverse Nachteile auf: Man denkt als Programmierer in Threads anstatt in Tasks (was laut Mario eigentlich ein absolutes No-Go sein sollte), es lassen sich keine eingebetteten Parallelkonstrukte realisieren und mit lokalen Daten geht OpenMP ebenfalls nur suboptimal um. Aber für die schnellen ersten Ergebnisse für parallel ausführbare Programme ist OpenMP laut Mario eine gute Wahl.

Außerdem unterstützt OpenMP keine objektorientierten Programmiersprachen wie C++, was natürlich in vielen Fällen ein klares KO-Kriterium ist. Aber wozu gibt es beispielsweise die Intel Threading Building Blocks. Mit dieser Thread-sicheren, hochoptimierten Sammlung von fertigen C++-Konstrukten lassen sich sequentiell programmierte Anwendungen recht schnell und ohne größere Kenntnisse der Parallelprogrammierung in parallel ablaufende Programme umwandeln. Praktisch an Intel TBB ist deren Vielseitigkeit: OS-seitig werden Linux, Mac OS und Windows unterstützt, und es gibt sogar eine nicht-kommerzielle Variante, die den LGPL-Lizenzrichtlinien unterliegt.

Neben OpenMP und Intel TBB existieren noch weitere Ansätze, wie sich Software parallelisieren lässt. Dazu gehört das noch recht junge Projekt Cilk++ von Intel, das einen ähnlichen Weg einschlägt wie Intel TBB, allerdings einen Parallel Debugger sein Eigen nennt, ein SDK bietet und auf hunderten von Prozessorkernen skalieren soll. Und vergessen sollte man natürlich auch nicht Parallel Studio, das unter anderem die Tools Parallel Inspector und Parallel Amplifier aufweist, mit deren Hilfe man Fehler im Quellcode aufspüren kann (Inspector) und sich die Anwendung weiter optimieren lässt (Amplifier). Das geht sogar so weit, dass Laufzeitfehler wie Race Conditions und Dead Locks aufgespürt werden können – bevor dies der Anwender später tut.

So, und die Sessions von Oliver Sturm und Bernd Marquardt sind dann morgen dran. Versprochen!

Da es auf diesem Blog ja um das Thema Multicore-Programmierung geht, widmet sich dieser Blogbeitrag der dotnet Cologne 2010. Zunächst einmal möchte ich den Organisatoren rund um Albert Weinert, Roland Weigelt und all den anderen ein großes Kompliment aussprechen: Ihr habt da wirklich ein tolles Event mit tollen Themen, Sessions und Sprechern organisiert. Ok, dass der Kaffee nicht immer warm war und die Technik gleich mal am Anfang nicht so recht wollte, übersehe ich gerne. Wichtig ist doch, dass die Inhalte stimmen und gut rübergebracht werden. Und das war auf jeden Fall so. Also zumindest kann ich das von den Vorträgen behaupten, die ich besucht habe.

Meine persönliche Sessionplanung umfasste vier Vortragende: Rami Radi und Mario Deilmann von Intel, den sehr unterhaltsamen Oliver Sturm und zu guter Letzt den werten Bernd Marquardt, der auf solch einer Veranstaltung natürlich nicht fehlen darf (und den ich im Juni auf den dotnetpro powerdays wieder erleben werde).

Ramis Session war wie immer sehr technisch orientiert und fand wegen der vielen Codebeispiele das Interesse der Zuhörenden, die sich im Raum “Bremen” eingefunden hatten. Und die wurden auch nicht enttäuscht: Rami legte sehr unterhaltsam dar, wie das Dreigestirn Windows 7, .NET 4 und Multicore-Architekturen voneinander profitieren. Dabei ging es unter anderem um ein wenig Grundlagenwissen in Sachen Nehahlem, also Turbo Boost, Quickpath-Architektur und andere Dinge.

Aber auch über die Verbesserungen von .NET 4 aus Multicore-Sicht wusste Rami anschaulich zu berichten: So stellte er Features wie Thread Scheduling, Thread Pooling, Garbabe Collection, TPL sowie PLINQ vor. Dabei gewährte er interessante Einblicke und verriet wichtige Details wie die parallele Aktualisierung von Gen-0- und Gen-2-Daten, die bei der Garbage Collection anfallen. Zudem ging er näher auf das Work-Stealing des in .NET 4 komplett überarbeitenden Thread Managers ein, bei der sich unterbeschäftigte Thread-Queues einfach Threads anderer Queues “klauen” können und so die Effizienz des Threadpool-Managers steigern.

Sehr erstaunlich fand ich auch die Tatsache, dass unter .NET 4 nun nicht mehr 25 Threads pro CPU verwaltet werden können, sondern derer 250! Hierfür ist allerdings ein sehr guter Scheduler notwendig, was Microsoft mit dem neuen .NET-Framework wohl gelungen ist.

Nach so viel Theorie wurde es dann sehr praktisch: Rami zeigte all die Verbesserungen unter .NET 4 im Hinblick auf seine Multicore-Fähigkeiten anhand eines Maze-Solvers, bei dem es um den den schnellsten Weg innerhalb eines Labyrinths von A nach B geht. Hierzu bediente er sich eines kleinen .NET-Programms, das er einmal unter .NET 3.5 und .NET 4 laufen ließ. Alleine schon der Umstieg von der älteren auf das brandneue Framework brachte beim Zeichnen des Labyrinths und dem anschließenden Finden des optimalen Wegs Zeitverbesserungen. Ganz zu Schweigen vom Unterschied zwischen dem seriell programmierten Programm und der Multicore-Variante mit mehreren Threads.

Abschließend startete Rami noch ein wenig den VTune Performance Analyzer, um der anwesenden Zuhörerschaft zu demonstrieren, wie sich mit dem Intel-Tool in .NET-Anwendungen solch hässliche Dinge wie Bottlenecks und False-Sharing-Probleme aufspüren lassen. Und wenn die Zeit nicht auf einmal vorbei gewesen wäre, hätte Rami wohl weitere zwei Stunden damit zugebracht, VTune in all seinen Facetten und mit all seinen Möglichkeiten vorzuführen.

Und was Mario, Oliver und Bernd in petto hatten, erfahrt ihr im zweiten Teil meiner dotnet-Cologne-2010-Berichterstattung.

In Köln bin ich, weil Intel dort einen Teil des Sponsorings übernommen hat und ich live aus dem Holiday Inn berichten werde, in dem die dotnet Cologne 2010 stattfindet. Das Programm habe ich ja schon in großen Teilen vorgestellt. Allerdings haben sich seitdem zwei Änderungen ergeben, die vor allem Intel betreffen. Und die will ich euch natürlich nicht vorenthalten.

Zum einen wird Mario Deilmann nicht über Intel Parallel Studio mit .NET und Visual Studio sprechen, sondern im Rahmen einer Lunch-Session die bekanntesten Windows-Modelle der Parallelprogrammierung vorstellen. Dabei geht es sicherlich um Multithreading-Konzepte wie OpenMP, APIs und Intel TBB. Und sicherlich wird auch Parallel Studio seinen Platz finden, alleine schon wegen der Unterstützung seitens Visual Studio 2010.

Zum anderen wird Kollege Rami Radi von Intel eine Stunde lang über Windows 7, .NET 4 und die Multicore-Programmierung sprechen. Wer sich hier schon länger tummelt, wird sich möglichweise daran erinnern, dass Rami diesen Vortrag schon mal gehalten hat. Womit er allerdings nicht minder aktuell wäre, denn das Thema Parallelprogrammierung hat mit Visual Studio 2010 und .NET 4 ja schließlich gerade erst begonnen.

Für alle, die der dotnet Cologne 2010 leider nicht beiwohnen können, folgt hier die gute Nachricht: Ich werde für euch von dort einen ganzen Tag lang über die wichtigsten und interessantesten Sessions in Sachen Parallelprogrammierung berichten. Macht euch schon mal einen dicken, roten Kringel um den 28. Mai 2010!

Wie ich überhaupt darauf komme? Nun, ein Microsoft-Mann hat mich in die Tech-Ed-Facebook-Gruppe eingeladen, und da konnte ich natürlich nicht widerstehen, mich derselben anzuschließen. Man erfährt noch nicht wirklich viel, aber zumindest ist dort nachzulesen, dass alle Frühanmelder stolze 500 Euro sparen können, wenn sie sich bis zum 5. Juli anmelden (dann kostet das Ticket 1.395 Euro).

Zwar ist die Tech-Ed-Seite noch nicht umgestellt (es geht noch um 2009!), und damit auch die Anmeldung noch nicht möglich, aber beide Missstände sollen wohl demnächst behoben sein.

Falls ihr den Termin im Kalender schon mal eintragen wollt: die Tech-Ed Europe 2010 findet vom 8. bis 12. November statt, und zwar wieder in Berlin auf dem altehrwürdigen IFA-Messegelände, was letztes Jahr ganz gut geklappt hat. So, und der Vollständigkeit halber will ich den Twitter-Alias nicht verschweigen, mit dem ihr der Tech-Ed Europe 2010 folgen könnt: teched_europe. Und falls ihr euch das bis November merken könnt: Der Hashtag steht auch schon fest und lautet #tee10.

Ach ja: Ich war letztes Jahr live in Berlin dabei und habe mit Tom zusammen ein paar schöne Blogbeiträge samt Videos erstellt und veröffentlicht. Dabei haben wir unter anderem darüber berichtet, wie…

… .NET-Entwickler mithilfe von VTune Performance Analyzer Bottlenecks aufspüren können

… die CCR .NET-Entwicklern bei der Parallelprogrammierung hilft

… .NET-Entwickler vom Multithreading profitieren

… Visual Studio und .NET 4 Parallelprogrammierer unterstützen

Einer der Hauptsponsoren auf dieser 2-in-1-Veranstaltung ist Wind River, ein Multicore-Spezialist und seit Mitte vergangenen Jahres zu Intel gehörend. Der Zusammenschluss von Intel und Wind River hat ja einen recht trivialen Hintergrund: Mit dem Embedded-Spezialisten Wind River sichert sich Intel einen riesigen Fundus an Multicore-, Linux- und Mobile-Gadgets-Wissen, das jetzt schon in diverse Tools und Lösungen einfließt, aber auch in künftige wie Smartphones und andere Gerätschaften, die Intel noch möglichst in diesem Jahr auf den Markt bringen will.

Aber zurück zum Multicore-Event: Dort gibt es ab heute bis Donnerstag Infos satt rund um die Themen Parallelprogrammierung, Multithreading und Co. Jeder Tag bietet drei Slots, die unterteilt sind in die Bereiche “Applying Multicore to Networking and Telecom”, “Resolving Multicore Debug Challenges”, “Parallelization and Application Partitioning”. Also geht es letztlich um das Verteilen, Testen und Implementieren von Multicore-Techniken.

Natürlich findet man auf der Multicore Expo 2010 alles, was man von solch einer Veranstaltung erwarten kann: ausführliche Workshops und TechTalks, Keynote Sessions, Sponsored Sessions und Paneldiskussionen. Dabei geht es um Themen wie “Simplifying Multicore”, “Software Development: the Key to Multicore Success” und “Community Creation for Embedded Multicore Processors & Applications”. Es stehen aber auch Dinge wie die mögliche Parallelprogrammierung für Atom-Prozessoren, Multicore und Cloud Computing und virtualisierte Multicore-Plafttformen auf der Agenda.

Und für alle, die nicht in San Jose dabei sein können, gibt es auf der Event-Seite im Anschluss an die Veranstaltung wieder sämtliche Präsentationen zum Download. Das hat voriges Jahr allerdings 150 Dollar gekostet, wenn man selbst nicht dabei war.

James Reinders in seiner Funktion als Chef-Entwickler bei Intel erzählte in seinen Vorträgen eine Menge über Parallel Studio und über geplante Projekte, die im Laufe der nächsten Monate realisiert werden. Aber auch Peter Norfolk von Bloor Research hatte das ein oder andere zu dem Thema zu sagen (mein Lieblingsspruch: “A fool with a tool is still a fool!”). Norfolk verwies in seiner Präsentation unter anderem auf den (bekannten) Effekt, dass bei der Anschaffung neuer (Multicore-)Systeme die vorhandene Software meist nicht skaliert und im Vergleich zur vorherigen Installation sogar schlechter laufen könnte. Und das macht natürlich niemandem Spaß.

Vor allem nicht im Business-Umfeld, auf das sich Norfolk bezog. Aber selbst wenn die Software an die neuen Multicore-Maschinen angepasst wurde (Stichwort: Multithreading), ergeben sich laut Norfolk möglicherweise auch Verstimmungen, wenn das Optimieren der Anwendungen nicht richtig geschehen ist (was beim Multithreaden durchaus vorkommt). Genauso wichtig wie das Parallelisieren von Business-Software ist laut Peter Norfolk aber auch das Parallelisieren der Geschäftsprozesse, damit sich diese auch auf die entsprechenden Algorithmen abbilden lassen. Das ist speziell im Business-Umfeld von entscheidender Bedeutung.

Eine weitere wichtige Erkenntnis der Intel Software-Konferenz 2010 lautet: Intel treibt die Software-Gemeinde weiter an und hilft ihr, Probleme besser und besser zu lösen. Das schafft der Prozessorhersteller einerseits mithilfe ständig verbesserter und neuer Tools, die beispielsweise bei der Parallelprogrammierung notwendig und hilfreich sind. Aber auch Projekte wie Intel Concurrent Collections oder Intel Cluster OpenMP zeigen stets neue Wege auf, wie Software-Entwickler ihre Produkte noch effizienter und eleganter in den Markt bringen können.

Eine weitere gute Nachricht: Intel bietet für die verschiedenen Stufen der Software-Entwicklung die passenden Tools, die sich Programmierer zu eigen machen können. Denn das eine, perfekte Werkzeug für sämtliche Aufgaben gibt es laut James Reinders nicht. Schade eigentlich …

Ach ja: Für die mobilen Entwickler hatte Uli Dumschat von Intel ebenfalls eine Menge nützlicher Infos und Tipps dabei. Aber das ist eine ganze andere Geschichte, die ich hier hoffentlich sehr bald veröffentlichen werde.

Wie sich das auf solchen Veranstaltungen gehört, gebührt das erste Wort dem Gastgeber, und das ist nun mal Ober-Parallel-Guru James Reinders, der gleich allen Anwesenden die Schuld für die Notwendigkeit der Parallelprogrammierung gab: “We are all guilty! We love data!” Und diese Sammelwut führt laut Reinders zwangsläufig dazu, dass sich die zu verarbeitende Datenmenge in den den nächsten Jahren exponentiell vervielfachen wird (Experten denken heute schon in Exabyte, also einer Trillion Byte). Und dieser Datenwust macht es unumgänglich, dass Daten möglichst parallel verarbeitet werden sollten. Hierfür benötigt man aber nicht nur schnelle Rechner und leistungsfähige Infrastrukturen, sondern auch hochoptimierte Anwendungen.

>> Den Rest des Originalbeitrags lesen …

Im zweiten Teil seines einleitenden Vortrags wurde James ein gutes Stück konkreter: Es ging im einzelnen um Parallel Studio, Cilk, Ct und daten-optimierte Intel-Compiler. Zu Parallel Studio hat er wohl nur so viel verraten, dass die nächste Version der Parallelisierungssuite für das gestern vorgestellte Visual Studio 2010 optimiert sein wird.

Mit der Übernahme von Cilk im Sommer 2009 hat sich Intel großes Know-how in Sachen task-basiertes Multithreading ins Haus geholt. Gerade sind Cilk- und Intel-Ingenieure dabei, ihre Produkte mehr und mehr zu verschmelzen, sodass in Zukunft noch eine ganze Menge aus dieser gemeinsamen Schmiede zu erwarten ist.

Aber auch mit der Ct-Technik geht es weiter voran, wie Reinders in seinem Vortrag darstellte. Ct basiert auf einem daten-konzentrischen Ansatz und soll die Methoden der Parallelprogrammierung in diesem Bereich maßgeblich verändern. Dazu gehören neue Techniken wie SWAR-Vektorisierung (SIMD within a register), die Unterstützung künftiger Hybridprozessoren und vieles mehr.

>> Den Rest des Originalbeitrags lesen …

Lag der Schwerpunkt 2009 auf der Parallelprogrammierung (es stand ja das Intel Parallel Studio kurz vor der Veröffentlichung), beschäftigt sich die iSTEP in diesem Jahr mit einer ganzen Reihe interessanter Themen. Dazu gehört natürlich eine genauere Betrachtung von Visual Studio 2010 (was ja bald auf den Markt kommt). Diesen Part wird unser guter Bekannter Steve Teixeira übernehmen, der zu den Vätern von VS 2010 gehört.

Aber auch über die generellen Probleme der Parallelprogrammierung wird zu reden sein. So verschafft David Norfolk von Bloor Research allen Anwesenden einen guten Überblick zum Thema “Mainstream Market” und wird hoffentlich die Frage beantworten, wohin die Reise geht und was Software-Entwickler in Sachen Multicore-Programmierung künftig beachten sollten.

Wenn Alexandre Jenny die Bühne betritt, wird es pragmatisch. Monsieur Jenny ist Gründer und CEO von Kolor, einem französischen Software-Unternehmen, das sich auf die Erstellung von Panoramabildern spezialisiert hat (und das seit 2004). Schon seit dieser Zeit sind Alexandre und sein Team äußert penibel darauf bedacht, mithilfe fest definierter Richtlinien das Multithreaden ihrer Software-Produkte bereits vom ersten Tag an permanent zu verbessern. Und das wohl mit großem Erfolg: Mithilfe ihrer Software gelang es Kolor, Paris in Form eines 26-Gigapixel-Bildes rundum abzubilden. Was hierfür alles notwendig ist und war, wird Alexendre eigens auf der iSTEP erzählen.

Nach dieser eher konsumer-lastigen Einlage wird es dann richtig ernst: Hugo R. Falter von der ParTec Cluster Competence Center GmbH wird darüber berichten, wie Intel, das Jülicher Supercomputing Center und seine Firma gemeinsam einen Supercomputer mit allem Schnipp und Schnapp konzipiert, gebaut und zum Laufen gebracht haben. Das ist sicherlich nichts für Weicheier! Und mit Christian Terboven von der Uni Aachen geht es dann ganz ähnlich weiter: In seinem Vortrag geht es um das Thema High-Performance Computing und darum, welche Tools notwendig sind, um ein Höchstmaß an Parallelität zu erreichen. Bestimmt auch sehr interessant, aber ohne Vorwissen steigt man wohl in Minute 3 aus.

Der dritte Abschnitt der Intel-Konference beschäftigt sich dann mit ganz anderen, aber nicht minder interessanten Dingen: Wohin geht es mit dem mobilen Markt? Uli Dumschat von Intel wird in seinem Vortrag intensiv auf die Frage eingehen, wie sich mit der Entwicklung neuer Software-Anwendungen für Netbook, Smartphone und Co. Geld verdienen lässt und was Intel damit zu tun hat. Ich verrate sicherlich nicht zu viel, wenn ich mutmaße, das Uli eine Menge über IADP, AppUp und MeeGo erzählen wird.

Als abschließender Redner wird dann Philip Ling in eine ähnliche Richtung gehen, wenngleich viel technischer. Sein Fokus liegt auf Embedded Systemen und wo er Chancen und Potenziale in diesem Markt sieht. Es geht also im In-Car-Entertainment und ähnliche Dinge – Philip wird letztendlich also auch über Intel Atom, MeeGo und Co reden.

Ach ja: Die Intel iSTEP 2010 Software Conference findet dieses Jahr am 13. April im wunderschönen Barcelona statt. Ich selbst werde zwar nicht vor Ort sein (mich zieht es auf die Internet World im genauso schönen München), aber die britischen KollegInnen des SoftTalk-Blog werden auf der Konferenz zugegen sein und in Bild, Wort und Ton berichten. Da werde ich es mir natürlich nicht nehmen lassen, die interessantesten Erkenntnisse hier zu bloggen. So, stay tuned …

• Funktionale Programmierung in C# 3.0 (Oliver Sturm)
• Anpassbare Anwendungen mit Windows Workflow 4 (Dariusz Paris von Microsoft)
• Intel Parallel Studio mit .NET und Visual Studio (Mario Deilmann von Intel)
• Debugging in Deep mit VS2010 und WinDbg (Gregor Biswanger)
• Parallelprogrammierung mit der TPL (Bernd Marquardt)
• und viele andere

Das ist nur das vorläufige Programm. Der ganze Tag besteht aus vier parallelen Teilen, in denen insgesamt 24 Vorträge plus Auftaktrede und fünf Lunch-Sessions stattfinden sollen. Da könnt ihr euch auf einiges gefasst machen.

Und damit der Tag nicht nur aus Arbeit besteht, beginnt um etwa halb sieben der unterhaltsame Teil der Dotnet Cologne mit Verlosung und anschließender Grillparty (hoffentlich passt das Wetter). Müst ihr da nicht dabei sein? Doch, ich finde schon. Ihr solltet euch allerdings beeilen, denn so richtig viele Plätze gibt es nicht mehr (es ist von etwa 50 die Rede). Also, wir sehen uns, oder?!

Leider fehlt sein Alter Ego, Ralf Westphal, dafür wird ihm aber ein erfahrener Software-Spezialist zur Seite gestellt, nämlich Volker Jungbluth, der seit 1988 der IT-Branche angehört und sogar sein eigenes ERP-System besitzt. Beide Referenten werden in insgesamt vier Sessions ihr geballtes Wissen preisgeben und über folgende Themen sprechen:

• Parallelisierung von nativem Code
• Parallelisierung mit Managed Code
• Parallelisierung im OLTP-Alltag
• Parallelisierung von Berechnungen mit OpenMP

Die Vorträge sind jeweils 75 Minuten lang und gehen fundiert auf die einzelnen Themen ein (eine Themenübersicht gibt es in diesem Programmflyer). Worauf wartet ihr also noch? Da heißt es sich schnell anmelden, denn der frühe Vogel spart bis zum 11. Mai 100 Euro, zahlt also bis dahin nur 399 Euro, nach diesem Stichtag sind es 499 Euro.

Ach ja: Die Keynote-Session wird wohl von Intel gehalten. Da gibt es bestimmt auch wieder eine ganze Menge zu hören …

Nun ist es aber so, dass ich von 21. bis 27. September in San Francisco weilen werde, um mich ebenfalls an drei Tagen auf dem Intel Developer Forum über die neuesten Entwicklungen aus dem Hause Intel in Sachen Programmierung und mehr zu informieren. Und da ich leider nicht an zwei Orten gleichzeitig sein kann, habe ich mir schon mal den Workshop-Plan ein wenig genauer angesehen. Darüber hinaus habe ich weitere Infos bei der Veranstalterin der Basta angefragt. Hoffentlich bekomme ich etwas zugeschickt. Damit ich es mit euch teilen kann.

Bis dahin lohnt sich auf jeden Fall ein kurzer Blick in die geplanten Inhalte des Power-Workshops von Jeffrey:

Der Titel des Ganzen lautet “Mastering .NET and Preparing for the Multi-Core Revolution”, findet von Montag bis Mittwoch von jeweils 9 bis 18 Uhr im Hotel Contel Mainz statt und kostet regulär 1.550 Euro. Falls sich drei Kollegen aus demselben Unternehmen anmelden, kommt der Workshop 100 Euro günstiger. Und für alle, die sich noch heute anmelden, gibt’s ein Netbook mit sämtlichen Ausgaben des dot.NET Magazins obendrauf.

Für das Geld bekommt man eine ganze Menge: Freien Eintritt zu Basta,  Rundum-Verpflegung und ein Zertifikat der Entwickler-Akademie – und obendrein macht ihr euch fit für das Multicore-Zeitalter. Dabei geht es um folgende Inhalte:

• So gehe ich richtig mit Programmierfehlern mithilfe der Ausnahmebehandlung (exception handling) um.

• So implementiert der C#-Compiler anonyme Methoden und Lambda-Funktionen.

• So ermöglicht und unterstützt C# die funktionale Programmierung.

• Sinn und Bedeutung von Threads und wie sich diese positiv auf die Leistungsfähigkeit einer Anwendung auswirken.

• So vereinfacht der CLR-Threadpool die Programmierung von C#-Anwendungen und beschleunigt diese.

• So führt Windows synchrone und asynchrone I/O-Operationen aus – wie .NET-Entwickler dies zu ihren Gunsten ausnutzen können.

• So teste ich ein parallel programmiertes C#-Programm mithilfe von .NET-Bordmitteln.

Diese und viele weitere Aspekte der Parallelprogrammierung werden also im Detail besprochen. Und, ist das nix?!

Mittwoch ging es dann wieder nach München, damit ich am Donnerstag auch ja pünktlich auf der .NET-Multicore-Konferenz sein konnte, um von dort aus live zu bloggen. Was auch gut geklappt und zudem viel Spaß gemacht hat. Und es war nicht nur informativ, sondern auch sehr unterhaltsam, Ralf Westphal und Bernd Marquardt gemeinsam auf der Bühne zu erleben. Denn neben der geballten fachlichen Kompetenz konnten die zwei auch mit Entertainment-Qualitäten überzeugen. Stellenweise habe ich mich an meine Jugend erinnert gefühlt, in der Statler und Waldorf auf dem Muppet-Show-Balkon Ähnliches abgeliefert haben.

Neben all der Unterhaltung stand natürlich das Fachliche im Vordergrund, und das war sehr fundiert. Es ging um wirklich spannende Dinge:

• Zunächst durfte Rami Radi von Intel die Konferenz mit seiner Keynote eröffnen. Sein Vortrag war (a) sehr folienlastig und (b) sehr informativ, wenngleich er dem ein oder anderen Zuhörer eine ganze Menge abverlangt hat. Mit Basics oder ähnlichem Ballast hat sich Rami erst gar nicht aufgehalten, sondern ging gleich in Medias Res. Wie gesagt: tough stuff!

• Was dann kam, hätte ganz gut vor Ramis Grundsatzrede gepasst: Eine Einführung in das Thema Multicore-/Multithread-Programmierung. Dort gingen Ralf und Bernd richtig interaktiv auf wichtige Fragen rund um die parallele Programmierung ein. Dazu gehören Latenzprobleme, der gemeinsame Zugriff auf Speicherressourcen, das Gesetz von Amdahl und der Umgang mit Threads.

• Teil drei der Multicore-Konferenz brachte dann Statler und Waldorf, äh, Ralf und Bernd erneut gemeinsam auf die Bühne, damit sie über Multithreading mit .NET-Bordmitteln reden konnten (genauer: mit Bordmitteln des .NET-Frameworks). Dabei ging es um wichtige Aspekte wie die Steuerung von Threads, den .NET-Threadpool, asynchrone Methoden und atomare Anweisungen.

• Nach der Mittagspause mussten dann Ralf und Bernd ohne ihre Alter Egos erneut “vors Mikro”, um über die parallele Programmierung unter .NET 3.5 einerseits und die Microsoft Concurrency Coordination Runtime anderseits zu referieren. Bernd erzählte unter anderem von der Schleifenparallelisierung, parallelen Aggregationen, von Task- und Future-Klassen und hatte sogar ein paar Tipps und Tricks dabei. Ralf seinerseits ging verstärkt auf das Thema Synchronisierung und das Warteschlangenprinzip der CCR ein.

Die CCR ermöglicht ein neues Programmiermodell für parallel laufende Anwendungen. Ein sehr schöner Ausspruch von Ralf lautet übrigens: “Vergesst Threads!”, da Threads synchronisiert werden müssen, was Ralf nicht wirklich mag. Um das besser verdeutlichen zu können, schreibt er in Echtzeit verschiedene kleinere Programme. Sehr schlau!

Das Besondere an der CCR ist das Warteschlangenprinzip: Jeder Befehl oder jedes Datum wird im Hintergrund aus der Warteschlange ausgelesen und verarbeitet, sobald eine Ressource frei ist. Damit müssen keine expliziten Threads erzeugt und wieder beendet werden, da sich die CCR automatisch darum kümmert. Hierfür steht die DispatcherQueue-Klasse zur Verfügung.

Die CCR erlaubt sowohl den Einsatz des Standard-Threadpools als auch eigene Threadpools auf Dispatcher-Basis.

Folgende Elemente kommen zum Einsatz:

• Parallele Erweiterungen für LINQ = PLINQ

• Schleifen parallelisieren: Die hierzu gehörige Klasse heißt System.Threading.Parallel. Schleifen werden auf mehrere Threads aufgeteilt werden, aber nur, wenn die einzelnen Schleifendurchläufe unabhängig voneinander sind. Dabei müssem die Indezies alle gleich sein. Am Ende der Schleife werden alle Threads synchronisiert. Fazit: Schleifenparallelisierung lohnt sich nur bei komplexen und großen Schleifen! Wichtig ist auch die richtige Verteilung einer Schleife auf die vorhandenen Prozessorressourcen. Dies gelingt, indem die einzelnen Schleifendurchläufe in kleinen Portionen verarbeitet werden.

• Aggregationen: Hierbei geht es um das Zusammenfassen von Ergebnissen. Dabei ist Locking meist erforderlich. Zwischenwerte werden über sogenannte ThreadLocateState weitergegeben. Der Ablauf sieht folgendes vor: Initialisierung, Zwischenspeichern der einzelnen Thread-Ergenisse und das abschließende Zusammenführen der Zwischenwerte inklusive Locking. Übrigens: Aufgrund des Zusammeführens der einzelnen Thread-Zwischenergebnisse kann ist bei der parallelen Ausführung zu Rundungsfehlern kommen und das Ergebnis weicht vom sequentiellen Programm ab.

• Codeblöcke parallelisieren: Hier kommt die Invoke-Methode zum Einsatz.

• Die Task-Klasse: Diese funktioniert ähnlich wie die ThreadPool-Klasse und haben dieser gegenüber wesentliche Vorteile: Sie lassen sich mit wait() synchronisieren und abbrechen. Interessant an dieser Task-Klasse ist die Tatsache, dass dahinter ein spezieller Thread-Pool steckt, der deutlich schneller als der Standard-Threadpool arbeitet.

• Die Future-Klasse: Sie ist abgeleitet von der Task-Klasse und ermöglicht die asynchrone Berechnung von Daten. Dabei wird auf Daten, die noch berechnet werden, automatisch gewartet oder das Endergebnis sofort ausgegeben. Die Future-Klasse eignet sich übrigens dazu, die Bedienoberfläche von Hintergrundberechnungen zu entkoppeln und damit die Anwendungen performanter zu machen.

• Concurrent Exceptions: Im Gegensatz zu sequentiellen Anwendungen können in parallelisierten Applikationen zu einer bestimmten Zeit mehrere Exceptions ausgeworfen werden. Hierfür ist natürlich ein anderer Exception-Mechanismus erforderlich. So müssen zum Beispiel im Falle einer Exception mehrere Threads gleichzeitig angehalten werden.

• Synchronisierung: Hierfür sind diverse Klassen im .NET-Framework vorhanden wie Lazyinit und WriteOnce.

Tipps und Tricks:

• Bei Parallel.For und Parallel.ForEach muss die (Anzahl der Durchläufe * Dauer) auf jeden Fall groß genug sein (beispielsweise schlägt bei der Matrix-Multiplikation die Parallelisierung erst bei sehr großen Matrizen voll durch).
• Nur äußere Schleifen parallelisieren wegen der Abhängigkeiten der Variablen
• Amdahl’s Gesetz berücksichtigen

• Statisches Threading birgt vor allem ein Problem: Es gibt statische Variablen, die von mehreren Threads gleichzeitig schreibend genutzt werden können.

• Threading mit instanzierten Klassen: Jeder Thread hat seine eigene Instanz, also zum Beispiel seine eigenen Variablen, was natürlich ein wenig mehr Ressourcen kostet.

• Steuerung von Threads: Hierbei geht es um die Priorisierung von Threads sowie das Starten, Pausieren und Stoppen von Threads. Die Herausforderung ist hier der jeweils richtige Zeitpunkt, ein Thread zu manipulieren. Außerdem muss man feststellen können, ob ein Thread gewollte beendet wurde. Dies kann per Bool’scher Variable erreicht werden.

• .NET-Threadpool: Der Pool soll ein einfaches Arbeiten mit mehreren Threads ermöglichen. Diese Threads “leben” meist relativ lang oder werden regelmäßig wiederkehrend benötigt. Es gibt eine maximale Anzahl an Threads innerhalb eines Pools. Wir ein Pool-Thread 30 Sekunden nicht benötigt, wird der Thread aus dem Pool entfernt. Schwierig dabei kann auch sein, dass ein neuer Pool-Thread erst nach einer halben Sekunde erzeugt wird, wenn kein laufender Thread in dieser Zeit beendet wird. Und: Jeder Prozess hat seinen eigenen Thread-Pool.

• Asynchrone Methoden: Einzelne Aufgaben werden in eigenen Threads ausgeführt. Die hierzu benötigten Methoden heißen BeginInvoke und EndInvoke. Allerdings sind diese Methoden kaum sinnvoll anwendbar.

• BackgroundWorker: Besteht aus drei Klassen: DoWork, ProgressChanged und ReportProgress.

• Synchronisierung: Im .NET-Framework gibt es Klassen für die Synchronisierung von Objekten.

• Atomare Anweisungen: Viele Befehle dürfen nicht unterbrochen werden. Daher stellt die Interlocked-Klasse sicher, das Grundbefehle vollständig ausgeführt werden, wenn mehrere Threads auf die Variablen zugreifen können: Increment/Decrement, Exchange, CompareExchange, Read (new), Add (new). Dies ist zum Beispiel für Sortieralgorithmen wichtig.

Zunächst geht es um echte Basics wie Multithreading mit Single- und Multicores. Fakt ist: Multithreading allein bringt gar nichts, dafür sind mehrere Prozessoren und die Zerlegung eines Programms in parallel zu verarbeitenden Bereiche notwendig.

Eine weitere Herausforderung sind Latenzzeiten, die sich aus asynchroner Prozessorverarbeitung ergeben. Das lässt sich mithilfe einer Kombination aus Multithreading und Multitasking auf mehreren Prozessoren optimieren.

Es gilt aber zugleich, den Durchsatz zu erhöhen. Dies gelingt ausschließlich auf Multicore-Systemen.

Es gibt ein grundsätzliches Problem bei der Parallelverarbeitung: den Zugriff auf gemeinsame Ressourcen. Diese Herausforderung meistern Zugriffskontrollen mithilfe explizierter Sperren. Hierfür sperren zum Beispiel einzelne Tasks gemeinsamen Speicher. Allerdings müssen die Zeitspannen und die Granularität dieser Sperren genau passen. Ein große Gefahr hierbei sind übrigens mögliche Deadlocks, die gerade bei parallel programmierten Anwendungen erst zur Laufzeit auftreten. Deadlocks lassen sich durch dieselbe Sperrreihenfolge vermeiden.

Jetzt redet Bernd über Data Races, die immer dann entstehen, wenn mehrere Threads auf dieselbe Ressource wie eine Variable schreibend zugreifen. Und das ist leider nicht vorhersehbar, da der schnellere Thread meist “gewinnt”.

Abschließend geht Bernd noch auf das Gesetz von Amdahl ein. Das hat mit dem Aspekt zu tun, dass die meisten Anwendungen nicht vollständig parallelisiert werden können bzw. sollen. Daher ist die Temposteigerung von seriellen Programmen, die parallelisiert werden, meist nicht optimal. Und das bedeutet laut Amdahl, dass der sequenzielle Teil einer Anwendung maßgeblich für die Temposteigerung zuständig ist.

Eine weitere Einschränkung bei der Geschwindigkeitssteigerung sind limitierende Faktoren wie das Erzeugen und Zerstören von Threads, Cache-Synchronisierungen und so fort. Die Erzeugung eines Threads dauert zum Beispiel so lang wie die Addition von 1.000 Integer-Zahlen. Abhilfe schaffen Threadpools, mit deren Hilfe ein Thread einmal erzeugt wird und dann immer wieder zur Verfügung steht. Wichtig ist aber auch die Granularität der Threads, damit die vorhandenen Ressourcen optimal genutzt werden.

Fazit: Es gibt je nach Rechendauer und -aufwand einen optimalen Parallelisierungsgrad. Und Threadpools helfen, parallelisierte Anwendungen zu beschleunigen.

Den Anfang macht Rami Radi von Intel, der die Einführungsrede hält und die Anwesenden auf das Thema Multicore einstimmen will.

Rami beginnt seinen Vortrag mit Hardware, nicht mehr Software. Namentlich spricht er über den Core i7-Prozessor, der ja im höchsten Maße multithreading-tauglich ist. Core i7 verarbeitet nämlich pro Prozessorkern zwei Threads simultan.

Die nächste Folie zeigt die ganze Vielfalt der Intel-Entwicklertools, über die ich hier schon ausführlich berichtet habe, also über Compiler, VTune etc.

So, jetzt wird’s ernst. Rami spricht über die Parallelprogrammierung im .NET-Umfeld, was seiner Meinung nach nicht einfach ist (wären wir sonst hier?). Zu den Herausforderungen gehören unter anderem falsch genutzter Speicher, zu viele und zu wenige Threads, gemeinsam genutzte Speicherbereiche, Load Balancing und viele andere. Wie gut, dass es für diese “Issues” die passenden Tools gibt wie den VTune Performance Analyzer.

Aber es gibt laut Rami auch genug Fälle, in denen parallelisierte Anwendungen langsamer laufen als serielle. Das hat diverse Gründe: Der serielle Code nimmt immer noch zu viel Raum ein, die kritischen Pfade sind nicht vernünftig parallelisiert oder die Speicherbandbreite reicht nicht aus.

Die nächste Folie zum Thema .NET-Konstrukte wirkt auf den ersten Blick ein wenig überfrachtet. Zum Glück will sich Rami auf die wirklich wichtigen Aspekte konzentrieren. Dazu gehören Thread-Pools. Rami zeigt ein kleines Beispiel anhand einer kleinen Fotoverwaltung, die in C# geschrieben ist.

Der Vorteil von Thread-Pools ist in diesem Fall, dass nicht ein, sondern zwei oder mehr Bilder gleichzeitig aus der SQL-Datenbank ausgelesen werden können, die die Bilder aufbewahrt. Der Trick hierbei ist übrigens, die Thread-Parameter in die For-Schleife zu packen. Außerdem muss ein Wait-Signal eingebaut werden, damit die Anwendung am Ende weiß, dass alle Bilder angezeigt worden sind. Darüber hinaus ist ein Lock-Befehl einzufügen, der die SQL-Zugriffe synchronisiert.

Interessant: Innerhalb des .NET-Umfelds kann nativer Code eingesetzt werden, um leistungsfähige Bibliotheken zu nutzen.

Jetzt gibt’s noch ein paar nützliche Tipps, mit denen man multithread-optimierten Code noch besser machen kann. Dazu gehören das Auslesen der vorhandenen Prozessorressourcen, das Zusammenfassen mehrerer Funktionen zu einem einzigen Thread, das Cachen von häufig benutzen Daten und das Benutzen von parallelen Datenbankverbindungen.

Schließlich gibt es noch eine kleine Einführung in VTune, mit dem sich Anwendungen prima analysieren lassen.

Auf der Konferenz habe ich auch James Reinders zum ersten Mal live erlebt, und in Echt ist er noch authentischer als in seinen Videos. Zu erzählen hat er sowieso eine ganze Menge über Parallel Studio, das übrigens am 26. Mai 2009 auf den Markt kommen soll. Zunächst zwar ohne Parallel Advisor, aber dafür inklusive Parallel Composer, Parallel Inspector und Parallel Amplifier. Und was es mit dem ominösen Ct-Projekt auf sich hat, haben wir von James ebenfalls erfahren.

Ansonsten gab es detaillierte Infos zu den Tools (samt Demos, die ich hoffentlich noch nachliefern kann) sowie eine kleine Einführung in Visual Studio 2010. Und warum Nero pro Jahr rund 50 Millionen Software-Titel verkauft, haben wir ebenfalls gelernt.

Ach ja: Nicht, dass es mir langweilig würde diese Woche. Am morgigen Donnerstag findet hier in München der prio.powerday zum Thema Multicore-Programmierung im .NET-Umfeld statt. Ich werde auch von dort Livebloggen und bin schon sehr gespannt, was Rami, Don, Bernd und Ralf zu erzählen haben. So, stay tuned …

Status quo aus Intel-Sicht sind die HPC-basierten Tools der Gegenwart, die permanent weiterentwickelt werden. Daneben wird es sehr bald (wohl im Mai) Parallel Studio geben für den Mainstream-Entwickler. Und drittens sind die vorhandenen Tools einer ständigen Evolution unterworfen (so kommt ein verbesserter Compiler irgendwann im Juni auf den Markt).

Die Evolution des Parallel Studio umfasst folgende Dinge:

• der Parallel Advisor wird wichtiger Bestandteil der Suite
• beste Kompatibilität mit Windows 7 und Visual Studio
• Unterstützung der nächsten Microsoft Concurrency Runtime
• Ergänzungen (was immer das bedeutet)

Den dritten Teil seines Vortrags leitet James mit einem Traum ein:

If you focused on “data parallel programming”, could you make it easier for the program to be deterministic and scale?

Die Antwort lautet natürlich “Yes” und mündet in der Vorstellung des Ct-Projekts, das Ende 2009 eine Beta-Version eines neuen Produkts gebären soll. Das Thema ist die datenbasierte Parallelprogrammierung unter C++. Die Hauptmerkmale sehen wie folgt aus:

• eine höchst abstrahierte, beschreibende Programmiersprache, die nicht mehr in Aufgaben “denkt”
• hoch skalierend
• C++ wird um neue Templates erweitert (vergleichbar mit Intel TBB). Es sind keinerlei Änderungen an den bekannten Compilern erforderlich.

Ct wird beispielsweise die Programmierung von Bild- und Videobearbeitungstools erheblich vereinfachen, da nicht mehr sämtliche Varianten der datenorientierten Programmierung berücksichtigt werden müssen (Threading auf SSE- und einer höheren Ebene). Die Beschleunigung mittels Ct geschieht quasi im Hintergrund und entlastet den Programmierer bei seiner Arbeit.

Ct wird also die parallele Programmierung von datenbasierten Anwendungen deutlich vereinfachen und eines Tages in sämtlichen Intel-Softwaretools integriert sein.

Ein sehr schöner Einstieg in das Thema Tuning ist folgendes Zitat: “Ich weiß, wie ich vier Pferde dazu bringe, einen Wagen zu ziehen. Wie aber geht das mit 1024 Hühnern?” Das ist eine wirklich passende Analogie zur Optimierungsarbeit beim parallelen Programmieren. Denn es gibt so viele Fallen, in die man beim Multithreading tappen kann: nicht-skalierender Code, Deadlocks oder Data Races zur Laufzeit und vieles mehr.

Dafür gibt es den Parallel Amplifier, der Flaschenhälse findet, die Skalierbarkeit der Anwendung ermittelt und mehr. Es hilft also Entwicklern und Programmierern, die parallele Struktur und das parallele Verhalten ihrer Anwendung besser zu verstehen.

Wie schon der Composer und Inspector, integriert sich Parallel Amplifier in Visual Studio und findet folgende Probleme:

• Wo verbraucht meine Anwendung die meiste Zeit?

• Wann gehen die Prozessoren in den Idle-Modus?

• Wo gibt es ungewollte Wartezeiten?

Sobald Amplifier die möglichen Fehler gefunden hat, lassen sich die entsprechenden Quellcode-Stellen per Mausklick öffnen und auf die Fehler hin überprüfen.

Parallel Amplifier findet aber auch Unter- und Überschäftigung der vorhandenen Prozesorkerne, zeigt also sehr anschaulich, in welchem Umfang die Ressourcen genutzt werden.

Praktisch ist auch die Vergleichsfunktion, die es ermöglicht, die Ergebnisse zweier Durchläufe grafisch darstellen zu lassen. Also vor und nach der Optimierung und deren Auswirkung auf die Ausnutzung der Ressourcen.

Jetzt folgt eine Livedemo, die den Amplifier präsentiert. Und auch hier muss ich leider sagen, dass sich das geschriebene Wort nicht dafür eignet, das Gesehehene vernünftig zu beschreiben. Aber ich versuche auch in diesem Fall, etwas Anschauliches nachzuliefern. Interessant dabei ist die Tatsache, dass der Amplifier die EXE-Datei zur Laufzeit analysiert und anschließend innerhalb von Visual Studio die Ergebnisse darstellt. Das macht das Aufspüren der betreffenden Quellcodestellen ziemlich einfach.

Überraschend war übrigens der Wechsel des Compilers, um in diesem Anwendungsfall eine spezielle Bibliothek nutzen zu können. Die Laufzeit reduzierte sich von 15 Sekunden auf unter eine Sekunde. Dies ist auf den Intel-C++-Compiler zurückzuführen, der diese Bibliothek bereithält und die Laufzeit dramatisch verringert.

Parallel Inspector ist, einfach gesagt, eine Kombination aus Threading- und Speicher-Checktool, und das sogar “proaktiv”. Proaktiv bedeutet in diesem Zusammenhang eine Fehlersuche zur Laufzeit der Anwendung. Darüber hinaus integriert sich der Inspector in Visual Studio und macht damit die Bedienung ziemlich einfach. Der Programmierer muss sich nur für eine der beiden Optionen entscheiden: Finde Threadfehler oder Speicherfehler.

Speicherfehler: Hier geht es um so unschöne Dinge wie Memory Leaks, Speicherüberläufe und Zeigerprobleme. Schön daran ist die Möglichkeit, irrelevante gefundene Probleme auszublenden. Dies macht das Aufspüren der wichtigen Fehler einfacher.

Threading-Fehler: Stichworte sind Deadlocks, Data Races und andere Synchronisationsprobleme, und das zur Laufzeit der Anwendung. Auch hier lassen sich unwichtige Probleme direkt ausblenden.

Ein schöner Nebenaspekt des Parallel Inspector ist dessen Compiler-Unabhängigkeit: Man kann also sowohl den Intel-C++- als auch den Microsoft-Compiler oder jeden anderen kompatiblen Compiler verwenden.

Sehr hübsch: Je nach gewünschter Intensität lässt sich der Inspector-Test (Speicher oder Threading) mithilfe eines virtuellen Zeigers einstellen. Das macht die Wahl des passenden Tests sehr intuitiv.

Die abschließende Demo ist wirklich sehr anschaulich und zeigt die einfache Handhabung des Inspectors aus Visual Studio heraus. Leider lässt sich das an dieser Stelle nur schlecht darstellen. Ich überlege mir aber etwas, wie ich das nachträglich zeigen kann. Versprochen!

Fazit: Parallel Inspector ist ein wirkliche gutes Tool, mit dem sich mögliche Threading- und Speicherprobleme identifizieren lassen, und das mit wenigen Mausklicks. Zudem geschieht dies aus der gewohnten Visual-Studio-Umgebung heraus.

Im Gegensatz zum letzten Blogeintrag steht mittlerweile fest, wer die Keynote-Rede halten wird. Es ist Rami Radi, Senior Software Application Engineer bei der Software und Services Group von Intel. Rami wird unter anderem den Irrglauben vieler .NET-Entwickler zerschlagen, dass ihre Anwendungen automatisch mit den aktuellen Hardware-Plattformen skalieren. Daher wird Rami zeigen, welche Schritte notwendig sind, um .NET-Software für Multicore-Plattformen wie den Core i7 von Intel zu analysieren, zu optimieren und fein abzustimmen.

Anschließend werden Bernd Marquardt und Ralf Westphal gemeinsam einen ersten Einblick in die Welt der Parallelverarbeitung und -programmierung gewähren. Das Auditorium wird also eine Menge über die Terminologie der Multicore-Programmierung erfahren. Zudem stehen die Konzepte des Multithreadings sowie deren Herausforderungen auf Bernds und Ralfs Agenda.

Nach einer kurzen Kaffeepause geht es dann ans Eingemachte: “Parallelverarbeitung mit .NET Bordmitteln”. Was bietet das .NET-Framework, um die eigenen Softwareprojekte für Core i7 und Co. zu optimieren. Ein kleiner Tipp: Hierzu gibt es auf diesem Blog eine ganze Menge nachzulesen. Wer die Infos dazu findet, darf sie behalten!

Am Nachmittag finden dann drei weitere Vorträge statt: “Parallele Algorithmen: Die Parallel Fx Library”, “Parallele Architekturen: Die Concurrency Coordination Runtime” und “Chances for parallel programming with the functional programming language F#”. Speziell die letzte Präsentation, die von F#-Guru Don Syme gehalten wird, birgt ein hohes Informationspotenzial. Denn es geht bei F# um einen ganz neuen Denkansatz für die parallele Programmierung, der auch dringend notwendig sein wird. Spätestens dann, wenn Visual Studio 2010 mit all seinen parallelen Möglichkeiten auf den Markt kommen wird – inklusive F#.

Ach ja: Um dem Thema F# und der funktionalen Programmierung einen gebührenden Rahmen zu geben, gibt es eine Warm-up-Veranstaltung zu diesem Thema. Don Syme, Bernd Marquardt und Ralf Westphal werden sich zwischen 17.30 und 21.30 Uhr drei volle Stunden Zeit nehmen, um mit euch über F# und die Parallelprogrammierung im .NET-Framework zu diskutieren.

Frühbucherrabatt-Tipp: Wer sich jetzt noch ganz schnell anmeldet (und zwar bis zum nächsten Montag, den 23.3.) kann satte 100 Euro für die Teilnahme am prio.powerday sparen (390 Euro statt 490 Euro). Das gilt natürlich auch für die Kombination aus F#-Nighttalk und .NET-Multicore-Konferenz. Also, worauf wartet ihr noch?!

Im Laufe seines Referats stellte Professor Tichy mehrere Thesen in Sachen Parallelprogrammierung auf, die ich hier ein wenig aufdröseln will.

These #1: Die Informatik erlebt gerade eine Evolution: Weg von der sequenziellen Programmierung hin zur parallelen Entwicklung. Parallelität gab es bis dato nur in Nischenbereichen wie Numerisches Rechnen, Betriebssystemen und Datenbanken und Parallelität auf Instruktionsebene. Meine Antithese dazu: Stimmt!

These #2: Es gab immer wieder spezielle Parallelrechner wie den Atanasoff-Berry-Rechner von 1942, der ausschließlich lineare Gleichungen mit 30 Koeffizienten lösen konnte. Dazu gehörte aber auch der Illiac-IV, ein SIMD-Rechner mit verteiltem Speicher und 64 Prozessoren. Dieser Großrechner wurde 1976 gebaut und war bis 1981 der schnellster Rechner der Welt. Natürlich erwähnte Tichy auch den Cray-1 Vektorrechner, der ebenfalls aus dem Jahr 1976 stammt und wohl den bekanntesten Vertreter der prähistorischen Parallelrechner darstellt. Das Alles (und viel mehr) mündete schließlich in riesigen Clustersystemen der Gegenwart, die allesamt auf der Webseite Top500.org zu bestaunen sind. Meine Antithese dazu: Eine schöne Liste!

These #3: Es gibt neben Intel-CPUs wie Core 2 Quad oder Core i7 weitere Parallelprozessoren, die allerdings (beispielsweise die Grafik-CPU Geforce 8 von Nvidia) hauptsächlich für Spezialbereiche konzipiert sind. Meine Antithese dazu: Wie sagte erst kürzlich ein bekannter Chefentwickler zu mir: “CUDA und die angeblich enorme Rechenleistung der Geforce-GPUs ist vor allem eins: Marketing!”

These #4: Die Moore’sche Regel hat eine Variation erfahren, die wir an der Uni Karlsruhe sogar ein wenig verfeinern wurde: “Die der Anzahl Prozessoren pro Chip wird sich mit jeder Chip-Generation bei etwa gleicher Taktfrequenz verdoppeln”. Meine Antithese dazu: Ja, das sagt Intel auch. Dann wird es wohl stimmen …

These #5: Was sollen wir mit all den Kernen nur anfangen, die uns in Zukunft zur Verfügung stehen? Die Antworten lieferte Professor Tichy postwendend selbst: automatische Protokollführer; inhaltsbasierte Bildersuche mithilfe einer Datenbank; intuitive Schnittstellen mit Bild- und Sprachverarbeitung; vorausschauende Anwendungen, die “ahnen”, was der Benutzer will; Modellierung des Benutzers und der Umgebung; Erhöhung der Zuverlässigkeit (Redundanzen). Meine Antithese dazu: Wie wäre es mit weiteren Beispielen: Videoschnitt, Bildbearbeitung, 3D-Spiele, skalierende Betriebssysteme und Videoencoding, um nur einige zu nennen.

These #6: Es gibt natürlich Probleme bei der parallelen Programmierung, die aber nicht dazu führen dürfen, dass darunter die Qualität leidet. Meine Antithese dazu: In der Tat, dass würden wohl die Kunden und Endanwender nicht tolerieren!

These #7: Paralleltools sind immer noch unzureichend vorhanden. Meine Antithese dazu: Ach, und was ist mit folgenden Werkzeugen: Parallel Composer, Thread Checker, Threading Building Blocks, VTune Performance Analyzer und andere mehr?

These #8: Software-Entwickler sind oder werden nicht gut genug ausgebildet. Meine Antithese dazu: Ja, das sagen andere auch. Wie gut, dass es zum Beheben dieses Dilemmas die passenden Programme gibt.

These #9: Der Weg zum fehlerfrei programmierten Parallelcode ist lang und steinig. Dabei sind vor allem massive Umstrukturierungen des Quellcodes notwendig. Und potenzielle Abhängigkeiten sowie mögliche Seiteneffekte müssen unbedingt beachtet werden. Meine Antithese dazu: Ja, dazu habe ich mir auch schon so meine Gedanken gemacht. Resultat: beliebte Fehler bei der Parallelprogrammierung, fünf Multicore-Programmierregeln und die passenden Multithreading-Konzepte.

These #10: Es gibt immer noch bestimmte Dinge in der Parallelprogrammierung, die kaum oder gar nicht funktionieren. Dazu gehört die oft ausgesprochene Empfehlung, Parallelkonstrukte nach und nach hinzuzufügen. Selbst vor allem laufzeitkritische Pfade zu parallelisieren bringt meist nichts. Darüber hinaus hat die feingranulare Parallelisierung innerer Schleifen nach Tichy keinen wesentlichen Effekt. Meine Antithese dazu: Es ist sicherlich kein einfaches Unterfangen, sequenziellem Quellcode paralleles Leben einzuhauchen, aber es gibt die passenden Methoden und Tools (siehe Antithese #7). Darüber hinaus lassen sich vor allem nummerische Probleme sehr gut mithilfe von parallelen Konstrukten lösen (auch im Nachhinein).

These #11: Parallelisierung darf nicht per Trial-and-Error erfolgen. Und man muss gut abschätzen, wo die Parallelisierung am meisten bringt – und wo nicht! Meine Antithese dazu: Gut gebrüllt, Löwe! Denn nur ein guter Parallelquellcode produziert keine ungewollten oder unvorhersehbaren Laufzeitfehler. Mit Tools wie dem Thread Checker lässt sich das übrigens überprüfen.

These #12: Es sind bessere Programmiersprachen zum Ausdruck paralleler Abläufe notwendig, aber auch parallele Algorithmen und Bibliotheken. Und Tools für das Debuggen von Parallelisierungsfehlern sowie Tools für parallele Programmierung. Meine Antithese dazu: Wie gut, dass es hierfür schon das ein oder andere gibt.

Da wäre zum einen der Schauplatz zu nennen: Das Konferenzzentrum befindet sich in unmittelbarer Nähe der FH München, also dort, wo unter anderem die Software-Entwickler von morgen ausgebildet werden. Ich habe auf jeden Fall gerade eine Mail an eine meiner Ex-Professorinnen abgeschickt; vielleicht wird ja dort an der Hochschule für angewandte Wissenschaften auch das Thema Multicore gelehrt (nix mehr FH!).

Zum anderen geht es auf der Webseite natürlich auch um die Inhalte der Konferenz, die zum Großteil schon feststehen. Diese ranken sich wie bereits berichtet um folgende Themen:

Um 9 Uhr findet zunächst einmal die Keynote-Präsentation statt. Wer diese halten wird, ist noch offen. Zumindest findet sich in der Agenda noch kein Name.

Ab 9:45 Uhr gibt es eine Einführung in das Thema Parallelverarbeitung. Es geht um Deadlocks, Race Conditions, Latenzen, Kanäle und andere Dinge.

Nach der Kaffeepause geht es ab 11.15 Uhr einen Schritt weiter: Bernd Marquardt und  Ralf Westphal erläutern, wie man mit .NET-Bordmitteln parallel programmierte Anwendungen erstellt. Sie behandeln also Begriffe wie ThreadPool, BackgroundWorker, WaitHandle und mehr. Grundwissen für Programmierer.

Nach dem Mittagessen (14:00) wird es dann ernst: Bernd zeigt den Anwesenden, wie sich die .NET-Bordmittel um höhere Abstraktionen erweitern lassen: Er spricht über Parallel Fx, PLinq und die Task Parallel Library (TPL), die Parallelprogrammierern bei ihrer Arbeit helfen sollen.

Ab 15:15 Uhr ist Zeit für den Blick aufs “Große Ganze”, sprich auf das Synchronisieren einzelner Aufgaben und Funktionen zu einem skalierenden Quellcode. Außerdem geht es um die Parallelität auf Architekturebene, wofür Microsoft die Concurrency Coordination Runtime (CCR) entwickelt hat.

Um 16:45 Uhr wird das große Finale eingeläutet: Bernd und Ralf stellen die funktionale Programmiersprache F# aus dem Hause Microsoft vor, mit der vor allem Synchronisierungsprobleme einfacher handhabbar sein sollen. F# bietet aber auch ganz neue Ansätze der Parallelprogrammierung. Nicht umsonst steckt Microsoft eine Menge an Arbeit und Geld in F# (und nicht zu vergessen die Anstrengungen rund um Visual Studio 2010).

Ach ja: Für die Multicore-Konferenz kann man sich ab sofort anmelden. Die Tageskarte kostet regulär 490 Euro, bis zum 23. März 2009 allerdings nur 390 Euro. Um diese 100 Euro Rabatt einstreichen zu können, müsst ihr bei der Anmeldung den Rabattcode PPMC9SDB eingeben.

Und dieser “Krafttag” wird es wohl in sich haben. Es geht unter anderem um folgende Fragen:

• Wie nutze ich aktuelle und zukünftige Multicore-Prozessoren optimal für meine Anwendungen?

• Welche Konzepte und Werkzeuge der Parallelprogrammierung gibt es?

• Was ist die Concurrency Coordination Runtime und welche Aufgaben übernimmt sie?

• Welche Bedeutung haben die Parallel Extensions für das .NET-Framework und wie setze ich sie am besten ein?

• Wie erstelle mithilfe von F# parallel programmierte Anwendungen?

Diese und viele weitere Fragen werden auf der großen .NET-Konferenz beantwortet. Und zwar von bekannten Größen der Branche wie Ralf Westphal und Bernd Marquardt, beide ihres Zeichens Microsoft MVP.

Falls Sie also zu den .NET-Entwicklern gehören, die unbedingt mehr wissen wollen (oder müssen) zum Thema Multicore-Programmierung, sollten Sie den 23. April schon mal ganz fett und dick im Kalender markieren.

Spartipp: Geben Sie bei der Anmeldung zum Multicore-Powerday einfach den Gutscheincode PPMC9SDB ein und schon sparen Sie 100 Euro. Ist das nix?!

Update: Sodala, jetzt ist auch die zugehörige Webseite online.

Dazu gehört beispielsweise ein Blick in die parallele Zukunft, die Steve Teixeira während seiner heutigen Keynote gewähren wird (mit Steve durften wir letzte Woche während der Tech-Ed EMEA 2008 in Barcelona zu diesem Thema ein Video-Interview führen). Dabei geht es vor allem um die geplante Version 10 von Visual Studio, bei der das Thema paralleles Programmieren in den Vordergrund rücken wird.

Was liegt da also näher, als dass Intel auf der Tech Summit vertreten ist (und das sogar als Gold-Sponsor), um über seine eigenen Bemühungen hinsichtlich der Software-Entwicklung für Multicore-Plattformen zu sprechen. So wird Ralph de Wargny am morgigen Freitag über die verschiedenen Aspekte reden, die es zu beachten gilt, wenn man unter Windows seriellen Programmcode parallelisieren will. Er wird also über die Intel Softwaretools reden wie den Intel VTune Performance Analyzer, aber auch über die zukünftige Parallelisierungs-Suite Intel Parallel Studio, die als Plugin für Microsoft Visual Studio fungieren wird.

Übrigens: Ralph und sein Kollege Edmund Preiss werden heute und morgen auf dem Tech Summit jeweils ein schickes Acer-Notebook mit Dual-Core-CPU verlosen. Sobald ich mehr Infos dazu habe, werde ich diese hier nachliefern!

Update: Die Prozedur ähnelt der auf der Tech-Ed: Am Intel-Stand vorbeikommen, sechs Fragen beantworten, Glück haben, Notebook abgreifen! Und den ersten glücklichen Gewinner gibt es auch schon, wie auf dem Bild unten zu erkennen ist.

Vom Software-Partner SOS Software Service gibt es ebenfalls Positives zu berichten: Gemeinsam mit Intel und Microsoft gibt es für alle Besucher des Tech Summit 30 Prozent Rabatt auf ein spezielles Software-Bundle für Entwickler. Dieses Programmpaket umfasst Visual Studio 2008 Professional, Intel TBB für Windows, Intel Thread Checker, Intel VTune Performance Analyzer und ein Buch über Intel TBB. Auf der zugehörigen Webseite erfahren Sie alles weitere über Preise, Umfänge und den zuständigen Ansprechpartner. Ach ja: Falls Sie nicht auf der Tech Summit sind oder waren, bekommen Sie 20 Prozent auf die Komplettpakete! Ist das was?!

Gestern, überpünktlich um 19:00 MEZ, hat die große Entwicklerkonferenz Microsoft Tech-Ed EMEA Developers 2008 in Barcelona ihre Pforten geöffnet. Es war ziemlich schnell ziemlich voll, was aber sicherlich nicht nur am Freibier lag. Denn allein der große Microsoft-Stand, der die komplette Halle okkupiert, bietet Themen en masse.

Aber natürlich auch der Intel-Stand läd zum Verweilen ein: Ob wegen der netten Kollegen, die mit Sachverstand die vielen Fragen beantworten, oder wegen des Gewinnspiels, bei dem man ein schickes HP-Notebook gewinnen kann – es gibt in der Tat viele gute Gründe für den Besuch der Microsoft Tech-Ed EMEA 2008.

Und so richtig los gehen tut es ohnehin erst heute. Auch bei uns …