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.

[1]  Robert J. Stroud,et al.  Implementing fault tolerant applications using reflective object-oriented programming , 1995, Twenty-Fifth International Symposium on Fault-Tolerant Computing. Digest of Papers.

[2]  Gregor Kiczales,et al.  Separation of concerns and operating systems for highly heterogeneous distributed computing , 1994, EW 6.

[3]  André Schiper,et al.  Uniform reliable multicast in a virtually synchronous environment , 1993, [1993] Proceedings. The 13th International Conference on Distributed Computing Systems.

[4]  Tim Menzies,et al.  "C++ is Better Than Smalltalk"?? , 1993, TOOLS.

[5]  Bradford B. Glade,et al.  The Horus System , 1993 .

[6]  Alan Borning,et al.  Multiple Inheritance in Smalltalk-BO , 1982, AAAI.

[7]  Takashi Masuda,et al.  Designing an Extensible Distributed Language with a Meta-Level Architecture , 1993, ECOOP.

[8]  Marc Shapiro,et al.  FOG/C++: A Fragmented Object Generator , 1990, C++ Conference.

[9]  Marc Shapiro,et al.  SOS: An Object-Oriented Operating System - Assessment and Perspectives , 1989, Comput. Syst..

[10]  Silvano Maffeis.  A Flexible System Design to Support Object-Groups and Object-Oriented Distributed Programming , 1993, ECOOP Workshop.

[11]  Rachid Guerraoui,et al.  Programmation d'une application distribuée résistante aux pannes avec l'environnement GARF , 1994 .

[12]  Flaviu Cristian,et al.  Understanding fault-tolerant distributed systems , 1991, CACM.

[13]  I. Bey,et al.  Delta-4: A Generic Architecture for Dependable Distributed Computing , 1991, Research Reports ESPRIT.

[14]  Rachid Guerraoui,et al.  Transaction Model vs. Virtual Synchrony Model: Bridging the Gap , 1994, Dagstuhl Seminar on Distributed Systems.

[15]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[16]  Yair Amir,et al.  Transis: A Communication Sub-system for High Availability , 1992 .

[17]  Ralph E. Johnson,et al.  Reflective facilities in Smalltalk-80 , 1989, OOPSLA '89.

[18]  Paul L. McCullough.  Transparent forwarding: First steps , 1987, OOPSLA '87.

[19]  Stijn Bijnens,et al.  A Reflective Invocation Scheme to Realise Advanced Object Management , 1993, ECOOP Workshop.

[20]  Rachid Guerraoui,et al.  Distributed Programming in GARF , 1993, ECOOP Workshop.

[21]  Kenneth P. Birman,et al.  Exploiting replication in distributed systems , 1990 .

[22]  Geoffrey A. Pascoe.  Encapsulators: A New Software Paradigm in Smalltalk-80 , 1986, OOPSLA.

[23]  Maurice Herlihy,et al.  Inheritance of synchronization and recovery properties in Avalon/C++ , 1988, Computer.

[24]  Jean-Pierre Briot,et al.  Actalk: A Testbed for Classifying and Designing Actor Languages in the Smalltalk-80 Environment , 1989, ECOOP.

[25]  Kenneth P. Birman,et al.  Understanding partitions and the 'no partition' assumption , 1993, 1993 4th Workshop on Future Trends of Distributed Computing Systems.

[26]  Andrew P. Black,et al.  Encapsulating Plurality , 1993, ECOOP.

[27]  Shivakant Mishra,et al.  Implementing fault-tolerant replicated objects using Psync , 1989, Proceedings of the Eighth Symposium on Reliable Distributed Systems.

[28]  Santosh K. Shrivastava,et al.  Object Replication in Arjuna , 1994 .

[29]  P. Verissimo,et al.  Replicated object management using group technology , 1993, 1993 4th Workshop on Future Trends of Distributed Computing Systems.

[30]  Rachid Guerraoui,et al.  Abstractions pour la Programmation Concurrente dans GARF , 1994 .

[31]  Dale Skeen,et al.  The Information Bus: an architecture for extensible distributed systems , 1994, SOSP '93.