1. Stackelberg Scheduling Strategies By Tim Roughgarden Presented by Alex Kogan

2. 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.

3. 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 ).

4. 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?

5. 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 minimum- cost equilibrium achieved by a Stackelberg strategy.

6. 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?

7. 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(m 2 ) algorithm for computing a strategy inducing total latency of at most 4/(3+  ) of the optimal in special case of linear latency functions.

8. Results (cont.) Computing the strategy inducing the Stackelberg equilibrium is NP-hard, even when the latencies are linear!

9. The Model Set M of m machines 1, 2, …, m l i () 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.

10. 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 l i, and let l i ~(x) = l i (s i + 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 l i ~.

11. 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.

12. 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.

13. 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.

14. The LLF Strategy (cont.) The LLF steps: –Compute the optimal assignment x* for (M, r) –Index the machines of M so that l 1 (x 1 *) ...  l m (x m *) –Let k  m be minimal with  i>k x i *   r –Put s i = x i * if i > k, s k =  r -  i>k x i *, s i = 0 if i < k A machine i is saturated by s if s i = x i *. LLF saturates machines of the largest latency until there’re no centrally-controlled jobs remaining.

15. 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(m 2 )

16. 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.