Replication & Consistency

1. Replication & Consistency

2. Logistics • Project • P01 • Non-blocking IO lecture: Nov 4th. • P02 deadline on NEXT Wednesday (November 17th) • Next quiz • Tuesday: November 16th

3. Last time: Amazon’s Dynamo service

4. Replication: Creating and using multiple copies of data (or services) Why replicate? • Improve system reliability • Prevent data loss • i.e. provide data durability • Increase data availability • Note: availability ≠ durability • Increase confidence: e.g. deal with byzantine failures • Improve performance • Scaling throughput • Reduce access times

5. What are the issues? Issue 1. Dealing with data changes • Consistencymodels • What is the semantic the system implements • (luckily) applications do not always require strict consistency • Consistency protocols • How to implement the semantic agreed upon? Issue 2. Replica management • How many replicas? • Where to place them? • When to get rid of them? Issue 3. Redirection/Routing • Which replica should clients use?

6. Scalability TENSION Management overheads Performance and Scalability To keep replicas consistent, we generally need to ensure that all conflictingoperations are done in the same order everywhere Conflicting operations: From the world of transactions: • Read–write conflict: a read operation and a write operation act concurrently • Write–write conflict: two concurrent write operations Problem: Guaranteeing global ordering on conflicting operations may be costly, reducing scalability Solution: Weaken consistency requirements so that hopefully global synchronization can be avoided

7. Client‘s view of the data-store Ideally: black box -- complete ‘transparency’ over how data is stored and managed

8. Management’ system view on data store Management system: Controls the allocated resources and aims to provide transparency

9. Consistency model Management system: Controls the allocated resources and aims to provide transparency Consistency model: Contract between the data store and the clients: The data store specifies the results of read and write operations in the presence of concurrent operations.

10. Roadmap for next few classes • Consistency models: • contracts between the data store and the clients that specify the results of read and write operations are in the presence of concurrency. • Protocols • To manage update propagation • To manage replicas: • creation, placement, deletion • To assign client requests to replicas

11. Consistency models • Data centric: Assume a global, data-store view (i.e., across all clients) • Continuous consistency • Limit the deviation between replicas • Models based on uniform ordering of operations • Constraints on operation ordering at the data-store level • Client centric • Assume client-independent views of the datastore • Constraints on operation ordering for each client independently

12. Notations For operations on a Data Store: • Read: Ri(x) a -- client i reads a from location x • Write: Wi(x) b -- client i writes b at location x

13. Sequential Consistency The result of any execution is the same as if : • operations by all processes on the data store were executed in some sequential order, and • the operations of each individual process appear in this sequence in the order specified by its program. Note: we talk about interleaved execution – there is some total ordering for all operations taken together

14. Sequential Consistency (example) What about: 11 11 11? What about: 00 10 10?

15. Causal Consistency (1) Writes that are potentially causally related must be seen by all processes in the same order. Concurrent writes may be seen in a different order by different processes. Causally related relationship: • A read is causally related to the write that provided the data the read got. • A write is causally related to a read that happened before this write in the same process. • If write1  read, and read  write2, then write1  write2. Concurrent <=> not causally related

16. Causal Consistency (Example) • This sequence is allowed with a causally-consistent store, but not with sequentially or strictly consistent store. • Note: W1(x)a  W2(x)b, but notW2 (x)b  W1(x)c

17. Causal Consistency: (More Examples) A violation of a causally-consistent store. A correct sequence of events in a causally-consistent store.

18. Increasing granularity: Grouping Operations Basic idea: You don’t care that reads and writes of a series of operations are immediately known to other processes. You just want the effect of the series itself to be known. One Solution: • Accesses to synchronization variables are sequentially consistent. • No access to a synchronization variable is allowed to be performed until all previous writes have completed everywhere. • No read data access is allowed to be performed until all previous accesses to synchronization variables have been performed.

19. Consistency models • Data centric: Assume a global, data-store view (i.e., across all clients) • Continuous consistency • Limit the deviation between replicas • Models based on uniform ordering of operations • Constraints on operation ordering at the data-store level • Client centric • Assume client-independent views of the datastore • Constraints on operation ordering for each client independently

20. Continuous Consistency Observation:We can actually talk a about a degree of consistency: • replicas may differ in their numerical value • replicas may differ in their relative staleness • Replicas may differ with respect to (number and order) of performed update operations Conit: consitency unit  specifies the data unit over which consistency is to be enforced.

21. Example Conit: contains the variables x and y: • Each replica maintains a vector clock • B sends A operation [<5,B>: x := x + 2]; A has made this operation permanent(cannot be rolled back) • A has three pendingoperations  order deviation = 3

22. Consistency models: contracts between the data store and the clients • Data centric: solutions at the data store level • Continuous consistency • limit the deviation between replicas, or • Models based on uniform ordering of operations • Constraints on operation ordering at the data-store level • Client centric • Assume client-independent views of the datastore • Constraints on operation ordering for each client independently

23. Eventual Consistency Idea: If no updates take place for a long enough period time, all replicas will gradually (i.e., eventually) become consistent. When? Situations where eventual consistency models may make sense • Mostly read-only workloads • No concurrent updates • Advantages/Drawbacks

24. Client-centric Consistency Models • System model • Monotonic reads • Monotonic writes • Read-your-writes • Write-follows-reads Goal: Avoid system-wide consistency, by concentrating on what eachclient independentlywants, (instead of what should be maintained by servers with a global view)

