A super-stabilizing log ( n ) -approximation algorithm for dynamic Steiner trees ✩

(1)

Contents lists available atSciVerse ScienceDirect

Theoretical Computer Science

www.elsevier.com/locate/tcs

A super-stabilizing log ( n ) -approximation algorithm for dynamic Steiner trees ^✩

Lélia Blin

^c

^,

^b

, Maria Potop-Butucaru

^a

^,

^b

^,∗ , Stephane Rovedakis

^d

^,∗∗

aUniv. Pierre & Marie Curie – Paris 6, France bLIP6-CNRS UMR 7606, France

cUniv. Evry Val d’Essonnes, Bd François Mitterrand, 91000 Evry, France dLaboratoire CEDRIC, CNAM, 292 Rue St Martin, 75141 Paris, France

a r t i c l e i n f o a b s t r a c t

Article history:

Received 11 March 2010

Received in revised form 1 July 2013 Accepted 4 July 2013

Communicated by D. Peleg Keywords:

Self-stabilization Dynamic Steiner tree Multicast

Message passing networks

This paper proposes a fully dynamic self-stabilizing algorithm for the dynamic Steiner tree problem. The Steiner tree problem aims at constructing a Minimum Spanning Tree (MST) over a subset of nodes called Steiner members, or Steiner group usually denotedS.

Steiner trees are good candidates to efficiently implement communication primitives such as publish/subscribe or multicast, essential building blocks in the design of middleware architectures for the new emergent networks (e.g., P2P, sensor or adhoc networks). Our algorithm returns a log(|^S|)-approximation of the optimal Steiner tree. It improves over existing solutions in several ways. First, it is fully dynamic, in other words it withstands the dynamism when both the group members and ordinary nodes can join or leave the network. Next, our algorithm is self-stabilizing, that is, it copes with nodes memory corruption. Last but not least, our algorithm issuper-stabilizing. That is, while converging to a correct configuration (i.e., a Steiner tree) after a modification of the network, it keeps offering the Steiner tree service during the stabilization time to all members that have not been affected by this modification.

1. Introduction

The design of eﬃcient distributed applications in the newly distributed emergent networks such as MANETs, P2P or sensor networks raises various challenges ranging from models to fundamental services. These networks face frequent churn (nodes and links creation or destruction) and various privacy and security attacks that cannot be easily encapsulated in the existing distributed models. Therefore, new models and new algorithms have to be designed.

Communication services are the building blocks for any distributed system and they have received a particular attention in the lately years. Their eﬃciency greatly depends on the performance of the underlying routing overlay. These overlays should be optimized to reduce the network overload. Moreover, in order to avoid security and privacy attacks the number of network nodes that are used only for the overlay connectivity have to be minimized. Additionally, the overlays have to offer some quality of services while nodes or links fail.

The work in designing optimized communication overlays for the new emergent networks has been conducted in both structured (DHT-based) and un-structured networks. Communication primitives using DHT-based schemes such as Pastry, CAN or Chord[2]build upon a global naming scheme based on hashing nodes identiﬁers. These schemes are optimized to

✩ A preliminary version of this work was published in Proceedings of SSS 2009[1].

*

Principal corresponding author at: Univ. Pierre & Marie Curie – Paris 6, France.

**

Corresponding author.

E-mail addresses:lelia.blin@lip6.fr(L. Blin),maria.gradinariu@lip6.fr(M. Potop-Butucaru),stephane.rovedakis@cnam.fr(S. Rovedakis).

http://dx.doi.org/10.1016/j.tcs.2013.07.003

(2)

eﬃciently route in the virtual name space. However, they have weak energy performances in MANETs or sensor networks where the maintenance of long links reduces the network perennial. Therefore, alternative strategies[3], mostly based on gossip techniques, have been recently considered. These schemes, highly eﬃcient when nodes have no information on the content and the topology of the system, offer only probabilistic guarantees on the message delivery.

In this paper we are interested in the study of overlays targeted to eﬃciently connect a group of nodes that are not necessarily located in the same geographical area (e.g., sensors that should communicate their sensed data to servers located outside the deployment area, P2P nodes that share the same interest and are located in different countries, robots that should participate to the same task but need to remotely coordinate). Steiner trees are good candidates to implement the above mentioned requirements since the problem have been designed for eﬃciently connect a subset of the network nodes, referred as Steiner members.

1.1. The Steiner tree problem

The Steiner tree problem can be informally expressed as follows: given a weighted graph in which a subset S of nodes is identified, find a minimum-weight tree spanningS. The Steiner tree problem is one of the most important combinatorial optimization problems and finding a Steiner tree is NP-hard[4].

A survey on different heuristics for constructing Steiner trees with different approximation ratios can be found in[5]. In our work we are interested in dynamic variants of Steiner trees ﬁrst addressed in[6]in a centralized on-line setting.

They propose a log

( |

^S

| )

-approximation algorithm for this problem that copes only with Steiner member arrivals. At ﬁrst step, a member becomes the root of the tree then at each step a new member is connected to the existing Steiner tree by a shortest path. This algorithm can be implemented in a decentralized environment (see[7]).

Our work considers the fully dynamic version of the problem where both Steiner members and ordinary nodes or communication links can join or leave the system. Additionally, our work aims at providing a super-stabilizing approximation of a Steiner tree. The property of self-stabilization [8,9] enables a distributed algorithm to recover from a transient fault regardless of its initial state. The super-stabilization [10] is an extension of the self-stabilization property for dynamic settings. The idea is to provide some minimal guarantees while the system repairs after a topology change.

