Es verhält sich nämlich so, dass die Leute bei appbackr den Umstieg auf das Yii-PHP-Framework  gewagt haben, und das aus nachvollziehbaren Gründen. Zum einen, weil sie damit in der Lage sind, ihren App-Markt schneller und effizienter zu verwalten, da Yii recht schlank ist und viele nützliche Funktionen wie User Management und Active Record bietet. Außerdem ist der Umgang mit Yii wohl recht einfach.

Darüber hinaus unterstützt Yii das PHPUnit-Framework, mit dem sich Unit-Tests unter PHP durchführen lassen. Das ist vor allem dann wichtig, wenn man wie appbackr eine test-getriebene Software-Entwicklung innerhalb der Firma implementieren, aber auch die vorhandenen Anwendungen und Programme mit Hilfe von PHPUnit überprüfen will.

Allerdings wollten sich die Leute bei appbackr nicht mit manuellen Unit-Tests zufrieden geben, die Yii mit Hilfe des Befehls phpunit [Testordner] vorsieht. Das ist nämlich umständlich, fehleranfällig und nervt die meisten Entwickler. Daher suchten sie nach einer Lösung, wie sich Unit-Tests unter Yii automatisieren lassen.

Tja, und an der Stelle kam und kommt Watchr ins Spiel. Mit diesem Tool ist es nämlich möglich, automatisierte Tests durchzuführen. Soll heißen: sobald auch nur eine Zeile Quellcode verändert wird, springt Watchr an, führt den Test autoamtisch durch und informiert den Entwickler über den Status des Tests. Wow, so einfach?! Na ja, nicht ganz, zwar informiert Watchr über den durchgeführten Test, sagt aber nichts darüber aus, ob der Test mit oder ohne Fehler durchgelaufen ist.

Doch die Jungs und Mädels von appbackr scheinen echt pfiffig zu sein, und haben in Growl das richtige Tool gefunden, um den perfekten Workflow aufzusetzen, der aus der Kette Watchr-PHPunit-Growl besteht. Damit können ihre Entwickler sofort sehen, ob der PHP-Unit-Test erfolgreich war  – oder nicht. Und das sogar inklusive einer aussagekräftigen Fehlermeldung. Schade nur, dass Growl ausschließlich Mac-Entwicklern zur Verfügung steht, da es für Mac OS X programmiert wurde.

Und wie das Ganze in der Praxis funktioniert, verrät der Blogbeitrag auch noch. Aber das sollten Sie sich am besten selbst ansehen..

Vor unserem konkreten Beispiel der Hinweis, dass Sie das Intel OpenCL SDK 1.1 in der Beta-Version von dieser Seite kostenlos laden können.

Das Intel OpenCL SDK gibt Ihnen die Möglichkeit, den Assembly-Code Ihres OpenCL-Kernel in Echtzeit zu analysieren und mit Hilfe von Intel VTune Amplifier XE anhand von Sampling-Profiling-Projekten grafisch darzustellen, zu bewerten und zu optimieren.

Den VTune Amplifier können Sie als Standalone-Version kaufen oder innerhalb des Paketes Parallel Studio XE 2011 käuflich erwerben. Zahlreiche Hintergrundberichte zum VTune Amplifier finden Sie selbstverständlich auch in diesem Blog.

Nun aber in medias res:

Ein neues Sampling Profiling Project im Vtune Amplifier einrichten

1. Klicken Sie auf File, dann New und dann Project

2. Im Create a Project-Dialog geben Sie einen Namen ein, und klicken auf Create Project.

3. In den Project Properties wählen Sie die Applikation aus, die Sie testen möchten.

4. Klicken Sie auf Modify, und tragen Sie folgende zwei Zeilen im Bereich User-defined Environment Variables ein:

ENABLE_JITPROFILING=1
CL_CONFIG_USE_VTUNE=True.

5. Bestätigen Sie die neuen Einstellungen in allen offenen Fenstern mit einem Klick auf OK.

6. Klicken Sie auf New Analysis, um die Analyse zu starten.

7. Wählen Sie den passenden Analysis Type aus, und klicken Sie auf Start.

OpenCL Kernel Assembly-Code einsehen

1. Warten Sie, bis das Sampling beendet ist.

2. Klicken Sie auf Hotspots Bottom-up in der Navigationsleiste.

