Identical Parallel Processors Research Articles

Power-aware scheduling of preemptable jobs on identical parallel processors to minimize makespan

This paper deals with power-aware scheduling of preemptable jobs on identical parallel processors to minimize schedule length when jobs are described by continuous, strictly concave functions relating their processing speed at time t to the amount of power allotted at the moment. Power is a continuous, doubly constrained resource, i.e. both: its availability at time t and consumption over scheduling horizon are constrained. Precedence constraints among jobs are represented by a task-on-arc graph. A methodology based on properties of optimal schedules is presented for solving the problem optimally for a given ordering of nodes in the graph. Heuristics for finding an ordering which leads to possibly short schedules are proposed and examined experimentally.

TABU SEARCH FOR MULTIPROCESSOR SCHEDULING: APPLICATION TO HIGH LEVEL SYNTHESIS

This paper describes a tabu search approach for a multiprocessor scheduling problem, where a list of jobs has to be scheduled on identical parallel processors. Each job in the list has a release date, a due date, a processing time and a set of predecessors. The objective is to minimize the number of processors used while respecting the constraints imposed by release dates, due dates and precedences. Two versions of this problem are considered here, in the first one precedence constraints are relaxed, they are taken into account in the second one. The proposed method is used to solve High Level Synthesis problem instances. The results show the effectiveness of our approach for both versions of the problem. A comparison with an exact method is also conducted.

Worst case analysis of decomposed software pipelining for cyclic unitary RCPSP with precedence delays

In this paper, we address a cyclic scheduling problem of finding a periodic schedule with minimal period for the unitary resource constrained cyclic scheduling problem. The main originality is in being able to cope with both precedence delays and complex resource settings which make the problem \(\mathcal{NP}\)-complete, in general.A guaranteed approach, called Decomposed Software Pipelining, has been proposed by Gasperoni and Schwiegelshohn (Parallel Process. Lett. 4:391–403, 1994), followed by the retiming method by Calland et al. (IEEE Trans. Parallel Distrib. Syst. 9(1):24–35, 1998) to solve the problem assuming parallel identical processors and ordinary precedence constraints. In this paper, an extension of this approach to unitary resource-constrained cyclic scheduling problems with precedence delays, is analyzed and its worst case performance ratio is provided.

Resource level minimization in the discrete–continuous scheduling

A discrete–continuous problem of non-preemptive task scheduling on identical parallel processors is considered. Tasks are described by means of a dynamic model, in which the speed of the task performance depends on the amount of a single continuously divisible renewable resource allotted to this task over time. An upper bound on the completion time of all the tasks is given. The criterion is to minimize the maximum resource consumption at each time instant, i.e., the resource level. This problem has been observed in many industrial applications, where a continuously divisible resource such as gas, fuel, electric, hydraulic or pneumatic power, etc., has to be distributed among the processing units over time, and it affects their productivity. The problem consists of two interrelated subproblems: task sequencing on processors (discrete subproblem) and resource allocation among the tasks (continuous subproblem). An optimal resource allocation algorithm for a given sequence of tasks is presented and computationally tested. Furthermore, approximation algorithms are proposed, and their theoretical and experimental worst-case performances are analyzed. Computer experiments confirmed the efficiency of all the algorithms.

A Short Note on an Advance in Estimating the Worst-Case Performance Ratio of the MPS Algorithm

Recently, a new approximation algorithm for the nonpreemptive scheduling of independent jobs on m identical parallel processors has appeared in the literature. The algorithm, named $MPS$ (MultiProcessor Scheduling), combines partial solutions which satisfy suitable properties. Its performance ratio is bounded by $\frac{z+1}{z}-\frac{1}{mz}$, where z represents the number of initial partial solutions provided by the algorithm. This note presents an advanced estimate of z and, consequently, an improved worst-case performance ratio of the $MPS$ algorithm.

Scheduling multiprocessor UET tasks of two sizes

In this paper we study task scheduling problems on m identical parallel processors, where each task has unit execution time, and needs either a single processor, or q processors concurrently, and it has a release date and a due date. Under the assumption that the release dates and due dates of the q -processor tasks are agreeable, we describe a polynomial time algorithm for minimising the number of tardy tasks. In addition, we apply this result for minimising the maximum lateness, and the maximum tardiness. We also discuss the combinatorial background of the polynomial time solvability of all these problems under the ‘agreeable’ assumption.

Minimizing total weighted flowtime subject to minimum makespan on two identical parallel machines

