Stackelberg Strategies for Weighted Load Balancing Games

An instance of a weighted Stackelberg load balancing game is given by a set of identical machines, a set of variable-length jobs and a parameter 0 ≤ α ≤ 1. A centralized authority, denoted the leader, selects a subset of the jobs whose total length is at most an α-fraction of the total length and determines their assignment on the machines. After the controlled jobs are assigned, the remaining jobs join the schedule. They act selfishly, each determining its own assignment.Our work combines theoretical and experimental results for this setting. We suggest various heuristics for the leader and analyze their performance.


I. INTRODUCTION
I N RESOURCE allocation applications, a set of resources is used by a set of clients (users). For example, in jobscheduling applications, servers process jobs; in communication or transportation networks, traffic is routed on network links. In some settings, the users are assigned to the different resources by a centralized authority. The centralized authority is aware of all clients' requests and can utilize the system in the best possible way. Other resource allocation applications lack a central authority and are managed by multiple strategic users, whose individual payoff is affected by the assignment of other users. As a result, game theory has become an essential tool in the analysis of resource-allocation services. In the corresponding game, every client is a selfish player who aims at maximizing his own utilization.
In this work, we consider systems in which the two models are combined. That is, some of the users obey a central authority and some are selfish. The goal of the system is to assign the centrally controlled users such that the total system performance is optimized. We formulate this goal as an optimization problem via Stackelberg games, in which one player, corresponding to the centralized authority, acts as a leader and the rest of the players, corresponding to the selfish users, as followers. The problem is then to compute a strategy for the leader (a Stackelberg strategy) that cause the followers to react in a way that is as good as possible for the social utility.
We focus on load balancing games in job scheduling systems. The users are jobs having variable weights and the resources are machines. Every job should be assigned on a single machine. The cost of a job depends on the total load on its machine and the social cost is given by the load on the most loaded machine. In centralized systems, this load balancing scenario is the well-studied minimum Makespan problem. It was well-studied also as a game where all the jobs are selfish, however, it has not been studied in an environment with a mixed type of jobs. All previous works on Stackelberg strategies consider non-atomic (splittable) players -every player has a neglected load and the total load can be distributed among the machines in an arbitrary way. Thus, our work initiate the study of Stackelberg strategies for weighted singleton congestion games.
Our goal is to develop Stackelberg strategies that guarantee load balancing and a low social cost. We will consider several different models, depending on the different capabilities of the leader.
In our model, the leader can select the jobs it controls and its power is given by a parameter 0 f ³ f 1, such that it can select any subset of jobs whose total load is at most an ³ fraction of the total load.
As we show, in some instances, the leader should better exploit its power only partially and let more jobs select their strategy selfishly. Intuitively, this is due to the fact that the leader acts first and its assignment is irrevocable.
The scenarios we propose to study arise in real life applications that provide service to a mixture of independent and controlled clients. For example, several companies suggest computing services on shared machines for private users (using cloud services) as well as local computation tasks. Similarly, in routing problems, some users obey and consult a navigation app, while others don't. The navigation app acts as a leader that determines the decisions (selected path) of some of the clients.

A. Notation and Problem Statement
A load balancing game is given by G = ïJ , M, {p j } "j * J ð, where J is a set of n jobs, M is a set of m machines, p j is the weight (also denoted size) of job j. In unweighted games, all the jobs have the same unit size, that is, "j, p j = 1.
A Stackelberg load balancing game is given by ïG, ³ð, where G is a load balancing game and 0 f ³ f 1 denotes the maximal fraction of the load controlled by the leader.
Let A be the set of jobs controlled by the leader. Let P = which the jobs are assigned 1 . If j * A then s j is determined by the leader and if j * J \ A, then s j is selected by player j. For a machine i * M, the load on i in s, denoted L i (s), is the total size of the jobs assigned on machine i in s, that is, L i (s) = {j|sj =i} p j . When s is clear from the context, we omit it. It takes p j time-units to process job j on machine i. As common in the study of job-scheduling games, we assume that all the jobs assigned on the same machine are processed in parallel and have the same cost, defined as the machine's completion time. Formally, the cost of job j in profile s is C j (s) = L sj (s). The players that control jobs act selfishly, trying to minimize the cost of the job they control. The leader is trying to optimize some global objective function. Note that if A = J then all the jobs are controlled by the leader and we have a classical job scheduling problem.
The leader applies its strategy first and determines an assignment for the players in A. Afterwards, the players in J \ A join this partial schedule, each selecting selfishly an assignment for its job. The jobs assigned by the leader cannot change their assignment. The selfish jobs may change their assignment in response to other jobs' assignments.
For a profile s, a job j * J \ A and a machine s 2 j ; = s j , let (s 2j , s 2 j ) denote the profile obtained from s by replacing the strategy of job j by s 2 j . That is, the profile resulting from a migration of job j from machine s j to machine s 2 j . A profile s is a pure Nash equilibrium (NE) if no selfish job can benefit from unilaterally deviating from its strategy in s to another strategy; i.e., for every job j * J \ A and every machine s 2 j it holds that C j (s 2j , s 2 j ) g C j (s). The cost of a schedule is defined to be the maximal completion time of a job, also known as the Makespan of the schedule, that is, cost(s) = max j*J C j (s).
It is well known that decentralized decision-making may lead to sub-optimal solutions from the point of view of society as a whole. For a game G, let S(G) be the set of feasible profiles of G. We denote by OP T (G) the cost of a social optimal (SO) solution; i.e., OP T = min s*S(G) cost(s). We quantify the inefficiency incurred due to self-interested behavior according to the price of anarchy (PoA) [16] and price of stability (PoS) [1], [20] measures. The PoA is the worst-case inefficiency of a pure Nash equilibrium, while the PoS measures the best-case inefficiency of a pure Nash equilibrium. Formally, Definition 1.1: Let G be a family of games and let G be a game in G. Let Υ(G) be the set of pure Nash equilibria of the game G. Assume that Υ(G) ; = '. " The price of anarchy of G is the ratio between the maximal cost of a NE and the social optimum of G. That is, PoA(G) = max s*Υ(G) cost(s)/OP T (G). The price of anarchy of the family of games G is PoA(G) = sup G*G PoA(G).
We now define the inefficiency measure of a Stackelberg game. Definition 1.2: Let ïG, ³ð be a family of Stackelberg games where G is a family of games and let G be a game in G. Let Υ(G, ³) be the set of pure Nash equilibria of the game ïG, ³ð. Assume that Υ(G, ³) ; = '. " The price of anarchy of ïG, ³ð is the ratio between the maximal cost of a NE and the social optimum of G.

