Lower Bound on the Step Complexity of Anonymous Binary Consensus

Transcription

1 Lower Bound on the Step Complexity of Anonymous Binary Consensus Hagit Attiya 1, Ohad Ben-Baruch 2, and Danny Hendler 3 1 Department of Computer Science, Technion, hagit@cs.technion.ac.il 2 Department of Computer-Science, Ben-Gurion University of the Negev, bbohad@gmail.com 3 Department of Computer-Science, Ben-Gurion University of the Negev, hendlerd@cs.bgu.ac.il Abstract. Obstruction-free consensus, ensuring that a process running solo will eventually terminate, is at the core of practical ways to solve consensus, e.g., by using randomization or failure detectors. An obstructionfree consensus algorithm may not terminate in many executions, but it must terminate whenever a process runs solo. Such an algorithm can be evaluated by its solo step complexity, which bounds the worst case number of steps taken by a process running alone, from any configuration, until it decides. This paper presents a lower bound of Ω(log n) on the solo step complexity of obstruction-free binary anonymous consensus. The proof constructs a sequence of executions in which more and more distinct variables are about to be written to, and then uses the backtracking covering technique to obtain a single execution in which many variables are accessed. 1 Introduction Consensus is an essential coordination mechanism for distributed systems: processes start with inputs from some domain and have to decide on the same output value, which is the input of some process. In asynchronous distributed systems, a consensus algorithm cannot ensure termination regardless of the way processes steps are interleaved. It is possible, however, to solve obstruction-free consensus, ensuring that a process running solo will eventually terminate. This progress property is at the core of practical ways to solve consensus, e.g., by using randomization or failure detectors. The feasibility and usefulness of obstruction-free consensus raise the important question of the resources, especially in terms of space and time, needed for solving it. An obstruction-free consensus algorithm may not terminate in many executions, and therefore, its worst-case time complexity measured over all executions is unbounded. However, since an obstruction-free consensus algorithm terminates whenever a process runs solo, i.e., without interleaving of steps This work is supported by the Israel Science Foundation (grant 1749/14). The second and third authors are also supported by the Lynne and William Center for Computing Science at Ben-Gurion University.

2 by other processes, it makes sense to evaluate its time complexity by counting the worst case number of steps taken by a process running alone, from any configuration, until it decides. This measure, called the solo step complexity [3], is formally defined in Section 2. Our Contribution: Our main result is a lower bound of Ω(log n) on the solo step complexity of obstruction-free binary anonymous consensus, where the domain of input values is {0, 1}. The first part of the proof is a construction of a sequence of executions in which more and more distinct variables are about to be written to. 4 Each of these variables must be read in some execution in the sequence, but not necessarily all in the same execution. To obtain a single solo execution in which many variables are accessed, we employ the backtracking covering technique [1,3, 6] to get an Ω(log n) lower bound for the solo step complexity of obstruction-free anonymous binary consensus. This is the first lower bound on the step complexity of a one-shot problem with inputs from a domain of constant size. As we show, the lower bound also holds for solo-fast algorithms [3, 10], in which a process only reads and writes when it runs solo, but may resort to any other primitives, including compare&swap or even general read-modify-write operations, when it encounters contention. log m log log m Related Work: Attiya et al. [3] define solo step complexity and solo-fast algorithms and prove an Ω(log n) lower bound for the space and solo step complexity of solo-fast implementations of perturbable objects. These proofs also employ the backtracking covering technique. However, the proofs hold for long-lived objects, while our lower bound is for the one-shot consensus problem. On the other hand, they do not assume that the implementation is anonymous. Adopt-Commit objects capture an inherent part of obstruction-free and randomized consensus. Aspnes and Ellen [2] prove an Ω(min{n, }) lower bound on the space and solo step complexity of anonymous Adopt-Commit objects, with input domain of size m. Since a consensus algorithm implies an implementation of an Adopt-Commit object, the same lower bounds hold for anonymous m-valued consensus. However, the bounds degenerate for binary consensus, leaving open the question of the step complexity for binary consensus, with or without an anonymity assumption. Our paper gives the first answer to this question. Aspnes and Ellen [2] also present an anonymous Adopt-Commit algorithm log log m log m whose solo step complexity is in O(min{n, }), matching their lower bound. This implies an O(1) upper bound for the solo step complexity of binary Adopt- Commit. Recent work by Capdevielle et al. [5] improves these results to bound the solo write complexity of binary anonymous consensus, i.e., the number of writes executed when a process runs solo. They show a lower bound of Ω(min{ n, log log m log m }) 4 A by-product of this part is a very simple proof of an Ω( n) lower bound for the space complexity of obstruction-free anonymous binary consensus [7, 11] (now obsolete, due to [12]).

