Showing papers on "Distributed algorithm published in 1984"

Distributed Asynchronous Deterministic and Stochastic Gradient Optimization Algorithms

Abstract: We present a model for asynchronous distributed computation and then proceed to analyze the convergence of natural asynchronous distributed versions of a large class of deterministic and stochastic gradient-like algorithms. We show that such algorithms retain the desirable convergence properties of their centralized counterparts, provided that the time between consecutive communications between processors plus communication delays are not too large.

Heuristic Algorithms for Task Assignment in Distributed Systems.

Abstract: Investigate the problem of static task assignment in distributed computing systems, i.e. given a set of k communicating tasks to be executed on a distributed system of n processors, to which processor should each task be assigned? The author proposes a family of heuristic algorithms for Stone's classic model of communicating tasks whose goal is the minimization of the total execution and communication costs incurred by an assignment. In addition, she augments this model to include interference costs which reflect the degree of incompatibility between two tasks. Whereas high communication costs serve as a force of attraction between tasks, causing them to be assigned to the same processor, interference costs serve as a force of repulsion between tasks, causing them to be distributed over many processors. The inclusion of interference costs in the model yields assignments with greater concurrency, thus overcoming the tendency of Stone's model to assign all tasks to one or a few processors. Simulation results show that the algorithms perform well and in particular, that the highly efficient Simple Greedy Algorithm performs almost as well as more complex heuristic algorithms. >

The Design and Simulation of a Mobile Radio Network with Distributed Control

Abstract: A new architecture for mobile radio networks, called the linked cluster architecture, is described, and methods for implementing this architecture using distributed control techniques are presented. We illustrate how fully distributed control methods can be combined with hierarchical control to create a network that is robust with respect to both node loss and connectivity changes. Two distributed algorithms are presented that deal with the formation and linkage of clusters and the activation of the network links. To study the performance of our network structuring algorithms, a simulation model was developed. The use of Simula to construct, software simulation tools is illustrated. Simulation results are shown for the example of a high frequency (HF) intratask force (ITF) communication network.

Fault-tolerant clock synchronization

Abstract: This paper gives two simple efficient distributed algorithms: one for keeping clocks in a network synchronized and one for allowing new processors to join the network with their clocks synchronized. The algorithms tolerate both link and node failures of any type. The algorithm for maintaining synchronization will work for arbitrary networks (rather than just completely connected networks) and tolerates any number of processor or communication link faults as long as the correct processors remain connected by fault-free paths. It thus represents an improvement over other clock synchronization algorithms such as [LM1,LM2,LL1]. Our algorithm for allowing new processors to join requires that more than half the processors be correct, a requirement which is provably necessary.

Multiple-access protocols and time-constrained communication

Abstract: During the past ten years, the field of multiple-access communication has developed into a major area of both practical and theoretical interest within the field of computer communications. The multiple-access problem arises from the necessity of sharing a single communication channel among a community of distributed users. The distributed algorithm used by the stations to share the channel is known as the multiple-access protocol. In this paper we examine the multiple-access problem and various approaches to its resolution.In this survey we first define the multiple-access problem and then present the underlying issues and difficulties in achieving multiple-access communication. A taxonomy for multiple-access protocols is then developed in order to characterize common approaches and to provide a framework within which these protocols can be compared and contrasted. Different proposed protocols are then described and discussed, and aspects of their performance are examined. The use of multiple-access protocols for "real- time" or "time-constrained" communication applications, such as voice transmission, is examined next. Issues in time-constrained communication are identified, and recent work in the design of time-constrained multiple-access protocols is surveyed.

Computation and communication in R*: a distributed database manager

Abstract: This article presents and discusses the computation and communication model used by R*, a prototype distributed database management system. An R* computation consists of a tree of processes connected by virtual circuit communication paths. The process management and communication protocols used by R* enable the system to provide reliable, distributed transactions while maintaining adequate levels of performance. Of particular interest is the use of processes in R* to retain user context from one transaction to another, in order to improve the system performance and recovery characteristics.

A Perspective on Distributed Computer Systems

