The widespread use of clusters and web farms has increased the importance of data replication. In this paper, we show how to implement consistent and scalable data replication at the middleware level. We do this by combining transactional concurrency control with group communication primitives. The paper presents different replication protocols, argues their correctness, describes their implementation as part of a generic middleware tool, and proves their feasibility with an extensive performance evaluation. The solution proposed is well suited for a variety of applications including web farms and distributed object platforms.

... this article, we analyze several quorum types in order to better understand their behavior in practice. The results obtained challenge many of the assumptions behind quorum based replication. Our evaluation indicates that the conventional read-one/write-all-available approach is the best choice for a large range of applications requiring data replication. We believe this is an important result for anybody developing code for computing clusters as the read-one/write-all-available strategy is much simpler to implement and more flexible than quorum-based approaches. In this article, we show that, in addition, it is also the best choice using a number of other selection criteria

Abstract. Dynamically adaptive systems sense their environment and adjust themselves to accommodate to changes in order to maximize performance. Depending on the type of change (e.g., modifications of the load, the type of workload, the available resources, the client distribution, etc.), different adjustments have to be made. Coordinating them is already difficult in a centralized system. Doing so in the currently prevalent component-based distributed systems is even more challenging. In this paper, we present an adaptive distributed middleware for data replication that is able to adjust to changes in the amount of load submitted to the different replicas and to the type of workload submitted. Its novelty lies in combining load-balancing techniques with feedback driven adjustments of multiprogramming levels (number of transactions that are allowed to execute concurrently). An extensive performance analysis shows that the proposed adaptive replication solution can provide high throughput, good scalability, and low response times for changing loads and workloads with little overhead. 1

Abstract. Replication has been widely used in J2EE servers for reliability and scalability. There are two properties which are important for a stateful J2EE application server. Firstly, the state of the server and the state of the backend databases should always be consistent. Secondly, each request from a client should be executed exactly once. In this paper, we propose a replication algorithm that provides both properties. We use passive replication where a primary server executes a request, and all state changed within the application server by this request is sent to the backup replicas at the end of the execution. An agreement protocol guarantees the consistency between the state of all replicas and the database. A client side communication stub automatically resubmits requests in case of failures, and unnecessary resubmissions are detected by the server replicas. We have implemented the algorithm and integrated it into the JBoss application server. A performance study using the ECPerf benchmark shows the feasibility of our approach.

The increasingly widespread use of cluster architectures has resulted in many new application scenarios for data replication. While data replication is, in principle, a well understood problem, recovery of replicated systems has not yet received enough attention. In the case of clusters, recovery procedures are particularly important since they have to keep a high level of availability even during recovery. In fact, recovery is part of the normal operations of any cluster as the cluster is expected to continue working while sites leave or join the system. The question is then how to optimize recovery so that it can be done without redundancies (that would affect the performance) and with minimal disruptions to normal operations. In this paper, we identify different performance and availability problems that are caused by recovery and propose an online recovery protocol to overcome them.

Abstract — If an off-the-shelf software product exhibits poor dependability due to design faults, software fault tolerance is often the only way available to users and system integrators to alleviate the problem. Thanks to low acquisition costs, even using multiple versions of software in a parallel architecture, a scheme formerly reserved for few and highly critical applications, may become viable for many applications. We have studied the potential dependability gains from these solutions for off-theshelf database servers. We based the study on the bug reports available for four off-the-shelf SQL servers, plus later releases of two of them. We found that many of these faults cause systematic, noncrash failures, a category ignored by most studies and standard implementations of fault tolerance for databases. Our observations suggest that diverse redundancy would be effective for tolerating design faults in this category of products. Only in very few cases would demands that triggered a bug in one server cause failures in another one, and there were no coincident failures in more than two of the servers. Use of different releases of the same product would also tolerate a significant fraction of the faults. We report our results and discuss their implications, the architectural options available for exploiting them and the difficulties that they may present.

this paper, we try to point out the possible causes of the lack of success of some optimistic protocols, and show which directions can be taken to overcome these shortcomings in order to diminish the existing reluctance in industry for this kind of protocols. We think that optimistic protocols will play a crucial role in the upcoming widearea distributed systems. Despite that bandwidth will grow more and more, latency will always be a problem in WANs due to physical limitations...

Abstract. Recent proposals have shown that middleware based database replication is able to provide 1-copy-serializability in LAN environments with excellent performance. This can be achieved by using powerful and fast multicast primitives that deliver messages to all sites in the same order in an all-or-nothing fashion. The question is whether a similar approach is feasible in WAN environments considering the increased message latency. Some of the approaches used in LANs might also work in WANs but others will be prohibitive. We have performed extensive tests of different protocols in a WAN testbed, in order to identify the most crucial bottlenecks, and the most promising optimizations. The performance results show that performance remains acceptable even for medium sized systems consisting of up to eight sites. As such, we believe that data replication guaranteeing 1-copy-serializability is a serious alternative to weaker approaches even in WAN environments.

Middleware platforms are becoming very popular among system developers. Due to its popularity, there is an increasing demand for dependable middleware support. In the past few years several research efforts have concentrated in augmenting the dependability of middleware infrastructures which have led to the definition of the FT-Corba specification. Active replication is one of the main techniques that have been used to achieve some of the required dependability attributes such as high-availability. This kind of replication requires deterministic replicas to behave as a state machine what has been traditionally achieved by restricting replicas to be single-threaded. Unfortunately, single-threading results too restrictive for middleware servers, especially transactional ones, where it is not admissible to process requests sequentially. In this paper, we show how it is possible to remove this restriction. We present a deterministic scheduling algorithm for multithreaded replicas in a transactional framework.

Abstract not found