We study contention resolution (CR) on a shared channel modelled as a game with selfish players. There are n agents and the adversary chooses some k smaller than n of them as players. Each participating player in a CR game has a packet to transmit. A transmission is successful if it is performed as the only one at a round. Each player aims to minimize its packet latency. We introduce the notion of adversarial equilibrium (AE), which incorporates adversarial selection of players. We develop efficient deterministic communication algorithms that are also AE. We characterize the price of anarchy in the CR games with respect to AE.

We develop deterministic algorithms for the problems of consensus, gossiping and checkpointing with nodes prone to failing. Distributed systems are modeled as synchronous complete networks. Failures are represented either as crashes or Byzantine faults with authentication. The algorithmic goal is to have both linear running time and linear amount of communication for as large an upper bound t on the number of faults as possible, with respect to the number of nodes n. For crash failures, these bounds of optimality are t = O(n / (log n)) for consensus and t = O(n / (log2 n)) for gossiping and checkpointing. For the model of Byzantine faults with authentication, we show how to reach consensus in both linear running time and communication for t = O(√n). We show how to implement the consensus algorithm for crash failures in the single-port model such as to preserve the range of t for which both the running time and communication are optimal. We prove a lower bound Ω (t+log n) on the running time of algorithms for each of the considered problems.

We study consensus and checkpointing in synchronous distributed systems. There are n nodes that communicate by sending messages, and any two nodes can communicate directly. The nodes are prone to crashing, with an upper bound t on the number of crashes. Algorithms use overlay networks of choice to save on the amount of communication. We explore using Ramanujan graphs as such overlay networks. We demonstrate that Ramanujan graphs have topological properties conducive to fault-tolerance and time/communication efficiency of distributed algorithms. Our consensus algorithm assumes binary input values, runs in O(t) time and sends O(n+t log t) bits. The algorithm sends the optimum number O(n) of bits for t=O(n/log n), thus for this range of t it improves on the algorithm by Galil, Mayer and Yung [FOCS 1995] that also sends O(n) bits but works in exponential time. The consensus algorithm can be implemented such that a node sends a message to at most one node at a round while maintaining the asymptotic time and communication performance bounds. Our checkpointing algorithm runs in linear time O(n) and with O(n log7 n) messages. It improves on the most communication-efficient and time-optimal algorithm by Galil, Mayer and Yung [FOCS 1995], which may have O(n1+ε) messages sent, for any chosen constant ε>0.

We study Consensus in synchronous networks with arbitrary connected topologies. Nodes may be faulty, in the sense of either Byzantine or proneness to crashing. Let t denote a known upper bound on the number of faulty nodes, and D_s denote a maximum diameter of a network obtained by removing up to s nodes, assuming the network is (s+1)-connected. We give an algorithm for Consensus running in time t + D_{2t} with nodes subject to Byzantine faults. We show that, for any algorithm solving Consensus for Byzantine nodes, there is a network G and an execution of the algorithm on this network that takes Ω(t + D_{2t}) rounds. We give an algorithm solving Consensus in t + D_{t} communication rounds with Byzantine nodes using authenticated messages of polynomial size. We show that for any numbers t and d > 4, there exists a network G and an algorithm solving Consensus with Byzantine nodes using authenticated messages in fewer than t + 3 rounds on G, but all algorithms solving Consensus without message authentication require at least t + d rounds on G. This separates Consensus with Byzantine nodes from Consensus with Byzantine nodes using message authentication, with respect to asymptotic time performance in networks of arbitrary connected topologies, which is unlike complete networks. Let f denote the number of failures actually occurring in an execution and unknown to the nodes. We develop an algorithm solving Consensus against crash failures and running in time 𝒪(f + D_{f}), assuming only that nodes know their names and can differentiate among ports; this algorithm is also communication-efficient, by using messages of size 𝒪(mlog n), where n is the number of nodes and m is the number of edges. We give a lower bound t+D_t-2 on the running time of any deterministic solution to Consensus in (t+1)-connected networks, if t nodes may crash.