B. Related Work
The two extreme cases, of A = J and A = ' are well studied. The case A = J is the classical minimum makespan problem, while the case A = ' is the classical load balancing game.
The minimum makespan problem is an NP-hard problem and has a rich collection of approximation algorithms. For identical machines, the simple greedy List-scheduling (LS) algorithm [10] provides a (2 2 1 m )-approximation to this problem. A bit better approximation ratio of ( 4 3 2 1 3m ) is guaranteed by the Longest Processing Time (LPT) algorithm [11]. A PTAS for the minimum makespan problem on identical machines is given in [12]. For related machines (with various speeds), List-scheduling guarantees Θ(m)-approximation [4] and a PTAS is presented in [6].
Load balancing game consist of a set of jobs (players) and a set of machines. Each job is controlled by a selfish agent who aims to minimize his cost -given by the load on the machine it is assigned to ([21]). The concept of the price of anarchy (PoA) was introduced by Koutsoupias and Papadimitriou in [16]. They proved that the price of anarchy of job scheduling games is 2 2 1 m . In [7], Finn and Horowitz presented an upper bound of 2 2 2 m+1 for the price of anarchy in load balancing games with identical machines. Czumaj and Vöcking [5] gave tight bounds for related machines that grow as the number of machines grows.
Other related work consider Stackelberg strategies for resource allocation games with identical players and nondecreasing latency functions which can vary between the resources. In these games, the leader is characterized by the fraction ³ * [0, 1] of the players it controls and an optimal allocation can be computed in polynomial time. Our model differs from the previous studies as we do not assume the players to have identical weight or strategy space, hence, the leader is characterized by the specific set of players it controls and calculating a socially optimum assignment is an NP-hard problem.
For routing games on parallel networks for with nondecreasing latency functions, it is known that computing an optimal Stackelberg strategy is NP-hard. There are two known approximation algorithms for the case of splittable (nonatomic) symmetric games with non-decreasing latency functions presented by Roughgarden in [18]; The Scale strategy which simply employs the optimal configuration scaled by the fraction of coordinated players . The best bound known for Scale PoA is 4 3 2 X 3 where X = (12 12α+1 [13]. The LLF (Largest Latency First) strategy presented by Roughgarden in [18] assigns the controlled players to the largest cost strategies in the optimal configuration. The best known upper bound, achieved by Karakostas and Kolliopoulos [13], is equal to 4 3 for ³ f 1 3 and 2(12α 2 ) 22α2 : 4α23α 2 for ³ > 1 3 . Subsequently, Kumar and Marathe [17] presented a fully polynomial-time approximation scheme for the problem of computing an optimal Stackelberg configuration on parallel links with polynomial latencies. Stackelberg routing in arbitrary networks is studied in [2].
The work mostly related to our study considers games with unsplittable (atomic) flows with non-decreasing latency functions. In these games, different machines may have different latency functions, that are not necessarily linear. The players are identical, but they do have a non-splittable constant size. Thus, the problem of calculating the optimal assignment is polynomially solvable, contrary to our model. Fotakis [8] studied LLF and a randomized version of Scale and gave upper and lower bounds for them. He also introduced the Stackelberg strategy ¼-Cover which assigns to every resource either at least ¼ or as many coordinated players as the resource has in the social optimum. Finally, he also gave upper bounds for strategies obtained by combining ¼-Cover with either LLF or Scale and upper bounds for games played on parallel links. Vittorio and Vinci [3] then presented improved bounds for the three Stackelberg strategies studied by Fotakis [8]. For LLF they showed PoA of exactly 20211α 8 for ³ * [0, 4 7 ] and for ³ * [ 4 7 , 1]. For ¼-Cover they showed that the PoA is for affine functions is 4λ21 3λ21 and 1 + 4λ+1 for linear ones. Finally, for Scale they give a bound of 2h(h+2) and r L (1) = 0.
To the best of our knowledge our work is the first to consider a model with unsplittable variable size jobs.

C. Our Results
Let ïG, ³ð be a Stackelberg load balancing game. The leader aims to minimize the makespan of the schedule achieved after the addition of selfish jobs. We consider two questions: 1) How should the leader choose the jobs it controls? 2) How should it schedule them on the machines? In Section II, we present results for games with two job sizes, that is, for all j * J , p j * {1, p}. First, in Section II-A we characterize the social optimum in these instances in leader-free settings. In Section II-B, we consider settings where the leader must exploit all of its power and we show that it may result with a worst schedule than a NE in a leader-free environment. In Section II-C we show that when ³ g min{ n1 P , npp P } the leader can guarantee an optimal NE. Furthermore, we show that for every ³ g 0, for every game G with two job sizes, P oAL(G, ³) f 1 + p21 OP T (G) . In Section III, we analyze the PoAL as a function of ³ and compare it to the PoA in a leader-free game. We show that for ³ < 1 m+1 , P oAL(G, ³) = P oA(G). We also show a lower bound of ³ g 1 m from which we can guarantee P oAL(G, ³) < P oA(G). Furthermore, we present and analyze two strategies for choosing and scheduling the controlled jobs.
In Section IV, we present the leader's heuristics for both choosing the controlled jobs and assigning them to machines. In Section V we present our experimental results.
We conclude in Section VI, where we summarize the work and suggest some directions for future work. Due to space constraints, some of the technical proofs are omitted.

