Efficient Randomized Test-And-Set Implementations

TL;DR

This paper introduces efficient randomized test-and-set implementations using group election, improving expected step complexities and space efficiency, and provides bounds on process steps under certain adversaries.

Contribution

It presents new TAS algorithms with improved expected max-step complexities and space efficiency, and introduces the group election problem as a key component.

Findings

Expected max-step complexity $O(\log^ extasteriskcentered k)$ in location-oblivious model

Expected max-step complexity $O(\log\log k)$ against read/write-oblivious adversary

Space complexity reduced from super-linear to linear in a modified TAS algorithm

Abstract

We study randomized test-and-set (TAS) implementations from registers in the asynchronous shared memory model with n processes. We introduce the problem of group election, a natural variant of leader election, and propose a framework for the implementation of TAS objects from group election objects. We then present two group election algorithms, each yielding an efficient TAS implementation. The first implementation has expected max-step complexity $O(\log^\ast k)$ in the location-oblivious adversary model, and the second has expected max-step complexity $O(\log\log k)$ against any read/write-oblivious adversary, where $k\leq n$ is the contention. These algorithms improve the previous upper bound by Alistarh and Aspnes [2] of $O(\log\log n)$ expected max-step complexity in the oblivious adversary model. We also propose a modification to a TAS algorithm by Alistarh, Attiya, Gilbert, Giurgiu, and Guerraoui [5] for the strong adaptive adversary, which improves its space complexity from super-linear to linear, while maintaining its $O(\log n)$ expected max-step complexity. We then describe how this algorithm can be combined with any randomized TAS algorithm that has expected max-step complexity $T(n)$ in a weaker adversary model, so that the resulting algorithm has $O(\log n)$ expected max-step complexity against any strong adaptive adversary and $O(T(n))$ in the weaker adversary model. Finally, we prove that for any randomized 2-process TAS algorithm, there exists a schedule determined by an oblivious adversary such that with probability at least $(1/4)^t$ one of the processes needs at least t steps to finish its TAS operation. This complements a lower bound by Attiya and Censor-Hillel [7] on a similar problem for $n\geq 3$ processes.

Tables

Table 1. Table 1: Randomized TAS implementations. In the second column we give the expected max-step complexity of the algorithm.

Adversary	Time	Space	Reference	Comments
strong adaptive	unbounded	$\lceil \log n\rceil +1$	[21]	deadlock-free only
strong adaptive	$O\left(1\right)$	$\Theta \left(1\right)$	[22, 23]	2-process implementation
strong adaptive	$O\left(\log n\right)$	$\Theta \left(n\right)$	[1]	-
strong adaptive	$O\left(\log k\right)$	$\Theta \left(n^3\right)$	[5]	$k$ is the contention
r/w-oblivious	$O\left(\log \log n\right)$	$\Theta \left(n^3\right)$	[2]	-
location-oblivious	$O\left({\log }^{\ast }k\right)$	$\Theta \left(n\right)$	Theorem 4	-
r/w-oblivious	$O\left(\log \log k\right)$	$\Theta \left(n\right)$	Theorem 6	-
strong adaptive	$O\left(\log k\right)$	$\Theta \left(n\right)$	Theorem 7	-
oblivious	$O\left({\log }^{\ast }k\right)$	$\Theta \left(\log n\right)$	[13]	uses impl. of Theorem 4

Equations

$$\sigma_{i+1}=A\Bigl{(}\mathcal{E}_{M}\bigl{(}(\sigma_{1},\dots,\sigma_{i}),\omega\bigr{)}\Bigr{)}.$$

$$\underset{p}{\max }{T}_{op,p}(\mathcal{E}).$$

$$E\left[\underset{p}{\max }{T}_{op,p}({\mathcal{E}}_{M,A})\right],$$

$$\tau (k):=\underset{{\mathcal{E}}^{\prime }\in {Exec}_{M,A,op}(k)}{\sup }E\left[\underset{p}{\max }{T}_{op,p}({\mathcal{E}}_{M,A})|\text{EM,A is an extension of E′}\right].$$

$$\mathrm{Pr}\left(\underset{p}{\max }{T}_{op,p}({\mathcal{E}}_{M,A})\le b(k)|\text{EM,A is an extension of E′}\right)\ge q(k),\text{ for all }{\mathcal{E}}^{\prime }\in {Exec}_{M,A,op}(k).$$

$$\phi (k):=\underset{{\mathcal{E}}^{\prime }\in {Exec}_{M,A,G}(k)}{\sup }E\left[win({\mathcal{E}}_{M,A})|\text{EM,A is an extension of E′}\right].$$

$$f^{\ast }(x)=\inf \{i:f^{(i)}(x)\le 1\}.$$

$$j^{\ast }:=\underset{j}{\max }\{m_j\ge 1\}\le n.$$

$$k_j=k_{max}^{M,G[j]}({\mathcal{E}}_j).$$

$$\operatorname{\mathbf{E}}[T(\mathcal{E})\mid\mathcal{E}_{0}]=O\big{(}t(k)\cdot g^{\ast}(k)\big{)}.$$

$$E[e_j\mid {\mathcal{E}}_j]\le f(k_j).$$

$$E[E[e_j\mid {\mathcal{E}}_j]\mid {\mathcal{E}}_0]\le E[f(k_j)\mid {\mathcal{E}}_0].$$

$$E[e_j\mid {\mathcal{E}}_0]\le f(E[k_j\mid {\mathcal{E}}_0]).$$

$$E[e_1\mid {\mathcal{E}}_0]\le f(E[k_1\mid {\mathcal{E}}_0])\le f(E[k_0\mid {\mathcal{E}}_0])=f(k_0),$$

$$E[e_j\mid {\mathcal{E}}_0]\le f(E[e_{j-1}\mid {\mathcal{E}}_0]).$$

$$E[e_j\mid {\mathcal{E}}_0]\le f^{(j)}(k_0).$$

$$E[j^{\ast }\mid {\mathcal{E}}_0]\le j+f^{(j)}(k_0).$$

$$x:=\max \{y\le k_0:f(y)\ge y-1\},\lambda :=\min \{i:f^{(i)}(k_0)\le x\}.$$

$$f(y)\ge y-1,\text{ for }0\le y\le x.$$

$$E[j^{\ast }\mid {\mathcal{E}}_0]\le g^{\ast }(k_0)+1.$$

$$E[t_j\mid {\mathcal{E}}_j]\le t(k_j).$$

$$E[t_j\mid j^{\ast }\ge j]\le t(k_0),$$

$$E\left[\sum _{1\le j\le j^{\ast }}{t}_j\right]\le t(k_0)\cdot E[j^{\ast }].$$

$$E\left[\sum _{1\le j\le j^{\ast }}{t}_j^{\prime }\right]=O(1)\cdot E[j^{\ast }].$$

$$t(k_{0})\cdot\operatorname{\mathbf{E}}[j^{\ast}]+O(1)\cdot\operatorname{\mathbf{E}}[j^{\ast}]+O(\operatorname{\mathbf{E}}[j^{\ast}])\stackrel{{\scriptstyle\eqref{eq:expiast}}}{{=}}O\big{(}t(k_{0})\cdot g^{\ast}(k_{0})\big{)}.$$

$$\operatorname{\mathbf{E}}\Biggl{[}\sum_{1\leq i\leq k^{\prime}}X_{i}\Biggr{]}\leq\operatorname{\mathbf{E}}\Biggl{[}\sum_{1\leq i\leq k}Y_{i}\Biggr{]}=\sum_{1\leq i\leq k}\operatorname{\mathbf{E}}[Y_{i}].$$

$$E[Y_i]$$

$$\displaystyle=\sum_{1\leq x\leq\ell}\Pr\Biggl{(}\left(x_{i}=x\right)\,\wedge\,\bigwedge_{1\leq j<i}\left(x_{j}\neq x+1\right)\Biggr{)}$$

$$\displaystyle\stackrel{{\scriptstyle\text{($\dagger$)}}}{{=}}\sum_{1\leq x<\ell}\Pr\Biggl{(}\left(x_{i}=x\right)\,\wedge\,\bigwedge_{1\leq j<i}\left(x_{j}\neq x+1\right)\Biggr{)}+\Pr(x_{i}=\ell)$$

$$\stackrel{\text{(∗)}}{=}\sum _{1\le x<\ell }\mathrm{Pr}(x_i=x)\prod _{j=1}^{i-1}\mathrm{Pr}(x_j\ne x+1)+\frac{1}{2^{\ell -1}}$$

$$=\sum _{1\le x<\ell }\frac{1}{2^x}{\left(1-\frac{1}{2^{x+1}}\right)}^{i-1}+\frac{1}{2^{\ell -1}}.$$

$$\displaystyle\operatorname{\mathbf{E}}\Biggl{[}\sum_{1\leq i\leq k^{\prime}}X_{i}\Biggr{]}$$

Full text

We also propose a modification to a TAS algorithm by Alistarh, Attiya, Gilbert, Giurgiu, and Guerraoui [5] for the strong adaptive adversary, which improves its space complexity from super-linear to linear, while maintaining its $O(\log n)$ expected max-step complexity. We then describe how this algorithm can be combined with any randomized TAS algorithm that has expected max-step complexity $T(n)$ in a weaker adversary model, so that the resulting algorithm has $O(\log n)$ expected max-step complexity against any strong adaptive adversary and $O(T(n))$ in the weaker adversary model.

Finally, we prove that for any randomized 2-process TAS algorithm, there exists a schedule determined by an oblivious adversary such that with probability at least $1/4^{t}$ one of the processes needs at least $t$ steps to finish its TAS operation. This complements a lower bound by Attiya and Censor-Hillel [7] on a similar problem for $n\geq 3$ processes.

1 Introduction

In this paper we study time and space efficient implementations of test-and-set (TAS) objects from atomic registers in asynchronous shared memory systems with $n$ processes. The TAS object is a fundamental synchronization primitive, and has been used in algorithms for classical problems such as mutual exclusion and renaming [17, 20, 11, 9, 5, 4, 3].

A TAS object stores a bit that is initially 0, and supports the operation TAS(**), which sets the bit (or leaves it unchanged if it is already set) and returns its previous value; the process whose call returns 0 is the winner of the object. TAS objects are among the simplest natural primitives that have no deterministic wait-free linearizable implementations from atomic registers, even in systems with only two processes. In fact, in systems with exactly two processes, a consensus protocol can be implemented deterministically from a TAS object and vice versa.

The TAS problem is very similar to the problem of leader election. In a leader election protocol, every process decides for itself whether it becomes the leader (it returns win) or whether it loses (it returns lose). At most one process can become the leader, and not all participating processes can lose. I.e., if all participating processes finish the protocol, then exactly one of them returns win and all others return lose. Obviously, any TAS object immediately yields a leader election protocol: Each process executes a single TAS() operation and returns win if the TAS() call returns 0, or lose if TAS(**) returns 1. Similarly, a leader election algorithm, together with one additional register, can be used to implement a linearizable TAS object with just a constant increase in the number of steps [15]. Similar transformations from leader election to linearizable TAS objects are implicit in several TAS algorithms, e.g., [1, 2].

Early randomized TAS implementations assumed a strong adaptive adversary model, where the adversary bases its scheduling decisions on the entire past history of events, including the coin flips by processes. Tromp, and Vitányi [22, 23] presented a randomized implementation for two processes which has constant expected max-step complexity and constant space complexity against any strong adaptive adversary. (The max-step complexity of an execution is the maximum number of steps any process needs to finish its algorithm in the execution. See Section 2.2 for formal definitions and a discussion.) Afek, Gafni, Tromp, and Vitányi [1] gave a deterministic implementation of a TAS object for $n$ processes, from $O(n)$ 2-process TAS objects. Any execution of this algorithm has max-step complexity $O(\log n)$. Using Tromp and Vitányi’s randomized 2-process TAS implementation, one obtains a randomized implementation of a TAS object from registers with $O(\log n)$ expected max-step complexity in the strong adaptive adversary model. Alistarh, Attiya, Gilbert, Giurgiu, and Guerraoui [5] presented an adaptive variant of that algorithm, called RatRace, in which the expected max-step complexity is logarithmic in the contention $k$, i.e., the total number of processes accessing the TAS object. The space requirements of RatRace are higher, though, as $\Theta(n^{3})$ registers are used.

No TAS algorithm with a sub-logarithmic expected max-step complexity against any strong adaptive adversary has been found yet, and no non-trivial time lower bounds are known either. The strong adaptive adversary, however, may be too strong in some settings to model realistic system behavior. Motivated by the fact that consensus algorithms benefit from weaker adversary models, Alistarh and Aspnes [2] devised a simple and elegant TAS algorithm with an expected max-step complexity of $O(\log\log n)$ for the oblivious adversary model, where the adversary has to make all scheduling decisions at the beginning of the execution. We will refer to this algorithm as the AA-algorithm. Although not explicitly mentioned in [2], the AA-algorithm works even for a slightly stronger adversary, the read/write-oblivious (r/w-oblivious) adversary. Such an adversary can take all past operations of processes, including coin flips, into account when making scheduling decisions, but it cannot see whether a process will read or write in its next step, if that decision is made by the process at random. The space complexity of the AA-algorithm is super-linear, as it uses RatRace as a component.

Our contribution.

