We describe the design principles of a ring network with spatial bandwidth reuse. Our goal is to provide the same functions of existing LAN/MAN designs that do not permit spatial reuse and concurrent transmission. A distributed fairness mechanism for this architecture, which uses low latency hard-ware control signals, is presented. The basic fairness mechanism can be extended for implementing multiple priority levels and integration of asynchronous with synchronous trafic. The ring is full-duplex and has two basic modes of operation: buffer insertion mode for variable size packets and slotted mode for fixed size packets or cells. As a result, this architecture is suitable for a wide range of applications and environments. Concurrent access and spatial reuse enable the simultaneous transmissions over disjoint segments of a bidirectional ring, and therefore, can increase the effective throughput, by a factor of four or more. The efficiency of this architecture does not degrade as the bandwidth and physical size of the system increases. The combination of a full-duplex ring, spatial reuse, reliable fairness mechanism and the exploitation of the recent advent in fiber-optic technology are the basis for the MetaRing network architecture. This network has been prototyped at the IBM T. J. Watson Research Center, and will also be deployed within

Given a ring of n processors it is required to design the processors such that they will be able to choose a leader (a uniquely designated processor) by sending messages along the ring. If the processors are indistinguishable then there exists no deterministic algorithm to solve the problem. To overcome this difficulty, probabilistic algorithms are proposed. The algorithms may run forever but they terminate within finite time on the average. For the synchronous case several algorithms are presented: The simplest requires, on the average, the transmission of no more than 2.442n bits and O (n) time. More sophisticated algorithms trade time for communication complexity. If the processors work asynchronously then on the average O (nlogn) bits are transmitted. In the above cases the size of the ring was assumed to be known to all the processors. If the size is not known then finding it may be done only with high probability: any algorithm may yield incorrect results (with nonzero probabilit...

In this paper we present algorithms, which given a circular arrangement of n uniquely numbered processes, determine the maximum number in a distributive manner. We begin with a simple unidirectional algorithm, in which the number of messages passed is bounded by 2n log n + 0(n). By making several improvements to the simple algorithm, we obtain a unidirectional algorithm in which the number of messages passed is bounded by 1.5n logn + 0(n). These algorithms disprove Hirschberg and Sinclair's'conjecture that 0(n²) is a lower bound on the number of messages passed in undirectional algorithms for this problem. At the end of the paper we indicate how our methods can be used to improve an algorithm due to Peterson, to obtain a unidirectional algorithm using at most 1.356n log n + 0(n) messages. This is the best bound so far on the number of messages passed in both the bidirectional and unidirectional cases.

In anonymous networks, the processors do not have identity numbers. We investigate the following representative problems on anonymous networks: (a) the leader election problem, (b) the edge election problem, (c) the spanning tree construction problem, and (d) the topology recognition problem. On a given network, the above problems may or may not be solvable, depending on the amount of information about the attributes of the network made available to the processors. Some possibilities are: (1) no network attribute information at all is available, (2) an upper bound on the number of processors in the network is available, (3) the exact number of processors in the network is available, and (4) the topology of the network is available. In terms of a new graph property called “symmetricity, ” in each of the four cases (1)–(4) above, we characterize the class of networks on which each of the four problems (a)–(d) is solvable. We then relate the symmetricity of a network to its 1- and 2-factors.

The problem of electing a leader in a synchronous ring of n processon is considered. Both positive and negative results are obtained. On the one hand, if processor IDs are chosen from some countable set, then there is an algorithm that uses only O(n) messages in the wont case. On the other hand, any algorithm that is restricted to use only comparisons of IDs requires fl(n log n) messages in the worst case. Alternatively, if the number of rounds is required to be bounded by some t in the wont case, and lDs are chosen from any set having at least f(n, t) elements, for a certain very fast-growing functionf then any algorithm requires fl(n log n) messages in the wont case.

We address the problem of the impossibility of implementing synchronous fault-tolerant service specifications in asynchronous distributed systems. We introduce a method for weakening a synchronous service specification so that it becomes implementable in "timed" asynchronous systems, that is, asynchronous systems in which processes have access to local hardware clocks. The method (1) adds to a service interface an exception indicator so that a client knows at any time if a server is currently providing its standard "synchronous" semantics or some other specified exceptional semantics, (2) the standard behavior provided when the exception indicator does not signal an exception is "similar" to the original synchronous service behavior, and (3) a server has to provide its standard semantics whenever the underlying communication and process services exhibit "synchronous behavior ". To illustrate our method, we show how the specification of a synchronous datagram service and an internal clock synchronization service can be transformed into a fail-aware service specification. Further illustrations of the usefulness of fail-aware services are provided by describing a railway crossing service and a fail-aware weak group membership service.

Abstract. The key design challenges in the construction of a SAT-based relational model finder are described, and novel techniques are proposed to address them. An efficient model finder must have a mechanism for specifying partial solutions, an effective symmetry detection and breaking scheme, and an economical translation from relational to boolean logic. These desiderata are addressed with three new techniques: a symmetry detection algorithm that works in the presence of partial solutions, a sparse-matrix representation of relations, and a compact representation of boolean formulas inspired by boolean expression diagrams and reduced boolean circuits. The presented techniques have been implemented and evaluated, with promising results. 1

The term shared dataspace refers to the general class of programming languages in which the principal means of communication among the concurrent components of programs is a common, content-addressable data structure called a dataspace. In the programming language and artificial intelligence communities, there is considerable interest in such languages, e.g., logic-based languages, production rule systems, and the Linda language. However, these languages have not been the subject of extensive program verification research. This paper specifies a proof system for a shared dataspace programming notation called Swarm---a programming logic similar in style to that of UNITY. The paper then uses the proof system to reason about a Swarm program to label the equal-intensity regions of a digital image.

The term shared dataspace refers to the general class of models and languages in which the principal means of communication is a common, content-addressable data structure called a dataspace. Swarm is a simple language we have used as a vehicle for the investigation of the shared dataspace approach to concurrent computation. It is the first shared dataspace language to have an associated assertional-style proof system. An important feature of Swarm is its ability to bring a variety of programming paradigms under a single, unified model. In a series of related examples we explore Swarm's capacity to express shared-variable, messagepassing, and rule-based computations; to specify synchronous and asynchronous processing modes; and to accommodate highly dynamic program and data structures. Several illustrations make use of a programming construct unique to Swarm, the synchrony relation, and explain how this feature can be used to construct dynamically structured, partially synchronous computations. The paper has three parts: an overview the Swarm programming notation, an examination of Swarm programming strategies via a series of related example programs, and a discussion of the distinctive features of the shared dataspace model. A formal operational model for Swarm is presented in an appendix.

We study a new problem, the wakeup problem, that seems to be fundamental in distributed computing. We present efficient solutions to the problem and show how these solutions can be used to solve the consensus problem, the leader election problem, and other related problems. The main question we try to answer is, how much memory is needed to solve the wakeup problem? We assume a model that captures important properties of real systems that have been largely ignored by previous work on cooperative problems.