Showing papers on "Distributed algorithm published in 1992"

Locality in distributed graph algorithms

Abstract: This paper concerns a number of algorithmic problems on graphs and how they may be solved in a distributed fashion. The computational model is such that each node of the graph is occupied by a processor which has its own ID. Processors are restricted to collecting data from others which are at a distance at most t away from them in t time units, but are otherwise computationally unbounded. This model focuses on the issue of locality in distributed processing, namely, to what extent a global solution to a computational problem can be obtained from locally available data.Three results are proved within this model: • A 3-coloring of an n-cycle requires time $\Omega (\log ^ * n)$. This bound is tight, by previous work of Cole and Vishkin. • Any algorithm for coloring the d-regular tree of radius r which runs for time at most $2r/3$ requires at least $\Omega (\sqrt d )$ colors. • In an n-vertex graph of largest degree $\Delta $, an $O(\Delta ^2 )$-coloring may be found in time $O(\log ^ * n)$.

Load distributing for locally distributed systems

Abstract: The problem of judiciously and transparently redistributing the load of the system among its nodes so that overall performance is maximized is discussed. Several key issues in load distributing for general-purpose systems, including the motivations and design trade-offs for load-distributing algorithms, are reviewed. In addition, several load-distributing algorithms are described and their performances are compared. These algorithms are sender-initiated algorithms, receiver-initiated algorithms, symmetrically initiated algorithms, and adaptive algorithms. Load-distributing policies used in existing systems are examined, and conclusions about which algorithm might help in realizing the most benefits of load distributing are drawn. >

Distributed object management

Abstract: Future information processing environments will consist of a vast network of heterogeneous, autonomous, and distributed computing resources, including computers (from mainframe to personal), information-intensive applications, and data (files and databases) A key challenge in this environment is providing capabilities for combining this varied collection of resources into an integrated distributed system, allowing resources to be flexibly combined, and their activities coordinated, to address challenging new information processing requirements In this paper, we describe the concept of distributed object management, and identify its role in the development of these open, interoperable systems We identify the key aspects of system architectures supporting distributed object management, and describe specific elements of a distributed object management system being developed at GTE Laboratories

Improved distributed algorithms for coloring and network decomposition problems

Abstract: This paper deals with the problems of computing a maximal independent set and a vertex coloring in a dktributed model of computation. Given a connected graph G = (V, E) with IVI = n and maximum degree A such that G is neither a complete graph nor an odd cycle, Brooks’ theorem shows that G can be colored with A colors. We generalize thk as follows: let G – w be A-colored; then, v can be colored by considering the vertices in an O(loga n) radius around v, and this is tight. Using this, we show that A-coloring G is reducible in 0(log3 n/log A) time to (A+ I)-vertex coloring G in a distributed model. This leads to fast distributed algorithms, and a linear–processor NC algorithm, for Acoloring. We also prove a tight Q(diameter(G)) lower bound for A-edge-coloring bipartite graphs, even with unlimited randomness. When A = 2, this implies an Q(n) lower bound for vertex coloring paths and even cycles. A fundamental notion in distributed graph algorithms is that of a cluster decomposition, introduced by Awerbuch, Goldberg, Luby and Plotkin. We improve the existing bounds by showing how to compute a cluster decomposition in O(n”(’(”)) ) time, where e(n) = 1/=. This implies improved bounds for several problems, such as computing a maximal independent set and a (A + I )-coloring. We also show how to compute a A–coloring within the same time bound, using our reduction technique. Next, we show that the problem of doing better than O(n”(’(m))) time for cluster decomposition is self-reducible to graphs of “intermediate” diameter and degree. This pinpoints the weak points of existing cluster decomposition algorithms. *This research was supported in part by NSF PYI award CGR89-96272 with matching support from UPS and Sun Microsystems. Permission to copy without fee ell or part of this material is granted provided that the copiss are not made or distributed for direct commercial advantage, the ACM copyright notica and tha title of the publication and its date appear, and notice ie given that copying is by permission of the Association for Computing Machinery. To copy otharwise, or to republish, requires a fee and/or specific permieaion. 24th ANNUAL ACM STOC 5/92/VICTORIA, B. C., CANADA a 1992 ACM 0-89791-51 2-7192 /000410!581 . ..$1.50

Communication on noisy channels: a coding theorem for computation

