Self-stabilizing and silent distributed algorithms for token distribution in rooted tree networks are given. Initially, each process of a graph holds at most ℓ tokens. Our goal is to distribute the tokens uniformly in the whole network so that every process holds exactly k tokens. In the initial configuration, the total number of tokens in the network may not be nk where n is the number of processes in the network. The root process is given the ability to create a new token or remove a token from the network. We aim to minimize the convergence time, the number of token moves, and the space complexity. First, a self-stabilizing token distribution algorithm that converges within O(nℓ) asynchronous rounds and needs Θ(nhϵ) redundant (or unnecessary) token moves is given, where ϵ=min(k,ℓ−k) and h is the height of the tree network. Next, two novel mechanisms to reduce the number of redundant token moves are presented. One reduces the number of redundant token moves to O(nh) without any additional costs while the other reduces the number of redundant token moves to O(n), but increases the convergence time to O(nhℓ). All given algorithms have constant memory at each process and each link register.

In the population protocol model [Angluin et al. 2006], it is impossible to design a self-stabilizing leader election protocol without any knowledge of the exact number of nodes in the system. The notion of loose-stabilization, which relaxes the closure requirement of self -stabilization, was introduced in 2009 to circumvent this impossibility. The notion can be described as follows: a loosely-stabilizing protocol guarantees that, starting from any initial configuration, a system reaches a safe configuration eventually, and after that, the system maintains its specification (e.g., the unique leader) not forever, but for a sufficiently long time. The previous work of the authors presented a loosely-stabilizing protocol that solves the leader election on complete graphs using only a given upper bound N on the number of nodes n in the system, instead of the exact value of n. In this paper, we propose two loosely-stabilizing protocols that solve leader election for arbitrary graphs. One is a deterministic protocol that uses the unique identifiers of nodes while the other is a probabilistic protocol that works on anonymous networks. Given an upper bound N on the number of nodes, both protocols maintain a unique leader for Ω(Ne2N) expected steps (holding time) after entering a safe configuration. The first algorithm enters a safe configuration within O(mN log n) expected steps (convergence time) while the second one does this within O(mN2log N) expected steps, where m is the number of edges in the graph. Both protocols require only O(log N) bits for each node's memory. A novel concept, called the same speed timer is introduced, by which all nodes of the system can count down their timers at the same speed. This concept allows to achieve fast convergence time of both algorithms. To design the second protocol, we design a self-stabilizing two-hop coloring protocol, which is interesting in its own right. This protocol uses only O(log N) memory space per node. We establish a lower bound. Any loosely-stabilizing leader election protocol with expected exponential holding time requires Ω(mN) expected convergence time. This lower bound shows a near-optimality of the first algorithm.

Self-stabilizing and silent distributed algorithms for token distribution in rooted tree networks are given. Initially, each process of a graph holds at most l tokens. Our goal is to distribute the tokens in the whole network so that every process holds exactly k tokens. In the initial configuration, the total number of tokens in the network may not be equal to nk where n is the number of processes in the network. The root process is given the ability to create a new token or remove a token from the network. We aim to minimize the convergence time, the number of token moves, and the space complexity. A self-stabilizing token distribution algorithm that converges within O(n l) asynchronous rounds and needs Theta(nh epsilon) redundant (or unnecessary) token moves is given, where epsilon = min(k,l-k) and h is the height of the tree network. Two novel ideas to reduce the number of redundant token moves are presented. One reduces the number of redundant token moves to O(nh) without any additional costs while the other reduces the number of redundant token moves to O(n), but increases the convergence time to O(nh l). All algorithms given have constant memory at each process and each link register.