II. INSTANCES WITH TWO JOB SIZES {1, p}
In this section, we consider the class G 2 of game instances with only two different job sizes, w.l.o.g., 1 and p. Formally, G * G 2 if there exists a constant p > 1 such that "j * J , p j * {1, p}. We denote by 3-job a job of size 3. Let n 1 and n p denote the number of 1-jobs and p-jobs, respectively. It is easy to see that LPT algorithm is optimal for any G * G 2 .

A. Social Optimum in Leader-Free Games
We first provide some simple observations regarding the social optimum and leader-free games in G 2 .
First, we denote r G to be the number of machines with exactly + Proof: Consider an optimal LPT schedule of G * G 2 . If n p > 0 then LPT first schedules all the p-jobs in a balanced way. The makespan after this stage is + np m ,p. For the makespan to remain + np m ,p, the number of 1-jobs must be at most (m 2 r G )p, since otherwise, n1+npp m > + np m ,p. If n 1 > (m 2 r G )p, then the number of 1-jobs is sufficient to perfectly balance the load on the machines, up to a gap of 1, hence, the resulting schedule has a makespan of + P m ,. Proposition 2.2: For every load balancing game G * G 2 , if P oA(G) > 1, then in every sub-optimal NE s, every machine a with L a (s) > OP T (G) processes only p-jobs. Proof: Let G * G 2 such that P oA(G) > 1. Let s be a NE of G such that cost(s) > OP T (G). Let a be a machine with L a (s) > OP T (G). By the pigeonhole principle, there must be a machine b for which L b < OP T (G). Hence, L a (s) > L b (s) + 1. Machine a processes only p-jobs, as otherwise, any 1-job on machine a would benefit from migrating to machine b, contradicting the stability of s.
Next, we characterize instances for which every NE is optimal. First, we calculate some useful values. Denote G * G 2 to be a game with n 1 > (m 2 r G )p. In order to calculate the value of OP T (G) we take s to be an LPT schedule which we know is optimal. Each machine has at least h p-jobs on it and there are m 2 r G machines with exactly h which has exactly (m 2 r G )p 1-jobs scheduled on them since OP T (G) > + np m ,. Thus, we have n p p-jobs and (m 2 r G )p 1-jobs in order to have all the machines with load of + np m ,. Hence, there are NETA STEIN, TAMI TAMIR: STACKELBERG STRATEGIES FOR WEIGHTED LOAD BALANCING GAMES more n 1 2 (m 2 r G )p 1-jobs in J and the maximal load they reach is + n12(m2rG)p m ,. Denote this value to be B G and we get in total OP T (G) = + P m , = + np m , + B G . For some schedule s 2 if there is a machine i with L i (s 2 ) > OP T (G) then it must be that there are only p-jobs on i. The number of p-jobs on i is + np m , + + BG p , + 1, meaning, the number of p-jobs that fits in a machine with load OP T (G) and additional 1 p-job. We denote the number of p-jobs on i to be C G . Using the above definitions, we can characterize instances for which every NE is optimal (proof omitted). Proposition 2.3: For every load balancing game G * G 2 , P oA(G) = 1 iff at least one of the following conditions holds: ,+p or (n p p21)(m21) f n 1