We consider broadcasting on multiple access channels under adversarial packet injection modeled by leaky-bucket adversaries. We study the impact of individual injection rates on latency, as compared to general leaky bucket adversaries. It is demonstrated that some broadcast algorithms designed for ad-hoc channels have bounded latency for wider ranges of injection rates when executed on channels with a fixed number of stations against adversaries that can activate at most one station per round. We give outcomes of simulations comparing the performance of broadcast algorithms against randomized adversaries, including comparisons to randomized backoff algorithms.

We investigate routing on networks modeled as multiple access channels, when packets are injected continually. An energy cap is a component of the system, understood as a bound on the number of stations that can be switched on simultaneously. Each packet is injected into some station and needs to be delivered to its destination station via the channel. A station has to be switched on in order to receive a packet when it is heard on the channel. Each station manages when it is switched on and off by way of a programmable wake-up mechanism, which is scheduled by a routing algorithm. Packet injection is governed by adversarial models that determine upper bounds on injection rates and burstiness. We develop deterministic distributed routing algorithms and assess their performance in the worst-case sense. An algorithm knows the number of stations but does not know the adversary. One of the algorithms maintains bounded queues for the maximum injection rate 1 subject only to the energy cap 3. This energy cap is provably optimal, in that obtaining the same throughput with the energy cap 2 is impossible. We give algorithms subject to the minimum energy cap 2 that have latency polynomial in the total number of stations~n for each fixed adversary of injection rate less than 1. An algorithm is k-energy-oblivious if at most k stations are switched on in a round and for each station the rounds when it will be switched on are determined in advance. We give a k-energy-oblivious algorithm that has packet delay O(n) for adversaries of injection rates less than (k-1)/(n-1), and show that there is no k-energy-oblivious stable algorithm against adversaries with injection rates greater than k/n. An algorithm routes directly when each packet makes only one hop from the station into which it is injected straight to its destination. We give a k-energy-oblivious algorithm routing directly, which has latency O(n^2/k) for adversaries of sufficiently small injection rates that are O(k^2/n^2). We develop a k-energy-oblivious algorithm routing directly, which is stable for injection rate k(k-1)/n(n-1), and show that no k-energy-oblivious algorithm routing directly can be stable against adversaries with injection rates greater than k(k-1)/n(n-1).

We consider synchronous distributed systems in which processors communicate by shared read- write variables. Processors are anonymous and do not know their number n. The goal is to assign individual names by all the processors to themselves. We develop algorithms that accomplish this for each of the four cases determined by the following independent properties of the model: concurrently attempting to write distinct values into the same shared memory register either is allowed or not, and the number of shared variables either is a constant or it is unbounded. For each such a case, we give a Monte Carlo algorithm that runs in the optimum expected time and uses the expected number of O(n log n) random bits. All our algorithms produce correct output upon termination with probabilities that are 1−n^{−Ω(1)}, which is best possible when terminating almost surely and using O(n log n) random bits.

We consider a communication channel in which the only available mode of communication is transmitting beeps. A beep transmitted by a station attached to the channel reaches all the other stations instantaneously. Stations are anonymous, in that they do not have any individual identifiers. The algorithmic goal is to assign names to the stations in such a manner that the names make a contiguous segment of positive integers starting from 1. We develop a Las Vegas naming algorithm, for the case when the number of stations n is known, and a Monte Carlo algorithm, for the case when the number of stations n is not known. The given randomized algorithms are provably optimal with respect to the expected time 𝒪( n log n), the expected number of used random bits 𝒪( n log n), and the probability of error.