3 problem lower bound upper bound m-valued adopt-commit Ω(min{ log n, log m }) [2] O(n) log log n log log m anonymous m-valued adoptcommit Ω(min{ log m n, }) [2, 5] O(min{ log m n, }) [2, 5] log log m log log m anonymous obstruction-free follows from above O(n) [3] m-valued consensus obstruction-free anonymous Ω(log n) (this paper) follows from above binary consensus Table 1: Lower and upper bounds for the solo step complexity of adopt-commit and consensus. on the solo write complexity of anonymous m-valued consensus. They present algorithms with a matching solo write complexity. An obstruction-free consensus algorithm with O(n) solo step complexity is implied by the results of [3]. A solo-fast consensus algorithm is presented in [10]. The Janus algorithm [4] solves obstruction-free anonymous consensus with O( n) writes and O(n) accesses to shared variables on the solo path, regardless of the number of possible values, m. Table 1 compares our results and known results. Organization: The model we use and required definitions are provided in Section 2. Our lower bound proofs appear in Section 3, and we conclude with a short discussion in Section 4. 2 Model of Computation We use a standard model of an anonymous asynchronous shared memory system. A set P of n > 1 processes p 0,..., p n 1 communicate by applying primitive operations (primitives), e.g., reads, writes and read-modify-write, to shared variables. No bound is assumed on the size of a shared variable (i.e., the number of distinct values it can take). An algorithm is a collection of deterministic state machines, one for each process. The algorithm also assigns initial values to the shared variables. Processes are anonymous, that is, they do not have access to process-identifiers and consequently, the steps they perform when executing their algorithms depend only on their initial inputs and on the responses they receive from the operations they apply. A configuration specifies the value of each shared variable and the state of each process. In an initial configuration, all shared variables have their initial values and all processes are in their initial states. Each step of process p i consists of some local computation and one shared memory event, which is a primitive applied to a shared variable and the corresponding response. A block write is a contiguous sequence of write events, each by a different process.

4 An execution fragment is a (possibly infinite) sequence of events, that result from interleaving the steps taken by processes, according to their state machines. For any finite execution fragment α and any execution fragment α, the execution fragment αα is the concatenation of α and α ; in this case α is called an extension of α. An execution is an execution fragment that starts from an initial configuration; the configuration at the end of the execution is reached by applying the events of the execution one by one starting from the initial configuration. If C is the configuration at the end of an execution α, we say that α leads to C. If another execution α starts from C, we sometimes write that α starts from α instead of writing that it starts from C. We denote the configuration reached after executing α starting from C by Cα. Two executions are indistinguishable to a process p, if p issues the same sequence of events and gets the same responses from these events in both executions. We denote by α p the sequence of events issued by p in α. Let α be an execution and let p i, p j be two processes. We say that p i, p j are clones in α (or simply clones if α is understood from the context) if they start with the same input and if α p i = α p j. An execution fragment α is Q-solo, for a non-empty set of processes Q P, if only processes in Q have events in α. If Q = {q}, we say that α is q-solo instead of {q}-solo. Unless stated otherwise, a q-solo extension from an execution α (for some process q) refers to the q-solo extension of α in which q completes its operation. A consensus object supports a single decide operation that receives an input value from some domain D. In this work, we consider binary consensus objects, for which D = {0, 1}. Decide operations by different processes must return the same output value, which must be one of the inputs. A process p participates in an execution fragment α if p has an event in α. We say that α is step-contention free for p if the events of α p are contiguous in α. Also, α is step-contention free if α is step-contention free for all processes. A process p is eventually step-contention free in α, if either p returns in α or if some suffix of α is p-solo. An algorithm is obstruction-free if every process that is eventually stepcontention free eventually returns [9]. This requirement is equivalent to solo termination [7]. Assume that p is eventually step-contention free in an execution α of an obstruction-free algorithm. Then p s solo step complexity in α is the number of steps p performs in the p-solo suffix of α until it returns. Since the algorithm is obstruction-free, this number is well-defined. The solo step complexity of the algorithm is the supremum of this number over all processes and executions. An algorithm is solo-fast if processes only apply reads and writes in stepcontention free executions but can apply additional primitives in other executions.