B. The Leader Controls Maximal Load from ³P
In this section we assume that the leader must fully exploit its power, that is, the leader must control a subset of jobs whose total size is maximal among subsets of total size at most ³P . We assume that the leader has the computational power to identify such a subset. In particular, if there exists a subset of the jobs with total size ³P , then the leader must control such a subset. A game in which the leader must control such a subset is denoted ïG, = ³ð.
The definition of PoAL is adjusted to fit this case as follows: We first show that controlling the maximal possible load may not always minimize the PoAL.

Proof:
Let G be a weighted Stackelberg load balancing game with m = 2, p = 4, n p = 3 and n 1 = 2 and let We have P = 14, thus, the leader must control jobs of total size 5. This implies that the leader controls one 4-job and one 1-job. W.l.o.g. the leader controls jobs j 1 and j 4 . Figure  1(a) presents an optimal schedule of J . OP T (G) = 8 and by Proposition 2.1 P oA(G) = 1. We show that P oAL(G, = ³) > 1. If the leader schedules both of the jobs on the same machine, w.l.o.g., on machine m 1 , then a possible NE is depicted in Figure 1(b). We have L 1 (s) = 9 and L 2 (s) = 5. The only job that may benefit from a migration is the 1-job on m 1 . However, this job was assigned by the leader and cannot change its assignment.
If the leader schedules each of the two controlled jobs on a different machine, w.l.o.g., s 1 = 1 and s 4 = 2, then a possible NE is a one where j 2 , j 3 are scheduled on m 1 and j 5 on m 2 . We have, L 1 (s) = 9 and L 2 (s) = 5 as depicted in Figure  1(c). The only job that may benefit from a migration is the 1-job on m 1 . However, this job was assigned by the leader and cannot change its assignment.
Hence, P oAL(G) = 9 8 > 1 = P oA(G). We show that there is no constant ³ < 1 such that controlling ³ of the total load is sufficient to guarantee an optimal assignment. Theorem 2.5: For every ÷ > 0 and every p > 1, there exists a load balancing game G * G 2 such that P oAL(G, = ³) g 1+ 1 p for ³ g 1 2 ÷.
Proof: Given ÷, p, let m g 3 be an integer such that 2p21 m f ÷ and let ÷ 2 = 2p21 pm . Let G be a game on m machines. Let n 1 = p and n p = m 2 1. Thus, P = pm. Since the leader controls a fraction 1 2 ÷ 2 of the total load and ÷ 2 P = 2p 2 1, it must be that the leader does not control exactly one p-job and p 2 1 1-jobs, that is, A consists of a single 1-job and m 2 2 p-jobs.
In every optimal schedule for G, all the machines have load p. Specifically, on m 2 1 machines there is one p-jobs and on one machines there are p 1-jobs. Thus, OP T (G) = + P m , = p. In order to achieve an optimal solution, the leader must schedule the jobs in A in a sub-assignment of an optimal schedule, since otherwise it cannot be completed to an optimal schedule. We show that the leader cannot schedule the jobs of A such that any stable addition of the selfish jobs is optimal.
The only possible assignment for the leader, is to schedule m 2 2 p-jobs on m 2 2 machines and the single 1-job on another machine. After the assignment of A, there is an empty machine. A possible stable assignment of the selfish jobs is produced by adding one p-job to the machine with load 1 and assigning the p 2 1 1-jobs on the empty machine. (see Figure  2) In this case, it is easy to see that the resulting schedule is stable against deviations of the selfish jobs, thus, the resulting schedule has cost p + 1 and P oAL = 1 + 1 p .

C. Games with Optional Control
As shown in section II-B, forcing the leader to fully exploit its power may be harmful. We therefore consider next the more flexible and reasonable setting in which the leader may choose the amount of load it controls out of the maximal allowed fraction ³.
Theorem 2.6: For every game ïG, ³ð with G * G 2 and ³ g min{ n1 P , npp P } it holds that P oAL(G, ³) = 1. Proof: Let G * G 2 . If ³ g npp P , the leader may choose to control all of the p-jobs and none of the 1 jobs. If ³ g n1 P , it can choose to control all of the 1-jobs. The leader would schedule the controlled jobs in a sub-assignment of an optimal schedule. Since all of the selfish jobs have the same size, they will complete the assignment in a balanced schedule, which is optimal.
Theorem 2.7: For every ³ g 0 and G * G 2 , P oAL(G, ³) f 1 + p21 OP T (G) . Proof: Let G * G 2 be a weighted Stackelberg load balancing game. Assume that the leader assigns the controlled jobs in a sub-assignment of an optimal schedule. We show that for any completion of this sub-assignment to a NE, s, it holds that cost(s) f OP T (G) + p 2 1.
Assume by contradiction that there is a machine m i with L i (s) g OP T (G) + p. By Proposition 2.2 the only selfish job on m i are p-jobs. Also, since the leader schedule the jobs in a sub-optimal assignment then there is at least one selfish job j on m i . By the pigeonhole principle there is a machine m i 2 with L i 2 < OP T (G). Thus, j would benefit from migrating to m i 2 and s is not stable.