We study the problem of scheduling n jobs on two identical parallel processors or machines where an optimal schedule is defined as one with the shortest total weighted flowtime (i.e., the sum of the weighted completion time of all jobs), among the set of schedules with minimum makespan (i.e., the completion time of the last job finished). We present a two phase non-linear Integer Programming formulation for its solution, admittedly not to be practical or useful in most cases, but theoretically interesting since it models the problem. Thus, as an alternative, we propose an optimization algorithm, for small problems, and a heuristic, for large problems, to find optimal or near optimal solutions. Furthermore, we perform a computational study to evaluate and compare the effectiveness of the two proposed methods.

A cyclic scheduling problem with an undetermined number of parallel identical processors

This paper presents two integer linear programming (ILP) models for cyclic scheduling of tasks with unit/general processing time. Our work is motivated by digital signal processing (DSP) applications on FPGAs (Field-Programmable Gate Arrays)--hardware architectures hosting several sets of identical arithmetic units. These hardware units can be formalized as dedicated sets of parallel identical processors. We propose a method to find an optimal periodic schedule of DSP algorithms on such architectures where the number of available arithmetic units must be determined by the scheduling algorithm with respect to the capacity of the FPGA circuit. The emphasis is put on the efficiency of the ILP models. We show the advantages of our models in comparison with common ILP models on benchmarks and randomly generated instances.

The worst-case analysis of the Garey–Johnson algorithm

The Garey–Johnson algorithm is a well known polynomial-time algorithm constructing an optimal schedule for the maximum lateness problem with unit execution time tasks, two parallel identical processors, precedence constraints and release times. The paper is concerned with the worst-case analysis of a generalization of the Garey–Johnson algorithm to the case of arbitrary number of processors. In contrast to other algorithms for the maximum lateness problem, the tight performance guarantee for the even number of processors differs from the tight performance guarantee for the odd number of processors.

Preemptive Parallel Processor Scheduling with Distinct Due Windows and Min-Max Criterion

Problem of scheduling n preemptive jobs on m identical parallel processors is studied, in which for each job a distinct due window is given in advance and an integer release date is specified. If a job is completed within its due window, then it incurs no penalty. Otherwise, it incurs a job-dependent earliness or tardiness cost. The objective is to find a job schedule such that a maximum of job-dependent costs associated with earliness, tardiness and a time a job is in process is minimized. It is proved that optimal solutions to this problem can be found by a solving a polynomial number of instances of classical maximum flow problem.

Algorithms for parallel processor scheduling with distinct due windows and unit-time jobs

