Makespan Problem Research Articles

MAKESPAN DISTRIBUTIONS IN FLOW SHOPS WITH MULTIPLE PROCESSORS

The makespan distributions in a flow shop with multiple processors(FSMP)are investigated in this study. The FSMP problem is characterized as the processing of n jobs through an m stage flow shop, where there exists one or more processors at each stage. Since it is known that the minimum makespan FSMP problem is computationally explosive, it was necessary to investigate the distribution of makespans in FSMP in order to provide guidance to the FSMP research. Results of this study may help gain a better understanding of the FSMP makespan problem.

MAKESPAN DISTRIBUTIONS IN FLOW SHOPS WITH MULTIPLE PROCESSORS

ABSTRACT The makespan distributions in a flow shop with multiple processors (FSMP) are investigated in this study. The FSMP problem is characterized as the processing of n job through an m stage flow shop, where there exists one or more processors at each stage. Since it is known that the minimum makespan FSMP problem is computationally explosive, it was necessary to investigate the distribution of makespans in FSMP in order to provide guidance to the FSMP research. Results of this study may help gain a better understanding of the FSMP makespan problem.

An iterative algorithm for scheduling UET tasks with due dates and release times

A new polynomial-time iterative algorithm is presented for the scheduling problem with a unit execution time task system, parallel identical processors, precedence constraints, release times, and the criterion of maximum lateness. For the maximum lateness and makespan problems the algorithm allows to achieve the performance guarantees previously known only for the problems without release times.

Scheduling with general job-dependent learning curves

Several recent papers focused on the effect of learning on the optimal solution of scheduling problems. We extend the setting studied so far to the case of job-dependent learning curves, that is, we allow the learning in the production process of some jobs to be faster than that of others. Our learning curve approach, which assumes learning takes place as a function of repetition of the production process, is otherwise completely general, and is not based upon any particular model of learning acquisition. We show that in the new, possibly more realistic setting, the problems of makespan and total flow-time minimization on a single machine, a due-date assignment problem and total flow-time minimization on unrelated parallel machines remain polynomially solvable.

On-line multi-threaded scheduling

On-line scheduling problems are studied with jobs organized in a number of sequences called threads. Each job becomes available as soon as a scheduling decision is made on all preceding jobs in the same thread.We consider two different on-line paradigms. The first one models a sort of batch process: a schedule is constructed, in an on-line way, which is to be executed later. The other one models a real-time planning situation: jobs are immediately executed at the moment they are assigned to a machine.The classical objective functions of minimizing makespan and minimizing average completion time of the jobs are studied.We establish a fairly complete set of results for these problems. One of the highlights is that List Scheduling is a best possible algorithm for the makespan problem under the real-time model if the number of machines does not exceed the number of threads by more than 1. Another one is a polynomial time best possible algorithm for minimizing the average completion time on a single machine under both on-line paradigms.

Scheduling start time dependent tasks with deadlines and identical initial processing times on a single machine

In this paper, we study the feasibility problem of scheduling a set of start time dependent tasks on a single machine with deadlines, processing rates and identical initial processing times. First, we show that the cases with arbitrary deadlines are strongly NP-complete. Second, we show that the cases with two distinct deadlines are NP-complete in the ordinary sense. Finally, we give an optimal polynomial algorithm for the makespan problem with two distinct processing rates. We solve a series of open problems in the literature and give a sharp boundary delineating the complexity of the problems. Scope and purpose There has been increasing interest in scheduling models where the job processing times are functions of their starting times. We consider such a model where the job processing times change linearly with their starting times. The initial processing times are the same but the processing rates are arbitrary. Each job has a deadline, which cannot be exceeded. The feasibility problem is to find a schedule satisfying the deadline constraints. The makespan problem is to find a feasible schedule minimizing the makespan. The complexity of the feasibility problem is actually equivalent to that of the makespan problem. We show that the feasibility problem with arbitrary deadlines is strongly NP-complete and the case with two distinct deadlines is NP-complete in the ordinary sense. We give also an optimal algorithm for a special case of the makespan problem.

The complexity of cyclic shop scheduling problems

We consider scheduling problems for shops in which a job set is manufactured repetitively. Jobs are scheduled to minimize the cycle time of the job set, which is equivalent to maximizing the throughput rate. We characterize the complexity of the scheduling problem for several types of job shops. Polynomial time algorithms are presented for open shops, and for job shops where each job has at most two operations. When there are two machines and the maximum number of operations of any job is a constant k⩾3, the recognition version of the job shop problem is shown to be binary NP-complete. We describe a pseudopolynomial time algorithm for a special case of the problem when k=3. We also establish that some generalizations of this problem are unary NP-complete. One consequence of these results is that the recognition version of the two machine job shop makespan problem with at most five operations per job is unary NP-complete. This resolves a question posed by Lenstra et al. (Ann. Discrete Math. 1977; 1: 343). More generally, our results provide a map of the computational complexity of cycle time minimization problems that is analogous to that in the literature for makespan problems. Copyright © 2002 John Wiley & Sons, Ltd.