We consider single-hop radio networks with multiple channels as a model of wireless networks. There are n stations connected to b radio channels that do not provide collision detection. A station uses all the channels concurrently and independently. Some k stations may become active spontaneously at arbitrary times. The goal is to wake up the network, which occurs when all the stations hear a successful transmission on some channel. Duration of a waking-up execution is measured starting from the first spontaneous activation. We present a deterministic algorithm that wakes up a network in O(klog1/b⁡klog⁡n) time, where k is unknown. We give a deterministic scalable algorithm for the special case when b>dlog⁡log⁡n, for some constant d>1, which wakes up a network in O(kblog⁡nlog⁡(blog⁡n)) time, with k unknown. This algorithm misses time optimality by at most a factor of O(log⁡n(log⁡b+log⁡log⁡n)), because any deterministic algorithm requires Ω(kblog⁡nk) time. We give a randomized algorithm that wakes up a network within O(k1/bln⁡1ϵ) rounds with a probability that is at least 1−ϵ, for any 0<ϵ<1, where k is known. We also consider a model of jamming, in which each channel in any round may be jammed to prevent a successful transmission, which happens with some known parameter probability p, independently across all channels and rounds. For this model, we give two deterministic algorithms for unknown k: one wakes up a network in time O(log−1⁡(1p)klog⁡nlog1/b⁡k), and the other in time O(log−1⁡(1p)kblog⁡nlog⁡(blog⁡n)) when the inequality b>log⁡(128blog⁡n) holds, both with probabilities that are at least 1−1/poly(n).

We consider the impact of scheduling disciplines on performance of routing in the framework of adversarial queuing. We propose an adversarial model which reflects stalling of packets due to transient failures and explicitly incorporates feedback produced by a network when packets are stalled. This adversarial model provides a methodology to study stability of routing protocols when flow-control and congestion-control mechanisms affect the volume of traffic. We show that any scheduling policy that is universally stable, in the regular model of routing that additionally allows packets to have two priorities, remains stable in the proposed adversarial model. © 2015 Wiley Periodicals, Inc.NETWORKS, Vol. 66(2), 88–97 2015

We study deterministic broadcasting on multiple access channels when packets are injected continuously. The quality of service is considered in the framework of adversarial queuing. An adversary is determined by injection rate and burstiness, the latter denoting the number of packets that can be injected simultaneously in a round. We consider only injection rates that are less than 1. A protocol is stable when the numbers of packets in queues stay bounded at all rounds, and it is of fair latency when waiting times of packets in queues are O (burstiness/rate). For channels with collision detection, we give a full-sensing protocol of fair latency for injection rates that are at most 1 2(⌈lg n ⌉ + 1), where n is the number of stations, and show that fair latency is impossible to achieve for injection rates that are ω (1 log n ). For channels without collision detection, we present a full-sensing protocol of fair latency for injection rates that are at most 1 c lg 2 n , for some c > 0. We show that there exists an acknowledgment-based protocol that has fair latency for injection rates that are at most 1 cn lg 2 n , for some c > 0, and develop an explicit acknowledgment-based protocol of fair latency for injection rates that are at most 1 27 n 2 ln n . Regarding impossibility to achieve just stability by restricted protocols, we prove that no acknowledgment-based protocol can be stable for injection rates larger than 3 1 + lg n .

We study broadcasting on multiple access channels by deterministic distributed protocols. Data arrivals are governed by an adversary. The power of the adversary is constrained by the average rate of data injection and a bound on the number of different packets that can be injected in one round. The injection rate is at most 1, which forbids the adversary from overloading the channel. We consider a number of deterministic protocols. For each of them we give an upper bound on the worst-case packet latency, as a function of the constraints imposed on the adversary. We present results of experiments by simulations to compare packet latency of the deterministic protocols and of backoff-type randomized protocols. The experiments are carried out in a simulation environment that captures the burstiness of data injection and the resulting traffic by admissibility condition defined by the fraction of active stations and the rate of changing the status of active versus passive among the stations.

We study communication complexity of consensus in synchronous message-passing systems with processes prone to crashes. The goal in the consensus problem is to have all the nonfaulty processes agree on a common value from among the input ones, after each process has been initialized with a binary input value. The system consists of n processes and it is assumed that at most t < n processes crash in an execution. A consensus algorithm that tolerates up to t failures is called fast when its time complexity is O(t). All the previously known fast deterministic consensus solutions sent Ω(n2) bits in messages. We give a fast deterministic consensus algorithm that has processes send only O(n log4 n) bits. In our solution, processes exchange messages according to topologies of overlay graphs that have suitable robustness and connectivity properties related to graph expansion.

