Some lower bound results for decentralized extrema-finding in rings of processors

AbstractWe consider the problem of finding the largest of a set of n uniquely numbered processors, arranged in a ring, by means of an asynchronous distributed algorithm without a central controller. Processors are identical, except for their unique number (identity). Using a technique of Frederickson and Lynch we show that arbitrary algorithms that solve this problem on rings where processors know the ring size cannot have a better worst-case number of messages than algorithms that use only comparisons between identities. We show a similar type of result for rings, where the ring size is not known. We use these results to answer a question, posed by Korach, Rotem, and Santoro in 1981 whether each extrema-finding algorithm that uses time n on a ring of n processors must use a quadratic number of messages; and to show a lower bound of 0.683 n log(n) on the worst-case number of messages for unidirectional rings with known ring size n. Also, we give a lower bound of 12n log(n) on the average number of messages for algorithms that use only comparisons on rings with known ring size n

Leader Election in Anonymous Rings: Franklin Goes Probabilistic

We present a probabilistic leader election algorithm for anonymous, bidirectional, asynchronous rings. It is based on an algorithm from Franklin, augmented with random identity selection, hop counters to detect identity clashes, and round numbers modulo 2. As a result, the algorithm is finite-state, so that various model checking techniques can be employed to verify its correctness, that is, eventually a unique leader is elected with probability one. We also sketch a formal correctness proof of the algorithm for rings with arbitrary size

Synchronization Algorithms for Multi-cores and Multiprocessors

A distributed system is a group of processors that do not allocate memory. As an alternative, each processor has its own local memory, and the processors communicate with one another through communication lines such as local-area or wide-area networks. The processors in a distributed system vary in size and function. Such systems may include small handheld or real-time devices, personal computers, workstations, and large mainframe computer systems. Distributed systems, will have their own set of unique challenges, including synchronizing data and creating sense of conflicts. Effective synchronization algorithms performance depends on runtime factors that are rigid to predict. The designers have protocols to employ the synchronization operation and waiting mechanisms to wait for synchronization delays. In this paper an effort is made to investigate synchronization algorithm that vigorously select waiting mechanisms and protocols in response to runtime factors so as to attain enhanced performance. DOI: 10.17762/ijritcc2321-8169.150615

Leader election in synchronous networks

Worst, best and average number of messages and running time of leader election algorithms of different distributed systems are analyzed. Among others the known characterizations of the expected number of messages for LCR algorithm and of the worst number of messages of Hirschberg-Sinclair algorithm are improve

Average Case Behavior of Distributed Extrema-Finding Algorithms

Coordinated Science Laboratory was formerly known as Control Systems LaboratoryNational Science Foundation / MCS-8217445Eastman Kodak Compan

Agents for Integrating Distributed Data for Function Computations

Many practical problems occur when we wish to manipulate the data in a way that requires information not included explicitly in this data, and where we have to deal with functions of such a nature. In a networked environment, the data may reside in components on a number of geographically distributed sites. These databases cannot be moved to other network sites due to security, size, and privacy consideration. In this paper, we present two self-decomposing algorithms for constructing a function from given discrete data, and finding the extrema of any function whose arguments are stored across a number of distributed databases