This article presents the design principles and efficient implementation techniques for ABCL/R3, an object-oriented concurrent reflective language. One of the most distinguished features of ABCL/R3 is compilation techniques using partial evaluation, which effectively remove interpretation from meta-level programs. The meta-level objects are designed so that they can be partially evaluated in an effective manner. Benchmark programs show that our compilation frameworks make object execution drastically faster than interpreter-based implementations, and achieves performance close to nonreflective compilers.

. Customizable meta-objects are a powerful abstraction for extending language features and implementation mechanisms, but interpretive execution suffers from severe performance penalty. Some of this penalty can be reduced by applying partial evaluation to meta- interpreters, but partial evaluation of meta-objects in existing concurrent object-oriented languages is ineffective. This paper proposes a new meta-object design for our reflective language ABCL/R3. It yields metaobjects that can be optimized effectively using partial evaluation. The crux of the design is the separation of state-related operations from other operations, and this separation is accomplished by using reader/writer methods in our concurrent object-oriented language called Schematic. Our benchmark trials show that non-trivial programs with partially evaluated meta-objects run more than six times faster than ones that are interpreted by meta-objects. In addition, a partially evaluated program that uses a customized ...

Parallel and distributed programs often have hardware/problem specific optimizations for improving quality of the program such as efficiency and robustness. Those optimizations, unfortunately, degrade portability and re-usability as they are intertwined with the original algorithm description. Reflective languages, which provide the application programmer extensible and abstract implementation of the language, can describe such optimizations as extensions to the language. The separation of optimization descriptions gains portability and re-usability of both application programs and optimizations. However, the interpretive execution model of reflective languages imposes a large amount of performance overhead, which sometimes outweighs benefits of optimizations. Previous reflective languages prohibit some of operations being modified via reflection, so as to reduce the amount of interpretation overhead. The imperfection of this approach is that it still leaves a considerable amount of overhead, and it yields less flexible, unclear reflective architecture. This dissertation investigates design and compilation framework of meta-interpreters and meta-objects in an object-oriented concurrent language ABCL/R3. By using partial evaluation to compile reflective programs, ABCL/R3 achieves flexible and lucid reflective architecture and efficient execution at the same time. We design full-fledged meta-interpreters by examining several concurrent programming examples. A newly proposed delegation mechanism enables to define modular and scope controlled extensions to meta-interpreters. We design meta-objects by exploiting the notion of reader/writer methods in a concurrent object-oriented language Schematic, so that they can be effectively partially evaluated. The compilation frameworks of meta-interpreters and meta-objects basically translate concurrent object definitions into a sequential program, then apply partial evaluator for a sequential language, and generates a program in a (non-reflective) concurrent object-oriented language, in which base-level and meta-level objects are collapsed to single level objects. The efficiency of generated programs is demonstrated by several benchmark programs, in which our compiler exhibits performance close to non-reflective languages.

Computational reflection gives programming languages high flexibility, which is useful for parallel/distributed programming. On the other hand, its interpreter based execution model makes efficient implementation difficult. Especially, meta-objects in concurrent languages are described with explicit state transition, which makes program reasoning---such as partial evaluation---difficult. In this paper, we propose a new meta-object design, which exploits reader/writer methods in our concurrent object-oriented language Schematic. The crux of the design is separation of state-related operations from others, which allows us to optimize meta-objects using an existing partial evaluator because the most methods in the meta-objects can be regarded as a sequential program. 1 Introduction 1.1 Reflection in Parallel/Distributed Programs Practical parallel and distributed programs often have complicated computation and communication structures for achieving efficiency, fault-tolerance, portabili...