Unrelated-machines scheduling is an optimization problem in computer science and operations research. It is a variant of optimal job scheduling. We need to schedule n jobs J₁, J₂, ..., J_n on m different machines, such that a certain objective function is optimized (usually, the makespan should be minimized). The time that machine i needs in order to process job j is denoted by p_i,j. The term unrelated emphasizes that there is no relation between values of p_i,j for different i and j. This is in contrast to two special cases of this problem: uniform-machines scheduling - in which p_i,j = p_i / s_j (where s_j is the speed of machine j), and identical-machines scheduling - in which p_i,j = p_i (the same run-time on all machines).

In the standard three-field notation for optimal job scheduling problems, the unrelated-machines variant is denoted by R in the first field. For example, the problem denoted by " R||${\displaystyle C_{\max }}$" is an unrelated-machines scheduling problem with no constraints, where the goal is to minimize the maximum completion time.

In some variants of the problem, instead of minimizing the maximum completion time, it is desired to minimize the average completion time (averaged over all n jobs); it is denoted by R||${\displaystyle \sum C_{i}}$. More generally, when some jobs are more important than others, it may be desired to minimize a weighted average of the completion time, where each job has a different weight. This is denoted by R||${\displaystyle \sum w_{i}C_{i}}$.

In a third variant, the goal is to maximize the minimum completion time, " R||${\displaystyle C_{\min }}$" . This variant corresponds to the problem of Egalitarian item allocation.

Algorithms

Linear programming formulation

A natural way to formulate the problem as a linear program is called the Lenstra–Shmoys–Tardos^[9] linear program (LST LP). For each machine i and job j_, define a variable ${\displaystyle z_{i,j}}$, which equals 1 iff machine i processes job j, and 0 otherwise. Then, the LP constraints are:

• ${\displaystyle \sum _{i=1}^{m}z_{i,j}=1}$ for every job j in 1,...,n;
• ${\displaystyle \sum _{j=1}^{n}z_{i,j}\cdot p_{i,j}\leq T}$ for every machine i in 1,...,m;
• ${\displaystyle z_{i,j}\in \{0,1\}}$ for every i, j.

Relaxing the integer constraints gives a linear program with size polynomial in the input. Solving the relaxed problem can be rounded to obtain a 2-approximation to the problem.^[9]

Another LP formulation is the configuration linear program. For each machine i, there are finitely many subsets of jobs that can be processed by machine i in time at most T. Each such subset is called a configuration for machine i. Denote by C_i(T) the set of all configurations for machine i. For each machine i and configuration c in C_i(T), define a variable ${\displaystyle x_{i,c}}$ which equals 1 iff the actual configuration used in machine i is c, and 0 otherwise. Then, the LP constraints are:

• ${\displaystyle \sum _{c\in C_{i}(T)}x_{i,c}=1}$ for every machine i in 1,...,m;
• ${\displaystyle \sum _{i=1}^{m}\sum _{c\ni j,c\in C_{i}(T)}x_{i,c}=1}$ for every job j in 1,...,n;
• ${\displaystyle x_{i,j}\in \{0,1\}}$ for every i, j.

Note that the number of configurations is usually exponential in the size of the problem, so the size of the configuration LP is exponential. However, in some cases it is possible to bound the number of possible configurations, and therefore find an approximate solution in polynomial time.

Special cases

There is a special case in which p_i,j is either 1 or infinity. In other words, each job can be processed on a subset of allowed machines, and its run-time in each of these machines is 1. This variant is sometimes denoted by " P|p_j=1,M_j|${\displaystyle C_{\max }}$". It can be solved in polynomial time. ^[10]

Extensions

Kim, Kim, Jang and Chen^[11] extend the problem by allowing each job to have a setup time, which depends on the job but not on the machine. They present a solution using simulated annealing. Vallada and Ruiz^[12] present a solution using a genetic algorithm.

Caragiannis^[13] extends the problem in a different way, by assuming that the jobs are owned by selfish agents (see Truthful job scheduling).

External links

• Summary of parallel machine problems without preemtion

References