41957109
End-to-end latency of a fault-tolerant CORBA infrastructure
This paper presents measured probability density functions (pdfs) for the end-to-end latency, of two-way, remote method invocations from a CORBA client to a replicated CORBA server in a fault-tolerance infrastructure. The infrastructure uses a multicast group-communication protocol based on a logical token-passing ring imposed on a single local-area network. The measurements show that the peaks of the pd/s for the latency are affected by the presence of duplicate messages for active replication, and by the position of the primary server replica on the ring for semi-active and passive replication. Because a node cannot broadcast a user message until it receives the token, up to two complete token rotations can contribute to the end-to-end latency seen by the client for synchronous remote method invocations, depending on the server processing time and the interval between two consecutive client invocations. For semi-active and passive replication, careful placement of the primary server replica is necessary to alleviate this broadcast delay to achieve the best possible end-to-end latency. The client invocation patterns and the server processing time must be considered together to determine the most favorable position for the primary replica. Assuming that an effective sending-side duplicate suppression mechanism is implemented, active replication can be more advantageous than semi-active and passive replication because all replicas compete for sending and, therefore, the replica at the most favorable position will have the opportunity to send first.
12760716
Making Web services dependable
Web services offer great promise for integrating and automating software applications within and between enterprises over the Internet. However, ensuring that Web services are dependable, and can satisfy their clients' requests when the clients need them is a real challenge because, typically, a business activity involves multiple Web services and a Web service involves multiple components, each of which must be dependable. In this paper, we describe fault tolerance techniques, including replication, checkpointing, and message logging, in addition to reliable messaging and transaction management for which Web services specifications exist. We discuss how those techniques can be applied to the components of the Web services involved in the business activities to render them dependable.
11584663
Deterministic scheduling for multithreaded replicas
Replication of objects, processes and components is essential for building reliable distributed systems. However, maintaining replica consistency in the presence of nondeterminism is a challenge. There are many sources of nondeterminism in the applications being replicated. In this paper, we focus on the nondeterminism resulting from multithreading in the applications, and present a deterministic scheduling algorithm for ensuring consistent execution of replicated multithreaded applications.
8178704
Unification of transactions and replication in three-tier architectures based on CORBA
In this paper, we describe a software infrastructure that unifies transactions and replication in three-tier architectures and provides data consistency and high availability for enterprise applications. The infrastructure uses transactions based on the CORBA object transaction service to protect the application data in databases on stable storage, using a roll-backward recovery strategy, and replication based on the fault tolerant CORBA standard to protect the middle-tier servers, using a roll-forward recovery strategy. The infrastructure replicates the middle-tier servers to protect the application business logic processing. In addition, it replicates the transaction coordinator, which renders the two-phase commit protocol nonblocking and, thus, avoids potentially long service disruptions caused by failure of the coordinator. The infrastructure handles the interactions between the replicated middle-tier servers and the database servers through replicated gateways that prevent duplicate requests from reaching the database servers. It implements automatic client-side failover mechanisms, which guarantee that clients know the outcome of the requests that they have made, and retries aborted transactions automatically on behalf of the clients.
195350091
Design and implementation of a pluggable fault tolerant CORBA infrastructure
In this paper we present the design and implementation of a Pluggable Fault Tolerant CORBA Infrastructure that provides fault tolerance for CORBA applications by utilizing the pluggable protocols framework that is available for most CORBA ORBS. Our approach does not require modification to the CORBA ORB, and requires only minimal modifications to the application. Moreover; it avoids the difficulty of retrieving and assigning the ORB state, by incorporating the fault tolerance mechanisms into the ORB. The Pluggable Fault Tolerant CORBA Infrastructure achieves performance that is similar to, or better than, that of other Fault Tolerant CORBA systems, while providing strong replica consistency.
8961835
Design and Implementation of a Pluggable Fault-Tolerant CORBA Infrastructure
In this paper we present the design and implementation of a Pluggable Fault-Tolerant CORBA Infrastructure that provides fault tolerance for CORBA applications by utilizing the pluggable protocols framework that most CORBA ORBs provide. Our approach does not require any modification to the CORBA ORB, and requires only minimal modification to the application. Moreover, it avoids the difficulty of retrieving and assigning the ORB state by embedding the fault tolerance mechanisms into the ORB. The Pluggable Fault-Tolerant CORBA Infrastructure exhibits similar or better performance than other Fault-Tolerant CORBA systems, while providing strong replica consistency.
2955672
Grammatically Interpreting Feature Compositions
Abstract : Feature modeling is a popular domain analysis method for describing the commonality and variability among the domain products. The current formalisms of feature modeling do not have enough support for automated domain product configuration and validation. We have developed a theory of feature modeling: a feature model is analogous to a definition of a language; a particular feature composition instance (domain product) is analogous to a program written in that language; and the way the features can be assembled to form a product is analogous to the way various tokens can be assembled to form a program. To apply this theory, we have developed a meta-language Two-Level Grammar++ to specify feature models. The interpreter derived from the feature model specification performs automated product configuration and product quality validation.
9581771
Scalable QoS guaranteed communication services for real-time applications
We propose an approach to flow-unaware admission control which is a combination with an aggregate packet forwarding scheme, improving scalability of networks while guaranteeing end-to-end deadlines for real-time applications. We achieve this by using an off-line delay computation and verification step, which allows to reduce the overhead at admission control while keeping admission probability and resource utilization high. Our evaluation data show that our system's admission probabilities are very close to those of significantly more expensive flow-aware approaches. At the same time, the admission control overhead during flow establishment is very low. Our results therefore support the claim from the DS architecture literature that scalability can be achieved through flow aggregation without sacrificing resource utilization and with significant reduction in run time overhead.
12486961
Guaranteeing Synchronous Message Deadlines with the Timed Token Medium Access Control Protocol
We study the problem of guaranteeing synchronous message deadlines in token ring networks where the timed token medium access control protocol is employed. Synchronous bandwidth, defined as the maximum time for which a node can transmit its synchronous messages every time it receives the token, is a key parameter in the control of synchronous message transmission. To ensure the transmission of synchronous messages before their deadlines, synchronous capacities must be properly allocated to individual nodes. We address the issue of appropriate allocation of the synchronous capacities. Several synchronous bandwidth allocation schemes are analyzed in terms of their ability to satisfy deadline constraints of synchronous messages. We show that an inappropriate allocation of the synchronous capacities could cause message deadlines to be missed, even if the synchronous traffic is extremely low. We propose a scheme, called the normalized proportional allocation scheme, which can guarantee the synchronous message deadlines for synchronous traffic of up to 33% of available utilization. >
6398503
Real-time schedulability of two token ring protocols
When designing real-time communication protocols, the primary objective is to guarantee the deadlines of synchronous messages while sustaining a high aggregate throughput. The authors compare two token ring protocols for their suitability in hard-real-time systems. A priority driven protocol (e.g., IEEE 802.5) allows implementation of a priority based real-time scheduling discipline like the rate monotonic algorithm. A timed token protocol (e.g., FDDI) provides guaranteed bandwidth and bounded access time for synchronous messages. These two protocols are studied by deriving their schedulability criteria, i.e., the conditions which determine whether a given message set can be guaranteed. Using these criteria, the average performance of these protocols is evaluated under different operating conditions. It is observed that neither protocol dominates the other for the entire range of system parameter space. The conclusion is that the priority driven protocol performs better at low bandwidths (1-10 Mb/s) while the timed token protocol has a superior performance at higher bandwidths.<<ETX>>
797656
Automated glue/wrapper code generation in integration of distributed and heterogeneous software components
UniFrame is a framework to help organizations to build interoperable distributed computing systems. Using UniFrame, a new system is built by assembling predeveloped heterogeneous and distributed software components. UniFrame solves the heterogeneity problem by explicitly modeling the domain knowledge of various technology domains (component model domains, programming language domains, operating system platform domains, etc.), from which the interoperation generative domain model (IGDM) straddling the technology domains can be constructed. The glue/wrapper code that realizes the interoperation among the distributed and heterogeneous software components can be generated from the IGDM. An informal implementation in Java of glue/wrapper code generator is given, followed by a discussion on a formalization of IGDM. The formalism comes from the fact that if the family of glue/wrapper code can be modeled formally, an instance glue/wrapper code can be generated automatically. In this formalization, the IGDM is formally modeled as a language definition using a grammar; the code that realizes the interoperation is a valid sentence derivable from the grammar, and will be generated automatically from the IGDM during the assembly time.