.NET DevCon 2011: von C# 5.0 und asynchroner Programmierung

Anfang März habe ich erstmals über die im Juni stattfindende .NET-Entwicklerkonferenz .NET DevCon 2011 berichtet, die in Nürnberg ihre Zelte aufschlagen und von der Neuen Mediengesellschaft Ulm ausgerichtet wird. Im zugehörigen Blogeintrag habe ich unter anderem darüber geschrieben, dass das Programm noch nicht ganz fertig ist, dass bis dato noch keine Sessions zu Windows Phone 7 angeboten werden und dass zudem eine Keynote-Session fehlt. Nun, seitdem hat sich einiges getan, was die Programminhalte betrifft.

Die gute Nachricht vorweg: die Sessionplanung scheint abgeschlossen zu sein und die Programmübersicht listet genau 50 Voträge auf, die an zwei Tagen auf je vier Tracks und vier Themenbereiche verteilt sind. Hierzu gehört auch die Begrüßung am ersten Tag und – jetzt kommt’s – eine Abschluss-Keynote vom Content Manager der Veranstaltung höchstpersönlich, Golo Roden. So gesehen ist mein Wunsch nach einer Keynote ja erfüllt worden, allerdings nicht für den Beginn, sondern für das Ende der .NET DevCon. Na, soll mir auch recht sein!

Die abschließende Keynote-Session wagt einen Blick in die Zukunft zugleich. Denn unter dem Titel “C# 4.0 and beyond” stellt Golo einige der Features vor, die in C# 5.0 implementiert werden sollen. Diese hat ja C#-Oberchefentwickler Anders Heijlsberg auf der PDC 2010 ausführlich dargestellt.

Eine der Hauptunterschiede zwischen C# 4.0 und C# 5.0 wird die Realisierung der asynchronen, sprich der nebenläufigen, also der Parallelprogrammierung sein. So geschieht unter .NET 4 das Verteilen mehrerer Threads auf die vorhandenen Prozessoren mithilfe von Klassenbibliotheken. Auf Basis von C# 5.0 hingegen soll das mit einer angepassten Sprachsyntax geschehen, wovon sich Microsoft eine deutliche Erleichterung der asynchronen Programmierung verspricht.

Hierfür wird es in C# 5.0 das neue Schlüsselwort async geben, das auf die Verwendung asynchroner Methoden hinweist. Daneben wird in C# 5.0 mit await ein neuer Operator eingeführt, der das Programm dazu bringen soll, eine asynchrone Methode auszuführen. Diesen asynchronen Methoden wird auch eine neue Klassenbibliothek spendiert, die sich Task<T> nennt und die für die Rückgabewerte einer Methode zuständig sein wird.

Natürlich werden die neuen asynchronen Methoden von C# 5.0 Fehler abfangen können, und das auf Basis von Try-Catch-Konstrukten. Darüber hinaus lassen sich mithilfe der unter C# 4.0 eingeführten CancellationTokenSource-Klasse Hintergrundprozesse abbrechen.

Tja, über all diese Dinge und sicherlich noch weit mehr wird Golo am 7. Juni auf der .NET DevCon von 17:15 bis 18:15 Uhr reden. Da kann man schon sehr gespannt sein!

Ach ja: Windows Phone 7 hat es leider doch nicht auf die .NET DevCon geschafft. Na, wozu gibt es die erst gestern vorgestellt Mobile DevCon?!

Und für alle, die sich die PDC-2010-Session von Anders Heijlsberg zu C# 5.0 anschauen wollen, haben wir das zugehörige Video verlinkt. Viel Spaß dabei!

Anmelden und Geld sparen: dotnet Cologne 2011

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.

Programm für Entwickler-Event “.NET DevCon 2011″ fast fertig

Wirft man einen Blick auf die Webseite der .NET DevCon 2011, die am 6. und 7. Juni in Nürnberg stattfinden wird, sieht man, dass das Programm schon ziemlich weit fortgeschritten ist. Am zweiten Tag gibt es nachmittags noch ein paar Lücken, ansonsten wirkt das Ganze schon recht rund.

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.

dotnet Cologne 2010 #3: Noch mehr Infos und Präsentationen

Ja doch, ich geb’s ja zu, ich bin mit meinem dritten Teil der dotnet Cologne 2010 (Teil 1 und Teil 2) ein wenig in Verzug. Und da ich dies natürlich wieder gutmachen möchte, gibt es heute neben den Infos zu den zwei noch ausstehenden Sessions von Oliver Sturm und Bernd Marquardt ein Schmankerl (bayerisches Idiom für “Leckerbissen”) dazu: Es sind nämlich schon ganz viele Präsentationen der Techsessions online, die man sich von dort einfach auf seinen Rechner laden kann. Ein toller Service für alle, die nicht dabei sein konnten oder durften oder sonst was.

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.

weiterlesen…

dotnet Cologne 2010, ein voller Erfolg – Teil 2

