1. CS 194: Distributed Systems Incentives and Distributed Algorithmic Mechanism Design
Scott Shenker and Ion Stoica
Computer Science Division
Department of Electrical Engineering and Computer Sciences
University of California, Berkeley
Berkeley, CA

2. Traditional Distributed Systems Paradigm
Choose performance goal
Design algorithm/protocols to achieve those goals
Require every node to use that algorithm/protocol

3. Living in the Brave New World....
Most modern Internet-scale distributed systems involve independent users
Web browsing, DNS, etc.
There is no reason why users have to cooperate
Users may only care about their own service
What happens when users behave selfishly?

4. Example: Congestion Control
Simple model to illustrate basic paradigm
Users send at rate ri
Performance Ui is function of rate and delay
use Ui = ri/di for this simple example
Delay di is function of all sending rates rj
Selfishness: users adjust their sending rate to maximize their performance

5. Simple Poisson Model with FIFO Queue
Define rtot =  ri and Utot =  Ui
In Poisson model with FIFO queues (and link speed 1):
di = 1/(1-rtot)

6. Selfish Behavior Users adjust ri to maximize Ui
We assume they arrive at a Nash equilibrium
A Nash equilibrium is a vector of r’s such that no user can increase their Ui by unilaterally changing ri
First order condition: Ui/ri = 0
Can be multiple equilibria, or none, but for our example problem there is just one.

7. Nash Equilibrium Ui = ri(1-rtot) Ui/ri = 1 - rtot - ri
Solving for all i
ri = 1/(n+1) where n is number of users
Utot = (n+1)-2
Total utility goes down as number of users increases!

8. Socially Optimal Usage
Set all ri to be the same value, call it x
Vary x to maximize Utot Utot = nx(1-nx)
Maximizing value is nx = 1/2 and Utot = 1/4 at socially optimal usage
Huge discrepancy between optimal and selfish outcomes!
Why?

9. Fair Queueing Very rough model of queueing delays for FQ
Assume vector of r’s is ordered: r1 ≤ r2 ≤ r ≤ rn
Smallest flow competes only with own level of usage: d1 = 1/(1 - nr1)
For all other flows, first r1 level of packet get this delay also

10. Fair Queueing (continued)
Packets in r2 - r1 see delay: 1/(1 - r1 - (n-1) r2)
Packets in r3 - r2 see delay: 1/(1 - r1 - r2 - (n-2) r3)
General rule:
Everyone gets the same rate at the highest priority (r1)
All remaining flows get the same rate at the next highest priority (r2)
And so on....

11. Nash Equilibrium for FQ
Nash equilibrium is socially optimal level!
Why?
True for any “reasonable” functions Ui, as long as all users have the same utility
In general, no users is worse off compared to situation where all users have the same utility as they do

12. Designing for Selfishness
Assume every user (provider) cares only about their own performance (profit)
Give each user a set of actions
Design a “mechanism” that maps action vectors into a system-wide outcome
Mechanism design
Choose a mechanism so that user selfishness leads to socially desirable outcome
Nash equilibrium, or other equilibrium concepts

13. Reasons for “Selfish Design” Paradigm
Necessary to deal with unpleasant reality of selfishness
World is going to hell, and the Internet is just going along for the ride.....
Best way to allow individual users to meet their own needs without enforcing a single “one-size-fits-all” solution
With congestion control, everyone must be TCP-compatible
That stifles innovation

14. Cooperative vs Noncooperative
Cooperative paradigm:
Works best when all utilities are the same
Requires a single standard protocol/algorithm, which inevitably leads to stagnation
Is vulnerable to cheaters and malfunctions
Noncooperative paradigm:
Accommodates diversity
Allows innovation
Does not require enforcement of norms
But may not be as efficient....

15. On to a more formal treatment....
...combining game theory with more traditional concerns.

16. Three Research Traditions
Theoretical Computer Science: complexity
What can be feasibly computed?
Centralized or distributed computational models
Game Theory: incentives
What social goals are compatible with selfishness?
Internet Architecture: robust scalability
How to build large and robust systems?

