Parallel Task Scheduling

Parallel task scheduling (also called parallel job scheduling or parallel processing scheduling) is an optimization problem in computer science and operations research. It is a variant of optimal job scheduling. In a general job scheduling problem, we are given ''n'' jobs ''J''₁, ''J''₂, ..., ''J_n'' of varying processing times, which need to be scheduled on ''m'' machines while trying to minimize the makespan - the total length of the schedule (that is, when all the jobs have finished processing). In the specific variant known as ''parallel-task scheduling'', all machines are identical. Each job ''j'' has a ''length'' parameter ''p_j'' and a ''size'' parameter ''q''_j, and it must run for exactly ''p_j'' time-steps on exactly ''q''_j machines in ''parallel''.

Veltman et al. and Drozdowski denote this problem by $P, size_j, C_$ in the three-field notation introduced by Graham et al. P means that there are several identical machines running in parallel; ''size_j'' means that each job has a size parameter; ''C''_max means that the goal is to minimize the maximum completion time. Some authors use $P, m_j, C_$ instead. Note that the problem of parallel-machines scheduling is a special case of parallel-task scheduling where $size_j=1$ for all ''j'', that is, each job should run on a single machine.

The origins of this problem formulation can be traced back to 1960. For this problem, there exists no polynomial time approximation algorithm with a ratio smaller than $3/2$ unless $P=NP$.

Definition

There is a set $\mathcal$ of $n$ jobs, and $m$ identical machines. Each job $j \in \mathcal$ has a processing time $p_j \in \mathbb$ (also called the ''length'' of ''j''), and requires the simultaneous use of $q_j\in \mathbb$ machines during its execution (also called the ''size'' or the ''width'' of j).

A schedule assigns each job $j \in \mathcal$ to a starting time $s_j \in \mathbb_0$ and a set $m_j \subseteq \$ of $, m_j, = q_j$ machines to be processed on. A schedule is feasible if each processor executes at most one job at any given time.
The objective of the problem denoted by $P, size_j, C_$ is to find a schedule with minimum length $C_= \max_(s_j+p_j)$, also called the makespan of the schedule.
A sufficient condition for the feasibility of a schedule is the following

$\sum_q_j \leq m \, \forall t \in \$.

If this property is satisfied for all starting times, a feasible schedule can be generated by assigning free machines to the jobs at each time starting with time $t = 0$. Furthermore, the number of machine intervals used by jobs and idle intervals at each time step can be bounded by $, \mathcal, + 1$. Here a machine interval is a set of consecutive machines of maximal cardinality such that all machines in this set are processing the same job. A machine interval is completely specified by the index of its first and last machine. Therefore, it is possible to obtain a compact way of encoding the output with polynomial size.

Computational hardness

This problem is NP-hard even when there are only two machines and the sizes of all jobs are $q_j=1$ (i.e., each job needs to run only on a single machine). This special case, denoted by $P2, , C_$, is a variant of the partition problem, which is known to be NP-hard.

When the number of machines ''m'' is at most 3, that is: for the variants $P2, size_j, C_$ and $P3, size_j, C_$, there exists a pseudo-polynomial time algorithm, which solves the problem exactly.

In contrast, when the number of machines is at least 4, that is: for the variants $Pm, size_j, C_$ for any $m \geq 4$, the problem is also strongly NP-hard (this result improved a previous result showing strong NP-hardness for $m \geq 5$).

If the number of machines is not bounded by a constant, then there can be no approximation algorithm with an approximation ratio smaller than $3/2$ unless $P = NP$. This holds even for the special case in which the processing time of all jobs is $p_j=1$, since this special case is equivalent to the bin packing problem: each time-step corresponds to a bin, ''m'' is the bin size, each job corresponds to an item of size ''q_j'', and minimizing the makespan corresponds to minimizing the number of bins.

Variants

Several variants of this problem have been studied. The following variants also have been considered in combination with each other.