A loosely-stabilizing leader election protocol with polylogarithmic convergence time in the population protocol model is presented in this paper. In the population protocol model, which is a common abstract model of mobile sensor networks, it is known to be impossible to design a self-stabilizing leader election protocol. Thus, in our prior work, we introduced the concept of loose-stabilization, which is weaker than self-stabilization but has similar advantage as self-stabilization in practice. Following this work, several loosely-stabilizing leader election protocols are presented. The loosely-stabilizing leader election guarantees that, starting from an arbitrary configuration, the system reaches a safe configuration with a single leader within a relatively short time, and keeps the unique leader for an sufficiently long time thereafter. The convergence times of all the existing loosely-stabilizing protocols, i.e., the expected time to reach a safe configuration, are polynomial in n where n is the number of nodes (while the holding times to keep the unique leader are exponential in n). In this paper, a loosely-stabilizing protocol with polylogarithmic convergence time is presented. Its holding time is not exponential, but arbitrarily large polynomial in n.

We study (deterministic) leader election in unidirectional rings of homonym processes that have no a priori knowledge on the number of processes. In this context, we show that there is no algorithm that solves process-terminating leader election for the class of asymmetric labeled rings. In particular, there is no process-terminating leader election algorithm in rings in which at least one label is unique. However, we show that process-terminating leader election is possible for the subclass of asymmetric rings, where multiplicity is bounded. We confirm this positive results by proposing two algorithms, which achieve the classical trade-off between time and space.

A novel concept of the same speed timer is presented, and is applied in the population protocol (PP) model to improve the convergence time of existing loosely-stabilizing leader election protocols. Loosely-stabilizing leader election guarantees that, starting from any configuration, the system reaches a safe configuration within a short time (convergence), and after that, the system keeps the unique leader for a long time (closure). Two loosely-stabilizing leader election protocols for arbitrary graphs exist in the literature; one uses identifiers of nodes and the other uses random numbers to elect a unique leader. Both protocols guarantee that the expected convergence time is polynomial and the expected holding time (the time the leader is kept) is exponential. In this paper, convergence time of these protocols is dramatically improved by the same speed timer without impairing the exponential holding time. Specifically, a fast deterministic loosely-stabilizing leader election protocol that uses identifiers of nodes and a fast randomized looselystabilizing leader election protocol are given. The expected convergence time and expected holding time of the former protocol are O(mN log N) and Ω(Ne2N), respectively, where m is the number of edges in the graph and N is a given upper bound on the number of nodes n. The expected convergence time and expected holding time of the latter protocol are O(mN2log n) and Ω(Ne2N), respectively. A self-stabilizing two-hop coloring protocol that uses only O(log n) memory space of each agent is given as a tool of the latter protocol. A lower bound is also given: any loosely-stabilizing leader election protocol with expected exponential holding time requires Ω(mN) expected convergence time.

We give a silent self-stabilizing protocol for computing a maximum matching in an anonymous network with a tree topology. The round complexity of our protocol is O(diam), where diam is the diameter of the network, and the step complexity is O(n*diam), where n is the number of processes in the network. The working space complexity is O(1) per process, although the output necessarily takes O(log(delta)) space per process, where delta is the degree of that process. To implement parent pointers in constant space, regardless of degree, we use the cyclic Abelian group Z_7.

Power and energy have become increasingly important concerns in the design and implementation of today's multicore/manycore chips. In this paper, we present two priority-based CPU scheduling algorithms, Algorithm Cache Miss Priority CPU Scheduler (${ \mmb {\cal CM}}$-PCS) and Algorithm Context Switch Priority CPU Scheduler (${\cal CS}$-PCS), which take advantage of often ignored dynamic performance data, in order to reduce power consumption by over 20 percent with a significant increase in performance. Our algorithms utilize Linux cpusets and cores operating at different fixed frequencies. Many other techniques, including dynamic frequency scaling, can lower a core's frequency during the execution of a non-CPU intensive task, thus lowering performance. Our algorithms match processes to cores better suited to execute those processes in an effort to lower the average completion time of all processes in an entire task, thus improving performance. They also consider a process's cache miss/cache reference ratio, number of context switches and CPU migrations, and system load. Finally, our algorithms use dynamic process priorities as scheduling criteria. We have tested our algorithms using a real AMD Opteron 6134 multicore chip and measured results directly using the “KillAWatt” meter, which samples power periodically during execution. Our results show not only a power (energy/execution time) savings of 39 watts (21.43 percent) and 38 watts (20.88 percent), but also a significant improvement in the performance, performance per watt, and execution time$\cdot$watt (energy) for a task consisting of 24 concurrently executing benchmarks, when compared to the default Linux scheduler and CPU frequency scaling governor.