Wie ich bereits berichtete, habe ich mich letzte Woche auf der dotnet Cologne 2010 herumgetrieben und mir dabei die Sessions von Rami Radi, Mario Deilmann, Oliver Sturm und Bernd Marquardt zu Gemüte geführt. Auf die Session von Rami bin ich ja bereits ausführlich eingegangen, und jetzt folgen noch die von Mario, Oliver und Bernd.

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.

weiterlesen…

dotnet Cologne 2010 war ein voller Erfolg!

Die letzte Woche war für mich mal wieder sehr event-haltig: Mittwoch und Donnerstag war ich auf der Droidcon 2010 in Berlin, am Freitag verschlug es mich dann nach Köln der dotnet Cologne 2010 wegen, und kaum war ich von meiner Reise zurück, unternahm ich am Samstag noch einen kurzen Abstecher in Richtung GamesCamp Munich 2010, die vom lieben Kollegen Flo Bergmann organisiert wurde.

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).

weiterlesen…

dotnet Cologne 2010 inkl. Parallelprogrammierung

Auf dem IT-techBlog hab ich’s schon verraten: Nächste Woche bin ich so richtig auf Achse. Mit den Stationen Berlin, Hamburg und Köln komme ich ganz gut rum in der Republik. Hoffen wir mal, dass der isländische Vulkan nix dagegen hat (ok, einen Teil der Strecken fahre ich ohnehin Zug).

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!

Dotnet Cologne 2010 nimmt Konturen an

Wer sich für die Themen .NET, C#, Parallelprogrammierung und andere Dinge interessiert, sollte jetzt unbedingt weiterlesen (allen anderen empfehle ich diese Lektüre). Denn am 28. Mai 2010 findet in Köln die zweite Community-Konferenz Dotnet Cologne 2010 statt. Das Gute daran: Das Programm dieser Veranstaltung steht zu weiten Teilen schon. Und es sind viele interessante Vorträge dabei. Kleiner Auszug gefällig?

• 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?!

Buchrezension: Parallelprogrammierung unter dotNET

Das Thema Paralllel Computing beschäftigt mich hier auf diesem Blog schon seit mehr als einem Jahr. Und so kurz vor Weihnachten hab ich die perfekte Geschenkempfehlung für alle dotNET-Entwickler, die sich selbst oder andere in Form eines Buches eine Freude machen wollen.

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

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

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

weiterlesen…

Wie .NET-Entwickler mit VTune Bottlenecks finden können

Vergangene Woche auf der Microsoft TechEd Europe 2009 hatten wir die Gelegenheit, uns von Rami Radi zeigen zu lassen, wie .NET-Entwickler mithilfe des Profiling- und Samplingtools VTune Performance Analyzer Schwachstellen in ihren Anwendungen aufspüren und beheben können. Dabei geht es beispielsweise sehr oft um Schleifenkonstrukte, die unverhältnismäßig viel CPU-Zeit in Anspruch nehmen, was mit den richtigen Tricks gar nicht notwendig wäre. Für alle, die also in Zukunft mehr aus ihrer Software herausholen wollen, sei dieser Video-Workshop wärmstens empfohlen.

Screencasts zur Parallelprogrammierung unter .NET 4

Der Name Dariusz Parys ist regelmäßig wiederkehrenden Besuchern dieses Blogs ein bekannter Name: Entweder stellt er sich unseren Fragen oder veranstaltet gemeinsam mit Intel TechTalks oder nimmt Screencasts auf, die er zum Wohle aller online stellt. Und genau die haben es mir besonders angetan, da man in relativ kurzer Zeit eine Menge über das parallele Programmieren unter .NET 4 mithilfe von Visual Studio 2010 lernen kann.

Daher hat’s mich sehr gefreut, dass ich heute Morgen zwei “neue” Screencasts” auf Channel 9 gefunden habe. Das erste beschäftigte sich mit der Frage, wie sich die Klasse Parallel dazu nutzen lässt, mehrere Funktionsblöcke gleichzeitig auf mehreren Prozessorkernen ablaufen zu lassen. Hierzu stellt die Parallel-Klasse ein Methode zur Verfügung, die sich Invoke nennt.

Praktisch an dieser Form der Parallelisierung ist die Tatsache, das die gleichzeitig ablaufenden Funktionen nicht synchronisiert werden müssen. Der Mainthread wird nämlich erst dann fortgesetzt, wenn die parallelen Threads fertig sind. Darum kümmert sich die Concurrency Runtime.

Screencast Nummer 2 zeigt in nur sechs Minuten, wie sich Tasks definieren lassen, die einen Rückgabewert liefern. Auch das hat den großen Vorteil, dass der Mainthread nicht unnötig warten muss, bis ein oder mehrere parallel ablaufende Aufgaben fertig sind. Die Übergabe des Returnwertes sorgt nämlich für die Synchronisation des Programmablaufs. Schön daran ist zudem, dass sich auf diesem Weg mehrere Tasks verknüpfen lassen und so ein Folgetask mit dem Rückgabewert des Vorgängertasks “gefüttert” werden kann. Es lassen sich aber nicht nur einfache Werte, sondern auch Objekte übergeben.

