Next-hop Policy Routing

Next-hop Policy Routing

CPSC 455/555

1/24/2006

General Policy Routing Problem• Biconnected directed

network• Destination• Users input a utility

for every allowed path• Mechanism outputs

utility-maximizing directed tree (arborescence)

• Mechanism outputs incentive payments

• G = (N,E)

• j N

• ui : Sij R0

Sij allowed ij paths

• g : u Tj

Tj all j-rooted treesg = argmaxTTjiui(Tij)

Tij the ij path in T

• p : u Rn

General Policy Routing Problems• Computing g alone is NP-hard

– Approximating to within an n1/4- factor is NP-hard

– If NPZPP, there is no poly-time algorithm that approximates to with an n1/2- factor

• There are potentially exponentially many paths for which an agent wishes to express a utility

• In practice, we don’t expect an agent’s preferences to require the expressiveness of this model.

Next-hop Preferences• Restrict utility functions to depend only on next

hopui(ui1

,…,uik, j) = ui(ui1

)• Models different roles of connected Autonomous

Systems– Customer– Peer– Provider

• AS may reasonably be most concerned about next hop– AS controls next hop– AS has firsthand performance observations

Next-hop Policy Routing Problem• Biconnected directed

network• Destination• Users input a utility

for every neighbor• Mechanism outputs

utility-maximizing directed tree (arborescence)

• Mechanism outputs incentive payments

• G = (N,E)

• j N

• wi : +(ui) R0

• g : w Tj

Tj all j-rooted treesg = argmaxTTj

w(T)

w(T) = (ui,uk)Twi(uk)

• p : w Rn

Lemma 1: Computing the next-hop policy routing output is equivalent to computing the maximum weight directed spanning tree rooted at j.

Proof: The weight of any output T cannot be decreased by connecting any nodes that are not in T, since utilities are nonnegative. Therefore we can restrict our attention to such outputs. By definition, the output must be of maximum weight.

Next-hop Output

Corollary 1: Computing the next-hop policy routing output is equivalent to computing the minimum weight directed spanning tree rooted at j.

Proof: Let M=maxeEw(e). Reweight the edges with w’(e) = M-w(e). Then w’(T) = (n-1)M – w(T)so the maximum weight tree under w is the minimum weight tree under w’.

Next-hop Output

Next-hop Payment• We know VCG payments must be of the

formpi = ki wk(T*) + hi(w-i)

• We normalize this by setting leaves in the output tree to receive payment zero. Let T-i

be the max weight arborescence of N-i. pi = ki wk(T*) - w(T-i) = w(T*) – wi(T*) - w(T-i)

• Payment can be computed in polynomial time with (n-1) max weight arborescence calculations.

MDST Mechanism Summary

Can we implement this in a BGP-like mechanism?

Users input edge utilities

wi : +(ui) R0Number of preference values is |E|

Mechanism outputs utility-maximizing arborescence

g : w Tj

g(w) = argmaxTTjw(T)

Poly-time computable with distributed MDST algorithm

Mechanism outputs incentive payments

p : w Rn

p(w) =

w(T*)-wi(T*)-w(T-i)

(n-1) additional applications of MDST algorithm

Proving Hardness for “BGP-based” Routing Algorithms

Requirements for routing to any destination :[P1] Each AS uses O(l) space for a route of length l.[P2] The routes converge in O(log n) stages.

[P3] Most changes should not have to be broadcast to most nodes. Formally, there are only o(n) nodes that can trigger (n) updates when they fail or change valuation.

• For “Internet-like” graphs: O(1) average degree O(log n) diameter, even after removing a node

• For an open set of preference values

Hardness results must hold:

LCP Routing is BGP-basedTheorem: Assume all node costs are in [1,r], for r =

polylog(n). Then the FPSS mechanism for lowest-cost routing is BGP-based.

Proof:[P1] Each AS uses O(l) space for a route of length l.FPSS algorithm only adds a price and cost per node.

[P2] The routes converge in O(log n) stages.Let d longest LCP and d’ be the longest k avoiding path. These are at most an r factor times the diameter of the network. The algorithm converges in max(d,d’).

Proof cont’d:

[P3] There are only o(n) nodes that can trigger (n) updates when they fail or change valuation.