Abstract. We have studied problems of scheduling n unit-time jobs on m identical parallel processors, in which for each job a distinct due window is given in advance. If a job is completed within its due window, then it incurs no penalty. Otherwise, it incurs a job-dependent earliness or tardiness cost. The objective is to find a job schedule such that the total weighted earliness and tardiness, maximum weighted earliness and tardiness or total weighted number of early and tardy jobs is minimized. Properties of optimal solutions of these problems are established. We proved that optimal solutions for these problems can be found in O(n) time in case of minimization of the total weighted earliness and tardiness and the total weighted number of early and tardy jobs and in O(n √

Scheduling parallel batch processors with incompatible job families to minimise weighted completion time

We consider the static scheduling of jobs to parallel identical batch processors with incompatible job families by minimising the total weighted completion time. This scheduling problem is applicable in many practical systems such as burn-in operations and wafer fabrication in semiconductor manufacturing. The scheduling problem is formulated as a mixed integer non-linear program. We develop the solution framework based on decomposition approach for the problems with realistic settings. Two heuristics are proposed based on the proposed decomposition approach and the performance of these heuristics is evaluated in the case of two and three batch processors.

Optimality of HLF for scheduling divide-and-conquer UET task graphs on identical parallel processors

The problem of scheduling a set of n unit execution time (UET) tasks subject to precedence constraints on m identical parallel processors is known to be N P -hard in the strong sense. However, polynomial time algorithms exist for some classes of precedence graphs. In this paper, we consider a class of divide-and-conquer graphs that naturally models the execution of the recursive control abstraction of divide-and-conquer algorithms. We prove that the Highest Level First (HLF) strategy minimizes the schedule length for this class, thus settling a conjecture of Rayward-Smith and Clark.

Minimizing the normalized sum of square for workload deviations on m parallel processors

In many organizations, it is desirable to distribute workload as equally as possible among a group of employees or machines. This paper proposes a performance measure, that we call the Normalized Sum of Square for Workload Deviations ( NSSWD), and studies the problem of how to schedule a set of n jobs on m parallel identical processors in order to minimize the NSSWD. The NSSWD criterion is relevant where uniformity of wear to machines or of workload to employees is desirable. An algorithm, called Workload Balancing (WB), is proposed for solving this problem. Moreover, we perform a simulation experiment to evaluate WB against several well-known heuristics in the literature. Lastly, we discuss the computational results obtained from the simulation experiment.

Scheduling of Unit-time Jobs with Distinct Due Windows on Parallel Processors

Problems of scheduling n unit-time jobs on m identical parallel processors are studied, in which for each job a distinct due window is given in advance. If a job is completed within its due window, then it incurs no penalty. Otherwise, it incurs a job-dependent earliness or tardiness cost. For the problem in which earliness and tardiness costs depend on the distance between job completion time and the due window, the objective is to find a job schedule such that a sum or maximum of weighted costs associated with earliness and tardiness is minimized. For the problem with distance-independent costs, the objective is to find a schedule such that the total weighted number of early and tardy jobs is minimized. Properties of optimal solutions of these problems are established. It is proved that these problems can be reduced to min-sum and min-max assignment problems solvable in time O(n4).

A memetic algorithm for the flexible flow line scheduling problem with processor blocking

This paper introduces an efficient memetic algorithm (MA) combined with a novel local search engine, namely, nested variable neighbourhood search (NVNS), to solve the flexible flow line scheduling problem with processor blocking (FFLB) and without intermediate buffers. A flexible flow line consists of several processing stages in series, with or without intermediate buffers, with each stage having one or more identical parallel processors. The line produces a number of different products, and each product must be processed by at most one processor in each stage. To obtain an optimal solution for this type of complex, large-sized problem in reasonable computational time using traditional approaches and optimization tools is extremely difficult. Our proposed MA employs a new representation, operators, and local search method to solve the above-mentioned problem. The computational results obtained in experiments demonstrate the efficiency of the proposed MA, which is significantly superior to the classical genetic algorithm (CGA) under the same conditions when the population size is increased in the CGA.

A New Approximation Algorithm for the Nonpreemptive Scheduling of Independent Jobs on Identical Parallel Processors

We consider the scheduling problem of n independent jobs on m identical parallel processors in order to minimize makespan, the completion time of the last job. We propose a new approximation algorithm that iteratively combines partial solutions to the problem. The worst‐case performance ratio of the algorithm is $\frac{z+1}{z}-\frac{1}{mz}$, where z is the number of initial partial solutions that are obtained by partitioning the set of jobs into z families of subsets which satisfy suitable properties. The computational behavior of our worst‐case performance ratio provided encouraging results on three families of instances taken from the literature.

SCHEDULING OF FLEXIBLE FLOW LINES WITH BLOCKING BY MEMETIC ALGORITHMS

This paper presents an efficient memetic algorithm (MA) for scheduling a flexible flow line problem by assuming processor blocking (FFLPB). The proposed MA is used to solve a mixed-integer model of the FFLPB developed in the literature. The flexible flow line consists of several processing stages in series without intermediate buffers, in which each stage has one or more identical parallel processors. The line produces several different products and each product must be processed by at most one processor in each stage. The mathematical model of the FFLPB is optimally solved and the obtained results are compared with MA runs.

PREEMPTIVE SCHEDULING ON PARALLEL PROCESSORS WITH DUE DATES

The paper presents a priority algorithm for the maximum lateness problem with parallel identical processors, precedence constraints, and preemptions. The presented algorithm calculates the priority of each task by constructing a schedule for the set of its successors. The algorithm is motivated by comparison of its nonpreemptive counterpart with other algorithms for the problem with unit execution time tasks. It is shown that the presented algorithm constructs an optimal schedule for the problem with two processors and arbitrary precedence constraints, and for the problem with an arbitrary number of processors and precedence constraints in the form of an in-tree. This proof also indicates that the presented algorithm allows the worst-case performance ratio previously established for the so-called Muntz–Coffman algorithm for a particular case of the considered problem where all due dates are zero.

Batch splitting in an assembly scheduling environment

This paper presents mathematical models and algorithms for a production scheduling problem with batch splitting of assembly operations. The operation precedence is represented in an operations network, and the operations at any particular workcenter are split into suitable batch sizes on the available identical parallel processors for faster completion. The solution methodology comprises of a batch splitting algorithm followed by a batch scheduling algorithm. The batch splitting algorithm is developed based on a preemptive scheduling algorithm after incorporating non-zero setup times. The batch scheduling algorithm is based on a critical path algorithm for an operations network. The mathematical model also considers movesizes for batches which determine the threshold for the batch size that needs to be built up before it can be transferred for the successor operation. The computational results for different problem sizes show that the proposed solution scheme can satisfactorily solve this complex scheduling problem for cases where the standard solvers fail to generate solutions within practical time limits. Moreover, there is a significant reduction in makespan due to batch splitting.