26,074 research outputs found
Termination Detection of Local Computations
Contrary to the sequential world, the processes involved in a distributed
system do not necessarily know when a computation is globally finished. This
paper investigates the problem of the detection of the termination of local
computations. We define four types of termination detection: no detection,
detection of the local termination, detection by a distributed observer,
detection of the global termination. We give a complete characterisation
(except in the local termination detection case where a partial one is given)
for each of this termination detection and show that they define a strict
hierarchy. These results emphasise the difference between computability of a
distributed task and termination detection. Furthermore, these
characterisations encompass all standard criteria that are usually formulated :
topological restriction (tree, rings, or triangu- lated networks ...),
topological knowledge (size, diameter ...), and local knowledge to distinguish
nodes (identities, sense of direction). These results are now presented as
corollaries of generalising theorems. As a very special and important case, the
techniques are also applied to the election problem. Though given in the model
of local computations, these results can give qualitative insight for similar
results in other standard models. The necessary conditions involve graphs
covering and quasi-covering; the sufficient conditions (constructive local
computations) are based upon an enumeration algorithm of Mazurkiewicz and a
stable properties detection algorithm of Szymanski, Shi and Prywes
An optimal algorithm for global termination detection in shared-memory asynchronous multiprocessor systems
In the literature, the problem of global termination detection in parallel systems is usually solved by message passing. In shared-memory systems, this problem can also be solved by using exclusively accessible variables with locking mechanisms. In this paper, we present an algorithm that solves the problem of global termination detection in shared-memory asynchronous multiprocessor systems without using locking. We assume a reasonable computation model in which concurrent reading does not require locking and concurrent writing different values without locking results in an arbitrary one of the values being actually written. For a system of n processors, the algorithm allocates a working space of 2n + 1 bits. The worst case time complexity of the algorithm is n + 2√n + 1, which we prove is the lower bound under a reasonable model of computation. © 1997 IEEE.published_or_final_versio
A Survey and analysis of algorithms for the detection of termination in a distributed system
This paper looks at algorithms for the detection of termination in a distributed system and analyzes them for effectiveness and efficiency. A survey is done of the published algorithms for distributed termination and each is evaluated. Both centralized distributed systems and fully distributed systems are reviewed. The algorithms are analyzed for the overhead and conclusions are made about the situations in which they can be used, i.e. an operating system, a real-time system, or a user application. An original algorithm is presented for the asynchronous case with first-in-first-out message ordering. It allows any process to initiate detection of termination and makes use of multiple tokens
The derivation of distributed termination detection algorithms from garbage collection schemes
It is shown that the termination detection problem for distributed computations can be modelled as an instance of the garbage collection problem. Consequently, algorithms for the termination detection problem are obtained by applying transformations to garbage collection algorithms. The transformation can be applied to collectors of the "mark-and-sweep" type as well as to reference counting garbage collectors. As examples, the scheme is used to transform the distributed reference counting protocol of Lermen and Maurer, the weighted reference counting protocol, the local reference counting protocol, and Ben-Ari's mark-and-sweep collector into termination detection algorithms. Known termination detection algorithms as well as new variants are obtained
GEM: a Distributed Goal Evaluation Algorithm for Trust Management
Trust management is an approach to access control in distributed systems
where access decisions are based on policy statements issued by multiple
principals and stored in a distributed manner. In trust management, the policy
statements of a principal can refer to other principals' statements; thus, the
process of evaluating an access request (i.e., a goal) consists of finding a
"chain" of policy statements that allows the access to the requested resource.
Most existing goal evaluation algorithms for trust management either rely on a
centralized evaluation strategy, which consists of collecting all the relevant
policy statements in a single location (and therefore they do not guarantee the
confidentiality of intensional policies), or do not detect the termination of
the computation (i.e., when all the answers of a goal are computed). In this
paper we present GEM, a distributed goal evaluation algorithm for trust
management systems that relies on function-free logic programming for the
specification of policy statements. GEM detects termination in a completely
distributed way without disclosing intensional policies, thereby preserving
their confidentiality. We demonstrate that the algorithm terminates and is
sound and complete with respect to the standard semantics for logic programs.Comment: To appear in Theory and Practice of Logic Programming (TPLP
Distributed Edge Connectivity in Sublinear Time
We present the first sublinear-time algorithm for a distributed
message-passing network sto compute its edge connectivity exactly in
the CONGEST model, as long as there are no parallel edges. Our algorithm takes
time to compute and a
cut of cardinality with high probability, where and are the
number of nodes and the diameter of the network, respectively, and
hides polylogarithmic factors. This running time is sublinear in (i.e.
) whenever is. Previous sublinear-time
distributed algorithms can solve this problem either (i) exactly only when
[Thurimella PODC'95; Pritchard, Thurimella, ACM
Trans. Algorithms'11; Nanongkai, Su, DISC'14] or (ii) approximately [Ghaffari,
Kuhn, DISC'13; Nanongkai, Su, DISC'14].
To achieve this we develop and combine several new techniques. First, we
design the first distributed algorithm that can compute a -edge connectivity
certificate for any in time .
Second, we show that by combining the recent distributed expander decomposition
technique of [Chang, Pettie, Zhang, SODA'19] with techniques from the
sequential deterministic edge connectivity algorithm of [Kawarabayashi, Thorup,
STOC'15], we can decompose the network into a sublinear number of clusters with
small average diameter and without any mincut separating a cluster (except the
`trivial' ones). Finally, by extending the tree packing technique from [Karger
STOC'96], we can find the minimum cut in time proportional to the number of
components. As a byproduct of this technique, we obtain an -time
algorithm for computing exact minimum cut for weighted graphs.Comment: Accepted at 51st ACM Symposium on Theory of Computing (STOC 2019
- …