The Arjuna Distributed Programming System.

1. The Arjuna Distributed Programming System. Instructor By Dr. Ravi Mukkamala Bharath Bushan R S

2. Outline • Introduction • Objects and Actions • Properties of Atomic Actions • Assumptions • Arjuna System Architecture • Implementation • Arjuna’s use of C++ • Future Work • Conclusion • References

3. Introduction • Arjuna Distributed system based on Objects and actions. • Provides integrated mechanisms • Arjuna provides such mechanisms through C++ classes. • This object oriented approach of Arjuna can be extended for fault tolerate systems

4. Objects and Actions • The objects and actions computational model – widely used for robust distributed systems. • Arjuna system is based on one such model. • Uses nested atomic actions. • Object – Its an instance of some type or class. • Consists variables and operations.

5. Properties of atomic actions • Distributed system – operation on remote object is invoked with RPC call. • Operation invocation controlled by atomic actions. • Serializability - Two phase locking protocol • Failure atomicity • Permanence of effect. • What is commit protocol ? Why needed ?

6. Assumptions • In this system Hardware components are workstations (nodes). • Nodes either work or crash • Node has both stable storage and volatile memory. • What happens after a crash of node ? • Lost, duplicated, corrupted messages - responsibility of communication subsystem

7. Arjuna System Architecture • Objects become active when an operation is invoked on it by a atomic action. • Active till some “A” commits or aborts. • Nested actions. • How does a object gets activated in the Arjuna system ? • Load object state into servers address space. • Discards to deactivate.

8. Architecture .. Contd N1 N2 N4 Object store Object store O1 O2 O3 C1 Volatile Volatile O’1 S1 Volatile O’2 S2 S3 O’4 N3 N5 N6 O’1 S7 S4 C2 O’4 O4 O5 Volatile O’6 O’7 S5 S6 Object store Volatile Volatile O1 O6 O7 Object store Object store

9. Implementation • Operations on objects are invoked with RPC • Server process are created as calls are made to objects • Rajdoot creates these servers. • Used because it has fault tolerance capabilities • Rajdoot is a RPC mechanism for orphan detection and killing. • One example.

10. Implementation ..Contd • Arjuna class hierarchy

11. Implementation ..Contd • Create instances of class AtomicAction to use operations (Begin , Abort, End). • Objects are Arjuna classes or user defined classes from the LockManager. • StateManager is the base class.... Rest are derived • Provides facilities to construct persistent objects and atomic actions • LockManager - (2PL for serializability). • AtomicAction (performs aborts and commits)

12. Implementation ..Contd • AbstractRecord – recovery, concurrency control and persistence of specific objects. • RecoveryRecord – supports state based recovery(Abort). • LockRecord – no restoration but ReleaseLock Operation. • ServerGroupRecord. • To abort action – what happens ??

13. Implementation ..Contd • Create an AtomicAction by declaring an AtomicAtomic instance {invoke by Begin()} AtomicAction A,B A.Begin(); //start of atomic action A B.Begin(); // start of atomic action B B.Abort(); // abortion of B A.End(); // commit of atomic action A. • Nested AtomicActions.

14. Implementation ..Contd • Support for Persistence and recovery…. How ?? • Recoverability – snapshot of objects state. • Persistence – new object state replaces old state held in object storage at commit time. • Object state can be transferred to or from stable storage.

15. Object State Transitions Stable Storage Volatile Storage Read_state activate Restore_state ObjectState passive active Write_state deactivate Save_state ObjectState

16. Arjuna’s use of C++ • Advantages • Uses inheritance and encapsulation. • Ability to overload standard operators. • Disadvantages • Lack of garbage collection of unreferenced objects. • Stub generator places restrictions on class definitions.

17. Future Work • Caching has not yet been implemented • Needs modification with the current LockManager

18. Conclusion • Arjuna followed the objects and actions model. • Object oriented approach of Arjuna can be extended for fault tolerant systems. • Uses the Rajdoot RPC mechanisms to create servers. • All Arjuna classes are derived from the StateManager.

19. References • Santosh K. Srivastava, Graeme N. Dixon, Graham D. Parrington, “An overview of Arjuna Distributed Programming System”. University of newcastle upon tyne. • Graham D. Parington “Reliable Distributed Programming in C++: The Arjuna Approach” • F. Panzieri, S K. Srivastava, “Rajdoot: A Remote Procedure Call Mechanism Supporting Orphan Detection and Killing”.