Solving the SDP for One Component Efficiently

After outlining all of the pruning and fixing methods, one part of the algorithm for solving the SDP for one component is still missing: the procedure to execute these methods. As already discussed, we can expect to have to calculate PN^d_s,tand FN^d_s,t for extended component graphs with the same start and end nodes for different delay values. This means that is is possible (and effective) to use previous results as bounds for the current domain request. Algorithm 9.2 shows how this works in detail.

Algorithm 9.2:Calculating PN^d_s,tand FN^d_s,tfor one component

Input : Extended component graphG_c, source nodes, target nodet, delay limitdand domain store Domains

Output: PN^d_s,tand FN^d_s,tofG

1 PosNodes pn,FixNodes fn;

// calculate pn (=PN^d_s,t)

2 ifDomains.hasPosNodes(s,t,d)then pn=Domains.getPosNodes(s,t,d) else

3 PosNodes pnUB=Domains.getPosUB(s,t,d);

4 PosNodes pnLB=Domains.getPosLB(s,t,d);

5 ifpnUB==pnLBthenpn=pnUBelse

6 PosNodes pnToTest=pnUB∧(¬pnLB);// bit-vector operations

7 prune(s,t,d,pnToTest);// call one of the pruning methods

8 pn=pnLB∨pnToTest;

9 end

10 end

// calculate fn (=FN^d_s,t)

11 ifDomains.hasFixNodes(s,t,d)then fn=Domains.getFixNodes(s,t,d) else

12 FixNodes fnUB=Domains.getFixUB(s,t,d);

13 FixNodes fnLB=Domains.getFixLB(s,t,d);

14 iffnUB==fnLBthenfn=fnUBelse

15 RestrictGraph Gr=restrict(G_c,pn);

16 FixNodes fnToTest=pn∧fnLB∧(¬fnUB);

17 fix(s,t,d,fnToTest,Gr);// call one of the fixing methods

18 fn=fnUB∨fnToTest;

19 end

20 end

// store calculated domains, return

21 Domains.setPosDomain(s,t,d,pn);

22 Domains.setFixDomain(s,t,d,fn);

23 Domains.simplify(s,t,d);

24 returnpn,fn;

The input of the preprocessing algorithm for a component cis the extended component graph Gc, the data for the required connection (source and target nodes, maximum allowed delay) and the store for previously calculated PN^d_s,tand FN^d_s,twithin this component.

The first step of the algorithm is calculating PN^d_s,t. If PN^d_s,t is already present in the domain store, then there is nothing more to do. Otherwise, we use the results of previous calls as upper and lower bounds. The upper bound is a previously calculated PN^d_s,t⁰ withd⁰ > dbut as small as possible. If no such domain has been calculated before, then it isV_c. Obviously, if there is no simple path using a node withind⁰, then there will be none withind, so PN^d_s,tis a subset of PN^d_s,t⁰. Similarly, we try to find a lower bound PN^d_s,t⁰⁰ withd⁰⁰ < dbut as large as possible. If no such domain has been calculated, then it is the empty set. If there is a simple path using a node within d⁰⁰, then this path is of course still valid with delay boundd, so all nodes in PN^d_s,t⁰⁰also belong to PN^d_s,t. If the upper and lower bounds are equal, then we already know PN^d_s,t and nothing more needs to be done. Otherwise, the nodes that are included in PN^d_s,t⁰ , but not in PN^d_s,t⁰⁰, are the ones we still need to test whether they belong to PN^d_s,t, which is stated in line 6. Note that we assume a bit-vector representation of the domains, so we can apply bit-wise logical operators. After determining which nodes need to be tested, we apply one of the pruning methods discussed previously. The pruning method will remove all nodes from the nodes to test that do not belong to PN^d_s,t. It is free to ignore the input about nodes to test. The Path Enumeration method for instance cannot use it, the All Pair Shortest Path method on the other hand can and does use it. The final PN^d_s,tis then assembled from the lower bound and the nodes that have passed the pruning.

The second step of the algorithm determines FN^d_s,t. It works basically the same way as the first step. One thing to note here is that the term upper bound still refers to a domain that was derived by allowing more delay and lower bound refers to a domain where less delay was allowed. The result is that for fixed nodes, the upper bound will contain fewer nodes than the lower bound.

In case no suitable upper or lower bounds have been calculated, the upper bound will be the empty set and the lower boundVc. For calculating the nodes for which we have to test whether they belong to FN^d_s,t (line 16), that means we have to test all nodes that belong to PN^d_s,t and are present in lower bound, but not in the upper bound. The restriction to PN^d_s,t is especially useful at the beginning when no suitable lower bound is known. One of the discussed fixing methods is then called with the nodes to test and removes all nodes that do not belong to FN^d_s,t. As an additional input, the fixing method gets the extended component graph, restricted by the possible nodes. This for instance increases the efficiency of path calculations, because parts of the extended component graph are removed.

The last step of the algorithm is storing the calculated domains in the domain store, followed by a simplification step. The main idea here is that it is not necessary to store all calculated domains, because a lot of them will be the same. It is sufficient to store the same domain only twice; for the lowest and the highest delay for which this domain occurred. As a consequence, the memory requirements for storing domains can be reduced. On the other hand, the probability of finding exactly the requested domain already present in the domain store is decreased, but we will still get the same upper and lower bounds and save execution time that way.

1

2

3

4 1

3

1

3

1 1

Figure 9.10: FN^d_s,tcan change without PN^d_s,tchanging.

As an implementation remark, note that PN^d_s,t and FN^d_s,t are stored completely independently from each other, because changing delays can add or remove nodes from one without affecting the other. It is easy to see that changing delay may change PN^d_s,twithout changing FN^d_s,t. Just think about a graph without fixed nodes where increasing the delay bound might add nodes to PN^d_s,t. The other direction is also possible, Figure 9.10 shows an example. For simplicity reasons we omitted the nodes for every arc. It holds that PN⁵_1,4 = PN⁶_1,4 = {1,2,3,4}, but FN⁵_1,4 ={1,2,4}and FN⁶_1,4 ={1,4}. The main insight here is that even with perfect pruning, the resulting graph can contain delay-infeasible paths. This means that an incomplete fixing method that does not take delays into account applied to a pruned extended component graph derived by a complete pruning algorithm will still be incomplete. In this example, the fixing method cannot distinguish the situations for delay5and6.