In view of their AA-algorithm, Alistarh and Aspnes asked whether any better TAS algorithm exists for the oblivious or even stronger adversary models. We answer this question in the affirmative: We present an adaptive algorithm that has an expected max-step complexity of $O(\log^{\ast}k)$ in the oblivious adversary model, where $k$ is the contention. In fact, our result holds for the slightly stronger location-oblivious adversary. This adversary makes scheduling decisions based on all past events (including coin flips), but it does not know which register a process will access in its next step, if this decisions is made at random.

This algorithm, however, is not efficient in the r/w-oblivious adversary model. For such adversaries, we devise a different algorithm that has expected max-step complexity $O(\log\log k)$, and uses $O(n)$ registers. It is similar to the AA-algorithm, but introduces a new idea that makes it adaptive.

Our two TAS algorithms above are the first ones with sub-logarithmic expected max-step complexity that need only $O(n)$ registers.

Both algorithms rely on a novel framework that uses a variant of the leader election problem, called group election, in which more than one process can get elected. We present a TAS implementation based on multiple such group election objects. The performance of the implementation is determined by the effectiveness of the group election objects used, which is measured in terms of the expected number of processes that get elected.

The AA-algorithm has the desirable property that its performance degrades gracefully when the adversary is not r/w-oblivious, and against a strong adaptive adversary it still achieves an expected max-step complexity of $O(\log k)$. In their basic form, our algorithms do not exhibit such a behavior—a strong adaptive adversary can find a schedule where processes need $\Omega(k)$ steps to complete their TAS(**) operation. To rectify that, we present a general method to combine any TAS algorithm with RatRace, so that if the algorithm has expected max-step complexity $T(k)$ against any r/w-oblivious or location-oblivious adversary, then the combined algorithm has expected max-step complexity O\bigl{(}T(k)\bigr{)} in the same adversary model, and $O(\log k)$ against any strong adaptive adversary. Further, we propose a modification of RatRace that improves its space complexity from $O(n^{3})$ to $O(n)$, without increasing its expected max-step complexity. Thus, combining this algorithm with any of our two algorithms for weak adversaries, yields an algorithm with linear space complexity.

Finally, we show for any randomized TAS implementation for two processes, that the oblivious adversary can schedule processes in such a way that for any $t>0$, with probability at least $1/4^{t}$ one of the processes needs at least $t$ steps to finish its TAS(**) operation. This result immediately implies the same lower bound on 2-process consensus. Attiya and Censor-Hillel [7] showed that with probability at least $1/c^{t}$, for some constant $c$, any randomized $f$-resilient $n$-process consensus algorithm does not terminate within a total number of $t(n-f)$ steps. However, the lower bound proof in [7] only works for $n\geq 3$ processes. Thus our result fills in the missing case of $n=2$.

In the conference version of this paper [14], we also proved a lower bound of $\Omega(\log n)$ for the number of registers needed to implement nondeterministic solo-terminating TAS. After the conference paper was published, Dan Alistarh made us aware that a proof by Styer and Peterson from 1989 [21] implies this result. In particular, Styer and Peterson [21] showed that any implementation of deadlock-free leader election requires at least $\lceil\log n\rceil+1$ registers. They also described a deadlock-free (deterministic) leader election algorithm that uses $\lceil\log n\rceil+1$ registers. However, this algorithm is not wait-free (and thus has unbounded step complexity).

Until recently, it was not unknown whether any randomized wait-free (or obstruction-free) TAS implementation exists that uses fewer than $O(n)$ registers. After completion of the draft of this paper, Giakkoupis, Helmi, Higham, and Woelfel [12, 13] presented deterministic obstruction-free algorithms that use only $O(\sqrt{n})$ and $O(\log n)$ registers, respectively. As the authors observed, these algorithms can be turned into randomize wait-free ones, and can be combined with the first algorithm proposed in this paper to achieve $O(\log^{\ast}n)$ expected max-step complexity in the oblivious adversary model, with $O(\sqrt{n})$ and $O(\log n)$ space complexity, respectively.

2 Preliminaries

We consider an asynchronous shared memory model where up to $n$ processes, with IDs $1,\dots,n$, communicate by reading and writing to atomic shared multi-reader multi-writer registers. Registers can store values from an arbitrary countable domain. Algorithms are randomized and use local coin flips to make random decisions. A coin flip is a step that yields a random value from some countable space $\Omega$, using an arbitrary but fixed probability distribution $\mathcal{D}$. Coin flips are private, i.e., only the process that executes the coin flip gets to see the outcome. For the model description we will assume (w.l.o.g.) that processes alternate between coin flip steps and shared memory steps (i.e., reads or writes), and that their first step is always a coin flip. Our algorithm descriptions do not always follow this convention, because in the given programs processes may execute multiple consecutive shared memory steps without any coin flips in-between. Obviously one can simply add “dummy” coin flip steps in order to achieve an alternation.

An execution is a possibly infinite sequence, where the $i$-th element contains all information describing the $i$-th step. That comprises the ID of the process taking that step, the type of step (read, write, or coin flip), the affected register in case of a read or write, the value returned in case of a read or coin flip, and the value written in case of a write. A schedule is a sequence of process IDs in $\{1,\ldots,n\}$, and a coin flip vector $\omega$ is a sequence of coin flip values in $\Omega$; these sequences may be infinite. Every execution $\mathcal{E}$ uniquely defines a schedule $\sigma(\mathcal{E})$ that is obtained from $\mathcal{E}$ by replacing each step with the ID of the process performing that step, and a coin flip sequence $\omega(\mathcal{E})$, which is the sequence of coin flip values defined by $\mathcal{E}$. Similarly, for a given algorithm $M$, a schedule $\sigma$ together with an infinite coin flip vector $\omega=(\omega_{1},\omega_{2},\dots)$ uniquely determine an execution $\mathcal{E}_{M}(\sigma,\omega)$, in which processes execute their shared memory and coin flip steps in the order specified by $\sigma$, and the value returned from the $i$-th coin flip (among all processes) is $\omega_{i}$. If a process has finished its algorithm, it does not take any more steps, even if it gets scheduled (alternatively, one can think of the process continuing to execute only no-ops).

2.1 Adversary Models

An adversary decides at any point of an execution, which process will take the next step. Formally, an adversary $A$ is a function that maps a finite execution $\mathcal{E}$ of some algorithm $M$ to a process ID $A(\mathcal{E})$, which identifies the process to take the next step following $\mathcal{E}$. This way, adversary $A$ and algorithm $M$, together with an infinite coin flip vector $\omega$, yield a unique infinite schedule $\sigma_{M}(A,\omega)=(\sigma_{1},\sigma_{2},\dots)$, where $\sigma_{1}=A(\varepsilon)$ for the empty execution $\varepsilon$, and

[TABLE]

Thus, given algorithm $M$ and adversary $A$ we can obtain a random schedule $\sigma_{M}(A,\omega)$ and the corresponding random execution $\mathcal{E}_{M}(\sigma_{M}(A,\omega),\omega)$ by choosing a coin flip vector $\omega$ at random according to the product distribution $\mathcal{D}^{\infty}$ over the set $\Omega^{\infty}$ of infinite coin flip vectors. The coin flip vector $\omega$ is the only source of randomness, here. We denote the random execution $\mathcal{E}_{M}(\sigma_{M}(A,\omega),\omega)$ by $\mathcal{E}_{M,A}$, and call it the random execution of $M$ scheduled by $A$. We are interested in random variables and their expectation defined by $\mathcal{E}_{M,A}$, e.g., the maximum number of shared memory steps any process takes (see Section 2.2).

An adversary model $\mathcal{A}$ maps each algorithm $M$ to a family $\mathcal{A}(M)$ of adversaries. We say that an algorithm $M$ has certain properties against any adversary in $\mathcal{A}$ to denote that these properties are satisfied for any adversary $A\in\mathcal{A}(M)$. The strong adaptive adversary model is defined for any algorithm as the set of all adversaries. Here, the next process scheduled to take a step is decided based on the entire past execution (including the results of all coin flip steps so far). The oblivious adversary model is the weakest standard adversary model, where each adversary $A$ is a function of just the length of the past execution, i.e., $A(\mathcal{E})=A(\mathcal{E}^{\prime})$, if $|\mathcal{E}|=|\mathcal{E}^{\prime}|$. Therefore, an oblivious adversary results in a schedule that is fixed in advance and is independent of the coin flip vector.

Several weak adaptive adversary models have been proposed, which are stronger than the oblivious model but weaker than the strong adaptive model. We will consider two such models. An adversary $A$ for algorithm $M$ is location-oblivious if for any finite execution $\mathcal{E}$ of $M$, the next processes $A(\mathcal{E})$ scheduled by $A$ to take a step can depend on the following information:

1. (i)

the complete past schedule $\sigma(\mathcal{E})$; 2. (ii)

the return values of all coin flip steps performed by each process $p$ preceding $p$’s latest shared memory step in $\mathcal{E}$; and 3. (iii)

for each process $p$ that does not finish in $\mathcal{E}$ and its next step is a shared memory step, the information whether that step will be a read or a write operation, and, in case of a write, the value that $p$ will write.

In particular, the location-oblivious adversary does not make a scheduling decision based on which register each process $p$ will access in its next shared memory step, if that register is determined at random based $p$’s coin flip after its latest shared memory step in $\mathcal{E}$.

Similar but incomparable to the location-oblivious adversary model is the r/w-oblivious adversary model. An adversary $A$ for algorithm $M$ is r/w-oblivious if for any finite execution $\mathcal{E}$ of $M$, $A(\mathcal{E})$ can depend on (i) and (ii) above, and also on the following information:

1. (iii*′*)

for each process $p$ that does not finish in $\mathcal{E}$ and its next step is a shared memory step, the register that $p$ will access in that step.

In particular, the adversary does not make a scheduling decision based on whether a process $p$’s next shared memory step is a read or a write operation, if this decision is made at random based on $p$’s coin flip after its last shared memory step in $\mathcal{E}$.

2.2 Complexity Measures

We use the following standard definitions. The space complexity of an implementation is the number of registers it uses. An event occurs with high probability (w.h.p.), if it has probability ${1-1/m^{\Omega(1)}}$ for some parameter $m$, as $m\to\infty$. In our case, $m$ will be either $n$, the total number of processes, or $k$, a notion of congestion defined in Section 2.2.

We are interested in randomized leader election, and a variant of it called group election. These problems are one-time in the sense that each process can participate in a leader (or group) election at most once. The following definitions are thus limited to one-time operations $op$.

Let $M$ be an algorithm in which a processes may call some operation $op$ (possibly in addition to other operations). For any process $p$ and any execution $\mathcal{E}$ of algorithm $M$, let $T_{op,p}(\mathcal{E})$ be the number of shared memory steps that $p$ executes in $\mathcal{E}$ during its $op$ call, and let $T_{op,p}(\mathcal{E})=0$ if $p$ does not call $op$. The max-step complexity of $op$ in execution $\mathcal{E}$ is defined as

[TABLE]

The expected max-step complexity of $op$ in algorithm $M$ against an adversary $A$ is

[TABLE]

where $\mathcal{E}_{M,A}$ is a random execution of $M$ scheduled by $A$ (see Section 2.1). The expected max-step complexity of $op$ against $A$ is the supremum of the quantity in (1) over all algorithms $M$. The expected max-step complexity of $op$ against an adversary model $\mathcal{A}$ is the supremum of the quantity in (1) over all $M$ and all $A\in\mathcal{A}(M)$.

In previous works [5, 2], the terms “expected individual step complexity” or simply “expected step complexity” have been used to denote what we refer to as “expected max-step complexity.” We prefer to use a new and thus unambiguous term to clearly distinguish this measure from other step complexity measures, and in particular, from $\max_{p}\operatorname{\mathbf{E}}[T_{op,p}(\mathcal{E}_{M,A})]$. It follows immediately from the definition of expectation that $\max_{p}\operatorname{\mathbf{E}}[T_{op,p}(\mathcal{E}_{M,A})]\leq\operatorname{\mathbf{E}}[\max_{p}T_{op,p}(\mathcal{E}_{M,A})]$.

Our implementations of group and leader election objects are adaptive with respect to contention, i.e., their max-step complexity depends on the number of participating processes rather than $n$, the number of processes in the system. In fact, the only way in which $n$ is used in the design of our algorithms is to determine the number of registers that must be used. If we allow the implementation to use unbounded space, then $n$ can be unbounded, too.

Expressing the max-step complexity in terms of contention requires some care. We are interested in the conditional expectation of the max-step complexity of an operation $op$, given that the number of processes calling $op$ is limited by some value $k$. A straightforward idea to limit contention would be to consider $\operatorname{\mathbf{E}}[\max_{p}T_{op,p}(\mathcal{E}_{M,A})\mid K\leq k],$ where $K$ is the actual number of processes that execute $op$ in $\mathcal{E}_{M,A}$. But this does not yield satisfying results, as an adaptive adversary may be able to force that conditional expectation to be unreasonably large for any given $k<n$. An adversary might achieve that, e.g., by letting $k$ processes start their operation $op$, and if it sees during the execution that the coin flips are favorable (i.e., will yield a fast execution), it can schedule one more process to invoke $op$, increasing the contention to more than $k$ processes. This would prevent “fast” executions from contributing to $\operatorname{\mathbf{E}}[\max_{p}T_{op,p}(\mathcal{E}_{M,A})\mid K\leq k]$.