25. Example: Consistency for Mobile Users Example: Distributed database to which a user has access through her notebook. • Notebook acts as a front end to the database. • At location A user accesses the database with reads/updates • At location B user continues work, but unless it accesses the same server as the one at location A, she may detect inconsistencies: • updates at A may not have yet been propagated to B • user may be reading newer entries than the ones available at A: • user updates at B may eventually conflict with those at A Note: The only thing the user really needs is that the entries updated and/or read at A, are available at B the way she left them in A. • Idea: the database will appear to be consistent to the user

26. Example - Basic Architecture

27. Client-centric Consistency Idea: Guarantees some degree of data access consistency for a single client/process point of view. Notations: • Xi[t]  Version of data item x at time t at local replica Li • WS(xi [t])  working set (all write operations) at Li up to time t • WS(xi [t]; xj [t])  indicates that it is known that WS(xi [t]) is included in WS(xj [t])

28. Monotonic-Read Consistency Intuition: Client “sees” the same or newer version of data. Definition: If a process reads the value of a data item x, any successive read operation on x by that process will always return that same or a more recent value.

29. Monotonic reads – Examples • Automatically reading your personal calendar updates from different servers. • Monotonic Reads guarantees that the user sees always more recent updates, no matter from which server the reading takes place. • Reading (not modifying) incoming e-mail while you are on the move. • Each time you connect to a different e-mail server, that server fetches (at least) all the updates from the server you previously visited.

30. Monotonic-Write Consistency Intuition: A write happens on a replica only if it’s brought up to date with preceding write operations on same data (but possibly at different replicas) Definition: A write operation by a process on a data item x is completed before any successive write operation on x by the same process. WS

31. Monotonic writes – Examples • Updating a program at server S2, and ensuring that all components on which compilation and linking depends, are also placed at S2. • Maintaining versions of replicated files in the correct order everywhere (propagate the previous version to the server where the newest version is installed).

32. Read-Your-Writes Consistency Intuition: All previous writes are always completed before any successive read Definition: The effect of a write operation by a process on data item x, will always be seen by a successive read operation on x by the same process.

33. Read-Your-Writes - Examples • Updating your Web page and guaranteeing that your Web browser shows the newest version instead of its cached copy. • Password database

34. Writes-Follow-Reads Consistency Intuition: Any successive write operation on x will be performed on a copy of x that is same or more recent than the last read. Definition: A write operation by a process on a data item x following a previous read operation on x by the same process, is guaranteed to take place on the same or a more recent value of x that was read. • Examples: news groups

35. Writes-Follow-Reads - Examples • See reactions to posted articles only if you have the original posting • a read “pulls in” the corresponding write operation.

36. Rodamap Updating replicas • Consistency models • What is the semantic the system provides in case of updates • (luckily) applications do not always require strict consistency • Consistency protocols: • How is this semantic implemented Replica and content management • How many replicas? • Where to place them? • When to get rid of them? Redirection/Routing • Which replica should clients use?

37. Reminder: System view Management system: Controls the allocated resources and aims to provide replication transparency Consistency model: contract between the data store and the clients

38. Next: implementation techniques Updating replicas • Consistency models (how to deal with updated data) • (luckily) applications do not always require strict consistency • Consistency protocols: Implementation issues • How is a consistency model implemented Replica and content management • How many replicas? • Where to place them? • When to get rid of them? Redirection/Routing • Which replica should clients use?

39. Reminder: Types of consistency models • Consistency model: contract between the data store and the clients • the data store specifies precisely what the results of read and write operations are in the presence of concurrency. • Data centric: solutions at the data store level • Continuous consistency: limit the deviation between replicas, or • Constraints on operation ordering at the data-store level • Client centric • Constraints on operation ordering for each client independently

40. Today: Consistency protocols Question: How does one design the protocols to implement the desired consistency model? • Data centric • Constraints on operation ordering at the data-store level • Sequential consistency. • Continuous consistency: limit the deviation between replicas • Client centric • Constraints on operation ordering for each client independently

41. Reminder: Monotonic-Read Consistency Definition: If a process reads the value of a data item x, any successive read operation on x by that process will always return that same or a more recent value. • Intuition: Client “sees” the same or a newer version of the data.

42. Implementation of monotonic-read consistency Sketch: • Globally unique identifier for each write operation • Quiz-like question: explain how exactly the globally unique identifier is (1) generated, and (2) used. • Each client keeps track of: • Write IDs relevant to the read operations performed so far on various objects (ReadSet) • When a client launches a read • Client sends the ReadSet to the replica server • The server checks that all updates in the ReadSet have been performed. [If necessary] Fetches unperformed updates • Returns the value

43. More quiz-like questions Sketch a Design for the consistency model • Monotonic-writes • Read-your-writes • Writes-follow-reads Write pseudo-code

44. Today: Consistency protocols Question: How does one design the protocols to implement the desired consistency model? • Data centric • Constraints on operation ordering at the data-store level • Sequential consistency, causal consistency, etc • Continuous consistency: limit the deviation between replicas • Client centric • Constraints on operation ordering for each client independently

45. Overview: Data-centric Consistency Protocols

46. Overview: Data-centric Consistency Protocols

47. Primary-Based Protocols Usage:distributed databases and file systems that require a high degree of fault tolerance. Replicas often placed on same LAN. Issues: blocking vs. non-blocking

48. Primary-backup protocol with local writes • The primary migrates to the node that executes the write • Usage: Mobile computing in disconnected mode • Idea: ship all relevant files to user before disconnecting, and update later.

49. Overview: Data-centric Consistency Protocols

50. Active Replication (1/2) • Model: Remote operations/updates (and not the result of state changes) are replicated • Control replication (and not data replication) • Requires total update ordering (either through a sequencer or using Lamport’s protocol). • Example: Replicated distributed objects • Problems • Operations need to be sequenced • Dealing with workflows