Docstoc

NetanelD.Seminar

Document Sample
NetanelD.Seminar Powered By Docstoc
					Mutual Exclusion Using Atomic
          Registers
        Lecturer: Netanel Dahan
         Instructor: Prof. Yehuda Afek

    B.Sc. Seminar on Distributed Computation
          Tel-Aviv University 11.03.07



                            Based on the book ‘Synchronization
                                Algorithms and Concurrent
                             Programming’ by Gadi Taubenfeld
Overview
   Introduction.
   Algorithms for two processes: Peterson’s and
    Kessels’ algorithms.
   Tournament algorithms.
   Lamport’s fast algorithm.
   Starvation free algorithms: the bakery
    algorithm and the black-white bakery version.
   Tight space bounds: lower and upper bounds
    of shared resources.
Introduction
The Mutual Exclusion Problem
The mutual exclusion problem is the guarantee of
mutually exclusive access to a shared resource, or
resources when there are several competing
processes.
A situation as described above, where several
processes may access the same resource and the
final result depends on who runs when, is called a
race condition, and the problem is essentially
avoiding such conditions.
The problem was first introduced by Edsgar W.
Dijkstra in 1965.
  General Solution
                    In order to solve the problem, we
remainder code     Surprise, surprise: the rest of the code.
                    add the entry and exit code, in a way
                    which guarantees that the mutual
 entry code         exclusion and deadlock freedom
                    properties are satisfied.
                    The part of the code in which the
critical section
                    shared resources reside.


  exit code
Assumptions
   The remainder code may not influence other
    processes.
   Shared objects appearing in the entry or exit
    code may not be referred to in the remainder
    or critical section.
   A process can not fail when not in the
    remainder.
   Once a process starts executing the CS and
    exit code, it always finishes them.
Related Concepts
    Mutual Exclusion: No two processes are in their
    critical section at the same time.

    Deadlock Freedom: If a process is trying to enter its
    critical section, then some process, not necessarily
    the same one, will eventually enter the critical
    section.

    Starvation Freedom: If a process is trying to enter its
    critical section, eventually it will succeed.
Algorithms for two
processes
 Algorithms for two processes
We start with describing two algorithms that solve the
mutual exclusion problem for two processes.
They will be used for introducing the problem and
possible solutions using atomic registers.

Throughout the presentation, it shall be known that the
only atomic operations on shared registers are reads
and writes.

In addition, we will use the statement await condition as
an abbreviation for while !condition do skip.
Peterson’s Algorithm
   Developed by Gary L. Peterson in 1981.
   The algorithm makes use of a register
    called turn, which can take the values 0
    and 1, the identifiers for the two
    possible processes, and two boolean
    registers b[0] and b[1].
   Both processes can read and write to
    turn, read b[0] and b[1], but only
    process i can write to b[i ].
Peterson’s Algorithm
     Initially: b[0] = b[1] = false, turn is immaterial.

    Process 0:                                Process 1:
1.   b[0] := true;                         1.   b[1] := true;
2.   turn := 0;                            2.   turn := 1;
3.   await (b[1] = false                   3.   await (b[0] = false
     or turn = 1)                               or turn = 0)
4.   critical section;                     4.   critical section;
5.   b[0] := false;                        5.   b[1] := false;
Peterson’s Algorithm
                                  I crossed the barrier
                      Check if there is contention.
  Process i:                   can go goam in
                                 Indicate in barrier
                      first. If Cross the turnCS.CS, and
                      If not, Iso I can inI the thecontention for
                      else I have to wait. crossing
                                 the critical
                      Do my indicate thesection. for later
                      Else… thang…
1. b[i] := true;                observation.


2. turn := i;

3. await (b[1-i] = false or turn = 1-i)

4. critical section;      Indicate I am not contending
                          anymore.
5. b[i] := false;
Properties
   Satisfies mutual exclusion and
    starvation freedom.
   Contention-free time complexity is four
    accesses to the shared memory.
   Process time complexity is unbounded.
   Three shared registers are used.
    Kessels’ single-writer algorithm

   A variation of peterson’s algorithm
    which uses single-writer registers.
   Uses 2 registers, which can take the
    values 0 and 1, and 2 boolean registers.
   Developed by J. L. W. Kessels in 1982.
Kessels’ single-writer algorithm
Initially: b[0] = b[1] = false, turn[0] and turn[1] are immaterial.
Only process i can write to b[i] and turn[i]. local[i] is local for process i.
     Process 0:                             Process 1:
1.    b[0] := true;                    1.     b[1] := true;
2.    local[0] := turn[1];             2.     local[1] := 1 - turn[0];
3.    turn[0] := local[0];             3.     turn[1] := local[1];
4.    await (b[1] = false or           4.     await (b[0] = false or
      local[0] ≠ turn[1]);                    local[1] = turn[0]);