5 α block write γ r-solo run returns v block write γ r-solo run returns v' Fig. 1: An (α, γ)-modifying event e. 3 Lower Bound Proof The lower bound on the solo step complexity of obstruction-free consensus is proved by constructing a sequence of executions. In these executions, events applied by an operation of one process influence the response of an operation of another process. Roughly speaking, since the latter process needs to return a different value, it must be able to distinguish between the different executions, implying that it must read an increasing number of variables. Throughout the proof, p denotes a process with input 0 that has yet to run; such a process exists as long as not all of the processes participate in the execution. In addition, for any execution α, we can extend α by letting a clone of p run in order to obtain β, and then we can let another clone of p run starting from β. Although in both cases we use a clone of p, we run different processes, one starting from α with input 0, and one starting from β with input 0, where in both cases, these are processes that did not participate in the execution before. Our proofs generalize the notion of a modifying event, introduced in [8]. Let α be an execution and q be a process participating in α. We define q s solo-valency after α to be the response returned by q in a q-solo execution that extends α and ends when q completes its decide operation. We let S(α, p) denote this response. Definition 1. Let γ be a set of write events about to be applied by a set of processes R after an execution α. Let r, q / R be two processes participating in α and let e denote the event that q is about to apply after α. We say that e is an (α, γ)-modifying event for r if S(αγ, p) S(αeγ, p). We say that e is an (α, γ)- visible event for r if the sequences of events performed in the r-solo executions from αγ and from αeγ differ. We say that e is a γ-modifying event for r (a γ-visible event for p) when α can be understood from the context. Figure 1 illustrates the effect of a modifying event e. Informally, an event is an (α, γ)-modifying event for p if, when executed after α, it changes the response of a p-solo execution that follows the block write γ. An event is an (α, γ)-visible event for p if, when executed after α, p reads a different value from some variable in a solo execution that follows γ, but p s response may or may not change. Observation 1 An (α, γ)-visible event for p is a write event applied to a variable other than those to which the events of γ are applied, which is read in a p-solo extension of αeγ.

6 Proof. Let e be an (α, γ)-visible event. If e is not as specified by the observation, then p cannot distinguish between αγ and αeγ in a solo execution, which implies that the p-solo executions after αγ and after αeγ are identical. This contradicts Definition 1. Observation 2 A modifying event is a visible event. Proof. If e is not a visible event then, from Definition 1, the sequences of events performed in the p-solo extensions of αγ and of αeγ are identical. In particular, p returns the same responses in these two executions. This contradicts Definition 1. We now define the notion of a visible sequence of executions {α i γ i } L i=1, which is central to our proof. The i th execution ends with a block write γ i, to i distinct variables. The key requirement is that, for all i and u {0, 1}, there is an extension of α i in which a process qi u p returns u while γ i is still pending. Letting v denote p s solo-valency after α i γ i, this allows us to construct the next sequence execution by deploying qi v until it is about to perform a γ i-visible event for p. Definition 2. A visible sequence of length L is a sequence of executions {α i γ i } L i=1 such that the following requirements hold: 1. At most 1 2 i(i + 1) processes participate in α i. 2. γ i is a block write by i different processes to i different variables. 3. For v {0, 1}, there exists a process q v i p and a block write γv i γ i, such that S(α i γ v i, qv i ) = v. Moreover, the (i + 1) th visible execution is constructed from the i th visible execution as follows: Let S(α i γ i, p) = v and let q i and γ γ i be such that S(α i γ, q i ) = v. Let β denote the q i -solo extension from α i γ (in which q i returns v) and let β = β e i β, where e i is the first γ i -visible event for p in β. Then α i+1 = α i γβ and γ i+1 = e i γ i, where the events of γ are re-issued in γ i+1 by new clone processes. Figure 2 illustrates the manner in which execution α i+1 γ i+1 is constructed from α i γ i. We now prove that any anonymous consensus algorithm has a visible sequence of length approximately n. This sequence will be used in order to obtain the step complexity lower bound, using the backtracking covering technique. Lemma 1. Let A be an obstruction-free anonymous binary consensus algorithm, then A has a visible sequence of length Ω( n). Proof. The construction of the visible sequence is inductive. In the i th step of the induction, we construct execution α i γ i. Throughout the proof, we fix process p to be some process with input 0. We assume that at least n/2 of the processes have input 0 and at least n/2 of them have input 1.