For a given destination, the paths of each node can be affected by the failures of at most dd’ other nodes. Thus the number of nodes that need updating upon failure summed over all nodes is O(ndd’) = O(n·polylog(n)). If (n) nodes could trigger (n) updates this would be (n2).

The same argument holds for cost changes, since they do not trigger path changes in an open set.

LCP Routing is BGP-based

O(dd’)

O(ndd’)

Long Convergence Time of MDST

1

1

1 1 1 1 1

2 2 2 2

•MDST has a path of length(n+1)/2 + lg(n) = (n).

• BGP routes in a hop-by-hop manner (n) stages required for convergence.• Internet-like graph•Max weighted tree invariant when weights are perturbed by < 1/2

Theorem 1: An algorithm for the MDST mechanism cannot satisfy property [P2].

Proof sketch:

Extensive Dynamic Communication of MDST

Theorem 2: A distributed algorithm for the MDST mechanism cannot satisfy property [P3].

Proof sketch:

(i) Construct a network and valuations such that for (n) nodes i, T-i is disjoint from the MDST T*.

(ii) A change in the valuation of any node uk of its edge in T* will change

pi = w(T*) – wi(T*) – w(T-i).

(iii) Node ui (or whichever node stores pi) must receive an update when this change happens. (n) nodes can each trigger (n) update

messages.

Network Construction (1)

(a) Construct 1-cluster with two nodes:

B R

1-cluster

redport

blueport

(b) Recursively construct (k+1)-clusters:

blueport

redport

L-1

L-1

B R B R

k-cluster k-cluster

(k+1)-cluster

L- 2k -1

L- 2k -1

L 2 lg n + 4

Network Construction (2)(c) Top level: m-cluster with n = 2m + 1 nodes.

B R

m-clusterL- 2m -1 L- 2m -2

jDestination

Final network (m = 3):

redport

blueport

B R9

9B R

9

97

79

9

9

9

7

j

B R B R

5

35

2

Network Construction (2)

(c) Top level: m-cluster with n = 2m + 1 nodes.

B R

m-clusterL- 2m -1 L- 2m -2

jDestination

Final network (m = 3):

redport

blueport

B R9

9B R

9

97

79

9

9

9

7

j

B R B R

5

35

2

blue j-tree

Network Construction (2)

(c) Top level: m-cluster with n = 2m + 1 nodes.

B R

m-clusterL- 2m -1 L- 2m -2

jDestination

Final network (m = 3):

redport

blueport

B R9

9B R

9

97

79

9

9

9

7

j

B R B R

5

35

2

blue j-tree red j-tree

Optimal Spanning Trees Lemma 2:

w(blue tree) = w(red tree) + 1 w(any other j-tree) + 2

Proof: The equality follows from an easy inductive argument.For the inequality, let T be any other j-tree. T must have

red and blue edges. Every cluster has exactly one blue edge and one red edge that connects to a node outside the cluster.

If only one of these edges appears in T, say, the blue edge, then one of the following must be true:

1. All the edges of T within the cluster are blue2. The cluster contains a smaller cluster with both red

and blue outgoing edges.

Therefore at least one cluster must have a red outgoing edge and a blue outgoing edge in T.

Optimal Spanning TreesProof cont’d: Consider the smallest cluster with a red outgoing edge and a blue outgoing edge. Let it be a (k+1)-cluster. We can use this cluster to increase the spanning tree weight by 2, contradicting its maximality.

B

B R

k-cluster k-cluster

(k+1)-cluster

L- 2k -3L- 2k -3

B

k-cluster k-cluster

(k+1)-cluster

L- 2k -1L- 2k -3

Proof of Theorem 2

B R

9

9B R

9

97

79

9

9

9

7

j

B R B R

5

35

2

• MDST T* is the blue spanning tree.• For any blue node B, T-B is the red spanning tree on N – {B}.

• A small change in any edge, red or blue, changes

Any change triggers update messages to all blue nodes!

p B = W(T*) – uB(T*) – W(T-B)

Summary

• General preferences computationally intractable

• Next-hop preferences are reasonable and computable

• Routing protocol should have BGP properties on Internet-like graphs

• A next-hop mechanism (MDST) cannot be computed via a BGP-like protocol.