5.    critical section;                5.     critical section;
6.    b[0] := false;                   6.     b[1] := false;
     Properties
   Same as Peterson’s algorithm, besides
    the use of 4 shared registers.
   In addition, satisfies local spinning.
     Local Spinning
   Accessing a physically remote register is
    costly.
   When a process waits, using an await
    statement, it does so by spinning (busy-
    waiting) on registers.
   It is much more efficient to spin on a
    locally-accessible registers.
Kessels’ single-writer algorithm
Initially: b[0] = b[1] = false, turn[0] and turn[1] are immaterial.
Only process i can write to turn[i]. local[i] is local for process i.
     Process 0:                             Process 1:
1.    b[0] := true;                    1.     b[1] := true;
2.    local[0] := turn[1];             2.     local[1] := 1 - turn[0];
3.    turn[0] := local[0];             3.     turn[1] := local[1];
4.    await (b[1] = false or           4.     await (b[0] = false or
      local[0] ≠ turn[1]);                    local[1] = turn[0]);
5.    critical section;                5.     critical section;
6.    b[0] := false;                   6.     b[1] := false;
Tournament
Algorithms
Tournament Algorithms
   A generalization method which enables
    the construction of an algorithm for n
    processes from any given solution for 2
    processes.
   Developed by Gary L. Peterson and
    Michael J. Fischer in 1977.
Tournament Algorithms
     Tournament Algorithms

   An important side affect is that a
    process may enter the critical section an
    arbitrary number of times before some
    other process in a different subtree.
Lamport’s Fast
Algorithm
Lamport’s Fast algorithm
   An algorithm for n processes.
   Provides fast access to the critical section in
    the absence of contention.
   Uses 2 registers which are long enough to
    store a process’ identifier, and a boolean
    registers array.
   Developed in 1987 by Lamport.
Lamport’s Fast algorithm
     Process i’s program:
1.    start: b[i] := true;
2.            x := i;
3.            if y ≠ 0 then b[i] := false;
4.                            await y = 0;
5.                            goto start fi;
6.           y := i;
7.           if x ≠ i then b[i] := false;
8.                         for j := 1 to n do await !b[j] od;
9.                         if y ≠ i then await y = 0;
10.                                      goto start fi fi;
11.   critical section;
12.   y := 0;
13.   b[i] := false;
Indicate contending
     b[i] := true



   Contention?        yes
     y≠0?                    Wait until CS is released

      no
      Barrier                     The last to cross
                                    the barrier!
       y := i


                      yes   Continue only after it is
   Contention?
     xi?                   guaranteed that no one can
                            cross the barrier
      no
                      yes     Last to cross the barrier?
  critical section                      y=i?

                                       no

     exit code               Wait until CS is released
Properties
   Satisfies mutual exclusion and deadlock
    freedom.
   Starvation of individual processes is possible.
   Fast access: In the absence of contention,
    only 7 accesses to the shared memory are
    required.
   Process time complexity is unbounded.
   n + 2 shared registers are used.
Starvation Free
Algorithms
Starvation Free Algorithms
   In many practical systems, since
    contention is rare deadlock freedom is a
    sufficient property.
   For other systems, it might be a too
    weak requirement, such as in cases
    where a process stays a long time in
    the critical section.
The Bakery Algorithm
   Based on the same policy as in a bakery,
    where each customer gets a number which is
    larger then the numbers waiting in line, and
    the lowest number holder gets served.
   Assumed to be up to n processes contending
    to enter the CS.
   Each process is identified by a unique number
    from {1…n}.
The Bakery Algorithm
   The algorithm makes use of a boolean array
    choosing[1…n] and an integer array
    number[1…n]. Entries choosing[i] and
    number[i] can be read by all processes but
    written only by process i.
   The relation <, is used on pairs of integers
    and is called the lexicographic order relation.
    It is defined by (a, b) < (c, d) if a < c or if
    a = c and b < d.
The Bakery Algorithm
Initially: all entries in number and choosing are 0 and false respectively.
       process i’s program:
1.      chossing[ i ] := true;
2.      number[ i ] := 1 + maximum(number[1],…,number[n]);
3.      choosing[ i ] := false;
4.      for j = 1 to n do
5.                await choosing[ j ] = false;
6.                await (number[ j ] = 0 or (number[ i ], i) < (number[ j ], j))
7.      od;
8.      critical section;
9.      number[ i ] := 0;
Properties
   Satisfies mutual exclusion and first-
    come-first-served.
   The algorithm is not fast: even in the
    absence of contention a process is
    required to access the shared memory
    3(n-1) times.
Properties
   Uses 2n shared registers.
   Non-atomic registers: it is enough to
    assume that the registers are safe,
    meaning that writes which are
    concurrent with reads will return an
    arbitrary value.
   The size of number[i] is unbounded.
The Bakery Algorithm
The Black-White Bakery Algorithm

   A variant of the bakery algorithm developed
    by Gadi Taubenfeld in 2004.
   By using a single additional shared bit the
    amount of space required is bounded.
   The shared bit represents a color for the
    customer’s tickets, while the idea is that there
    is a priority to the holders of a ticket which
    color is different then the shared bit.