3. Wählen Sie die /Function-Option in der Data Grouping Auswahlbox, und suchen Sie in der Tabellenübersicht nach nach den OpenCL Kernels Ihrer Anwendung.
Hinweis: Wenn Sie unterschiedliche Anwendungen mit identischen OpenCL-Kernel-Namen parallel laufen und testen lassen, wählen Sie die /Process /Function/Thread -Option in der Data Grouping-Auswahlbox und achten auf die Processes-Übersicht. Der betreffende OpenCL wird dann jeweils unter der Applikation aufgeführt.
Doppelklicken Sie dann auf den betreffenden OpenCL-Kernel, um den Source Code und die relevanen Sampling-Information einzusehen.

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…

Hierin beschreibt Asaf Shelly sehr ausführlich, wie sich ein Videoclip mit Standardauflösung in eine HD-Auflösung umwandeln lässt und das Videobild zudem aufgehübscht wird. Es erfordert natürlich eine gewaltige Anstrengung der vorhandenen CPUs, die erforderlichen Berechnungen durchzuführen. Asaf zeigt hierbei, wie sich bestehender Sourcecode lediglich mit Hilfe von Visual Studio 2010, OpenMP und ein, zwei weiteren Handgriffen so optimieren lässt, dass die Rechenzeit für einen einzigen Frame von 57 Sekunden auf 2 Sekunden reduziert werden kann – und das unter Zuhilfenahme von nur zwei und nicht vier Prozessorkernen!

Der erste Schritt besteht darin, innerhalb des VS-2010-Projektes den Schalter “Streaming SIMD Extensions 2″ zu aktivieren. Alleine dies  bewirkt eine Reduzierung der Rechenzeit von 57 auf 15 Sekunden, was fast dem Faktor 4 entspricht! Voraussetzung hierfür ist neben Visual Studio 2010 ein Rechner mit der aktuellen Core-Prozessor-Generation, die auf den Codenamen “Sandy Bridge” hört. Nur dann wird nämlich mit Hilfe des o.a. Schalters optimierter AVX-Code generiert, ohne dass Sie sich als Programmierer darum kümmern müssen.

Im zweiten Schritt wird der Programmcode mithilfe der Headerdatei “emmintrin.h” für intrinsische Funktionen “aktiviert”, Intrinsische Funktionen zeichnen sich dadurch aus, dass prozessorspezifische Operationen in Funktionsaufrufen gekapselt werden können. Dies führt mithilfe einer kleinen Codeanpassung dazu, dass das modifizierte Programm samt AVX-Aktivierung nicht mehr 57, sondern nur noch 3,7 Sekunden für die Berechnung benötigt.

Im dritten und letzten Schritt wird noch einen OpenMP-basierte for-Loop “eingebaut”, was dazu führt, dass derselbe Algorithmus nicht mehr in 57 Sekunden ausgeführt wird, sondern nur noch in 2,2 Sekunden. Darüber hinaus reicht es völlig, den zugehörigen Code auf zwei Prozessorkernen und nicht mehr auf vier ausführen zu lassen. Dies erreichen Sie übrigens mit dem OpenMP-Schalter “omp_set_num_threads(2)”.

Fazit: Mit wenigen Handgriffen lassen sich rechenintensive Algorithmen auf Sandy-Bridge-basierten Rechnern derart beschleunigen, dass anstatt einer Minute nur noch wenige Sekunden für die Berechnung erforderlich sind – und das mit der Hälfte der erforderlichen CPU-Ressourcen! Also, worauf warten Sie noch?

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

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

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

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

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

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

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

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

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

Den Anfang macht der System Analyzer, mit dem sich in Echtzeit analysieren lässt, was während des Gameplays alles passiert. Um das Testsystem von rechenintensiven Aufgaben zu befreien, läuft der System Analyzer auf einem anderen Rechner als das zu testende Spiel. Dabei stehen verschiedene Funktionen wie die CPU-Diagnose, das Ermitteln der Anzahl der Locks per Frame und der Framerate selbst sowie andere wichtige Parameter zur Verfügungung.