The problem of exploring a discrete environment by identical oblivious asynchronous agents (or robots) devoid of direct means of communication has been well investigated so far. The (terminating) exploration requires that starting from a configuration where no two agents occupy the same node, every node needs to be visited by at least one agent, with the additional constraint that all agents eventually stop moving. Agents have sensors that allow them to see their environment and move accordingly. The previous works on this problem assume agents having an unlimited visibility, that is, they can sense the agents on every node of the ring, whatever the ring size. In this paper, we address deterministic exploration in an anonymous, unoriented ring using oblivious, and myopic agents. By myopic, we mean that their visibility is limited in terms of sensing distance. We consider the strongest possible myopia that is, an agent can only sense agents located at its own and at its immediate neighboring nodes. Our contribution is threefold. We first prove that within such settings, no deterministic exploration is possible in the semi-synchronous model. The result is also valid for the (fully) asynchronous model and holds for any k 6. Finally, we provide optimal (in terms of number of agents) deterministic algorithms in the fully synchronous model for both cases 3 6.

In this paper, we propose a silent self-stabilizing asynchronous distributed algorithm for constructing a kclustering of any connected network with unique IDs. Our algorithm stabilizes in O(n) rounds, using O(log n) space per process, where n is the number of processes. In the general case, our algorithm constructs O(n/k) k-clusters. If the network is a Unit Disk Graph (UDG), then our algorithm is 7.2552k+O(1)competitive, that is, the number of k-clusters constructed by the algorithm is at most 7.2552k + O(1) times the minimum possible number of k-clusters in any k-clustering of the same network. More generally, if the network is an Approximate Disk Graph (ADG) with approximation ratio λ, then our algorithm is 7.2552λ2k + O(λ)-competitive. Our solution is based on the self-stabilizing construction of a data structure called the MIS Tree, a spanning tree of the network whose processes at even levels form a maximal independent set of the network. The MIS tree construction is the time bottleneck of our k-clustering algorithm, as it takes Θ(n) rounds in the worst case, while the rest of the algorithm takes O(D) rounds, where V is the diameter of the network. We would like to improve that time to be O(D), but we show that our distributed MIS tree construction is a P-complete problem.

Abstract Sensor networks are mainly used to gather strategic information in various monitored areas. Sensors may be deployed in zones where their internal memory, or the sensors themselves, can be corrupted. Since deployed sensors cannot be easily replaced, network persistence and robustness are the two main issues that have to be addressed while efficiently deploying large scale sensor networks. The sensing radius of a sensor is the distance within which a sensor can monitor certain events. The communication radius of a sensor is the distance within which a sensor can transmit and receive data. A sensor is said to cover a particular monitored area if a circular area, with radius equal to that sensor's sensing radius, covers that area. A set of sensors is said to be strongly connected if any two sensors in the set can communicate with each other, either directly or indirectly. The goal of forming a minimum connected cover of a query region in sensor networks is to select a subset of nodes that entirely covers a particular monitored area, which is strongly connected, and which does not contain a subset with the same properties. Selecting a minimal number of connected sensors is an NP hard problem. In our work, we address minimality in terms of inclusion. In this paper, we consider the most general case, wherein every sensor has a different sensing and communication radius. We propose two novel and robust solutions to the minimum connected cover problem that can cope with both transient faults (corruptions of the internal memory of sensors) and sensor crash/join. Also, our proposal includes extended versions which use multi‐hop information. We also prove the self‐stabilization property of our solutions, both analytically and through extended simulations. A self‐stabilizing system is a system that, when started from an arbitrary state, is always guaranteed to recover following the occurrence of (transient) faults and converge to a desired behavior (legitimate state) in a finite number of steps.Viasimulations, we also conclude that our solutions provide better performance, in terms of coverage, than preexisting self‐stabilizing solutions. Moreover, we observe that multi‐hop solutions produce a better approximation to an optimal cover set. Copyright © 2009 John Wiley & Sons, Ltd.