7 Let C 0 be an initial configuration. For the base case, let q1 1 be a process with input 1. Let α denote a q1-solo 1 execution starting from C 0. Clearly, q1 1 must write in the course of α to a variable that is read by a p-solo execution from C 0. Let α 1 denote the prefix of α up until q1 s 1 first such write event, denoted e. Let γ 1 = e, then γ 1 is a block write of size 1. Let q1 0 p be a process with input 0. Process q1 0 is a clone of p in C 0. By setting γ1 0 to be the empty sequence of events, a q1-solo 0 extension from α 1 γ1 0 returns 0 (as would a p-solo execution), whereas by setting γ1 1 = {e}, a q1-solo 1 extension from α 1 γ1 1 returns 1, implying that Requirements 2 and 3 of Definition 2 hold. In addition, exactly one process participates in α 1, implying that Requirement 1 also holds for the base case. For the induction step, consider an execution α i γ i that satisfies Requirements 1-3 of Definition 2. Let C i = C 0 α i and let S(α i γ i, p) = v. From Requirement 3 of the induction hypothesis, there exist qi v (which will play the role of q i in the construction of Definition 2 ) and γi v γ i (which will play the role of γ) such that S(α i γi v, qv i ) = v. Let β denote the qv i -solo extension of α iγi v. Since the algorithm is anonymous, we can use clones after α i for processes in γi v so that the block write γ i can be performed after the γi v block write. Process p returns v in a p-solo extension of α i γi vγ i (which is indistinguishable to p from α i γ i ) but returns v in a p-solo extension of α i γi vβγ i, hence, qi v must perform a γ i -modifying event e for p in β. Consequently, from Observation 2, qi v performs a γ i -visible event for p in β. Thus, the γ i -visible event e i specified by Definition 2 exists. As specified by Definition 2, let β = β e i β, α i+1 = α i γi vβ and γ i+1 = e i γ i. Since e i is a γ i -visible event, from Observation 1, it is a write event to a variable not covered by γ i. Hence, γ i+1 is a block write by i + 1 different processes to i + 1 different variables. Therefore, Requirement 2 holds. A qi v-solo extension of α i+1e i returns v (as this is a continuation of α i γi vβ e i ), thus by taking qi+1 v = qv i and γi+1 v = {e i}, we get that qi+1 v returns v when running solo after α i+1 γi+1 v. Let qv i+1 p be a process with input 0 that does not α i+1 γ i+1 α i γ β' by q i e i γ i Fig. 2: The inductive execution construction of Definition 2. Process q i is designated as q v i+1 with corresponding γ v i+1 = {e i}; a clone of p is designated as q v i+1 with corresponding γ v i+1 = γ i (see the proof of Lemma 1).

