Sämtliche Beiträge der Kategorie Multicore
Aus seriell mach parallel: Intel Parallel Advisor Lite
Kollege Preiss von Intel hat mal wieder fleißig geschrieben, und rausgekommen ist ein gedruckter Beitrag in der Elektronik Industrie, den es aber natürlich auch als PDF zum kostenlosen Download gibt. Thema des Artikels: Intel Parallel Advisor Lite, ein ziemlich mächtiges Tool zum Konvertieren von seriellem in parallelen Code. Der Advisor Lite ist übrigens Teil der Intel-Suite Parallel Studio, ein Plug-In für Visual Studio 2005 und 2008.
In dem ausführlichen Beitrag wird gezeigt, wie das Intel-Tool dabei helfen kann, serielle Codeabschnitte zu parallelisieren. Ach ja: Das betrifft ausschließlich C++-Programmierer. Toll an Advisor Lite ist sein schrittweises Herantasten an den möglichen Multithread-Code: Anstatt alles auf einmal umzustellen, erlaubt das Tool ein sukzessives Optimieren des seriellen Quellcodes. Hierzu setzt es vorhandene Debugger-Tools ein, mit denen der parallelisierte Quellcode sofort getestet und mögliche Fehler identifiziert und eliminiert werden können. Dazu zählen unter anderem Data-Sharing-Probleme, die sich beim Synchronisieren von Threads ergeben können.
Interessant an Edmunds Artikel ist übrigens die Vorgehensweise des Advisor Lite:
- Leistungsengpässe (Hotspots) identifizieren
- Annotationen in den seriellen Quellcode einfügen (eine Art von C-/C++-Makros)
- die annotierten Quellcodes verifizieren
- parallele Datenzugriffe untersuchen
- Datenkonflikte auflösen, die unter Schritt 4 aufgespürt wurden
- Quellcodeänderungen testen
Ach ja: Wer noch nicht wissen sollte, was Annotationen sind: Sogar hierzu hält Edmund die passenden Antworten parat. Also alles in allem eine wirklich gelungene Abhandlung in Sachen Parallel Advisor Lite. Und, worauf wartet ihr noch?
Ausführliche Übersicht zur Multicore-Programmierung
Zugegeben, es ist auf diesem Blog ein wenig still geworden rund um das Thema Multicore-Programmierung. Das liegt daran, dass ich mich mit dem Thema hier schon ausführlich beschäftigt habe und sich die Themen grade ein wenig verschieben. Mit der Ankündigung des Intel AppUp Center während des letztjährigen Intel Developer Forum rückte das Netbook mit all seinen Facetten in den Mittelpunkt.
Das wird sicherlich auch noch ein wenig so bleiben, was aber nicht bedeutet, dass auf dem Software Dev Blog die parallele Verarbeitung von Programmcode keinen Platz mehr findet. Um dies unmittelbar zu belegen, möchte ich heute auf eine sehr ausführliche Übersicht aufmerksam machen. “Ultimativ” klingt immer ein wenig anbiedernd und angeberisch, aber in diesem Fall kommt der Begriff ziemlich nah an das heran, was die amerikanischen Kollegen unter dem Titel “Intel Guide for Developing Multithreaded Applications” zusammengetragen haben.
Diese wirklich umfangreiche Sammlung betrachtet sämtliche Aspekte der Parallelprogrammierung. Ob das das Multithreaden von Anwendungen im Allgemeinen ist oder spezielle Themen wie die Daten- und Ablaufsynchronisation oder das Speichermanagement – so detailliert konntet ihr euch dem Thema wohl selten widmen. Ok, das Ganze findet zwar auf Englisch statt, aber das sollte doch keine echte Hürde darstellen.
Ach ja, natürlich darf eine genaue Beschreibung sämtlicher Intel-Tools nicht fehlen, wenn es um das Multithreaden von Anwendungen geht. Also so Themen wie Intel Compiler, Parallel Inspector, OpenMP, Parallel Amplifier und viele mehr. Na, dann kann ich euch nur noch “Gut Stöber” wünschen und dass ihr möglichst viele Antworten auf eure parallelen Fragen findet. Die gibt es natürlich auch hier auf dem Software Dev Blog. Probiert doch einfach mal die Suchfunktion aus!
Antiviren-Software von Avast ist multicore-tauglich
Gerade habe ich auf Zdnet.de eine News entdeckt, die von der sofortigen Verfügbarkeit der kostenlosen Antiviren-Software Avast Free Antivirus 5.0 berichtet. Neben einer komplett neu gestalteten Bedieneroberfläche für mehr Komfort hat sich laut der Avast-Entwickler die Scan-Engine deutlich verbessert, was gemäß interner Benchmarks die Verarbeitungsgeschwindigkeit um bis zu 80 Prozent schneller machen soll. Daneben glänzt die Software mit Echtzeitüberprüfungen des Dateisystems sowie des gesamten E-Mail-, Internet- und Netzwerkdatenverkehrs.
So viel Verbesserung in Sachen Performance lässt sich unter anderem mit Multicore-Optimierungen seitens der Avast-Entwickler bewerkstelligen. Damit erfolgt beispielsweise der Echtzeit-Scan auf einem Prozessorkern, während die GUI von einem zweiten Kern ausgeführt wird, was die Software insgesamt performanter macht.
Was die Leute bei Avast alles dafür getan haben, um ihre Software multicore-tauglich zu machen, werde ich versuchen herauszufinden. Sobald ich die passenden Antworten habe, werden sie natürlich hier veröffentlicht.
PS: Falls ihr Avast Free Antivirus installieren wollt, solltet ihr vorher unbedingt die bereits installierte Antiviren-Software deinstallieren. Ansonsten legt ihr euch möglicherweise den PC selbst lahm.
Das war das Software-Dev-Blog-Jahr 2009 (Teil 3)
Nach dem ersten und zweiten Teil der Software-Dev-Blog-Rückschau 2009 folgt heute der dritte Blogbeitrag, der die Monate September bis Dezember betrachtet.
Was für den August galt, traf auf den September im selben Maße zu: War ich im Vormonat auf der Games Developer Conference, so verschlug mich der neunte Monat des Jahres in das wundervolle San Francisco, wo ich eine ganze Woche auf Intel-Kosten verweilen durfte. Es ging natürlich vorwiegend um die Intel-eigene Entwicklerkonferenz IDF, wo ich mich mit zwei wesentlichen Themenschwerpunkten beschäftigte: Multicore und Netbooks. So besuchte ich unter anderem die Techsessions Software-Tools für skalierende Apps, Parallel Computing mit .NET 4 und Visual Studio 2010, Moblin Technical Overview, Netbook-Ecosysteme und Anwendungsmodelle und sammelte erste Informationen zum geplanten Intel App Store.
Der September und die IDF-Berichterstattung deuteten es bereits an: Das Software Dev Blog wird sich neben der Parallelprogrammierung in Zukunft auch mit dem Thema Netbooks, Atom-Prozessor und Co. beschäftigen. Und so verlagerten sich die Blogbeiträge im Oktober mehr und mehr in diese Richtung. So ging es um die Frage, was beim Intel Atom Developer Program alles zu beachten ist, wer eigentlich den App Store braucht und was das Intel App Store SDK wohl leisten wird. Daneben wartete im Oktober ein weiteres Event auf uns: das mobiledevecamp Munich 2009, das sich an Software-Entwickler mobiler Anwendungen richtete und das in den heiligen Intel-Hallen zu Feldkirchen stattfand. Dort waren rund 80 Leute zugegen (unter anderem Martin Mohring von der Liunux Foundation) und es war insgesamt eine wirklich gute Veranstaltung. Ansonsten fand der erste Intel Blogger Day statt und das Software Dev Blog wurde genau ein Jahr alt.
Im November ging es noch mal auf Reisen, dieses Mal nach Berlin auf die Microsoft Tech-Ed Europe 2009. Auf dieser Entwickler- und Business-Konferenz trafen sich rund 8.000 Menschen, um sich umfassend über die neuesten Microsoft-Technologien zu informieren. Intel war natürlich auch vor Ort, und so habe ich wieder gemeinsam mit Tom viele schöne Videos nebst den passenden Blogbeiträgen erstellt und verfasst. So haben wir mit Steve Teixeira über die Parallelprogrammierung aus Microsoft-Sicht geplaudert, uns von Rami Radi erklären lassen, wie .NET-Entwickler von Multithreading profitieren und haben gelernt, wie die Zukunft der Parallelprogrammierung aussehen wird. Aber es gab auch Neues von Intel in Sachen Multicore, und zwar in Form der Cloud-Testumgebung Intel Parallel Universe.
Der Dezember stand wieder eher im Zeichen des Intel App Store und des zugehörigen Intel Atom Developer Program. Aber es ging auch um Moblin, um die sieben Schritte bis zur ersten eigenen App im Intel App Store, um ein neues Buch zum Thema Parallelprogrammierung unter .NET und um Pine Trail.
Und worauf können wir uns für 2010 einstellen? Nun, während der CES in Las Vegas wird Intel wohl seinen App Store vorstellen. Ende Januar wird Intel dann auf den M-Days mit eigenen Stand vertreten sein und über das Intel Atom Developer Program und den App Store berichten. Apropos Stand: auf der Mobile World Conference in Barcelona wird Intel ebenfalls vor Ort sein – und damit auch ich. Ansonsten werden wir viele neue Dinge rund um Netbook-Apps und Co. zu sehen bekommen. Und die Games Developer Conference 2010 in Köln wird uns sicherlich auch wieder erwarten.
Das war das Software-Dev-Blog-Jahr 2009 (Teil 2)
Auf den ersten Teil der Software-Dev-Blog-2009-Trilogie folgt natürlich sofort der zweite, der die Monate Mai bis August umfasst.
Der Mai stand ganz im Zeichen der Ankündigungen: So war die Geburtsstunde des deutschsprachigen Intel Onlineshops für den Mittelstand zu vermelden, aber auch die Entwicklersuite Parallel Studio erblickte das Licht der digitalen Welt. Ansonsten war der Mai eher ruhig aus Blogsicht. Daher war ein wenig Zeit für Surftipps, für die Vorstellung eines Softwaretools für mobile Spieleentwickler und für eine genauere Betrachtung, was der Parallel Advisor Lite zu leisten imstande ist.
Was dem Mai an Events beziehungsweise an deren Ankündigungen fehlte, holte der Juni direkt wieder nach. So verwies ich auf die Exasol Roadshow, die es Anfang Juli nach München verschlagen sollte. Aber auch die Intel-Microsoft-Techtalks und das GameCamp Munich 2009 waren mir entsprechende Hinweise wert. Ansonsten kam die Firma Maxon zu Wort, die mir verriet, warum Cinema 4D auf Multicore-Plattformen so leistungsstark ist.
Anfang Juli stattete ich der Intel-Außenstelle Ulm einen Kurzbesuch ab. Was ich von dort mitnahm war vor allem eins: Aus Ulm kommen grafisch orientierte Linux-Debugger, mit denen sich sequenziell und parallel programmierte Anwendungen sehr komfortabel testen lassen. Bemerkenswert fand ich im Juli aber auch diverse Einsichten: Warum Colin McRae DiRT 2 so geil auf einem Multicore-Rechner aussieht, warum Demigod auch auf Notebooks spielbar ist und warum Empire: Total War auf Notebooks gut läuft. Daneben gab es Infos zu Tools wie den Visual Studio: Parallel Debugger Extensions, Videosessions der TechTalks mit Intel und Microsoft und Screencasts zur Parallelprogrammierung unter .NET 4.
Der August stand ganz im Zeichen der Games Developer Conference, die im Gegensatz zum letzten Jahr in Köln vor der GamesCom stattfand. Auch dorthin reiste ich natürlich, gemeinsam mit Tom, mit dem ich schon seit längeren Videointerviews und ähnliche Dinge drehe und auf Youtube stelle. So lernten wir auf der GDC09 eine ganze Menge: Warum die nächste CryEngine erst 2012 kommt, warum CPUs für Spieleentwickler wichtig sind, wie Intel Parallel Studio funktioniert, wie man Spieletitel für integrierte Grafikchips optimiert und vieles mehr.
Das war das Software-Dev-Blog-Jahr 2009 (Teil 1)
Immer, wenn sich ein Jahr dem Ende entgegen neigt, ist es Zeit für die ultimative Abrechnung der vergangenen 360+x Tage. Daher folgt an dieser Stelle eine Rückschau auf die Software-Dev-Blog-relevanten Ereignisse. Der Schwerpunkt liegt hierbei auf den Events des Jahres 2009, aber auch neue Techniken und Tools werden Thema sein.
Um das Ganze besser konsumierbar zu machen, wird die Rückschau 2009 als Trilogie verfasst sein, wobei der letzte Teil auch ein wenig in die Zukunft blicken wird. Also dann mal los.
Der Januar begann traditionsgemäß mit der OOP, die im Messezentrum zu München stattfand. Dort trafen sich an fünf Tagen Software-Entwickler aus ganz Deutschland (und darüber hinaus), um über sämtliche Aspekte der objektorientierten Programmierung zu reden. Da Intel einer der Sponsoren dieses großen Events war, kam mir die Rolle des OOP-Berichterstatters zu. Es gab eine ganze Menge zu bloggen: über die Multicore-Programmierung, über 12 Thesen zu diesem Thema und über die Parallelprogrammierung im .NET-Umfeld, woraus ein umfassender Dreiteiler entstand (Teil 1, Teil 2 und Teil 3). Daneben hielt der Januar Blogposts zu der Frage parat, warum DivX, Nik Software und Crysis so gut auf Multicore-Prozessoren skalieren.
Der Februar ließ bereits erahnen, was die Multicore-Entwicklergemeinde im Jahr 2009 in Sachen Intel-Tools zu erwarten hatte: die Parallelisierungssuite Parallel Studio warf erste Schatten voraus, die im Laufe der Zeit immer länger werden sollten. In vier Blogbeiträgen wurden die Fähigkeiten dieses Visual-Studio-Plugins näher beleuchtet (Teil 1, Teil 2, Teil 3 und Teil 4). Der Februar war ohnehin sehr tool-lastig: So ging es unter anderem um hochoptimierte Software-Bibliotheken für die Parallelprogrammierung, um den Concurrency Checker und den Thread Profiler. Events fanden aus Blogsicht im Februar keine statt.
Der März begann mit einer Art Ritterschlag: das Entwicklerportal MSDN, auf dem Microsoft seine Community mit neuesten Infos und Tools versorgt, spendierte dem Thema Parallelprogrammierung eine deutschsprachige Sektion und band das Software Dev Blog prominent an diversen Stellen ein. Das nahm ich natürlich zum Anlass, einen Vierteiler zum Thema .NET-Threads zu veröffentlichen (Teil 1, Teil 2, Teil 3, Teil 4). In Sachen Events gab es auch wieder etwas zu vermelden, und zwar in Form von Vorschauen: auf die Intel Software Conference, auf den prio.powerday, die Games Developer Conference und die Eurographics 2009.
Der April war wieder sehr event-lastig, nämlich in Form der Intel Software Conference 2009 (ISC09) und des prio-powerday 2009 “Multicore-Programmierung im .NET-Umfeld”. Auf der ISC09 ging es unter anderem um die Parallelprogrammierung für den Mainstream, um Microsoft und die parallele Programmierung und natürlich um Parallel Studio. Und weil der April noch nicht genug hatte, folgte kurz nach der ISC09 der prio.powerday 2009, auf dem Dinge wie das Multithreading mit .NET-Bordmitteln besprochen wurden, aber auch die Parallele Programmierung unter .NET 3.5 und die Microsoft Concurrency Coordination Runtime.
Merry Xmas für alle BlogleserInnen
Ich wünsche allen Lesern ein friedliches Weihnachtsfest, viele tolle Geschenke und ein paar erholsame Tage. Und auf viele neue Geschichten, die es auf diesem Blog auch nächstes Jahr wieder geben wird.
Ach ja: Bis Ende des Jahres wird es hier noch den ultimativen Jahresrückblick geben. Also, freut euch schon mal drauf.
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.
Maxon setzt auf Intel Softwaretools für optimierte Apps
Dass Maxon alles dafür getan hat, ihre Software-Anwendungen wie Cinema 4D für die aktuellen Intel-Prozessoren zu optimieren, darüber habe ich schon vor längeren gebloggt. Und wie es der Zufall wollte (ok, der natürlich keiner war), konnten wir mit Maxon höchstpersönlich darüber reden, wie sie es immer wieder schaffen, dass ihre Anwendungen besonders performant auf Rechnern mit Intel-Architektur laufen.
Ein wesentlicher Punkt ist unter anderem der Einsatz des Intel C++ Compilers, der laut Maxon schon mal ohne nennenswerte Änderungen am Code etwa 15 Prozent mehr Speed bringt. Aber auch der Intel Thread Profiler steht bei Maxon ganz oben auf der Liste, wenn es darum geht herauszufinden, wie sich das parallelisierte Programm verhält, ob also die anfallenden Threads möglichst gleichmäßig auf die vorhandenen Ressourcen verteilt werden (Skalierung ist hier das Zauberwort).
Darüber hinaus kommen VTune Performance Analyzer und Intel Threading Building Blocks zur Sprache. Ok, dann würde ich mal sagen, den Rest solltet ihr euch am besten selbst ansehen. Viel Spaß dabei!
Apps unter Mac OS X multicore-tauglich machen
Disclaimer: Dieser Beitrag ist ein Extrakt des Artikels “Mehrkern-Beschleuniger”, der in der mac-developer 1/2010 erschienen ist. Autor dieses Beitrags ist Maximilian Götzfried.
Ende August war ich bei Apple, um ein wenig mehr über deren Multicore-Beschleuniger Grand Central Dispatch zu erfahren. Diese in Snow Leopard implementierte Technik erlaubt es Anwendungsentwicklern, mit relativ wenig Aufwand, ihre Anwendungen multicore-tauglich zu machen. Und das ohne größeren Programmieraufwand, sondern lediglich mithilfe der C-API und den NSOperation-Klassen.
Das Tolle an GCD ist deren einfache Verwendung: Anstatt selbst Threads auf Basis von Tasks oder anderen Objekten zu erzeugen, kümmert sich GCD selbst darum. Das bedeutet aber für den Software-Entwickler, dass er sich für eine optimale Ausnutzung der vorhandenen Prozessorressourcen grundsätzlich Gedanken machen muss über die Programmlogik. Das Resultat seines überarbeiteten Programms sind einzelne Tasks, die je nach Programmablauf an die vorhandenen Multithreading-Queues übergeben werden können, wo sie von GCD bestmöglich verarbeitet werden.
Wie bereits angedeutet, stellt GCD zwei Möglichkeiten zur Verfügung, Programmcode zu multithreaden: Mithilfe der NSOperation-Klasse und der C-API. Beides soll kurz beleuchtet werden.
NSOperation: Warteschlangentechnik für asynchrone Tasks
Für das asynchrone, also zeitversetzte Ausführen von Anwendungen ist lediglich das Erstellen von NSOperation-konformen Objekten erforderlich, die dann an die zugehörige Warteschlange übergeben werden, die die Queue nach dem FIFO-Prinzip verarbeitet. Hierfür werden Tasks im Hintergrund ausgeführt, pausiert und zu Ende geführt. Es ist sogar möglich, die Anzahl der maximalen Threads festzulegen, was in Extremfällen ein einziger sein kann. Natürlich erlaubt GCD die ständige Rückkehr zum Main Thread.
