共查询到20条相似文献,搜索用时 31 毫秒
1.
In the totally anonymous shared memory model of asynchronous distributed computing, processes have no identifiers and run identical programs. Moreover, processes have identical interface to the shared memory, and in particular, there are no single-writer registers. This paper assumes that processes do not fail, and the shared memory consists only of read/write registers, which are initialized to some default value. A complete characterization of the functions and agreement tasks that can be solved in this model is presented. Furthermore, it is shown that if a function is computable, then two registers are sufficient for some algorithm to compute it. Consensus is an important agreement task that can be computed. The paper proves logarithmic lower bounds on the number of registers and rounds needed for solving consensus in this model. A consensus protocol using a linear number of shared registers and rounds is also presented. 相似文献
2.
Reaching agreement among processes sharing read/write memory is possible only in the presence of an eventual unique leader. A leader that fails must be recoverable, but on the other hand, a live and well-performing leader should never be decrowned. This paper presents the first leader algorithm in shared memory environments that guarantees an eventual leader following global stabilization time. The construction is built using light-weight lease and renew primitives. The implementation is simple, yet efficient. It is uniform, in the sense that the number of potentially contending processes for leadership is not a priori known. 相似文献
3.
This paper considers the problem of electing an eventual leader in an asynchronous shared memory system. While this problem
has received a lot of attention in message-passing systems, very few solutions have been proposed for shared memory systems.
As an eventual leader cannot be elected in a pure asynchronous system prone to process crashes, the paper first proposes to
enrich the asynchronous system model with an additional assumption. That assumption (denoted AWB) is particularly weak. It is made up of two complementary parts. More precisely, it requires that, after some time, (1) there
is a process whose write accesses to some shared variables be timely, and (2) the timers of (t−f) other processes be asymptotically well-behaved (t denotes the maximal number of processes that may crash, and f the actual number of process crashes in a run). The asymptotically well-behaved timer notion is a new notion that generalizes and weakens the traditional notion of timers whose durations are required to
monotonically increase when the values they are set to increase (a timer works incorrectly when it expires at arbitrary times,
i.e., independently of the value it has been set to).
The paper then focuses on the design of t-resilient AWB-based eventual leader protocols. “t-resilient” means that each protocol can cope with up to t process crashes (taking t=n−1 provides wait-free protocols, i.e., protocols that can cope with any number of process failures). Two protocols are presented.
The first enjoys the following noteworthy properties: after some time only the elected leader has to write the shared memory,
and all but one shared variables have a bounded domain, be the execution finite or infinite. This protocol is consequently
optimal with respect to the number of processes that have to write the shared memory. The second protocol guarantees that
all the shared variables have a bounded domain. This is obtained at the following additional price: t+1 processes are required to forever write the shared memory. A theorem is proved which states that this price has to be paid
by any protocol that elects an eventual leader in a bounded shared memory model. This second protocol is consequently optimal
with respect to the number of processes that have to write in such a constrained memory model. In a very interesting way,
these protocols show an inherent tradeoff relating the number of processes that have to write the shared memory and the bounded/unbounded
attribute of that memory. 相似文献
4.
The timestamp problem captures a fundamental aspect of asynchronous distributed computing. It allows processes to label events
throughout the system with timestamps that provide information about the real-time ordering of those events. We consider the
space complexity of wait-free implementations of timestamps from shared read-write registers in a system of n processes. We prove an lower bound on the number of registers required. If the timestamps are elements of a nowhere dense set, for example the integers,
we prove a stronger, and tight, lower bound of n. However, if timestamps are not from a nowhere dense set, this bound can be beaten: we give an implementation that uses n − 1 (single-writer) registers. We also consider the special case of anonymous implementations, where processes are programmed
identically and do not have unique identifiers. In contrast to the general case, we prove anonymous timestamp implementations
require n registers. We also give an implementation to prove that this lower bound is tight. This is the first anonymous timestamp
implementation that uses a finite number of registers. 相似文献
5.
The vast majority of papers on distributed computing assume that processes are assigned unique identifiers before computation begins. But is this assumption necessary? What if processes do not have unique identifiers or do not wish to divulge them for reasons of privacy? We consider asynchronous shared-memory systems that are anonymous. The shared memory contains only the most common type of shared objects, read/write registers. We investigate, for the first time, what can be implemented deterministically in this model when processes can fail. We give anonymous algorithms for some fundamental problems: time-stamping, snapshots and consensus. Our solutions to the first two are wait-free and the third is obstruction-free. We also show that a shared object has an obstruction-free implementation if and only if it satisfies a simple property called idempotence. To prove the sufficiency of this condition, we give a universal construction that implements any idempotent object. 相似文献
6.
Murali Krishna Ramanathan Ronaldo A. Ferreira Suresh Jagannathan Ananth Grama Wojciech Szpankowski 《Distributed Computing》2007,19(5-6):403-418
We present an efficient randomized algorithm for leader election in large-scale distributed systems. The proposed algorithm
is optimal in message complexity (O(n) for a set of n total processes), has round complexity logarithmic in the number of processes in the system, and provides high probabilistic
guarantees on the election of a unique leader. The algorithm relies on a balls and bins abstraction and works in two phases. The main novelty of the work is in the first phase where the number of contending processes
is reduced in a controlled manner. Probabilistic quorums are used to determine a winner in the second phase. We discuss, in
detail, the synchronous version of the algorithm, provide extensions to an asynchronous version and examine the impact of
failures. 相似文献
7.
First-Come-First-Served (FCFS) mutual exclusion (ME) is the problem of ensuring that processes attempting to concurrently
access a shared resource do so one by one, in a fair order. In this paper, we close the complexity gap between FCFS ME and
ME in the asynchronous shared memory model where processes communicate using atomic reads and writes only, and do not fail.
Our main result is the first known FCFS ME algorithm that makes O(log N) remote memory references (RMRs) per passage and uses only atomic reads and writes. Our algorithm is also adaptive to point
contention. More precisely, the number of RMRs a process makes per passage in our algorithm is Θ(min(k, log N)), where k is the point contention. Our algorithm matches known RMR complexity lower bounds for the class of ME algorithms that use
reads and writes only, and beats the RMR complexity of prior algorithms in this class that have the FCFS property. 相似文献
8.
Strom R.E. Yellin D.M. 《IEEE transactions on pattern analysis and machine intelligence》1993,19(5):478-485
The authors present a practical extension to typestate checking, which is capable of proving programs free of uninitialized variable errors even when these programs contain conditionally initialized variables where the initialization of a variable depends upon the equality of one or more tag variables to a constant. The user need not predeclare the relationship between a conditionally initialized variable and its tags, and this relationship may change from one point in the program to another. The technique generalizes liveness analysis to conditional liveness analysis. Like typestate checking, this technique incorporates a dataflow analysis algorithm in which each point in a program is labeled with a lattice point describing statically tracked information, including the initialization of variables. The labeling is then used to check for programming errors such as referencing a variable which may be uninitialized 相似文献
9.
The butterfly barrier 总被引:3,自引:0,他引:3
Eugene D. Brooks III 《International journal of parallel programming》1986,15(4):295-307
We describe and algorithm for barrier synchronization that requires only read and write to shared store. The algorithm is faster than the traditionallocked counter approach for two processors and has an attractive log2
N time scaling for largerN. The algorithm is free of hot spots and critical regions and requires a shared memory bandwidth which grows linearly withN, the number of participating processors. We verify the technique using both a real shared memory multiprocessor, for numbers of processors up to 30, and a shared memory multiprocessor simulator, for number of processors up to 256.Work performed under the auspices of the U.S. Department of Energy by the Lawrence Livermore National Laboratory under contract No. W-7405-ENG-48. 相似文献
10.
We present a shared memory algorithm that allows a set of f+1 processes to wait-free “simulate” a larger system of n processes, that may also exhibit up to f stopping failures.
Applying this simulation algorithm to the k-set-agreement problem enables conversion of an arbitrary k-fault-tolerant{\it n}-process solution for the k-set-agreement problem into a wait-free k+1-process solution for the same problem. Since the k+1-processk-set-agreement problem has been shown to have no wait-free solution [5,18,26], this transformation implies that there is no
k-fault-tolerant solution to the n-process k-set-agreement problem, for any n.
More generally, the algorithm satisfies the requirements of a fault-tolerant distributed simulation.\/ The distributed simulation implements a notion of fault-tolerant reducibility\/ between decision problems. This paper defines these notions and gives examples of their application to fundamental distributed
computing problems.
The algorithm is presented and verified in terms of I/O automata. The presentation has a great deal of interesting modularity,
expressed by I/O automaton composition and both forward and backward simulation relations. Composition is used to include
a safe agreement\/ module as a subroutine. Forward and backward simulation relations are used to view the algorithm as implementing a multi-try snapshot\/ strategy.
The main algorithm works in snapshot shared memory systems; a simple modification of the algorithm that works in read/write
shared memory systems is also presented.
Received: February 2001 / Accepted: February 2001 相似文献
11.
Two algorithms for barrier synchronization 总被引:5,自引:0,他引:5
Debra Hensgen Raphael Finkel Udi Manber 《International journal of parallel programming》1988,17(1):1-17
We describe two new algorithms for implementing barrier synchronization on a shared-memory multicomputer. Both algorithms are based on a method due to Brooks. We first improve Brooks' algorithm by introducing double buffering. Our dissemination algorithm replaces Brook's communication pattern with an information dissemination algorithm described by Han and Finkel. Our tournament algorithm uses a different communication pattern and generally requires fewer total instructions. The resulting algorithms improve Brook's original barrier by a factor of two when the number of processes is a power of two. When the number of processes is not a power of two, these algorithms improve even more upon Brooks' algorithm because absent processes need not be simulated. These algorithms share with Brooks' barrier the limitation that each of then processes meeting at the barrier must be assigned identifiersi such that 0i<n. 相似文献
12.
Summary. We prove the existence of a “universal” synchronous self-stabilizing protocol, that is, a protocol that allows a distributed
system to stabilize to a desired nonreactive behaviour (as long as a protocol stabilizing to that behaviour exists). Previous
proposals required drastic increases in asymmetry and knowledge to work, whereas our protocol does not use any additional
knowledge, and does not require more symmetry-breaking conditions than available; thus, it is also stabilizing with respect
to dynamic changes in the topology. We prove an optimal quiescence time n+D for a synchronous network of n processors and diameter D; the protocol can be made finite state with a negligible loss in quiescence time. Moreover, an optimal D+1 protocol is given for the case of unique identifiers. As a consequence, we provide an effective proof technique that allows
to show whether self-stabilization to a certain behaviour is possible under a wide range of models.
Received: January 1999 / Accepted: July 2001 相似文献
13.
《International Journal of Parallel, Emergent and Distributed Systems》2012,27(2):153-165
This paper presents parallel incremental algorithms for analyzing activity networks. The start-over algorithm used for this problem is a modified version of an algorithm due to Chaudhuri and Ghosh (BIT 26 (1986), 418-429). The computational model used is a shared memory single-instruction stream, multiple-data stream computer that allows both read and write conflicts. It is shown that the incremental algorithms for the event and activity insertion problems both require only O(loglogn) parallel time, in contrast to O(logn log logn) parallel time for the corresponding start-over algorithm. 相似文献
14.
We focus on unreliable asynchronous shared memory model which support only atomic read and write operations. For such a model
we provide a necessary condition for the solvability of problems in the presence of multiple undetectable crash failures.
Also, by using game-theoretical notions, a necessary and sufficient condition is provided, for the solvability of problems
in the presence of multiple undetectable initial failures (i.e., processes may fail only prior to the execution).
Our results imply that many problems such as consensus, choosing a leader, ranking, matching and sorting are unsolvable in
the presence of a single crash failure, and that variants of these problems are solvable in the presence of a single crash
failure, and that variants of these problems are solvable in the presence of t−1 crash failures but not in the presence of t crash failures.
We show that a shared memory model can simulate various message passing models, and hence our impossibility results hold also
for those message passing models. Our results extend and generalize previously known impossibility results for various asynchronous
models.
Received: October 26, 1990/November 28, 1994 相似文献
15.
We present a global snapshot algorithm with concurrent initiators, with termination detection in an anonymous asynchronous distributed message-passing system having FIFO channels. In anonymous systems, process identifiers are not available and an algorithm cannot use process identifiers in its operation. Such systems arise in several domains due to a variety of reasons. In the proposed snapshot algorithm for anonymous systems, each instance of algorithm initiation is identified by a random number (nonce); however, this is not used as an address in any form of communication. In the algorithm, each process can determine an instant when the local snapshot recordings at all the processes have terminated. This is a challenging problem when an algorithm cannot use process identifiers and a process does not know the number of processes in the system or the diameter of the network and cannot use a predefined topology overlay on the network, because there is no easy way to identify the global termination condition. The message complexity of our algorithm is (cn2), where c is the number of concurrent initiators and n is the number of processes in the system, which is much better than that of the algorithm by Chalopin et al. (2012) [6]. Further, the algorithm by Chalopin et al. also requires knowledge of the network diameter. 相似文献
16.
In this paper, we use the regular distribution method to design a perfect load balancing algorithm for an n-star with a maximum error of 1 and a time complexity of 3n(n+1). This algorithm is based on the novel notion of leader trees. A second algorithm proposed in this paper as an enhancement
to our first algorithm and uses an arbitrary spanning tree as the leader tree and has a worst time complexity of 2.25n
2−3n+0.75. We also discuss the issue of dynamically selecting the leader tree and hybrid load balancing algorithms in general.
Furthermore, we present a hybrid algorithm for load balancing on the star interconnection network which benefits from a diffusion
load balancing preprocessing phase and shows a smaller mean time complexity than our two first algorithms. 相似文献
17.
Shlomi Dolev Seth Gilbert Nancy A. Lynch Alexander A. Shvartsman Jennifer L. Welch 《Distributed Computing》2005,18(2):125-155
We present a new approach, the GeoQuorums approach, for implementing atomic read/write shared memory in mobile ad hoc networks. Our approach is based on associating abstract atomic objects with certain geographic locations. We assume the existence
of focal points, geographic areas that are normally “populated” by mobile nodes. For example, a focal point may be a road junction, a scenic
observation point, or a water resource in the desert. Mobile nodes that happen to populate a focal point participate in implementing
a shared atomic object, using a replicated state machine approach. These objects, which we call focal point objects, are prone
to occasional failures when the corresponding geographic areas are depopulated. The GeoQuorums algorithm uses the fault-prone
focal point objects to implement atomic read/write operations on a fault-tolerant virtual shared object. The GeoQuorums algorithm
uses a quorum-based strategy in which each quorum consists of a set of focal point objects. The quorums are used to maintain
the consistency of the shared memory and to tolerate limited failures of the focal point objects, which may be caused by depopulation
of the corresponding geographic areas. We present a mechanism for changing the set of quorums on the fly, thus improving efficiency.
Overall, the new GeoQuorums algorithm efficiently implements read and write operations in a highly dynamic, mobile network. 相似文献
18.
This paper presents new algorithms for solving some geometric problems on a shared memory parallel computer, where concurrent reads are allowed but no two processors can simultaneously attempt to write in the same memory location. The algorithms are quite different from known sequential algorithms, and are based on the use of a new parallel divide-and-conquer technique. One of our results is an O(log n) time, O(n) processor algorithm for the convex hull problem. Another result is an O(log n log log n) time, O(n) processor algorithm for the problem of selecting a closest pair of points among n input points. 相似文献
19.
本文旨在解决共享医疗数据场景下的群组用户授权管理与完整性验证问题. 首先, 为防止群组用户越权操作, 引入授权标识符, 医疗数据持有者凭授权标识符, 结合用户身份完成权限分配; 而授权标识符的数学构造可有效保证其不可伪造性. 其次, 为记录撤销用户并剥夺其访问权限, 引入基于跳表设计的撤销用户表; 跳表的快速查找和插入的特性, 使方案撤销用户的开销仅为${\mathrm{O}}(\log n)$. 随后, 完善了共享数据完整性验证的具体流程与数学设计. 最后通过安全性分析和仿真实验证明了方案的安全性和高效性. 相似文献
20.
A new elegant and simple algorithm for mutual exclusion of N processes is proposed. It only requires shared variables in a memory model where shared variables need not be accessed atomically.
We prove mutual exclusion by reformulating the algorithm as a transition system (automaton), and applying simulation of automata.
The proof has been verified with the higher-order interactive theorem prover PVS. Under an additional atomicity assumption,
the algorithm is starvation free, and we conjecture that no competing process is passed by any other process more than once.
This conjecture was verified by model checking for systems with at most five processes. 相似文献