The Black-White Bakery Algorithm
Tight Space Bounds
Tight Space Bounds
We show that for n processes, n shared
bits are necessary and sufficient for
solving the mutual exclusion problem
assuming the only atomic operations are
reads and writes, and the processes are
asynchronous.
A Lower Bound
   Any deadlock free mutual
    exclusion algorithm for n processes
    must use at least n shared
    registers.
   Proved by James E. Burns and Nancy A.
    Lynch in 1980.
Definitions
   Event: an action carried by a specific
    process.

   x, y and z will denote runs.
   When x is a prefix of y, (y – x) denotes
    the suffix of y obtained by removing x.
Definitions
   x; y is an extension of x by y.
   We always know where (remainder,
    entry, CS, exit) a process is.
   If a run involves only process p, then all
    events in the run involve only process
    p.
Definitions

   Run x looks like run y to process p.

   Process p is hidden in run x.

   Process p covers register r in run x.
Illustrations
   Run x looks like run y to process p.
          run x                   run y
•   p reads 5 from r1   •   p reads 5 from r1
•   q writes 6 to r1    •   p writes 7 to r1
•   p writes 7 to r1    •   q writes 6 to r1
•   q writes 8 to r1    •   q reads 6 from r1
•   p reads 8 from r1   •   q writes 8 to r1
•   q writes 6 to r1    •   p reads 8 from r1
Illustrations
   Process p is hidden in run x.

          •   p reads 5 from r1
          •   q reads 5 from r1
          •   p writes 7 to r1
          •   q writes 8 to r1
          •   p reads 8 from r1
          •   q writes 6 to r1
Illustrations
   Process p covers register r in run x.


    • p writes 7 to r1         p covers r1 at
    • q writes 8 to r1           this point
    • p reads 8 from r1
    • p writes 2 to r1
Lemma 1
   Let x be a run which looks like run y to every
    process in a set P. if z is an extension of x which
    involves only processes in P then y ; (z – x) is a run.




    P events    x             y         then, this is
      only                               also a run

                z
Lemma 2
   If a process p is in its CS in run z, then
    p is not hidden in z.



          p is in its        then, p is
           critical         not hidden
           section

                        z
Lemma 3
   Let x be a run in which all the processes
    are hidden. Then, for any process p,
    there exists a run y which looks like x
    to p, where all processes except maybe
    p are in their remainders.
   Proof: by induction on the number of
    steps of processes other then p.
Lemma 4
   Let x be a run where all the processes
    are hidden. Then, for any process p,
    there is an extension z of x which
    involves only p in which p covers some
    register that is not covered by any other
    process.
Proof
   From lemma 3, there exists a run y
    which looks like x to p, where all
    processes except maybe p are in their
    remainders. By the deadlock freedom
    property, starting from y process p is
    able to enter the CS on its own.
Proof
   By lemma 1, since y looks like x to p,
    p should be able to do the same
    starting from x.
   Suppose p only writes registers covered
    by other processes before entering the
    CS.
Proof
   Then, when all covered registers are
    written one after the other we get a run
    in which p is hidden and is in its CS.
   By lemma 2, this is not possible.
Main Lemma
   Let x be a run in which all the processes
    are in their remainders. Then, for every
    set of processes P there is an extension
    z of x which involves only processes in
    P, in which the processes in P are
    hidden and cover |P| distinct registers.
   Proof: by induction on the size of P.
An Upper Bound
   There is a deadlock free mutual
    exclusion algorithm for n processes
    which uses n shared bits.
   As a prove we will see the One-Bit
    Algorithm developed independently by
    J. E. Burns (1981) and L. Lamport
    (1986).
The One-Bit Algorithm
   Up to n processes may be contending
    to enter the CS, each with a unique
    identifier from {1…n}.
   Uses a boolean array b, where all
    processes can read all entries, but only
    process i can write b[i].
The One-Bit Algorithm
Initially: all entries in b are false.
      Process i’s program:
1.     repeat
2.         b[i] := true; j := 1;
3.          while (b[i] = true) and (j < i) do
4.              if b[j] = true then b[i] = false; await b[j] = false fi;
5.              j := j + 1;
6.          od
7.     until b[i] := true;
8.     for j := i + 1 to n do await b[j] = false od;
9.     critical section;
10.    b[i] := false;
Properties
   Satisfies mutual exclusion and deadlock
    freedom.
   Starvation of individual processes is
    possible.
   Not fast: even in the absence of
    contention a process needs to access all
    of the n shared bits.
Properties
   Not symmetrical: a process with a smaller
    identifier has higher priority.
   Uses only n shared bits, hence it is space
    optimal .
   Non-atomic registers: it is enough to assume
    that the registers are safe, meaning that
    writes which are concurrent with reads will
    return an arbitrary value.
Questions
Thank you for listening…

				
DOCUMENT INFO