We define a measure of contention, called max-contention, that the adversary cannot change once the first process is poised to invoke operation $op$. Let $\mathcal{E}$ be an execution of algorithm $M$, and let $\mathcal{E}^{\prime}$ be the prefix of $\mathcal{E}$ ending when the first process becomes poised to invoke $op$; $\mathcal{E}^{\prime}:=\mathcal{E}$ if no such process exists. The max-contention of $op$ in execution $\mathcal{E}$ of algorithm $M$, denoted $k_{\max}^{M,op}(\mathcal{E})$, is the maximum number of processes that invoke $op$, in any execution of $M$ that is an extension of $\mathcal{E}^{\prime}$. In other words, $k_{\max}^{M,op}(\mathcal{E})$ is the maximum number of invocations of $op$ for any possible way of continuing execution $\mathcal{E}^{\prime}$ of $M$.

Let $\mathit{Exec}_{M,A,op}(k)$ be the set of all possible executions $\mathcal{E}^{\prime}$ of algorithm $M$ that can result for a given adversary $A$, and have the properties that: (i) $\mathcal{E}^{\prime}$ ends when the first process becomes poised to invoke $op$; and (ii) $k_{max}^{M,op}(\mathcal{E}^{\prime})\leq k$. We define the adaptive expected max-step complexity of $op$ in algorithm $M$ against adversary $A$ to be a function $\tau:\{1,\dots,n\}\to\mathds{R}_{\geq 0}$, where

[TABLE]

The adaptive expected max-step complexity of $op$ against adversary $A$ (or against an adversary model $\mathcal{A}$) is defined similarly to $\tau(k)$, except that the supremum is taken also over all algorithms $M$ (respectively, over all $M$ and all $A\in\mathcal{A}(M)$). We say that the adaptive max-step complexity of $op$ in algorithm $M$ against adversary $A$ is bounded by $b(k)$ with probability $q(k)$, if

[TABLE]

We also say that the adaptive max-step complexity of $op$ against  $A$ (or $\mathcal{A}$) is bounded by $b(k)$ with probability $q(k)$, if the above holds for all algorithms $M$ (respectively, all $M$ and all $A\in\mathcal{A}(M)$). Throughout the remainder of the paper, when we say (expected) max-step complexity, we mean adaptive (expected) max-step complexity.

In the terminology introduced in this section, we will often replace operation $op$ by the object $G$ that supports this operation, if $op$ is the only operation that $G$ provides.

2.3 Some Basic Objects

We now describe several simple objects that we use as building blocks for our TAS algorithms.

A doorway object supports the operation enter() which takes no parameters and returns a boolean value, true or false. Each process calls enter() at most once, and we say that it enters the doorway when it invokes enter(), and exits when the enter() method responds. The process passes through the doorway if its enter(**) method returns true, and is deflected if it returns false. A doorway object satisfies the following two properties:

1. (D1)

Not all processes entering the doorway are deflected; and 2. (D2)

If a process passes through the doorway, then it entered the doorway before any process exited the doorway.

A simple, wait-free implementation of a doorway object is given in Figure 1. It is straightforward that the implementation satisfies properties (D1) and (D2): The first process that writes to $B$ “closes” the doorway. All processes that read $B$ after that will be deflected, and thus (D2) is true. But the first process that reads $B$ does not get deflected, because at the point of that read, no process has written $B$. Therefore, (D1) is also true. The implementation uses only one register and each process finishes its enter(**) method in a constant number of steps.

A randomized 2-process TAS object can be implemented from a constant number of registers, so that its TAS() method has constant expected max-step complexity. More precisely, an implementation by Tromp and Vitányi [23] uses two single-reader single-writer registers, and guarantees for any strong adaptive adversary and any $\ell>0$, that with probability at least $1-1/2^{\ell}$, both processes finish after $O(\ell)$ steps. In our algorithms, when a process calls the TAS() method of a 2-process TAS object it must “simulate” one of two possible IDs, $1$ or $2$. Thus, we use a 2-process TAS object TAS2 that supports an operation TAS($i$), where $i\in\{1,2\}$. If two processes call the method TAS($i$), they must use different values for $i$. We will say that a process wins (loses) if its TAS(**) call returns 0 (respectively 1).

A splitter object [19, 8] provides a single method split(), which takes no parameters and returns a value in $\{\textnormal{{stop}},\textnormal{{left}},\textnormal{{right}}\}$. If a process $p$ calls split(), we say that $p$ goes through the splitter. If the call returns stop, we say that $p$ stops at the splitter; and if it returns left (right), we say $p$ turns left (respectively right).

A deterministic splitter, denoted Splitter, was proposed by Moir and Anderson [19]. It guarantees that if $\ell$ processes go through the splitter, then at most $\ell-1$ turn left, at most $\ell-1$ turn right, and at most one stops. Thus if only one process goes through the splitter, that process stops.

A randomized splitter, denoted RSplitter, was proposed by Attiya, Kuhn, Plaxton, Wattenhofer and Wattenhofer [8]. Similarly to the deterministic splitter, it guarantees that if only one process goes through the splitter, then that process must stop. But now, any process that does not stop, turns left or right with equal probability, and independently of other processes. Randomized and deterministic splitters are incomparable in “strength”, as for a randomized splitter it is possible that all processes going through it turn to the same direction.

Both splitter implementations, the deterministic one by Moir and Anderson, and the randomized by Attiya et. al., use two shared registers and have max-step complexity $O(1)$ in any execution. For completeness we provide the implementations in Figure 2. The deterministic splitter implementation has the following additional doorway-like property, which is useful for the design of our algorithms:

1. (S)

If a process stops or turns right at the splitter, then its split() call was invoked before any other split() call on the same object responded.

This follows immediately from the use of doorway $D$ in line 2: Suppose a split() operation by process $p$ gets invoked after some other split() call by process $q$ responded. Then $q$ has already exited the doorway, when $p$ enters it, so by doorway-property (D2) process $p$ gets deflected, and its split(**) call returns left.

3 Fast TAS for Weak Adversaries

We present implementations of TAS objects for weak adversary models. In Section 3.1, we introduce the problem of group election, which is a natural variant of leader election, and in Section 3.2, we give a TAS implementation from group election objects. Then, in Sections 3.3 and 3.4, we provide efficient randomized implementations of group election from registers, for the location-oblivious and the r/w-oblivious adversary models, respectively.

3.1 Group Election

In the group election problem processes must elect a non-empty subset of themselves, but unlike in leader election, it is not required that exactly one process gets elected. Still it is desirable that the expected number of processes elected should be bounded by a small function in the number of participating processes.

Formally, a group election object, denoted GroupElect, provides the method elect(), which takes no parameters and returns either win or lose. We say a process participates in a group election when it calls elect(). The processes whose elect(**) calls return win get elected. A group election object must satisfy the following property:

1. (GR)

Not all participating processes’ elect(**) calls return lose.

That is, if at least one process participates and all participating processes finish their elect(**) calls, then at least one process gets elected.

We are interested in group election objects for which the expected number of elected processes is bounded by a (small) function of the max-contention. This function is called the effectiveness of the group election object and is formally defined next.

Consider an $n$-process group election object $G$. Let $M$ be an algorithm in which processes invoke the elect() operation of $G$, and let $A$ be an adversary. For an execution $\mathcal{E}$ of $M$, let $\mathit{win}(\mathcal{E})$ denote the number of processes that get elected on $G$. Similarly to definition (2) for max-step complexity, let $\mathit{Exec}_{M,A,G}(k)$ be the set of all possible executions $\mathcal{E}^{\prime}$ of $M$ that can result for adversary $A$, and have the properties that: (i) $\mathcal{E}^{\prime}$ ends when the first process is poised to invoke $G$.elect(); and (ii) $k_{max}^{M,G}(\mathcal{E}^{\prime})\leq k$. The effectiveness of group election object $G$ in algorithm $M$ against adversary $A$ is a function $\varphi:\{1,\dots,n\}\to[1,n]$, where

[TABLE]

The effectiveness of $G$ against adversary $A$ (or against an adversary model $\mathcal{A}$) is defined similarly to $\phi(k)$, except that the supremum is taken also over all algorithms $M$ (respectively, over all $M$ and $A\in\mathcal{A}(M)$).

3.2 TAS from Group Election

We now present an implementation of a TAS object from $n$ group election objects. The algorithm uses also $n$ deterministic splitters, $n$ 2-process TAS objects, and one doorway object. All these objects can be implemented from a total number of $O(n)$ registers, as we saw in Section 2.3.

The implementation is given in Figure 3. First, each process enters a doorway, and if deflected, its TAS() call immediately returns 1. Any process that passes through the doorway participates in a series of group elections, on objects $G[1],\ldots,G[n]$. If the process is not elected on $G[i]$, then its TAS() returns 1. Otherwise, it goes through splitter $S[i]$ next. If the process turns left at the splitter, then TAS(**) returns 1; if it turns right, it participates in the next group election, on $G[i+1]$. Finally, if the process stops at $S[i]$, then it does not participate in any further group elections. Instead, it tries to win a series of 2-process TAS, on $T[i],\dots,T[1]$, until it either loses in one of them and returns 1, or wins in all of them and returns 0.

The idea is that fewer and fewer processes participate in each group election, as only processes that get elected in $G[i]$ may participate in $G[i+1]$. The rate at which the number of processes drops depends on the effectiveness of the group election objects. The purpose of the doorway at the beginning is to achieve linearizability (without the doorway, we would obtain a leader election object instead). The splitter objects serve two purposes. First, they ensure that as soon as only one process remains, that process will not participate in other group elections, and will switch to the list of 2-process TAS objects. Second, they guarantee that the number of processes participating in each $G[i]$ strictly decreases with $i$. This ensures that no more than $n$ group election objects are needed. Finally, the 2-process TAS objects ensure that (at most) one process returns [math].

Next we prove the correctness of the implementation, and analyze its max-step complexity in terms of the max-step step complexity and effectiveness of the group election objects used.

We use the following standard notation. For any function $f\colon X\to Y$, where $Y\subseteq X$, and for $i\geq 0$, we denote by $f^{(i)}$ the $i$-fold composition of $f$, defined recursively by $f^{(0)}(x)=x$ and $f^{(i+1)}(x)=f(f^{(i)}(x))$. Further, if $f$ is a real function, we define

[TABLE]

Theorem 1**.**

Figure 3 gives an implementation of a TAS object from a set of group election objects. Suppose that for each group election object $G[i]$ used in this implementation, the expected max-step complexity of $G[i]$ against a given adversary $A$ is bounded by a function $t(k)$ of the max-contention $k$ of $G[i]$, and the effectiveness of $G[i]$ against $A$ is bounded by a function $f(k)$. Suppose also that functions $f$ and $t$ are non-decreasing, and $f$ is concave. Then the expected max-step complexity of the TAS implementation against $A$ is O\big{(}t(k)\cdot g^{\ast}(k)\big{)}, where $g(k):=\min\{f(k),k-1\}$. Moreover, the same bound on the expected max-step complexity applies even if the assumption that the effectiveness of $G[i]$ is bounded by $f(k)$ holds only for $1\leq i\leq g^{\ast}(n)$.

The assumption that functions $t$ and $f$ are non-decreasing is not restrictive, as the expected max-step complexity and the effectiveness are by definition non-decreasing functions of the max-contention. The requirement that $f$ is concave is also reasonable, as it suggests that the larger the max-contention, the smaller the increase in the expected number of elected processes, for the same increase in max-contention. This assumption is needed in the analysis for the following reason: We inductively obtain upper bounds for the expectation $E[k_{j}]$ of the number $k_{j}$ of processes participating in the group election on $G[j]$. Concavity of $f$ allows us to bound the expected number of processes getting elected on $G[j]$ by Jensen’s inequality: $E[f(k_{j})]\leq f(E[k_{j}])$.

3.2.1 Proof of Theorem 1

We first show that the implementation is correct, and then analyze its max-step complexity.

Correctness.

Consider an arbitrary execution. For $j\geq 1$, let $m_{j}$ be the number of processes that begin $j$ iterations of the repeat-until loop (lines 4–4), and for $1\leq j\leq n$ let $e_{j}$ be the number of processes that get elected on group election object $G[j]$ (in line 4). Clearly, $e_{j}\leq m_{j}$, and at most $e_{j}$ processes go through splitter $S[j]$ (in line 4). Moreover, by the splitter semantics, at most $e_{j}-1$ of them turn right, provided $e_{j}\geq 1$. Thus, if $e_{j}\geq 1$, at most $e_{j}-1\leq m_{j}-1$ processes execute a $(j+1)$-th iteration of the repeat-until loop. Hence, $m_{j+1}<m_{j}$, and in particular $m_{n+1}=0$. Thus, we have

[TABLE]

Next we observe that each 2-process TAS object $T[j]$, $1\leq j\leq n$, is accessed by at most two processes: possibly a single process which stops at $S[j]$ and then calls $T[j]$.TAS($1$) (in line 4), and possibly the winner of $T[j+1]$, if $j<n$, which calls $T[j]$.TAS($2$) (in line 4). At most one of them can win $T[j]$. Since a process needs to win $T[1]$ (either in line 4 or in line 4) in order to win the implemented TAS(**) method, it follows that at most one process wins.