A silent self-stabilizing asynchronous distributed algorithm is given for constructing a k-dominating set, and hence a k-clustering, of a connected network of processes with unique IDs and no designated leader. The algorithm is comparison-based, takes O(k) time and uses O(k log n) space per process, where n is the size of the network. It is known that finding a minimum k-dominating set is 𝒩𝒫-hard. A lower bound is given, showing that any comparison-based algorithm for the k-clustering problem that produces clusters of average size more than 2 in the worst case takes Ω(diam) time, where diam is the diameter of the network.

In this paper, we address the problem of k-out-of-lscr exclusion, a generalization of the mutual exclusion problem, in which there are lscr units of a shared resource, and any process can request up to k units (1 les k les lscr). We propose the first deterministic self-stabilizing distributed k-out-of-lscr exclusion protocol in message-passing systems for asynchronous oriented tree networks which assumes bounded local memory for each process.

Given an arbitrary network G of processes with unique IDs and no designated leader, and given a k-dominating set I C G, we propose a silent self-stabilizing distributed algorithm that computes a subset D of I which is a minimal k-dominating set of G. Using D as the set of cluster-heads, a partition of G into clusters, each of radius k, follows. The algorithm is comparison-based, requires O(log n) space per process, converges in O(n) rounds and O(n2) steps, where n is the size of the network, and works under an unfair scheduler.

No abstract available.

We present two space and time efficient asynchronous distributed self-stabilizing algorithms. The first sorts an oriented chain network and the second heapifies a rooted tree network. The time complexity of both solutions is linear - in terms of the nodes (for the chain) and height (for the tree). The chain sorting algorithm uses O(m) bits per process where m represents the number of bits required to store any value in the network. The heapify algorithm needs O(m ldr D) bits per process where D is the degree of the tree.

The efficiency of service discovery is critical in the development of fully decentralized middleware intended to manage large scale computational grids. This demand influenced the design of many peer-to-peer based approaches. The ability to cope with the expressiveness of the service discovery was behind the design of a new kind of overlay structures that is based on tries, or prefix trees. Although these overlays are well designed, one of their weaknesses is the lack of any concrete fault tolerant mechanism, especially in dynamic platforms; the faults are handled by using preventive and costly mechanisms, \eg using a high degree of replication. Moreover, those systems cannot handle any arbitrary transient failure. Self-stabilization, which is an efficient approach to designreliable solutions for dynamic systems, was recently suggested to be a good alternative to inject fault-tolerance in peer-to-peer systems. However, most of the previous research on self-stabilization in tree and/or P2P networks was designed in theoretical models, making these approaches hard to implement in practice. In this paper, we provide a self-stabilizing message passing protocol to maintain prefix trees over practical peer-to-peer networks. A complete correctness proof is provided, as well as simulation results to estimate the practical impact of our protocol.

No abstract available.

This report gives an overview of the workshop on "Dependable Application Support for Self-Organising Networks" held in conjunction with DSN 2007. The principal objective of the workshop is to facilitate a forum for researchers to explore, examine and address dependability related challenges in hosting distributed applications in self-organised networks such as MANETs, sensor and P2P networks.

In this paper, we propose and prove correct a distributed stabilizing implementation of an overlay, called DR-tree, optimized for efficient selective dissemination of information. DR-tree copes with nodes dynamicity (frequent joins and leaves) and memory and counter program corruptions, that is, the processes can connect/disconnect at any time, and their memories and programs can be corrupted. The maintenance of the structure is local and requires no additional memory to guarantee its stabilization. The structure is balanced and is of height 0(logm(N)), which makes it suitable for performing efficient data storage or search. We extend our overlay in order to support complex content-based filtering in publish/subscribe systems. Publish/subscribe systems provide useful platforms for delivering data (events) from publishers to subscribers in a decoupled fashion in distributed networks. Developing efficient publish/subscribe schemes in dynamic distributed systems is still an open problem for complex subscriptions (spanning multi-dimensional intervals). Embedding a publish/subscribe system in a DR-trees is a new and viable solution. The DR-tree overlay also guarantees subscription and publication times logarithmic in the size of the network while keeping its space requirement low (comparable to its DHT-based counterparts). Nonetheless, the DR- tree overlay helps in eliminating the false negatives and drastically reduces the false positives in the embedded publish/subscribe system.