We consider bit communication complexity of binary consensus in synchronous message passing systems with processes prone to crashes. A distributed algorithm is locally scalable when each process contributes to the complexity measure an amount that is poly-logarithmic in the size~n of the system, and it is globally scalable when the average contribution per process to the complexity measure is such. We show that consensus can be solved by a randomized algorithm that is locally scalable with respect to both time and bit communication complexities against oblivious adversaries. If a bound t on the number of crashes is a constant fraction of the number n of processes then our randomized consensus solution terminates in the expected O(log n) time while the expected number of bits that each process sends and receives is O(log n). Our solution uses overlay networks with topologies that are explicitly defined and have suitable connectivity and robustness properties related to graph expansion. To compare our results to deterministic consensus solutions, it is known [20] that consensus cannot be solved deterministically by an algorithm that is locally scalable with respect to message complexity and that deterministic solutions globally scalable with respect to bit communication complexity exist for any bound t

The distributed setting of this paper is an asynchronous system consisting of n processes prone to crashes and a number of shared read-write registers. We consider problems regarding assigning integer values to processes in an exclusive way, in the sense that no integer is assigned to two distinct processes. In the problem of renaming, any k ≤ n processes, that hold original names from a range [N]={1,...,N}, contend to acquire unique integers as new names in a smaller range [M] using some r shared registers. When k and N are known, our wait-free solution operates in O(log k (log N + log k log log N)) local steps, for M=O(k), and with r=O(k log(N/k)) auxiliary shared registers. Processes obtain new names by exploring their neighbors in bipartite graphs of suitable expansion properties, with nodes representing names and processes competing for the name of each visited node. We show that 1+min{k-2,log2r(N/2M)} local steps are required in the worst case to wait-free solve renaming, when k and N are known and r and M are given constraints. We give a fully adaptive solution, with neither k nor N known, having M=8k-lg k-1 as a bound on the range of new names, operating in O(k) steps and using O(n2) registers. We apply renaming algorithms to obtain solutions to the Store&Collect problem. When both k and N are known, then storing can be performed in O(log k (log N + log k log log N)) steps and collecting in O(k) steps, for r=O(k log(N/k)) registers.

We consider broadcasting on the multiple-access channel when packets are injected continuously. Multiple-access channel is a synchronous system with the properties that a single transmission at a round delivers the message to all nodes, while multiple simultaneous transmissions result in a conflict which prevents delivering messages to any among the recipients. The traditional approach to dynamic broadcasting has been concerned with stability of protocols under suitable stochastic assumptions about injection rates. We study deterministic protocols competing against adversaries restricted by injection rate and burstiness of traffic. Stability means that the number of packets in queues is bounded by a constant in any execution, for a given number of stations, protocol, and adversary. Strong stability denotes the property that the number of queued packets is proportional to the burstiness of traffic, that is, the maximum number of packets an adversary may inject simultaneously. There are three natural classes of protocols we consider. The weakest acknowledgement-based protocols have a station rely on its local clock and on a feedback from the channel during its own attempts of transmissions. Full-sensing protocols allow a station to rely on a global clock and to store the history of all the previous successes/failures of transmissions in the course of an execution. A station running an adaptive protocol can rely on a global clock, may add control bits to be piggybacked on messages, and may store the complete history of the feedback from the channel during an execution. It turns out that there is no adaptive broadcast protocol stable for the injection rate λ = 1 for the multiple-access channel with at least n ≥ 4 stations, even when collision detection is available. We show that a simple full-sensing protocol is universally stable, which means it can handle any constant injection rate λ ‹ 1 in a stable manner. A more involved full-sensing protocol is shown to be both universally stable and strongly-stable for injection rate ρ (n) ≤ 1over>d lg2 n, where d>0 is a sufficiently large constant and n is the number of stations. We show that there is an acknowledgement-based protocol that is strongly stable for injection rate ρ(n)≤ 1 d lg2 n, for a sufficiently large constant d0. Regarding the stability of acknowledgement-based protocols, we show that no such a protocol is stable for injection rate ρ(n)> 2 1+lg n. This implies that there are no universally stable acknowledgement-based protocols. We show that when collision detection is available, then a simple full-sensing protocol is both universally stable and strongly stable for injection rate ρ(n)≤ 1 2 lgn. As a complementary fact, we prove that no adaptive protocol for a channel with collision detection can be strongly stable for the injection rate that satisfies ρ (n) = ω (1 log n). This shows that the protocol we give is optimal with respect to injection rates it handles in a strongly stable manner.