We now argue that at least one process wins, provided that at least one process calls the implemented TAS() method, and that all processes that do so finish their call. Recall that by (3), $j^{\ast}\leq n$ is the largest index such that at least one process starts its $j^{\ast}$-th iteration of the while-loop. By (GR), at least one process gets elected on $G[j^{\ast}]$, and subsequently goes through splitter $S[j^{\ast}]$. I.e., $e_{j^{\ast}}\geq 1$. Since $m_{j^{\ast}+1}=0$, none of these $e_{j^{\ast}}$ processes executes another iteration of the repeat-until loop, and thus they all turn left or stop at $S[j^{\ast}]$. As not all of them can turn left either, at least one (and thus by the splitter semantics exactly one) process must stop at $S[j^{\ast}]$. It follows that at least one process calls $T[j^{\ast}]$.TAS($1$), and so at least one process wins $T[j^{\ast}]$. Since for $1<j\leq n$ the winner of $T[j]$ continues to $T[j-1]$, some process must win $T[1]$. Thus some process wins the implemented TAS() method.

It remains to show that the TAS implementation is linearizable. If process $p$’s TAS() call $z$ returns 0, then by property (D2) of the doorway, $p$ must have entered doorway $D$ during $z$ before any other process exited it. In particular, no TAS() call happens before $z$ (i.e., responds before $z$ gets invoked). Thus, we can obtain a linearization of the execution by putting $z$ first, and adding all other TAS() operations after $z$ in the order of their invocation. The resulting sequential history is valid (the first TAS() returns 0, and all other TAS() return 1), and preserves the happens-before order, because no TAS() happens before $z$.

Step Complexity.

Consider an algorithm $M$ that uses the implemented TAS object. Let $\mathcal{E}:=\mathcal{E}_{M,A}$ be a random execution of $M$ scheduled by adversary $A$.

For each $1\leq j\leq n$, let $\mathcal{E}_{j}$ be the prefix of execution $\mathcal{E}$, until the first process is poised to invoke $G[j].\textnormal{{elect(}}\textnormal{\emph{}}\textnormal{{)}}$; or $\mathcal{E}_{j}:=\mathcal{E}$ if no such process exists. Observe that if $\mathcal{E}_{1}\neq\mathcal{E}$, then the last step of $\mathcal{E}_{1}$ is the step at which the first process passes through doorway $D$. Similarly for $i>1$, if $\mathcal{E}_{i}\neq\mathcal{E}$ then the last step of $\mathcal{E}_{i}$ is the step in which the first process turns right at splitter $S[j-1]$.

For $1\leq j\leq n$, let $k_{j}:=k_{max}^{M,G[j]}(\mathcal{E})$ be the max-contention of $G[j]$ in $\mathcal{E}$. By definition, it is also

[TABLE]

Let $\mathcal{E}_{0}$ be the prefix of $\mathcal{E}$ until the first process is poised to invoke the implemented TAS(**) operation, i.e., it is poised to enter doorway $D$. Let $k_{0}:=k_{max}^{M,D}(\mathcal{E})$ be the max-contention of $D$ in $\mathcal{E}$, and thus $k_{0}=k_{max}^{M,D}(\mathcal{E}_{0})$ as well.

Observe that, for any $1\leq j\leq n$, execution $\mathcal{E}_{j-1}$ is a prefix of $\mathcal{E}_{j}$, and $k_{j-1}\geq k_{j}$.

Let $T(\mathcal{E})$ denote the max-step complexity of the implemented TAS in execution $\mathcal{E}$. To prove the expected max-step complexity bound claimed in the theorem we must show that for any given $k\geq 0$, if $k_{0}=k$ then

[TABLE]

We will assume $k_{0}\geq 1$, otherwise $T(\mathcal{E})=0$ as no process invokes the implemented TAS(**).

First we bound the expected number of group election objects accessed by at least one process in the execution.

For $1\leq j\leq n$, let $e_{j}$ be the number of processes elected in the group election on $G[j]$. From the theorem’s assumption that the effectiveness of $G[j]$ is bounded by function $f$ of the max-contention of $G[j]$, it follows

[TABLE]

We take the conditional expectation given $\mathcal{E}_{0}$ to obtain

[TABLE]

The expression on the left equals $\operatorname{\mathbf{E}}[e_{j}\mid\mathcal{E}_{0}]$ by the tower rule, since $\mathcal{E}_{0}$ is a prefix of $\mathcal{E}_{j}$. For the right side we have $\operatorname{\mathbf{E}}[f(k_{j})\mid\mathcal{E}_{0}]\leq f(\operatorname{\mathbf{E}}[k_{j}\mid\mathcal{E}_{0}])$, by Jensen’s inequality and the assumption that $f$ is concave. Therefore,

[TABLE]

For $j=1$, (4) yields

[TABLE]

where the second inequality holds because $k_{1}\leq k_{0}$ and $f$ is non-decreasing, and the last equation holds because $k_{0}$ is completely determined given $\mathcal{E}_{0}$.

For $j>1$, we have $k_{j}\leq e_{j-1}$: This is trivial if $k_{j}=0$. If $k_{j}\geq 1$ then the last step of $\mathcal{E}_{j}$ is when the first process $p$ turns right at splitter $S[j-1]$. Property (S) then implies that any other process $q$ that may participate at the group election in $G[j]$ must have already invoked $S[j-1]$.split(**), and thus must have already been elected at $G[j-1]$.

Using the inequality $k_{j}\leq e_{j-1}$ we have just shown, and the assumption $f$ is non-decreasing, we obtain from (4) that for $j>1$,

[TABLE]

Combining the above inequalities for $j=1,2,\ldots,$ and using that $f$ is non-decreasing we get

[TABLE]

The $e_{j}$ processes elected on $G[j]$ will participate in an additional number of at most $e_{j}$ group election objects beyond the first $j$ ones, as each splitter $S[i]$ ensures $e_{i+1}\leq e_{i}-1$, if $e_{i}>0$. Therefore, if $j^{\ast}:=\max\{j\colon k_{j}>0\}$ is the total number of group election objects accessed by at least one process, then for any $0\leq j\leq k_{0}$,

[TABLE]

Let

[TABLE]

Note that $x\geq 1$, as $f(y)\geq 0$ for $y\geq 0$. Also, since $f$ is concave and non-negative, it follows

[TABLE]

Setting $j:=\lambda$ in (5) we obtain $\operatorname{\mathbf{E}}[j^{\ast}\mid\mathcal{E}_{0}]\leq\lambda+f^{(\lambda)}(k_{0})$. Since $f(y)\geq y-1$ for $0\leq y\leq x$, and by definition, $f(y)<y-1$ for $x<y\leq k_{0}$, it follows that $\lambda+f^{(\lambda)}(k_{0})\leq g^{\ast}(k_{0})+1$, where $g(k):=\min\{f(k),k-1\}$. Therefore,

[TABLE]

In the following we will assume that $\mathcal{E}_{0}$ is fixed, thus so is $k_{0}$.

Next we will bound the expectation of the maximum number of steps any single process takes on the group election objects. This number is bounded by $\sum_{1\leq j\leq j^{\ast}}t_{j}$, where $t_{j}$ is the max-step complexity of $G[j]$ in $\mathcal{E}$. We will bound the expectation of this sum using a version of Wald’s Theorem (note that the number $j^{\ast}$ of terms in the sum as well as the terms $t_{j}$ are random variables.) From the assumption that the max-step complexity of $G[j]$ is bounded by a function $t$ of the max-contention on $G[j]$, we have that

[TABLE]

Since $k_{j}\leq k_{0}$ and $t$ is a non-decreasing function, it follows $\operatorname{\mathbf{E}}[t_{j}\mid\mathcal{E}_{j}]\leq t(k_{0})$. This implies

[TABLE]

as the execution prefix $\mathcal{E}_{j}$ is sufficient to determine whether or not $j^{\ast}\geq j$ holds. We will use the above inequality to apply the following variant of Wald’s Theorem, for random variables that are not independent. A proof of this theorem can be found, e.g., in [16].

Theorem 2** (Wald’s Theorem).**

Let $X_{1},X_{2},\dots$ be a sequence of non-negative random variables and let $Y$ be a non-negative integer random variable such that the expectations of $Y$ and of each $X_{j}$ exist. If for all $j$, $\operatorname{\mathbf{E}}[X_{j}\mid j\leq Y]\leq\mu$ for some $\mu\geq 0$, then $\operatorname{\mathbf{E}}[X_{1}+\dots+X_{Y}]\leq\mu\cdot\operatorname{\mathbf{E}}[Y]$.

We apply the theorem for $X_{j}=t_{j}$, $Y=j^{\ast}$, and $\mu=t(k_{0})$ to obtain

[TABLE]

Using the same argument we can also bound the expectation of $\sum_{1\leq j\leq j^{\ast}}t^{\prime}_{j}$, where $t^{\prime}_{j}$ is the max-step complexity of the TAS2 object $T[j]$ in $\mathcal{E}$. For $T[j]$ we have that its expected max-step complexity is constant (against any adversary), i.e., $\operatorname{\mathbf{E}}[t^{\prime}_{j}\mid\mathcal{E}^{\prime}_{j}]=O(1)$, for the prefix $\mathcal{E}^{\prime}_{j}$ of $\mathcal{E}$ until some process is poised to invoke $T[j]$.TAS(**). Then the same reasoning as above yields

[TABLE]

Finally, the number of remaining steps of a process in $\mathcal{E}$, that are not steps on one of the objects $G[j]$ or $T[j]$, is bounded by $O(j^{\ast})$.

Therefore the expected max-step complexity of the TAS implementation is bounded by

[TABLE]

Finally, note that for the above analysis we do not need any assumptions on the effectiveness of objects $G[j]$ for $j>g^{\ast}(n)$, as (5) is used only for $j:=\lambda\leq g^{\ast}(k_{0})$. This completes the proof of Theorem 1. ∎

3.3 Group Election for Location-Oblivious Adversaries

We present a simple randomized group election implementation from registers, which has effectiveness $O(\log k)$ in the location-oblivious adversary model, and constant max-step complexity. This can be used to implement a TAS object with expected max-step complexity $O(\log^{\ast}k)$ against location-oblivious adversaries.

The group election implementation is given in Figure 4. Each process first writes to a random register among the $\ell:=\lceil\log n\rceil$ registers $R[1],\ldots,R[\ell]$, where $R[i]$ is chosen with probability $1/2^{i}$ if $1\leq i<\ell$, and with probability $1/2^{\ell-1}$ if $i=\ell$. Then the process reads the next register, $R[i+1]$, and gets elected if and only if no process has previously written to that register.

We have that at least one process gets elected, namely a process that writes to the rightmost register that gets written. The idea for the $O(\log k)$ bound on the effectiveness is as follows. Since the probability that a process chooses index $i+1$ equals half the probability it chooses $i$, at most a constant expected number of processes write to $R[i]$ before some process writes to $R[i+1]$. After a process has written to $R[i+1]$, no process that writes to $R[i]$ can still get elected. Therefore, for every index $i$ there will only be a constant expected number of processes that choose that index and get elected. Moreover, if at most $k$ processes participate in the group election, then with sufficiently high probability (in $k$) only the first $O(\log k)$ registers get written at all. A simple calculation then shows that only an expected number of $O(\log k)$ processes get elected.

Lemma 3**.**

Figure 4 gives a randomized implementation of a group election object with effectiveness at most $2\log k+4$ and constant max-step complexity against any location-oblivious adversary.

Proof.

Let $M$ be an algorithm that uses the implemented group election object, and consider any execution of $M$ in which all processes participating in the group election finish their elect(**) call. Let $i^{\ast}$ be the largest index such that some process $p$ writes to $R[i^{\ast}]$ (in line 5). Then $p$ reads the value 0 from $R[i^{\ast}+1]$ in the next line and returns win. Hence, at least one process gets elected. Further, each process does exactly two shared memory operations, thus the max-step complexity is constant. It remains to bound the effectiveness of the group election object.

Let $A$ be a location-oblivious adversary, and let $\mathcal{E}:=\mathcal{E}_{M,A}$ be a random execution of $M$ scheduled by $A$. Fix the prefix $\mathcal{E}^{\prime}$ of $\mathcal{E}$ until the first process is poised to invoke elect(), and let $k:=k_{max}^{M,\textnormal{{elect(}}\textnormal{\emph{}}\textnormal{{)}}}(\mathcal{E}^{\prime})=k_{max}^{M,\textnormal{{elect(}}\textnormal{\emph{}}\textnormal{{)}}}(\mathcal{E})$ be the max-contention of elect() in $\mathcal{E}$. Let $k^{\prime}\leq k$ be the actual number of processes that execute the write operation in line 5 during $\mathcal{E}$, and for $1\leq i\leq k^{\prime}$, let $p_{i}$ be the $i$-th process to execute the write operation.

Since adversary $A$ is location-oblivious, it does not know the index of the register on which $p_{i}$ will write, before $p_{i}$ finishes that operation. We can thus assume that a list $x_{1},\ldots,x_{k}$ of indices is chosen in advance, right after the last step of $\mathcal{E}^{\prime}$, such that each index $x_{i}$ is drawn independently at random according to the distribution in line 5, and then for each $1\leq i\leq k^{\prime}$, process $p_{i}$ writes to register $R[x_{i}]$ in line 5. Note that although just the first $k^{\prime}$ of the values $x_{i}$ are actually used, we draw $k\geq k^{\prime}$ values initially as $k^{\prime}$ may not be known in advance.