Single machine scheduling with step-deteriorating processing times

We study in this paper a scheduling model in which each task has a normal processing time which deteriorates as a step function if its starting time is beyond a given deteriorating date. We focus on problems with identical task deteriorating dates. We show that the flow time problem is NP-complete and suggest a pseudo-polynomial algorithm for the makespan problem. We also introduce a general method of solution, which facilitates the identification of solvable cases for some related problems. Finally, we provide a counter-example that invalidates the conjecture of optimality of a switching algorithm reported in the literature. Thus, we solve several unexplored or open problems and obtain a sharp boundary delineating the complexity of the considered problems.

Scheduling jobshops with some identical or similar jobs

We consider the following job shopscheduling p roblem: N jobs move through I machines, along R routes, with given processing times, and one seeks a schedule to minimize the latest job completion time. This problem is NP-hard. We are interested in the case where the number of routes and the number of machines are fixed, while the number of jobs varies and is large. We distinguish two cases: If jobs on the same route are identical we provide an approximation algorithm which is within constant of the optimum, no matter how many jobs there are. If jobs on the same route have different processing times, the job-shop scheduling problem can be crudely approximated by a continuous deterministic fluid scheduling problem, with buffers of fluid representing the jobs waiting for each operation. The fluid makespan problem is easily solved ∗ Part of this work was done as part of the author’s M.Sc. thesis, done under the supervision of Michal Penn and Gideon Weiss, in the Faculty of Industrial Engineering and Management, Technion, Haifa, Israel. † Research supported by the fund for promotion of research at the Technion, and by the fund for joint

Flow shop and open shop scheduling with a critical machine and two operations per job

This paper develops polynomial time algorithms to solve the m machine flow shop and open shop makespan problems with a critical machine (that processes all jobs) and at most two operations per job under certain assumptions. In the flow shop case, an O( m( nlog n+log m)) algorithm is developed (where n is the number of jobs) assuming that all jobs that require processing on the same subset of machines are contiguously processed. In the open shop case, an O( n+ mlog m) algorithm is developed assuming that the load on the critical machine exceeds the load on any other machine.

Worst‐case performance of critical path type algorithms

AbstractThe critical path method remains one of the most popular approaches in practical scheduling. Being developed for the makespan problem this method can also be generalized to the maximum lateness problem. For the unit execution time task system and parallel processors this generalization is known as the Brucker–Garey–Johnson algorithm. We characterize this algorithm by introducing an upper bound on the deviation of the criterion from its optimal value. The bound is stated in terms of parameters characterizing the problem, namely number of processors, the length of the longest path, and the total required processing time. We also derive a similar bound for the preemptive version of the Brucker– Garey–Johnson algorithm.

Worst-case performance of critical path type algorithms

The critical path method remains one of the most popular approaches in practical scheduling. Being developed for the makespan problem this method can also be generalized to the maximum lateness problem. For the unit execution time task system and parallel processors this generalization is known as the Brucker–Garey–Johnson algorithm. We characterize this algorithm by introducing an upper bound on the deviation of the criterion from its optimal value. The bound is stated in terms of parameters characterizing the problem, namely number of processors, the length of the longest path, and the total required processing time. We also derive a similar bound for the preemptive version of the Brucker–Garey–Johnson algorithm.

Single machine scheduling with deadlines and increasing rates of processing times

The makespan, flow time and maximum lateness problems of scheduling a set of tasks with deadlines and increasing rates of processing times on a single machine are considered in this paper. We first show that, when the increasing rates of processing time are identical, the makespan problem is equivalent to the corresponding flow time problem. Both problems are solvable in $O(n^5)$ time by a dynamic programming algorithm. As an application of the dynamic programming algorithm, we demonstrate that the corresponding maximum lateness problem can be solved in $O(n^6\log n)$ time. We then show that the general makespan problem is strongly NP-complete. Thus, both the corresponding flow time problem and maximum lateness problem are also strongly NP-complete.

A tabu search method guided by shifting bottleneck for the job shop scheduling problem