The Write-All problem for an asynchronous shared-memory system has the objective for the processes to update the contents of a set of shared registers, while minimizing the total number of read and write operations. First abstracted by Kanellakis and Shvartsman [12], Write-All is among the standard problems in distributed computing. The model consists of $n$ asynchronous processes and n registers, where every process can read and write to any register. Processes may fail by crashing. The most efficient previously known deterministic algorithm performs O(n1+ε) reads and writes, for an arbitrary fixed constant ε>0, and is due to Anderson and Woll [4]. This paper presents a new deterministic algorithm that performs O(n polylog n) read/write operations, thus improving the best previously known upper bound from polynomial to polylogarithmic in the average number of read/write operations per process. Using an approach to store and retrieve information about progress made in auxiliary registers, the novelty of the new algorithm is in using a family of multi-partite graphs with expansion properties to structure a set of registers as a graph and then have each asynchronous process explore a part of the graph according to its pattern of traversals. An explicit instantiation of our Write-All algorithm, based on best-known polynomial-time constructions of lossless expanders and a-expanding graphs, performs n • 2O(log3 log n) reads and writes. In this explicit solution to Write-All, the processes perform asymptotically less read/write operations than the most efficient non-explicit solution known before.

We present an improved algorithm to wake up a multi-hop ad-hoc radio network. The goal is to have all the nodes activated, when some of them may wake up spontaneously at arbitrary times and the remaining nodes need to be awoken by the already active ones. The best previously known wakeup algorithm was given by Chrobak, Gasieniec and Kowalski [11], and operated in time log n), where n is the number of nodes. We give an algorithm with the running time log n). This also yields better algorithms for other synchronization-type primitives, like leader election and localclocks synchronization, each with a time performance that di#ers from that of wake-up by an extra factor of O(log n) only, and improves the best previously known method for the problem by a factor of n . A wake-up algorithm is a schedule of transmissions for each node. It can be represented as a collection of binary sequences. Useful properties of such collections have been abstracted to define a (radio) synchronizer. It has been known that good radio synchronizers exist and previous algorithms [17, 11] relied on this. We show how to construct such synchronizers in polynomial time, from suitable constructible expanders. As an application, we obtain a wake-up protocol for a multiple-access channel that activates the network in time polylog n), where k is the number of stations that wake up spontaneously, and which can be found in time polynomial in n. We extend the notion of synchronizers to universal synchronizers. We show that there exist universal synchronizers with parameters that guarantee time log n) of wake-up.

The Collect problem for an asynchronous shared-memory system has the objective for the processors to learn all values of a collection of shared registers, while minimizing the total number of read and write operations. First abstracted by Saks, Shavit, and Woll [37], Collect is among the standard problems in distributed computing, The model consists of $n$ asynchronous processes, each with a single-writer multi-reader register of a polynomial capacity. The best previously known deterministic solution performs O(n3/2log n) reads and writes, and it is due to Ajtai, Aspnes, Dwork, and Waarts [3]. This paper presents a new deterministic algorithm that performs O(n log7 n) read/write operations, thus substantially improving the best previous upper bound. Using an approach based on epidemic rumor-spreading, the novelty of the new algorithm is in using a family of expander graphs and ensuring that each of the successive groups of processes collect and propagate sufficiently many rumors to the next group. The algorithm is adapted to the Repeatable Collect problem, which is an on-line version. The competitive latency of the new algorithm is O(log7 n) vs. the much higher competitive latency O(√nlog n) given in [3]. A result of independent interest in this paper abstracts a gossiping game that is played on a graph and that gives its payoff in terms of expansion.