For each $1\leq i\leq k^{\prime}$, let $X_{i}$ be the 0/1 random variable that is $1$ if and only if $p_{i}$ gets elected, i.e., $p_{i}$ reads the value 0 on register $R[x_{i}+1]$ in line 5, and returns win. Further, for each $1\leq i\leq k$, let $Y_{i}$ be the 0/1 random variable that is $1$ if and only if $x_{j}\neq x_{i}+1$ for all $j<i$. Clearly, $X_{i}\leq Y_{i}$ for $i\leq k^{\prime}$, as $p_{i}$ reads the value 0 only if none of the processes $p_{1},\ldots,p_{i-1}$ writes to register $R[x_{i}+1]$. The expected number of processes that get elected is then

[TABLE]

Using that $x_{1},\dots,x_{i}$ are chosen independently ($\ast$), and that $x_{i}=\ell$ implies $Y_{i}=1$ ($\dagger$), we obtain

[TABLE]

Substituting that to (7) yields

[TABLE]

We bound the sum in the last line by bounding with 1 each of the first $\log k$ terms, and using for the remaining terms that $1-\left(1-\frac{1}{2^{i+1}}\right)^{k}\leq 1-\left(1-\frac{k}{2^{i+1}}\right)=\frac{k}{2^{i+1}}$. We get

[TABLE]

as $\ell=\lceil\log n\rceil\geq\log k$. This completes the proof of Lemma 3. ∎

We can now apply Theorem 1 to obtain the following result.

Theorem 4**.**

There is a randomized implementation of a TAS object from $\Theta(n)$ registers with expected max-step complexity $O(\log^{\ast}k)$ against any location-oblivious adversary.

Proof.

We consider the TAS implementation of Figure 3, and use the algorithm in Figure 4 to implement the group election objets $G[j]$, for $1\leq j\leq 2\log^{\ast}n$. For $2\log^{\ast}n<j\leq n$, we just let $G[j]$ be a trivial group election object, where all participating processes get elected and the max-step complexity is zero. From Lemma 3, the group election objects $G[j]$, for $1\leq j\leq 2\log^{\ast}n$, have constant max-step complexity, and effectiveness bounded by $f(k)=2\log k+4$ against any location-oblivious adversary. For $g(k):=\min\{2\log k+4,k-1\}$, we have $g^{\ast}(k)=\log^{\ast}k+O(1)<2\log^{\ast}n$. Theorem 1 then implies that the resulting TAS object has expected max-step complexity $O(\log^{\ast}k)$ against any location-oblivious adversary. Moreover the algorithm uses $\Theta(n)$ registers, as each of the first $2\log^{\ast}n$ group election objection requires $\log n+O(1)$ registers, while the remaining trivial group election objects do not use any registers. ∎

3.4 Group Election for R/W-Oblivious Adversaries

We present a randomized group election implementation from registers, which has constant effectiveness and expected max-step complexity $O(\log\log k)$ in the r/w-oblivious adversary model. This can be used to implement a TAS object with expected max-step complexity $O(\log\log k)$ against r/w-oblivious adversaries.

The group election implementation is given in Figure 5. The algorithm consists of two phases, the backward sifting phase and the forward sifting phase. The latter phase is similar to a sifting procedure used to eliminate processes in the TAS algorithm by Alistarh and Aspnes [2]. Their algorithm, however, is not adaptive. To achieve that, the backward sifting phase runs essentially the same sifting procedure but in the opposite direction.

Two shared arrays of registers are used, one in each phase, namely, $\mathit{Up}[1\dots\ell]$ and $\mathit{Down}[1\dots\ell-1]$, where $\ell=\lceil\log_{b}\log n\rceil$ and $b=\frac{3}{2}$. All entries in both arrays are initially 0.

In the backward sifting phase, for each $i=1,2,\dots$, each process $p$ decides at random to either read register $\mathit{Up}[i]$ or to write the value 1 to it. The probability of writing decreases with $i$, more precisely, it is $q_{i}=1/2^{b^{i-1}}$. The phase ends for $p$ as soon as it has executed a read operation or has written to all registers of $\mathit{Up}$. If $p$ reads the value 1 on $\mathit{Up}[i]$, it means that some other process has written to $\mathit{Up}[i]$ before, and $p$ returns lose immediately. If $p$ reads 0 on $\mathit{Up}[i]$, then it moves on to the forward sifting phase. If $p$ writes to $\mathit{Up}[i]$ instead, then it continues to the next element of $\mathit{Up}$ if $i<\ell$, or if $p$ has already reached the end of array $\mathit{Up}$, it moves on to the forward sifting phase.

Suppose that process $p$ reaches the forward sifting phase after reading the value 0 on register $\mathit{Up}[i_{p}]$ for some index $i_{p}\in\{1,\dots,\ell\}$, or after writing the value 1 on register $\mathit{Up}[i_{p}]$ for $i_{p}=\ell$. Then, for each $i=i_{p}-1,i_{p}-2,\dots$,1, processes $p$ either reads register $\mathit{Down}[i]$ or writes the value 1 to it. As before, the decision is made at random and the probability of writing is $q_{i}$. If $p$ reads the value 1, it returns lose. If $p$ writes to $\mathit{Down}[i]$ or reads 0 from it, then $p$ continues to $\mathit{Down}[i-1]$ if $i>1$, or $p$ returns win if $i=1$.

Let $k$ be the maximum number of processes participating in the group election. Then with high probability no process accesses a register of array $\mathit{Up}$ beyond the first $O(\log\log k)$ registers, because for larger indices $i$ the probability $q_{i}$ of writing to $\mathit{Up}[i]$ is polynomially small in $k$. This implies the $O(\log\log k)$ bound on the expected max-step complexity. The bound on the effectiveness is obtained as follows. We have that the number $r_{i}$ of processes that move from the backward to the forward sifting phase after reading register $\mathit{Up}[i]$ is in expectation bounded by $1/q_{i}$: Each of those $r_{i}$ processes must read register $\mathit{Up}[i]$ before any process has written to $\mathit{Up}[i]$, and the probability of writing to that register is $q_{i}$. We show by an inductive argument that the number $s_{i}$ of processes that access $\mathit{Down}[i]$ and do not return lose right after the operation is $O(1/q_{i})$ in expectation, thus the number $s_{1}+r_{1}$ of processes that get elected is $O(1)$ in expectation. The inductive argument goes as follows: The number of processes that access $\mathit{Down}[i]$ is $s_{i+1}+r_{i+1}$ (where $s_{\ell}$ is defined as the number of processes that write to $Up[\ell]$). The expectation of $s_{i+1}+r_{i+1}$ is $O(1/q_{i+1})$, by the induction hypothesis and the earlier observation that $r_{i}$ is bounded by $1/q_{i}$. The first write operation on $\mathit{Down}[i]$ occurs in expectation after $1/q_{i}$ accesses, and after that only processes that write to $\mathit{Down}[i]$ do not return lose. So in total the expected number of processes that do not return lose after accessing $\mathit{Down}[i]$ is at most $1/q_{i}$ plus the fraction $q_{i}(r_{i+1}+s_{i+1})$ of processes that write to $\mathit{Down}[i]$. A simple calculation bounds that by $O(1/q_{i})$.

Lemma 5**.**

Figure 5 gives a randomized implementation of a group election object with effectiveness at most $16$ and expected max-step complexity $O(\log\log k)$ against any r/w-oblivious adversary.

Proof.

Let $M$ be an algorithm that uses the implemented group election object, and consider any execution of $M$. First we argue that not all elect(**) calls return lose in the execution. Suppose, towards a contradiction, that they all do. Then each process reads the value 1 on some register $\mathit{Up}[i]$ or some register $\mathit{Down}[i]$, and the process returns lose immediately after that. This implies that at least one process writes the value 1 to some register. We argue that no process writes to any of the registers $\mathit{Down}[i]$: Otherwise, let $i_{\min}$ be the smallest index such that some process $p_{\min}$ writes the value 1 to $\mathit{Down}[i_{\min}]$. But then $p_{\min}$ does not return lose at any point, because after writing to $\mathit{Down}[i_{\min}]$, $p_{\min}$ may only read registers $\mathit{Down}[j]$ for $j<i_{\min}$. Thus, some process must write to a register $Up[i]$. Let $i_{\max}$ be the largest index such that some process $p_{\max}$ writes the value 1 to $\mathit{Up}[i_{\max}]$. But then $p_{\max}$ does not return lose at any point, as after writing to $\mathit{Up}[i_{\max}]$, $p_{\max}$ may only read registers $\mathit{Up}[i]$ for $i>i_{\max}$, and registers $\mathit{Down}[i]$, for $1\leq i\leq\ell-1$, none of which has value 1.

Next we bound the effectiveness of the implementation. Let $A$ be some r/w-oblivious adversary, and let $\mathcal{E}:=\mathcal{E}_{M,A}$ be a random execution of algorithm $M$ scheduled by $A$. Fix the prefix $\mathcal{E}^{\prime}$ of $\mathcal{E}$ until the first process is poised to invoke elect(), and let $k:=k_{max}^{M,\textnormal{{elect(}}\textnormal{\emph{}}\textnormal{{)}}}(\mathcal{E}^{\prime})$ be the max-contention of elect() in $\mathcal{E}$. For $1\leq i\leq\ell$, let $r_{i}$ be the number of processes in $\mathcal{E}$ that read register $\mathit{Up}[i]$ before any process writes to it. For $1\leq i\leq\ell-1$, let $s_{i}$ be the number of processes that either read register $\mathit{Down}[i]$ before any process writes on it, or write on register $\mathit{Down}[i]$. We also define $s_{\ell}$ to be the number of processes that write on $\mathit{Up}[\ell]$. The total number of processes that access register $\mathit{Down}[i]$, for $1\leq i\leq\ell-1$, is then at most111We say ‘at most’ instead of ‘exactly’ because we do not require that all processes finish their elect(**) call in $\mathcal{E}$. $r_{i+1}+s_{i+1}$, and the number of processes that get elected in the group election is $r_{1}+s_{1}$. We will show that $\operatorname{\mathbf{E}}[r_{1}+s_{1}]\leq 16$.

Since adversary $A$ is r/w-oblivious, it does not know whether a process poised to access a shared register will read or write to that register. We can thus assume that right after the last step of $\mathcal{E}^{\prime}$, we perform for each register $\mathit{Up}[i]$ and each register $\mathit{Down}[i]$ a series of $k$ independent coin flips with heads probability $q_{i}$, and that the $j$-th process to subsequently accesses that register uses the $j$-th coin flip value in the series to decide whether it should read or write on the register. We observe that once these series of coin flips have been fixed, the values of all random variables $r_{i}$ and $s_{i}$ are completely determined by the number $k^{\prime}\leq k$ of processes that invoke elect(), provided that all these $k^{\prime}$ processes finish their elect() call. (In particular, $r_{i}$ and $s_{i}$ do not depend on the order in which the $k^{\prime}$ processes are scheduled to take steps.) Moreover, if not all $k^{\prime}$ elect(**) calls are executed to completion, then for each $1\leq i\leq\ell$, $r_{i}$ and $s_{i}$ are smaller or equal than the corresponding values if all $k^{\prime}$ calls were executed to completion.

It follows that instead of the schedule determined by adversary $A$, we can consider a schedule with the following convenient properties: Exactly $k$ of processes call the implemented elect(**) method and all processes finish their call; for each $1\leq i<\ell$, all operations on register $\mathit{Up}[i]$ are scheduled before any operation on $\mathit{Up}[i+1]$; for each $1<i\leq\ell-1$, all operations on $\mathit{Down}[i]$ are scheduled before any operation on $\mathit{Down}[i-1]$; and all operations on array $\mathit{Up}$ are scheduled before any operation on array $\mathit{Down}$. Let $R_{i}$ and $S_{i}$ denote the same quantities as $r_{i}$ and $s_{i}$ but for a schedule as described above. Then $R_{i}\geq r_{i}$ and $S_{i}\geq s_{i}$, if the same series of coin flips are used for each register under both schedules, and thus

[TABLE]

We now bound $\operatorname{\mathbf{E}}[R_{1}+S_{1}]$. For that we no longer assume that coin flips are fixed in advance.

For each $1\leq i\leq\ell-1$, the values of $R_{i+1}$ and $S_{i+1}$ are determined before the first process accesses register $\mathit{Down}[i]$. It follows that

[TABLE]

where the term $1/q_{i}$ accounts for the processes that read $\mathit{Down}[i]$ before any process writes on $\mathit{Down}[i]$, and the term $q_{i}(R_{i+1}+S_{i+1})$ accounts for the processes that write on $\mathit{Down}[i]$. Taking the unconditional expectation yields

[TABLE]

We now show by induction on $i=\ell,\ell-1,\dots,1$ that

[TABLE]

Recall that $\ell=\lceil\log_{b}\log n\rceil\geq\log_{b}\log n$, and $b=3/2$. We also have $q_{i}=1/2^{b^{i-1}}$ and thus $q_{i+1}=q_{i}^{b}$. For the base case of $i=\ell$, we have that $S_{\ell}$ is the number of processes that write to $Up[\ell]$, thus

[TABLE]

For $i<\ell$, we obtain from (8) that

[TABLE]

