Showing papers on "Distributed algorithm published in 1991"

An efficient and fault-tolerant solution for distributed mutual exclusion

Abstract: In this paper, we present an efficient and fault-tolerant algorithm for generating quorums to solve the distributed mutual exclusion problem. The algorithm uses a logical tree organization of the network to generate tree quorums, which are logarithmic in the size of the network in the best case. Our approach is resilient to both site and communication failures, even when such failures lead to network partitioning. Furthermore, the algorithm exhibits a property of graceful degradation, i.e., it requires more messages only as the number of failures increase in the network. We describe how tree quorums can be used for various distributed applications for providing mutually exclusive access to a distributed resource, managing replicated objects, and atomically commiting a distributed transaction.

Delta Four: A Generic Architecture for Dependable Distributed Computing

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.

Replica control in distributed systems: as asynchronous approach

Abstract: An asynchronous approach is proposed for replica control in distributed systems. This approach applies an extension of serializability called epsilon-serializability (ES R), a correctness criterion which allows temporary and bounded inconsistency in replicas to be seen by queries. Moreover, users can reduce the degree of inconsistency to the desired amount. In the limit, users see strict l-copy serializability. Because the system maintains ESR correctness (1) replicas always converges to global serializability and (2) the system permits read access to object replicas before the system reaches a quiescent state. Various replica control methods that maintain ESR are described and analyzed. Because these methods do not require users to refer explicitly to ESR criteria, they can be easily encapsulated in high-level applications that use replicated data.

Paradigms for process interaction in distributed programs

Abstract: Distributed computations are concurrent programs in which processes communicate by message passing. Such programs typically execute on network architectures such as networks of workstations or distributed memory parallel machines (i.e., multicomputers such as hypercubes). Several paradigms—examples or models—for process interaction in distributed computations are described. These include networks of filters, clients, and servers, heartbeat algorithms, probe/echo algorithms, broadcast algorithms, token-passing algorithms, decentralized servers, and bags of tasks. These paradigms are appliable to numerous practical problems. They are illustrated by solving problems, including parallel sorting, file servers, computing the topology of a network, distributed termination detection, replicated databases, and parallel adaptive quadrature. Solutions to all problems are derived in a step-wise fashion from a general specification of the problem to a concrete solution. The derivations illustrate techniques for developing distributed algorithms.

Distributed database systems: where are we now?

Abstract: The authors explain what is meant by a distributed database system and discuss its characteristics. They survey the state of distributed database technology, focusing on how well products meet the goals of transparent management of distributed and replicated data, reliability through distributed transactions, better performance, and easier, more economical system expansion. They then consider unsolved problems with regard to network scaling, distribution design, distributed query processing, distributed transaction processing, integration with distributed operating systems, and distributed multidatabase systems. >

Distributed program checking: a paradigm for building self-stabilizing distributed protocols

Abstract: The notion of distributed program checking as a means of making a distributed algorithm self-stabilizing is explored. A compiler that converts a deterministic synchronous protocol pi for static networks into a self-stabilizing version of pi for dynamic networks is described. If T/sub pi / is the time complexity of pi and D is a bound on the diameter of the final network, the compiled version of pi stabilizes in time O(D+T/sub pi /) and has the same space complexity as pi . The general method achieves efficient results for many specific noninteractive tasks. For instance, solutions for the shortest paths and spanning tree problems take O(D) to stabilize, an improvement over the previous best time of O(D/sup 2/). >

Distributed genetic algorithms for the floorplan design problem

Abstract: Designing a VLSI floorplan calls for arranging a given set of modules in the plane to minimize the weighted sum of area and wire-length measures. A method of solving the floorplan design problem using distributed genetic algorithms is presented. Distributed genetic algorithms, based on the paleontological theory of punctuated equilibria, offer a conceptual modification to the traditional genetic algorithms. Experimental results on several problem instances demonstrate the efficacy of this method and indicate the advantages of this method over other methods, such as simulated annealing. The method has performed better than the simulated annealing approach, both in terms of the average cost of the solutions found and the best-found solution, in almost all the problem instances tried. >

Practical uses of synchronized clocks in distributed systems

Abstract: Synchronized clocks are interesting because they can be used to improve performance of a distributed system by reducing communications. Since they have only recently become a reality in distributed systems, their use in distributed algorithms has received relatively little attention. This paper discusses a number of distributed algorithms that make use of synchronized clocks and analyzes how clocks are used in these algorithms

Another adaptive distributed shortest path algorithm

Abstract: The authors give a distributed algorithm to compute shortest paths in a network with changing topology The authors analyze its behavior The proof of correctness is discussed It does not suffer from the routing table looping behavior associated with the Ford-Bellman distributed shortest path algorithm although it uses truly distributed processing Its time and message complexities are evaluated Comparisons with other methods are given >

A DAG-based algorithm for distributed mutual exclusion

