An efficient and flexible implementation of aspect-oriented languages [Elektronische Ressource] / vorgelegt von Christoph-Matthias Bockisch

Christoph-Matthias Bockisch

Sujets

• Informatik

Informations

• Publié par: technischen_universitat_darmstadt
• Publié le: 01 janvier 2009
• Nombre de lectures: 8
• Langue: English
• Poids de l'ouvrage: 1 Mo

Extrait

An Ecient and Flexible Implementation of
Aspect-Oriented Languages
Vom Fachbereich Informatik der Technischen Universitat Darmstadt genehmigte
Dissertation
zur Erlangung des akademischen Grades eines
Doktor-Ingenieurs (Dr.-Ing.)
vorgelegt von
Diplom-Informatiker Christoph-Matthias Bockisch
geboren in Bielefeld
Referentin: Prof. Dr.-Ing. Mira Mezini
Korreferent: Prof. dr. ir. Mehmet Aksit
Datum der Einreichung: 14. Mai 2008
Datum der mundlichen Prufung: 1. Juli 2008
Erscheinungsjahr 2009
Darmstadt D17Abstract
Compilers for modern object-oriented programming languages generate code
in a platform independent intermediate language [LY99, CLI06] preserv-
ing the concepts of the source language; for example, classes, elds, meth-
ods, and virtual or static dispatch can be directly identied within the in-
termediate code. To execute this intermediate code, state-of-the-art im-
plementations of virtual machines perform just-in-time (JIT) compilation
+[DS84, ACL 99, Ayc03] of the intermediate language; i.e., the virtual in-
structions in the intermediate code are compiled to native machine code at
runtime. In this step, a declarative representation of source language con-
cepts in the intermediate language facilitates highly e cient adaptive and
speculative optimization of the running program which may not be possible
otherwise.
In contrast, constructs of aspect-oriented languages|which improve the
separation of concerns|are commonly realized by compiling them to con-
ventional intermediate language instructions or by driving transformations of
the intermediate code, which is called weaving. This way the aspect-oriented
constructs’ semantics is not preserved in a declarative manner at the inter-
mediate language level. This representational gap between aspect-oriented
concepts in the source code and in the intermediate code hinders high perfor-
mance optimizations and weakens features of software engineering processes
like debugging support or the continuity property of incremental compila-
tion: modifying an aspect in the source code potentially requires re-weaving
multiple other modules [SDR08, RDHN06].
To leverage language implementation techniques for aspect-oriented lan-
guages, this thesis proposes the Aspect-Language Implementation Archi-
tecture (ALIA) which prescribes|amongst others|the existence of an in-
termediate representation preserving the aspect-oriented constructs of the
source program. A central component of this architecture is an extensible
and exible meta-model of aspect-oriented concepts which acts as an inter-
face between front-ends (usually a compiler) and back-ends (usually a vir-
tual machine) of aspect-oriented language implementations. The architecture
iiiand the meta-model are embodied for Java-based aspect-oriented languages
in the Framework for Implementing Aspect Languages (FIAL) respectively
the Language-Independent Aspect Meta-Model (LIAM) which is part of the
framework. FIAL generically implements the work ows required from an ex-
ecution environment when executing aspects provided in terms of LIAM. In
addition to the rst-class intermediate representation of aspect-oriented con-
cepts, ALIA|and the FIAL framework as its incarnation|treat the points
of interaction between aspects and other modules|so-called join points|as
being late-bound to an implementation. In analogy to the object-oriented
terminology for late-bound methods, the join points are called virtual in
ALIA. Together, the rst-class representation of aspect-oriented concepts in
the intermediate representation as well as treating join points as being virtual
facilitate the implementation of new and e ective optimizations for aspect-
oriented programs.
Three dierent instantiations of the FIAL framework are presented in this
thesis, showcasing the feasibility of integrating language back-ends with dif-
ferent characteristics with the framework. One integration supports static as-
pect deployment and produces results similar to conventional aspect weavers;
the woven code is executable on any standard Java virtual machine. Two in-
stantiations are fully dynamic, where one is realized as a portable plug-in for
ALIAstandard Java virtual machines and the other one, calledSteamloom ,
is realized as a deep integration into a specic virtual machine, the Jikes
+Research Virtual Machine [AAB 05]. While the latter instantiation is not
portable, it exhibits an outstanding performance.
Virtual join point dispatch is a generalization of virtual method dis-
patch. Thus, well established and elaborate optimization techniques from
the eld of virtual method dispatch are re-used with slight adaptations in
ALIASteamloom . These optimizations for aspect-oriented concepts go be-
yond the generation of optimal bytecode. Especially strikingly, the power
of such optimizations is shown in this thesis by the examples of the c ow
+dynamic property [ACH 05b], which may be necessary to evaluate during
virtual join point dispatch, and dynamic aspect deployment [MO03]|i.e.,
the selective modi