Maintaining consistency in distributed systems

In systems designed as assemblies of independently developed components, concurrent access to data or data structures normally arises within individual programs, and is controlled using mutual exclusion constructs, such as semaphores and monitors. Where data is persistent and/or sets of operation are related to one another, transactions or linearizability may be more appropriate. Systems that incorporate cooperative styles of distributed execution often replicate or distribute data within groups of components. In these cases, group oriented consistency properties must be maintained, and tools based on the virtual synchrony execution model greatly simplify the task confronting an application developer. All three styles of distributed computing are likely to be seen in future systems - often, within the same application. This leads us to propose an integrated approach that permits applications that use virtual synchrony with concurrent objects that respect a linearizability constraint, and vice versa. Transactional subsystems are treated as a special case of linearizability

Estimating and Measuring Application Latency of Typical Distributed Interactive Simulation (DIS) - Based Simulation Architecture

One of the challenges in a distributed virtual environment stems from the requirement to simultaneously execute the simulations in realtime to support human interaction, in conjunction with maintaining a consistent view of the shared simulated environment. Maintaining a consistent set of simulation state data in the presence of network latency is difficult if individual data items are updated frequently. The principle application of DIS-based simulation environments has been in the domain of training where a consistent view or its correctness is often judged in subjective terms such as the simulation looking and feeling correct. New application areas for these systems are emerging in the analysis and test domains. For these domains, quantifying shared state consistency in terms of overall distributed application architecture is desirable. This research effort will investigate and validate methods to calculate and measure the latency effects that consider the structure of the applications themselves. Additional latencies introduced due to the software architecture may significantly affect the consistency of the simulation. An improved understanding is beneficial to the Air Force where real-time distributed simulations used for the purpose of analyzing the systems they simulate and the support of live test events

Exploiting models for scalable and high throughput distributed software

In high-throughput distributed applications, such as large-scale banking systems, synchronization between objects becomes a bottleneck. This short paper focusses on research, in close collaboration with ING Bank, on the opportunity of leveraging application specific knowledge captured by model driven engineering approaches, to increase application performance in high-contention scenarios, while maintaining functional application-level consistency

Traceability Analysis of a High-Level Automotive System Architecture Document

More and more functions in automotive systems are enabled and controlled by software that is distributed over a large number of systems and components. In addition, the systems are more and more interconnected to implement the desired vehicle functions. Creating and maintaining a high-level overview of the relations between vehicle functions, systems, and components in a complete and consistent way requires a lot of effort. On the other hand, such a high-level architecture is beneficial for planning the development, analyzing the architecture, or defining product variants. In this paper, we analyze a real-world document that was manually created to document all vehicle functions, systems, and components of one car series and relations between these. We formalized the content of this model by providing a model of the concepts and a set of consistency rules. By evaluating the consistency rules on the given document, we found 213 contradictory relations and 547 missing relations. Based on these results, we conclude that manually maintaining such high-level architectures is highly error-prone and should thus be supported by automation and appropriate tooling

Contract-based return-value commutativity: safely exploiting contract-based commutativity for faster serializable transactions

A key challenge of designing distributed software systems is maintaining data consistency. We can define data consistency and data isolation guarantees --e.g. serializability-- in terms of schedules of atomic reads and writes, but this excludes schedules that would be semantically consistent. Others use manually provided information on "non-conflicting operations" to define guarantees that work for more applica

Byzantine-Resistant Total Ordering Algorithms

AbstractMulticast group communication protocols are used extensively in fault-tolerant distributed systems. For many such protocols, the acknowledgments for individual messages define a causal order on messages. Maintaining the consistency of information, replicated on several processors to protect it against faults, is greatly simplified by a total order on messages. We present algorithms that incrementally convert a causal order on messages into a total order and that tolerate both crash and Byzantine process faults. Varying compromises between latency to message ordering and resilience to faults yield four distinct algorithms. All of these algorithms use a multistage voting strategy to achieve agreement on the total order and exploit the random structure of the causal order to ensure probabilistic termination

Automatic Analysis of Consistency Properties of Distributed Transaction Systems in Maude

Many transaction systems distribute, partition, and replicate their data for scalability, availability, and fault tolerance. However, observing and maintaining strong consistency of distributed and partially replicated data leads to high transaction latencies. Since different applications require different consistency guarantees, there is a plethora of consistency properties---from weak ones such as read atomicity through various forms of snapshot isolation to stronger serializability properties---and distributed transaction systems (DTSs) guaranteeing such properties. This paper presents a general framework for formally specifying a DTS in Maude, and formalizes in Maude nine common consistency properties for DTSs so defined. Furthermore, we provide a fully automated method for analyzing whether the DTS satisfies the desired property for all initial states up to given bounds on system parameters. This is based on automatically recording relevant history during a Maude run and defining the consistency properties on such histories. To the best of our knowledge, this is the first time that model checking of all these properties in a unified, systematic manner is investigated. We have implemented a tool that automates our method, and use it to model check state-of-the-art DTSs such as P-Store, RAMP, Walter, Jessy, and ROLA.Ope