Automatisierte Unit-Tests für PHP-Entwickler leicht gemacht
Ich mag ja amerikanische Überschriften wie “Automated PHP unit testing for lazy coders”. Vor allem dann, wenn die Geschichte hält, was die Headline verspricht. Im konkreten Fall geht es um einen Beitrag, der auf dem appbackr-Blog erschienen ist und den ich Ihnen nicht vorenthalten wollte.
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..
Workshop: VTune Amplifier XE 2011 im Teamwork mit Intel OpenCL SDK 1.1 Beta
Wussten Sie, dass die Intel OpenCL SDK 1.1 Beta und der Intel VTune Amplifier XE 2011 hervorragend zusammenarbeiten, wenn es darum geht, die optimale Perfomance in OpenCL-Anwendungen zu ermitteln und Flaschenhälse zu finden?
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.
Early-Bird-Rabatt für die C++ Advanced Developer Conference
Die ppedv AG veranstaltet am 5. und 6. Mai 2011 die C++ Advanced Developer Conference (ADC). Tagungsort wird das beschauliche Prien am Chiemsee sein.
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:
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…
AVX mit Visual Studio 2010 und OpenMP optimal einsetzen
Dass es israelische Software-Entwickler echt drauf haben, ist ja nichts Neues. So ist es auch nicht erstaunlich, dass ich heute auf einem der Intel Software-Blogs einen exzellenten Beitrag gefunden habe, den ich Ihnen nicht vorenthalten will.
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?
Acht nützliche Tipps zum Parallelisieren
Aufmerksamen Lesern des Software Dev Blogs wird es nicht entgangen sein: es war hier in letzter Zeit ein wenig ruhiger, was mit vielen anderen Aktivitäten meinerseits zu tun hatte. Ich war viel unterwegs, hab viele neue Themen recherchiert und gesammelt, saß mit Leuten zusammen, etc. Und der Output wird sich sehen lassen können: Das reicht von Exklusivinfos direkt vom Intel Developer Forum in San Francisco bis hin zu neuesten Beiträge rund um das Thema Cilk und Co, die ich mit dem Kollgen Deilmann von Intel gemeinsam erarbeiten werde.
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.
Das war die GDCE 2010: Videointerviews und mehr, Teil 3
Sodala, nachdem Teil 1 und Teil 2 der GDCE-2010-Rückschau draußen sind, folgt jetzt das dritte und letzte Kapitel meiner Trilogie in Sachen Spieleentwicklung. Den Abschluss soll ein Dreiteiler bilden (sic!), der sich mit der Analysetool-Suite Intel Graphics Performance Analyzers beschäftigt.
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.
Parallelprogrammieren lernen mit Schach
Der werte Kollege Deilmann von Intel hat mir ein paar Internetlinks zukommen lassen, deren Inhalte sich mit dem Thema Parallelprogrammierung beschäftigen. Ein Beitrag hierzu ist auf den ersten Blick zwar ziemlich oberflächlich, bietet aber auf den zweiten Blick viele nützliche Infos zum Thema Multicore und Multithreading. In Form eines 34-seitigen pdfs wird nämlich das N-Queens-Problem detailliert dargestellt und gezeigt, wie sich dieses per Parallelprogrammierung lösen lässt.
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.
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.
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.
Multicore-Workshop mit Jeffrey Richter parallel zur Basta
Von 21. bis 25. September findet in Mainz die Basta! 2009 statt, eine der größten unabhängigen Entwicklerkonferenzen in diesem Land. Gerne würde ich ja dort hinfahren, um mir die eine oder andere Session anzuhören und darüber zu bloggen. Besonders interessant finde ich natürlich den Multicore-Workshop von Jeffrey Richter, der parallel zur Basta an drei Tagen stattfindet.
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.