8 participate in α i+1 γ i+1. qi+1 v is a clone of p in α i. Hence, a qi+1 v -solo extension of α i+1 γ i returns v (as would a p-solo execution). Thus, by taking γi+1 v = γ i we get that qi+1 v returns v when running solo after α i+1γi+1 v. Therefore, Requirement 3 holds. Since γi v i, we employ at most i + 1 new clones in order to extend α i and obtain α i+1. By the induction hypothesis, at most 1 2i(i+1) processes participate in α i, and hence, at most 1 2 (i + 1)(i + 2) processes participate in α i+1. Even if all the processes that participate in α i have the same input, as long as i < n/2 there is a sufficient number of processes to construct α i+1 γ i+1. It follows that our construction may proceed for at least n/2 iterations. Since every obstruction-free anonymous binary consensus algorithm has a visible sequence of length Ω( n), Requirement 2 of Definition 2 implies: Corollary 1. Let A be an obstruction-free read/write anonymous binary consensus algorithm, then A uses Ω( n) distinct shared variables. To conclude the lower bound proof, we now show that any algorithm with a visible sequence of length L has an execution that reaches a configuration C, such that a solo run by process p starting at C reads at least log 2 L different variables. Let A be an algorithm that has a visible sequence {α i γ i } L i=1. Let e i denote the event used in Definition 2 to construct the (i+1) th visible execution, that is, γ i+1 = e i γ i. Also, let φ i denote the p-solo extension from α i γ i. Our goal is to prove that in one of the solo extensions φ i, p reads a large set of variables. Let π i denote the sequence of distinct variables read by p in φ i, in the order of their first read in φ i. If all the variables read in φ i are always read also in φ i+1, then, since we know that e i writes to a variable not covered by γ i that is read in the course of φ i+1, the size of π i is always at least i, so that π L is of size at least L. However, this is not necessarily the case, as it may happen that reading the value written by e i causes p to backtrack and avoid reading some of the variables of π i, thus making π i+1 shorter than π i. The backtracking covering technique [1,3,6] is used to derive a step complexity lower bound even when the latter scenario occurs for some i. The technique associates with each sequence π i a binary number Ψ i. The most significant bit of Ψ i is 1 if the first variable read by p in φ i is covered by γ i and 0 otherwise. The second most significant bit is 1 if the second variable read by p in φ i (if it exists) is covered and 0 otherwise, and so on. If we assume (towards a contradiction) that all sequences φ i are of length smaller than L, then every sequence π i, i {1,..., L}, may be represented by a Ψ i that is a log 2 L-digit number. The basic idea underlying the proof is that a variable v read in π i may be absent from π i+1 (that is, p backtracks from the read of v) only if the write in e i is to a variable that precedes v in π i. The simple intuition is that p avoids reading v in φ i+1 although it reads it in φ i, only if it reads from some variable v that precedes v in φ i different values in φ i and φ i+1.

9 In terms of the values of Ψ, this implies that a less significant bit of Ψ may be flipped from 1 to 0 only if a more significant bit of Ψ is flipped from 0 to 1. 5 If no digits are flipped, then all the variables read in φ i are read also in φ i+1 (that is, there is no backtracking) but a variable not covered by γ i is covered be e i, hence the value of Ψ grows as well. It follows that function Ψ is monotonically increasing. Since it increases L times, it cannot be that all sequences π i are represented by numbers with fewer than log 2 L binary bits, hence, at least one of the executions φ i reads at least log 2 L variables. We formalize these arguments in the proof of the following lemma. Lemma 2. Let A be an algorithm that has a visible sequence of executions of length L. Then A has an execution in which some process accesses at least log 2 L different variables in the course of a solo execution. Proof. We prove that one of the p-solo execution fragments φ i accesses at least log 2 L different variables. For simplicity, and without loss of generality, we assume that L is an integral power of 2 and let s = log 2 L 1. We define a monotone increasing progress function Ψ i as follows: Ψ i is a (log 2 L)-bit number, where the j th bit is 1 if and only if φ i accesses at least j variables and the j th variable (in the order of first variable-accesses) is covered by γ i. Thus, the j th bit of Ψ i is 0 if either φ i accesses fewer than j variables or, otherwise, if the j th variable accessed in φ i is not covered by γ i. If there exists an i such that π i > s then we are done. Otherwise π i s for all i, hence, for all i {1,..., L}, every variable of π i has a corresponding bit of Ψ i. Recall the construction of α i+1 from α i by Lemma 1. The construction was done by extending α i with write steps to some of the variables covered by γ i (while keeping these variables covered by clone processes). The construction then proceeded by a q i -solo execution until q i was about to perform a write step e i to an uncovered variable. In terms of the value of Ψ, event e i may flip some of the bits of Ψ i from 1 to 0, if the corresponding variables are not accessed in φ i+1. However, this may happen only if e i covers an earlier variable, that is, if e i covers a variable that corresponds to a more significant bit of Ψ, and thus Ψ i+1 > Ψ i. To proceed with the corresponding formal argument, let Ψ i [j] denote the j th (in left to right order) bit of Ψ i : Ψ i = s 2 s j Ψ i [j] j=0. We now show that Ψ i+1 > Ψ i for all i {1,..., L 1}. To see this, recall that the i + 1 sequence execution is constructed by extending α i with execution fragment γβ e i, where β e i is a q i -solo execution such that e i is its first γ i -visible 5 Note that once a variable becomes covered in the executions we construct for our proofs, it remains covered, so a bit of Ψ may be flipped from 1 to 0 only if the corresponding variable was read in φ i and is no longer read in φ i+1.