Abstract: Distributed computer systems have been the subject of a vast amount of research. Many prototype distributed computer systems have been built at university, industrial, commercial, and government research laboratories, and production systems of all sizes and types have proliferated. It is impossible to survey all distributed computing system research. Instead, this paper identifies six fundamental distributed computer system research issues, points out open research problems in these areas, and describes how these six issues and solutions to problems associated with them transect the communications subnet, the distributed operating system, and the distributed database areas. It is intended that this perspective on distributed computer system research serve as a form of survey, but more importantly to illustrate and encourage a better integration and exchange of ideas from various subareas of distributed computer system research.

Tight lower and upper bounds for some distributed algorithms for a complete network of processors

Abstract: Distributed algorithms for complete asynchronous networks of processors (i.e., networks where each pair of processors is connected by a communication line) are discussed. The main result is O(nlogn) lower and upper bounds on the number of messages required by any algorithm in a given class of distributed algorithms for such networks. This class includes algorithms for problems like finding a leader or constructing a spanning tree (as far as we know, all known algorithms for those problems may require O(n2) messages when applied to complete networks). O(n2) bounds for other problems, like constructing a maximal matching or a Hamiltonian circuit are also given. In proving the lower bound we are counting the edges which carry messages during the executions of the algorithms (ignoring the actually number of messages carried by each edge). Interestingly, this number is shown to be of the same order of magnitude of the total number of messages needed by these algorithms. In the upper bounds, the length of any message is at most log2[4mlog2n] bits, where m is the maximum identity of a node in the network. One implication of our results is that finding a spanning tree in a complete network is easier than finding a minimum weight spanning tree in such a network, which may require O(n2) messages.

A Diagnosis Algorithm for Distributed Computing Systems with Dynamic Failure and Repair

Abstract: The problem of designing distributed fault-tolerant computing systems is considered. A model in which the network nodes are assumed to possess the ability to "test" certain other network facilities for the presence of failures is employed. Using this model, a distributed algorithm is presented which allows all the network nodes to correctly reach independent diagnoses of the condition (faulty or fault-free) of all the network nodes and internode communication facilities, provided the total number of failures oes not exceed a given bound. The proposed algorithm allows for the reentry of repaired or replaced faulty facilities back into the network, and it also has provisions for adding new nodes to the system. Sufficient conditions are obtained for designing a distributed fault-tolerant system by employing the given algorithm. The algorithm has the interesting property that it lets as many as all of the nodes and internode communication facilities fail, but upon repair or replacement of faulty facilities, the system can converge to normal operation if no more than a certain number of facilities remain faulty.

A distributed algorithm for deadlock detection and resolution

Abstract: This paper presents two distributed algorithms for detecting and resolving deadlocks. By insuring that only one of the deadlock processes will detect it, the problem of resolving the deadlock is simplified. That process could simply abort itself. In one version of the algorithm, an arbitrary process detects deadlock; and in a second version, the process with the lowest priority detects deadlock.

A distributed algorithm for generalized deadlock detection

Abstract: An efficient distributed algorithm to detect deadlocks in distributed and dynamically changing systems is presented. In our model, processes can request any N available resources from a pool of size M. This is a generalization of the well-known AND-OR request model. The algorithm is incrementally derived and proven correct. Its communication, computational, and space complexity compares favorably with those of previously known distributed AND-OR deadlock detection algorithms.

Maintaining the time in a distributed system: an example of a loosely-coupled distributed service (synchronization, fault-tolerance, debugging)

Abstract: • investigate whether the improved algorithm is generally optimal • extend simulation framework: varying drifts, node mobility, and communication patterns • adapt simulation framework to internal synchronization • show worst-case optimality of simple algorithm for internal synchronization and find generally optimal algorithm • implement and compare the algorithms on the BTnode platform Simulation

Analysis of speedup in distributed algorithms

