The Design and Implementation of Arjuna

Arjuna is an object-oriented programming system implemented entirely in C++, that provides a set of tools for the construction of fault-tolerant distributed applications. Arjuna exploits features found in most object-oriented languages (such as inheritance) and only requires a limited set of system capabilities commonly found in conventional operating systems. Arjuna provides the programmer with classes that implement atomic transations, object level recovery, concurrency control and persistence. These facilities can be overridden by the programmer as the needs of the application dictate. Distribution of an Arjuna application is handled using stub generation techniques that operate on the original C++ class headers normally used by the standard compiler. The system is portable, modular and flexible. The paper presents the design and implementaion details of Arjuna and takes a retrospective look at the system based on the application building experience of users.

[1]  Stuart M. Wheater,et al.  The Design and Implementation of a Framework for Extensible Software , 1995 .

[2]  Santosh K. Shrivastava,et al.  Shadows-a flexible support system for objects in distributed systems , 1993, Proceedings Third International Workshop on Object Orientation in Operating Systems.

[3]  Partha Dasgupta,et al.  Distributed Programming with Objects and Threads in the Clouds System , 1991, Comput. Syst..

[4]  Santosh K. Shrivastava.  Lessons Learned from Building and Using the Arjuna Distributed Programming System , 1994, Dagstuhl Seminar on Distributed Systems.

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

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

[7]  Santosh K. Shrivastava,et al.  The Treatment of Persistent Objects in Arjuna , 1989, Comput. J..

[8]  Graham D. Parrington.  Reliable Distributed Programming in C++: The Arjuna Approach , 1990, C++ Conference.

[9]  Santosh K. Shrivastava,et al.  Exploiting Type Inheritance Facilities to Implement Recoverability in Object Based Systems , 1987, SRDS.

[10]  Santosh K. Shrivastava,et al.  Structuring Fault-Tolerant Object Systems for Modularity in a Distributed Environment , 1994, IEEE Trans. Parallel Distributed Syst..

[11]  Santosh K. Shrivastava,et al.  Replicated K-resilient objects in Arjuna , 1990, [1990] Proceedings. Workshop on the Management of Replicated Data.

[12]  Larry Carter,et al.  Distrbution and Abstract Types in Emerald , 1987, IEEE Transactions on Software Engineering.

[13]  Santosh K. Shrivastava,et al.  Rajdoot: A Remote Procedure Call Mechanism Supporting Orphan Detection and Killing , 1988, IEEE Trans. Software Eng..

[14]  Santosh K. Shrivastava,et al.  An Overview of Arjuna: A Programming System for Reliable Distributed Computing , 1989 .

[15]  Robert J. Stroud.  Transparency and reflection in distributed systems , 1993, OPSR.

[16]  Graham D. Parrington,et al.  Programming Distributed Applications Transparently in C++: Myth or Reality? , 1992 .

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

[18]  Sacha Krakowiak,et al.  Architecture and Implementation of Guide, an Object-Oriented Distributed System , 1991, Comput. Syst..

[19]  Santosh K. Shrivastava,et al.  Architectural support for mobile objects in large scale distributed systems , 1995, Proceedings of International Workshop on Object Orientation in Operating Systems.

[20]  S. K. Shrivastava,et al.  Fault-Tolerant Execution of Computationally and Storage Intensive Parallel Programs Over a Network of Workstations: A Case Study , 1995 .

[21]  Barbara Liskov,et al.  Distributed programming in Argus , 1988, CACM.

[22]  Kenneth P. Birman,et al.  Exploiting virtual synchrony in distributed systems , 1987, SOSP '87.

[23]  Santosh K. Shrivastava,et al.  Exercising application specific run-time control over clustering of objects , 1994, Proceedings of 2nd International Workshop on Configurable Distributed Systems.

[24]  Roy H. Campbell,et al.  Designing and implementing Choices: an object-oriented system in C++ , 1993, CACM.

[25]  Graham D. Parrington.  A Stub Generation System for C++ , 1995, Comput. Syst..

[26]  Santosh K. Shrivastava,et al.  Maintaining information about persistent replicated objects in a distributed system , 1993, [1993] Proceedings. The 13th International Conference on Distributed Computing Systems.

[27]  Luiz Eduardo Buzato,et al.  Stabilis: A Case Study in Writing Fault-Tolerant Distributed Applications Using Persistent Objects , 1992, POS.

[28]  Gregor Kiczales,et al.  Towards a new model of abstraction in software engineering , 1991, Proceedings 1991 International Workshop on Object Orientation in Operating Systems.

[29]  Kenneth P. Birman,et al.  The process group approach to reliable distributed computing , 1992, CACM.