10 event for p. From Definition 1, e i is the first write step by q i to a variable u not covered by γ i that is accessed in the course of a solo execution by p after α i γ i. Hence, u appears in π i. Let k be the index of u in π i. Variable u was not covered before by γ i, therefore Ψ i [k] = 0. For every j < k, Ψ i [j] = Ψ i+1 [j] because e i is the first write by q i to a variable not covered by γ i, and therefore, e i does not change any of the bits corresponding to the variables that precede u in π i : if any such variable was covered by γ i, then it is also covered by γ i+1. Moreover, e i causes bit k of Ψ i to flip from 0 to 1, since it covers the k th variable accessed in φ i (which is also the k th variable accessed in φ i+1 ). We get: Ψ i+1 = s 2 s j Ψ i+1 [j] j=0 k 1 = 2 s j Ψ i+1 [j] + 2 s k + j=0 k 1 2 s j Ψ i+1 [j] + 2 s k j=0 k 1 > 2 s j Ψ i+1 [j] + j=0 Ψ i s j=k+1 s j=k+1 2 s j 2 s j Ψ i+1 [j] Using the last inequality and the fact that Ψ 1 > 0 (as γ 1 covers a variable accessed in φ 1 ) we conclude that Ψ L L. However, Ψ is a (log L)-bit number and therefore cannot exceed L 1. This is a contradiction. Thus, there must be an i such that π i > s, as required. Theorem 1. The solo step complexity of any read/write obstruction-free anonymous consensus algorithm is Ω(log n). Proof. From Lemma 1, any read/write obstruction-free anonymous algorithm for binary consensus has a visible sequence of executions of length Ω( n). The theorem now follows from Lemma 2. Unlike read/write algorithms, solo-fast algorithms are allowed to perform stronger synchronization operations (such as compare-and-swap or fetch-andadd) in the face of step contention. We now strengthen Theorem 1 by showing that it holds also for solo-fast implementations. This would have been immediate if the executions we construct to prove Theorem 1 were step-contention free, but this is not the case. To see this, consider the construction of α i+1 in Definition 2. A new process q i runs solo after α i γ until about to perform its first γ i -visible event e i, which is used to extend the block write. If and when e i is eventually executed (as part of a block write γ associated with some later process q j, j > i), the execution may have already been extended by steps of processes other than q i, making q i s execution non step-contention free.