To our knowledge there are only two self-stabilizing approximations of Steiner trees[11,12]. Both works assume the shared memory model and an unfair centralized scheduler. In[11]the authors propose a self-stabilizing algorithm based on a pruned minimum spanning tree. The computed solution has an approximation ratio of

|

^V

| − |

^S

| +

^{1, where}^V is the set of nodes in the network. In[12], the authors proposed a four-layered algorithm which is built upon the techniques proposed in[13]to obtain a 2-approximation.

The above cited algorithms are designed to work only for static networks. In [12] the members can become ordinary nodes and ordinary nodes can become members, but the network does not change. These algorithms could be used in dynamic networks, however to guarantee a 2-approximation after a topology change in the network the tree must be totally reconstructed in most cases because of the computation of a minimum spanning tree of the network. Therefore, each topology change induces a computation extra cost in the network to maintain a 2-approximate Steiner tree.

1.2. Our results

We describe the ﬁrst distributed super-stabilizing algorithm for the Steiner tree problem. This algorithm has the following novel properties with respect to the previous constructions:

•

it is specially designed to cope with dynamism of the system. In other words, our solution tolerates nodes (or links) join and leave the system, while using O

(|

^S

|

^log

(

n

))

memory bits with

the maximal degree of the network and n

= |

^V

|

the network size (or O

( |

^S

|

^log

(

n

))

in the classical message passing model, i.e., by considering only the memory size for local variables).¹

•

it’s design includes self-stabilizing policies. Starting from an arbitrary state (nodes local memory corruption, counter program corruption, or erroneous messages in the network buffers), our algorithm is guaranteed to converge to a tree spanning the Steiner members whose weight is at most log

( |

^S

| )

times the weight of an optimal solution.

•

Additionally, it issuper-stabilizing. That is, while a topology change occurs, i.e., during the re-stabilization period, the algorithm offers the guarantee that only the subtree connected through the crashed node/edge is reconstructed. Moreover, a log

(|

^S

|)

-increasing is preserved when a topology change occurs in a legitimate conﬁguration.

Table 1summarizes our contribution compared to previous works. The approximation ratio of our algorithm is logarith- mic, which is not as good as the 2-approximation of the algorithm proposed by Kamei and Kakugawa in [12]. However, this latter algorithm is not super-stabilizing. Designing a super-stabilizing 2-approximation algorithm for the Steiner tree problem is a challenging open question. Indeed, all known 2-approximation distributed algorithms (self-stabilizing or not)

1 To solve the problem, one can use a self-stabilizing reset algorithm with a centralized algorithm computing a Steiner tree on each node but this requires at leastO(nlog(n))memory bits because the map of the network have to be stored on each node.

(3)

Table 1

Distributed (deterministic) algorithms for the Steiner tree problem.

Dynamicity Super-stabilizing Self-stabilizing Approximation

[14] No No No 2

[11] No No Yes |^V| + |^S| −¹

[12] No No Yes 2

This paper Yes Yes Yes log(|S|)

for the Steiner tree problem use a minimum spanning tree (MST) computation, and so the main point is the design of a super-stabilizing algorithm solving the MST problem.

The paper is organized as follows. The two next sections introduce the model and the description of the approaches proposed by Imase and Waxman and Aharoni and Cohen for the dynamic Steiner tree problem. Section 4 presents the detailed description of our algorithm, and Section5prove the correctness of our algorithm and its super-stabilizing ability.

The last section of the paper resumes the main results and outlines some open questions.

2. Model and notations

We consider an undirected weighted connected networkG

= (

V

,

E

,

w

)

whereV is the set of nodes,E is the set of edges and w:E

→

R⁺ is a positive cost function. Nodes represent processors and edges represent bidirectional communication links. We consider an asynchronous communication message passing model with reliable and FIFO channels (on each link messages are delivered in the same order as they have been sent). Each node v in the network has a unique identiﬁer, noted ID_v. S

⊆

^V deﬁnes the set of members we have to connect. For any pair of nodes u

,

v

∈

^V^{, we note} ^d

(

u

,

v

)

the distance of the shortest path P

(

u

,

v

)

betweenu and v in G (i.e.d

(

u

,

v

) =

e∈^P(u,v)w

(

e

)

). For a node v

∈

^V, we denote the set of its neighbors N

(

v

) = {

^u

, (

u

,

v

) ∈

^E

}

. A Steiner tree, T in G is a connected acyclic sub-graph of G such that T

= (

VT

,

ET

)

, S

⊆

^VT

⊆

^V ^and^ET

⊂

^E. We denote byW

(

T

)

the cost of a treeT, i.e.W

(

T

) =

e∈^Tw

(

e

)

.

Alocal state of a node is the value of the local variables of the node and the state of its program counter. We consider a ﬁned-grained communication atomicity model [15,9]. That is, each node maintains a local copy of the variables of its neighbors. These variables are refreshed via special messages (denoted in the sequel

InfoMsg

) exchanged periodically by neighboring nodes. A conﬁgurationof the system is the cross product of the local states of all nodes in the system plus the content of the communication links. Anatomic stepat node pis an internal computation based on the current value ofp’s local variables and a single communication operation (send/receive) at p.

We assume a distributed weakly fair daemon. Acomputationof the system is deﬁned as aweakly fair, maximalsequence of conﬁgurations,e