This completes the inductive proof that $\operatorname{\mathbf{E}}[S_{i}]\leq 7/q_{i}$. Applying this inequality, for $i=1$, we obtain

[TABLE]

Therefore, the effectiveness of the implemented group election is $\operatorname{\mathbf{E}}[r_{1}+s_{1}]\leq\operatorname{\mathbf{E}}[R_{1}+S_{1}]\leq 16$.

It remains to bound the expected max-step complexity of the implementation. Let $i^{\ast}$ be the maximum index $i$ such that some process accesses register $\mathit{Up}[i]$ in execution $\mathcal{E}$. Then the maximum number of shared memory operations by any process is at most $2i^{\ast}-1$. We have that $\Pr(i^{\ast}\geq i)$ is bounded by the expected number of processes that access $\mathit{Up}[i]$, and this is bounded by $kq_{i}$. Thus, for $\lambda:=\lceil\log_{b}\log k\rceil$, we have

[TABLE]

Since $q_{\lambda+1}=1/2^{b^{\lambda}}\leq 1/k$ and $\sum_{i\geq 0}q_{\lambda+1}^{b^{i}-1}\leq\sum_{i\geq 0}q_{1}^{b^{i}-1}<3$, it follows that $\operatorname{\mathbf{E}}[i^{\ast}]\leq\lambda+4.$ Hence, the expected max-step complexity is at most $2\operatorname{\mathbf{E}}[i^{\ast}]-1\leq 2(\lambda+4)-1=2\lceil\log_{b}\log k\rceil+7$. This completes the proof of Lemma 5. ∎

Theorem 6**.**

There is a randomized implementation of a TAS object from $\Theta(n)$ registers with expected max-step complexity $O(\log\log k)$ against any r/w-oblivious adversary.

Proof.

We consider the TAS implementation of Figure 3, and use the algorithm in Figure 5 to implement the group election objets $G[j]$, for $1\leq j\leq 16$. For $16<j\leq n$, we let $G[j]$ by a trivial group election object, where all participating processes get elected and the max-step complexity is zero. From Lemma 5, the group election objects $G[j]$, for $1\leq j\leq 16$, have effectiveness at most $16$ and expected max-step complexity $O(\log\log k)$ against any r/w-oblivious adversary. Theorem 1 then implies that the resulting TAS algorithm has expected max-step complexity $O(16\cdot\log\log k)$ against any location-oblivious adversary. Moreover the algorithm uses $\Theta(n)$ registers, as each of the first $16$ group election objection uses $O(\log\log n)$ registers, and the remaining trivial group election objects do not use any registers. ∎

4 Linear-Space TAS for Strong Adaptive Adversaries

We present a TAS implementation from $\Theta(n)$ registers that has max-step complexity $O(\log k)$ both in expectation and w.h.p. (i.e., with probability ${1-1/k^{\Omega(1)}}$), against any strong adaptive adversary. Our implementation is a variant of the RatRace algorithm proposed by Alistarh et al. [5], which has the same max-step complexity but uses $\Theta(n^{3})$ registers.

Theorem 7**.**

There is a randomized implementation of a TAS object from $\Theta(n)$ registers with max-step complexity $O(\log k)$, both in expectation and w.h.p., against any strong adaptive adversary.

Before we prove Theorem 7, we give an overview of the original RatRace algorithm. To simplify exposition, throughout this section we treat $\log n$, $n/\log n$, and $\log\log n$ as integers. It is easy to accommodate the calculations for the case that this is not true, by rounding appropriately.

Overview of RatRace.

RatRace [5] uses two shared memory data structures, a primary tree and a backup grid. The primary tree is a perfect binary tree of height $3\log n$, where each node $v$ stores a randomized splitter object $S_{v}$, and a randomized 3-process TAS object $T_{v}$. The latter can be implemented from two 2-process TAS objects.

Each process $p$ starts at the root of the primary tree and moves downwards towards the leaves. The process goes through the splitters at the nodes it visits along the way, until it stops at a splitter, or “falls off” the bottom of the tree (which happens only with low probability). If $p$ turns left or right at a splitter $S_{v}$, then it moves respectively to the left or right child of $v$, provided $v$ is not a leaf. If $v$ is a leaf, $p$ moves to the backup grid as explained below. If $p$ stops at $S_{v}$ then it stops moving downwards, and starts to move upwards towards the root, along the same path. At each node $u$ in the path to the root, $p$ tries to win the TAS on object $T_{u}$. If $p$ loses that TAS, it immediately loses the implemented TAS. Otherwise, it moves to the parent of $u$ in the tree. The process that wins the TAS at the root competes against the winner at the backup grid.

The backup grid is an $n\times n$ square grid, where each node $v=(i,j)\in\{1,\ldots,n\}^{2}$ stores a deterministic splitter object, and also a randomized 3-process TAS object as before. We define the left and right children of node $(i,j)$ at the grid to be nodes $(i+1,j)$ and $(i,j+1)$, respectively. Each process that falls off the primary tree starts at node $(1,1)$, and proceeds in a similar way as in the primary tree: At each node the process goes through the splitter, moving to the child as indicated by the direction to which the process turns at the splitter, until it stops at some splitter. Then, the process tries to move back to node $(1,1)$ along the same path, by winning all the TAS in the nodes along the way. The properties of deterministic splitters guarantee that the process wins a splitter before it falls off the grid.

The winner of the TAS at node $(1,1)$ of the backup grid, and the winner of the TAS at the root of the primary tree participate in a randomized 2-process TAS, which determines the winner of RatRace.

To ensure linearizability, a doorway object is used such that only processes that pass through the doorway participate in the above algorithm, whereas processes that are deflected lose immediately.

Reducing the Space Complexity (Proof of Theorem 7).

RatRace requires $\Theta(2^{3\log n})=\Theta(n^{3})$ registers for the primary tree of height $3\log n$, and $\Theta(n^{2})$ registers for the backup $n\times n$ grid. Next we show how to reduce this space complexity, without increasing the max-step complexity.

We use a data structure, which we call an elimination path, that is similar to the backup grid but uses fewer registers. An elimination path of length $\ell$ is an $\ell$-node path where each node $i\in\{1,\ldots,\ell\}$ stores a deterministic splitter $S_{i}$, and a randomized 2-process TAS object $T_{i}$. The possible outcomes for a process accessing an elimination path is to win, lose, or fall off the path. A process $p$ enters the elimination path at node $i=1$, and moves towards node $\ell$, going through splitter $S_{i}$ at each node $i$ it visits. If $p$ turns left at $S_{i}$, then it loses and takes no more steps. If it turns right, then it moves to the next node, $i+1$, if $i<\ell$, whereas if $i=\ell$, $p$ falls off the path and takes no more steps in the path. Last, if $p$ stops at $S_{i}$, then it starts moving back towards node 1. From node $i>1$, it moves to $i-1$ if it wins the TAS on $T_{i}$, otherwise, it loses and stops. The winner of the elimination path is the winner of $T_{1}$.

With some slight modifications, the TAS algorithm in Figure 3 implements an elimination path of length $n$. More precisely, we remove line 4, where the process accesses the doorway, and replace line 4, where the process participates in a group election, with the statement: if $i>n$ return fall-off. The process wins (loses) if the return value is 0 (respectively, 1).

The next lemma summarizes the main properties of an elimination path.

Lemma 8**.**

*At most one process wins in an elimination path, and not all processes that access the elimination path lose. If $k\leq\ell$ processes access an elimination path of length $\ell$, then no process visits a node with index $j>k$, and no process falls off. *

Proof.

The properties that at most one process wins and not all processes lose follow from the same properties of the TAS implementation in Figure 3. For the second part of the lemma, we have that at each splitter, not all processes can turn right. Hence, if at most $k$ processes enter the elimination path, then at most $k-i$ processes turn right at splitter $S_{i}$, for $i\leq k$. This implies that no process visits a node with index $j>k$, and that no process falls off the end of the path. ∎

To reduce the space complexity of the RatRace algorithm, the first modification we make is to replace the backup grid by a backup elimination path $B$ of length $n$. Lemma 8 implies that $B$ has the same properties as the backup grid against a strong adaptive adversary. Unlike the backup grid however, $B$ requires only $\Theta(n)$ registers.

A second modification is that we replace the primary tree of height $3\log n$, by a data structure consisting of a smaller primary tree, of height $\log n-\log\log n$, and $n/\log n$ elimination paths $P_{i}$ of length $4\log n$, where $1\leq i\leq n/\log n$. Note that we have as many elimination paths as the leaves of the primary tree. The total number of registers required is $\Theta(2^{\log n-\log\log n}+(4\log n)\cdot n/\log n)=\Theta(n)$. The primary tree is used in the same way as before, but now any process that falls off moves to one of the elimination paths, instead of the backup grid. More precisely, a process that falls off the $i$-th leaf moves to elimination path $P_{i}$. The winner at each $P_{i}$ (if there is one) moves back to the primary tree, at leaf $i$, and from there it tries to reach the root as in the original RatRace algorithm. Any process that falls off a path $P_{i}$ moves to the backup elimination path $B$. Finally, as before, the winner of $B$ and the winner of the primary tree participate in a 2-process TAS to determine the winner of the implemented TAS.

Consider a random execution of an algorithm that uses the above TAS implementation, scheduled by a strong adaptive adversary. Fix the prefix of this execution until the first process is poised to invoke the implemented TAS, and suppose the max-contention is $k$.

If $\log k\leq(\log n-\log\log n)/3$, then a bound of $O(\log k)$ on the expected max-step complexity, and also on the max-step complexity w.h.p., follows from the analysis of the original RatRace [5].

In the following we assume that $\log k>(\log n-\log\log n)/3$. We use the next simple lemma, which implies that w.h.p. the number of processes that enter each elimination path $P_{i}$ is not greater than its length.

Lemma 9**.**

With probability at least $1-1/n$, each leaf node in the primary tree is visited by at most $4\log n$ processes.

Proof.

The number of processes that visit a given leaf node is stochastically dominated by the number of balls that fall in a given bin in the standard bins-and-balls model, with $n$ balls and $n/\log n$ bins. In this model each ball is placed in a bin chosen independently and uniformly at random. The domination follows because we can assume each process $p$ comes with an independent and uniform random bit string of length $\log n-\log\log n$. If $p$ goes through a randomized splitter in a node at distance $i-1$ from the root, and does not stop at that splitter, then the $i$-th bit in the bit string determines whether $p$ will turn left or right at the splitter. Hence, the random bit string uniquely determines the leaf that $p$ will reach, if it does not stop at any splitter along the way.

For $1\leq i\leq n$, let $X_{i}$ be the 0/1 random variable that is 1 if and only if the $i$-th ball falls in some fixed bin $b$. Let $X=X_{1}+\dots+X_{n}$ be the total number of balls that fall in $b$. Then $\operatorname{\mathbf{E}}[X]=\log n$, and by a standard Chernoff bound, stated as Theorem 10 below, we obtain

[TABLE]

Therefore, the same $n^{-2}$ upper bound applies to the probability that more than $4\log n$ processes visit a given leaf node. Then by a union bound, the probability that the maximum number of visits at any of the $n/\log n$ leaves exceeds $4\log n$ is at most $n^{-1}/\log n$. ∎

The following Chernoff Bound, used in the proof above, can be found in [18, Theorem 2.3(b)].

Theorem 10** (Chernoff Bound).**

Let $X_{1},X_{2},\dots,X_{n}$ be independent random variables with $0\leq X_{i}\leq 1$, for each $i\in\{1,\dots,n\}$, and let $X=X_{1}+\dots+X_{m}$ and $\mu=\operatorname{\mathbf{E}}[X]$. Then for any $\delta>0$,

[TABLE]

From Lemma 9, we have that w.h.p. no more than $4\log n$ processes enter any single elimination path $P_{i}$, and thus w.h.p. no process enters the backup elimination path $B$, by Lemma 8. If no process enters $B$, then each process traverses at most a path of length $\log n-\log\log n$ in the primary tree (from the root to a leaf), and at most one of the elimination paths $P_{i}$ of length $4\log n$. Therefore, each process goes through at most $O(\log n)$ splitters, and participates in at most $O(\log n)$ 3-process TAS objects. It follows that the max-step complexity is bounded by $O(\log n)=O(\log k)$ w.h.p. Since w.h.p. no process reaches $B$, and the maximum number of steps a process takes at $B$ is $O(n)$ w.h.p., it follows that the expected max-step complexity is bounded by $O(\log k)$, as well. This completes the proof of Theorem 7. ∎

5 Combining TAS Algorithms for Different Adversaries

RatRace and its linear-space variant presented in Section 4 achieve logarithmic max-step complexity in the strong adaptive adversary model. These algorithms do not benefit from weaker adversaries, as their expected max-step complexity is still logarithmic even in the oblivious adversary model. On the other hand, the TAS implementations in Section 3, which are more efficient against weaker adversaries, exhibit poor performance in the strong adaptive adversary model, having linear expected max-step complexity. In this section we describe how one can combine any of the implementations in Section 3 with RatRace, to obtain a TAS object that has the expected max-step complexity of RatRace against any strong adaptive adversary, and the expected max-step complexity of the corresponding algorithm in Section 3 in the weaker adversary model.

Theorem 11**.**

For any randomized TAS implementation Imp, there is a randomized TAS implementation Comb that has the following properties:

1. (a)

If $f$ is a non-decreasing function such that the expected max-step complexity of Imp is at most $f(k)$ against any location-oblivious (or r/w-oblivious) adversary, then Comb has expected max-step complexity O\bigl{(}f(k)\bigr{)} against any location-oblivious (respectively r/w-oblivious) adversary; 2. (b)

Comb* has expected max-step complexity $O(\log k)$ against any strong adaptive adversary; and* 3. (c)

The space complexity of Comb is $\Theta(n)$ plus the space complexity of Imp.

Combining Theorem 11 with Theorems 4 and 6, yields the following result.

Corollary 12**.**

*There are randomized implementations of TAS objects from $\Theta(n)$ registers with expected max-step complexity $O(\log^{\ast}k)$ or $O(\log\log k)$ against any location-oblivious adversary or any r/w-oblivious adversary, respectively, and with expected max-step complexity $O(\log k)$ against any strong adaptive adversary. *

5.1 Proof of Theorem 11

5.1.1 Implementation

We present a TAS implementation, Comb, which achieves the step and space complexities stated in Theorem 11. Each process first enters a doorway $D$, and the processes that get deflected lose immediately. A process that passes through $D$, then runs both Imp and a variant of RatRace, in parallel. The only difference of the RatRace variant used from the original RatRace is that its initial doorway is removed. More precisely, after passing through $D$, each process executes a step of Imp in every odd step, and a step of RatRace (without doorway) in every even step.

A natural way to combine the two interleaved executions would be that each process takes steps until it either wins or loses in one of the two algorithms; if it loses it also loses in the combined implementation, and if it wins in one of the two algorithms it competes against the winner of the other algorithm. This approach, however, could yield an execution in which no process wins. For instance, suppose that Imp is also an instance of RatRace. In an execution in which only two processes, $p$ and $q$, participate, process $p$ might loses against $q$ on one of the 2- or 3-process TAS objects in the first instance of RatRace, and at the same time $q$ may lose against $p$ on a TAS object in the second instance of RatRace; thus all processes lose.

To solve this problem we impose the rule that if a process loses in Imp at a point when it has already stopped at some splitter object in RatRace, then the process continues to execute RatRace. More precisely, we use the rules below to combine the two executions, with the help of an auxiliary 2-process TAS object $T_{top}$.

1. (C1)

If a process wins either RatRace or Imp, then it stops taking steps in the other algorithm, and tries to win $T_{top}$; if it wins $T_{top}$ then it wins the implemented TAS object, otherwise it loses. 2. (C2)

If a process loses RatRace then it stops taking steps in Imp, and it loses the implemented TAS object. 3. (C3)

If a process loses Imp while it has a pending split() call on a (randomized or deterministic) splitter of RatRace, then it keeps taking steps in RatRace, until its pending split() operation completes. Once it has no more pending split(**) operation it does one of the following:

1. (C3a)

If it has not yet stopped at any of the splitter objects in RatRace, then it stops taking steps in RatRace, and it loses the implemented TAS object. 2. (C3b)

If it has already stopped at one of the splitter objects in RatRace, then it continues taking steps in RatRace until RatRace finishes, and it either wins or loses RatRace. If it wins RatRace, then it proceeds as in (C1); otherwise it loses the implemented TAS.

We now prove that Comb is a correct (linearizable) TAS implementation, and then we show that it satisfies properties (a)–(c) of Theorem 11.

5.1.2 Correctness

A process accesses $T_{top}$ if and only if it wins either RatRace or Imp. It follows that at most two processes can execute the TAS() operation on $T_{top}$, one that won RatRace and one that won Imp, and thus at most one process can win Comb. In the following we show that in any execution in which all processes complete their TAS() call, at least one process wins (therefore exactly one process wins). Due to the initial doorway $D$, linearizability follows from exactly the same arguments as for the algorithm in Section 3.2 (see the correctness proof of Theorem 1).

For the purpose of a contradiction, consider an execution $\mathcal{E}$ in which all participating processes take sufficiently many steps to finish Comb, and they all lose Comb. Let $Q$ be the set of processes that stop at some RatRace splitter in $\mathcal{E}$.

First suppose that $Q$ is empty. Then no process wins or loses RatRace, as otherwise it would have first stopped at some splitter, and thus it would be in $Q$. Hence, by (C1)–(C3) all processes execute Imp to completion, and either win or lose Imp eventually. Then, by the assumption that Imp is a correct TAS algorithm, exactly one process wins Imp, and this process also wins $T_{top}$, since no process wins RatRace, and hence no other process participates in a TAS(**) operation on $T_{top}$. This contradicts the assumption that all processes lose Comb.

Now suppose that $Q$ is not empty, that is, in execution $\mathcal{E}$ at least one process stops at a splitter of RatRace. By the assumption that all processes lose Comb in $\mathcal{E}$, there is no process that wins either Imp or RatRace (otherwise that process would execute a TAS() operation on $T_{top}$ and some process would win $T_{top}$, and thus Comb). In particular, no process in $Q$ wins RatRace, and since by (C3)(C3b), each $q\in Q$ does not stop taking steps in RatRace even after losing Imp, it must lose RatRace at some point. Hence, each process in $Q$ loses a TAS() operation on some 2- or 3-process TAS object of RatRace. Recall that the TAS objects used by RatRace are arranged in a rooted tree (where we consider the elimination paths as part of the tree). Whenever a process wins a non-root TAS object $T$ of that tree, it continues to the parent of $T$. Among all TAS objects on which processes in $Q$ lose, let $T^{\ast}$ be one that is closest to the root. Then there must be a process $q\in Q$ that wins $T^{\ast}$, so $q$ ascends to the parent of $T^{\ast}$. Then $q$ must lose on some other TAS object closer to the root than $T^{\ast}$, which contradicts the definition of $T^{\ast}$.

5.1.3 Complexity

The linear space complexity of Comb claimed in part (c) of Theorem 11 follows immediately from the construction and our RatRace implementation given in Section 4, which uses $\Theta(n)$ registers (Theorem 7). We now analyze the expected max-step complexity of Comb.

High Level Idea.

We first describe the general idea for bounding the expected max-step complexity of Comb, ignoring some of the subtleties that arise in the detailed analysis to follow. We relate the expected max-step complexity of Comb to the expected max-step complexity of RatRace and Imp, respectively, depending on what adversary model is used. Note that the 2-process TAS object $T_{top}$ has constant expected max-step complexity even against a strong adaptive adversary, so it does not affect the asymptotic max-step complexity of Comb. Recall that during Comb processes alternate between steps of RatRace and Imp until one of those two algorithms terminate, and if RatRace terminates first, then the calling process also terminates its Imp call (but not necessarily the other way around). Therefore, the asymptotic max-step complexity of Comb is dominated by that of RatRace. Hence, if a random execution of $k$ processes calling Comb is scheduled by a strong adaptive adversary, then the maximum number of steps any process takes is $O(\log k)$, which is the upper bound for RatRace as stated in Theorem 7.

Now suppose such a random execution is scheduled by a location-oblivious or r/w-oblivious adversary. It suffices to show that the expected maximum number of steps any process devotes to RatRace during Comb is bounded asymptotically by the expected maximum number of steps any process devotes to Imp. A process can devote more steps to RatRace than to Imp only if, by the time it finishes Imp, it has either already stopped at a splitter in RatRace, or it has a pending split() call that will return stop. Hence, it suffices to consider processes that stop at RatRace splitters. Suppose a process stops at a RatRace splitter in its $i$-th split() operation. Since the process alternates between RatRace and Imp steps prior to its last split() operation, and each split() operation takes a constant number of steps, until finishing its $i$-th split() operation the process devotes $\Theta(i)$ steps to RatRace and $\Theta(i)$ steps to Imp. In the remainder of its RatRace execution, the process executes at most $i+1$ TAS() calls on 2- or 3-process TAS objects (one for each splitter it went through previously, in addition to $T_{top}$). The number of steps for each such TAS() call is bounded by a geometrically distributed random variable. Using Chernoff Bounds, we show that with probability $1-1/4^{i}$ the process needs only $O(i)$ steps for its at most $i+1$ TAS() calls to finish RatRace after stopping at the $i$-th splitter. Due to the arrangements of splitters in a primary tree and elimination paths, at most $2^{i}$ processes can stop after their $i$-th split() operation. Thus, by a union bound applied to all processes stopping at the $i$-th splitter they go through, with probability exponentially close to $1$, all these processes need only $O(i)$ steps to finish RatRace. To summarize: all processes that stop at their $i$-th splitter devote $\Omega(i)$ steps of Comb to Imp, $\Theta(i)$ steps to split() operations during RatRace, and with high probability $O(i)$ steps to the remainder of RatRace. Hence, by the union bound applied to all $i>0$, the expected maximum number of steps any process needs for RatRace is asymptotically bounded by the number of steps it devotes to Imp.

Detailed Analysis.

First, we modify Comb such that there is no initial doorway $D$, and processes do not access the 2-process TAS object $T_{top}$ after winning RatRace or Imp. Instead, a process simply terminates if it wins RatRace or Imp. Since the expected max-step complexity of $T_{top}$ is constant, removing $T_{top}$ does not affect the asymptotic expected max-step complexity. We will refer to this modified algorithm as Comb*′*.

Consider an execution prefix $\mathcal{E}$ of an algorithm $M$ that uses Comb, where $\mathcal{E}$ ends when the first process exits doorway $D$, and suppose $P$ is the set of processes that enter $D$ during $\mathcal{E}$. Then the max-contention $k_{\max}^{M,\textnormal{{Comb}}}(\mathcal{E})$ is at least $|P|$. Hence, it suffices to show for any set $P$, that a random execution of Comb*′* by the processes in $P$ has expected max-step complexity O\bigl{(}f(|P|)\bigr{)} if scheduled by a location-oblivious (or r/w-oblivious) adversary, and $O(\log|P|)$ if scheduled by a strong adaptive adversary.

To that end, let $M_{C}$ be the algorithm in which the processes in $P$ (and only them) call Comb*′, and let $A_{C}$ be some adversary. A scheduling of $M_{C}$ by $A_{C}$ yields a random execution in which a subset of the processes in $P$ take steps (the max-congestion in that execution is $|P|$). For two random coin flip vectors $\omega_{I},\omega_{R}\in\Omega^{\infty}$, let $\mathcal{E}_{C}$ denote the random execution of $M_{C}$ scheduled by $A_{C}$, where the $i$-th coin flip result obtained during the execution of Imp and RatRace within Comb′* is the $i$-th element of $\omega_{I}$ and $\omega_{R}$, respectively. For a process $p\in P$, let $T_{C}^{p}$ denote the number of steps $p$ executes in $\mathcal{E}_{C}$, and let $T_{I}^{p}$ and $T_{R}^{p}$ denote the number of those steps that are devoted to Imp and RatRace, respectively. Let $T_{C}=\max_{p\in P}T_{C}^{p}$, $T_{I}=\max_{p\in P}T_{I}^{p}$, and $T_{R}=\max_{p\in P}T_{R}^{p}$. Then $\operatorname{\mathbf{E}}[T_{C}]$ is the expected max-step complexity of Comb*′* in $M_{C}$ against $A_{C}$.

Lemma 13**.**

There are constants $d_{I},d_{R}>0$ such that

[TABLE]

Before we prove Lemma 13, we argue that it implies parts (a) and (b) of Theorem 11.

To prove part (a), we assume that adversary $A_{C}$ is location-oblivious (or r/w-oblivious). Let $M_{I}$ be the algorithm in which the process in $P$ call Imp.

We construct a location-oblivious (or r/w-oblivious) adversary $A_{I}$ that schedules $M_{I}$ by simulating adversary $A_{C}$ as follows. Let $\omega_{R}^{\ast}\in\Omega^{\infty}$ be a coin flip sequence such that $E[T_{I}\mid\omega_{R}=\omega_{R}^{\ast}]$ is maximized. To schedule an execution of algorithm $M_{I}$, adversary $A_{I}$ simulates adversary $A_{C}$ on algorithm $M_{C}$, using the $i$-th element of $\omega_{R}^{\ast}$ for the $i$-th coin flip used in RatRace. By the structure of Comb*′*, in which processes alternate steps of RatRace and Imp, it is uniquely determined when a process $p$ executes its $i$-th step of Imp. Therefore, even the location-oblivious (or r/w-oblivious) adversary can simulate all steps of RatRace in $\mathcal{E}_{C}$, and schedule processes to take steps in $M_{I}$ exactly in the same order as they take steps in the Imp portion of $\mathcal{E}_{C}$.

Let $\tau_{I}$ denote the expected max-step complexity of Imp against adversary $A_{I}$. Then we have $E[T_{I}\mid\omega_{R}=\omega_{R}^{\ast}]\leq\tau_{I}(|P|)$. Since $\omega_{R}^{\ast}$ is chosen to maximize the conditional expectation on the left side, it follows that $E[T_{I}]\leq\tau_{I}(|P|)$. Moreover, by the theorem’s assumption that the expected max-step complexity of Imp is bounded by $f$, we have $\tau_{I}(|P|)\leq f(|P|)$. From the last two inequalities and (9), we obtain $E[T_{C}]\leq d_{I}\cdot(f(|P|)+1)=O(f(P))$. As this is true for all sets $P$, and any location-oblivious (or r/w-oblivious) adversary $A_{C}$, it proves part (a) of Theorem 11.

