Session Chair

Rodger Lea trained at Lancaster University in the UK, where he was part of the Distributed Systems Research Group. He has spent time at Chorus Systems in Paris and HP's European Labs in Bristol. The main focus of his work is in the design and development of distributed systems. Until recently that work has concentrated on the development of distributed operating systems based on the object oriented model and utilising micro-kernel technology. Recently he has been exploring how to use such a platform to support cooperative working using shared tools and multi-media in a shared distributed 3D virtual environment.

F. Hauck, U. Becker, M. Geier, E. Meier, U. Rastofer and M. Steckmeier
Friedrich-Alexander University of Erlangen-Nürnberg, Germany

Download paper in postscript (103k) or gzip compressed postscript (28k).

Presented by Uwe Ratofer

The motivation for this project is that CORBA has fixed semantics. Clients want to influence functional and non-functional properties of a distributed object, e.g. local caching, worst case execution time, object migration. The project refers to a group of closely related properties such as this as an aspect. The Aspect IX approach adopts a fragmeted partitioned object model. In this model each object has two parts: an interface and a fragment implementation. Aspects are configured using a local get_aspect method. An example of this was given: a client sets local execution time; if it supported by local object it sets the parameter; if the local object does not support the parameter then an attempt is made to get another aspect and execute it - if none is available then an exception is raised. Aspect IX is CORBA compliant so it can still model stub servers and, in addition, clients can dynamically configure aspects. Applications for the approach are wide area distributed systems, mobile agents and process control. The current status of the project is that a Java implementation has been commenced.

T. Kramp and R. Koster
University of Kaiserslautern, Germany

Download paper in postscript (335k) or gzip compressed postscript (71k).

Presented by Thorsten Kramp

In current middleware implementations resource management is usually hidden or not present. If it is, there are usually built in policies meaning "one size fits all" semantics. Secondly, internal resource usage is unpredictable. What we are looking for is flexibility, modularity and predictability. There was further discussion of QoS parameters and QoS negotiation. As a way to achieve service level location transparency, smart proxies were introduced and their characteristics presented. Smart proxies are server provided code, loaded dynamically at run time to establish end-to-end control. This may even provide a mechanism for standardising high level service interfaces as well as providing location transparency. The QoS supporting object oriented middleware "Squirrel" architecture was described. The project has currently implemented a network protocol with bounded message latencies, clock synchronisation, open real-time threads and the loading of smart proxies. Future project work will include: employing a network server to ease portability; specifying the interface to the application-specific QoS manager with sample CSCW applications; and investigating the benefits real-time operating systems have to offer in respect of QoS supporting middleware.

It was questioned what happened if there was a clash between protocols and the scheduler, ie: how you could avoid overloading the server with multiple proxies. Thorsten's answer was that only a selected set of proxies is implemented for limited hardware diversity.

P. McDaniel, P. Honeyman and A. Prakash
University of Michigan, USA

Download paper in postscript (4307k) or gzip compressed postscript (125k).

P. Murray, R. Fleming, P. Harry and P. Vickers
Hewlett Packard Labs, UK

Download paper in postscript (529k) or gzip compressed postscript (149k).

Presented by Paul Murray

Somersault is an active replication software library. A discusion of replication efficiency was presented. In the model an input message passes to a replica which passes it to a second replica and this second replica performs the output. The use of replicas increases latencies from 0.83 to 1.53 milliseconds. This 50%+ increase is accounted for by an extra hop. Similar throughput is achieved, e.g. 4800 versus 5100 requests per second. Typically throughput is as good in non-replicated as replicated environments. The architecture provides fast failover but there is no rollback. The relationship between CORBA and Somersault is that Somersault is integrated below the ORB as an alternative transport. Only replicated objects are affected by its introduction: non-determinism must be made explicit. State transfer for recovery purposes and state serialisation were discussed. A key feature is that unreplicated objects are completely unaware of Somersault, so legacy code can interact with existing systems.

There were a few questions. Firstly, Somersault's mechanism for replication implies the need a perfect failure detector? The answer was that pnly two replicas were necessary. Next, if a client sets up a connection to a replica, how does the reply get back to client? Paul replied that Somersault provides the transport and multiple TCP connections are set up underneath the Somersault layer. Finally, it was questioned that if there is only one duplicate is there any way of further replication. The reply was, yes, the current implementation can do it. However it is not actually done because the current client does not need it.

