Bert Robben

Portable Support for Transparent Thread Migration in Java

In this paper, we present a mechanism to capture and reestablish the state of Java threads. We achieve this by extracting a thread’s execution state from the application code that is executing in this thread. This thread serialization mechanism is implemented by instrumenting the original application code at the byte code level, without modifying the Java Virtual Machine. We describe this thread serialization technique in the context of middleware support for mobile agent technology. We present a simple execution model for agents that guarantees correct thread migration semantics when moving an agent to another location. Our thread serialization mechanism is however generally applicable in other domains as well, such as load balancing and checkpointing.

An AOP Case with Static and Dynamic Aspects

Aspect-oriented-programming (aop) is a promising new approach where the description of a complex system/application is enhanced with various aspects, related to communication properties, distribution, synchronization, etc. All aspects can be described separately and are brought together by using a so-called weaver. Mostly, this is performed at compile-time, what makes that aspects disappear in the final software version. We argue that in some cases aspects should remain run-time entities in order to capture the dynamic properties of an application [MJV97]. We believe there is a need for dynamic aspects, e.g. strongly related to objects, which are clearly run-time entities.

Non-functional Policies

It is well known that a meta-object protocol (MOP) is a powerful mechanism to control the behavior of an application and to implement non-functional requirements such as fault-tolerance and distributed execution. A key feature of these architectures is the strict separation between the application at the base-level and the nonfunctional concerns at the meta-level. This makes it possible to develop generic meta-programs that can be reused for many applications. However, an important difficulty with this approach is the expression of application specific policies with respect to non-functional behavior. In this paper, we show a new approach that solves this problem by clearly separating policy from both application and meta-level. In our approach, policies are expressed at a high-level of abstraction as separate strategies. This results in highly reusable meta-programs that take application specific characteristics into account. We have validated our approach in the Correlate prototype.

Components for Non-Functional Requirements

Building distributed applications is very hard as we not only have to take care of the application semantics, but of non-functional requirements such as distributed execution, security and reliability as well. A component-oriented approach can be a powerful technique to master this complexity, and to manage the development of such applications. In such an approach, each non-functional requirement is realised by a single component. In this extended abstract we describe how the metalevel architecture of Correlate can be used to support such an approach.

Open Implementation of a Mobile Communication System

This extended abstract applies the concept of open implementation. In object-oriented programming an open implementation is often realized by means of a so-called Meta-Object Protocol (MOP). We are using this technique in the scope of the telematica project SMove. This extended abstract presents two cases in which a MOP may be used, namely in device selection logic and in replication protocols.

A Metaobject Protocol for Correlate

Distributed applications are complex software systems that need support for non-functional requirements such as reliability and security. Often these non-functional requirements are mixed with the application semantics resulting in an overly complex system. A promising solution that cleanly separates the application from the non-functional requirements is the use of a language with a metalevel architecture. In this extended abstract, we briefly present the metalevel architecture of Correlate, a concurrent language extension to Java.

On flexible support for mobile objects

CORRELATE is a concurrent object-oriented language with a flexible run time system that enables the instantiation of application specific run time objects. We have exploited this capability in the development of mobile agents for large scale distributed computing systems, such as the Internet. We discuss some key elements of the run time system. We illustrate how the system architecture supports mobile objects, we discuss what it requires from the operating system and how we aim at evolving towards more flexibility.

Flexible load balancing software for parallel applications in a time-sharing environment

Networks of workstations become more and more appropriate for parallel applications. XENOOPS is an advanced environment for parallel software, running on such networks, as well as on multicomputers. The XENOOPS load balancing framework meets the requirements of the regular users of a time-sharing distributed system, and of the HPCN users who prefer to exploit multiple processors as if these processors have been reserved for one particular application. On the one hand, a parallel application can dynamically obtain and effectively exploit workstations as these turn idle. On the other hand, workstation owners transparently claim their device when accessing it on the console. In both cases, the parallel application transparently reorganises itself while maintaining a balanced work load distribution. Consequently, dynamic load balancing also becomes important for regular applications, which would not require dynamic reallocation in a space-sharing system.

Experiences with an Object-Oriented Parallel Language: The CORRELATE Project

The CORRELATE language has been used in the prototyping of multiple HPC applications, ranging from typical scientific simulations to solvers for optimisation problems using cooperative search agents. Moreover, the language has been used in the development of specific subsystems to optimise the execution of a particular application. In the CORRELATE project, the role of the meta-level architecture is crucial as it enables the seamless integration of application objects and system objects. This is a key issue in supporting the development of both application and system objects in a single and comprehensive environment.

Affordable Overhead in CORRELATE: Comparing two MD Simulators

In this paper, we illustrate the way HPC application programs are developed using CORRELATE, a concurrent object-oriented language that supports applications for distributed memory systems. Our programming environment favours HPC applications because CORRELATE is a heterogeneous language that extends C++: on the one hand, CORRELATE objects can be coarse grained entities that exploit the language support because they model the concurrency aspects that are inherent to parallelism. On the other hand, each CORRELATE object can encapsulate C++ entities to implement its behaviour.