Distributed Coordination [235]

• Mutual Exclusion: share a critical section

• remember sempahores!

• Resource Allocation: share a resource

• remember Dining Philosophers!

• Reading/Writing Registers: share a variable

• Leader Election: agree on a leader

• what if a token gets lost? need a root for a tree?

• systems reboot?

• Common Knowledge: everyone knows that everyone knows ...

• when can I be sure?

• Consensus: everyone agrees on a value

• what if processors lie (faulty)?

• Distributed Minimum-Weight Spanning Tree:

• find tree concurrently with distributed information

• see VISUAL OS (Distributed Algorithms)

LeLann's Mutual Exclusion [236]

• use TOKEN to guarantee mutual exclusion on ring network

• to stop processes after cycles around the ring:

At all i:                              Extra code at i=1:

                                       send({\em neighbor, TOKEN})

    do forever  {

                                        cycles <- cycles - 1

                                        if cycles = 0 then send(neighbor, STOP)


      msg <- receive()

      /* critical section */
   
      send(neighbor,msg)

      if msg = STOP then goto EXIT


    }

    EXIT: destroy(i)

Lamport's Logical Register [237]

• one logical ``shared'' register by distributed local registers

• RP: reading process

• WP: writing process

• logical register is only ``regular'' (not necessarily consistent)

Lamport's Logical Register [238]

At register process x_i in {1,...,n}:
   
   do forever

     message <- receive()

     if message = READ then send(reader, x)

     else {     /* message is the value to be written */

       x <- message

       send(writer, DONE)

     }

At reading process j in {n+1,...,2n}:
   
   do forever

     send(register, READ)

     value <- receive()

At writing process k=2n+1:
   
   do forever

     /* compute new value */

     for i=1,...,n do send(i, value)

     for i=1,...,n do message <- receive()

Coordination: Leader Election [239]

Given: n processes on a ring, each with unique identifier

Problem: elect a leader

• say to regenerate a token

• or to be a root in a spanning tree

• all processes must agree and know who the leader is

LeLann's Leader Election [240]

• if received ID is larger, send it to the next node

• if received ID is smaller, ignore it

• if received ID is equal, process is the leader

• because its ID traveled all the way around

• Which process is elected leader? How should it be announced?

Local Variables:

1. temp_id <- i, the temporary ID of the process

2. next_temp_id, the temporary ID of the next clockwise process

3. neighbor <- i+1, the next counterclockwise process on the ring 

At p_i in {1,...,n}:

   send(neighbor, temp_id)

   do forever

     next_temp_id <- receive()

     if next_temp_id > temp_id then send(neighbor, next_temp_id)

     if next_temp_id = temp_id then announce( LEADER)

Peterson's Leader Election [241]

• process sends its own temp ID to next counterclockwise neighbor

• process receives, sends, temp ID of next clockwise neighbor

• process compares the three IDs

• if clockwise temp ID is largest, it replaces the temp ID

• if clockwise temp ID is not largest, process goes to relay mode

• if clockwise temp ID = own temp ID, receiver is leader

  ACTIVE:

  do forever

    send(neighbor, temp_id)

    next_temp_id <- receive()

    if next_temp_id = temp_id then

      announce(LEADER)

    send(neighbor, next_temp_id)

    next_next_temp_id <- receive()

    if next_temp_id > max(temp_id, next_next_temp_id) then

      temp_id <- next_temp_id

    else

       goto RELAY

  
  RELAY:

  do forever

    temp_id <- receive()

    send(neighbor, temp_id)