Priya Narasimhan

Replica consistency of CORBA objects in partitionable distributed systems

The Eternal system enhances the CORBA standard to provide fault tolerance within distributed systems that are susceptible to network partitioning. Fault tolerance is achieved through consistent replication of both client and server objects. Objects may be actively or passively replicated, and replicated objects of both types may coexist. Nested operations involving both active and passive objects are accommodated. Suppression of duplicate operations is ensured by unique message and operation identifiers. Continued operation is allowed in all components of a partitioned network. State transfer mechanisms and fulfilment operations restore the consistency of the states of the replicas when communication is re-established and the components remerge.

A fault tolerance framework for CORBA

We describe a fault tolerance framework for CORBA that provides fault tolerance management and core services, implemented above the ORB for ease of use and customization, and fault tolerance mechanisms, implemented beneath the ORB for transparency and efficiency. Strong replica consistency is facilitated by a multicast engine that provides reliable totally ordered delivery of multicast messages to the replicas of an object. Transparency to the application allows application programmers to focus on their applications rather than on fault tolerance, and transparency to the ORE allows existing commercial CORBA ORBs to be used without modification. The fault tolerance framework adheres to CORBAs objective of interoperability by ensuring that different implementations of the specifications of the framework can interoperate and that non-fault-tolerant objects can interwork with fault-tolerant objects.

Providing support for survivable CORBA applications with the Immune system

The Immune system aims to provide survivability to CORBA applications, enabling them to continue to operate despite malicious attacks, accidents or faults. Every object within the CORBA application is actively replicated by the Immune system, with majority voting applied on incoming invocations and responses to each replica of the object. Secure multicast protocols are employed to enable the majority voting to be effective, even when processors within the network and objects within the application become corrupted.

Strong replica consistency for fault-tolerant CORBA applications

The Eternal system provides transparent fault tolerance for CORBA applications, without requiring modifications to the application or to the object request broker (ORB), and without requiring special skills of the CORBA application programmers. Eternal maintains strong replica consistency as replicas of objects perform operations, and even as they fail and are recovered. Eternal implements the new fault-tolerant CORBA standard.

Eternal: fault tolerance and live upgrades for distributed object systems

The Eternal system supports distributed object applications that must operate continuously, without interruption of service, despite faults and despite upgrades to the hardware and the software. Based on the CORBA distributed object computing standard, the Eternal system replicates objects, invisibly and consistently, so that if one replica of an object fails, or is being upgraded, another replica is still available to provide continuous service. Through the use of interceptors, Eternal renders the object replication transparent to the application and also to the CORBA ORE. Consequently, Eternal is able to provide fault tolerance, and live hardware and software upgrades, for existing unmodified CORBA application programs, using unmodified commercial-off-the-shelf ORBs.

Realize: resource management for soft real-time distributed systems

The Realize system simplifies the development of complex applications by separating the application programming from the management of resources for soft real-time CORBA applications, and from the replication of CORBA objects to provide high availability and fault tolerance. Realize uses totally ordered multicast messages to maintain consistency of the states of the object replicas, and adjusts the degree of replication dynamically as resource availability changes. By measuring the usage of the resources and by monitoring the behavior of application objects, Realize allocates objects to processors and migrates objects between processors to balance the load on the processors. Realize employs a least-laxity scheduling strategy that meets soft real-time deadlines for tasks operating across multiple processors. Thus, with Realize, the difficult issues of distribution, real-time scheduling, load balancing, replication, consistency, and fault detection and recovery are hidden from the application programmer.

The Realize middleware for replication and resource management

The Realize middleware manages the resources of CORBA distributed systems for soft real-time applications, and replicates CORBA objects to provide high availability and fault tolerance. By measuring the usage of the resources and by monitoring the behavior of the application, Realize allocates the objects to the processors and schedules the tasks in order to balance the load and to meet soft real-time deadlines. By using totally ordered multicast messages, Realize maintains the consistency of the replicas of the objects. The difficult issues of distribution, real-time scheduling, replication, consistency, and fault detection and recovery are handled by Realize and are hidden from the application programmer.

Message packing as a performance enhancement strategy with application to the Totem protocols

Packing a number of messages into a single packet for transmission can be used as a strategy to improve the performance of communication protocols. We investigate this technique and its application to the Totem reliable ordered multicast protocols. The mechanism underlying message packing is also analyzed by means of a buffer model with exponential message lengths and exponential interarrival times between messages. The results obtained from the analysis and from the implementation of this strategy in the Totem protocols show that message packing is a very effective technique for improving the performance, especially for messages of small length.

Gateways for accessing fault tolerance domains

Enterprise applications can be structured as domains, where each domain contains objects that are replicated for fault tolerance, with the replication being managed by a fault tolerance infrastructure local to the domain. Gateways can allow unreplicated clients to benefit from the fault tolerance services of the replicated servers, without compromising replica consistency within the fault tolerance domain. For CORBA-based enterprise applications, the gateway mechanisms can be implemented transparently to the ORB and to the application using interception; specific enhancements to existing ORBs make it possible for unreplicated clients to enjoy a higher degree of reliability.

Object-oriented programming of complex fault-tolerant real-time systems

The challenge is to build, on top of standard operating systems, complex fault tolerant real time systems that operate fast enough to meet real time deadlines even under fault conditions, using an approach that simplifies the application programming. The Realize system, being developed at the University of California, Santa Barbara, aims to meet that challenge.