Synchronization is an important task in distributed computing since it allows asynchronous systems to simulate synchronous ones. Synchronization among distributed processes can be implemented using waves. A wave is a distributed execution, often made up of a broadcast phase followed by a feedback phase, requiring the participation of all the system processes before a particular event called decision is taken. Waves consisting of consecutive distinct broadcasts with corresponding feedbacks are referred to as a multi-wave. Solutions to a large number of fundamental problems in distributed computing such as distributed reset [1] and multiphase stabilization [10] require the completion of multi-waves. In this article, we propose a time and state-space optimal snap-stabilizing multi-wave algorithm implementing k distinct consecutive waves (k > 2) in a rooted tree, with O(kh) rounds of delay and at most k + 4 states per process, where h is the height of the tree. A system is said to be snap-stabilizing if it always behaves according to its specification [13]. One of the main advantages of the multi-wave algorithm being snap-stabilizing is that the arbitrary initial configuration has limited or no effect on the pace of the broadcast propagation.

We present a self-stabilizing optimal (in terms of the distance) local routing algorithm (𝒮𝒪ℒℛ) for a wireless mobile ad hoc network. The distance may represent various metrics, including the real distance and the number of hops. The optimal routing for any node is computed for t closest nodes (called t -set) where t is an application-dependent parameter and is decided in advance. The locality is defined with respect to the t -set, not with respect to the direct neighbours. Our protocol is a particular case of distance vector routing protocol, where the number of entries in the routing table is limited to t . A self-stabilizing system has the ability to automatically recover to normal behaviour in case of transient faults without a centralized control. Each node can start in some arbitrary state and with no knowledge of the network architecture, but still eventually computes a correct routing table for the nodes in its t -set. If we assume that the t -set represents the set of destinations for which the shortest path needs to be computed, 𝒮𝒪ℒℛ becomes an optimal on-demand routing protocol. It can be extended to a global routing protocol by using features specific to other protocols (e.g. hierarchical routing, cluster routing, interval routing, etc.).

Publish/Subscribe systems provide a useful platform for delivering data (events) from publishers to subscribers in an anonymous fashion in distributed networks. In this paper, we promote a novel design principle for self-. dynamic and reliable content-based publish/subscribe systems and perform a comparative analysis of its probabilistic and deterministic implementations. More specifically, we present a generic content-based publish/subscribe system, called DPS (Dynamic Publish/Subscribe). DPS combines classical content-based filtering with self-. (self-organizing, selfconfiguring, and self-healing) subscription-driven clustering of subscribers. DPS gracefully adapts to failures and changes in the system while achieving scalable events delivery. DPS includes a variety of fault-tolerant deterministic and probabilistic content-based publication/subscription schemes. These schemes are targeted toward scalability, and aim at reducing and distributing the number of messages exchanged. Reliability and scalability of our system are shown through analytical and experimental evaluation.

The network connectivity is a basic requirement while implementing fundamental communication and storage abstractions in P2P networks, featuring scalability and fault-tolerance. The quality of services of abstractions like for example multicast, publish/subscribe, group membership or persistent storage is strongly related to the connectivity degree of the underlying overlay. Intuitively, a higher overlay connectivity ensures a reinforced reliability and consequently, the deployment of distributed applications with real-time constraints on top of these overlays becomes feasible even in environments characterized by a high dynamicity, i.e., nodes arriving and departing at a high rate. Our paper proposes a novel delta-connected DHT-free P2P overlay. Our overlay offers strong connectivity guarantees despite the system dynamicity. The construction and the maintenance of our overlay is completely decentralized and handled strictly locally, through deterministic algorithms whose correctness is rigorously proved

