Stijn Bijnens

A Reflective Invocation Scheme to Realise Advanced Object Management

The integration of the notion of distribution in an object-oriented language not only introduces a need for location independent object invocation but also has to cope with various object management operations. These meta-operations include object migration, object replication and granularity control. Additionally, in a multithreaded environment, the concurrency control specifications defined on an object by the application programmer must be realised correctly. Our object invocation scheme offers mechanisms for realising these management operations and concurrency control transparently. This scheme-based on reference objectsis generic in the sense that it can be extented to realise some additional object management operations currently not supported by our prototype. This prototype is realised in a C++ environment on various distributed memory platforms.

Language Constructs for Coordination in an Agent Space

This paper describes an open language framework based on concurrent object-oriented programming. In this computational model, autonomous active objects are used to specify interacting agents. Many researchers have indicated the suitability of concurrent object-oriented programming as a base for multi-agent languages [Pog94][Sho93], but we claim that powerful coordination constructs are needed to achieve better expressive power in the language. Our language framework supports two kinds of semantics for coordination in the agent space: Sender-initiated coordination by means of pattern-based group communication. Receiver-initiated coordination by means of multi-object synchronisation constraints.

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.

Sender-Initated and Receiver-Initated Coordination in a Global Object Space

This paper features a case study of a complex parallel application (in the area of Molecular Dynamics Simulation) modelled in a concurrent object-oriented language. In this computational model, application objects can exhibit some autonomous behaviour and reside in a global object space. At runtime, this object space can physically be mapped onto a distributed memory machine.

Massively parallel programming using object parallelism

We introduce the concept of object parallelism. Object parallelism offers a unified model in comparison with traditional parallelisation techniques such as data parallelism and algorithmic parallelism. In addition, two fundamental advantages of the object-oriented approach are exploited. First, the abstraction level of object parallelism is application-oriented, ie., it hides the details of the underlying parallel architecture. Thus, the portability of parallel applications is inherent and program development can occur on monoprocessor systems. Secondly, the concept of specialisation (through inheritance) enables the integration of the given application code with advanced run time support for load balancing and fault tolerance.<<ETX>>

A reusable load balancer for parallel search problems

Abstract In this paper, we describe the design and implementation of a reusable load balancer for parallelsearch problems. Parallel search problems are a significant research topic in the parallel processing area: these applications expose irregularities that require dynamic load balancing techniques. Software for dynamic load balancing should be reusable. Our load balancer can be developed independently from the application -and thus be replaced and reused- as it does not directly interact with the application itself. Our prototype implementation runs on a transputer system; we used different load balancing strategies: sender-initiated, receiver-initiated and symmetrically-initiated. The modularity of our load balancer is illustrated by the fact that we could easily replace the load balancer by different alternatives and compare the performance results.

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.

Object-Oriented Simulation Software for Drug Design

In this paper, we report on the design and implementation of a parallel object-oriented implementation of a protein simulation application, which is the heart of a drug design software package, to be exploited at Novo Nordisk Research Labs on a large cluster of workstations.