III. INSTANCES WITH ARBITRARY JOB SIZES
Algorithm 1 presents a strategy for the leader, given the job sizes and the fraction of load 0 f ³ f 1 that the leader may control. Recall that P = j p j . Thus, the leader may choose to assign any subset of jobs of total load at most ³P . We assume that the leader has unlimited computational power, in particular, it may solve NP-hard problems.
Algorithm 1 -A strategy for assigning the controlled jobs on m machines 1: Sort the jobs such that p 1 g · · · g p n 2: Let k be the maximal index for which jfk p j f ³P . 3: Assign the k first jobs in a way that minimizes the maximal load on a machine. The analysis is similar to the analysis of the PTAS for the minimum makespan problem [9]. Let s 2 be the schedule of the k longest jobs and let s denote the NE profile after the selfish jobs join. If cost(s 2 ) = cost(s) then s is optimal for G. Otherwise, cost(s) g OP T (G).
Let j be the job determining cost(s). Since s is NE, every machine has load of at least cost(s) 2 p j . Therefore, P g m(cost(s) 2 p j ) + p j . Also, since the jobs are sorted in nonincreasing order of processing times, we have that p j f p k+1 and therefore, P g m · cost(s) 2 (m 2 1)p k+1 . Furthermore, a lower bound for the optimal solution is a perfectly balanced schedule, thus, OP T (G) g P m , which implies that cost(s) f OP T (G) + (1 2 1 m )p k+1 . Next we bound p k+1 in terms of OP T (G). To obtain such a bound, consider the k +1 longest jobs. In an optimal schedule, some machine is assigned at least + k+1 m , g 1 + + k m , of these jobs. Since each of these jobs has processing time at least p k+1 , we conclude that OP T (G) g (1 + + k m ,)p k+1 , which implies that p k+1 f OP T (G) 1++ k m , and finally, Our next results identify the threshold fraction ³, such that controling less than fraction ³ may not be helpful at all while controlling at least fraction ³ is guaranteed to be beneficial.
Theorem 3.2: If ³ < 1 m+1 then P oAL(G, ³) = P oA(G). Proof: Recall that P oA(G) = 2 2 2 m+1 . We show that there exists a game G for which P oAL(G, ³) = 2 2 2 m+1 for every ³ < 1 m+1 . Given m, the set of players in G consists of m 2 2m jobs of size 1 and two jobs of size m. Thus, P = m 2 +m. OP T (G) = m + 1 achieved by assigning the two long jobs on different machines and balance the load with the unit jobs.
Assume the leader controls a fraction ³ < 1 m+1 of the load. Thus, it controls load less than m, implying that it controls at most m 2 1 unit jobs. Therefore, after the leader schedules the controlled jobs, there is an empty machine m 1 .
In a possible NE schedule s the two m-jobs are assigned on m 1 and all of the unit jobs are balanced on the remaining machines, each having load m.
We show that s is NE. Clearly, none of the unit jobs on machine i ; = 1 may benefit from a migration since L i (s) = m and L 1 (s) = 2m. Moreover, since for every i ; = 1 L i (s) = m and there are only two m-jobs scheduled on m 1 , they will not benefit from a migration.
Therefore, for any ³ < 1 m+1 we have a NE s with cost(s) = 2m. Thus, P oAL(G, ³) = 2m m+1 . In order to show that controlling a fraction ³ g 1 m21 guarantees a reduced equilibrium inefficiency, we characterize instances that achieve the worst PoA. We first show that every optimal solution must be perfectly balanced and then that there are at least m relatively short jobs. Proof: Let G be a game with P oA(G) = 2m m+1 and let r = OP T (G) m+1 . Let s be a schedule such that cost(s) = 2mr. Therefore, there is a machine M a with L a (s) = 2mr.
Assume by contradiction that OP T (G) > P m , thus, P < r(m 2 + m) then i; =a L i (s) < r(m 2 2 m). Therefore, there is a machine b ; = a with L b < rm. Also, since L a (s) = 2mr and OP T (G) = r(m + 1) it must be that M a processes at least two jobs and the shortest job on M a has size at most rm. By migrating to M b , the shortest job on M a will reduce its cost below 2rm, contradicting the stability of s. . If the leader controls A, since |A| f m, it may schedule each job on a different machine. Let s 2 be the resulted schedule s 2 after the selfish jobs reach NE.
We show that the schedule s 2 is a NE for a game with all selfish jobs. Assume there is a job j scheduled on machine a that may benefit from a migration. Then since all of the jobs with p f opt(G) 2 are satisfied, it must be that p j > OP T (G) 2 and there is a machine b with L b (s 2 ) < OP T (G) 2 . Also, machine b has an additional job j 2 scheduled on it, since otherwise j is the only job on a and it may not benefit from a migration. It must be that p j 2 f OP T (G) 2 since the leader scheduled all of the larger jobs on distinct machines. Thus, j 2 may benefit by migrating to b. Contradicting the stability of the jobs with sizes smaller than OP T (G) 2 .
Since s 2 is a NE then it must be that cost(s 2 ) f (2 2 2 m+1) )OP T (G). Also, we showed that in every NE with cost (2 2 2 m+1) )OP T (G) it must be that there is a machine with two jobs larger than OP T (G) 2 . Thus, since s 2 does not satisfy the condition, cost(s 2 ) < (2 2 2 m+1) )OP T (G). Algorithm 2 presents a strategy for the leader, given a fraction ³, which is the load of jobs the leader control.
Algorithm 2 -A strategy for finding an approximation for a schedule with m machines 1: Sort the jobs such that p 1 g · · · g p n 2: Assign the k first jobs such that k i=1 p i f ³P in First-Fit with limit of C 7 .