= (

c0

,

c1

, . . . ,

ci

, . . .)

, where each configurationci+¹ follows from ci by the execution of a single action by at least one node. During an execution step, one or more processors execute an action and a processor may take at most one action. Weak fairnessof the sequence means that if any action inG is continuously enabled along the sequence, it is eventually chosen for execution.Maximality means that the sequence is either infinite, or it is finite and no action ofG is enabled in the final global state.

To compute the time complexity, we use the deﬁnition ofround. This deﬁnition captures the execution rate of the slowest processor in any computation. Given a computatione(e

∈

E^{), the}^{first round}ôfê(let us call ite) is the minimal prefix ofe containing the execution of one action (an action of the protocol or a disabling action) of every enabled processor from the initial configuration. Let ebe the suffix ofesuch thate

=

êê^{. The}second roundofeis the first round ofe, and so on.

Deﬁnition 1(Self-stabilization).GivenL_Aa non-emptylegitimacy predicate²an algorithmA^isself-stabilizingiff the following two conditions hold:

(i) Every computation ofAstarting from a conﬁguration satisfyingL_A^preservesL_A^(closure).

(ii) Every computation ofAstarting from an arbitrary configuration contains a configuration that satisfiesL_A(convergence).

Alegitimate conﬁgurationfor the Steiner tree problem is a conﬁguration that provides an instance of a tree T spanning S. Additionally, we expect a competitiveness of log

(

z

)

, i.e., _W^W₍⁽_T^T_∗⁾₎^log

(

z

)

, with

|

^S

| =

^z^and^T^∗an optimal Steiner tree.

In the following we propose a self-stabilizing Steiner tree algorithm. We expect our algorithm to be alsosuper-stabilizing [10]. That is, given a class of topology changes

Λ

and a passage predicate, an algorithm is super-stabilizing with respect to

Λ

iff it is self-stabilizing, and for every computation³ e beginning at a legitimate conﬁguration and containing a single topology change event of type

Λ

, the passage predicate holds for every conﬁguration ofe.

2 A legitimacy predicate is deﬁned over the conﬁgurations of a system and is an indicator of its correct behavior.

3 [10]use the notion of trajectory which is the computation of a system enriched with dynamic actions.

(4)

In the following we propose a self-stabilizing Steiner tree algorithm and extend it to a super-stabilizing Steiner tree algorithm that copes with the addition/removal of a Steiner member and the removal of a tree node/edge. During the tree re-stabilization the algorithm veriﬁes a passage predicate detailed below.

3. Centralized on-line Steiner tree algorithms

As stated in Introduction section, several centralized approximation algorithms have been proposed for the Steiner tree problem. The best approximation ratio reached is a constant multiplicative approximation ratio of two, achieved in[16,17].

These algorithms make the hypothesis that the set of Steiner members is ﬁxed and it is given as an input. However, this hypothesis cannot always be assumed, especially in the case when Steiner members constitute a multicast group. That is, Steiner members can dynamically join and leave the multicast group. In this case a new Steiner tree must be computed after a modiﬁcation of the multicast group to guarantee a good approximation solution. This method is wasteful in time and maintenance. Moreover, the Steiner tree cannot be used by the upper application level until the reconstruction ends. In the following we present two centralized algorithms[6,18], that we extend in the next section to a super-stabilizing distributed approximated Steiner tree with an approximation ratio of log

(|

^S

|)

^.

In [6], Imase and Waxman introduced the Dynamic Steiner Tree (DST) problem which can be stated as follows. Let R

= {

^r0

,

r1

, . . . ,

rK

}

be a sequence of requests, where eachri is a pair

(

vi

, ρ

i

)

such that vi

∈

^V ^and

ρ

i

∈ {

add, remove

}

^{. Let} S_i be the set of nodes in the multicast group after requestr_i, consisting of every node v for which there exists jⁱ ^such thatrj

= (

vj

,

add

)

andrl

= (

vl

,

remove

)

for all j

<

li. Given a graphG

= (

V

,

E

)

, a nonnegative weight for each edgee

∈

^E and a sequence of requests R, compute a sequence of multicast trees

{

^T1

,

T2

, . . . ,

TK

}

^where ^Ti is of minimum cost and spans S_i.

The no rearrangeable version (DST-N) of DST problem requires that any path added for requestrjcannot be modiﬁed by any requestri

,

i

>

j. That is, ifriis an add request then we haveTi−¹

⊆

Ti. For a remove request we have Ti

⊆

Ti−¹. Imase and Waxman[6]have shown that for any algorithmA solving DST-N problem with a request sequence containing only add requests, there exists an instance such that for everyi, 0

<

i^K^:

A

(

Si

)

OPT

(

Si

)

1

+

¹ 2

log

|

Si

| −

1

,

whereK is the length of the request sequence,OPT

(

Si

)

is the optimum solution for a tree spanningSi, and A

(

Si

)

is the cost of the tree spanning Si generated by A. If both add and remove requests are allowed and if the tree cannot be rearranged (i.e., DST-N problem), then there is no upper bound on the worst case performance ratio[6].

Moreover, the authors proposed a Dynamic Greedy Algorithm (DGA) to solve DST-N problem [6] with a worst case performance ratio of two times from the optimum (i.e., a performance ratio of log

(|

Si

|)

), given a sequence with only add requests. Algorithm DGA below constructs the solution as follows:

