42,550 research outputs found
On Consistency of Operational Transformation Approach
The Operational Transformation (OT) approach, used in many collaborative
editors, allows a group of users to concurrently update replicas of a shared
object and exchange their updates in any order. The basic idea of this approach
is to transform any received update operation before its execution on a replica
of the object. This transformation aims to ensure the convergence of the
different replicas of the object, even though the operations are executed in
different orders. However, designing transformation functions for achieving
convergence is a critical and challenging issue. Indeed, the transformation
functions proposed in the literature are all revealed incorrect.
In this paper, we investigate the existence of transformation functions for a
shared string altered by insert and delete operations. From the theoretical
point of view, two properties - named TP1 and TP2 - are necessary and
sufficient to ensure convergence. Using controller synthesis technique, we show
that there are some transformation functions which satisfy only TP1 for the
basic signatures of insert and delete operations. As a matter of fact, it is
impossible to meet both properties TP1 and TP2 with these simple signatures.Comment: In Proceedings Infinity 2012, arXiv:1302.310
Extending Eventually Consistent Cloud Databases for Enforcing Numeric Invariants
Geo-replicated databases often operate under the principle of eventual
consistency to offer high-availability with low latency on a simple key/value
store abstraction. Recently, some have adopted commutative data types to
provide seamless reconciliation for special purpose data types, such as
counters. Despite this, the inability to enforce numeric invariants across all
replicas still remains a key shortcoming of relying on the limited guarantees
of eventual consistency storage. We present a new replicated data type, called
bounded counter, which adds support for numeric invariants to eventually
consistent geo-replicated databases. We describe how this can be implemented on
top of existing cloud stores without modifying them, using Riak as an example.
Our approach adapts ideas from escrow transactions to devise a solution that is
decentralized, fault-tolerant and fast. Our evaluation shows much lower latency
and better scalability than the traditional approach of using strong
consistency to enforce numeric invariants, thus alleviating the tension between
consistency and availability
On Coordinating Collaborative Objects
A collaborative object represents a data type (such as a text document)
designed to be shared by a group of dispersed users. The Operational
Transformation (OT) is a coordination approach used for supporting optimistic
replication for these objects. It allows the users to concurrently update the
shared data and exchange their updates in any order since the convergence of
all replicas, i.e. the fact that all users view the same data, is ensured in
all cases. However, designing algorithms for achieving convergence with the OT
approach is a critical and challenging issue. In this paper, we propose a
formal compositional method for specifying complex collaborative objects. The
most important feature of our method is that designing an OT algorithm for the
composed collaborative object can be done by reusing the OT algorithms of
component collaborative objects. By using our method, we can start from correct
small collaborative objects which are relatively easy to handle and
incrementally combine them to build more complex collaborative objects.Comment: In Proceedings FOCLASA 2010, arXiv:1007.499
Causal Consistency: Beyond Memory
In distributed systems where strong consistency is costly when not
impossible, causal consistency provides a valuable abstraction to represent
program executions as partial orders. In addition to the sequential program
order of each computing entity, causal order also contains the semantic links
between the events that affect the shared objects -- messages emission and
reception in a communication channel , reads and writes on a shared register.
Usual approaches based on semantic links are very difficult to adapt to other
data types such as queues or counters because they require a specific analysis
of causal dependencies for each data type. This paper presents a new approach
to define causal consistency for any abstract data type based on sequential
specifications. It explores, formalizes and studies the differences between
three variations of causal consistency and highlights them in the light of
PRAM, eventual consistency and sequential consistency: weak causal consistency,
that captures the notion of causality preservation when focusing on convergence
; causal convergence that mixes weak causal consistency and convergence; and
causal consistency, that coincides with causal memory when applied to shared
memory.Comment: 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel
Programming, Mar 2016, Barcelone, Spai
Update Consistency for Wait-free Concurrent Objects
In large scale systems such as the Internet, replicating data is an essential
feature in order to provide availability and fault-tolerance. Attiya and Welch
proved that using strong consistency criteria such as atomicity is costly as
each operation may need an execution time linear with the latency of the
communication network. Weaker consistency criteria like causal consistency and
PRAM consistency do not ensure convergence. The different replicas are not
guaranteed to converge towards a unique state. Eventual consistency guarantees
that all replicas eventually converge when the participants stop updating.
However, it fails to fully specify the semantics of the operations on shared
objects and requires additional non-intuitive and error-prone distributed
specification techniques. This paper introduces and formalizes a new
consistency criterion, called update consistency, that requires the state of a
replicated object to be consistent with a linearization of all the updates. In
other words, whereas atomicity imposes a linearization of all of the
operations, this criterion imposes this only on updates. Consequently some read
operations may return out-dated values. Update consistency is stronger than
eventual consistency, so we can replace eventually consistent objects with
update consistent ones in any program. Finally, we prove that update
consistency is universal, in the sense that any object can be implemented under
this criterion in a distributed system where any number of nodes may crash.Comment: appears in International Parallel and Distributed Processing
Symposium, May 2015, Hyderabad, Indi
Town of Milton Shoreland Protection Project
Mettee Planning Consultants (MPC) worked with the Milton Conservation Commission to evaluate and streamline the town’s water resource protection regulations. One of the outcomes was revision and passage of a Shoreland Protection Overlay District as part of the town’s zoning ordinance
- …