Incentive-Compatible Interdomain Routing

1. Incentive-Compatible Interdomain Routing Michael Berger Based on the article: “Incentive-Compatible Interdomain Routing” Joan Feigenbaum, Christos Papadimitriou, Rahul Sami, Scott Shenker

2. Preliminaries • Data on the Internet has to be conveyed from many sources to many targets. • Routing - Conveyance of the data through the different routes. • AS = Autonomous System = A Sub-network that serves as a mid-point for the conveyance routes. A.K.A Domain.

3. Our Goal • To convey all data on the Internet in the most efficient way. • Problem:To know the most efficient way, we must know the true efficiencies of the AS’s.But every AS has an owner, and the owners are human!

4. Definitions • Traffic - Quantity of packets that are transmitted throughout the network. • Cost - For every AS, it is the additional load imposed on its internal network by carrying traffic. • Transit Traffic - For every AS, it is the traffic which neither originates nor is destined to that AS. • Price - A compensation which is paid for every AS for carrying transit traffic. • LCP = Lowest-Cost Path (between any two AS’s).

5. Our Goal - More Formally • To convey all data on the network s.t. the total costs are minimized. • High efficiency = Low total costs • Problem:To do that, we must know the true costs of the AS’s.But every AS might be lying about its costs!

6. Model - General Assumptions (I) • AS’s are unitary strategic agents. • There is no centralized authority that controls the network, whom the AS’s can trust. • There exists a protocol that, given a set of AS costs, can compute all LCPs.

7. Model - General Assumptions (II) • Cost per-packet is constant. • BGP (Border Gateway Protocol) is a suitable protocol that finds and uses LCPs. • In reality, BGP doesn’t find LCPs, but shortest paths (in terms of number of hops). • In reality, BGP doesn’t always use LCPs, but also employs routing by policy and transit restrictions.

8. Our Goal - According to Model • Devise a pricing scheme for the AS’s s.t. they would have no incentive to lie about their transit costs. • Must be strategy-proof. • Additional Requirement: The pricing scheme would give no payments to AS’s that carry no transit traffic. • Provide a distributed algorithm for the AS’s that is “BGP-friendly”, to compute the above prices.

9. Part I:Pricing Scheme

10. Definitions • N - set of nodes (AS’s) on the network.n = |N| • L - set of links between nodes of N. • G - the AS graph (N - vertices, L - edges). • Tij - For any two nodes i, j  N, it is the intensity of traffic (number of packets) originating from i destined to j. • ck - the transit cost of node k for each transit packet it carries.c-k = (c1, ..., ck-1, ck+1, ..., cn) • pk - the payment which will be given to node k to compensate it for carrying transit traffic.

11. Specific Assumptions • Between every two nodes there is at most one link. • Allows us to represent network as graph G. • Every link is bi-directional. • Allows G to be undirected. • G is 2-connected. • The transit cost of a node k is the same for all neighbors of k from which the traffic arrives. • Allows us to define ck.

12. More Definitions • Ik(c;i,j) - Indicator function for the LCP from i to j. Ik(c;i,j) = 1 if node k is an intermediate node on the LCP from i to j. Ik(c;i,j) = 0 otherwise. • Note: Ii(c;i,j) = Ij(c;i,j) = 0. • V(c) - Total cost of routing all packets on LCPs.

13. Formulation of Goal • Minimize V(c). • Problem:If nodes report false costs, BGP might end up computing different (false) LCPs. • Let c* be the reported cost vector. Then, by definition of Ik:

14. k’s profits k’s revenues k’s costs Mechanism Design Problem • Purpose: Minimize V(c) (objective function) by making nodes reveal true costs. • Input: <G, c> • c is vector of reported costs, or strategies. The strategy ck of node k is the cost that it reports. • Output: Set of LCPs and prices. • For any given vector c we require:

15. welfare that world receives from k’s existence per packet from i to j cost of all nodes per packet from i to j if k didn’t exist cost of all nodes per packet from i to j when k exists k’s costs per packet from i to j Mechanism Design Solution • Theorem:When routing picks lowest-cost paths and the network is 2-connected, there is a unique strategy-proof pricing mechanism that gives no payment to nodes that carry no transit traffic. The payments are of the form:

16. Proof of Theorem (I) • Let uk(c) denote the total costs incurred by a node for the cost vector c. • We have already seen that (Ik(c;i,j))k N minimizes V(c). • We can build a VCG mechanism!

17. Proof of Theorem (II) • A known fact - payments must be expressible as:

18. Proof of Theorem (III)

19. Notes on Pricing • Payments are a sum of per-packet payments that don’t depend on the traffic matrix. • Payments are zero if LCP between i and j doesn’t traverse k. Therefore, payments can be computed at k by counting the packets as they enter k (after pricing has been determined). • Costs do not depend on the source and destination of packets, but prices do. • Payment to node k for a packet from i to j is determined by the cost of the LCP and the cost of the lowest-cost path that doesn’t pass through k.

20. Part II:Distributed Algorithm(for computing prices)

21. Substrate - BGP (I) • d - Diameter of network, i.e. the maximum number of AS’s in an LCP (not the diameter of G). • Every node i stores, for each AS j, the LCP from i to j (vector of AS ID’s). Each LCP is also described by its total transit cost (sum of costs of transit nodes). • Every node stores O(nd) AS numbers and O(n) path costs. • Routing Table - the above information stored in node i.

22. Substrate - BGP (II) • “BGP” Algorithm:for each node i (concurrently) { while (1) { Receive routing tables from all neighbors that have sent them; Compute own routing table; if (change detected) { Send routing tables to all neighbors; } }} • Stage - every while iteration. • For every node i, a change can occur because: • A neighbor’s routing table has changed. • A link of i was added or removed.