1. T0

= ( {

^v0

} , ∅ ) ;

^S0

= {

^v0

}

^; 2. For eachrequestr_i, 1ⁱ^K

(a) Ifri is an add requestthen

i. LetPithe shortest path fromvi toTi−¹; ii. T_i

:=

^Ti−1

∪

^Pi;S_i

:=

^Si−1

∪ {

^vi

}

^; (b) Ifriis a remove requestthen

i. S_i

:=

^Si

\{

^vi

}

^;

ii. Untilthere is a nodev

∈ /

^Si with degree 1 inT_idoT_i

:=

^Ti

\

^v.

Fig. 1presents an example of the execution of the Algorithm DGA.Fig. 1(a) presents the considered network topology.

In this example, there is a ﬁrst request which adds the nodeaas a Steiner member (seeFig. 1(b)). A second request adds the nodeb as Steiner member, in this caseb is connected to a via a shortest path (bold line in Fig. 1(c)). There are two new requests to add ﬁrst nodec and then node das Steiner members connected via a shortest path (see Fig. 1(d) and (e) respectively) to b. Finally, there is a last request to remove the nodeb from the set of Steiner members (see Fig. 1(f)).

Note that, algorithm DGA do not modify the existing Steiner tree even if a better one can be constructed. Therefore, the algorithm ratio cannot be bounded, for the algorithm DGA when both add/remove operations are performed on the Steiner set.

Our distributed algorithm extends to distributed setting the idea of [6]for the case of “add” members. In order to bound the approximation ratio for the case when the Steiner nodes are removed, we extend the approach of[18] to the distributed setting. Aharoni and Cohen [18] builds on the idea of Imase and Waxman to construct a multicast tree in datagram networks. They consider both, add and remove requests and they propose a scalable algorithm which guarantees a worst case performance ratio of log

(|

^Si

|)

. The multicast tree is constructed as follows. To add a Steiner member x, x sends a request to the root in order to obtain the list Zi−¹ of Steiner members already in the tree (the request of xis theith request received by the root). The root sends the list toxand generates a new list Zi by addingx. Then,xselects the closest Steiner member y

∈

^Zi−1 fromx, and asks y to add the shortest path betweenxand y in the multicast tree.

This is achieved via a unicast protocol. This can introduce a local loops and destabilize the tree. The removal of a Steiner

(5)

Fig. 1.Steiner tree construction done by the on-line algorithm DGA, where the Steiner members are black nodes and Steiner tree edges are bold lines.

(a) Network topology, (b) conﬁguration after the ﬁrst requestr0=(a,add), (c) requestr1=(b,add)andbis connected toT0 via a shortest path, (d) requestr2=(c,add)andc is connected toT1via a shortest path, (e) request r3=(d,add)anddis connected to T2 via a shortest path, (f) request r4=(b,remove)andbis no more a Steiner member.

memberxrequires the rearrangement of the tree, otherwise the inapproximability result of Imase and Waxman holds[6].

Therefore,xinforms the root that it wants to leave the tree. The root removesxfrom the listZiof Steiner members. Then the root computes for each child u of x a list Z_i

(

u

)

of the Steiner members. Z_i

(

u

)

is obtained from Z_i from which any Steiner member descendant of u is removed. This new list, Zi

(

u

)

is sent to u for each u child of x. xcan leave the tree and every child uis connected to the tree by following the add procedure. A worst case performance ratio of log

(|

^Si

|)

^is guaranteed with both add/remove requests.

In the next section, we present the stabilizing algorithm we propose to construct a dynamic distributed Steiner tree based on both[6]and[18]ideas. For the add part, we use the Imase and Waxman[6]approach, while for the remove part we use the Aharoni and Cohen[18]approach.

4. Super-stabilizing distributed Steiner tree algorithmS3T

This section describes a stabilizing algorithm for the Steiner tree problem, calleds3t. It implements the technique proposed by Imase and Waxman presented in Section 3, in a stabilizing manner. In our implementation we assume a rooted network where the root is a special node chosen in the Steiner group. This node will also be the root of the constructed Steiner tree. The choice of the root is beyond the scope of the current paper. In the following we assume the system augmented with a leader oracle that returns to every node in the system its status: leader or follower. The single node that receives “leader” while invoking the leader oracle is the root and is allowed to execute the root code detailed in Sec- tion4.2.1. In the following, the root node is notedr. Several implementations for leader oracles fault-tolerant, stabilizing or dynamic can be found for example in[19–21].

Connection priority In the sequential on-line algorithm[6], Steiner members are connected via a shortest path following an order (deﬁned by the sequence of requests). However, in this paper we consider that the system can start in an arbitrary state and Steiner members may be connected in an erroneous manner. Therefore, we need some information to take into account the connection order of Steiner members to be able to design a fault-tolerant distributed algorithm which follows the approach proposed by Imase and Waxman. When a nodev becomes a Steiner member in the network (i.e.,

Member

_v equal to true), the nodevobtains also aconnection priorityto join the tree, given by the system and denoted by

Priority

_v. These priorities are unique and they are used by all the nodes to establish a connection to the Steiner tree. Hence, the connection request of a Steiner member a has a highest prioritythen a Steiner member b if

Priority

_a

< Priority

_b. However, when a Steiner member v is disconnected from the Steiner tree (because of faults or topology changes) then its priority is no more valid. If v reconnects then a new connection priority is obtained using

getPriority(

v

)

