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. RoutingRouting - Conveyance of the data through the different routes. AS DomainAS = 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 TrafficTraffic - Quantity of packets that are transmitted throughout the network. CostCost - For every AS, it is the additional load imposed on its internal network by carrying traffic. Transit TrafficTransit Traffic - For every AS, it is the traffic which neither originates nor is destined to that AS. PricePrice - A compensation which is paid for every AS for carrying transit traffic. LCPLCP = 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. N nN - set of nodes (AS’s) on the network. n = |N| LL - set of links between nodes of N. GG - the AS graph (N - vertices, L - edges). T ijT ij - For any two nodes i, j  N, it is the intensity of traffic (number of packets) originating from i destined to j. c k c -kc k - the transit cost of node k for each transit packet it carries. c -k = (c 1,..., c k-1, c k+1,..., c n ) p kp k - the payment which will be given to node k to compensate it for carrying transit traffic. Definitions

11. 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 c k. Specific Assumptions

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

13. 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 I k : Formulation of Goal

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

15. 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: Mechanism Design Solution k’s costs 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 welfare that world receives from k’s existence per packet from i to j

16. Let u k (c) denote the total costs incurred by a node for the cost vector c. Proof of Theorem (I) We have already seen that (I k (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. 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. Notes on Pricing

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

21. dd - 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 –Routing Table - the above information stored in node i. Substrate - BGP (I)

22. “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; } } } StageStage - 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. Substrate - BGP (II)

23. 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. BGP - Specific Assumptions

24. 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)). BGP - Performance

25. 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: Loop-Free BGP j k i 5 5 2

26. Input: cost vector c where c i is known only to node i. Output: set of prices, with node i knowing all the values. Substrate: BGP, receiving 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. Goal - Computation Algorithm

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

28. 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. Upper Bounds for Prices (I) j a k i

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

30. 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). Upper Bounds for Prices (III) j a k i d

31. 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). Upper Bounds for Prices (IV) j a d i k

32. 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)). Upper Bounds for Prices (V)

33. bb - 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: Exact Prices (I)

34. 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 !!! Exact Prices (II)

35. 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 = v k, v k-1, …, v 0 = 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). Price Computation Algorithm (I)

36. 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; } Initialization: Price Computation Algorithm (II)

37. 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 { v t =nearest common ancestor of i and a; } if (array P(c;i,j) changed) Send array P(c;i,j) to neighbors; } Case ICase IICase IIICase IV Price Computation Algorithm (III)

38. 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) or P -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. j s k i j s k i Correctness of Algorithm

39. d’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. Performance of Algorithm (I)

40. 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 i O(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. Performance of Algorithm (II)

41. 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. A Pinch of Criticism

42. 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. Summary