CO454: Scheduling, Spring 2010

Lecture 1: Introduction, Framework and Notation

May 4th, 2010

1 Introduction to Scheduling

Scheduling: allocating sparse resources to activities over time optimally with respect to an
objective

Example 1: Tomorrow You-Mi has two classes to attend, two assignments due at different times which
she has not started yet. She has flexible time for lunch but it should be after 12pm. She wants to go
to gym in the late afternoon. However, she needs to come home for dinner before 7pm. How should
You-Mi schedule her day efficiently for tomorrow?
Example 2: At a sea port, whenever a cargo ship arrives, we need a pilot to guide the ship into an
appropriate berth. Everyday, the port authority receives arrival information of all ships arriving that
day, which includes the tentative arrival time and arrival location. The goal is to guide as many ships
as possible from their location to their designated berth within a specified time window. Your task is
to help the port authority come up with a day-to-day schedule for the pilot team.
Example 3: A factory produces five different types of toys. Each type of toys is assembled through the
sequence of machines in the assembly line with different amounts of processing time on each machine.
The current outstanding toy orders have different due dates. How should we schedule the production
of each machine so that the factory can complete on time as many orders as possible?

2 Framework and Notation

Any scheduling problem has associated with it a finite set of tasks (activities) or jobs and a finite set of
resources or machines. The set of jobs is normally represented as J and is, unless mentioned otherwise,

1
supposed to have n elements, J = {1, 2, . . . , n}. The set of machines is normally represented as M and
the number of machines, unless mentioned otherwise, is supposed to be m, M = {1, 2, . . . , m}. At any
point of time a single machine can process at most one job.
Each job j ∈ J has the following pieces of data associated with it:

(1) Processing time (pij ) The time taken by machine i to process job j. In many cases, the
processing time of job j will be independent of the machine and the processing time is simply be
pj .

(2) Release time (rj ) Job j is only available for processing after time rj . If rj is not mentioned, the
job j can be processed at any time.

(3) Due date (dj ) The time job j needs to be processed by. In many cases, completion after the due
date is allowed with a penalty.

(4) Weight (wj ) The relative importance of job j to the other jobs in the system (a priority factor).

Most scheduling problems can be described by a triplet (α | β | γ). The first term α is called the
machine environment and contains a single entry. This field describes the resources which are available
for the completion of various tasks. The second term β denotes the various constraints on the machines
and jobs which must be respected by the schedule. The third term γ denotes the objective which will
be optimized by the scheduling problem.
The possible machine environments are as follows:

(1) Single machine (α = 1) In this case we have only one machine. Although it might seem a very
special case, the study of these problems will lead to many techniques useful for more realistic
cases.

(2) Identical parallel machines (α = P ) In this case we have m identical machines and any job
can run on any machine with the same processing time (pij = pj ). When the number of machines
is constant, say m = 2, then the number of machines is appended after the letter P , for instance,
P 2.

(3) Uniformly related parallel machines (α = Q) In this case we have m machines and any job
can run on any machine. However, each machine i has a uniform speed si . The time taken to
process job j on machine i is then pij = pj /si .

2
 (4) Unrelated parallel machines (α = R) In this case we have m machines and any job can run on
any machine. However, each job j takes time pij on machine i. The pij ’s are completely unrelated.
For instance, machine i could have pij > pij 0 , but machine i0 could have pi0 j < pi0 j 0 .

(5) Open shop (α = O) The following three machine environments fall in the shop scheduling
framework. In this framework, each job j consists of m operations and a job is said to be complete
if and only if all the operations are completed. Furthermore, each operation takes place on a
dedicated machine. Thus each job needs to visit each machine before completion. In the open
shop, the jobs can visit the m machines in any order.

(6) Flow shop (α = F ) In a flow shop, each job needs to visit the machines in the same fixed order,
which is assumed to be {1, 2, . . . , m}. One can think of the process as a job visiting a machine
and on completion entering the queue of the next machine. A machine on completion of a job
chooses to process any job in its queue.

(7) Job shop (α = J) In a job shop, each job comes with a predetermined order in which it needs to
be processed by the m machines.

The side constraints capture the various restrictions on the scheduling problem. We note that there
could be more than one side constraints. The various side constraints we will encounter in this course
are:

(1) Release dates (β = rj ) Unless specified, we assume that all jobs are available from the beginning.

(2) Setup times (β = sjk (i)) Sometimes, a machine i needs to spend a set-up time after the com-
pletion of job j and beginning the job k. Unless mentioned these set-up times are assumed to be
0.

(3) Precedence constraints (β = prec) Sometimes, a job j cannot be processed until a job k is
finished. Such constraints are called precedence constraints. We assume that these constraints
are not cyclical, that is, we do not have a situation like job j precedes k, job k precedes l and job
l precedes j. One represents the precedence constraint via a directed acyclic graph (DAG) where
the nodes are the various jobs, and an arc from j to k implies j precedes k in the constraint.

(4) Preemption (β = prmp) A job can be preempted if it is not necessary that the processing be
completed once it has started. If jobs can be preempted then a schedule can complete a fraction f

3
 of the job in one machine and a fraction (1−f ) in some other machine. The total time to complete
is in the proportion of the fractions. By default, we assume that preemption is not allowed.

The objective function decides how the scheduling algorithm is designed. Normally, the objective
depends on the completion time Cj of the jobs, j ∈ J. When jobs have due dates, the lateness of a job
denotes the difference between the completion time and the due date. This is denoted as Lj ,

Lj = Cj − dj .

Note that if Lj is negative, the job is not late. An associated measure is called the tardiness of a
job, Tj , and
Tj = max(Lj , 0).

Finally, we use Uj to capture if a job j is finished before or after the deadline. If a job j has Cj > dj ,
we say that the job is tardy and let Uj = 1. We have Uj = 0 otherwise.
We are now ready to define some objective functions as follows:

(1) Makespan (γ = Cmax ) Find a schedule which minimizes the maximum completion time, that is,
Cmax := max Cj .
j∈J
P
(2) Total weighted completion time (γ = wj Cj ). Find a schedule which minimizes the weighted
P
average time taken by a job to complete. When all weights are 1, we simply use Cj in the γ-field.
This measure is also called the flow time or the weighted flow time.

(3) Maximum lateness (γ = Lmax ) Find a schedule which minimizes the maximum lateness of a
job, that is, minimize Lmax := max Lj .
j∈J
P
(4) Weighted number of tardy jobs (γ = wj Uj ) Find a schedule which minimizes the weighted
P
number of tardy jobs. When all weights are 1, we simply use Uj in the γ-field.

Definition 1. Regular perfomance measures are functions that are nondecreasing in C1 , . . . , Cn .

P
Claim 1. The performance measure Uj is regular.

0
Proof. Consider two schedules S and S 0 such that CjS ≤ CjS for all jobs j ∈ J. Therefore, if for a
0 0
job j, CjS > dj , then CjS > dj as well. This implies if UjS = 1 for job j, then UjS = 1 as well. So,
P S P S0 P
j Uj ≤ j Uj implying Uj is regular.