17. Different Assumptions
Theoretical Computer Science:
Nodes are obedient, faulty, or adversarial.
Large systems, limited comp. resources
Game Theory:
Nodes are strategic (selfish).
Small systems, unlimited comp. resources

18. Internet Systems (1) Agents often autonomous (users/ASs)
Have their own individual goals
Often involve “Internet” scales
Massive systems
Limited comm./comp. resources
Both incentives and complexity matter.

19. Internet Systems (2) Agents (users/ASs) are dispersed.
Computational nodes often dispersed.
Computation is (often) distributed.

20. Internet Systems (3) Scalability and robustness paramount
sacrifice strict semantics for scaling
many informal design guidelines
Ex: end-to-end principle, soft state, etc.
Computation must be “robustly scalable.”
even if criterion not defined precisely
If TCP is the answer, what’s the question?

21. Fundamental Question What computations are (simultaneously): TCS
Computationally feasible
Incentive-compatible
Robustly scalable
TCS
Game Theory
Internet
Design

22. Game Theory and the Internet
Long history of work:
Networking: Congestion control [N85], etc.
TCS: Selfish routing [RT02], etc.
Complexity issues not explicitly addressed
though often moot

23. TCS and Internet Increasing literature No consideration of incentives
TCP [GY02,GK03]
routing [GMP01,GKT03]
etc.
No consideration of incentives
Doesn’t always capture Internet style

24. Game Theory and TCS Various connections:
Complexity classes [CFLS97, CKS81, P85, etc.]
Cost of anarchy, complexity of equilibria, etc. [KP99,CV02,DPS02]
Algorithmic Mechanism Design (AMD)
Centralized computation [NR01]
Distributed Algorithmic Mechanism Design (DAMD)
Internet-based computation [FPS01]

25. DAMD: Two Themes Incentives in Internet computation
Well-defined formalism
Real-world incentives hard to characterize
Modeling Internet-style computation
Real-world examples abound
Formalism is lacking

26. System Notation Outcomes and agents:  is set of possible outcomes.
o   represents particular outcome.
Agents have valuation functions vi.
vi(o) is “happiness” with outcome o.

27. Societal vs. Private Goals
System-wide performance goals:
Efficiency, fairness, etc.
Defined by set of outcomes G(v)  
Private goals: Maximize own welfare
vi is private to agent i.
Only reveal truthfully if in own interest

28. Mechanism Design Branch of game theory:
reconciles private interests with social goals
Involves esoteric game-theoretic issues
will avoid them as much as possible
only present MD content relevant to DAMD

29. Utilities: ui(a) = vi(O(a)) + pi(a)
Mechanisms
Actions: ai Outcome: O(a) Payments: pi(a)
Utilities: ui(a) = vi(O(a)) + pi(a)
Agent 1
Agent n
Mechanism
. . .
p 1
a 1
p n
a n O v1 vn
M does now know v, onlyommunication is a....

30. Mechanism Design AO(v) = {action vectors} consistent w/selfishness
ai “maximizes” ui(a) = vi(O(a)) + pi(a).
“maximize” depends on information, structure, etc.
Solution concept: Nash, Rationalizable, ESS, etc.
Mechanism-design goal: O(AO (v))  G(v) for all v
Central MD question: For given solution concept, which social goals can be achieved?

31. Direct Strategyproof Mechanisms
Direct: Actions are declarations of vi.
Strategyproof: ui(v) ≥ ui(v-i, xi), for all xi ,v-i
Agents have no incentive to lie.
AO(v) = {v} “truthful revelation”
Example: second price auction
Which social goals achievable with SP?

32. Strategyproof Efficiency
Efficient outcome: maximizes vi
VCG Mechanism:
O(v) = õ(v) where õ(v) = arg maxo vi(o)
pi(v) = ∑j≠i vj(õ(v)) + hi(v-i)

33. Why are VCG Strategyproof?
Focus only on agent i
vi is truth; xi is declared valuation
pi(xi) = ∑j≠i vj(õ(xi)) + hi
ui(xi) = vi(õ(xi)) + pi(xi) = j vj(õ(xi)) + hi
Recall: õ(vi) maximizes j vj(o)

