Stackelberg Scheduling
Strategies
By
Tim Roughgarden
Presented by Alex Kogan
Abstract
• We consider setting of scheduling jobs on a set
of shared machines with load-dependent latency
functions. The system performance is measured
by the total latency of the system.
– We assume that the users selfishly wish only to
minimize the latencies of their own jobs.
– In this case, the total latency is non-optimal.
Abstract (cont.)
• If there’s a mix of “selfishly controlled” jobs
and “centrally controlled” jobs, the assignment
of centrally controlled jobs will influence the
subsequent actions of the selfish users.
• We’re interested in assigning the centrally
controlled jobs in the best possible way (that
maximizes the overall system performance ).
Coping with Selfishness
• In many large-scale systems (like the Internet),
there is no central authority controlling the
allocation of shared resources.
– The users act selfishly (non-cooperative game).
– Results in Nash eq. => sub-optimal performance.
• Given a system with a mix of centrally and
selfishly controlled jobs, how can centrally
controlled jobs assignment to induce “good”
behavior from the non-cooperative users?
Stackelberg Games
• The roles of different players are asymmetric.
– One player acts as a leader (according to some
strategy).
– All other agents (the followers) react independently
and selfishly to the leader’s strategy, reaching a
Nash equilibrium relative to the leader’s strategy.
• The Stackelberg equilibrium is the minimumcost equilibrium achieved by a Stackelberg
strategy.
The Central Questions
• Given a set of m machines with load-dependent
latencies and a large number of very small jobs
to be scheduled, we can ask:
– Among all leader strategies for a given set of
machines and jobs, can we characterize and/or
compute the strategy inducing the Stackelberg
equilibrium - i.e., the eq. of minimal total latency?
– What is the worst-case ratio between the total
latency of the Stackelberg eq. and that of the optimal
assignment of jobs to the machines?
Results
• We give a simple polynomial-time algorithm
algorithm for computing a leader strategy that
induces an equilibrium with total latency no
more then 1/ times the optimal ( - the
fraction of centrally controlled jobs).
• We give an O(m2) algorithm for computing a
strategy inducing total latency of at most
4/(3+) of the optimal in special case of linear
latency functions.
Results (cont.)
• Computing the strategy inducing the
Stackelberg equilibrium is NP-hard, even when
the latencies are linear!
The Model
• Set M of m machines 1, 2, …, m
• li() is the latency of machine i (continuous and
non-decreasing).
• (M, r) - an instance with machines M, rate r and
no centrally controlled jobs.
• (M, r, ) - a Stackelberg instance, where
(0,1) indicates the fraction of the centrally
controlled traffic.
Stackelberg Strategies and
Induced Equilibria
• Definition: A Stackelberg strategy for the
Stackelberg instance (M, r, ) is an assignment
feasible for (M, r).
• Definition: Let s be a strategy for Stackelberg
instance (M, r, ) where machine i has latency
function li, and let li~(x) = li(si + x) for each
iM. An equilibrium induced by s is an
assignment t at Nash equilibrium for (M,(1-)r)
w.r.t. latency functions li~.
The Aloof Strategy
• If x* is the optimal assignment for (M, r), put
s = x*.
• The minimum-cost strategy (ignoring the
existence of jobs that are not centrally
controlled).
• Poor performance.
The Scale Strategy
• If x* is the optimal assignment for (M, r), put
s =  x*.
• The optimal assignment of the jobs, suitably
scaled.
• Poor performance.
The LLF Strategy
• Both the Aloof and the Scale strategies suffer
from the same flaw: both don’t consider the
selfish users behavior.
• It’s reasonable for a good strategy to give
priority to the machines that are least appealing
to selfish users - machines with relatively high
latency.
• We consider the Largest Latency First strategy.
The LLF Strategy (cont.)
• The LLF steps:
– Compute the optimal assignment x* for (M, r)
– Index the machines of M so that
l1(x1*)  ...  lm(xm*)
– Let k  m be minimal with i>k xi*  r
– Put si = xi* if i > k, sk = r - i>k xi*, si = 0 if i < k
• A machine i is saturated by s if si = xi*. LLF
saturates machines of the largest latency until
there’re no centrally-controlled jobs remaining.
The LLF Performance Guarantee
• For arbitrary latency functions, the LLF always
induces an assignment of cost no more than 1/
times that of the optimal assignment.
– can be computed in polynomial time
• For linear latency functions, the LLF
performance guarantee is 4/(3 + ).
– can be computed in O(m2)
The Complexity of Computing
Optimal Strategies
• The LLF strategy not always provides the
optimal result.
• The problem of computing the optimal
Stackelberg strategy is NP-hard, even for
instances with linear latency functions.