Theorem 3.6:
For every ³ f m m+1 , Algorithm 2 gives P oAL(G, ³) g 2 2 2 m+1 . Proof: Given m, let G be a game for which the set of players in G consists of m jobs of size m and m jobs of size 1. Thus, OP T (G) = m+1 is achieved in a balanced schedule and P oA(G) = 2 2 2 m+1 . Let ³ f m m+1 be the fraction of controlled load. Therefore, the leader controls at most m 2 1 jobs with size m.
If C 7 g 2m, if the leader controls only one job, then the cost after the selfish jobs join may be the worst case. Otherwise, the leader assigns at least two m-jobs on a machine. in both case cost(s) g 2m and P oAL(G, ³) g 2 2 2 m+1 . If C 7 < 2m the leader assigns only one m-job on at most m 2 1 machines. Let M 1 be one of those machines. In a possible NE schedule s a selfish m-job is assigned on M 1 , the selfish m-jobs are assigned on different machines and all of the unit jobs are assigned on a single machine. Therefore, each machine having load m except M 1 , with L 1 (s) = 2m. Thus, P oAL(G, ³) = 2 2 2 m+1 .

IV. OUR HEURISTICS
In this section we describe the heuristics we have designed and implemented. An instance in our experiments is characterized by a set of jobs, a number of machines and two different heuristics. The first defines the leader's strategy and depends on the fraction of load it controls and the second defines the selfish players behaviour. We describe each of these two classes of heuristics separately.

A. Leader's Strategy
A leader's strategy consists of two steps: (i) Choosing the controlled jobs, (ii) Scheduling the controlled jobs. In this section we describe the heuristics we propose for these steps. Note that the leader's strategy is independent of the selfish jobs' behaviour, however, the leader may benefit and adjust its heuristic if it is known in advance how the selfish jobs will act after it is done assigning the controlled jobs.
1) Choosing the Controlled Jobs: Given a fraction 0 f ³ f 1, the leader needs to choose the jobs it controls. Recall that P = j p j . Given 0 f ³ f 1, the leader may control jobs of total load at most ³P . We implemented three simple heuristics. In the first heuristic, denoted Pick Smallest, the leader sorts the jobs in non-decreasing order of size and adds jobs according to this order as long as their total size is at most ³P .
In the second heuristic, the leader sorts the jobs in nonincreasing order. For choosing the controlled jobs there are two options: it may choose the largest jobs prefix of this sorted set whose total size is at most ³P and stop when the next job can not fit, we denote this heuristic Pick Largest -Stop, or it may add jobs according to the sorted order and skip jobs whose addition will make the total load more than ³P , we denote this strategy Pick Largest -Skip. 2) Leader's Scheduling Strategy: Given the set of controlled jobs, the leader's next mission is to schedule them on the machines. We assumed the leader has limited computational power, meaning, it cannot solve N P -hard problems and in particular, it cannot calculate an optimal schedule for the jobs.
The first algorithm we implemented returns an LPT schedule. Meaning, the leader first sorts the controlled jobs in a non-increasing order. Next, it assigns one job at a time to a least loaded machine. We denote this heuristic Leader's LPT.
The second algorithm uses the bin packing algorithm First Fit. We denote this heuristic Leader's FF. The bin packing problem is an optimization problem, in which items of different sizes must be packed into a finite number of bins or containers, each of a fixed given capacity, in a way that minimizes the number of bins used. First Fit algorithm packs each item into the first bin where it fits, possibly opening a new bin if the item cannot fit into any currently open bin.
We consider the machines as bins and the jobs as items. Let L = j*J pj m . Clearly, L is a lower bound on OP T . In our heuristics, the bins' capacity is determined to be µL for different values of µ * {0.9, 1, 1.1}. The leader sorts the job on non-increasing order and then uses First Fit with the chosen bins capacity to schedule the controlled jobs on the machines. If some job cannot fit into any machine without an overflow beyond µL (this may happen if ³ is relatively large), then the jobs is assigned on a lightly loaded machine.

