多处理器编程的艺术 读书笔记 第二章 互斥 (下)

REF: 多处理器编程的艺术(The Art of Multiprocessor Programming)

说明：我自己的理解为红色(不保证正确)，参考书上的为黑色。

最后修改时间： 09-16-2011

-------------------------------------------------------------------------

2.5 Fairness

    Definition 2.5.1. A lock is first-come-first-served if, whenever, thread A finishes
                              its doorway before thread B starts its doorway, then A cannot be overtaken by B.
 2.6 Lamport’s Bakery Algorithm
              class Bakery implements Lock {
                boolean[] flag;
                Label[] label;
                public Bakery (int n) {
                  flag = new boolean[n];
                  label = new Label[n];
                  for (int i = 0; i < n; i++) {
                     flag[i] = false; label[i] = 0;                                                  //[1]
                  }
                }
                public void lock() {
                  int i = ThreadID.get();
                  flag[i] = true;                                                                          //[2]
                  label[i] = max(label[0], ...,label[n-1]) + 1;                           //[3]
                  while ((∃k != i)(flag[k] && (label[k],k) << (label[i],i))) {};   //[4]
                }
                public void unlock() {
                  flag[ThreadID.get()] = false;                                              //[5]
                }
              }
        Figure 2.9  The Bakery lock algorithm.

      - flag[A] : Indicating whether A wants to enter the critical section.
      -  label[A] : an integer that indicates the thread’s relative order when entering the Critical Section,
                        for each thread A.
                        // label[A]'s  task is establishing an order among the contending threads.


      - [1]: Init
               All threads(0 ~ n-1) don't want to enter the critical section.
               Order of each threads is 0.
      - [2]: Request to enter the CS(Critical Section).
      - [3]: Get a sequence number which is greater by one than the maximal one.
      - [4]: Wait until there is no other threads want to enter CS or itself is the earlist one among all
               threads waiting at the 'waiting section'.
     * stages [2], [3]  is called 'doorway section'.
     * Since releasing a lock does not reset the label[], it is easy to see that each thread’s labels are
        strictly increasing.
     - Lemma 2.6.1. The Bakery lock algorithm is deadlock-free.
     - Lemma 2.6.2. The Bakery lock algorithm is first-come-first-served.
     - Lemma 2.6.3. The Bakery algorithm satisfies mutual exclusion.
    
2.7 Bounded Timestamps
      - Think of assigning a timestamp to a thread as placing that thread’s token on
        that timestamp’s node. A thread performs a scan by locating the other threads’
        tokens, and it assigns itself a new timestamp by moving its own token to a node
        a such that there is an edge from a to every other thread’s node.
     -  Let G be a precedence graph, and A and B subgraphs of G (possibly single nodes).
         We say that A dominates B in G if every node of A has edges directed to every node of B.
    -  graph multiplication
    - Define the graph T^ k inductively to be:
         1. T^1 is a single node.
         2. T^2 is the three-node graph defined earlier.
         3. For k > 2, T^ k = T^2 ◦ T ^(k−1).
     -  The key to understanding the n-thread labeling algorithm is that the nodes covered by tokens
         can never form a cycle.
         
2.8 Lower Bounds on the Number of Locations
       -  Any deadlock-free Lock algorithm requires allocating and then reading or writing at least n
          distinct locations in the worst case.
       ++++  We will observe the following important limitation of memory locations accessed solely
         by read or write instructions (in practice these are called loads and stores): any information
         written by a thread to a given location could be overwritten (stored-to) without any
         other thread ever seeing it.
        - Definition 2.8.1. A Lock object state s is inconsistent in any global state where
            some thread is in the critical section, but the lock state is compatible with a global
            state in which no thread is in the critical section or is trying to enter the critical section.
        - Lemma 2.8.1. No deadlock-free Lock algorithm can enter an inconsistent state.