Scalable Consistency Protocols for Distributed Services- Notes | CS 7210, Study notes of Computer Science

Download Scalable Consistency Protocols for Distributed Services- Notes | CS 7210 and more Study notes Computer Science in PDF only on Docsity!

Scalable Consistency

Protocols for Distributed

Services

Mustaque Ahamad Rammohan Kordale

Introduction

 target environment: highly interactive, distributed applications  need to provide low latency access to dynamically changing shared state  scalability along the lines of system load, geographical distribution  use of server replication, client caching: introduces problem of consistency

Local Consistency

 strong consistency  flexible control over update dissemination  nodes that update shared state NOT responsible for informing others  node itself is responsible for taking local consistency actions to invalidate old copies of objects

Advantages

 access latencies lowered  number of client requests to servers (server load) decreased  both push and pull style dissemination  guarantee serialization, yet allow for control over currency of cached copies

contd...

 Ideally, node view ⊂⊂ current global view  Synchronization costly, nodes may not be interested in updates  In LC, node view can lag behind current global view  A node's view is locally consistent if:  (^) Node's View i ⊂ Global View j  (^) If Node's View i ⊂ Global View j and Node's View i+ ⊂ Global View k , then Global View k is more recent than Global View j  Readers can be concurrent with writers

Consistent Views

 A node's view does not have to be a subset of the current view

Invalidation Set Protocol

 single server  maintains consistent node views by receiving information about what object copies have been overwritten  all write misses/faults require communication with the server  server keeps information on a per node basis about which objects need to be invalidated for a node  object copies are invalidated only when a client communicates with the server

 two copies x(v) and y(v') belong to a consistent view if they have overlapping lifetimes.  a set of copies belong to a consistent view if each pair of copies in the set has overlapping times  protocol uses vector clocks

Clock Rules

 if operation writes v to x and the value v is read by another operation, then the read must be ordered after the write  if v and v' are the values of x by two consecutive writes, a read operation that reads the value v must be ordered before the second write.

Write, Read and Valid Times

 Write Time: The value of VTi after the operation is completed  Read Time: server maintains the read time for an object as follows-  when Pi requests copy from server, x(v).rt = update(x(v).rt, VT)  if x is currently cached in exclusive mode, server updates x(v).rt with owners copy as well, as the owner now possesses a read-only copy

 Valid time: advanced on three occasions  locally cached objects updated to node's clock value.  when a server requests node for a copy, node updates copy's valid time with its clock value.  server updates valid time of an object copy before returning it.  Local consistency check: invalidate all related objects whose valid times are less than the write time of x.

Hybrid Protocol

 Object lifetime based protocol can be more conservative than required.  If x's server is Sx, then Sx maintains both the invalidation set and write, read and valid times for each object copy.  For objects managed by Sx, invalidation based on set. For others, use object lifetimes.

Performance and Evaluation

 evaluation based on distributed filesystem  workloads: Princeton and Toronto for system load and geographic distribution respectively.  metrics measured: cache misses, server requests, average response time  Princeton load: difference between cache misses not too significant, difference between server requests is significant.