We examine the task of concurrently computing alternative solutions to a problem. We restrict our interest to the case where only one of the solutions is needed; in this case we need some rule for selecting between the solutions. We use ‘‘fastest first’’, where the first successful alternative is selected. For problems where the required execution time is unpredictable, such as database queries, this method can show substantial execution time performance increases. These increases are dependent on the mean execution time of the alternatives, the fastest execution time, and the overhead involved in concurrent computation. Among the problems with exploring multiple alternatives inparallel are side-effects and combinatorial explosion in the amount of state which must be preserved. These are solved by process management and an application of ‘‘copy-on-write’’ virtual memory management. The side effects resulting from interprocess communication are handled by a specialized message layer which interacts with process management. In order to test the utility of the design, we show how it can be applied to two application areas, distributed execution of recovery blocks and OR-parallelism in Prolog. 1.

Atomic commitment is one of the key functionalities of modern information systems. Conventional distributed databases, transaction processing monitors, or distributed object platforms are examples of complex systems built around atomic commitment. The vast majority of such products implement atomic commitment using some variation of 2 Phase Commit (2PC) although 2PC may block under certain conditions. The alternative would be to use non-blocking protocols but these are seen as too heavy and slow. In this paper we propose a non-blocking distributed commit protocol that exhibits the same latency as 2PC. The protocol combines several ideas (optimism and replication) to implement a scalable solution that can be used in a wide range of applications.

Large-scale distributed storage systems have gained popularity for storing and processing ever increasing amount of data. Replication mechanisms are often key to achieving high availability and high throughput in such systems. Research on fundamental problems such as consensus has laid out a solid foundation for replication protocols. Yet, both the architectural design and engineering issues of practical replication mechanisms remain an art. This paper describes our experience in designing and implementing replication for commonly used log-based storage systems. We advocate a general replication framework that is simple, practical, and strongly consistent. We show that the framework is flexible enough to accommodate a variety of different design choices that we explore. Using a prototype system called PacificA, we implemented three different replication strategies, all using the same replication framework. The paper reports detailed performance evaluation results, especially on system behavior during failure, reconciliation, and recovery. 1.

Massively multiplayer online games (MMOs) have emerged as an exciting new class of applications for database technology. MMOs simulate long-lived, interactive virtual worlds, which proceed by applying updates in frames or ticks, typically at 30 or 60 Hz. In order to sustain the resulting high update rates of such games, game state is kept entirely in main memory by the game servers. Nevertheless, durability in MMOs is usually achieved by a standard DBMS implementing ARIES-style recovery. This architecture limits scalability, forcing MMO developers to either invest in high-end hardware or to over-partition their virtual worlds. In this paper, we evaluate the applicability of existing checkpoint recovery techniques developed for main-memory DBMS to MMO workloads. Our thorough experimental evaluation uses a detailed simulation model fed with update traces generated synthetically and from a prototype game server. Based on our results, we recommend MMO developers to adopt a copy-on-update scheme with a double-backup disk organization to checkpoint game state. This scheme outperforms alternatives in terms of the latency introduced in the game as well the time necessary to recover after a crash. 1.

This repon has been submitted for publication outs~de o vl and will probably be cooyrtghted if accepted for publicatlo has been issued as a Research Report for early dissemcnation of its contents. In view of the transfer of copyright to the outside publisner, its distrtbution outside of ISM orlor ro oublication mould be limited to oeer communications and soecjfic requesrs. After outside publication, requests should be filled only by reprints or legally obtained copies of the art~cle ie.g., payment of rovalt~esl. LIMITED DISTRIBUTION NOTICE This report has been submitted for publication eleewhen and hae been issued as a Research Report for early diseemination of its contents. As a courteey to the intended publisher, it should not be widely distributed until after the date of outeide publication. Copies may be requested from:

Abstract. The challenge of building consistent, available, and scalable data management systems capable of serving petabytes of data for millions of users has confronted the data management research community as well as large internet enterprises. Current proposed solutions to scalable data management, driven primarily by prevalent application requirements, limit consistent access to only the granularity of single objects, rows, or keys, thereby trading off consistency for high scalability and availability. But the growing popularity of “cloud computing”, the resulting shift of a large number of internet applications to the cloud, and the quest towards providing data management services in the cloud, has opened up the challenge for designing data management systems that provide consistency guarantees at a granularity larger than single rows and keys. In this paper, we analyze the design choices that allowed modern scalable data management systems to achieve orders of magnitude higher levels of scalability compared to traditional databases. With this understanding, we highlight some design principles for systems providing scalable and consistent data management as a service in the cloud. 1

Abstract not found

Abstract: Pervasive healthcare is an emerging discipline, where mobile embedded systems are increasingly used to support transactions. Such systems entail a range of heterogeneous entities- both the embedded devices and the networks connecting them. While these systems are exposed to frequent and varied perturbations, the support of atomic distributed transactions is still a fundamental requirement to achieve consistent decisions. Guaranteeing atomicity and high performance in traditional fixed wired networks is based on the assumption that faults like node and link failures occur rarely. This assumption is not supported in current and future mobile healthcare embedded systems where the heterogeneity and mobility often result in link and node failures as a dominant operational scenario. In this paper we summarize our work to provide for atomic commit protocols for mobile environments where consistency can not be compromised, for example healthcare systems. We present the implementation and experimental evaluation of a commit protocol showing its suitability for healthcare environments.

Transactional business processes require a high degree of reliability in order to guarantee consistent results. In case of failure, participants must take the necessary actions to leave the process in a globally-correct state. Conventional Web services, however, frequently lack essential reliability features. Based on the Web Services Transactions specifications, we present a framework that provides fault tolerance to the services involved in a transactional business process, leveraging techniques in logical logging and application recovery. In contrast to current implementations, it aims to minimize the impact on existing applications with regards to

Modern computing and networking hardware makethe physical interconnection of manymachines simple. However, programming an application to takeevenlimited advantage of the interconnection is notoriously difficult due to the complexity of the protocols involved. Furthermore, real world demands insist that such applications need to be programmed in an existing, preferably widely available, language. One approach aimed at easing this difficulty is based upon the concept of transparency.Bymaking the underlying distribution of the system transparent to the programmer it is hoped that the programming task becomes comparable with that of programming centralised applications.