Lecture #6: Distributed Mutual Exclusion

These topics are from Chapter 6 (Distributed Mutual Exclusion) in Advanced Concepts in OS, supplemented with other materials.

Topics for Today

• Lamport's mutual exclusion algorithm
• token-based distributed mutual exclusion algorithms
• Suzuki-Kasami broadcast algorithm
• Raymond's tree-based algorithm

Lamport's Mutual Exclusion Algorithm

• Assumes messages are delivered in FIFO order between each pair of sites
• Is not based on tokens
• Is based on Lamport's clock synchronization scheme*
• Each request gets a timestamp
• Requests with lower timestamps take priority over requests with higher timestamps
• Each site maintains a queue of pairs (timestamp, site), ordered by timestamp

* Are these the single-integer valued clocks, or the vector clocks?

The Algorithm

• Request
  • S_i sends REQUEST(ts_i, i) to all sites in its request set R_i and puts the request on request_queue_i
  • when S_j receives REQUEST(ts_i, i) from S_i it returns a timestamped REPLY to S_i and places S_i's request on request_queue_j
• S_i waits to start the CS until both
  • [L1:] S_i has received a message with timestamp > (ts_i, i) from all other sites
  • [L2:] S_i's request is at the top of request_queue_i
• Release
  • S_i removes request from top of request_queue_i and sends time-stamped RELEASE message to all the sites in its request set
  • when S_j receives a RELEASE messages from S_i it removes S_i's request from request_queue_j

Correctness

Suppose S_i and S_j are executing the CS concurrently.

L1 and L2 must hold at both sites concurrently.

S_i and S_j both have requests at top of their queues and L1 holds, at some instant t.

WLOG suppose S_i's request has earlier timestamp than S_j's.
(Remember the tie-breaking rule!)

Assuming communication channels are FIFO, at instant t S_i's request is queued at S_j, when S_j is in the CS and S_j's own request is at the top of the queue, ahead of a smaller timestamp request.

This is a contradiction.

Example

Performance

• 3(N-1) messages per CS invocation
• sd = T

What does this assume about transmission delay versus message processing delay?

Token-Based Algorithms

• one token, shared among all sites
• site can enter its CS iff it holds token
• The major difference is the way the token is searched
• use sequence numbers instead of timestamps
  • used to distinguish requests from same site
  • kept independently for each site
• The proof of mutual exclusion is trivial
• The proof of other issues (deadlock and starvation) may be less so

Suzuki-Kasami Broadcast Algorithm

• token has form (Q, LN)
  • Q is queue of requests
  • LN is vector of sequence numbers
  • LN[i] is seq. number of S_i's most recent request
• when S_i wants to enter CS:
  • if S_i does not already have the token
    then increment RN_i[i] and broadcast REQUEST(i,RN_i[i])
• when S_j receives REQUEST(i,n):
  • set RN_j[i] to max(RN_j[i], n)
  • if have token and RN_j[i]=LN[i]+1 send token to S_i
• when S_i leaves CS:
  • set LN[i] to RN_i[i]
  • for every S_j
    if S_j not in Q and RN_i[j]=LN[j]+1 then append S_j to Q
  • if Q is not empty
    then delete the top site S_k from Q and send (Q¢,LN) to S_k

Performance of Suzuki-Kazami Algorithm

• a request will be served after at most N-1 others
• 0 or N messages per CS executed
• synchronization delay = 0 or T

Comparison of Lamport and Suzuki-Kazami Algorithms

The essential difference is in who keeps the queue. In one case every site keeps its own local copy of the queue. In the other case, the queue is passed around within the token.

What is gained by this scheme versus the centralized mutual exclusion scheme?

Raymond's Tree-Based Algorithm

• sites are logically arranged as a directed tree
• edges represent the holder variable of each site
• which node is root changes over time

S_i requests entry to CS

• if S_i does not hold the token and Q_i is empty then send request to holder_i
• add S_i to Q_i

S_j receives request from S_i

• if S_j is holding token
  • send token to S_i
  • set holder_j to S_i
• if S_j is not holding token
  • place request in Q_j
  • if S_j does not have a pending request then send request to holder_j

S_i receives token

• delete top entry S_j from Q_i
• if k = i enter own critical section
• if k ¹ i then
  { send token to S_j; set holder_i to S_j }

S_i leaves a CS

• if Q_i is nonempty then
  { delete top entry S_j from Q_i; send token to S_j; set holder_i to S_j }
• if Q_i is (still) nonempty then send request to holder_i

Properties of Raymond's Algorithm

• free from deadlock
• free from starvation
  due to connectedness & FIFO queue service
• ``average'' case
  • O(logN) message complexity
  • O(T logN / 2) synchronization delay

On what assumption(s) does average-case analysis depend?

What are worst-case metrics?

What is degenerate case?

What trade-off does this point out?

Worst Case in Balanced Binary Tree

What is the worst-case number of messages if the topology is a balanced binary tree?

How about other topologies?

Universal Bounds