Abstract: A token-based distributed mutual exclusion algorithm is presented. The algorithm assumes a fully connected, reliable physical network and a directed acyclic graph (DAG) structured logical network. The number of messages required to provide mutual exclusion is dependent upon the logical topology imposed on the nodes. Using the best topology, the algorithm attains comparable performance to a centralized mutual exclusion algorithm; i.e., three messages per critical section entry. The algorithm achieves minimal heavy-load synchronization delay and imposes very little storage overhead. >

Topics in distributed algorithms

Abstract: Synchronization of ABD networks assertional verification distributed infimum approximation garbage collection.

An optimal algorithm for distributed system level diagnosis

Abstract: A system consisting of n identical processors connected by links in which some processors could be faulty is considered. Initially each unit knows only its own i.d. and the i.d.'s of its immediate neighbors; no unit has any global knowledge about the system. An optimal algorithm for system level diagnosis in such a system that is based on the transmission of packets by fault-free units is presented. The algorithm requires at most 3n log p+O(n+pt) message transmissions by fault-free units, where p fault-free units simultaneously start the algorithm and there are t faulty units. The correctness of the algorithm is argued. >

Detecting Termination of Distributed Computations By External Agents.

Abstract: An algorithm is presented that defects for termination of distributed computations by an auxiliary controlling agent. The algorithm assigns a weight W, 0>

A Distributed Solution to the k-out of-M Resources Allocation Problem

Abstract: We consider, in a distributed system, a set of M identical resources shared between n processes. Each of these resources can be used by at most one process at a given time (i.e. in mutual exclusion). In the k-out of-M resources allocation problem a process P i can requestat once any number k i of these M resources ; this process remains blocked until it has got a set of k i resources. A distributed algorithm, which generalizes the Ricart-Agrawala's mutual exclusion algorithm, is given for this problem ; a variant reducing the number of messages is also proposed. Finally this solution is extended to solve the generalized resourcesallocation problem in which a process request can concern several instances of different types of resources, each type being represented by some number of identical resources.

Restoring consistent global states of distributed computations

Abstract: We present a mechanism for restoring any consistent global state of a distributed computation. This capability can form the baais of support for rollback and replay of computations, an activity we view aa essential in a comprehensive environment for debugging distributed programs. Our mechanism records occasional state checkpoints and logs all messages communicated between processes. Our mechanism offers flexibility in the following ways: any consistent global state of the computation can be restored; execution can be replayed either exactly as it occurred initially or with user-controlled variations; there is no need to know a prioti what states might be of interest. In addition, if checkpoints and logs are written to stable storage, our mechanism can be used to restore states of computations that cause the system to crash.

Parallel and distributed algorithms for finite constraint satisfaction problems

Abstract: The authors develop two new algorithms for solving a finite constraint satisfaction problem (FCSP) in parallel. In particular, they give a parallel algorithm for the EREW PRAM model and a distributed algorithm for networks of interconnected processors. If an FCSP can be represented by an acyclic constraint network of size n with width bounded by a constant then: the parallel algorithm takes O(log n) time using O(n) processors and there is a mapping of this problem to a distributed computing network of poly(n) processors which stabilizes in O(log n) time. >

Location-independent object invocation in open distributed systems

Abstract: Object naming and location schemes are of vital importance in an open distributed system, since they provide the basis for all interactions between objects in distributed applications. In this paper we present the COMET naming scheme, which is tailored to an open environment. This naming scheme is complemented by a location scheme, that ensures efficient mapping of location-independent names on object addresses.

Prototyping parallel and distributed programs in Proteus

Abstract: This paper presents Proteus, an architecture-independent language suitable for prototyping parallel and distributed programs. Proteus is a high-level imperative notation based on sets and sequences with a single construct for the parallel composition of processes. Although a shared-memory model is the basis for communication between processes, this memory can be partitioned into shared and private variables. Parallel processes operate on individual copies of private variables, which are independently updated and may be merged into the shared state at specifiable barrier synchronization points. Several examples are given to illustrate how the various parallel programming models, such as synchronous data-parallelism and asynchronous control-parallelism, can be expressed in terms of this foundation. This common foundation allows prototypes to be tested, evolved and finally implemented through refinement techniques targeting specific architectures. >

Distributed computing: models and methods

Abstract: Publisher Summary Distributed computing is an activity that is performed on a spatially distributed system. An important problem in distributed computing is to provide a user with a non-distributed view of a distributed system to implement a distributed file system that allows the client programmer to ignore the physical location of his data. The models of computation generally considered to be distributed are process models in which the computational activity is represented as the concurrent execution of sequential processes. Different process models are distinguished by the mechanism employed for inter-process communication. The process models that are most distributed are the ones in which processes communicate by message passing. A process sends a message by adding it to a message queue and another process receives the message by removing it from the queue. There are two basic complexity measures for distributed algorithms: time and message complexity. The time complexity of an algorithm measures the time needed both for message transmission and for computation within the processes. The most common measure of message complexity is the total number of messages transmitted. If messages contain on the order of a few hundred bits or more, then the total number of bits sent might be a better measure of the cost than the number of messages.

