42
Incentive-Compatible Interdomain Routing Michael Berger Based on the article: “Incentive-Compatible Interdomain Routing” Joan Feigenbaum, Christos Papadimitriou, Rahul Sami, Scott Shenker
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.• RoutingRouting - Conveyance of the data
through the different routes.• ASAS = Autonomous System = A Sub-
network that serves as a mid-point for the conveyance routes. A.K.A DomainDomain.
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• 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).
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
• NN - set of nodes (AS’s) on the network.nn = |N|
• LL - set of links between nodes of N.• GG - the AS graph (N - vertices, L - edges).
• TTijij - For any two nodes i, j N, it is the intensity of traffic (number of packets) originating from i destined to j.
• cckk - the transit cost of node k for each transit packet it carries.cc-k-k = (c1, ..., ck-1, ck+1, ..., cn)
• ppkk - the payment which will be given to node k to compensate it for carrying transit traffic.
Definitions
• 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.
Specific Assumptions
• IIkk(c;i,j)(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)V(c) - Total cost of routing all packets on LCPs.
More Definitions
Nk
kkNjiij cjicITcV ),;()(
,
• 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:
Formulation of Goal
Nkkk
Njiij
Nkkk
Njiij cjicITcjicITcV ),;(),;()(
,
*
,
Nkkk
Nkkk cjicIcjicIji ),;(),;(, *
• 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:
Mechanism Design Problem
Njikkij
kk
kkk
cjicITpc
xcc
,
),;()(
where
)|()(
k’srevenues
k’sprofits
k’scosts
• 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
Nr Nrrrr
krkk
kij
kij
Njiij
k
cjicIcjicIjicIcp
pTp
,;,;|),;(
where
,
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
• Let uk(c) denote the total costs incurred by a node for the cost vector c.
Proof of Theorem (I)
Nji Nk Nkkkkij
Njikijkk
cucjicITcV
jicITccu
,
,
)(),;()(
Then,
),;()(
• We have already seen that (Ik(c;i,j))k N minimizes V(c).
• We can build a VCG mechanism!
Proof of Theorem (II)
)()()( kkk
k chcVcup kc
finite) are costsother connected,-2 is(G
0),;|(, jicIji kk
payment) zero
ofnt (Requireme
0 kp 0)( ; cuk
)|()( kkk cVch
• A known fact - payments must be expressible as:
Proof of Theorem (III)
)()()|( cVcucVp kkk
Nji Nrrr
Nrr
krkkij cjicIcjicIjicIcT
,
),;(),;|(),;(
Nji
kijij pT
,
• 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
kijp
Part II:Distributed Algorithm(for computing prices)
• 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 TableRouting Table - the above information stored in
node i.
Substrate - BGP (I)
• “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)
• 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
• 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
• 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
55
2
• 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.
Goal - Computation Algorithm
kijp
• 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.• PP-k-k(c;i,j)(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
• Question: For kP(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)
kajp
kijp
Nr Nr
rrrk
rkkkij cjicIcjicIjicIcp ,;,;|),;(
kaj
kij pp j
a
k
i
• Question: For kP(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)
aikaj
kij ccpp
j
i
k
a
Nr Nr
rrrk
rkkkij cjicIcjicIjicIcp ,;,;|),;(
kajp
kijp
• Question: For kP(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)
),(),( jicjaccpp akaj
kij j
a
k
i
d
Nr Nr
rrrk
rkkkij cjicIcjicIjicIcp ,;,;|),;(
kajp
kijp
• Question: For kP(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)
),(),( jicjacccp akkij j
a
d
i
k
Nr Nr
rrrk
rkkkij cjicIcjicIjicIcp ,;,;|),;(
kajp
kijp
• Question: For kP(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)
kajp
kijp
• 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)
kbj
kij pp
bikbj
kij ccpp
),(),( jicjbccpp bkbj
kij
),(),( jicjbcccp bkkij
• 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).
kijp
• 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)
• 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). ),...,,( 01 jij
vij
vij
vij
iij ppppp kk
Price Computation Algorithm (I)
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:
rvijp jij
iij pp ,
Price Computation Algorithm (II)
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;}
}}
);,min(:1 rrr vaj
vij
vij pppkr
);,min(: aivaj
vij
vij ccpppkr rrr
));,(),(,min(: jicjaccppptr avaj
vij
vij
rrr ));,(),(,min(: jicjacccpptr av
vij
vij r
rr
Case I
Case II
Case III
Case IV
Price Computation Algorithm (III)
• 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 .
kijp
sijp
j
sk
i
j
sk
i
Correctness of Algorithm
• 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.
kijp
|)),;((|max,,
jicP k
kji
kijp
Performance of Algorithm (I)
• 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)
• 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
• 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