This paper addresses the problem of trajectory tracking that deals with gathering coherent information on the past behavior of a mobile target. When a target enters and moves within a region covered by a sensor network, information about this target is generated by any active sensor that detects the target in its monitoring area. These gathered data have to be received by some registered nodes that are in charged of identifying the trajectory of the target to perform latter complex computations at the application level (e.g., trajectory forecasting, pursuer/evader, optimization of the management of natural disasters, etc,), Our first contribution consists informally specifying the problem: the proposed formal specification is the first one to the best of our knowledge. We also propose an original architecture combining three distinct abstractions which allows describing various solutions. Some algorithmic solutions that is necessary far the self-stabilizing-implementation of the trajectory tracking specification is outlined. The overall solution blends together in the context of tracking applications, three research areas: temporal correlated data, causal correlated (content related) data, and self-stabilizing overlays

In this paper, we design self-* novel solutions to the minimal connected sensor cover problem. The concept of self-* is used to include fault-tolerant properties like self-configuring, self-reconfiguring/self-healing, etc. We present two self-stabilizing, fully distributed, strictly localized, and scalable solutions, and show that these solutions are both self-configuring and self-healing. The proposed solutions are space optimal in terms of the number of states used per node. Another feature of the proposed algorithms is that the faults are contained only within the neighborhood of the faulty nodes. This paper also includes a comparison of the performance of the two proposed solutions in terms of the stabilization time, cover size metrics, and ability to cope with transient and permanent faults.

The group mutual exclusion (GME) problem was introduced by Joung. The GME solution allows n processes to share m mutually exclusive resources. We present several algorithms to solve the GME problem in token rings. The space requirement and the size of messages of all algorithms are bounded. So, the proposed algorithms solve the problem suggested by Joung, which is to obtain a solution using messages of bounded size. The time and space complexities of the first and second algorithms depend on n and m respectively. The first algorithm is more efficient when n ≪ m, whereas the second one when m ≪ n. The cost of the third algorithm is min(n, m). So, it is suitable for any type of network. However, the third solution is obtained with a message size of log(min(n, m)) extra bits. The third algorithm has an additional desirable property. It serves the requests in a first in first out manner. The fourth algorithm improves the bandwidth usage by avoiding the token circulation when no new requests are made for a different session. This property of the fourth algorithm can be incorporated into the other three algorithms.

A self-stabilizing algorithm, regardless of the initial system state, converges in finite time to a set of states that satisfy a legitimacy predicate. The mutual exclusion problem is fundamental in distributed computing, since it allows processors competing to access a shared resource to be able to synchronize and get exclusive access to the resource (i.e. execute their critical section). It is well known that providing self-stabilization in general uniform networks (e.g. anonymous rings of arbitrary size) can only be probabilistic. However, all existing uniform probabilistic self-stabilizing mutual exclusion algorithms designed to work under an unfair distributed scheduler (that may choose processors to execute their code in an arbitrary manner) suffer from the following common drawback: once stabilized, there exists no upper bound on time between two successive executions of the critical section at a given processor. In this paper, we present the first self-stabilizing algorithm that guarantees such a bound (O(n3), where n is the network size) while working using an unfair distributed scheduler. Our algorithm works in an anonymous unidirectional ring of any size and has a polynomial expected stabilization time.

A snap-stabilizing protocol guarantees that the system always behaves according to its specification provided some processor initiated the protocol. We present how to snap-stabilize some important protocols, like Leader Election, Reset, Snapshot, and Termination Detection. We use a Snap-stabilizing Propagation of Information with Feedback protocol for arbitrary networks as the key module in the above transformation process. Finally, we design a universal transformer to provide a snap-stabilizing version of any protocol (which can be self-stabilized with the transformer of [15]).

Abstract In this paper, we present the first self‐stabilizing solution to the k‐out‐of‐ℓ exclusion problem on a ring. The k‐out‐of‐ℓ exclusion problem is a generalization of the well‐known mutual exclusion problem—there are ℓ units of the shared resources, any process can request k $(1 \leq k \leq \ell)$ units of the shared resources, and no resource unit can be allocated to more than one process at one time. The space requirement of the proposed algorithm is independent of ℓ for all processors except a special processor, called Root. The stabilization time is only 5n, where n is the size of the ring. Copyright © 2003 John Wiley & Sons, Ltd.