A novel algorithm for discrete-event simulation: asynchronous distributed discrete-event simulation algorithm for cyclic circuits using a dataflow network

Abstract: Distributed simulation of circuits in which the process interactions form a cyclic graph is addressed. The method described uses a dataflow network synthesized on the basis of the connectivity of the circuit components. The algorithm, called Yaddes (which stands for yet another asynchronous distributed discrete-event simulation algorithm), computes for each component a quantity time of next event, which permits the corresponding model to execute asynchronously as far ahead in simulation time as possible. The network ensures that a simulation process executing in a distributed processing environment will not deadlock. The algorithm, which also offers acceptable performance and provable correctness, is compared with the two other principal algorithms proposed to avoid deadlocks: the deadlock recovery algorithm and the exception-mode algorithm. Performance results for Yaddes are presented. >

A formal study of distributed meeting scheduling: preliminary results

Abstract: Automating routine organizational tasks, such as meeting scheduling, requires a careful balance between the individual (respecting his or her privacy and personal preferences) and the organization (making efficient use of time and other resources). We argue that meeting scheduling is an inherently distributed process, and that negotiating over meetings can be viewed as a distributed search process. Keeping the process tractable requires introducing heuristics to guide distributed schedulers’ decisions about what information to exchange and whether or not to propose the same tentative time for several meetings. While we have intuitions about how such heuristics could affect scheduling performance and efficiency, rigorously verifying these intuitions requires a more formal model of the meeting schedule problem and process. We present our preliminary work toward this goal, as well as experimental results that validate some of the predictions of our formal model. Our model provides a springboard into deeper investigations of important issues in distributed artificial intelligence as well, and we outline our ongoing work in this direction.

Centralized and distributed multisensor integration with uncertainties in communication networks

Abstract: Algorithms in which each sensor is represented in a local coordinate system and the communication networks between sensors have uncertainties are considered. The algorithms are general and can be applied to various integration tasks. The effects of the communication network uncertainties are minimized in the local estimation and central fusion processes. In the centralized multisensor integration, the local measurements and local measurement models are transferred to the central coordinate system and the optimal integration is obtained at the central process. In contrast, the local measurements, together with the previous central estimate transmitted from the communication network, are locally processed in the distributed multisensor integration algorithm. Because the distributed algorithm uses the communication networks twice, more errors are introduced, so that when the uncertainties are large, the centralized algorithm is preferred. Although the algorithms are developed in the three-dimensional coordinate system, with straightforward extension they can be applied to N-dimensional coordinate systems. >

Electing leaders based upon performance: the delay model

Abstract: In a distributed system an algorithm used to select a distinguished node or leader in the system is known as a leader election algorithm. Leader election algorithms are examined that attempt to locate the leader at a good node (from a performance standpoint) in the system. In the preference-based approaches examined, each node in the system uses locally available information to vote for the various candidates (potential leaders) on the basis of the performance level it would realize under each of them. The preference-based leader election algorithms proposed and examined are simple, and are shown to perform almost as well as a traditional optimization-based approach to leader election. >

A distributed link restoration algorithm with robust preplanning

Abstract: A technique that combines benefits of fast, distributed heuristics and of centralized optimal algorithms is proposed. As a form of preplanning, whenever the topology of the network is deliberately changed, new optimal rerouting plans are calculated, using a centralized or a distributed approach, for each possible total cable failure. These plans are used to calculate distance labels that are stored in the digital cross-connect systems or other switching elements. When a failure occurs, the nodes (switches) at either end of the failed cable start the execution of a distributed max-flow algorithm and communicate with their neighbors by message passing. As nodes become involved in the execution of the distributed algorithm, they imitate their state using the precalculated distance labels. An appropriate set of distance labels can be defined on a transformed version of the network such that, if no topology changes have occurred in the network since the labels were calculated, the algorithm immediately converges to the optimal solution. If, on the other hand, links and/or nodes have been removed since the labels were calculated, the algorithm will still function properly and converge to a solution that has the maximal number of restored circuits (although the restoration paths are not necessarily of shortest possible length). >

Centralized and distributed operating systems

Abstract: An introduction to issues in contemporary operating systems which progresses from concepts that apply to all operating systems to the principles of distributed operating systems. Topics on distributed systems include system management, nets, distributed storage and remote procedure calls.

Efficient distributed algorithms for leader election in complete networks

Abstract: An efficient protocol for leader election in an asynchronous complete network is presented. The time complexity of the protocol is better than the currently known protocols for this problem. A message optimal protocol is presented that requires O(N/log N) time, where N is the number of nodes in the network. Also given is family of protocols with message and time complexities O(Nk) and O(N/k) respectively, where log N >