function. This function can be seen locally by each node as the invocation of an oracle which delivers an initial connection priority via

getPriority(

v

)

, that sets the priority variable. Note that, we consider the rootrhas the highest connection priority and we assume that the oracle delivers connection priorities in a monotonous way. That is, priorities are given following an increasing order.

To construct the Steiner tree, our algorithm is composed of two parts: (i) all shortest distances to Steiner members computation, and (ii) Steiner members connection.

In the former part, each node in the network (Steiner member or not) computes its shortest distance to every Steiner member in the network. Basically, distance values are propagated in the network from each Steiner member which is considered as the root of a distinct shortest path tree. Note that we need to maintain for each node the shortest distances to every Steiner member. Only maintaining the distance between each node to the root may not achieve a performance ratio of log

(

z

)

. That is, the resulting tree would be a Shortest Path tree rooted atr with a cost O

(

z

)

times the cost of an optimum solution (seeFig. 2for an example). Note that, the existing self-stabilizing solutions for this problem (e.g.,[22,9]) compute the shortest path between all-pairs of nodes and do not allow to restrict the computation to a subset of nodes as needed here to solve the approximate Steiner tree problem.

(6)

Fig. 2.A(z/2)-approximation ratio between a Shortest Path tree and an optimal Steiner tree. (a) Network topology withrthe root andzthe number of Steiner members (black nodes), (b) a Shortest path tree connecting every Steiner member torof cost(z−¹)z, (c) an optimal Steiner tree for the network given in (a) of costz−2+z=2(z−1).

In the latter part, only the nodes with correct distance values (with respect to their neighborhood) can participate to the connection of Steiner members. Each node has two status: connected (i.e., belongs to the Steiner tree) or not. Every non Steiner member node v which does not belong to the Steiner tree remains not connected. It waits the reception of a connection request initiated by a non connected Steiner member. Every Steiner member xwhich can participate to the second phase (if not already in the Steiner tree) can send a connection request to join the Steiner tree. It tries to be connected via the shortest path (computed by the ﬁrst part) to another Steiner member y with a priority value lower than x’s priority value. If the connection is accepted, then an acknowledgment is sent back on the shortest path, enabling the nodes to change their status to connected. An anomaly in the connection of the memberxis detected if one of the two following conditions is not satisﬁed:

1. x is connected to the closest Steiner member y part of the Steiner tree with a lower priority value than x(i.e., y’s priority is higher thanx’s priority),

2. all or some ancestors ofxin the Steiner tree maintain a connection request with a priority value equal or lower than the one maintained byx.

If the Steiner memberxor a node on the path used to connect xdoes not satisfy one of the above conditions, then it leaves the Steiner tree (i.e., its status becomes not connected). This initiates the remove of the path, in order to force the connection ofxvia a correct path (i.e., a path satisfying the above conditions). Obviously, this procedure is also executed if xis no more a Steiner member.

Our self-stabilizing algorithm, calleds3t, is a composition of two algorithms (Algorithms 1 and 2) used to construct the approximate Steiner tree. In Section 4.1, we present the ﬁrst part of the algorithm (associated toAlgorithm 1) dedicated to the computation of all shortest paths to Steiner members, then we present in Section 4.2the part dedicated to the connection of Steiner members (associated toAlgorithm 2).

4.1. All shortest paths to Steiner members

In this subsection, we are interested in the problem of constructing all shortest paths to every Steiner member from each processor of the network.Deﬁnition 2deﬁnes the sub-graph containing all these shortest paths.

Deﬁnition 2(All members shortest paths graph).LetG

= (

V

,

E

,

w

)

a weighted and undirected connected network and S

⊆

^V the set of Steiner members. A sub-graph G

= (

V_G

,

E_G

)

of G contains all shortest paths to every Steiner members from each node p

∈

^V if the following conditions are satisﬁed:

1. VG

=

^V ^and^EG

⊆

^E^{, and}

2.

∀

^x

∈

^S

,

G

[

^x

]

is a connected sub-graph (i.e., there exists a path inG

[

^x

]

between any pair of nodesu

,

v

∈

^VG) withG

[

^x

]

the union of paths between each v

∈

^VG andx, and

3. For each node p

∈

^VG, the path betweenpand every nodex

∈

^Sⁱⁿ^Gis a shortest path between pandxinG.

We give a formal speciﬁcation to the problem of computing all shortest paths to Steiner members, stated inSpeciﬁca- tion 1.

Speciﬁcation 1.LetCthe set of all possible conﬁgurations of the system. Let G

= (

V

,

E

,

w

)

a weighted graph and S

⊆

^{V the set} of Steiner members. A self-stabilizing algorithmA_ASP solving the problem of computing all shortest paths to every Steiner member satisﬁes the following conditions:

•

^AlgorithmA_ASPreaches a set of terminal conﬁgurationsT

⊆

Cin ﬁnite time, and

•

In every conﬁguration

γ ∈

T, there is a constructed the sub-graph which satisﬁesDeﬁnition2.

• γ _∈

_T, each node p

∈

V is aware of the priority Priority_xof every Steiner member x

∈

^S.

(7)

Table 2

Data structures for all member shortest distances computation for anyv∈^V.

Macros:

Card(list,ID) = |{^t∈^list:^t[⁰] =^ID}|

