Baruch Mor

Scheduling problems with two competing agents to minimize minmax and minsum earliness measures

A relatively new class of scheduling problems consists of multiple agents who compete on the use of a common processor. We focus in this paper on a two-agent setting. Each of the agents has a set of jobs to be processed on the same processor, and each of the agents wants to minimize a measure which depends on the completion times of its own jobs. The goal is to schedule the jobs such that the combined schedule performs well with respect to the measures of both agents. We consider measures of minmax and minsum earliness. Specifically, we focus on minimizing maximum earliness cost or total (weighted) earliness cost of one agent, subject to an upper bound on the maximum earliness cost of the other agent. We introduce a polynomial-time solution for the minmax problem, and prove NP-hardness for the weighted minsum case. The unweighted minsum problem is shown to have a polynomial-time solution.

Single machine batch scheduling with two competing agents to minimize total flowtime

We study a single machine scheduling problem, where two agents compete on the use of a single processor. Each of the agents needs to process a set of jobs in order to optimize his objective function. We focus on a two-agent problem in the context of batch scheduling. We assume identical jobs and identical (agent-dependent) setup times. The objective function is minimizing the flowtime of one agent subject to an upper bound on the flowtime of the second agent. As in many real-life applications, we restrict ourselves to settings where the batches of the second agent must be processed continuously. Thus, the batch sizes are partitioned into three parts, starting with a sequence of the first agent, followed by a sequence of the second agent, and ending by another sequence of the first agent. In an optimal schedule, all three are shown to be decreasing arithmetic sequences. We introduce an efficient solution algorithm (where n is the total number of jobs).

Polynomial time solutions for scheduling problems on a proportionate flowshop with two competing agents

In scheduling problems with two competing agents, each one of the agents has his own set of jobs and his own objective function, but both share the same processor. The goal is to minimize the value of the objective function of one agent, subject to an upper bound on the value of the objective function of the second agent. In this paper we study two-agent scheduling problems on a proportionate flowshop. Three objective functions of the first agent are considered: minimum maximum cost of all the jobs, minimum total completion time, and minimum number of tardy jobs. For the second agent, an upper bound on the maximum allowable cost is assumed. We introduce efficient polynomial time solution algorithms for all cases.

Total absolute deviation of job completion times on uniform and unrelated machines

Unlike other measures of variation of job completion times considered in scheduling literature, the measure of minimizing total absolute deviation of job completiontimes (TADC) was shown to have a polynomial time solution on a single machine. It was recently shown to remain polynomially solvable when position-dependent job processing times are assumed. In this paper we further extend these results, and show that minimizing TADC remains polynomial when position-dependent processing times are assumed (i) on uniform and unrelated machines and (ii) for a bicriteria objective consisting of a linear combination of total job completion times and TADC. These extensions are shown to be valid also for the measure of total absolute differences of job waiting times (TADW).

Batch scheduling of identical jobs with controllable processing times

In scheduling models with controllable processing times, the job processing times can be controlled (i.e. compressed) by allocating additional resources. In batch scheduling a large number of jobs may be grouped and processed as separate batches, where a batch processing time is identical to the total processing times of the jobs contained in the batch, and a setup time is incurred when starting a new batch. A model combining these two very popular and practical phenomena is studied. We focus on identical jobs and linear compression cost function. Two versions of the problem are considered: in the first we minimize the sum of the total flowtime and the compression cost, and in the second we minimize the total flowtime subject to an upper bound on the maximum compression. We study both problems on a single machine and on parallel identical machines. In all cases we introduce closed form solutions for the relaxed version (allowing non-integer batch sizes). Then, a simple rounding procedure is introduced, tested numerically, and shown to generate extremely close-to-optimal integer solutions. For a given number of machines, the total computational effort required by our proposed solution procedure is O(n), where n is the number of jobs.

Minmax scheduling problems with common flow-allowance

In due-date assignment problems with a common flow-allowance, the due-date of a given job is defined as the sum of its processing time and a job-independent constant. We study flow-allowance on a single machine, with an objective function of a minmax type. The total cost of a given job consists of its earliness/tardiness and its flow-allowance cost components. Thus, we seek the job schedule and flow-allowance value that minimize the largest cost among all the jobs. Three extensions are considered: the case of general position-dependent processing times, the model containing an explicit cost for the due-dates, and the setting of due-windows. Properties of optimal schedules are fully analysed in all cases, and all the problems are shown to have polynomial time solutions.

Batch scheduling on uniform machines to minimize total flow-time

The solution of the classical batch scheduling problem with identical jobs and setup times to minimize flowtime is known for twenty five years. In this paper we extend this result to a setting of two uniform machines with machine-dependent setup times. We introduce an O(n) solution for the relaxed version (allowing non-integer batch sizes), followed by a simple rounding procedure to obtain integer batch sizes.

Heuristics for scheduling problems with an unavailability constraint and position-dependent processing times

We study a single machine scheduling problem, where the machine is unavailable for processing for a pre-specified time period. We assume that job processing times are position-dependent. The objective functions considered are minimum makespan, minimum total completion time and minimum number of tardy jobs. All these problems are known to be NP-hard even without position-dependent processing times. For all three cases we introduce simple heuristics which are based on solving the classical assignment problem. Lower bounds, worst case analysis and asymptotic optimality are discussed. All heuristics are shown numerically to perform extremely well.

Minimizing maximum cost on a single machine with two competing agents and job rejection

The classical Lawler’s Algorithm provides an optimal solution to the single-machine scheduling problem, where the objective is minimizing maximum cost, given general non-decreasing, job-dependent cost functions, and general precedence constraints. First, we extend this algorithm to allow job rejection, where the scheduler may decide to process only a subset of the jobs. Then, we further extend the model to a setting of two competing agents, sharing the same processor. Both extensions are shown to be solved in polynomial time.

Minsum and minmax scheduling on a proportionate flowshop with common flow-allowance

We study due-date assignment problems with common flow allowance on a proportionate flowshop. We focus on both minsum and minmax objectives. Both cases are extended to a setting of a due-window. The proposed solution procedures are shown to be significantly different from those of the single machine problems. All the problems studied here are solved in polynomial time: the minsum problems in O(n2) and the minmax problems in O(nlog n), where n is the number of jobs.