A quantitative analysis of aspects in the eCos kernel

Nearly ten years after its first presentation and five years after its first application to operating systems, the suitability of Aspect-Oriented Programming (AOP) for the development of operating system kernels is still highly in dispute. While the AOP advocacy emphasizes the benefits of AOP towards better configurability and maintainability of system software, most kernel developers express a sound skepticism regarding the thereby induced runtime and memory costs: Operating system kernels have to be lean and efficient.We have analyzed the runtime and memory costs of aspects in general, on the level of μ-benchmarks, and by refactoring and extending the eCos operating system kernel using AspectC++, an AOP extension to the C++ language. Our results show that most AOP features do not induce a intrinsic overhead and that the actual overhead induced by AspectC++ is very low. We have also analyzed a test case with significant aspect-related costs. This example shows how the structure of the underlying kernel can have a negative impact on aspect implementations and how these costs can be avoided by an aspect-aware design.Based on this analysis, our conclusion is that AOP is suitable for the development of operating system kernels and other kinds of highly efficient infrastructure software.

[1]  Wolfgang Schröder-Preikschat,et al.  On the Configuration of Non-Functional Properties in Operating System Product Lines , 2005 .

[2]  Jörgen Hansson,et al.  Application-tailored database systems: a case of aspects in an embedded database , 2004, Proceedings. International Database Engineering and Applications Symposium, 2004. IDEAS '04..

[3]  Oege de Moor,et al.  Measuring the dynamic behaviour of AspectJ programs , 2004, OOPSLA.

[4]  Hans-Arno Jacobsen,et al.  Quantifying aspects in middleware platforms , 2003, AOSD '03.

[5]  Gregor Kiczales,et al.  Using aspectC to improve the modularity of path-specific customization in operating system code , 2001, ESEC/FSE-9.

[6]  Danilo Beuche,et al.  The PURE family of object-oriented operating systems for deeply embedded systems , 1999, Proceedings 2nd IEEE International Symposium on Object-Oriented Real-Time Distributed Computing (ISORC'99) (Cat. No.99-61702).

[7]  Bernd Freisleben,et al.  Supporting autonomic computing functionality via dynamic operating system kernel aspects , 2005, AOSD '05.

[8]  Robert Grimm,et al.  Patch (1) Considered Harmful , 2005, HotOS.

[9]  Michael Haupt,et al.  Micro-measurements for Dynamic Aspect-Oriented Systems , 2004, Net.ObjectDays.

[10]  Tzilla Elrad,et al.  Aspect-oriented programming: Introduction , 2001, CACM.

[11]  Ron Cytron,et al.  Footprint and feature management using aspect-oriented programming techniques , 2002, LCTES/SCOPES '02.

[12]  Ondrej Lhoták,et al.  Optimising aspectJ , 2005, PLDI '05.

[13]  Julia L. Lawall,et al.  Web cache prefetching as an aspect: towards a dynamic-weaving based solution , 2003, AOSD '03.

[14]  Olaf Spinczyk,et al.  Advances in AOP with AspectC++ , 2005, SoMeT.

[15]  Daniel Mahrenholz,et al.  An Aspect-Oriented Implementation of Interrupt Synchronization in the PURE Operating System Family∗ , 2002 .

[16]  William G. Griswold,et al.  An Overview of AspectJ , 2001, ECOOP.

[17]  Mario Südholt,et al.  An expressive aspect language for system applications with Arachne , 2005, AOSD '05.

[18]  Julia L. Lawall,et al.  On the automatic evolution of an OS kernel using temporal logic and AOP , 2003, 18th IEEE International Conference on Automated Software Engineering, 2003. Proceedings..

[19]  Mik Kersten,et al.  Mylar: a degree-of-interest model for IDEs , 2005, AOSD '05.

[20]  Wolfgang Schröder-Preikschat,et al.  Static and Dynamic Weaving in System Software with AspectC++ , 2006, Proceedings of the 39th Annual Hawaii International Conference on System Sciences (HICSS'06).

[21]  Gregor Kiczales,et al.  Aspect-oriented programming , 2001, ESEC/FSE-9.

[22]  Robert E. Filman,et al.  What Is Aspect-Oriented Programming , 2001 .

[23]  Danilo Beuche,et al.  On architecture transparency in operating systems , 2000, EW 9.

[24]  Stephen R. Schach,et al.  Categorization of common coupling and its application to the maintainability of the Linux kernel , 2004, IEEE Transactions on Software Engineering.

[25]  Adrian M. Colyer,et al.  Using AspectJ for component integration in middleware , 2003, OOPSLA '03.

[26]  Gregor Kiczales,et al.  Back to the future: a retroactive study of aspect evolution in operating system code , 2003, AOSD '03.

[27]  Olaf Spinczyk,et al.  Using AOP to develop architectural-neutral operating system components , 2004, EW 11.

[28]  Karel Driesen,et al.  The direct cost of virtual function calls in C++ , 1996, OOPSLA '96.

[29]  Gregor Kiczales,et al.  Discussing aspects of AOP , 2001, CACM.

[30]  John R. Gurd,et al.  Using AspectJ to separate concerns in parallel scientific Java code , 2004, AOSD '04.

[31]  Olaf Spinczyk,et al.  Architecture-Neutral Operating System Components , 2003 .