Abstract: Communication is critical to distributed computing, parallel computing, or any situation in which automata interact-hence its significance as a resource in computation. In view of the likelihood of errors occurring in a lengthy interaction, it is desirable to incorporate this possibility in the model of communication. The author relates the noisy channel and the standard (noise less channel) complexities of a communication problem by establishing a 'two-way' or interactive analogue of Shanon's coding theorem: every noiseless channel protocol can be simulated by a private-coin noisy channel protocol whose time bound is proportional to the original (noiseless) time bound and inversely proportional to the capacity of the channel, while the protocol errs with vanishing probability. The method involves simulating the original protocol while implementing a hierarchical system of progress checks which ensure that errors of any magnitude in the simulation are, with high probability, rapidly eliminated. >

Distributed algorithms for dynamic replication of data

Abstract: We present two distributed algorithms for dynamic replication of a data-item in communication networks. The algorithms are adaptive in the sense that they change the replication scheme of the item (i.e. the set of processors at which the data-item is replicated), as the read-write pattern of the processors in the network changes. Each algorithm continuously moves the replication scheme towards an optimal one, where optimality is defined with respect to different objective functions. One algorithm optimizes the communication cost objective function, and the other optimizes the communication time. We also provide a lower bound on the performance of any dynamic replication algorithm.

A Cartesian parallel nested dissection algorithm

Abstract: This paper is concerned with the distributed parallel computation of an ordering for a symmetric positive definite sparse matrix. The purpose of the ordering is to limit fill and enhance concurrency in the subsequent Cholesky factorization of the matrix. A geometric approach to nested dissection is used based on a given Cartesian embedding of the graph of the matrix in Euclidean space. The resulting algorithm can be implemented efficiently on massively parallel, distributed memory computers. One unusual feature of the distributed algorithm is that its effectiveness does not depend on data locality, which is critical in this context, since an appropriate partitioning of the problem is not known until after the ordering has been determined. The ordering algorithm is the first component in a suite of scalable parallel algorithms currently under development for solving large sparse linear systems on massively parallel computers.

Multiway Synchrinizaton Verified with Coupled Simulation

Abstract: We consider the problem of implementing multiway synchronization in a distributed environment providing only binary asynchronous communication. Our implementation strategy is formulated as a transformation on transition systems and we give a distributed algorithm for multiway synchronization. Correctness assertions and proofs are based on a new method: coupled simulations. The coupled simulation equivalence is weaker than observation equivalence and stronger than testing equivalence and combines some of their advantages. Like observation equivalence (and unlike testing) it is established through case analysis over single transitions. Like testing equivalence (and unlike observation) it allows an internal choice to be distributed onto several internal choices. The latter is particularly important when relating our distributed implementations to their specifications.

A dynamic information-structure mutual exclusion algorithm for distributed systems

Abstract: A dynamic information-structure mutual exclusion algorithm is presented for distributed systems whose information-structure evolves with time as sites learn about the state of the system through messages An interesting feature of the algorithm is that it adapts itself to heterogeneous or fluctuating traffic conditions to optimize the performance (the number of messages exchanged) The performance of the algorithm is studied by simulation technique and compared to the performance of a well-known mutual exclusion algorithm The impact message loss and site failures on the algorithm is discussed and methods to tolerate these failures are proposed >

Competitive algorithms for distributed data management (extended abstract)