A computationally effective heuristic method for solving the minimum makespan problem of job shop scheduling is presented. The proposed local search method is based on a tabu search technique and on the shifting bottleneck procedure used to generate the initial solution and to refine the next-current solutions. Computational experiments on a standard set of problem instances show that, in several cases, our approach, in a reasonable amount of computer time, yields better results than the other heuristic procedures discussed in the literature.

Job shop scheduling with a non-regular objective: A comparison of neighbourhood structures based on a sequencing/timing decomposition

Commercial software packages for production management are characterized by a gap between MRP logic, based on a backward scheduling approach, and finite capacity scheduling, usually based on forward scheduling. In order to partially bridge that gap, we need scheduling algorithms able to meet due dates while keeping WIP and inventory costs low. This leads us to consider job shop scheduling problems characterized by non-regular objective functions; such problems are even more difficult than classical job shop scheduling, and suitable heuristics are needed. One possibility is to consider local search strategies based on the decomposition of the overall problem into sequencing and timing sub-problems. For given job sequences, the optimal timing problem can be solved as a node potential problem on a graph. Since solving the timing problem is a relatively time-consuming task, we need to define a suitable neighbourhood structure to explore the space of job sequences; this can be done by generalizing well-known results for the minimum makespan problem. A related issue is if solving timing problems exactly is really necessary, or if an approximate solution is sufficient; hence, we also consider solving the timing problem approximately by a fast heuristic. We compare different neighbourhood structures, by embedding them within a pure local improvement strategy. Computational experiments show that the overall approach performs better than release/dispatch rules, although the performance improvement depends on the problem characteristics, and that the fast heuristic is quite competitive with the optimal timing approach. On the one hand, these results pave the way to the development of better local search algorithms (based e.g. on tabu search); on the other hand, it is worth noting that the heuristic timing approach, unlike the optimal one, can be extended to cope with the complicating features typical of practical scheduling problems.

The time dependent machine makespan problem is strongly NP-complete

The computational complexity of the problem of scheduling a set of start-time dependent tasks with deadlines and identical decreasing rates of processing times on a single machine to minimize the makespan is open. In this paper we show that the problem is strongly NP-complete by a reduction from 3-Partition. Scope and purpose There has been increasing interest in scheduling models where the job processing times are a function of their starting times. There are many practical scheduling problems that can be modeled in this way. We study one such model where the job processing times decrease linearly with their starting times. The jobs have the same processing time decreasing rates but each job has an individual deadline which cannot be exceeded. The problem is to find a feasible schedule satisfying the deadline constraints that minimizes the makespan. This is an open problem in the literature and we show that it is strongly NP-complete. Thus, future research on this model should be focussed on the design of effective heuristics.

Scheduling identical jobs with chain precedence constraints on two uniform machines

The problem of scheduling identical jobs with chain precedence constraints on two uniform machines is considered. It is shown that the corresponding makespan problem can be solved in linear time.

Probabilistic Analysis and Practical Algorithms for the Flow Shop Weighted Completion Time Problem

In the flow shop weighted completion time problem, a set of jobs has to be processed on m machines. Every machine has to process each one of the jobs, and every job has the same routing through the machines. The objective is to determine a sequence of the jobs on the machines so as to minimize the sum of the weighted completion times of all jobs on the final machine. In this paper, we present a characterization of the asymptotic optimal solution value for general distributions of the job processing times and weights. In particular, we show that the optimal objective value of this problem is asymptotically equivalent to certain single and parallel machine scheduling problems. This characterization leads to a better understanding of the effectiveness of the celebrated weighted shortest processing time algorithm, as well as to the development of an effective algorithm closely related to the profile fitting heuristic, which was previously utilized for flow shop makespan problems. Computational results show the effectiveness of WSPT and this modified profile fitting heuristic on a set of random test problems.

Open shop scheduling to minimize the number of late jobs

We develop polynomial algorithms for several cases of the NP-hard open shop scheduling problem of minimizing the number of late jobs by utilizing some recent results for the open shop makespan problem. For the two machine common due date problem, we assume that either the machines or the jobs are ordered. For the m machine common due date problem, we assume that one machine is maximal and impose a restriction on its load.

The complexity of single machine scheduling with two distinct deadlines and identical decreasing rates of processing times

The makespan problem on a single machine for a set of tasks with two distinct deadlines and identical decreasing rates of processing times is considered in this paper. Ho et al. [1] have proposed a model of a task system in which the processing time of a task decreases with its starting time. When the decreasing rate is identical, the computational complexity of the makespan problem with two distinct deadlines is posed as an open problem. In this paper we show that the problem is NP-complete. It follows that both the corresponding flow time problem and maximum lateness problem are also NP-complete.