We consider the problem of gossiping when dynamic node crashes are controlled by adaptive adversaries. We develop gossiping algorithms which are efficient with respect to both the time and communication measured as the number of point-to-point messages. If the adversary is allowed to fail up to $t$ nodes, among the total of $n$, where additionally $n-t=\Omega(n/\textpolylog n)$, then one among our algorithms completes gossiping in time $\cO(\log^2 t)$ and with $\cO(n\text polylog t)$ messages. We prove a lower bound which states that the time has to be at least $\Omega\Big(\frac\log n\log(n\log n)-\log t\Big)$ if the communication is restricted to be $\cO(n\text polylog n)$.We also show that one can solve efficiently a more demanding consensus problem with crash failures by resorting to one of our gossiping algorithms. If the adversary is allowed to fail $t$ nodes, where $n-t=\Omega(n/\textpolylog n)$, we obtain a time-optimal solution that is away from the communication optimality by at most a polylogarithmic factor.

The problem of performing t tasks in a distributed system on p failure-prone processors is one of the fundamental problems in distributed computing. If the tasks are similar and independent and the processors communicate by sending messages then the problem is called Do-All. In our work the communication is over a multiple-access channel, and the attached stations may fail by crashing. The measure of performance is work, defined as the number of the available processor steps. Algorithms are required to be reliable in that they perform all the tasks as long as at least one station remains operational. We show that each reliable algorithm always needs to perform at least the minimum amount Ω(t + p√t) of work. We develop an optimal deterministic algorithm for the channel with collision detection performing only the minimum work Θ(t + p√t). Another algorithm is given for the channel without collision detection, it performs work O(t + p√t + p · min {f, t}), where f < p is the number of failures. It is proved to be optimal if the number of faults is the only restriction on the adversary. Finally we consider the question if randomization helps for the channel without collision detection against weaker adversaries. We develop a randomized algorithm which needs to perform only the expected minimum work if the adversary may fail a constant fraction of stations, but it has to select the failure-prone stations prior to the start of an algorithm.

The problem of performing t tasks on n asynchronous or undependable processors is a basic problem in parallel and distributed computing. We consider an abstraction of this problem called the Write-All problem— using n processors write 1's into all locations of an array of size t. The most efficient known deterministic asynchronous algorithms for this problem are due to Anderson and Woll. The first class of algorithms has work complexity of Ο(t . n ε), for n ≰ ty and any ε > 0, and they are the best known for the full range of processors (n = t). To schedule the work of the processors, the algorithms use sets of q permutations on [q] (q ≰ n) that have certain combinatorial properties. Instantiating such an algorithm for a specific ε either requires substantial pre-processing (exponential in 1/ε2) to find the requisite permutations, or imposes a prohibitive constant (exponential in 1/ε3) hidden by the asymptotic analysis. The second class deals with the specific case of t = nu, u ≰ 2, and these algorithms have work complexity of Ο(t log t). They also use sets of permutations with the same combinatorial properties. However instantiating these algorithms requires exponential in n preprocessing to find the permutations. To alleviate this costly instantiation Kanellakis and Shvartsman proposed a simple way of computing the permutation schedules. They conjectured that their construction has the desired properties but they provided no analysis.

There is given a graph, that models a communication network of a multiprocessor system, and there are tokens (jobs) allocated to nodes of the graph. The task is to distribute the tokens evenly, subject to the constraint that they may be moved only along the edges of the graph. The cost of a distribution strategy is measured as the total number of operations of moving a token along an edge. An algorithm for general graphs is developed, by reduction to a maximum-flow minimum-cost problem, that finds a cost-optimal distribution strategy, given a graph and an initial token allocation. The main result is an algorithm for graphs that are lines of nodes; it finds the distribution strategy in time O(n), for a line of n nodes.

A mesh-connected processor array is considered in which the links are faulty in the following sense: Each attempt by two neighboring processors to communicate by exchanging messages may fail with some constant probability. A message sent across a link and not delivered is said to be delayed by the link. It is assumed that all the links delay with the same fixed delay probability, independently of each other. The problem of sorting is addressed in this model. It is proved that an $n \times n$ mesh can be sorted in the expected time $O( n )$ with large probability. More precisely, it is shown that there are two constants $c > 0$ and $r > 1$, depending on the delay probability, such that the $n \times n$ mesh is sorted in time $cn + t$ with the probability at least $1 - r^{ - t} $. One specific algorithm is considered, but the analysis shows that many known algorithms could sort in the expected time $O( n )$, after some natural modifications.