K. R. Mazouni

System support for object groups

This paper draws several observations from our experiences in building support for object groups. These observations actually go beyond our experiences and may apply to many other developments of object based distributed systems.Our first experience aimed at building support for Smalltalk object replication using the Isis process group toolkit. It was quite easy to achieve group transparency but we were confronted with a strong mismatch between the rigidity of the process group model and the flexible nature of object interactions. Consequently, we decided to build our own object oriented protocol framework, specifically dedicated to support object groups (instead of using a process group toolkit). We built our framework in such a way that basic distributed protocols, such as failure detection and multicasts, are considered as first class entities, directly accessible to the programmers. To achieve flexible and dynamic protocol composition, we had to go beyond inheritance and objectify distributed algorithms.Our second experience consisted in building a CORBA service aimed at managing group of objects written on different languages and running on different platforms. This experience revealed a mismatch between the asynchrony of group protocols and the synchrony of standard CORBA interaction mechanisms, which limited the portability of our CORBA object group service. We restricted the impact of this mismatch by encapsulating asynchrony issues inside a specific messaging sub-service.We dissect the cost of object group transparency in our various implementations, and we point out the recurrent sources of overheads, namely message indirection, marshaling/unmarshaling and strong consistency.

Implementation of the GARF replicated objects platform

This paper presents the design and implementation of the GARF system, an object-oriented platform that helps programming fault-tolerant distributed applications in a modular way. The originality of GARF is to separate a distributed object into several objects, the complexity of distribution and fault-tolerance being encapsulated in reusable classes. The use of those classes by the GARF system is based on a run-time mechanism of invocation redirection, where most other systems use inheritance, a compile-time mechanism. Our runtime, which supports the GARF object model, is written in Smalltalk. It is presented in detail, as well as the reusable classes that support fault-tolerance. Fault-tolerant objects are implemented using groups of replicated objects. Our Dependable Object Toolkit provides group management facilities at the object level. Object groups are built on top of the Isis toolkit, which provides group management facilities at the Unix process level. Our mapping of object groups on process groups and our interfacing of Smalltalk and Isis are detailed. Performance analysis and a first evaluation of our prototype are also presented.

Garf: a tool for programming reliable distributed applications

The authors discuss Garf object-oriented tool that supports the design and programming of reliable distributed applications. Garf lets developers program an application and then replicate its critical components over several machines. Using a built-in library of distributed abstractions, developers can choose a replication strategy for each component of the application.

Filtering duplicated invocations using symmetric proxies

Invocation is the communication paradigm of objects. It is asymmetric by definition: the invoker initiates the invocation whereas the invokee reacts to it. A proxy is a local representative of the invokee on the invokers machine. Like the invocation, the proxy notion is asymmetric. However, when replicated objects are considered, there is a need for symmetric proxies: a regular proxy plus an invoker proxy on the invokees machine. This paper shows that symmetric proxies are needed to implement pre-filtering of duplicated invocations. It defines both the duplicated invocation problem and the pre-filtering approach as an efficient solution. The paper presents an object model based on symmetric proxies. Finally, the implementation of the model in the GARF system is presented as well as similar works in the literature.<<ETX>>

Experiences with object group systems

The GARF, Bast, and OGS systems represent the resulting efforts of a multi‐year ‘object group’ program at the Swiss Federal Institute of Technology in Lausanne. The intent of the program was to understand the extent to which one could build flexible and performance system supports to encapsulate object plurality. That is, we experimented with various ways to build libraries and services to support object groups in a distributed setting. This paper summarizes the main steps of the efforts and draws some conclusions about the successes and failures of our approaches. Copyright

The GARF library of DSM consistency models

GARF is an object-oriented system intended to support high level and modular programming of reliable distributed applications. GARF provides a distributed shared memory abstraction, but does not enforce any particular consistency criterion. GARF rather offers an extensible library of consistency criteria. The programmer can bind a specific criterion to each object, according to its use and semantics. This flexible approach enables to increase availability of objects of which behaviors do not require strong consistency guarantees.

Lessons from Designing and Implementing GARF

GARF is an object oriented system aimed to support the design and the programming of reliable distributed applications on top of a network of workstations. The specificity of GARF resides in its incremental programming model, and its extensible library of generic components. In this paper, we first give an overview of GARF. Then we assess its features with respect to its programming model, its abstraction library, and the implementation of its prototype. We finally present the perspectives of future design and implementation.

Visual programming of fault-tolerant distributed applications

The design of fault-tolerant distributed applications is a complex task. In addition to application functionalities, the programmer must consider issues related to both replication and distribution for every application component concerned with fault-tolerance. This paper describes an approach which combines two environments (SystemSpecs and GARF) so as to: graphically design applications using high level Petri nets; and discharge the programmer of fault-tolerance issues.