Contiguous jobs: In this variant, the machines have a fixed order $(M_1, \dots, M_m)$. Instead of assigning the jobs to any subset $m_j \subseteq \$, the jobs have to be assigned to a ''contiguous interval'' of machines. This problem corresponds to the problem formulation of the strip packing problem.

Multiple platforms: In this variant, the set of machines is partitioned into independent platforms. A scheduled job can only use the machines of one platform and is not allowed to span over multiple platforms when processed.

Moldable jobs: In this variant each job $j \in \mathcal$ has a set of feasible machine-counts $D_j \subseteq \$. For each count $d \in D_j$, the job can be processed on ''d'' machines in parallel, and in this case, its processing time will be $p_$. To schedule a job $j \in \mathcal$, an algorithm has to choose a machine count $d \in D_j$ and assign ''j'' to a starting time $s_j$ and to $d$ machines during the time interval $[s_j,s_j+p_).$ A usual assumption for this kind of problem is that the total workload of a job, which is defined as $d \cdot p_$, is non-increasing for an increasing number of machines.

Release dates: In this variant, denoted by $P, size_j,r_j, C_$, not all jobs are available at time 0; each job ''j'' becomes available at a fixed and known time ''r_j''. It must be scheduled after that time.

Preemption (computing), Preemption: In this variant, denoted by $P, size_j,r_j,\text, C_$, it is possible to interrupt jobs that are already running, and schedule other jobs that become available at that time.

Algorithms

The list scheduling algorithm by Garey and Graham has an absolute ratio $2$, as pointed out by Turek et al. and Ludwig and Tiwari.
Feldmann, Sgall and Teng observed that the length of a non-preemptive schedule produced by the list scheduling algorithm is actually at most $(2-1/m)$ times the optimum preemptive makespan.
A polynomial-time approximation scheme (PTAS) for the case when the number $m$ of processors is constant, denoted by $Pm, size_j, C_$, was presented by Amoura et al. and Jansen et al.
Later, Jansen and Thöle found a PTAS for the case where the number of processors is polynomially bounded in the number of jobs.
In this algorithm, the number of machines appears polynomially in the time complexity of the algorithm.
Since, in general, the number of machines appears only in logarithmic in the size of the instance, this algorithm is a pseudo-polynomial time approximation scheme as well.
A $(3/2+\varepsilon)$-approximation was given by Jansen, which closes the gap to the lower bound of $3/2$ except for an arbitrarily small $\varepsilon$.

Differences between contiguous and non-contiguous jobs

Given an instance of the parallel task scheduling problem, the optimal makespan can differ depending on the constraint to the contiguity of the machines. If the jobs can be scheduled on non-contiguous machines, the optimal makespan can be smaller than in the case that they have to be scheduled on contiguous ones.
The difference between contiguous and non-contiguous schedules has been first demonstrated in 1992 on an instance with $n=8$ tasks, $m=23$ processors, $C^_=17$, and $C^c_=18$.
Błądek et al. studied these so-called c/nc-differences and proved the following points:

* For a c/nc-difference to arise, there must be at least three tasks with $q_j > 1.$
* For a c/nc-difference to arise, there must be at least three tasks with $p_j>1.$
* For a c/nc-difference to arise, at least $m=4$ processors are required (and there exists an instance with a c/nc-difference with $m=4$).
* For a c/nc-difference to arise, the non-contiguous schedule length must be at least $C^_=4.$
* The maximal c/nc-difference $\sup_C^_(I)/C^_(I)$ is at least $5/4$ and at most $2.$
* To decide whether there is an c/nc-difference in a given instance is NP-complete.

Furthermore, they proposed the following two conjectures, which remain unproven:

* For a c/nc-difference to arise, at least $n=7$ tasks are required.
* $\sup_C^_(I)/C^_(I) = 5/4$

Related problems

There are related scheduling problems in which each job consists of several operations, which must be executed ''in sequence'' (rather than in parallel). These are the problems of open shop scheduling, flow shop scheduling and job shop scheduling.

References

{{Scheduling problems

Optimal scheduling
Packing problems