B. Selfish Player's Strategies
The selfish players behaviour also has significant impact on the results. We considered two methods according to which the selfish players reach a NE.
In the first method the selfish players are added to the game sequentially, each added to a least loaded machine at that time.
The jobs are considered in LPT order. We denote this strategy Player's LPT. We claim that in this case, after adding the selfish players, the schedule is stable against deviation of the selfish players. The proof of the following claim follows from the analysis of LPT for classical load balancing games [21].
Claim 4.1: LPT algorithm for non-empty machines produces a NE for the selfish jobs.
In the second method the jobs are added greedily in arbitrary order and then we use Best Response Dynamics (BRD). The best response dynamics is one of the most elementary methods in game theory. Using Round Robin according to the jobs assignment order. Each player at its turn tries to improve its state. If there is a machine for which the player may benefit from a migration, it will migrate to a most beneficial option. Otherwise, it stays on the same machine. The algorithm stops when non of the players has a beneficial migration. It is known that BRD algorithm converges to a NE when starting the algorithm with empty machines. The discussed case of adding players to non-empty machines is a sub-problem of it and achieves NE similarly.

V. EXPERIMENTAL RESULTS
Our instances consist of 20 machines and 100 jobs. It is common to use exponential times for job processing times as it is often a good approximation of service times [19]. In order to work with integers, we used geometrical distribution and chose parameter 0.13 which provides instances with mostly small jobs, with an amount of larger jobs that allows many combinations of equilibrium with different makespan values. Diversity of job sizes and relatively low loads, enables a good comparison between different heuristics.
The random jobs generator may create jobs whose size is larger than the optimal makespan, calculated by j*J pj m . We address these jobs as outliners. The presence of such jobs hurts the comparison of the different heuristics, since they may cause that an instance will have the same makespan for all strategies. By scheduling one such long job on a machine, non of the selfish jobs may benefit by choosing this machine. In order to emphasis the differences between the different heuristics, we remove the outliners using the following method. We note that on average 1 2 2 jobs were removed from each instance. In the following sections we present our experimental results. These results were obtained by running our heuristics on the same 100 instances, each consisting of 100 players and 20 machines. For each instance we calculated the lower bound, L = j p j /M , on the optimal makespan. For each experiment we present in the diagrams the average makespan scaled by L. For example, if the average makespan in all the runs performed in some experiment is 1.2L then the corresponding bar in the figure has height 1.2. Since L f OP T , this ratio is an upper bound on the price of anarchy.

A. Choosing the Controlled Jobs
In this section, we present our results for the comparison of the first part in the leader's strategy. Specifically, we compare how the performance is affected by the fraction of load controlled by the leader and the different heuristics for choosing the leader's controlled jobs. We consider all the possible combinations of leader and selfish players strategies. Recall that Leader's FF algorithm schedules each job on the first machine where it fits with limit of µ j*J pj m on the totals' machine load for µ * {0.9, 1, 1.1}, possibly starting to schedule on a new machine if the job cannot fit into any currently open machine. In the experiment described below, we fixed µ = 1 as a representative case for the strategy. First, we can conclude that Pick Smallest provides the worst results for all ³ values and heuristics. As shown in the figures, the PoA increases with ³, meaning that the leader's control hurts the social cost.
In contrast, we can also conclude that for the other two strategies Pick Largest -Skip and Pick Largest -Stop, as ³ increases, the final schedule is better and the leader reduces the makespan in average by factor 1.16, 1.11, 1.08 if it controls 0.3, 0.5, 0.7 fraction of the load respectively. Other than that, the difference between both strategies is minor, with a slight advantage to the Pick Largest -Stop strategy in most of the cases.

B. Leader's Scheduling Strategy
In this section we discuss the optimal strategy we recommend the leader to apply on the controlled jobs. The best strategy may differ between the amount of load the leader controls, the selfish players behaviour or other parameters we examine.
The experiments that consider the selection of the controlled jobs, reported in section 5.1, reveal that Pick Largest -Stop has the best performance, thus, we use it in the following experiments.

