Fachgebiet Programmierung eingebetteter Systeme Fakult¨at IV Elektrotechnik und Informatik Technische Universit¨at Berlin Optimized Aspect Execution Mechanisms inside Virtual Machines for Embedded Systems vorgelegt von Diplom-Informatikerin Christine Hundt Von der Fakult¨at IV { Elektrotechnik und Informatik der Technischen Universit¨at Berlin zur Erlangung des akademischen Grades Doktor der Ingenieurwissenschaften { Dr.-Ing. { genehmigte Dissertation Promotionsausschuss: Vorsitzender: Prof. Dr. Hans-Ulrich Heiß Technische Universit¨at Berlin Berichtende: Prof. Dr. Sabine Glesner Technische Universit¨at Berlin Berichtender: Prof. Dr. Robert Hirschfeld Hasso-Plattner-Institut, Universit¨at Potsdam Tag der wissenschaftlichen Aussprache: 4. November 2011 Berlin 2012 D 83 Abstract The rapidly growing mobile market has stimulated the demand for more and more complex custom applications for embedded mobile devices, for ex- ample, smart phones. To manage this complexity and, at the same time, to keep the time to market small, advanced software engineering methods have to be applied. Aspect-oriented programming (AOP) provides advanced modular- ization and abstraction mechanisms. The main advantages of this concept are improved maintainability, reusability, and extensibility of applications. Fur- thermore, dynamic AOP can be used to implement the dynamic adaptation of mobile device applications to changing contexts, like the location. However, the overhead introduced by the additional abstraction mechanisms limits the applicability to embedded mobile devices because they have limited resources (CPU, memory) compared to desktop PCs. To overcome this problem, we present a set of optimizations that signif- icantly reduce the overhead of common AOP mechanisms and, finally, make AOP applicable for embedded mobile devices. The foundation of our work is a thorough analysis of the overhead that is typically generated by the realization of AOP mechanisms. The key idea of our approach is a deep integration of AOP mechanisms into the virtual machine. To this end, we shift mechanisms like the registration of activated aspects to the level of the JVM. Furthermore, we optimize the execution of AOP programs by introducing caching mecha- nisms and specialized bytecode instructions that are tailored for the execu- tion of AOP mechanisms. Moreover, we analyze AOP-specific semantic code properties in order to develop optimizations that utilize these AOP-specific se- mantic information and that exploit typical AOP usage schemes. In addition to the AOP optimizations, we realize an efficient dynamic aspect deployment mechanism. We apply our optimizations to the Java-based aspect-oriented pro- gramming language ObjectTeams [HHM07] by extending the extremely small and portable JamVM [Lou] Java virtual machine. To evaluate our approach, we execute micro benchmarks, investigate the effect of our optimizations on a real-world application, and finally discuss the transferability of our optimizations to other approaches. Our evaluation shows a considerable performance gain for the aspect activation and the aspect exe- cution of ObjectTeams. In particular, we demonstrate that our optimizations improve the performance of commonly used AOP mechanisms by up to 90%. At the same time, we reduce the code size of the adapted classes, which is also important for small devices. Finally, with our case study, namely the OTPong game application, we show that our approach is capable of significantly opti- mizing the execution time of real-word applications. Our main contribution is a significant reduction of the overhead of high-level AOP constructs, which is also demonstrated by the results of our experiments. The success of the op- timizations provides evidence that advanced high-level abstraction techniques like AOP can be efficiently used in embedded mobile devices. Furthermore, our work shows that efficient dynamic aspect deployment can be supported on the level of the JVM. This substantially enhances the dynamic capabilities of ObjectTeams. Zusammenfassung Der rasant wachsende Mobilger¨atemarkt verlangt nach immer komplexeren Anwendungen fur¨ eingebettete Mobilger¨ate, wie Smartphones. Um diese Kom- plexit¨at beherrschbar zu machen und gleichzeitig die Produktzyklen m¨oglichst kurz zu halten, ist es n¨otig fortgeschrittene Softwareentwicklungsmethoden an- zuwenden. Die aspektorientierte Programmierung (AOP) stellt fortgeschritte- ne Modularisierungs- und Abstraktionsmechanismen zur Verfugung.¨ Die wich- tigsten Vorteile dieses Konzeptes sind die verbesserte Wartbarkeit, Wieder- verwendbarkeit und Erweiterbarkeit von Anwendungen. Daruber¨ hinaus ist dynamische Aspektorientierung dazu geeignet die dynamische Anpassung von mobilen Anwendungen an wechselnde Kontexte, wie z.B. den Standort, zu realisieren. Allerdings schr¨ankt der Overhead, der durch die zus¨atzlichen Ab- straktionsmechanismen entsteht, die Anwendbarkeit auf eingebettete Mobilge- r¨ate ein, da diese im Vergleich zu Desktop PCs beschr¨ankte Ressourcen (CPU, Speicher) aufweisen. Um dieses Problem zu bew¨altigen, pr¨asentieren wir eine Reihe von Opti- mierungen, welche den Overhead von typischen AOP-Mechanismen signifikant reduzieren und damit AOP fur¨ eingebettet Mobilger¨ate anwendbar machen. Die Grundlage unserer Arbeit ist eine grundliche¨ Analyse des Overheads, der typischerweise durch die Realisierung von AOP-Mechanismen entsteht. Die Kernidee unseres Ansatzes ist eine tiefe Integration der AOP-Mechanismen in die virtuelle Maschine. Zu diesem Zweck verschieben wir diese Mechanismen, wie etwa die Registrierung von aktiven Aspekten, auf die Ebene der JVM. Wei- terhin optimieren wir die Ausfuhrung¨ von AOP Programmen durch die Einfuh-¨ rung von Cache-Mechanismen, sowie spezialisierten Bytecode-Instruktionen, die auf die Ausfuhrung¨ von AOP-Mechanismen zugeschnitten sind. Daruber¨ hinaus analysieren wir AOP-spezifische semantische Code-Eigenschaften und entwickeln darauf aufbauend Optimierungen, die sich diese Eigenschaften und typische AOP Benutzungsschemata zunutze machen. Zus¨atzlich zu den AOP- Optimierungen realisieren wir einen effizienten dynamischen Aspekt-Deploy Mechanismus. Wir wenden unsere Optimierungen auf die Java-basierte as- pektorientierte Programmiersprache ObjectTeams [HHM07] an, indem wir die extrem kleine und fur¨ eingebettete Systeme portierte JamVM [Lou] erweitern. Um unseren Ansatz zu evaluieren fuhren¨ wir Mikro-Benchmarks aus und untersuchen den Effekt unserer Optimierungen auf eine echte Anwendung. Un- sere Evaluierung zeigt eine erhebliche Performanz-Steigerung fur¨ die Aspekt- Aktivierung und die Aspekt-Ausfuhrung¨ von ObjectTeams. Unsere Optimie- rungen verbessern die Performanz von h¨aufig verwendeten AOP-Konstrukten um bis zu 90%. Gleichzeitig verringern wir die Code-Gr¨oße adaptierter Klassen, was ebenfalls wichtig ist fur¨ kleine Ger¨ate. Schließlich zeigen wir mit unserer Fallstudie, der Spieleanwendung OTPong, dass unser Ansatz in der Lage ist, die Ausfuhrungszeit¨ von echten Anwendungen signifikant zu optimieren. Unser wichtigster Beitrag ist die signifikante Reduzierung des Overheads von h¨oheren AOP-Konstrukten, die wir durch unserer Experimente untermauern konnten. Der Erfolg der Optimierungen zeigt, dass fortgeschrittene h¨ohere Abstraktions- techniken wie AOP effizient auf eingebetteten Mobilger¨aten verwendet werden k¨onnen. Außerdem zeigt unserer Arbeit, wie effizientes dynamisches Aspekt- Deployment auf der Ebene der JVM umgesetzt werden kann. Dadurch konnten wir die dynamischen F¨ahigkeiten von ObjectTeams maßgeblich erweitern. Danksagung Die vorliegende Arbeit entstand w¨ahrend meiner T¨atigkeit im DFG Aktions- plan Informatik Verifikation und Optimierung bei der Ubersetzung h¨oherer Programmiersprachen, geleitet von Prof. Dr. Sabine Glesner. Bei ihr m¨och- te ich mich herzlich fur¨ die Betreuung meiner Arbeit bedanken und dafur,¨ dass sie mich immer unterstutzt¨ und ermutigt hat. Außerdem danke ich mei- nem Zweitgutachter Prof. Dr. Robert Hirschfeld fur¨ seine Unterstutzung¨ und die konstruktiven Anmerkungen von ihm und seiner Arbeitsgruppe am Hasso- Plattner-Institut Potsdam. Bei meine Kollegen bedanke ich mich herzlich fur¨ die nette Arbeitsatmo- sph¨are und den tollen Promotionsfilm. Stephan Herrmann ist maßgeblich dafur¨ verantwortlich, dass ich den Weg des wissenschaftlichen Arbeitens eingeschla- gen habe. Paula Herber und Lars Alvincz haben mir immer mit Rat und Tat und viel Fr¨ohlichkeit zur Seite gestanden. Außerdem m¨ochte ich meinen Diplo- manden Daniel St¨ohr und Julian Bischof danken, deren Arbeiten zum Erfolg dieser Arbeit beigetragen haben. Schließlich m¨ochte ich meiner Familie dafur¨ danken, dass sie immer fur¨ mich da war und mich unterstutzt¨ hat. Meinen Bruder Andreas danke ich fur¨ die Hilfe beim Cross-Kompilieren. Contents 1 Introduction 13 2 Background 17 2.1 Aspect-oriented Programming................... 17 2.1.1 AOP Mechanisms...................... 18 2.1.2 Aspect Weaving....................... 19 2.1.3 ObjectTeams........................ 21 2.1.4 Dynamic AOP....................... 26 2.2 Java Virtual Machine........................ 28 2.2.1 The JVM Architecture................... 28 2.2.2 Bytecode Interpretation.................. 31 2.2.3 Optimized Bytecode Execution.............. 32 2.2.4 Java for Embedded Systems / Small Platforms...... 38 3 Related Work 41 3.1 Optimization for Aspect-oriented Programming......... 41 3.2 Using High-level Semantic Information for Optimization.... 42 3.3 Dynamic AOP Approaches..................... 43 3.3.1 Dynamic Weaving