@article {18661,
	title = {AQuA: an adaptive architecture that provides dependable distributed objects},
	journal = {Computers, IEEE Transactions on},
	volume = {52},
	year = {2003},
	month = {2003/01//},
	pages = {31 - 50},
	abstract = {Building dependable distributed systems from commercial off-the-shelf components is of growing practical importance. For both cost and production reasons, there is interest in approaches and architectures that facilitate building such systems. The AQuA architecture is one such approach; its goal is to provide adaptive fault tolerance to CORBA applications by replicating objects. The AQuA architecture allows application programmers to request desired levels of dependability during applications{\textquoteright} runtimes. It provides fault tolerance mechanisms to ensure that a CORBA client can always obtain reliable services, even if the CORBA server object that provides the desired services suffers from crash failures and value faults. AQuA includes a replicated dependability manager that provides dependability management by configuring the system in response to applications{\textquoteright} requests and changes in system resources due to faults. It uses Maestro/Ensemble to provide group communication services. It contains a gateway to intercept standard CORBA IIOP messages to allow any standard CORBA application to use AQuA. It provides different types of replication schemes to forward messages reliably to the remote replicated objects. All of the replication schemes ensure strong, data consistency among replicas. This paper describes the AQuA architecture and presents, in detail, the active replication pass-first scheme. In addition, the interface to the dependability manager and the design of the dependability manager replication are also described. Finally, we describe performance measurements that were conducted for the active replication pass-first scheme, and we present results from our study of fault detection, recovery, and blocking times.},
	keywords = {active replication pass-first scheme, adaptive architecture, adaptive fault tolerance, AQuA, CORBA, data consistency, data integrity, dependable distributed objects, distributed object management, performance measurements, quality of service, replicated dependability manager, replication schemes, software fault tolerance, system resources},
	isbn = {0018-9340},
	doi = {10.1109/TC.2003.1159752},
	author = {Ren,Yansong and Bakken,D. E. and Courtney,T. and Michel Cukier and Karr,D. A. and Rubel,P. and Sabnis,C. and Sanders,W. H. and Schantz,R.E. and Seri,M.}
}
@conference {18651,
	title = {An adaptive framework for tunable consistency and timeliness using replication},
	year = {2002},
	month = {2002///},
	pages = {17 - 26},
	abstract = {One well-known challenge in using replication to service multiple clients concurrently is that of delivering a timely and consistent response to the clients. In this paper, we address this problem in the context of client applications that have specific temporal and consistency requirements. These applications can tolerate a certain degree of relaxed consistency, in exchange for better response time. We propose a flexible QoS model that allows these clients to specify their temporal and consistency constraints. In order to select replicas to serve these clients, we need to control of the inconsistency of the replicas, so that we have a large enough pool of replicas with the appropriate state to meet a client{\textquoteright}s timeliness, consistency, and dependability requirements. We describe an adaptive framework that uses lazy update propagation to control the replica inconsistency and employs a probabilistic approach to select replicas dynamically to service a client, based on its QoS specification. The probabilistic approach predicts the ability of a replica to meet a client{\textquoteright}s QoS specification by using the performance history collected by monitoring the replicas at runtime. We conclude with experimental results based on our implementation.},
	keywords = {adaptive framework, concurrent multiple client service, consistency requirements, dependability requirements, distributed object management, flexible QoS model, lazy update propagation, performance history, probabilistic approach, Protocols, quality of service, replication, temporal requirements, timely consistent response, tunable consistency, tunable timeliness},
	doi = {10.1109/DSN.2002.1028882},
	author = {Krishnamurthy, S. and Sanders,W. H. and Michel Cukier}
}
@conference {18683,
	title = {Passive replication schemes in AQuA},
	year = {2002},
	month = {2002/12//},
	pages = {125 - 130},
	abstract = {Building large-scale distributed object-oriented systems that provide multidimensional quality of service (QoS) in terms of fault tolerance, scalability, and performance is challenging. In order to meet this challenge, we need an architecture that can ensure that applications{\textquoteright} requirements can be met while providing reusable technologies and software solutions. This paper describes techniques, based on the AQuA architecture, that enhance the applications{\textquoteright} dependability and scalability by introducing two types of group members and a novel passive replication scheme. In addition, we describe how to make the management structure itself dependable by using the passive replication scheme. Finally, we provide performance measurements for the passive replication scheme.},
	keywords = {AQuA architecture, distributed object management, Fault tolerance, group members, large-scale distributed object-oriented systems, management structure, multidimensional quality of service, passive replication scheme, performance measurements, reusable technologies, scalability, software fault tolerance, software performance evaluation, software reusability, software solutions},
	doi = {10.1109/PRDC.2002.1185628},
	author = {Ren,Yansong and Rubel,P. and Seri,M. and Michel Cukier and Sanders,W. H. and Courtney,T.}
}
@conference {18684,
	title = {Performance evaluation of a probabilistic replica selection algorithm},
	year = {2002},
	month = {2002///},
	pages = {119 - 127},
	abstract = {When executing time-sensitive distributed applications, a middleware that provides dependability and timeliness is faced with the important problem of preventing timing failures both under normal conditions and when the quality of service is degraded due to replica failures and transient overload on the server. To address this problem, we have designed a probabilistic model-based replica selection algorithm that allows a middleware to choose a set of replicas to service a client based on their ability to meet a client{\textquoteright}s timeliness requirements. This selection is done based on the prediction made by a probabilistic model that uses the performance history of replicas as inputs. In this paper, we describe the experiments we have conducted to evaluate the ability of this dynamic selection algorithm to meet a client{\textquoteright}s timing requirements, and compare it with that of a static and round-robin selection scheme under different scenarios},
	keywords = {client-server systems, Dependability, distributed object management, dynamic selection algorithm, Middleware, probabilistic model, probabilistic model-based replica selection algorithm, probability, quality of service, real-time systems, replica failures, round-robin selection scheme, static scheme, time-sensitive distributed applications, timeliness, timing failures, transient overload},
	doi = {10.1109/WORDS.2002.1000044},
	author = {Krishnamurthy, S. and Sanders,W. H. and Michel Cukier}
}
@conference {18685,
	title = {Performance evaluation of a QoS-aware framework for providing tunable consistency and timeliness},
	year = {2002},
	month = {2002///},
	pages = {214 - 223},
	abstract = {Strong replica consistency models ensure that the data delivered by a replica always includes the latest updates, although this may result in poor response times. On the other hand, weak replica consistency models provide quicker access to information, but do not usually provide guarantees about the degree of staleness in the data they deliver. In order to support emerging distributed applications that are characterized by high concurrency demands, an increasing shift towards dynamic content, and timely delivery, we need quality of service models that allow us to explore the intermediate space between these two extreme approaches to replica consistency. Further, for better support of time-sensitive applications that can tolerate relaxed consistency in exchange for better responsiveness, we need to understand how the desired level of consistency affects the timeliness of a response. The QoS model we have developed to realize these objectives considers both timeliness and consistency, and treats consistency along two dimensions: order and staleness. We evaluate experimentally the framework we have developed to study the timeliness/consistency tradeoffs for replicated services and present experimental results that compare these tradeoffs in the context of sequential and FIFO ordering.},
	keywords = {client-server systems, Computer networks, CORBA-based middleware, distributed applications, distributed object management, Network servers, QoS, quality of service, replica consistency, replicated services, server replicas, timeliness},
	doi = {10.1109/IWQoS.2002.1006589},
	author = {Krishnamurthy, S. and Sanders,W. H. and Michel Cukier}
}
@article {18650,
	title = {An adaptive algorithm for tolerating value faults and crash failures},
	journal = {Parallel and Distributed Systems, IEEE Transactions on},
	volume = {12},
	year = {2001},
	month = {2001/02//},
	pages = {173 - 192},
	abstract = {The AQuA architecture provides adaptive fault tolerance to CORBA applications by replicating objects and providing a high-level method that an application can use to specify its desired level of dependability. This paper presents the algorithms that AQUA uses, when an application{\textquoteright}s dependability requirements can change at runtime, to tolerate both value faults in applications and crash failures simultaneously. In particular, we provide an active replication communication scheme that maintains data consistency among replicas, detects crash failures, collates the messages generated by replicated objects, and delivers the result of each vote. We also present an adaptive majority voting algorithm that enables the correct ongoing vote while both the number of replicas and the majority size dynamically change. Together, these two algorithms form the basis of the mechanism for tolerating and recovering from value faults and crash failures in AQuA},
	keywords = {active replication communication, adaptive algorithm, adaptive fault tolerance, adaptive majority voting algorithm, AQuA architecture, client-server systems, CORBA, crash failures, data consistency, data integrity, Dependability, distributed object management, fault tolerant computing, objects replication, value faults},
	isbn = {1045-9219},
	doi = {10.1109/71.910872},
	author = {Ren,Yansong and Michel Cukier and Sanders,W. H.}
}
@conference {18647,
	title = {A dynamic replica selection algorithm for tolerating timing faults},
	year = {2001},
	month = {2001/07//},
	pages = {107 - 116},
	abstract = {Server replication is commonly used to improve the fault tolerance and response time of distributed services. An important problem when executing time-critical applications in a replicated environment is that of preventing timing failures by dynamically selecting the replicas that can satisfy a client{\textquoteright}s timing requirement, even when the quality of service is degraded due to replica failures and excess load on the server. We describe the approach we have used to solve this problem in AQuA, a CORBA-based middleware that transparently replicates objects across a local area network. The approach we use estimates a replica{\textquoteright}s response time distribution based on performance measurements regularly broadcast by the replica. An online model uses these measurements to predict the probability with which a replica can prevent a timing failure for a client. A selection algorithm then uses this prediction to choose a subset of replicas that can together meet the client{\textquoteright}s timing constraints with at least the probability requested by the client. We conclude with experimental results based on our implementation.},
	keywords = {AQuA, client, client-server systems, CORBA-based middleware, distributed object management, distributed services, dynamic replica selection algorithm, fault tolerant computing, local area network, Local area networks, quality of service, replica failures, response time, server replication, time-critical applications, timing failures, timing fault tolerance},
	doi = {10.1109/DSN.2001.941397},
	author = {Krishnamurthy, S. and Sanders,W. H. and Michel Cukier}
}
@conference {18666,
	title = {Building dependable distributed applications using AQUA},
	year = {1999},
	month = {1999///},
	pages = {189 - 196},
	abstract = {Building dependable distributed systems using ad hoc methods is a challenging task. Without proper support, an application programmer must face the daunting requirement of having to provide fault tolerance at the application level, in addition to dealing with the complexities of the distributed application itself. This approach requires a deep knowledge of fault tolerance on the part of the application designer, and has a high implementation cost. What is needed is a systematic approach to providing dependability to distributed applications. Proteus, part of the AQuA architecture, fills this need and provides facilities to make a standard distributed CORBA application dependable, with minimal changes to an application. Furthermore, it permits applications to specify, either directly or via the Quality Objects (QuO) infrastructure, the level of dependability they expect of a remote object, and will attempt to configure the system to achieve the requested dependability level. Our previous papers have focused on the architecture and implementation of Proteus. This paper describes how to construct dependable applications using the AQuA architecture, by describing the interface that a programmer is presented with and the graphical monitoring facilities that it provides},
	keywords = {ad hoc methods, application programmer, AQuA, complexities, computational complexity, dependable distributed applications, distributed CORBA application, distributed object management, Fault tolerance, fault tolerant computing, proteus},
	doi = {10.1109/HASE.1999.809494},
	author = {Ren,J. and Michel Cukier and Rubel,P. and Sanders,W. H. and Bakken,D. E. and Karr,D. A.}
}
@conference {18689,
	title = {Proteus: a flexible infrastructure to implement adaptive fault tolerance in AQuA},
	year = {1999},
	month = {1999/11//},
	pages = {149 - 168},
	abstract = {Building dependable distributed systems from commercial off-the-shelf components is of growing practical importance. For both cost and production reasons, there is interest in approaches and architectures that facilitate building such systems. The AQuA architecture is one such approach; its goal is to provide adaptive fault tolerance to CORBA applications by replicating objects, providing a high-level method for applications to specify their desired dependability, and providing a dependability manager that attempts to reconfigure a system at runtime so that dependability requests are satisfied. This paper describes how dependability is provided in AQuA. In particular it describes Proteus, the part of AQuA that dynamically manages replicated distributed objects to make them dependable. Given a dependability request, Proteus chooses a fault tolerance approach and reconfigures the system to try to meet the request. The infrastructure of Proteus is described in this paper, along with its use in implementing active replication and a simple dependability policy},
	keywords = {adaptive fault tolerance, AQuA, commercial off-the-shelf components, CORBA applications, cost, dependable distributed systems, distributed object management, object replication, proteus, reconfigurable architectures, Runtime, Software architecture, software fault tolerance},
	doi = {10.1109/DCFTS.1999.814294},
	author = {Sabnis,C. and Michel Cukier and Ren,J. and Rubel,P. and Sanders,W. H. and Bakken,D. E. and Karr,D.}
}
@conference {18662,
	title = {AQuA: an adaptive architecture that provides dependable distributed objects},
	booktitle = {Seventeenth IEEE Symposium on Reliable Distributed Systems},
	year = {1998},
	month = {1998/10//},
	pages = {245 - 253},
	abstract = {Dependable distributed systems are difficult to build. This is particularly true if they have dependability requirements that change during the execution of an application, and are built with commercial off-the-shelf hardware. In that case, fault tolerance must be achieved using middleware software, and mechanisms must be provided to communicate the dependability requirements of a distributed application to the system and to adapt the system{\textquoteright}s configuration to try to achieve the desired dependability. The AQuA architecture allows distributed applications to request a desired level of availability using the Quality Objects (QuO) framework and includes a dependability manager that attempts to meet requested availability levels by configuring the system in response to outside requests and changes in system resources due to faults. The AQuA architecture uses the QuO runtime to process and invoke availability requests, the Proteus dependability manager to configure the system in response to faults and availability requests, and the Ensemble protocol stack to provide group communication services. Furthermore, a CORBA interface is provided to application objects using the AQuA gateway. The gateway provides a mechanism to translate between process-level communication, as supported by Ensemble, and IIOP messages, understood by Object Request Brokers. Both active and passive replication are supported, and the replication type to use is chosen based on the performance and dependability requirements of particular distributed applications},
	keywords = {adaptive architecture, AQuA, availability requests, client-server systems, commercial off-the-shelf hardware, CORBA, dependability manager, dependability requirements, dependable distributed objects, distributed object management, Ensemble protocol stack, Fault tolerance, group communication services, middleware software, Object Request Brokers, process-level communication, proteus, Quality Objects, replication, software fault tolerance, Software quality},
	doi = {10.1109/RELDIS.1998.740506},
	author = {Cukier, Michel and Ren,J. and Sabnis,C. and Henke,D. and Pistole,J. and Sanders,W. H. and Bakken,D. E. and Berman,M.E. and Karr,D. A. and Schantz,R.E.}
}
