Proof Outline

Throughout the rest of this paper, we let A = (P, V, δ) be an arbitrary local-spin algorithm for n > 3 processes and let sinit be an initial system state of A. To prove the lower bound of three on the RMR time complexity, the objective is to construct an execution of A from sinit in which some process takes at least three RMR steps to enter and exit C once. We call such an execution a goal execution.

A goal execution will be constructed in the following way. We start by con-structing n solo executions, one per process, each starting from sinit and involving its steps only until it has just entered C. (The progress condition implies that this is possible.) For each i ∈ P, let αi denote the solo execution of i. Next, for each αi

and each process j 6= i, we extend αi to what is denoted by αij by running j alone until j has just entered a system state at which j is locally spinning in T. Execution αij exists according to Lemma 5.5. The lower bound proof focuses on the set of all αij’s, called set E. More precisely, we define

E = {αij| i, j ∈ P and i 6= j}.

We show that a goal execution can be constructed by extending some execution in E.

Consider the number of RMR steps that have been taken by each process in each execution in E. For brevity, let time(i, αij) and time(j, αij) respectively denote the number of RMR steps taken by i and j in their trying regions in αij. Then two cases are discussed.

Case 1. ∃ αij ∈ E : time(i, αij) ≥ 2 or time(j, αij) ≥ 2.

Let αij ∈ E be such an execution. A goal execution can be extended from αij

by applying the inherent cost lemma.

Figure 5.1: A goal execution extended from αij in which time(i, αij) ≥ 2.

If time(i, αij) ≥ 2, we extend αij to an execution in which i takes at least one RMR step in its corresponding exit region so that i takes at least three RMR steps in total. The way to extend αij is described as follows and is illustrated in Fig. 5.1. From the end of αij, we let i leave C first and then let i and j take enabled steps alternately until j enters C. Since i and j take enabled steps alternately, this execution is admissible. Thus, the progress condition implies that j eventually enters C. By the inherent cost lemma, there exists at least one RMR step to j, which must be taken by i because only processes i and j are involved, in the portion of the resulting execution after αij.

If time(i, αij) ≥ 2 does not hold, it must be the case that time(j, αij) ≥ 2 holds. Similarly, by the inherent cost lemma, we extend αij to an execution in which j instead of i takes at least one RMR step in its corresponding exit region. The construction will be given in the detailed proof.

Case 2. ∀ αij ∈ E : time(i, αij) < 2 and time(j, αij) < 2.

This case is the core of the lower bound proof. We construct a goal execution in which some process takes one RMR step in T and takes at least two RMR steps in its corresponding exit region.

We first use the following property, called the rendezvous property, which says that in most executions in E, processes communicate through the same

remote shared variable: (The property will be proved in the next subsection.) Suppose that for all αij ∈ E, processes i and j each access at most one remote shared variable in αij. Then there exists a shared vari-able v such that for all αij ∈ E that v is remote to both i and j, both i and j must access v in αij. More precisely,

∃ v ∈ V, ∀ αij ∈ E, v 6∈ Vi and v 6∈ Vj : both i and j must access v in αij. Since for all αij ∈ E, time(i, αij) < 2 and time(j, αij) < 2, i and j each access at most one remote shared variable in αij. Therefore, the above property guarantees the existence of such a shared variable v. Let m be the process to which v is local. We conclude that for each αij with i 6= m and j 6= m, we always have time(i, αij) = 1 and time(j, αij) = 1. Furthermore, both i and j must access the same remote shared variable v.

Take any three distinct processes i, j and k that are different from m. Processes i, j and k exist since n > 3. Consider αij and αik. By the conclusion above, i and j each take exactly one RMR step in αij, and they access the shared variable v, which is located at process m. Likewise, i and k each take exactly one RMR step in αik, and they access v. A goal execution can be constructed by extending either αij or αik, in which i takes at least two more RMR steps in addition to the one it has taken in αij or αik. The construction is illustrated in Fig. 5.2.

First, we extend αij to α⁰_ij in the same way as that shown in Fig. 5.1, i.e., by letting i leave C and then running i and j until j reaches C. In the suffix of α⁰_ij after αij, if i takes at least two RMR steps, α⁰_ij is already a goal execution.

Otherwise, the inherent cost lemma implies that i takes exactly one RMR step, which is from i to j. Based on this implication, a goal execution α⁰_ik is constructed below.

Execution α⁰_ik begins with αik, in which i has taken one RMR step. It then continues by letting process i run alone until it takes the RMR step to j

Figure 5.2: A goal execution extended from either αij or αik. We write e to denote the RMR step from i to j.

as it does in the suffix of α⁰_ij after αij. This is possible mainly because αij(sinit)∼ⁱ

Vi

αik(sinit). (A precise argument will be given in the detailed proof.) It finishes by running processes i and k until k enters C ; along the way, the inherent cost lemma guarantees that i must take at least one RMR step to k. Thus, i takes at least three RMR steps in α⁰_ik, and thereby α_ik⁰ is a goal execution.