23. BGP - Specific Assumptions • Same assumptions as before. • G is an undirected, 2-connected graph. • Router table contains total costs of LCPs. • All nodes compute and exchange tables concurrently. • Frequency of communication is limited by need for keeping network traffic low. • Local computation is not a bottleneck. • When there is more than one LCP to choose from, BGP makes the choice in a loop-free manner. • Explained below. • Static environment - no changes in links.

24. BGP - Performance • Storage requirement on each node - O(nd) (size of router table). • Number of operations complexity - Measured by number of stages required for convergence and total communication. • Computation of all LCPs within d stages. • Each stage involves O(nd) communication on any link (size of router table). • For node i, total communication in a single stage is O(nd * degree(i)).

25. Loop-Free BGP • BGP builds the LCPs in a manner that satisfies the following:For every node j, the sub-graph of G containing all the LCPs from j to other nodes in G, is a tree. • Contrary example: j 5 5 k 2 i

26. Goal - Computation Algorithm • Input: cost vector c where ci is known only to node i. • Output: set of prices, with node i knowing all the values. • Substrate: BGP, receiving <G, c> as distributed input, and giving LCPs as distributed output. • Complexity: Around O(nd) storage requirements on each node, around d stages of communication, around O(nd * degree(i)) data communicated by node i in each stage.

27. Yet More Definitions • P(c;i,j) - LCP from i to j for the vector of declared costs c (the inner nodes). • c(i,j) - The cost of the above path. • k-avoiding path - Any path that doesn’t pass through k. • P-k(c;i,j) - The lowest-cost k-avoiding path from i to j. • T(j) - The tree of all LCPs for node j.

28. Upper Bounds for Prices(I) • Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ? • Reminder: • Case I: a is i’s parent in T(j), a isn’t k. j k a i

29. Upper Bounds for Prices (II) • Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ? • Reminder: • CaseII: a is i’s child in T(j). j k i a

30. Upper Bounds for Prices (III) • Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ? • Reminder: • Case III: a isn’t adjacent to i in T(j), and k is on P(c;a,j). j k d a i

31. Upper Bounds for Prices (IV) • Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ? • Reminder: • Case IV: a isn’t adjacent to i in T(j), and k isn’t on P(c;a,j). j d k a i

32. Upper Bounds for Prices (V) • Question: For kP(c;i,j), given that i and a are neighbors in G and given , what is ? • Other Cases: • a is i’s parent in T(j), a =k. • a is i’s descendant in T(j), but not its child. • a is i’s ancestor in T(j), but not its parent. • In all the above cases, P-k(c;i,j) will not be (a, P-k(c;a,j)).

33. Exact Prices (I) • b - The neighbor of i on P-k(c;i,j). • Lemma:For b, the previous four inequalities attain equality.Case I:Case II:Case III:Case IV:

34. Exact Prices (II) • Proof: • b falls into one of the four cases. • From definition of P-k(c;i,j), there is no undercutting shorter k-avoiding path (no other “blue” path). • Consequence:From the inequalities of cases (I) - (IV) and from the Lemma, we can deduce that:is exactly equal to the minimum, over all neighbors a of i, of the right-hand side of the corresponding inequality !!!

35. Price Computation Algorithm (I) • Data:In each node i, for each destination node j: • LCP from i to j (after running BGP), i.e.:P(c;i,j) = (i = vk, vk-1, …, v0 = j) • Array of prices in LCP, i.e.: • Cost of LCP, i.e. c(i,j). • Assumptions: • Same assumptions as before for BGP. • Each node i knows for each destination node j and each neighbor a, whether a is its parent, child or neither in T(j).

36. Price Computation Algorithm (II) • Initialization: Run BGP(); for each node i (concurrently) { for each destination node j { Set all entries in array P(c;i,j) to ; Set entries in array P(c;i,j) to 0; } Send all arrays P(c;i,j) to neighbors; }

37. Case I Case II Case III Case IV Price Computation Algorithm (III) while (1) { for each destination node j { if (received array P(c;a,j) from neighbor a) { if (a is i’s parent in T(j)) else if (a is i’s child in T(j)) else { vt=nearest common ancestor of i and a; } } if (array P(c;i,j) changed) Send array P(c;i,j) to neighbors; } } }

38. j j k k s s i i Correctness of Algorithm • Inductively, according to inequalities of cases (I) - (IV), the value of is never too low. • For every node s on P-k(c;i,j), the suffix of P-k(c;i,j) from s to j is either P(c;s,j) orP-k(c;s,j).Therefore, inductively, after m stages there will be m nodes on P-k(c;i,j) with a correct per-packet price value .

39. Performance of Algorithm (I) • d’ - • Main part of algorithm requires O(d’) stages. • After computing , there still remains to compute the total prices. • For every packet from i to j, every node k on P(c;i,j) counts the number of packets and multiplies by . This is later sent to an accounting mechanism. • Requires O(n) additional storage in each node.

40. Performance of Algorithm (II) • Theorem (proven):Our algorithm computes the VCG prices correctly, uses storage of size O(nd), converges in at most (d+d’) stages, and communicates for node iO(nd*i) data in each stage. • Compare to original BGP - O(nd) storage, d stages, communication for node i of O(nd*i) data in each stage. • In the worst case, d’/d = (n). • Tested on a snapshot of more than half the real internet:n = 5773, d = 8, d’ = 11.

41. A Pinch of Criticism • A lot of assumptions in the model. • But a good starting point. • Mixing theoretical and real information. • Payment for AS’s - theoretical. • Structure of Internet - real. • More than one way to tell a lie.

42. Summary • Incentive - efficiency of data transfer on network (Internet). • Strategy-proof pricing scheme to make AS’s reveal true costs. • Distributed algorithm for calculation of price, using BGP. • More room for development.