The proof of part (b) is almost identical: We now assume $A_{C}$ is a strong adaptive adversary. We construct a strong adaptive adversary $A_{R}$ which schedules processes in $P$ to execute RatRace by simulating adversary $A_{C}$ on algorithm $M_{C}$, assuming the worst-case vector $\omega_{I}$. As before, we argue that $E[T_{R}]\leq\tau_{R}(|P|)$, where $\tau_{R}$ is the expected max-step complexity of RatRace against $A_{R}$. Since by Theorem 7 the expected max-step complexity of RatRace is $O(\log k)$ against any strong adaptive adversary, $\tau_{R}(|P|)=O(\log|P|)$. Then from (10) it follows $E[T_{C}]=O(\log|P|)$. This completes the proof of Theorem 11. It remains to prove Lemma 13.

5.2 Proof of Lemma 13

We first prove (10). Consider a process $p\in P$ that invokes Comb*′* in $\mathcal{E}_{C}$. Process $p$ alternates devoting steps to Imp and RatRace (starting with a step of Imp), until either its Comb*′* call ends, because $p$ won RatRace or lost RatRace or won Imp (see (C1) and (C2)), or until it stops executing steps of Imp (see (C3)). Hence, in either case at least $\lfloor T_{C}^{p}/2\rfloor$ of $p$’s steps in $\mathcal{E}_{C}$ are devoted to RatRace, and thus $T_{R}\geq(T_{C}-1)/2$. This implies (10).

Next we prove (9). We will use the next statement which follows easily from Chernoff Bounds.

Lemma 14**.**

For every constant $0<q<1$, there exists a constant $c>0$ such that the following is true for all $\Delta\geq 0$, and all integers $m\geq 1$. If $X_{1},\dots,X_{m}$ are random variables satisfying ${\Pr(X_{i}>\ell\mid X_{1},\dots,X_{i-1})\leq q^{\ell}}$ for every integer $\ell\geq 0$, then

[TABLE]

Proof.

If we choose $c\geq\lceil\log_{4}(1/q)\rceil$, then the statement is true for $m=1$. Therefore, in the rest of the proof it suffices to consider $m\geq 2$. Conditionally on $X_{1},\ldots,X_{i-1}$, random variable $X_{i}$ is dominated by a geometric random variable $Y_{i}$ with parameter $q$. It follows that $\sum_{1\leq i\leq m}X_{i}$ is dominated by $\sum_{1\leq i\leq m}Y_{i}$, where the random variables $Y_{i}$ are mutually independent. Let $Y=\sum_{1\leq i\leq m}Y_{i}$, so $\operatorname{\mathbf{E}}[Y]=m/q$. We can then apply a Chernoff Bound for independent geometric random variables (e.g., [10, Theorem 1.14]), which states that for any $\delta>0$,

[TABLE]

Setting $\delta=cq+cq\Delta/m-1$, for a $c$ large enough that $\delta>0$, we obtain

[TABLE]

For $c\geq 4/q$, we have $(cq+cq\Delta/m-1)^{2}\geq(cq+cq\Delta/m)^{2}/2$, and thus

[TABLE]

(For the second to last inequality we used $m\geq 2$.) For large enough $c$, this is at least $\Delta\ln 4$, and then the claim follows from (11). ∎

The next lemma bounds the probability a process devotes more steps to RatRace than to Imp. Let $Q$ be the set of processes $p\in P$ that stop at some RatRace splitter when executing Comb*′* in $\mathcal{E}_{C}$.

Lemma 15**.**

There is a constant $c>0$ such that for all $\Delta\geq 0$ and any process $p\in P$,

[TABLE]

Proof.

In the RatRace portion of Comb*′, a process first executes only split(**) operations until it either loses RatRace (and thus Comb′), or stops at a splitter. After stopping at a splitter, $p$’s remaining execution of RatRace comprises only TAS() operations on 2-process and 3-process TAS objects. In particular, $p$ executes at most one such TAS() operation for each splitter it went through until it stopped at one. Recall also that once $p$ has finished the Imp portion of Comb′, it finishes at most one more split() call in RatRace (if it has a pending such call). Hence, $p$ executes at most $T_{I}^{p}$ split() calls in the RatRace portion of Comb′*, and thus also at most $T_{I}^{p}$ TAS() operations. Thus, defining $Z$ as the number of steps $p$ takes during those TAS() operations, we have

[TABLE]

For $i\in\{1,\dots,T_{I}^{p}\}$ let $Z_{i}$ denote the number of steps process $p$ executes in order to finish its $i$-th TAS() operation on a 2- or 3-process TAS object of the RatRace portion of Comb*′*; if $p$ executes fewer than $i$ such TAS() operations, then $Z_{i}=0$. As discussed in Section 2.3, for $\ell\geq 0$ a process finishes a TAS() on a 2-process TAS object in $O(\ell)$ steps with probability at least $1-1/2^{\ell}$. We can implement each 3-process TAS object from two 2-process TAS objects in such a way that for each TAS() operation on the 3-process TAS, a process needs only to complete one or two TAS() operations on the 2-process TAS objects. This way, we get the same asymptotic bound as for 2-process TAS objects, i.e., for $\ell\geq 0$, with probability at least $1-1/2^{\ell}$ a process finishes a TAS() operation on a 3-process TAS object in $O(\ell)$ steps. Therefore, there is a constant $s>0$ such that $\Pr(Z_{i}>s\ell\mid T_{I}^{p},Z_{1},\dots,Z_{i-1},\,p\in Q)\leq 2^{-\ell}$ for all $\ell\geq 0$. Then by Lemma 14, applied to $X_{i}=Z_{i}/s$, there is a constant $c^{\prime}>0$, so that for all $\Delta\geq 0$ and all $m\geq 1$,

[TABLE]

Applying (12) yields the claim for a sufficiently large constant $c>0$. ∎

By Lemma 15 (used for the inequality labeled $(\ast)$ below), there is a constant $c>0$ such that for any $\Delta\geq 0$,

[TABLE]

Recall that in RatRace a process can stop either at a randomized splitter on the primary tree, or at a deterministic splitter on an elimination path. Moreover, at most one process can stop at each splitter, so at most $2^{i}$ processes can stop at the $i$-th splitter they go through. Since a process $p$ executes fewer than $T_{I}^{p}$ split(**) calls in RatRace before stopping at a splitter or terminating Comb*′*, the number of processes $p\in Q$ satisfying $T_{I}^{p}\leq\Delta$ is at most $2^{\Delta}$. Hence,

[TABLE]

For any process $p\in P$ that does not stop at any RatRace splitter, i.e., $p\in P\setminus Q$, we have $T_{R}^{p}\leq T_{I}^{p}+O(1)$, because once $p$ has finished the Imp portion of Comb*′, it finishes at most one split(**) call in RatRace before finishing Comb′*. It follows that for any $p\in P$, $T_{R}^{p}>2cT_{i}^{p}$ implies $p\in Q$, if the constant $c$ is sufficiently large. Using this observation we obtain

[TABLE]

It follows that

[TABLE]

Then

[TABLE]

Finally, combining that with the fact that $T_{C}=T_{I}+T_{R}$, implies (9). This completes the proof of Lemma 13. ∎

6 A 2-Process Time Lower Bound for Oblivious Adversaries

We show a lower bound on the max-step complexity of any 2-process TAS implementation, against the worst possible oblivious adversary.

Theorem 16**.**

For any randomized 2-process TAS implementation and any integer $t\geq 0$, there is an oblivious adversary $A$ such that with probability at least $1/4^{t}$ the max-step complexity of the implemented TAS(**) operation against $A$ is at least $t$.

Proof.

The proof employs Yao’s minimax principle [24].

Let $M$ be a randomized implementation of a 2-processes TAS object. For any execution $\mathcal{E}$ of this implementation, let $c_{t}(\mathcal{E})=1$ if some process executes at least $t$ shared memory steps in $\mathcal{E}$; let $c_{t}(\mathcal{E})=0$ otherwise.

Let $\Sigma_{t}$ be the set of all possible schedules $\sigma=(\sigma_{1},\sigma_{2},\ldots)$, where $\sigma_{i}\in\{0,1\}$, and $\sigma$ has the following properties: (i) $|\sigma|=2k$, for some $k\in\{t,\ldots,2t-1\}$; (ii) $\sigma_{2i-1}=\sigma_{2i}$, for all $i\in\{1,\dots,k\}$; and (iii) some process $p\in\{0,1\}$ appears exactly $2t$ times at $\sigma$ (so, the other process, $1-p$, appears $2(k-t)<2t$ times). We have

[TABLE]

Consider the coin flip sequences $\omega_{p}=(\omega_{p,1},\dots,\omega_{p,t})\in\Omega^{t}$, for $p\in\{0,1\}$. For any schedule $\sigma\in\Sigma_{t}$, let $\mathcal{E}_{M}(\sigma,\omega_{0},\omega_{1})$ denote the execution of algorithm $M$ where processes are scheduled according to $\sigma$, and the $i$-th coin flip of process $p$ returns the value $\omega_{p,i}$. Recall our model assumption that (w.l.o.g.) each process alternates between coin flip steps and shared memory steps. Since each process appears at most $2t$ times in $\sigma\in\Sigma_{t}$, each process executes at most $t$ coin flips in the resulting execution. We will now show that

[TABLE]

To prove (18), let $\lambda_{p}$, for $p\in\{0,1\}$, be an arbitrary but fixed infinite extension of $\omega_{p}$, e.g., we can choose $\lambda_{p}=(\omega_{p,1},\dots,\omega_{p,t},0,0,\dots)$, assuming that [math] is an element of $\Omega$. Let $M_{\lambda}$ be the TAS algorithm where each process $p$ executes the same program as in $M$, but ignores its coin flips, and instead acts as if its $i$-th coin flip is the $i$-th element of vector $\lambda_{p}$. Then $M_{\lambda}$ behaves as a deterministic 2-process TAS algorithm. Since there is no wait-free deterministic 2-process TAS algorithm, there exists an execution of $M_{\lambda}$ in which at least one process executes at least $t$ shared memory steps without finishing its TAS() call. Moreover, there is such an execution $\mathcal{E}^{\prime}$ which has the additional property that each coin flip step by process $p\in\{0,1\}$ (whose result is replaced in the algorithm by an element of $\lambda_{p}$) is immediately followed in $\mathcal{E}^{\prime}$ by the next shared memory step of the same process $p$. Let $\mathcal{E}$ be the prefix of $\mathcal{E}^{\prime}$ that ends when the first process has executed its $t$-th shared memory step, and let $\sigma$ be the schedule corresponding to $\mathcal{E}$. The prefix $\mathcal{E}$ exists, because we argued above that some process executes at least $t$ shared memory steps without finishing its TAS() call. It follows that $c_{t}(\mathcal{E})=1$ and $\sigma\in\Sigma_{t}$, and also $\mathcal{E}=\mathcal{E}_{M}(\sigma,\omega_{0},\omega_{1})$. This proves (18).

Now let $(\omega_{0}^{\ast},\omega_{1}^{\ast})$ be chosen according to any product distribution over $\Omega^{t}\times\Omega^{t}$, and $\sigma^{\ast}$ according to any probability distribution over $\Sigma_{t}$. By Yao’s minimax principle [24],

[TABLE]

Let $\varepsilon$ denote the left side in this inequality, and recall that $c_{t}(\mathcal{E}_{M}(\sigma,\omega_{0}^{\ast},\omega_{1}^{\ast}))$ is a 0–1 random variable indicating whether some process executes at least $t$ steps in $\mathcal{E}_{M}(\sigma,\omega_{0}^{\ast},\omega_{1}^{\ast})$. Hence, $\varepsilon$ is a lower bound for the probability that some process needs at least $t$ steps to finish its TAS(**) call in a random execution of $M$, for the worst possible schedule $\sigma$. Thus, it suffices to prove that $\varepsilon\geq 1/4^{t}$. To do so we choose $\sigma^{\ast}$ uniformly in $\Sigma_{t}$ to obtain

[TABLE]

This completes the proof of Theorem 16. ∎

Conclusion

In this paper we devised several efficient randomized TAS algorithms. Most importantly, we presented an algorithm with an expected max-step complexity of $O(\log^{\ast}k)$ against the oblivious and some slightly stronger adversary models, where $k$ is a measure of contention.

The progress in improving randomized TAS algorithms is mirrored by recent progress on randomized consensus algorithms. Aspnes [6] has devised a randomized consensus algorithm that has $O(\log\log n)$ expected max-step complexity in the oblivious adversary model. This algorithm is based on the sifting technique from [2]. It would be interesting to investigate whether techniques similar to those presented here can be used to achieve even faster consensus algorithms. In particular, we believe that our group election implementation for r/w-oblivious adversaries proposed in Section 3.4 could be used in the framework of [6] to obtain an adaptive binary consensus algorithm with expected max-step complexity $O(\log\log k)$.

Several other important problems remain open. For the oblivious adversary, no TAS implementations with constant expected max-step complexity are known, and no super-constant lower bounds are known even in the strong adaptive adversary model.

Acknowledgements

We thank Dan Alistarh for pointing out Styer and Peterson’s $\Omega(\log n)$ space lower bound for deadlock-free leader election [21]. We also thank the anonymous reviewers for their helpful feedback.