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.

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.

In this paper, we introduce CORRELATE, a programming language with an open implementation framework. In principle, CORRELATE exploits the know how of concurrent object-oriented programming languages with high level synchronisation primitives. This is an essential element to support multi-agent systems as the inherent concurrency between the computational agents must be controlled. Another specific element of CORRELATE is its capability to define autonomous operations: we illustrate how these language elements can be used to program reactive and cognitive multi-agent systems. CORRELATE is aimed to be a powerful testbed and development system at the crossroad of many disciplines: generic aspects of agent models and architectures are supported while the open implementation framework, can still be customized to deal with different flavors of agent-oriented programming.

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. CORRELATE is a truly object-based language in that it enforces the application programmer to model an application as a collection of objects that interact by invoking operations on each other. Even though the development of commercial software is more and more dominated by the use of object-oriented technology for obvious reasons (ensuring that development efforts can be paid back in real sales), HPC applications are seldom built using OO language technology because of the potential overhead that is generated by an advanced object support system. The CORRELATE programming system attempts to deliver the best of both worlds by supporting concurrent objects as well as sequential objects. The latter can be implemented efficiently in C++, and concurrent objects simplify the modelling of interactions and synchronisation between high level application objects. These aspects are illustrated by showing two CORRELATE implementations of an application in the area of molecular dynamics. The first example uses a coarse-grained approach in which subspaces of the simulated geometry are modelled as CORRELATE objects — and in that sense, these objects look similar to individual processes in SPMD programs. As an extreme, the second application models each particle as a CORRELATE object.

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.

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.

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.

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.

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 non-functional 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.

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.

In this position paper, we present some problems we face in the development of an integrated software application for broadcast planning. Concretely, we’ll discuss customization and authorization. Our current implementation of both issues suffers from heavy cross-cutting and codetangling. Therefore we would like to present these problems at the ECOOP 2000 workshop on aspect-oriented programming to deepen our understanding and to evaluate whether AOP can help us to build an improved solution.

Middleware has emerged as an important architectural component in supporting distributed applications. However conventional middleware technologies are not able to meet the requirements of a wide range of application domains. This position paper describes an approach based on non-functional policies that allows application-specific reconfiguration of ORBs. Reconfigurability is supported by combining the strengths of component-oriented programming and metaprogramming: an ORB is developed as an adaptable graph of meta-level components. However, the power of these techniques is more than an application programmer can handle, who is typically not an expert in metaprogramming nor ORB development. This problem is solved through a declarative binding between application at the baselevel and ORB implementation at the metalevel. This declarative binding is realized by instantiating application-specific policies that are interpreted by the metaprogram.

This paper gives an overview of the KULRoT 99 team. This team is based on our last year’s team. The major problem we experienced with KULRoT 98 was a slow reaction time. The cause of this problem was related to bad synchronization and an insufficient notion of time. To tackle this problem, we switched to a new architecture that gives each soccer player a better notion of time. Preliminary results already show a large improvement in reaction time. In this position paper, we describe this architecture and briefly mention some plans for future work.

Department of Computer Science, K.U.Leuven

It’s no secret that instantiating frameworks can be a tedious process. In this position paper, we propose our solution to the problem, which consists of providing an application programmer with a language that supports high level abstractions, and automatically instantiating the underlying frameworks based on the code written in that language. Application programmers use only the language, not the underlying frameworks. While this hides the frameworks’ abstractions, we can maintain the open architecture of the frameworks by making the interesting objects from the hidden frameworks available again as meta-objects at the language level. This leads to a system where objects (e.g. pattern participants) live at three different levels of abstraction: the objects that are hidden in the underlying frameworks, the base-level language objects, and the meta-level language objects that are incarnations of the interesting objects from the underlying frameworks.

Department of Computer Science, K.U.Leuven

Correlate is a concurrent object-oriented language that has been used in real-world applications in areas of High- Performance Computing, network applications and multi-agent systems. The practical goal of the language is to offer a powerful programming environment in which both application and system software can be described using the paradigm of concurrent objects. In this paper, the formal description of Correlate in the pi-calculus is discussed. In our experience, such a formalization process is a crucial step in the design process of a practical language, even though not every detail need to be modelled. Several examples illustrate the benefits of our specification especially from the viewpoint of the language designer. Finally it is shown that an operational prototype can be easily constructed by translation from the pi-calculus to Pict.