MinEltS(list,ID,S) = ^min{^t∈^list:^t[⁰] =^ID∧^t[⁴] =^S∧(∀^t∈^list::^t[⁰] =^t[⁰]

∧t[4] =t[4] ∧(t[2]t[2] ⇒(t[2] =t[2] ∧t[1]>t[1])))}

MinElt(list,ID) =

MinEltS(list,ID,BAD) IfMinEltS(list,ID,BAD)= ∅ MinEltS(list,ID,OK) Otherwise

MinDist(v,ID) = ^minu∈N(v){^t[²] +^w(u,v):t∈^list_distu∧^t[⁰] =^ID∧CNgInfo(v,list_distu,t)}

Update(v) = {^t∈^list_distu:u∈^N(v)∧^u=^NMinDist(v,t[⁰])∧BestPath(v,u,t)}

NeigMinDist(v,ID)= ^min{^u∈^N(v): (∃^t∈^list_distu::^t[⁰] =^ID

∧CNgInfo(v,list_distu,t)∧^t[²] +^w(u,v)=MinDist(v,ID))}

. . . . Predicates:

DelInfo(v,t) ≡ (Card(list_distv,t[⁰]) >1∧^t=MinElt(list_distv,t[⁰]))∨Del(v,t)

Del(v,t) ≡ t[4] =BAD∧(∀u∈N(v)::(∀t∈list_distu::t[0] =t[0] ∨t[3] =IDv∨t[2]t[2])) BadInfo(v,t) ≡ t[4] =O K∧ [(t[0] =IDv∧ ¬Memberv)∨ ¬CInfo(v,t)]

CInfo(v,t) ≡ ^t[⁰] =^IDv⇒(t[³] ∈^N(v)∧Card(list_distt[3],t[⁰])=¹

∧(∃^t∈^list_distt[3]::^t[⁰] =^t[⁰] ∧^t[¹] =^t[¹] ∧^t[²] +^w(t[³],^v)^t[²] ∧^t[⁴] =^t[⁴])) MemberInfo(v,t)≡ ^t[⁰] =ÎDv∧^t[¹] =Priority_v∧^t[²] =⁰∧^t[³] =ÎDv∧^t[⁴] =ÔK

CMemberInfo(v)≡ Card(list_distv,IDv)=¹∧(∃^t∈^list_dist^v::MemberInfo(v,t)) BetterPath(v) ≡ (∃u∈N(v)::(∃t∈list_distu::CNgInfo(v,list_distu,t)

∧(∀t∈list_distv::t[0] =t[0] ⇒(t[4] =OK∧t[2] +w(u,v) <t[2])))) CLocalDist(v) ≡ (Memberv⇒CMemberInfo(v))∧ ¬BetterPath(v)

∧(∀^t∈^list_distv:: ¬BadInfo(v,t)∧ ¬DelInfo(v,t)) CNgInfo(v,list,t)≡ ^t[³] =^IDv∧^t[⁴] =^OK∧Card(list,t[⁰])=¹

BestPath(v,u,t)≡ CNgInfo(v,list_distu,t)∧(∀^t∈^list_distv::^t[⁰] =^t[⁰] ∧^t[²] +^w(u,v)=MinDist(v,t[⁰]))

4.1.1. All members shortest paths algorithm

For any node v

∈

^V^, ^N

(

v

)

is the neighbors set of v in the network G (our algorithm is built upon an underlying self-stabilizing protocol that regularly updates the neighbor set of every node). For each node v, variable list_dist_v is a set which stores 5-uplets encoding information related to the distances between v

∈

^V and every Steiner memberx

∈

^S

⊆

^V^. Every uplet is composed of ﬁve ﬁelds:

•

the identiﬁer of a Steiner memberx

∈

^S (whose the uplet is related),

•

connection priority given to the Steiner memberx(deﬁned by

Priority

_x),

•

the shortest distance between v and the Steiner memberx,

•

the identiﬁer of the neighbor which has propagated the distance tox,

•

the status of the uplet to notice if the distance in the uplet can be considered or not, i.e., in statusOKor BAD respectively.

In the following, we use the notationt

[

ⁱ

]

^{, 0}ⁱ4, to denote thei-th ﬁeld of a 5-uplett in variable list_dist_v.

Correct uplets An uplet t

∈

^list_distv iscorrect at v if: (i) there is no other uplet related to the same Steiner member x (given byt

[

⁰

]

) in list_distv, and (ii) one of the following cases is veriﬁed:

•

^if^t is related to v (i.e.,t

[

⁰

] =

^IDv) then v must be a Steiner member andt

= [

^IDv

, Priority

_v

,

0

,

ID_v

,

OK

]

^(veriﬁed using Predicate

CMemberInfo(

v

)

),

•

^if^t is related to Steiner memberx

=

^v then in this case the following conditions must be satisﬁed:

1. there is a neighboruofvwhich maintains an uplet with a smaller distance and equal value on other ﬁelds (veriﬁed using Predicates

BadInfo(

v

,

t

)

and

CInfo(

v

,

t

)

), and

2. there is no shorter path towards xthan the one stored in list_distv (i.e., Predicate

BetterPath(

v

)

is not satisﬁed atv) propagated by another neighbor thant

[

³

]

^.

When all the uplets maintained in the network are correct, then for each uplett

∈

^list_distv at node v the ﬁeldt

[

²

]

^gives the distance of the shortest path to the related Steiner member (given byt

[

⁰

]

). Moreover, the ﬁeldt

[

³

]