We present the first snap-stabilizing propagation of information with feedback (PIF) protocol in arbitrary networks. A snap-stabilizing protocol, starting from any arbitrary initial system configuration, always behaves according to its specification. Our protocol is distributed, deterministic, and does not use a pre-constructed spanning tree.

The group mutual exclusion (GME) problem deals with sharing a set of (m) mutually exclusive resources among all (n) processes of a network. Processes are allowed to be in a critical section simultaneously provided they request the same resource. We present three group mutual exclusion solutions for tree networks. All three solutions do not use process identifiers, and use bounded size messages. They achieve the best context-switch complexity, which is O(min (n, m)). The first solution uses a fixed root of the tree and uses 0 to O(n) messages per critical section entry. This solution supports an unbounded degree of concurrency, thus provides the maximum resource utilization. The second solution also uses a fixed root, but uses a reduced number of messages for the critical section entry. It generates an average of O(log n) messages per critical section entry and also allows an unbounded degree of concurrency. However, the concurrency may be limited in some parts of the network. We remove the restriction of using a fixed root in the third solution in addition to maintaining all other desirable properties of the second solution.

Wormhole routing is the most common in parallel architecture in which messages are sent in small fragments called flits. It is a lightweight and efficient method of routing messages between parallel processors. Self-stabilization is a technique that guarantees tolerance to transient faults (e.g. memory corruption or communication hazard) for a given protocol. Self-stabilization guarantees that the network recovers to a correct behavior infinite time, without the need for human intervention. Self-stabilization also guarantees the safety property, meaning that once the network is in a legitimate state, it will remain there until another fault occurs. This paper presents the first self-stabilizing network algorithm in the wormhole routing model, using the unidirectional ring topology. Our solution benefits from wormhole routing by providing high throughput and low latency, and front self-stabilization by ensuring automatic resilience to all possible transient failures.

We propose a group mutual exclusion algorithm for unidirectional rings. Our algorithm does not require the processes to have any id. Moreover, processes maintain no special data structures to implement any queues. The space requirement of processes depends only on the number of shared resources, and is equal to 4/spl times/log(m+1)+2 bits. The size of messages is 2/spl times/log(m+1) bits only. Every resource request generates O(n/sup 2/) messages in the worst case, but zero messages in the best case.

We present a deterministic distributed Propagation of Information with Feedback (PIF) protocol in arbitrary rooted networks. The proposed algorithm does not use a preconstructed spanning tree. The protocol is self-stabilizing, meaning that starting from an arbitrary state (in response to an arbitrary perturbation modifying the memory state), it is guaranteed to behave according to its specification. Every PIF wave initiated by the root inherently creates a tree in the graph. So, the tree is dynamically created according to the progress of the PIF wave. This allows our PIF algorithm to take advantage of the relative speed of different components of the network. The proposed algorithm can be easily used to implement any self-stabilizing system which requires a (self-stabilizing) wave protocol running on an arbitrary network.

We present the first deterministic self-stabilizing network orientation algorithms. We present three protocols for arbitrary and asynchronous networks. All the protocols set up a chordal sense of direction in the network. The protocols are self-stabilizing, meaning that starting from an arbitrary state, the protocols are guaranteed to reach a state, in which all edge labels (assigned to the links) are valid (meaning, they satisfy the specification of the orientation problem).

A self-stabilizing algorithm, regardless of the initial system state, converges infinite time to a set of states that satisfy a legitimacy predicate without the need for explicit exception handler of backward recovery. Mutual exclusion is fundamental in the area of distributed computing, by serializing the accesses to a common shared resource. All existing probabilistic self-stabilizing mutual exclusion algorithms designed to work under an unfair distributed scheduler suffer from the following common drawback: Once stabilized, there exists no upper bound of time between two executions of the critical section at a given node. We present the first probabilistic self-stabilizing algorithm that guarantees such a bound (O(n/sup 3/), where n is the network size) while working using an unfair distributed scheduler. As the scheduling adversary gets weaker the bound gets better. Our algorithm works in an anonymous unidirectional ring of any size and has a O(n/sup 3/) expected stabilization time.

