Incentive-Compatible
Interdomain Routing
Michael Berger
Based on the article:
“Incentive-Compatible Interdomain Routing”
Joan Feigenbaum, Christos Papadimitriou,
Rahul Sami, Scott Shenker
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 Subnetwork that serves as a mid-point for
the conveyance routes. A.K.A Domain.
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!
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).
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!
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.
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.
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.
Part I:
Pricing Scheme
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.
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.
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.
V (c ) 
T  I
i , jN
ij
kN
k
(c; i, j )ck
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:


*
i, j  I k (c ; i, j )ck   I k (c; i, j )ck 
kN
 kN


V (c ) 
*
T
I
(
c
 ij  k ; i, j )ck 
i , jN
kN
T  I
i , jN
ij
kN
k
(c; i, j )ck
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:
 k (c )   k (c |k x )
where
 k (c )  p 
k
k’s
k’s
profits revenues
T
i , jN
ij
I k (c; i, j )ck
k’s
costs
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:
p k   Tij pijk
i , jN
where
welfare that world receives from k’s
existence per packet from i to j


k
p  ck I k (c; i, j )    I r c | ; i, j cr   I r c; i, j cr 
rN
rN

k
ij


cost of all nodes cost of all nodes per
k’s costs per packet
per packet from i to packet from i to j
from i to j
j if k didn’t exist
when k exists
Proof of Theorem (I)
• Let uk(c) denote the total costs incurred by a
node for the cost vector c.
u k ( c )  ck
T
i , jN
ij
I k (c; i, j )
Then,
V (c ) 
 T I
i , jN
ij
k N
k
(c; i, j )ck 
u
k N
• We have already seen that (Ik(c;i,j))k N
minimizes V(c).
• We can build a VCG mechanism!
k
(c )
Proof of Theorem (II)
• A known fact - payments must be expressible
as:
k
p  uk (c)  V (c)  hk (c )
k
ck    i, j I k (c |k ; i, j )  0
(G is 2 - connected, other costs are finite)
;
 p 0
(Requireme nt of
zero payment)
k
k
 hk (c )  V (c | )
k
u k (c )  0
Proof of Theorem (III)
 p  V ( c |  )  u k (c )  V (c )
k
k


k
  Tij ck I k (c; i, j )   I r (c | ; i, j )cr   I r (c; i, j )cr 
i , jN
rN
rN



T
i , jN
ij
k
ij
p
Notes on Pricing
• Payments are a sum of per-packet payments
that don’t depend on the traffic matrix.
k
• Payments pij 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.
Part II:
Distributed Algorithm
(for computing prices)
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.
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.
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.
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)).
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
k
i
5
2
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 pijk 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.
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.
Upper Bounds for Prices (I)
• Question: For kP(c;i,j), given that i and a are
k
k
neighbors in G and given paj , what is pij ?
• Reminder:
pijk  ck I k (c; i, j )   I r c |k ; i, j cr   I r c; i, j cr
rN
rN
• Case I: a is i’s parent in T(j), a isn’t k.
p p
k
ij
k
aj
j
k
a
i
Upper Bounds for Prices (II)
• Question: For kP(c;i,j), given that i and a are
k
k
neighbors in G and given paj , what is pij ?
• Reminder:
pijk  ck I k (c; i, j )   I r c |k ; i, j cr   I r c; i, j cr
rN
rN
• Case II: a is i’s child in T(j).
p  p  ci  ca
k
ij
k
aj
j
k
i
a
Upper Bounds for Prices (III)
• Question: For kP(c;i,j), given that i and a are
k
k
neighbors in G and given paj , what is pij ?
• Reminder:
pijk  ck I k (c; i, j )   I r c |k ; i, j cr   I r c; i, j cr
rN
rN
• Case III: a isn’t adjacent to i in T(j), and k is
on P(c;a,j).
j
p  p  ca  c(a, j )  c(i, j )
k
ij
k
aj
k
d
a
i
Upper Bounds for Prices (IV)
• Question: For kP(c;i,j), given that i and a are
k
k
neighbors in G and given paj , what is pij ?
• Reminder:
pijk  ck I k (c; i, j )   I r c |k ; i, j cr   I r c; i, j cr
rN
rN
• Case IV: a isn’t adjacent to i in T(j), and k
isn’t on P(c;a,j).
p  ck  ca  c(a, j )  c(i, j )
k
ij
j
d
k
a
i
Upper Bounds for Prices (V)
• Question: For kP(c;i,j), given that i and a are
k
k
neighbors in G and given paj , what is pij ?
• 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)).
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:
p p
Case II:
p  p  ci  cb
Case III:
p  p  cb  c(b, j )  c(i, j )
Case IV:
p  ck  cb  c(b, j )  c(i, j )
k
ij
k
ij
k
ij
k
ij
k
bj
k
bj
k
bj
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:
k
pij is exactly equal to the minimum, over all
neighbors a of i, of the right-hand side of
the corresponding inequality !!!
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.:
( piji  pijvk , pijvk 1 ,..., pijv0  pijj )
– 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
(II)
• Initialization:
Run BGP();
for each node i (concurrently) {
for each destination node j {
vr
Set all entries pij in array P(c;i,j) to  ;
i
j
Set entries pij , pij in array P(c;i,j) to 0;
}
Send all arrays P(c;i,j) to neighbors;
}
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))
Case I
r  k 1 : pijvr  min( pijvr , pajvr );
else if (a is i’s child in T(j))
Case II
r  k : pijvr  min( pijvr , pajvr  ci  ca );
else {
vt=nearest common ancestor of i and a;
Case III
v
v
v
Case IV
}
}
}
r  t : pijr  min( pijr , pajr  ca  c(a, j )  c(i, j ));
r  t : pijvr  min( pijvr , cvr  ca  c(a, j )  c(i, j ));
}
if (array P(c;i,j) changed)
Send array P(c;i,j) to neighbors;
}
Correctness of Algorithm
• Inductively, according to inequalities of
k
cases (I) - (IV), the value of pij 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).
j
j
s
k
i
s
k
i
Therefore, inductively, after m stages there
will be m nodes on P-k(c;i,j) with a correct
s
per-packet price value pij.
Performance of Algorithm (I)
• d’ - max (| P (c; i, j ) |)
k
i , j ,k
• Main part of algorithm requires O(d’)
stages.
k
• After computing pij , 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
k
multiplies by pij . This is later sent to an
accounting mechanism.
– Requires O(n) additional storage in each node.
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 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.
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.
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.