IncentiveCompatible 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.
• ProblemTo know the most efficient way, we must
  know the true efficiencies of the ASs.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 ASs).

5
Our Goal - More Formally

• To convey all data on the network s.t. the total
  costs are minimized.
• High efficiency Low total costs
• ProblemTo do that, we must know the true costs
  of the ASs.But every AS might be lying about
  its costs!

6
Model - General Assumptions (I)

• ASs are unitary strategic agents.
• There is no centralized authority that controls
  the network, whom the ASs 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 doesnt find LCPs, but shortest
  paths (in terms of number of hops).
• In reality, BGP doesnt always use LCPs, but also
  employs routing by policy and transit
  restrictions.

8
Our Goal - According to Model

• Devise a pricing scheme for the ASs 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 ASs that carry no transit
  traffic.
• Provide a distributed algorithm for the ASs that
  is BGP-friendly, to compute the above prices.

9
Part IPricing Scheme
10
Definitions

• N - set of nodes (ASs) 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, ck1,
  ..., 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(ci,j) - Indicator function for the LCP from i
  to j. Ik(ci,j) 1 if node k is an intermediate
  node on the LCP from i to j. Ik(ci,j) 0
  otherwise.
• Note Ii(ci,j) Ij(ci,j) 0.
• V(c) - Total cost of routing all packets on
  LCPs.

13
Formulation of Goal

• Minimize V(c).
• ProblemIf 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
Mechanism Design Problem

• Purpose Minimize V(c) (objective function) by
  making nodes reveal true costs.
• Input ltG, cgt
• 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
Mechanism Design Solution

• TheoremWhen 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(ci,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
  dont depend on the traffic matrix.
• Payments are zero if LCP between i and j
  doesnt 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 doesnt pass through k.

20
Part IIDistributed Algorithm(for computing
prices)
21
Substrate - BGP (I)

• d - Diameter of network, i.e. the maximum number
  of ASs 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 IDs). 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 Algorithmfor 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 neighbors 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 followingFor 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 ltG, cgt 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(ci,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 doesnt pass
  through k.
• P-k(ci,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(ci,j), given that i and a are
  neighbors in G and given , what is ?
• Reminder
• Case I a is is parent in T(j), a isnt k.

j
k
a
i
29
Upper Bounds for Prices (II)

• Question For k?P(ci,j), given that i and a are
  neighbors in G and given , what is ?
• Reminder
• Case II a is is child in T(j).

j
k
i
a
30
Upper Bounds for Prices (III)

• Question For k?P(ci,j), given that i and a are
  neighbors in G and given , what is ?
• Reminder
• Case III a isnt adjacent to i in T(j), and k is
  on P(ca,j).

j
k
d
a
i
31
Upper Bounds for Prices (IV)

• Question For k?P(ci,j), given that i and a are
  neighbors in G and given , what is ?
• Reminder
• Case IV a isnt adjacent to i in T(j), and k
  isnt on P(ca,j).

j
d
k
a
i
32
Upper Bounds for Prices (V)

• Question For k?P(ci,j), given that i and a are
  neighbors in G and given , what is ?
• Other Cases
• a is is parent in T(j), a k.
• a is is descendant in T(j), but not its child.
• a is is ancestor in T(j), but not its parent.
• In all the above cases, P-k(ci,j) will not be
  (a, P-k(ca,j)).

33
Exact Prices (I)

• b - The neighbor of i on P-k(ci,j).
• LemmaFor b, the previous four inequalities
  attain equality.Case ICase IICase
  IIICase IV

34
Exact Prices (II)

• Proof
• b falls into one of the four cases.
• From definition of P-k(ci,j), there is no
  undercutting shorter k-avoiding path (no other
  blue path).

• ConsequenceFrom 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)

• DataIn each node i, for each destination node
  j
• LCP from i to j (after running BGP),
  i.e.P(ci,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(ci,j) to Set entries
in array P(ci,j) to 0 Send all arrays
P(ci,j) to neighbors
37
Price Computation Algorithm (III)
while (1) for each destination node j if
(received array P(ca,j) from neighbor a) if
(a is is parent in T(j)) else if (a is
is child in T(j)) else vtnearest
common ancestor of i and a if
(array P(ci,j) changed) Send array P(ci,j)
to neighbors
38
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(ci,j), the suffix of
  P-k(ci,j) from s to j is either P(cs,j)
  orP-k(cs,j).Therefore, inductively, after m
  stages there will be m nodes on P-k(ci,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(ci,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 (dd) stages, and
  communicates for node i O(ndi) data in each
  stage.
• Compare to original BGP - O(nd) storage, d
  stages, communication for node i of O(ndi) data
  in each stage.
• In the worst case, d/d ?(n).
• Tested on a snapshot of more than half the real
  internetn 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 ASs - 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 ASs reveal
  true costs.
• Distributed algorithm for calculation of price,
  using BGP.
• More room for development.