1) Leader's First Fit:
Our next experiments analyze the influence of the parameter µ in the Leader's FF strategy. Recall that the Leader's FF strategy schedules the controlled jobs using First Fit algorithm with machine capacity of µ j pj m for µ > 0. We applied this strategy with µ * {0.9, 1, 1.1}. These values were chosen since we aim to have approximate PoA closer to 1; if we choose a low µ value, the selfish players may determine the makespan since larger jobs may join nonempty machines.
If we choose higher µ value, then already the jobs assigned by the leader may cause a high makespan. On the other hand, this leaves more empty machines for the selfish jobs and potentially prevents them from reaching load higher than µ j pj m on the reamaining machines. Figures 8 and 7 present the approximated PoA with regards to the discussed options for µ parameter and the controlled fraction ³ achieved with ³ * {0.3, 0.5, 0.7} and µ * {0.9, 1, 1.1}. In the experiments described in Figure 7 the selfish jobs join and perform BRD. In the experiments described in Figure 8 they are added using LPT rule. As presented in Figure 7, when the selfish players use Player's BRD strategy, for every fraction ³, the best performance is achieved when µ = 1. For µ = 0.9 we have significantly worst result for ³ * {0.3, 0.5}, but better than µ = 1.1 for ³ = 0.7. This difference is explainable since the leader have the most significant control for this ³ and both approximated PoA results values are below 1.1 and for µ = 1.1 the leader schedules as much as it can near the load of 1.1 j pj m which ensured result near 1.1. In contrast to µ = 0.9 which allowed lower results.
On the other hand, for Player's LPT in Figure 8 we get consistent results for all ³ values. We get the worst results for the value µ = 0.9. Next, we have µ * {1, 1.1} with close results, with a minor advantage to µ = 1.1.

2) Leader's Strategy:
We conclude with experiments that compare the leader's strategy choice with regards to the selfish players behaviour. Based on the results of thee previous experiments, in all the experiments we report in this section, the controlled jobs are chosen using Pick Largest -Stop and for Leader's FF we use parameter µ = 1. In the experiments presented bellow, we compared which leader's strategy gives better results with respect to the applied player's strategy for every ³ choice. The results shown in both Figures 9 and 10, imply that for ³ = 0.3 we get better makespan when using Leader's FF strategy. On the other hand, for larger ³ we get that Leader's LPT perform better. Moreover, we can conclude that when the selfish players use BRD, the difference between the makespans resulting from the two leader's strategy are more significant comparing to games in which the selfish players are added by LPT.
Another interesting result we can infer from these experiments, is the difference between the results for selfish players behaviour. For all ³ values and leader's strategy choice, we get much lower makespans when the selfish players use BRD.

VI. CONCLUSIONS
In this work we examined the potential influence of a leader who control a subset of the jobs in load balancing games. The leader assigns the jobs it controls and the other jobs then select their assignments in a selfish way. We present theoretical as well as experimental results answering several questions regarding the advantages and disadvantages of controlling a fraction of the load. We have designed and implemented several heuristics for possible strategies the leader may apply when choosing the jobs to control and when scheduling them on the machines.
In the theoretical results, we proved that if the leader is obligated to control a maximal amount of the given fraction, the resulting schedule may be worse than a NE schedule in a leader-free environment. On the other hand, for a setting in which the leader may choose to exploit only part of its power, we presented tight bounds on the fraction ³ of the controlled load that may improve the game cost. Additionally, we presented several relations between the common P oA(G) measure and the P oAL(G, ³) measure which we defined.
Our experiments show that controlling the largest jobs in a game is the best strategy for the leader, while controlling the smallest jobs may cause significant damage. In fact controlling no job may be better than controlling only small ones. One of the main conclusions that resulted from the experiments is that controlling a larger fraction of the load improves the game cost when controlling the larger jobs.
We have observed that when using the heuristic Leader's FF, the performance is significantly influenced by the choice of the capacity to which the machines are loaded. Let L = j pj m , then for a parameter µ, the leader adds jobs to machine in a First-Fit matter, where each job is added to the first machine whose addition will result in total load at most µL. In general, the best result achieved for this strategy is when µ = 1. Although, if the selfish players scheduling strategy is known to be LPT, then filling the machines up to capacity 1.1L results is slightly better outcomes. Also, for large ³ values the results for all µ values are very close, but on the other hand for low ³ we can definitely conclude that we should not use µ less than 1. Future work on this algorithm may find more characteristics for choosing the µ value.
Another conclusion we can infer, is that knowing the selfish player's behaviour in advance may be helpful for the leader. Similarly, the strategy choice depends also on ³ -the fraction of controlled jobs. In general, for both selfish players methods it holds that the Leader's LPT strategy gives the best results, but if it is known that the selfish players acts in BRD and the controlled fraction is low we may consider using Leader's FF.
For future work it may be interesting to improve the Leader's FF strategy and characterize the jobs that the leader should choose specifically for using this heuristic. Leader's FF is a heuristic in which the leader assigns the controlled jobs on a subset of the machines and leave some of the machines empty for the selfish jobs. We believe that additional algorithms using this approach should be considered and analyze and may perform even better than Leader's FF. Also, it may be interesting to get inspiration from additional known approximation algorithms for the minimum makespan problem as we did with Leader's LPT which is based on the algorithm presented in [7].
In the theoretical side, we believe that there are many interesting open problems in this setting. For example, analyzing weighted Stackelberg games of congestion games with nonsingelton strategy space, non symmetric singelton games, or games with non-uniform resources, that is, machines with different speeds. Also, in our settings the leader has unlimited computational power, meaning, it is able to solve NP-hard problems. It will be interesting to have results for a leader with a limited computational power. Another interesting direction is to analyze the consequences of controlling a specific given subset of jobs A ¦ J instead of a fraction ³ of the load.