Abstract: We deal with the competitive analysis of algorithms for managing data in a distributed environment. We deal with the file allocation problem ([C], [DF], [ML]), where copies of a file may be stored in the local storage of some subset of processors, copies may be replicated and discarded over time so as to optimize communication costs, but multiple copies must be kept consistent and at least one copy must be stored somewhere in the network at all times. We deal with competitive algorithms for minimizing communication costs, over arbitrary sequences of reads and writes, and arbitrary network topologies. We define the constrained file allocation problem to be the solution of many individual file allocation problems simultaneously, subject to the constraints of local memory size. We give competitive algorithms for this prblem on uniform networks. We then introduce distributed competitive algorithms for on-line data tracking (a generalization of mobile user tracking [AP1, AP3] to transform our competitive distributed data management algorithms into distributed algorithms themselves.

An Effective Spanning Tree Algorithm for a Bridged LAN

Abstract: 1 Network (BLAN) is an internetare interconnected by bridges. topology of a BLAN is to enpath is existed between we propose a new

Efficient task migration algorithm for distributed systems

Abstract: The objective of the study was to achieve balanced load among processors, reduce the communication overhead of the load balancing algorithm, and improve respource utilization, which results in better average resonse time. A communication protocol and a fully distributed algorithm for dynamic load balancing through task migration in a connected N-processor network are presented. Each processor communicates its load directly with only a subset (of the size square root N) of processors, reducing communication traffic and average response time. It is proved that the given algorithm will perform task migration even if there is only one light load processor and one heavy load processor in the system. Simulation results show that the proposed scheme can save up to 60% of the protocol messages used by the broadcast algorithms and can reduce the average response time. >

Distributed Slicing and Partial Re-execution for Distributed Programs

Abstract: We present a parallel algorithm to compute dynamic slices for distributed programs. Dynamic slices are used in debugging to re-execute only those statements of the original program that actually influenced an observed erroneous result. We introduce the notion of a Distributed Dependence Graph (DDG) as the graphical representation of the relevant dependencies among statements that arise during execution of a distributed program. Based on the DDG, we developed a parallel and fully distributed slicing algorithm, where each process determines its local section of the global slice. The potential for non-determinism in distributed programs is addressed by constructing a slice such that non-deterministic selections that were made during execution of the original program are reproduced when re-executing the program slice.

Load balancing for distributed branch & bound algorithms

Abstract: The authors present a new load balancing strategy and its application to distributed branch & bound algorithms and demonstrate its efficiency by solving some NP-complete problems on a network of up to 256 transputers. The parallelization of their branch & bound algorithm is fully distributed. Every processor performs the same algorithm but each on a different part of the solution tree. In this case it is necessary to distribute subproblems among the processors to achieve a well balanced workload. Their load balancing method overcomes the problem of search overhead and idle times by an appropriate load model and avoids trashing effects by a feedback control method. Using this strategy they were able to achieve a speedup of up to 237.32 on a 256 processor network for very short parallel computation times, compared to an efficient sequential algorithm. >

Global snapshots for distributed debugging

Abstract: The widespread adoption of distributed computing has accentuated the need for an effective set of support tools to facilitate debugging and monitoring. In providing such support, one fundamental problem is that of constructing a global snapshot or global state of a distributed computation. This paper examines global snapshot algorithms from a distributed debugging perspective, and proposes an abstract framework based on global snapshots, which is defined to form a consistent state of the entire system. It is shown that by using a property preserving algorithm, this framework can be superimposed on the underlying computation, but not interfere with it. >

A fault-tolerant algorithm for replicated data management

Abstract: The problem of managing replicated copies of data in a distributed database is considered. Quorum consensus methods for managing replicated data require that an operation proceed only if a group of copies form a quorum. For example, in a majority voting scheme, for a write operation to proceed, a majority of the copies have to form a quorum. The authors first introduce a performance measure for measuring the performance of fault-tolerant algorithms for this problem. They then propose a quorum-based method which is highly fault tolerant and has a low message overhead. The algorithm can tradeoff fault tolerance for lower message overhead. The algorithm is compared to existing algorithms. >

Distributed algorithms for dynamic channel allocation in microcellular systems

Abstract: The capacity of a microcellular system using dynamic channel allocation was studied. It was found that these systems can self-organize, with little loss in capacity, by using channel-allocation algorithms that are simple, practical, and local. The performances of both deterministic and probabilistic algorithms were calculated. Two classes of isotropic algorithms look particularly promising: the timid class, which is the simplest, and the aggressive class, which could provide improvements in system capacity and blocking probability. In particular, at the expense of additional rearrangements per call, these local algorithms can approach the capacity achieved by a global channel-allocation strategy. >

A fast distributed shortest path algorithm for a class of hierarchically clustered data networks

Abstract: A distributed algorithm is presented that can be used to solve the single-destination shortest path (SDSP) problem or the all-pairs shortest path (APSP) problem for a class of clustered data networks. The network graph is assumed to be characterized with a balanced hierarchically clustered (BHC) topology. The BHC topology is introduced in this paper and is shown to be a realistic characterization for a large class of interconnected data networks. For certain types of BHC topologies, the SDSP problem can be solved with computation and communication time complexities of O(log n), assuming one processor is available at each of the n number of nodes. Assuming p processors are available at each node, computation and communication time complexities of O((n/p) log n) and O(n log n) are achievable, respectively, for solving the APSP problem. It is also shown that the algorithm converges in an asynchronous environment. >

Coterie join algorithm

Abstract: Given a set of nodes in a distributed system, a coterie is a collection of subsets of the set of nodes such that any two subsets have a nonempty intersection and are not properly contained in one another. A subset of nodes in a coterie is called a quorum. An algorithm, called the join algorithm, which takes nonempty coteries as input, and returns a new, larger coterie called a composite coterie is introduced. It is proved that a composite coterie is nondominated if and only if the input coteries are nondominated. Using the algorithm, dominated or nondominated coteries may be easily constructed for a large number of nodes. An efficient method for determining whether a given set of nodes contains a quorum of a composite coterie is presented. As an example, tree coteries are generalized using the join algorithm, and it is proved that tree coteries are nondominated. It is shown that the join algorithm may be used to generate read and write quorums which may be used by a replica control protocol. >

Call blocking performance of distributed algorithms for dynamic channel allocation in microcells

Abstract: The authors determine the blocking performance of channel allocation algorithms where every channel is available for use in every cell and where decisions are made by mobiles based only on local observations. Using a novel Erlang-B approximation method, together with simulation, they demonstrate that even the simplest algorithm, the timid, compares favorably with impractical, centrally administered fixed channel allocation. The results suggest that an aggressive algorithm, that is, one requiring call reconfigurations, could provide substantially reduced blocking. Practical algorithms are presented that take major steps toward achieving the excellent performance of the best aggressive algorithm but that have the stability of the timid algorithm. >

Distributed diagnosis algorithms for regular interconnected structures

Abstract: A distributed diagnosis algorithm to locate faulty processing elements in large-scale regular interconnected structures based on the concepts of system-level diagnosis is developed. This algorithm can either operate in a systolic manner or may be executed on a supervisory processor to locate the faulty processors. The computational complexity of the algorithm is linear when run on a supervisory processor and constant when run in parallel systolic manner. The implementation complexity and diagnosis capability of the algorithm are also analyzed without restricting the fault set size. The probability of correct diagnosis is shown to be very high even in the presence of large fault sets. >

A distributed data-balanced dictionary based on the B-link tree

Abstract: Many concurrent dictionary data structures have been proposed, but usually in the context of shared memory multiprocessors. The paper presents an algorithm for a concurrent distributed B-tree that can be implemented on message passing parallel computers. This distributed B-tree (the dB-tree) replicates the interior nodes in order to improve parallelism and reduce message passing. It is shown how the dB-tree algorithm can be used to build an efficient, highly parallel, data-balanced distributed dictionary, the dE-tree. >

Standards for message-passing in a distributed memory environment

Abstract: This report presents a summary of the main ideas presented at the First CRPC Work-shop on Standards for Message Passing in a Distributed Memory Environment, held April 29-30, 1992, in Williamsburg, Virginia. This workshop attracted 68 attendees including representative from major hardware and software vendors, and was the first in a series of workshops sponsored by the Center for Research on Parallel Computation. The aim of this series of workshops is to develop and implement a standard for message passing on distributed memory concurrent computers, thereby making it easier to develop efficient, portable application codes for such machines. The report discusses the main issues raised in the CRPC workshop, and describes proposed desirable features of a message passing standard for distributed memory environments.

In search of gigabit applications

Abstract: Applications in existing specialized, metacomputer environments and those yet to be developed for services such as telecommunications, distributed data, and image transfer that will require networks which can handle volumes of data on the order of gigabits per second are discussed. Specific examples are presented from the fields of computational science, data navigation, and collaborative environments and instrument control. It is concluded that distributed computing and collaborative environments that support the interaction of multiple computers, as well as the interaction of computers with humans, are the paradigms that will characterize gigabit applications. >

Architectural support for designing fault-tolerant open distributed systems

Abstract: An overview of the main techniques for designing fault-tolerant software and hardware systems is provided. The important features of the building blocks (computers, memories, buses, etc.) that can support an efficient implementation of fault-tolerant open distributed systems (FTODSs) are identified. Taking into account the features of these building blocks, an organization for FTODS is proposed. A distributed voting algorithm and a two-level hierarchy for permanent memory are key elements in this scheme. The algorithms needed for transferring files and synchronizing the concurrent activities of the computing modules and for recovery-are ISO standard protocols. Low-level voting and recovery algorithms that can run as a layer of software above the operating system make the open distributed system an attractive environment for applying fault-tolerant techniques. >

Distributed Game Tree Search on a Massively Parallel System

Abstract: We present our distributed αΒ-algorithm and show how αΒ- enhancements like iterative deepening, transposition tables, history tables etc. that are useful in the sequential game tree search can be applied to a distributed algorithm. The methods we describe are suitable even for large distributed systems. We describe an extension of the Young Brothers Wait Concept that we introduced to reduce the search overhead. For the first time experiments with bigger processor networks (up to 256 Transputers) show good results. We obtained a speedup of 126 running our algorithm with 256 processors.

Distributed file allocation with consistency constraints

Abstract: The resource allocation problem in distributed computing systems that have strict mutual consistency requirements is discussed. A model that incorporates the behavior of consistency control algorithms which ensure that mutual consistency of replicated data is preserved even when communication links of the computer network and/or computers on which the files reside fail is presented. The constrained resource allocation problem is formulated as a mixed nonlinear integer program. An efficient algorithm is proposed to solve this problem. The performance of the algorithm is evaluated in terms of its accuracy, efficiency and execution times, using a representative problem set. >