Documents
User Generated
Resources
Learning Center

# NetanelD.Seminar

VIEWS: 10 PAGES: 61

• pg 1
```									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
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
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
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.
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 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
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
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…

```
To top