stores the identiﬁer of a neighbor of v on the shortest path towards this Steiner member (which allows to determine this path). Additionally, the ﬁeld t

[

¹

]

indicates the connection priority associated to the Steiner membert

[

⁰

]

. These ﬁelds are used by the second part of the algorithm.

To maintain up to date its shortest path to every Steiner member, each nodev executes RuleDR^{(given in}Algorithm 1 andTable 2) to modify its variable list_distv if needed. Indeed, if there is an uplet t

∈

^list_distv at v which is not correct,

(8)

Algorithm 1All member shortest distances computation for anyv

∈

^V^.

Inputs:N(v): set of (locally) ordered neighbors ofv;

IDv: unique identiﬁer of nodev;

Memberv: boolean to true ifvis a Steiner member, false otherwise;

Priority_v: integer indicating the connection priority given tov;

Variable:list_distv: set of shortest distances leading to Steiner members;

. . . . FunctionMembersDistCompute(v)

{

If(∃^t∈^list_distv::DelInfo(v,t))

thenlist_distv:=^list_dist^v\{^t∈^list_dist^v:DelInfo(v,t)}^; If (∃t∈list_distv::BadInfo(v,t))

thenlist_distv:=^list_distv∪ {[^t[⁰],^t[¹],^t[²],^t[³],^BAD] :^t∈^list_distv∧BadInfo(v,t)};^list_distv:=^list_distv\{^t∈^list_distv:BadInfo(v,t)}^; If Member_v∧ ¬CMemberInfo(v)

thenlist_distv:=^list_dist^v\{^t∈^list_dist^v:^t[⁰] =^ID^v}^; list_distv:=list_distv∪ {[IDv,Priorityv,0,IDv,OK]}; If BetterPath(v)

thenlist_distv:=^list_distv\{^t∈^list_distv:^t[³] ∈^N(v)∧^t[⁴] =^OK∧^t[²]>MinDist(v,t[⁰])}^;

list_distv:=^list_distv∪ {[^t[⁰],^t[¹],^t[²] +^w(NMinDist(v,t[⁰]),^v),NMinDist(v,t[⁰]),^OK] :^t∈Update(v)}^; }

. . . . Algorithm:

DR:(All shortest member distances) If¬CLocalDist(v)

thenMembersDistCompute(v);

then Predicate

CLocalDist(

v

)

is not satisfied and Rule DRis enabled. However, the set of all Steiner members is not known in advance and a mechanism to delete incorrect uplets is necessary. It is not sufficient to only delete an incorrect uplet detected at a node v, this uplet must be removed from the network otherwise it can be propagated forever. To this end, the fifth field is used to notify that an uplet is incorrect (with Status BAD) before its deletion, otherwise an uplet has StatusOK.

The action of RuleDR is to execute FunctionMemberDistCompute

(

v

)

whose goal is to update variable list_dist_v. This function is composed of four parts: the ﬁrst one to remove 5-uplets, the second one to change the status of 5-uplets from OK to BAD, the third one to manage 5-uplets related to v in case v is a Steiner member, and the last one to add new 5-uplets related to better paths to reach Steiner members.

First of all, the execution of FunctionMemberDistCompute

(

v

)

removes a 5-uplett iftrelates no information on a shortest path for any Steiner member, or t has Status BAD and v is not referred as the source of a 5-uplet related to t by a neighbor u(i.e., 5-upletst satisfying Predicate

DelInfo(

v

,

t

)

). Note that, if there are several 5-uplets related to a Steiner member in list_distv, then they are also removed except the only one given by Macro

MinElt

. This macro selects among all uplets associated to the same Steiner member the uplet x with Status BAD to force its deletion (if there is one, OK otherwise), which has the shortest distance (and smallest connection priority, if several). The status OK of any 5-uplett is changed to BAD if neither v is the source nor a neighbor of v has propagated the 5-uplet associated to the Steiner member of t, or the distance or the status are not correct (i.e., 5-uplets t satisfying Predicate

BadInfo(

v

,

t

)

). Indeed before the removal of an uplet t by a node v, it has to verify that no other node has propagated t. To this end, the status of uplets is used to make this veriﬁcation and to propagate the deletion. When the status of an uplet is changed fromOKto BAD by a node, this modiﬁcation is propagated down on the propagation path. Thus, each node v can remove an uplet t

∈

^list_distv with Status BAD when v has no neighbor u with an uplet related to t (see Predicate

Del (

v

,

t

)

).

Note that a cycle in a propagation path of an uplet t is detected using the uplets distance. Finally, variable list_dist_v is modiﬁed to maintain a single 5-uplet associated to v (in case v is a Steiner member) and to also maintain information related to a shortest path for each Steiner member (i.e., Predicates

CMemberInfo(

v

)

and

BetterPath(

v

)

are satisﬁed respectively).

Remarks.Variable list_distv is used to store a dynamic set of uplets whose size can be arbitrary high because of the initial conﬁguration of the system. Therefore, we consider that each node has a memory with a bounded size. More precisely, we assume a bound of O

(

Zlog

(

N

))

bits at each node, with Z an upper bound on the number of Steiner members and N an upper bound on the size of the network. Since each uplet uses O

(

log

(

N

))

bits, each node has to maintain at most one uplet related to the shortest path towards every Steiner members. Therefore, a node can add a better path towards a Steiner memberxif it has no uplet related toxor an uplet in StatusOKwith a higher distance.

(9)

4.2. Steiner tree construction

