Job scheduling game

From Wikipedia, the free encyclopedia
Jump to: navigation, search

In game theory, a job scheduling game is a game that models a scenario in which multiple selfish users wish to utilize multiple processing machines. Each user has a single job, and he needs to choose a single machine to process it. The incentive of each user is to have his job run as fast as possible.

Definition[edit]

Job scheduling games are the following set of problems: given  M machines and N jobs. Each job i is associated with a vector p_i  = (p_i^1,...,p_i^m) , corresponding to its size on each machine (i.e.,  p_i^j is the processing time of job i on machine j). Players correspond to jobs. The strategy set of each player is the set of machines. Given a strategy for each player, the total load on each machine is the sum of processing times of the jobs that chose that machine. Usually each player seeks to minimize the total load on its chosen machine. The standard objective function is minimizing the total load on the most-loaded machine (this objective is called makespan minimization).

For example: given game with 2 machines M1 and M2 and 2 jobs J1 and J2. The rows represent the strategies job J1 can choose and the columns represent the strategies job J2 can choose.

J1/J2 M1 M2
M1 (1,10) (10,10)
M2 (1,1) (10,1)

Motivation[edit]

The problem of dividing several jobs among several machines in a way that optimizes some global objective function is well known and has been widely studied in computer science. In this type of problems there is a central designer that determines the allocation of jobs into machines and all the participating entities are assumed to obey the protocol. However, since the emergence of the Internet, problems in distributed settings has been studied as well. In this type of problems, different machines and jobs may be owned by different strategic entities, who will typically attempt to optimize their own objective rather than the global objective.

Main Properties[edit]

The price of stability is used to measure inefficiency. It differentiates between games in which all equlibria are inefficient and those in which there exists an equilibrium that is inefficient

For every job scheduling game price of stability is equal to 1[edit]

proof: Price of stability is equal to best Nash equilibrium divided by OPTimum. Therefore, in order to prove that Price of stability = 1 it is sufficient to prove that the optimum is equal to the best Nash equilibrium. In order to proof that, it is sufficient to proof that there is an OPTimum solution which is in Nash equilibrium, since if the OPTimum is also Nash equilibrium it is especially best Nash equilibrium.

The optimum state is when the most loaded machine is the less loaded it can be. Assuming each job which was scheduled to the most loaded machine will not aspire to move to another machine. In addition, each job that was scheduled to a machine which is not the most loaded one, will not aspire to move to the most loaded machine. Given a game with in the optimum state with  M machines. Assuming there is a job  x that aspire to be scheduled on machine  M_i instead of being scheduled on the most loaded machine -  M_d. In that case, there exist a machine that after job x was transfer, its load is less than the load of the machine  M_d before job x changed. This is in contradiction to the assumption that the game is in the OPTimum state. Therefore, job will not be reassigned from and to the most loaded machine. We will now observe the scheduling of the  M-1 machines left and the amount of jobs left (with out the jobs that was scheduled on machine  M_d). For the same reasons that were mention earlier, there is no job that would like to move from the (new) most load machine or to the (new) most load machine. By passing all  M machines in inductive steps we will get n jobs scheduled to  M .This jobs will not aspire to move from their own machine. Meaning, for each job, its strategy is its best response to the profile. In other words we have got an OPTimum state which is also in Nash equilibrium. Thus, price of stability = 1.


The price of anarchy is a concept from game theory that describes the difference in maximum social utility and the utility of an equilibrium point of the game.

There exist job scheduling game where Price of anarchy is not bounded[edit]

claim: Price of anarchy = \infty .

proof: Given a game with 2 machines M_1 and M_2 and 2 jobs J_1 = 1,K and J_2 = K,1 for any natural  K >1 . In this game, job J_1 cost 1 on machine M_1 and K on machine M_2 , and job J_2 cost K on machine M_1 and 1 on machine M_2 . Therefore, the OPTimum state is when J_1 is scheduled to M_1 and J_2 scheduled to M_2 since the objective function is 1. Moreover, the worst Nash equilibrium is when J_1 is scheduled to M_2 and J_2 scheduled to M_1 since the objective function is K. It is a Nash equilibrium because if job J_1 will be scheduled to machine  M_2 the total load of this machine will raise from K to K+1, and likewise for job  J_2 . Since Price of anarchy is equal to worst Nash equilibrium divided by Optimum, price of anarchy = K . This is true for any natural K and thus price of anarchy is not bounded as claimed.

External links[edit]