Yehuda Afek

Applying static network protocols to dynamic networks

This paper addresses the problem of how to adapt an algorithm designed for fixed topology networks to produce the intended results, when run in a network whose topology changes dynamically, in spite of encountering topological changes during its execution. We present a simple and unified procedure, called a reset procedure, which, when combined with the static algorithm, achieves this adaptation. The communication and time complexities of the reset procedure, per topological change, are independent of the number of topological changes and are linearly bounded by the size of the subset of the network which participates in the algorithm.

Lazy caching

This paper examines cache consistency conditions for multiprocessor shared memory systems. It states and motivates a weaker condition than is normally implemented. An algorithm is presented that exploits the weaker condition to achieve greater concurrency. The algorithm is shown to satisfy the weak consistency condition. Other properties of the algorithm and possible extensions are discussed.

Wait-free made fast

An implementation of an asynchronous shared-data structure is wait-free if no adversarial scheduler can stop an individual operation on the data structure from making progress (that is the implementation can tolerate a fail-stop fault of any number of processes). An implementation is non-blocking if an adversarial scheduler cannot stop the system from making progress. Existing wait-free implementations of shared data structures are slow when contention (processor concurrency) is low, namely, they have an Cl(n) term in their time complexity, where n is the total number of processes, however their time complexity for each operation is bounded. On the other hand, non-blocking implementations are fast when contention is low, but do not provide bounds on the time complexity of indwidual operations when contention is high. Neither seems to be satisfactory in practice. Inspired by Lamport’s fast mutual exclusion algorithm [Lam87], we pose in this paper the question of implementing fast and wait-free data-structures. We then devise universal methods that combine the advantages of both non-blocking and waitfree approaches, i.e., fast when contention is low and guaranteed progress of any individual operation. The time complexity of the algorithms presented here is not a function of n, but a function of k the actual number of processes that access the object concurrently, Two such methods are presented here; The first method, which is called group update, replaces the O(n) term in the time complexity of wait-free implementations by an O(min(n, k log k)) term (or more precisely, O(k log k +s + kf), where s and ~ are the data structure size and single update complexity, respectively). The second method, which is called individual update, rePermission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyri ht notice and the % title of the publication and. KSdate appear,. an notice is given that copym IS by permwon of the Assoc!abon of Computing Machinery. o cop otherwse, or to repubhsh, requires y ‘/’ a fee ancf/or soecl ICoermisslon. STOC’ 95, L& Veg&, Nevada, USA @ 1995 ACM 0-89791 -718-9/95/0005..

Memory-Efficient Self Stabilizing Protocols for General Networks

3.50 places the O(n) term of wait-free implementations with an O(k) term (or O(k~log f)).

A biological solution to a fundamental distributed computing problem

A self stabilizing protocol for constructing a rooted spanning tree in an arbitrary asynchronous network of processors that communicate through shared memory is presented. The processors have unique identifiers but are otherwise identical. The network topology is assumed to be dynamic, that is, edges can join or leave the computation before it eventually stabilizes.

The local detection paradigm and its applications to self-stabilization

Modeling of development in the fruit fly yields an algorithm useful in designing wireless communication networks. Computational and biological systems are often distributed so that processors (cells) jointly solve a task, without any of them receiving all inputs or observing all outputs. Maximal independent set (MIS) selection is a fundamental distributed computing procedure that seeks to elect a set of local leaders in a network. A variant of this problem is solved during the development of the fly’s nervous system, when sensory organ precursor (SOP) cells are chosen. By studying SOP selection, we derived a fast algorithm for MIS selection that combines two attractive features. First, processors do not need to know their degree; second, it has an optimal message complexity while only using one-bit messages. Our findings suggest that simple and efficient algorithms can be developed on the basis of biologically derived insights.

Local Stabilizer

Abstract A new paradigm for the design of self-stabilizing distributed algorithms, called local detection , is introduced. The essence of the paradigm is in defining a local condition based on the state of a processor and its immediate neighborhood such that the system is in a globally legal state if and only if the local condition is satisfied at all the nodes. In this work we also extend the model of self-stabilizing networks traditionally assuming memory failure to include the model of dynamic networks (assuming edge failures and recoveries). We apply the paradigm to the extended model which we call “dynamic self-stabilizing networks”. Without loss of generality, we present the results in the least restrictive shared memory model of read/write atomicity, to which end we construct basic information transfer primitives. Using local detection, we develop deterministic and randomized self-stabilizing algorithms that maintain a rooted spanning tree in a general network whose topology changes dynamically. The deterministic algorithm assumes unique identities while the randomized assumes an anonymous network. The algorithms use a constant number of memory words per edge in each node; and both the size of memory words and of messages is the number of bits necessary to represent a node identity (typically O (log n ) bits where n is the size of the network). These algorithms provide for the easy construction of self-stabilizing protocols for numerous tasks: reset, routing, topology-update and self-stabilization transformers that automatically self-stabilize existing protocols for which local detection conditions can be defined.

Long-lived renaming made adaptive

A local stabilizer protocol that takes any on-line or of-line distributed algorithm and converts it into a synchronous self-stabilizing algorithm with local monitoring and repairing properties is presented. Whenever the self-stabilizing version enters an inconsistent state, the inconsistency is detected, in O(1) time, and the system state is repaired in a local manner. The expected computation time that is lost during the repair process is proportional to the largest diameter of a faulty region.

Self-stabilization over unreliable communication media

Two implementations of an adaptive, wait-free, and long-lived renaming task in the read/write shared memory model are presented. Implementations of longlived and adaptive objects were previously known only in the much stronger model of load-linked and storeconditional (i.e., read-modify-write) shared memory. In read/write shared-memory only one-shot adaptive objects are known. Presented here are two algorithms that assign a new unique id in the range 1, . . . , O(k’) to any process whose initial unique name is taken from a set of size N, for an arbitrary N and where k is the number of processors that actually take steps or hold a name while the new name is being acquired. The step complexity of acquiring a new name is respectively O(k2) and O(k2 log k), while the step complexity of releasing a name is 1. The main differences between the two algorithms are in the precise definition of adaptiveness, and in their space complexity. The first algorithm adapts to the interval contention of an operation while requiring a bounded amount of space. The second algorithm adapts to the point contention but requires an unbounded amount of space. The two algorithms use completely different techniques to achieve their goals.

Reliable communication over unreliable channels

SummaryA self-stabilizing system has the property that it will converge to a desirable state when started from any state. Most previous researchers assumed that processes in self-stabilizing systems may communicate through shared variables while those that studied meassage passing systems allowed messages with unbounded size. This paper discusses the development of self-stabilizing systems which communicate through message passing, and in which messages may be lost in transit. The systems presented all use fixed size message headers. First, a selfstabilizing version of theAlternating Bit Protocol, a fundamental communication protocol for transmitting data across an unreliable communication medium, is presented. Secondly, the alternating-bit protocol is used to construct a self-stabilizing token ring.