C. Peter and F. Puntigam
TU Vienna, Austria

Download paper in postscript (392k) or gzip compressed postscript (75k).

Presented by Christof Peter

The paper discusses the problem regarding messages that are correct but not understood because they arrive at the wrong time. The goal is to intercept messages before they arrive. The concept of process types which specify a constant set of messages signatures was introduced. These have a variable state and the constraints placed on message sequence depends on the state. An illustration showing type splitting in a client server architecture was given. Integrating Process Types in CORBA can be achieved through extensions to the IDL to allow the identification of tokens. This involves extending message signatures with "require" and "ensure" clauses and extending type parameters with states. A typical definition was shown and discussed.

A member of the floor asked how a client and service class can be coordinated when tokens go back to client? Christof explained that the tokens know from IDL extension what state change is required. Another question how archiving os achieved in code example. The reply was that this is achieved through another extension but it's not appropriate to elaborate further at this time.

T. Preuß, J.-H. Syrbe and H. König
Brandenburg University of Technology at Cottbus, Germany

Download paper in postscript (938k) or gzip compressed postscript (339k).

Presented by Thomas Preuß

Open service markets involve service supplier relations and virtual private resources. A diagram showing open service markets was shown. A diagram of customer supplier relations was shown. The architecture of VPR was shown to consist of VPR user, VPR proxy, VPR customer, VPR server and VPR service manager. The conclusions to be drawn are that the implemented VPR server components can establish relations between customers and suppliers, guaranteeing service provision and service properties. A prototype implementation is underway. In the future, a generic implementation will be carried out with QoS enforcement.

One question was asked: Could you give an example of what applications are supported? Thomas's answer was virtual enterprises doing business on the internet through use of services with guarantees.

P.-G. Raverdy and R. Lea
Sony Computer Science Lab and Sony Distributed Systems Lab, Japan

Download paper in postscript (845k) or gzip compressed postscript (108k).

Presented by Pierre Raverdy

Adaptive methods can be implemented in several ways. A diagram showing run time components was presented. The adaptation manager registers adaptive objects, configures them and permits modification of objects. Adaptation events have been identified. The DART compiler model has been built and is used to build all the glue code for adaptive methods. The distribution library allows replication of meta objects and partial objects. There are two complementary adaptation mechanisms and fine grain adaptation is supported. Adaptation management allows interoperation between libraries and application. Dynamicity allows dynamic loading of new meta-objects

Gordon Blair asked that since there are two mechanisms for adaptation in DART which was prefered? Pierre replied that it depends on the application.

L. Sacks, M. Verdier, O. Prnjat, M. Loryman, M. Wittig, M. Kande, B. Bushan, S. Mazaher, D. Maillot, C. Autant and N. Ganivet
University College London, UK / GMD Fokus, Germany / Norwegian Computing Center, Norway / Telis, France / Alcatel ISR, France

Download paper in postscript (727k) or gzip compressed postscript (94k).

Presented by Ognjet Prnjat

Trumpet is an ACTS project. The background to the project is the liberalisation of the telecommunications market, introducing new bearer services and the need for technogical innovation and internetworking. The project is investigating security and integrity issues in the open network market. The project has adopted the TMN architecture model, the ODP methodology and the use of UML notation. A value added service provider was described and a diagram of a public network architecture shown. A trial implementation of the architecture has been built.

One brief question asked how is security supported? The answer was through a policy based on GSS/SSI.

I. Welch and R. Stroud
University of Newcastle-upon-Tyne, UK

Download paper in postscript (839k) or gzip compressed postscript (238k).

Presented by Ian Welch

Reuse of third party components means ensuring they meet additional non-functional requirements. This is problematic because requirements vary according to run time environments. Adaptation can be achieved through wrappers. It is desirable that one-time wrapping of class objects be achieved, rather than performing object by object wrapping. A prototype that automates the construction and application of wrappers has been implemented in Java. Some diagrams showing adaptation of classes at run time on the fly were presented. Further diagrams of a thin client system and a reflective class loader were shown. System evaluation has been carried out and futher work will be focus on improvements to the system.

A member of the floor commented that this was reminiscent of binary component adaptation implemented elsewhere. Is this the case? Ian said it is similar, but we use different aspects. The implementation is not at the byte code level. In a way the system is similar to open C++. Another question was how do we deal with objects holding references to instances of the same class? Couldn't this result in wrapped, wrapped meta classes? Ian replied that this problem was solved by conflation.