Abstract: We present and analyze several practical parallel algorithms for multicomputers. Chapter four presents two distributed algorithms for implementing alpha-beta search on a tree of processors. Each processor is an independent computer with its own memory and is connected by communication lines to each of its nearest neighbors. Measurements of the first algorithm's performance on the Arachne distributed operating system are presented. For each algorithm, a theoretical model is developed that predicts speedup with arbitrarily many processors. Chapter five shows how locally-defined iterative methods give rise to natural multicomputer algorithms. We consider two interconnection topologies, the grid and the tree. Each processor (or terminal processor in the case of a tree multicomputer) engages in serial computation on its region and communicates border values to its neighbors when those values become available. As a focus for our investigation we consider the numerical solution of elliptic partial differential equations. We concentrate on the Dirichlet problem for Laplace's equation on a square region, but our results can be generalized to situations involving arbitrarily shaped domains (of any number of dimensions) and elliptic equations with variable coefficients. Our analysis derives the running time of the grid and the tree algorithms with respect to per-message overhead, per-point communication time, and per-point computation time. The overall result is that the larger the problem, the closer the algorithms approach optimal speedup. We also show how to apply the tree algorithms to non-uniform regions. A large-network algorithm solves a problem of size N on a network of N processors. Chapter six presents a general method for transforming large-network algorithms into quotient-network algorithms, which solve problems of size N on networks with fewer processors. This transformation allows algorithms to be designed assuming any number of processing elements. The implementation of such algorithms on a quotient network results in no loss of efficiency, and often a great savings in hardware cost.

Asynchronous distributed flow control algorithms

Abstract: : This document considers algorithms for flow control in computer networks with fixed routing. The goal is to establish input rates, for each source-destination pair, that satisfy a particular fairness criterion. Described are several algorithms in which the input rates are calculated based on controls established by the links of the network. These controls are updated iteratively, using feedback information from the network. It is shown that the rates thus calculated converge to the desired values when the links are assumed to update synchronously, and without feedback delay. A model for asynchronous operation with delay is given, and we demonstrate for this model that the input rates calculated by the synchronous algorithms may fail to converge. We show how to modify the algorithms, by the introduction of an update protocol and by using more of the available feedback information, so that convergence of the rates is guaranteed. The author extends the model for asynchronous computation developed by Bertsekas to get some results relating to general asynchronous distributed algorithms with update protocols. These results are used to give an alternate proof of the correct operation of one of the flow control algorithms. A computer program is developed to simulate the flow control algorithms for a voice packet network. The simulation results indicate that the algorithms behave as expected for a network with static loads. However, when input loads change in imitation of real conversations, the control algorithms do not adapt fast enough to control the flows effectively. (Author)

Information Transfer in Distributed Computing with Applications to VLSI

Abstract: Simple general lower bound techniques are developed for measuring the amount of interprocessor commumcatlon required in distributed computing. Optimal bounds are shown for many problems, such as integer multiplication, integer division, matrix squaring, matrix inversion, solving a linear system of equations, and computing square roots. Using these techniques, one can unify and strengthen the area-time trade-off results known in the literature. Many new trade-off results are also shown in several of the existing models Categories and SubJect Descriptors: B.7. l [Integrated Circuits]: Types and Design Styles--VLSI (verylarge-scale mtegratton); F.2.3 [Analysis of Algorithms and Problem Complexity]\" Trade-offs among Complexity Measures General Terms. Algorithms, Theory Additional

Computational Methods for Optimizing Distributed Systems

Abstract: Inevitably, reading is one of the requirements to be undergone. To improve the performance and quality, someone needs to have something new every day. It will suggest you to have more inspirations, then. However, the needs of inspirations will make you searching for some sources. Even from the other people experience, internet, and many books. Books and internet are the recommended media to help you improving your quality and performance.

Object management in distributed information systems

Abstract: A simple model for object sharing in distributed office information systems is described. The model provides a small set of operators for object definition, manipulation, and retrieval in a distributed environment, modeled as a logical network of workstations. Relationships among objects can be established across work station boundaries, objects are relocatable within the distributed environment, and mechanisms are provided for access control and the dynamic sharing of objects among individual work stations. An object naming convention supports location-transparent object references; that is, objects can be referenced by user-defined names rather than by addresses. The primitive operations introduced can be used as the basis for the specification and stepwise development of office information models and systems of increasing complexity. An experimental prototype implementation of the distributed object sharing model is described.