In this subsection, we are interested in the problem of constructing an approximate Steiner tree. We assume there are a designated processor, notedr, and a dynamic set of Steiner members S

⊆

^V in a weighted and undirected connected network G

= (

V

,

E

,

w

)

. We consider the construction of a treeT rooted atrspanning all nodes inS. Moreover, we expect the weight of T is at most log

( |

^S

| )

times the weight of an optimal solution. We can deﬁne this sub-graph as inDeﬁnition 3.

Deﬁnition 3(Approximate Steiner tree).LetG

= (

V

,

E

,

w

)

a weighted and undirected connected network with a designated node r and a set S

⊆

^V of Steiner members. A sub-graph T

= (

V_T

,

E_T

)

of G is called an approximate Steiner treeif the following conditions are satisﬁed:

1. S

⊆

^VT

⊆

^V ^and^ET

⊆

^{E, and}

2. T is a connected and acyclic sub-graph (i.e., there exists a single path inT between any pair of nodes x

,

y

∈

^VT), and 3. for every Steiner memberx

∈

^S (except the rootr), the shortest path inG betweenxand the closest Steiner member

y

∈

^Sx toxis contained in T, withSx

⊆

^S ^{such that}

∀

^z

∈

^S,^z

∈

^Sx if we have

Priority

_z

< Priority

_x.

We give a formal speciﬁcation to the problem of constructing an approximate Steiner tree, stated inSpeciﬁcation 2.

Speciﬁcation 2.LetCthe set of all possible conﬁgurations of the system. Let G

= (

V

,

E

,

w

)

a weighted and undirected graph with a designated node r and a set S

⊆

V of Steiner members. A self-stabilizing algorithmA_ST solving the problem of constructing an approximate Steiner tree satisﬁes the following conditions:

•

^AlgorithmA_ST reaches a set of terminal conﬁgurationsT

⊆

Cin ﬁnite time, and

• γ _∈

_T, there is a constructed sub-graph T which satisﬁesDeﬁnition3and whose weight W

(

T

)

is at most equal to log

( |

^S

| ) ×

^W

(

T^∗

)

, with W

(

H

) =

e∈Hw

(

e

)

and W

(

T^∗

)

the weight of an optimal Steiner tree T^∗in G.

4.2.1. Steiner members connection algorithm

In this subsection, we explain the way all Steiner members are connected in order to construct the Steiner tree. A formal description of the second part of our algorithm is given in Algorithm 2andTable 3. Each node v

∈

^V has several inputs:

(i)

IsRoot (

v

)

indicates tov if it is the rootr or not (input from the leader oracle), (ii)

Member

_v is equal to true ifv is a Steiner member and in this case (iii)

Priority

_v gives the connection priority ofv, ﬁnally (iv) list_distv gives tov a set of shortest distance to each Steiner member (computed by Algorithm 1). In the following, we consider that for each node v

∈

^V the information maintained in variable list_distv are locally correct with respect to the neighbors of v(i.e., Predicate

CLocalDist(

v

)

is satisﬁed), otherwise the rules given inAlgorithm 2are not enabled at v.

Variables Every nodev maintains six variables for constructing and maintaining the approximate Steiner tree.

•

^pv: identiﬁer of the parent of node v in the current tree;

•

^Lv: (Level) number of nodes on the path between the root r and v in the approximate Steiner tree, 0 if v is not connected;

• need

_v:trueifvis a Steiner member (i.e.,v

∈

^S

⊆

^V^{) or}^v has a connection request from a descendant,falseotherwise;

• connect

_v:trueifvis connected (i.e., belongs to the Steiner tree),falseotherwise;

• memb_connect

_v: identiﬁer of a Steiner member to whichv must be connected,

⊥

^otherwise;

• color

_v: the lowest priority among Steiner members descendant of v in the Steiner tree (including v’s priority if v is a Steiner member),

⊥

^otherwise.

Description of the algorithm Every nodev

∈

^V sends periodically its local variables to each of its neighbors using

InfoMsg

messages. Upon the reception of this message each neighbor updates the local copy of its neighbor variables. The description of an

InfoMsg

message is as follows:

InfoMsg

_v

[

^u

] = InfoMsg,

list_dist_v

,

p_v

,

L_v

, need

_v

, connect

_v

, memb_connect

_v

, color

_v

. Moreover, upon the reception of an

InfoMsg

message each node corrects its local state by executing several rules (given inAlgorithms 1 and 2) and then broadcasts its new local state in its neighborhood.

Root of the Steiner tree We assume that each node v can check if it is the root of the Steiner tree using an oracle (e.g., a leader election algorithm) whose response is given by

IsRoot

_v. Thus, according to the description of the oracle only a unique node can be the leader, i.e., the rootr. In a correct state (deﬁned by Predicate

CRoot(

r

)

), the rootrhas no parent and a level equal to zero (i.e., p_r

=

^IDr and Lr

=

0). Moreover, variables

need

_r and

connect

_r are equal totruesince we consider ris always connected (it always belongs to the Steiner tree). The root rhas no connection request to send, thus variable

memb_connect

_rmust be equal to IDr. Finally,r has always the smallest connection priority value among Steiner members given by

Priority

_r (we assume that r is the member registered by the system before the other ones) and

color

_r

= Priority

_r. Whenever the state of the root is not correct (i.e., Predicate

CRoot(

r

)

is not satisﬁed), then Rule RR can be executed (only) byr.