Proposes a self-stabilizing synchronization technique, called the Neighborhood Synchronizer (/spl Nscr//spl Sscr/), that synchronizes nodes with their neighbors in a tree network. The /spl Nscr//spl Sscr/ scheme has an extremely small memory requirement-only one bit per processor. Algorithm /spl Nscr//spl Sscr/ is inherently self-stabilizing. We apply our synchronizer to design a broadcasting algorithm /spl Bscr//spl Ascr/ in a tree network. Algorithm /spl Bscr//spl Ascr/ is also inherently self-stabilizing and needs only 2h+2m-1 rounds to broadcast m messages, where h is the height of the tree.

Recently (1998), we introduced a new self-stabilizing PIF paradigm, called the Propagation of information with Feedback and Cleaning (PFC), for the rooted tree networks. In this paper, we propose the first self-stabilizing PIF scheme for the tree networks without sense of direction-the trees do not have a root and the processors do not maintain any ancestor. The proposed PIF scheme is based on the paradigm PFC. A PIF algorithm in trees without sense of direction is very useful in many applications because this allows to maintain only one spanning tree of the network instead of one per processor. The proposed algorithm requires 3 states per processor, and only 2 states for the initiator and leaves. This space requirement is optimal for both self-stabilizing and non-stabilizing PIF algorithms on tree networks. Thus, the processors need no extra space to stabilize the proposed PIF scheme.

We propose a self-stabilizing synchronization technique, called the global rooted synchronization, that synchronizes processors in a tree network. This synchronizer converts a synchronous protocol for tree networks into a self-stabilizing version. The synchronizer requires only O(1) memory (other than the memory needed to maintain the tree) at each node regardless of the size of the network, stabilizes in O(h) time, where h is the height of the tree, and does not invoice any global operations. Applications of this technique are presented.

This paper implements and analyzes the performance of parallel algorithms for the string-to-string correction and the longest common subsequence (LCS) problems, on the shared-memory Sequent Symmetry multiprocessor machine. The speedup of the first algorithm is 12.686 with 15 processors for a sequence of length 800, while the speedup of the LCS algorithm is 3.227 employing 8 processors for a sequence of length 128.

A self-stabilizing system is a network of processors, which, when started from an arbitrary (and possibly illegal) initial state, always returns to a legal state in a finite number of steps. This implies that the system can automatically deal with infrequent errors. One issue in designing self-stabilizing algorithms is the number of states required by each machine. This paper presents mutual exclusion algorithms which will be self-stabilizing while only requiring each machine in the network to have two states. The concept of a randomized central demon is also introduced in this paper. The first algorithm is a starting point where no randomization is needed (the randomized central demon is not necessary). The other two algorithms require randomization. The second algorithm builds on the first algorithm and reduces the number of network connections required. Finally, the number of necessary connections is again reduced yielding the final two-state, probabilistic algorithm for an asynchronous, unidirectional ring of processes.>

A deadlock detection algorithm utilizing a transaction-wait-for (TWF) graph is presented. It is a fully distributed algorithm which allows multiple outstanding requests. The proposed algorithm can achieve improved overall performance, using multiple disjoint controllers coupled with the two-phase property, while maintaining the simplicity of centralized schemes. The detection step is divided into two phases. Phase 1 analyzes the conditions of the system of interacting transactions, involving phase 2 only if conditions are possible for deadlocks to occur. Phase 2 performs the actual cycle detection. The proposed algorithm can be used in transaction-based distributed processing systems. Some results on the complexity of the algorithm are given.>

A new class of Petri nets called regular nets is described.The structure of these nets guarantees liveness once the invanants are marked with tokens.Some graphical properties ofmvariants and variants are discussed.The concept of net labeling is introduced and a systematic method of synthesizing regular nets ts presented.It is shown how the safety of such nets can be trivially assured, thus producing live and safe control structures.