Screencasts zur Parallelen Programmierung unter .NET 4

Auf Channel 9 habe ich gerade drei sehr interessante Screencasts entdeckt, die Dariusz Parys dort eingestellt hat. Anhand sehr anschaulicher Beispiele zeigt Dariusz folgende Dinge:

Zurück zum Multicore-Blogging: Post-Konferenzing

Die vorige Woche stand ganz im Zeichen der Multicore-Konferenzen. Los ging’s am Montagabend in Salzburg bei Bier und Brez’n im Pitterkeller des ehrwürdigen Crown Plaza, wo ich mit netten Kollegen zusammensaß und über dies und das geplaudert habe. Das Dienstagsprogramm rankte sich dann um das Thema Multicore-Programmierung und Parallel Studio, aber auch um andere Dinge wie das Nero-Engagement und Microsoft-Bemühungen.

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.

weiterlesen…

prio.powerday: Microsoft Concurrency Coordination Runtime

Direkt nach Bernds Vortrag ist Ralf Westphal wieder dran und erzählt etwas zur Concurrency Coordination Runtime (CCR). Im Gegensatz zu Bernd geht es bei Ralfs Vortrag weniger um die Leistungssteigerung parallel programmierter Anwendungen als vielmehr um die optimale asynchrone Datenverarbeitung im parallelen .NET-Umfeld.

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.

prio.powerday: Parallele Programmierung unter .NET 3.5

Nach der Mittagspause ist Bernd Marquardt ohne sein Alter Ego an der Reihe. Sein Thema: Parallele Programmierung mithilfe des .NET-Frameworks 3.5, und zwar per TPL.

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.

weiterlesen…

prio.powerday: Multithreading mit .NET-Bordmitteln

Und weiter geht’s. Bernd und Ralf gehen jetzt näher auf das Thema Multithreading mit .NET-Bordmitteln ein. Hierbei gibt es verschiedene Aspekte:

• 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.

weiterlesen…

prio.powerday: Einführung in die parallele Programmierung

Jetzt sind mit kaum einer halben Stunde Verspätung Ralf Westphal und Bernd Marquardt dran. Sie wollen uns erst mal erzählen, was parallele Programmierung eigentlich bedeutet.

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.

weiterlesen…

prio.powerday: Multicore-Programmierung unter .NET

Kaum dass ich aus Salzburg zurück bin, sitze ich hier im Konferenzhaus in der Lazarettstraße, München, und nehme an der Multicore-Konferenz für .NET-Entwickler teil, die im Rahmen der prio.powerdays stattfindet.

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.

weiterlesen…

F# und Co: prio.powerday “Multicore im .NET-Umfeld”

Zugegeben, das wird jetzt kein Final Call, dafür ist es noch zu früh. Aber der prio.powerday “Multicore-Programmierung für .NET-Entwickler” wirft bereits seine Schatten voraus, und daher will ich die Gelegenheit nutzen, über ein paar Details zu reden.

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!

weiterlesen…

Workshop: Alles über .NET-Threads – Teil 4

Eine neue Woche beginnt, und im selben Atemzug endet meine vierteilige Serie zum Thema .NET-Threads. So habe ich im ersten Kapitel über das Erzeugen von Threads geschrieben, im zweiten Teil mich über das Verwalten derselben ausgelassen, und am letzten Donnerstag war der ThreadPool und dessen Möglichkeiten dran. Und heute?! Nun, heute geht es um die Synchronisierung mehrerer Threads und atomare Aktionen.

Zunächst einmal kann man festhalten, dass die Thread-Synchronisierung im .NET-Framework ähnlich funktioniert wie im Win32- oder Pthreads-Umfeld. Es geht also um den gegenseitigen Ausschluss sowie um atomare Aktionen auf spezielle Variablen. Wie bei der von C# bekannten Methode lock wird ein Codeabschnitt mithilfe der geschweiften Klammern geblockt, sodass zu dieser Zeit nur ein einziger Thread darauf zugreifen kann. Hierfür bietet das .NET-Framework eine ähnliche Konstrukte:

Monitor.Enter ( this )
try
{
……. shared_var = other_shared_var +1;
……. other_shared_var = 0;
}
finally
{
…… Monitor.Exit ( this )
}

Mit der Klasse Monitor wird der entsprechende Codeabschnitt blockiert. Mit Enter() wird der Abschnitt gesperrt und mit Exit() wieder freigegeben. Praktisch an Monitor ist auch dessen Möglichkeit, Datenstrukturen als Parameter zu übergeben.

Bei Monitor.Enter() geschehen übrigens zwei Dinge: Erstens wird eine Warteschlange eingerichtet, die auf diejenigen Threads verweist, die gesperrt werden sollen und eine zweite Queue mit Threads, die darüber informiert werden wollen, wenn eine Speere verfügbar ist. Monitor.Exit() sorgt dafür, dass der erste verfügbare Thread in Warteschlange #1 gesperrt wird.

weiterlesen…