Arjuna(ID:2907/arj001)

Arjuna - object-oriented programming system: tools for building fault-tolerant distributed applications; provides nested atomic actions for structuring application programs systems in taking the approach that every major entity in the system is an object.  

Thus, Arjuna not only supports an object-oriented model of computation, but its internal structure is also object-oriented.  This approach permits the use of the type inheritance mechanism of object-oriented systems for incorporating the properties of fault-tolerance and distribution in a very flexible way, permitting the implementation of concurrency control and recovery for objects in a type specific manner.
  Arjuna has been implemented without any  changes to the underlying operating system (Sun Unix, HP-UX), making it quite portable.  The Arjuna System software is available for research purposes.


Structures:
References:
  • Dixon, G.N., Parrington, G.D., Shrivastava, S.K. and Wheater, S.M. "The Treatment of Persistent Objects in Arjuna" CS-TR: 283, Department of Computing Science, University of Newcastle, 1989 view details Abstract: Arjuna is a programming system which provides a set of tools for constructing fault-tolerant distributed applications. It supports an object-oriented model of computation in which atomic actions (atomic transations) control sequences of operations invoked upon persistent objects. Persistent objects outlive the applications that create them and this paper concentrates on the mechanisms within Arjuna that are concerned with their management. The paper describes how these mechanisms are related to the other Arjuna mechanisms required by atomic actions for the distribution, concurrency control, recovery and commitment of persistent objects.
    External link: Online copy
  • Shrivastava, S.K., Dixon, G.N., Parrington, G.D., Hedayati, F., Wheater, S.M. and Little, M.C. "The Design and Implementation of Arjuna" CS-TR: 280, Department of Computing Science, University of Newcastle, 1989 view details
  • Parrington, G.D. "Reliable Distributed Programming in C++: The Arjuna Approach" CS-TR: 308, Department of Computing Science, University of Newcastle, 1990 view details Abstract: Programming in a distributed system is fraught with potential difficulties caused, in part, by the physical distribution of the system itself. By making the distributed of the system transparent it is hoped that the task becomes comparable with that of programming a more traditional centralised system. Object-orientated programming systems are natural starting points for such an attempt due to the inherent modularisation and encapsulation properties they possess. Arjuna is one such system, programmed in C++, which permits the construction of reliable distributed applications in a relatively transparent manner. Objects in Arjuna can be located anywhere in the distributed system and are accessed as if they were purely local to the application. The use of remote procedure calls to perform the actual accesses is hidden by the use of stub generation techniques which operate on the original C++ class descriptions thus furthering the illusion of transparency. Reliablilty is achieved through the provision of traditional atomic transaction mechanisms implemented using only standard language features. External link: Online copy
  • Little, M.C. and Shrivastava, S.K. "Replicated K-Resilient Objects in Arjuna" CS-TR: 319, Department of Computing Science, University of Newcastle, 1991 view details Abstract: This paper describes the design of an object replication scheme for the Arjuna distributed system. The design supports K-resiliency, where, in the absence of network partitions, K out of a total of K+1 replica failures can be tolerated before an object becomes unavailable. The scheme chosen employs active replication where each and every functioning replica of an object carries out processing. Computations are structured as atomic actions (atomic transactions). The paper presents the details of how object groups are created and terminated, how a group can be invoked and object replicas inserted and removed in a consistent manner in the presence of node failures.

    External link: Online copy
    Resources