Advanced Real-Time Languages for Distributed Industrial Process Control

Abstract: IHigher level programming languages for general scientific and technical applications have become increasingly sophisticated in program safety, production economics, and hardware independence. These languages, such as Algol 68, PL/1, and Pascal, are designed primarily to form computational tasks for sequential and off-line execution. Distributed industrial computer control systems impose new programming requirements, such as true parallelism; on-line, real-time task execution; intertask communication via an explicit communication system; and programmed support of fault tolerance. This article outlines the requirements of suitable programming languages for distributed industrial process control, starting with an investigation of the features of distributed systems. In the context of these features, a general concept of the required language elements is discussed, and an example of a modern real-time programming language, that fulfills some of these requirements is given as a basis for a higher level multicomputer real-time programming language. The application of this multicomputer language to a problem involving the control of a soaking pit furnace plant shows its contribution to distributed industrial process control.

Real-Time Synchronization of Interprocess Communications

Abstract: : This paper considers a fixed (possibly infinite) set of distributed asynchronous processes which at various times are willing to communicate with each other We describe probabilistic distributed algorithms for synchronizing processes so that they can handshake at will The means of synchronization are boolean flag variables, each of which can be written by only one process and read by at most one other process The use of flag variables seems as to require the fewest assumptions possible without considering specific systems A process is considered to be tame over a time interval delta if its speed varies within certain arbitrarily fixed nonzero bounds We show our synchronization algorithms have real time response: If a pair of processes are mutually willing to communicate within a time interval delta of length at least a given constant and the pair are tame on delta, then they establish communication within delta with high likelihood (for the worst case behavior of the system and the expected time for establishment of communication is also constant We feel the term real time is merited, for the actual time needed for establishment of communication is upper bounded by a constant with overwhelming probability; furthermore, violations of this property occur with vanishingly low likelihood We have very few assumptions: (1) Tameness is required of a process only during the interval it is willing to communicate; and (2) the processes may be willing to communicate with a time varying set of processes which are only bounded in number

Concurrent Maintenance of Binary Search Trees

Abstract: The problem of providing efficient concurrent access for independent processes to a dynamic search structure is the topic of this paper. We develop concurrent algorithms for search, update, insert, and delete in a simple variation of binary search trees, called external trees. The algorithm for deletion, which is usually the most difficult operation, is relatively easy in this data structure. The advantages of the data structure and the algorithms are that they are simple, flexible, and efficient, so that they can be used as a part in the design of more complicated concurrent algorithms where maintaining a dynamic search structure is necessary. In order to increase the efficiency of the algorithms we introduce maintenance processes that independently reorganize the data structure and relieve the user processes of nonurgent operations. We also discuss questions of transactions in a dynamic environment and replicated copies of the data structure.

A Model to Solve Timing-Critical Application Problems in Distributed Computer Systems

Abstract: Today, real-time computer applicationis can require system processing speeds up to hundreds of MIPS. Concurrently, there is a need for short svstem response time, particularly w here timing-critical application (TCA) problenis are concerned. As a way of meeting these system demands, concurrent processing of data items in advanced distributed computer ssystems is rapidly gainiing favor. With the advent of I SI technology, the system designer cani nows feasibly interconnect nuimierous processors and memnorv modules in a network system.t Howesver, without the proper software tool, the incremental increase of network processors may degrade system tlhroughput and fail to pass the system response time requirenmenlt.-4 Why? Because thc unsophisticated software tool usually causes both an unbalanced use of processors ancd anI increase in interprocessor traffic. tJnbalanced proecssor rIisC occurs when many software tasks in one processor cause extra qucueing delay time for task executioin. Heavier interprocessor traffic arises when the highlv data-dependent software tasks locatcd on diffterent processors generate considerable CoImImunication saste upon data transfer. E ft icienqt Lt iliiat ion of dlistributed compurci systenms clemiiands the ollows in e:

Communication Mechanisms for Programming Distributed Systems

Abstract: LSI and VLSI advances have greatly decreased costs for such computer hardware as processors and memories. Now universities and industry are taking advantage of this low-cost technology to research the development of distributed computer systems composed of multiple (cooperating) computers as alternatives to systems based on single computers. However, this new technology brings with it its own communications and synchronization problems. To solve them, system designers must have access to appropriate , well-defined mechanisms for expressing forms of communication and synchronization. This article covers applications-level software-communication mechanisms that have appeared in other literature. It focuses on communication mechanisms explicitly designed for distributed programming, addressing particularly what the various communication mechanisms do, as opposed to how they are implemented, then illustrating-with specific distributed programming examples-how communication mechanisms influence the programming process. However , to begin any discussion of distributed computer systems , their characteristics must be defined. As Stankovic and Van Dam indicate, 3 we can define a distributed processing system as a collection of distributed processing components physically and logically interconnected , possessing a decentralized, system-wide resource 'A more general discussion of software communication mechanisms can be found in Stankovic's paper, which illustrates control flow and data flow comparison of effective communication through procedure calis and messages; 1 Andrew's survey of concepts and notations for concurrent programming provides a detailed discussion on primitives for concurrent programming ,2 which can be considered a superset of distributed programming. control, and executing application programs in a coordinated manner.t Coordination is established by communication and synchronization, which constitute virtual communication among the application processes assigned to the individual processing components. At the applications level, communication and synchronization are said to be virtual because there may or may not be a direct, physical communications channel between the processes. The actual message exchanges occur at a level more primitive than applications-level software. Since memory is not shared, interaction among the processes requires message passing. An interconnection network routes messages from a source process to a destination process, and all in-terprocess interactions map into some actual communication protocols at the network level. Figure 1 illustrates a tEnslow's widely accepted definition characterizes system distribution from three standpoints: hardware, control, and database decentralizaton. 4 Figure 1. A logical view of a distributed computing system's architecture including the distributed communications network, or DCN, and the distributed processing component, or DPC.

Distributed algorithms for ensuring fair interprocess communicatons

Abstract: Message passing is one of the primary methods of information exchange between communicating processes. Many programming languages (e.g., CSP, ADA) provide interprocess communication through a rendezvous in which a sender (receiver) process waits until the receiver (sender) is ready to receive (send) a message; thus there is no buffering of messages. Many of these languages also allow non-deterministic constructs by which a process may wait to communication with any of a set of other processes. In this paper we consider the problem of ensuring different fairness properties in such a system of processes. In a natural model we prove a simple lower bound on the time complexity to ensure weak fairness and present near optimal algorithms in special cases. We also give new efficient algorithms to ensure strong fairness.In this paper we introduce a formal model for processes and consider two different fairness properties: weak fairness and strong fairness. We investigate different distributed scheduling algorithms for ensuring the various fairness properties in a model where neighboring schedulers interact with each other using shared variables. We use the time complexity measure as defined in [Ly80].

Election and traversal in unidirectional networks

Abstract: This paper presents distributed algorithms for election and traversal in strongly connected unidirectional networks. A unidirectional network consists of nodes which are processors connected by unidirectional communication links. Initially, processors differ by their identifier but are otherwise similar. The election algorithm distinguishes a single processor from all other processors. The election algorithm requires O(log n) bits of memory in each processor and has communication complexity of O(n • m+n2log n) bits. In the traversal algorithm one node initiates a token which visits all the nodes of the network and returns to the initiator. The traversal algorithm is derived from the election algorithm. It achieves the same communication complexity and uses only O(1) bits of memory in each processor.

On the message complexity of distributed problems

Abstract: An important question in distributed computing is the analysis of the influence that the amount of topological information available at the processors has on the complexity of solution algorithms for a given problem. Only few results, typically expressed in terms of lower-bounds, are known to date. In this paper, we prove lower-bounds for two well-known distributed problems: extrema-finding and minimum-weight spanning-tree construction. To establish these results, we introduce the notion of reducibility and equivalence between the elements of a class of distributed problems. We also prove the worst-case optimality of two algorithms.