Discrete Optimization
A comparison of branch-and-bound algorithms for a family scheduling problem with identical parallel machines

https://doi.org/10.1016/j.ejor.2004.03.022Get rights and content

Abstract

This paper investigates branch-and-bound algorithms for the problem of scheduling jobs with family setups on identical parallel machines to minimize the weighted sum of completion times. In particular, we propose a new branching scheme that appears to substantially outperform current procedures in terms of computation time and search tree size.

Introduction

We consider the problem of scheduling N jobs on M identical parallel machines in order to minimize the weighted sum of job completion times. The set of N statically-available jobs is partitioned into G families, and there are sequence-independent setup times between jobs belonging to different families. The sequence-independent setup times, which we refer to as family setup times, depend only on the family being switched to. The number of jobs in family i is denoted by Ni, and the setup time for family i by si. A setup time for the first-processed family on each machine must be scheduled first on that machine.

The complexity of the problem for M=1 is an open question. However, for an arbitrary number of parallel machines the problem is strongly NP-hard, even if all the weights are equal. Dynamic programs have been proposed to solve problems with fixed G and M. These dynamic programs are polynomial in the sum of weights and the sum of processing and setup times, respectively. Current branch-and-bound algorithms can solve in a reasonable time, say, five machine problems with up to 15 jobs. Branching within the branch-and-bound algorithms involves adding a new job to a partial schedule, at the end of the sequence of jobs associated with one of the machines.

Our interest is centred on the refinement of these branch-and-bound algorithms for the problem. We consider instances of the problem to be characterized by the parameters (G,N,M) as well as by the ranges of job processing times and setup times. Our goal is to develop an algorithm that extends the range of (G,N,M) that is able to be solved optimally in reasonable time. Our new algorithm makes use of additional dominance rules, an alternative approach to the elimination of list redundancy, and a revised branching scheme. After reviewing the literature in Section 2, in Section 3 we develop and present our set of dominance rules and also address the issue of list redundancy. Our revised branching scheme is proposed and justified in Section 4, and the new branch-and-bound algorithm is proposed in Section 5. Computational experiment (Section 6) shows that the new algorithm substantially decreases execution times and the size of the search tree for many combinations of (G,N,M). For example, the new algorithm can optimally solve instances with three machines and 20 jobs while expending (on average) less than a tenth of the computational effort required by a branch-and-bound algorithm that has recently been proposed in the literature.

Section snippets

Problem statement and literature review

As noted in the introduction, the set of single-operation jobs to be scheduled is partitioned, according to processing requirements, into mutually-exclusive and exhaustive families. We assume that this grouping exploits job processing similarities to the extent that a setup time between jobs (on any given machine) need only be scheduled when switching from a job of one family to a job belonging to a different family. Furthermore, we will assume that the setup times are sequence-independent

Dominance rules

In an optimal schedule for P|si|∑wC, the sequence of jobs at each machine must fulfil the optimality conditions that apply for the 1|si|∑wC problem. These single-machine optimality conditions can be summarised as follows.

In a flowtime-optimal sequence for a problem with family setup times, jobs of the same family must appear in shortest weighted processing time (SWPT) order. This result is due to Monma and Potts [24]. Mason and Anderson [23] show that when the family setup times are

Branching schemes

A branching scheme, for the branch-and-bound algorithms to be considered, defines the method by which a partial schedule at a node is extended to form a more complete schedule at its child nodes. Within all of the branching schemes that we address, the number of jobs in the partial schedule is increased by one when branching from a node. The root node of a search tree represents an empty schedule.

We consider three branching schemes: the BP scheme of Azizoglu and Webster, a minor revision to

Branch-and-bound algorithms

We have implemented two branch-and-bound algorithms. The algorithms differ only in the branching scheme used. The first algorithm, BP, uses the revised best-processor branching scheme. The second algorithm, LLP, uses the least-loaded-processor branching scheme. Redundancy of solutions is addressed through use of “strong” redundancy elimination in both algorithms. We supplement the upper bounds used by Azizoglu and Webster with a simple heuristic that schedules entire families to machines using

Computational experience

Our implementations of BP and LLP were written in C++ and run on a desktop computer with a 1.5 GHz Pentium III processor, 512 Mb of RAM and the Windows 2000 operating system. We have generated our test instances according to the same rules followed by Azizoglu and Webster. For each (G,N,M) we randomly assign jobs to families by first drawing a random number for each family and then distributing jobs approximately in proportion to these random numbers, subject to the constraint that total the

Conclusions

In this paper we have proposed a new least-loaded-processor (LLP) branching scheme for the P|si|∑wC problem. We have shown that algorithms that use this scheme have the potential to significantly outperform otherwise identical algorithms that use the previously-proposed best-processor (BP) branching scheme. The average computation time and mean node-count can be reduced by large factors through the substitution of LLP for BP. This enables the solution of larger problems, and expands the

Acknowledgements

The authors appreciate the comments and observations by anonymous referees. These have improved the clarity and content of this paper.

References (36)

  • S.T. Webster et al.

    Dynamic programming algorithms for scheduling parallel machines with family setup times

    Computers and Operations Research

    (2001)
  • M. Azizoglu et al.

    Scheduling parallel machines to minimize weighted flowtime with family setup times

    International Journal of Production Research

    (2003)
  • K.R. Baker

    Introduction to Sequencing and Scheduling

    (1974)
  • J. Bruno et al.

    Scheduling independent tasks to reduce mean finishing time

    Communications of the ACM

    (1974)
  • J. Bruno et al.

    Task sequencing in a batch environment with setup times

    Foundations of Control Engineering

    (1978)
  • Z.-L. Chen et al.

    Solving parallel machine scheduling problems by column generation

    INFORMS Journal on Computing

    (1999)
  • T.C.E. Cheng et al.

    Parallel machine scheduling with batch setup times

    Operations Research

    (1994)
  • T.C.E. Cheng et al.

    Parallel machine batching and scheduling to minimize total completion time

    IIE Transactions

    (1996)
  • Cited by (26)

    • Iterated greedy algorithms for a complex parallel machine scheduling problem

      2022, European Journal of Operational Research
      Citation Excerpt :

      All experiments are performed on a computer with an Intel i7-8700K CPU of 3.70GHz and 64 GB of RAM, running Linux with a single thread. Operation’s families are defined according to the scheme proposed by Dunstall & Wirth (2005a). First, a random number between 0 and 1 is generated for each family.

    • Mathematical formulations for scheduling jobs on identical parallel machines with family setup times and total weighted completion time minimization

      2021, European Journal of Operational Research
      Citation Excerpt :

      Small sized instances have n ∈ {15, 20, 25, 30}, m ∈ {3, 4, 5} and f ∈ {3, 5, 8}, while the large sized ones have n ∈ {40, 60, 80}, m ∈ {3, 6, 9} and f ∈ {5, 8, 12, 16}. Processing times, weights and setup times were generated as in Dunstall and Wirth (2005a). For each combination of (n, m, f), 100 instances were created, for a total of 7200 instances.

    View all citing articles on Scopus
    View full text