The AOSTA Project: Aspects in Operating Systems: Tools and Applications
At the core of a computer system, an operating system (OS) takes care of managing resources, enforcing security policies, optimizing performance and providing a basis for middleware and applications to rely upon. Future computers are not only expected to be increasingly reliable, but also to automatically detect and resolve performance and resource problems, defective or misbehaving hard- and software components and attacks to system integrity and security from the inside (i.e. malicious users or malicious software running on the system) as well as from the outside (e.g. denial-of-service attacks or worms coming in via a network connection). Furthermore, the system should be able to cope with the addition or removal of system components without human interaction.
The autonomic computing initiative defines strategies to realize the following challenges: self-configuration, self-optimization, self-protection and self-healing, each targeting at one of the problems mentioned above. To establish rules for self-organization of a computer system, organic computing tries to cope with the inherent complexity by taking a view of the system as an entity comparable to biological systems whose general mode of operation can be defined by a set of high-level goals. While autonomic computing triies to solve these challenges in a top-down manner by mapping high-level goals into low-level system behaviour, organic computing follows a botton-up approach creating an emergent behaviour to fulfil the high-level goals of a system. Organic system software, in turn, will be able to achieve these goals which can also ultimately be implemented by autonomic computing and related technologies.
Most of the organic and autonomic functionality, however, penetrates several different components of an operating system, resulting in an intricate implementation which may eventually lead to reliability and code maintenance problems, in contrast to the original aims of an organic system. To ease the implementation of these so-called crosscutting concerns (CCCs), aspect oriented programming (AOP) is a novel software development paradigm that provides means to encapsulate code handling the CCCs into a separate level of aspect code, which in turn can be inserted ("woven") into the appropriate locations in the system. The weaving process can take place at compile-time (static AOP) or at runtime (dynamic AOP), each requiring a differing set of tools and techniques.
Our AOSTA (Aspects in Operating Systems: Tools and Applications) research project focuses on creating novel approaches to implementing organic and autonomic computing functionality at the operating system level using static and dynamic aspect-oriented technologies. Topics of research are automatic identification of cross-cutting concerns in operating system kernels, design and continued development of our TOSKANA toolkit which provides dynamic AOP inside the NetBSD kernel, aspect-oriented functionality improvements through the use of microkernel technology, enhanced support for static and dynamic AOP for native machine code in compiler tool chains and low-level virtual machines - especially in non object-oriented contexts - and exploring the general potential of increased dynamic behaviour in operating systems.