11 Though not step-contention free, it is easy to show that all the events of the executions in a visible sequence are issued by processes that are unaware of step contention. It follows that these executions may be constructed also for solo-fast implementations. A formal proof follows. Let α be a step-contention free execution for some process p and let α be an execution that is indistinguishable to p from α. Let e be the event that p is about to perform after α, then we say that e is issued while p is unaware of step contention. This notion was defined in [3]. Lemma 3. Let α = α i γ i be an execution of a visible sequence, then all the events of α are issued by processes that are unaware of step contention. Proof. (Sketch.) We consider the events performed by processes that participate in α. The proof proceeds by case analysis on the sets of participating processes. 1. Processes deployed by the inductive construction. Let q be a process that is deployed in the i th step of the inductive construction as q i (see Definition 2). When q first joins the execution (either as process q1 1 in the base case or as a clone of process p named qi+1 v, see the proof of Lemma 1), it runs solo until about to perform a γ i -visible event, e i. If e i is not a modifying event, then q is designated as qi+1 v and e i is designated as γi+1 v (see the proof of Lemma 1). Process q is then deployed also in the next inductive construction step, after its step e i is executed (as part of γ i+1, see Definition 2). Eventually, either the construction terminates or there is a step j > i of the inductive construction when q (now called q j in Definition 2) is about to execute a visible event, e j, which is also a modifying event. This is the last event executed by q in the construction. Apart from clone processes that run in lockstep with q, no events by other processes are interleaved within its steps. Thus, all the events of this set of processes are issued when they are unaware of step contention. 2. Clones for processes that execute an event in γi v (see the proof of Lemma 1), for 1 i < L. Each clone runs in lockstep with its respective original process (and possibly also with the steps of additional clones) and performs exactly the same steps, until the original process executes an event e i which is part of γi v, for some 1 i < L and v {0, 1}. Then, the clone s last event (which is identical to e i ) becomes part of γ i+1. Hence, also the events of these processes are issued when they are unaware of step contention. It follows from the above case analysis that all participating processes run solo or in lockstep with their clones until they are about to perform their last event, hence they all issue their events when they are unaware of step contention. Corollary 2. Let A be a solo-fast obstruction-free anonymous binary consensus algorithm. Then the solo step complexity of A is Ω(log n). Proof. A visible sequence of executions of A can be constructed as prescribed by Lemma 1 as long as all processes may only perform reads and writes. From

12 Lemma 3, all the events in these executions are by processes that are unaware of step contention, hence they may only perform reads and writes. Process p itself runs solo as it executes φ i after visible execution i (see the proof of Lemma 1), for i {1,..., L}, hence it encounters no step contention. 4 Discussion This paper presents the first lower bound, of Ω(log n), for the solo step complexity of obstruction-free anonymous binary consensus. Previously, there were no nontrivial lower bounds on the time complexity of obstruction-free binary consensus. This improves our understanding of the time complexity of obstructionfree consensus, which has been lagging behind our understanding of its space complexity. Recently, the question of the space complexity of binary obstructionfree consensus (with solo termination) has been largely settled, showing that Ω(n) shared variables are necessary [12]. An obvious open question is to remove the anonymity assumption, possibly exploiting ideas from the recent lower bound on the space complexity of consensus [12]. Another direction is to improve the lower bound, with or without the anonymity assumption, or to find a matching upper bound. References 1. Aspnes, J., Attiya, H., Censor-Hillel, K., Hendler, D.: Lower bounds for restricteduse objects. In: SPAA. pp (2012) 2. Aspnes, J., Ellen, F.: Tight bounds for adopt-commit objects. Theory of Computing Systems 55(3), (2013) 3. Attiya, H., Guerraoui, R., Hendler, D., Kuznetsov, P.: The complexity of obstruction-free implementations. J. ACM 56(4) (2009) 4. Bouzid, Z., Sutra, P., Travers, C.: Anonymous agreement: The Janus algorithm. In: OPODIS. pp (2011) 5. Capdevielle, C., Johnen, C., Kuznetsov, P., Milani, A.: Brief announcement: On the uncontended complexity of anonymous consensus. In: DISC. p. 667 (2015) 6. Ellen, F., Hendler, D., Shavit, N.: On the inherent sequentiality of concurrent objects. SIAM J. Comput. 41(3), (2012) 7. Fich, F., Herlihy, M., Shavit, N.: On the space complexity of randomized synchronization. J. ACM 45(5), (1998) 8. Hendler, D., Shavit, N.: Solo-valency and the cost of coordination. Distributed Computing 21(1), (2008) 9. Herlihy, M., Luchangco, V., Moir, M.: Obstruction-free synchronization: Doubleended queues as an example. In: ICDCS. pp (2003) 10. Luchangco, V., Moir, M., Shavit, N.: On the uncontended complexity of consensus. In: DISC. pp (2003) 11. Zhu, L.: Brief announcement: Tight space bounds for memoryless anonymous consensus. In: DISC. pp (2015) 12. Zhu, L.: A tight space bound for consensus. In: STOC (2016), to appear