1 / 78

Replication & Consistency

Replication & Consistency. Logistics. Project P01 Non-blocking IO lecture: Nov 4 th . P02 deadline on NEXT Wednesday (November 17 th ) Next quiz Tuesday: November 16 th. Last time: Amazon’s Dynamo service. Replication : Creating and using multiple copies of data (or services)

Download Presentation

Replication & Consistency

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related