44 research outputs found
Safe Generic Data Synchronizer
Rapport interne.Reconciliating divergent data is an important issue in concurrent engineering, mobile computing and software configuration management. Actually, a lot of synchronizers or merge tools perform reconciliations, however, which strategy they apply ? is it correct ? In this paper, we propose to use a transformational approach to build a safe generic data synchronizer
Contention management for distributed data replication
PhD ThesisOptimistic replication schemes provide distributed applications with access
to shared data at lower latencies and greater availability. This is
achieved by allowing clients to replicate shared data and execute actions
locally. A consequence of this scheme raises issues regarding shared data
consistency. Sometimes an action executed by a client may result in
shared data that may conflict and, as a consequence, may conflict with
subsequent actions that are caused by the conflicting action. This requires
a client to rollback to the action that caused the conflicting data,
and to execute some exception handling. This can be achieved by relying
on the application layer to either ignore or handle shared data inconsistencies
when they are discovered during the reconciliation phase of an
optimistic protocol.
Inconsistency of shared data has an impact on the causality relationship
across client actions. In protocol design, it is desirable to preserve the
property of causality between different actions occurring across a distributed
application. Without application level knowledge, we assume
an action causes all the subsequent actions at the same client. With
application knowledge, we can significantly ease the protocol burden of
provisioning causal ordering, as we can identify which actions do not
cause other actions (even if they precede them). This, in turn, makes
possible the client’s ability to rollback to past actions and to change
them, without having to alter subsequent actions. Unfortunately, increased
instances of application level causal relations between actions
lead to a significant overhead in protocol. Therefore, minimizing the
rollback associated with conflicting actions, while preserving causality,
is seen as desirable for lower exception handling in the application layer.
In this thesis, we present a framework that utilizes causality to create
a scheduler that can inform a contention management scheme to reduce
the rollback associated with the conflicting access of shared data.
Our framework uses a backoff contention management scheme to provide
causality preserving for those optimistic replication systems with high
causality requirements, without the need for application layer knowledge.
We present experiments which demonstrate that our framework reduces
clients’ rollback and, more importantly, that the overall throughput of
the system is improved when the contention management is used with
applications that require causality to be preserved across all actions
Dynamic contention management for distributed applications
PhD ThesisDistributed applications often make use of replicated state to afford a greater level of
availability and throughput. This is achieved by allowing individual processes to progress
without requiring prior synchronisation. This approach, termed optimistic replication,
results in divergent replicas that must be reconciled to achieve an overall consistent state.
Concurrent operations to shared objects in the replicas result in conflicting updates that
require reconciliatory action to rectify. This typically takes the form of compensatory
execution or simply undoing and rolling back client state.
When considering user interaction with the application, there exists relationships and
intent in the ordering and execution of these operations. The enactment of reconciliation
that determines one action as conflicted may have far reaching implications with regards to
the user’s original intent. In such scenarios, the compensatory action applied to a conflict
may require previous operations to also be undone or compensated such that the user’s
intent is maintained. Therefore, an ability to manage the contention to the shared data
across the distributed application to pre-emptively lower conflicts resulting from these
infringements is desirable. The aim is to not hinder throughput, achieved from the weaker
consistency model known as eventual consistency.
In this thesis, a model is presented for a contention management framework that schedules
access using the expected execution inherent in the application domain to best inform
the contention manager. A backoff scheme is employed to create an access schedule, preserving
user intent for applications that require this high level of maintenance for user
actions. By using such an approach, this results in a performance improvement seen
in the reduction of the overall number of conflicts, while also improving overall system
throughput. This thesis describes how the contention management scheme operates and,
through experimentation, the performance benefits received
What\u27s in Unison? A Formal Specification and Reference Implementation of a File Synchronizer
A file synchronizer is a tool that reconciles disconnected modifications to a replicated directory structure. Trustworthy synchronizers are difficult to build, since they must deal correctly with both the semantic complexities of file systems and the unpredictable failure modes arising from distributed operation. On the other hand, synchronizers are often packaged as stand-alone, user-level utilities, whose intended behavior is relatively easy to isolate from the other functions of the system. This combination of subtlety and isolability makes file synchronizers attractive candidates for precise mathematical specification.
We present here a detailed specification of a particular file synchronizer called Unison, sketch an idealized reference implementation of our specification, and discuss the relation between our idealized implementation and the actual code base
Supporting Collaborative Writing of XML Documents
ISBN : 978-972-8865-91-7International audienceSynchronisation of replicated shared data is a key issue in collaborative writing systems. Most existing synchronization tools are specific to a particular type of shared data, i.e. text files, calendars, XML files. Therefore, users must use different tools to maintain their different copies up-to-date. In this paper we propose a generic synchronization framework based on the operational transformation approach that supports synchronisation of text files, calendars, XML files by using the same tool. We present how our framework is used to support cooperative writing of XML documents. An implementation is illustrated through the revision control system called So6, which is part of a distributed collaborative technology called LibreSource
Research report : Collaborative Peer 2 Peer Edition: Avoiding Conflicts is Better than Solving Conflicts
Collaborative edition is achieved by distinct sites that work independently
on (a copy of) a shared document. Conflicts may arise during this process and
must be solved by the collaborative editor. In pure Peer to Peer collaborative
editing, no centralization nor locks nor time-stamps are used which make
conflict resolution difficult. We propose an algorithm which relies on the
notion or semantics dependence and avoids the need of any integration
transformation to solve conflicts. Furthermore, it doesn't use any history file
recording operations performed since starting the edition process. We show how
to define editing operations for semi-structured documents i.e. XML-like trees,
that are enriched with informations derived for free from the editing process.
Then we define the semantics dependence relation required by the algorithm and
we present preliminary results obtained by a prototype implementation.Comment: 12 page