Praktisch am System Analyzer sind die vorhandenen Hardware-Diagnose-Tools, mit denen sich auf Intel-Systemen Dinge wie die Auslastung der vorhandenen Execution Units untersuchen lassen. Aber auch bestimmte Ansichten auf die aktuelle Spielszene erlauben das Analysieren des Spiels. So lassen sich beispielsweise mit der Gitterdarstellung verborgene Objekte entdecken, die dort gar nicht hingehören und nur überflüssige Rechenzeit verbraten.

Der Frame Analyzer geht dann richtig in die Tiefe und lässt jedes einzelne Bild eines Spiels analysieren. So kann man anhand der DirectX-Drawcalls feststellen, welche Bereiche eines Frames besonders viel Rechenzeit beanspruchen und diese Bereiche gegebenenfalls optimieren. So zeigen beispielsweise versteckte Objekte hohes Optimierungspotenzial, da sie zum Gameplay nichts beitragen, aber trotzdem Rechenzeit kosten. Um die möglichen “Störenfriede” zu eliminieren, kann man aber auch experimentell vorgehen, indem man einzelne Parameter ausschaltet um zu sehen, wie sich das auf die Szene und die Renderleistung auswirkt.

Das dritte Tool schließlich, Platform View, ist zum einen “neu” in der Version 3.0 von Intel GPA und bietet zum anderen einen detaillierten Blick auf den Parallelisierungsgrad des Spiels. Dabei kann man sich sämtliche Threads anzeigen lassen, die gerade aktiv sind und diese in der Detailansicht genau analysieren. So lässt sich beispielsweise herausfinden, warum die CPU auf die GPU warten muss oder auch anders herum.

Zur Erinnerung: das sogenannte “Damenproblem” stammt aus der Mathematik und beschäftigt sich mit der Frage, wie viele Damen auf einem Schachbrett so aufgebaut werden können, dass sie sich gemäß der Schachregeln nicht gegenseitig schlagen können. Auf einem 8×8-Schachbrett gibt es übrigens 12 eindeutige Lösungen.

Nur, wie lässt sich das für eine größere Zahl n berechnen, und wie geschieht das auf einem Parallelrechner möglichst schnell? Genau damit beschäftigt sich der pdf-Workshop, der sehr anschaulich und anhand vieler Codebeispiele mögliche Ansätze und Konzepte miteinander vergleicht und natürlich auch verrät, welche Lösung die beste ist, wenn man solche Probleme möglichst elegant und parallel lösen möchte.

Der Download ist kostenlos und jedem Einsteiger in die Parallelprogrammierung sehr zu empfehlen.

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.

Sehr hilfreich ist auch das “Verketten” mehrerer Threads, um so bestimmte Abhängigkeiten zu definieren. Hierzu gehört auch die Möglichkeit, Thread zu priorisieren. Darüber hinaus lassen sich NSOperation-Threads mit Rückgabewerten definieren, die während des Programmablaufs dann weiter verwendet werden können.

Grand-Central-Dispatch-API
Neben den NSOperation-Klassen erlaubt die GCD-API das direkte Verwenden der vorhandenen Funktionen. Hierfür kann man entweder eigene Queues erzeugen oder auf die globale Warteschlange zugreifen. Es existieren drei globale Queues, die sich lediglich in ihrer Priorität unterscheiden. Daneben gibt es natürlich auch eine Main Queue, die die Steuerung des Main Threads übernimmt.

Im Gegensatz zu den globalen Queues funktionieren eigene Warteschlange rein seriell, womit sie beispielsweise in Bereichen eingesetzt werden können, die bis dato mit Hilfe von Locks überwacht wurden. Queues werden blockweise gefüllt, der zugehörige Code wird asynchron im Hintergrund ausgeführt. Für eine problemlos Rückkehr zur Main Queue sollte jeder Block eine Callback-Funktion aufweisen, die auf das “Hauptprogramm” verweist. Natürlich lassen sich Queues auch pausieren (suspend) und weiter ausführen (resume).

Weitere wichtige GCD-Techniken
Neben den Klassen und APIs stehen weitere Techniken in GCD zur Verfügung, die man als Entwickler kennen sollte. So ermöglichen beispielsweise Semaphore die bessere Kontrolle bgrenzter Ressourcen. Aber auch Deadlocks lassen sich dank GCD besser vermeiden, Blöcke können zeitlich gesteuert genutzt werden, Systemereignisse lassen sich effizient und einfach überwachen und vieles mehr.

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