34. Group Strategyproofness
Definition:
True: vi Reported: xi
Lying set S={i: vi ≠ xi}
 iS ui(x) > ui(v)   jS uj(x) < uj(v)
If any liar gains, at least one will suffer.

35. Algorithmic Mechanism Design [NR01]
Require polynomial-time computability:
O(a) and pi(a)
Centralized model of computation:
good for auctions, etc.
not suitable for distributed systems

36. Complexity of Distributed Computations (Static)
Quantities of Interest:
Computation at nodes
Communication:
total
hotspots
Care about both messages and bits

37. “Good Network Complexity”
Polynomial-time local computation
in total size or (better) node degree
O(1) messages per link
Limited message size
F(# agents, graph size, numerical inputs)

38. Internet systems often have “churn.”
Dynamics (partial)
Internet systems often have “churn.”
Agents come and go
Agents change their inputs
“Robust” systems must tolerate churn.
most of system oblivious to most changes
Example of dynamic requirement:
o(n) changes trigger (n) updates.

39. Protocol-Based Computation
Use standardized protocol as substrate for computation.
relative rather than absolute complexity
Advantages:
incorporates informal design guidelines
adoption does not require new protocol
example: BGP-based mech’s for routing

40. Two Examples
Multicast cost sharing
Interdomain routing

41. Multicast Cost Sharing (MCS)
Receiver Set
Source
Which users receive the multicast? 3 3
1,2
3,0
Cost Shares 1 5 5 2
How much does each receiver pay? 10
6,7
1,2
Model [FKSS03, §1.2]:
Obedient Network
Strategic Users
Users’ valuations: vi
Link costs: c(l)

42. P Users (or “participants”) R Receiver set (i = 1 if i  R)
Notation
P Users (or “participants”)
R Receiver set (i = 1 if i  R)
pi User i’s cost share (change in sign!)
ui User i’s utility (ui =ivi – pi)
W Total welfare W(R) = V(R) – C(R)
C(R) =  c(l)
V(R) =  vi
l  T(R)
i  R

43. “Process” Design Goals
No Positive Transfers (NPT): pi ≥ 0
Voluntary Participation (VP): ui ≥ 0
Consumer Sovereignty (CS): For all trees and costs, there is a cs s.t. i = 1 if vi ≥ cs.
Symmetry (SYM): If i,j have zero-cost path and vi = vj, then i = j and pi = pj.

44. Two “Performance” Goals
Efficiency (EFF): R = arg max W
Budget Balance (BB): C(R) = i  R pi

45. Impossibility Results
Exact [GL79]: No strategyproof mechanism can be both efficient and budget-balanced.
Approximate [FKSS03]: No strategyproof mechanism that satisfies NPT, VP, and CS can be both -approximately efficient and -approximately budget-balanced, for any positive constants , .

46. Efficiency pi = vi – (W – W-i),
Uniqueness [MS01]: The only strategyproof, efficient mechanism that satisfies NPT, VP, and CS is the Marginal-Cost mechanism (MC):
pi = vi – (W – W-i),
where W is maximal total welfare, and W-i is maximal total welfare without agent i.
MC also satisfies SYM.

47. Budget Balance (1)
General Construction [MS01]: Any cross-monotonic cost-sharing formula results in a group-strategyproof and budget-balanced cost-sharing mechanism that satisfies NPT, VP, CS, and SYM.
Cost sharing: maps sets to charges pi(R)
Cross-monotonic: shares go down as set increases pi(R+j)  pi(R)
R is biggest set s. t. pi(R)  vi, for all i  R.

48. Budget Balance (2)
Efficiency loss [MS01]: The Shapley-value mechanism (SH) minimizes the worst-case efficiency loss.
SH Cost Shares: c(l) is shared equally by all receivers downstream of l.

49. Network Complexity for BB
Hardness [FKSS03]: Implementing a group-strategyproof and budget-balanced mechanism that satisfies NPT, VP, CS, and SYM requires sending (|P|) bits over (|L|) links in worst case.
Bad network complexity!

50. Network Complexity of EFF
“Easiness” [FPS01]: MC needs only:
One modest-sized message in each link-direction
Two simple calculations per node
Good network complexity!

51. pi  vi – (W – W-i) Computing Cost Shares
Case 1: No difference in tree Welfare Difference = vi Cost Share = 0
Case 2: Tree differs by 1 subtree. Welfare Difference = W (minimum welfare subtree above i) Cost Share = vi – W

52. Two-Pass Algorithm for MC
Bottom-up pass:
Compute subtree welfares W.
If W < 0, prune subtree.
Top-down pass:
Keep track of minimum welfare subtrees.
Compare vi to minimal W.

53. Interdomain-Routing Mechanism-Design Problem
WorldNet
Qwest
UUNET
Sprint
Agents: Transit ASs
Inputs: Routing Costs or Preferences
Outputs: Routes, Payments

54. Lowest-Cost-Routing MD
Per-packet costs {ck }
Agents’ valuations:
(Unknown) global parameter: Traffic matrix [Tij]
{route(i, j)}
Outputs:
{pk}
Payments:
Objectives:
Lowest-cost paths (LCPs)
Strategyproofness
“BGP-based” distributed algorithm

55. A Unique VCG Mechanism Theorem [FPSS02]:
For a biconnected network, if LCP routes are always chosen, there is a unique strategyproof mechanism that gives no payment to nodes that carry no transit traffic. The payments are of the form
pk =  Tij , where
pij k
i,j
= ck + Cost ( P-k(c; i, j) ) – Cost ( P(c; i, j) )
pij k
Proof is a straightforward application of [GL79].

56. Features of this Mechanism
Payments have a very simple dependence on traffic [Tij ]: Payment pk is weighted sum of per-packet prices .
Cost ck is independent of i and j, but price depends on i and j.
Price is 0 if k is not on LCP between i, j.
Price is determined by cost of min-cost path from i to j not passing through k (min-cost “k-avoiding” path).
pij k
pij k
pij k
pij k

57. BGP-Based Computational Model (1)
Follow abstract BGP model of [GW99]:
Network is a graph with nodes corresponding to ASs and bidirectional links; intradomain-routing issues are ignored.
Each AS has a routing table with LCPs to all other nodes:
Dest.
LCP
LCP cost
AS1
AS3
AS5
AS1 3
AS2
AS7
AS2 2
Entire paths are stored, not just next hop.

58. Computational Model (2)
An AS “advertises” its routes to its neighbors in
the AS graph, whenever its routing table changes.
The computation of a single node is an infinite
sequence of stages:
Receive routes from neighbors
Update routing table
Advertise modified routes
Complexity measures:
- Number of stages required for convergence
- Total communication 
Surprisingly scalable in practice.

59. Computing the VCG Mechanism
Need to compute routes and prices.
Routes: Use Bellman-Ford algorithm to compute
LCPs and their costs.
Prices:
pij k
= ck + Cost ( P-k(c; i, j) ) – Cost ( P(c; i, j) )
Need algorithm to compute cost of
min-cost k-avoiding path.

60. Structure of k-avoiding Paths
BGP uses communication between neighbors only
 we need to use “local” structure of P-k(c; i,j).
Tail of P-k(c; i,j) is either of the form j i a k
(1) P-k(c; a,j) i k j
or (2) P(c; a,j) a
Conversely, for each neighbor a, either P-k(c; a,j)
or P(c; a,j) gives a candidate for P-k(c; i,j).

61. A “BGP-Based” Algorithm
Dest.
cost
LCP and path prices
LCP cost
AS3
AS5
AS1
c(i,1)
AS1 c1
pi1 3
pi1 5
LCPs are computed and advertised to neighbors.
Initially, all prices are set to .
In the following stages, each node repeats:
- Receive LCP costs and path prices from neighbors.
- Recompute candidate prices; select lowest price.
- Advertise updated prices to neighbors.
Final state: Node i has accurate values.
pij k

62. Performance of Algorithm
d = maxi,j || P ( c; i, j ) ||
d = maxi,j,k || P-k ( c; i, j ) ||
Theorem [FPSS02]:
This algorithm computes the VCG prices correctly, uses routing tables of size O(nd) (a constant factor increase over BGP), and converges in at most (d + d’) stages (worst-case additive penalty of d stages over the BGP convergence time).