One of the major challenges in distributed systems is establishing consistency among replicated data in a timely fashion. While the consistent ordering of events has been extensively researched, the time span to reach a consistent state is mostly considered an effect of the chosen consistency model, rather than being considered a parameter itself. This paper argues that it is possible to give guarantees on the timely consistency of an operation. Subsequent to an update the cloud and all connected clients will either be consistent with the update within the defined upper bound of time or the update will be returned. This paper suggests the respective algorithms and protocols capable of producing such comprehensive Timed Consistency, as conceptually proposed by Torres- The solution offers business customers an increasing level of predictability and adjustability. The temporal certainty concerning the execution makes the cloud a more attractive tool for time-critical or mission-critical applications fearing the poor availability of Strong Consistency in cloud environments.
Consistency models mostly focus on ordering events. Torres- @cite_5 instead emphasize the timeliness of consistency. They considering time as an endogenous factor rather than as a result of the selected consistency model. Based on the arbitrary timeliness requirement they attach a lifetime to an object and develop a theory about the consistency properties on its basis. Given a distributed system would exist, that itself establishes timed consistency from a data-centric point of view, an end-to-end client-centric consistency is implied by Torres- model @cite_15 @cite_20 .
@cite_5 @cite_15 @cite_20
2131460078 2115806861 1503941956 2162601662
When distributed clients query or update shared data, eventual consistency can provide better availability than strong consistency models. However, programming and implementing such systems can be difficult unless we establish a reasonable consistency model, i.e. some minimal guarantees that programmers can understand and systems can provide effectively. To this end, we propose a novel consistency model based on eventually consistent transactions. Unlike serializable transactions, eventually consistent transactions are ordered by two order relations (visibility and arbitration) rather than a single order relation. To demonstrate that eventually consistent transactions can be effectively implemented, we establish a handful of simple operational rules for managing replicas, versions and updates, based on graphs called revision diagrams. We prove that these rules are sufficient to guarantee correct implementation of eventually consistent transactions. Finally, we present two operational models (single server and server pool) of systems that provide eventually consistent transactions. The tradeoffs between consistency, performance, and availability are well understood. Traditionally, however, designers of replicated systems have been forced to choose from either strong consistency guarantees or none at all. This paper explores the semantic space between traditional strong and optimistic consistency models for replicated services. We argue that an important class of applications can tolerate relaxed consistency, but benefit from bounding the maximum rate of inconsistent access in an application-specific manner. Thus, we develop a conit-based continuous consistency model to capture the consistency spectrum using three application-independent metrics, numerical error, order error, and staleness. We then present the design and implementation of TACT, a middleware layer that enforces arbitrary consistency bounds among replicas using these metrics. We argue that the TACT consistency model can simultaneously achieve the often conflicting goals of generality and practicality by describing how a broad range of applications can express their consistency semantics using TACT and by demonstrating that application-independent algorithms can efficiently enforce target consistency levels. Finally, we show that three replicated applications running across the Internet demonstrate significant semantic and performance benefits from using our framework. Techniques such as replication and caching of objects that implement distributed services lead to consistency problems that must be addressed. We explore new consistency protocols based on the notion of object value lifetimes. By keeping track of the lifetimes of the values stored in shared objects (i.e., the time interval that goes from the writing of a value until the latest time when this value is known to be valid), it is possible to check the mutual consistency of a set of related objects cached at a site. Initially, this technique is presented assuming the presence of physical clocks. Later, these clocks are replaced by vector clocks and then by plausible clocks. Lifetimes based on such clocks result in weaker consistency but do provide more efficient implementations. Given a distributed system with several shared objects and many processes concurrently updating and reading them, it is convenient that the system achieves convergence on the value of these objects. Such property can be guaranteed depending on the consistency model being employed. Causal Consistency is a weak consistency model that is easy and cheap to implement. However, due to the lack of real-time considerations, this model cannot oer convergence. A solution for overcoming that problem is to include time aspects within the framework of the model. This is the aim of Timed Causal Consistency.