Job shop scheduling (or job-shop problem) is an optimization problem in computer science and operations research in which ideal jobs are assigned to resources at particular times. The most basic version is as follows:
We are given n jobs J1, J2, ..., Jn of varying sizes, which need to be scheduled on m identical machines, while trying to minimize the makespan. The makespan is the total length of the schedule (that is, when all the jobs have finished processing). Nowadays, the problem is presented as an online problem (dynamic scheduling), that is, each job is presented, and the online algorithm needs to make a decision about that job before the next job is presented.
This problem is one of the best known online problems, and was the first problem for which competitive analysis was presented, by Graham in 1966. Best problem instances for basic model with makespan objective are due to Taillard.
Problem variations
Many variations of the problem exist, including the following:
- Machines can be related, independent, equal
- Machines can require a certain gap between jobs or no idle-time
- Machines can have sequence-dependent setups
- Objective function can be to minimize the makespan, the Lp norm, tardiness, maximum lateness etc. It can also be multi-objective optimization problem
- Jobs may have constraints, for example a job i needs to finish before job j can be started (see workflow). Also, the objective function can be multi-criteria.
- Jobs and machines have mutual constraints, for example, certain jobs can be scheduled on some machines only
- Set of jobs can relate to different set of machines
- Deterministic (fixed) processing times or probabilistic processing times
- There may also be some other side constraints
Job Scheduling Algorithm Video
NP-hardness
If one already knows that the travelling salesman problem is NP-hard (as it is), then the job-shop problem with sequence-dependent setup is clearly also NP-hard, since the TSP is special case of the JSP with (the salesman is the machine and the cities are the jobs).
Problem representation
The disjunctive graph is one of the popular models used for describing the job shop scheduling problem instances.
A mathematical statement of the problem can be made as follows:
Let and be two finite sets. On account of the industrial origins of the problem, the are called machines and the are called jobs.
Let denote the set of all sequential assignments of jobs to machines, such that every job is done by every machine exactly once; elements may be written as matrices, in which column lists the jobs that machine will do, in order. For example, the matrix
means that machine will do the three jobs in the order , while machine will do the jobs in the order .
Suppose also that there is some cost function . The cost function may be interpreted as a "total processing time", and may have some expression in terms of times , the cost/time for machine to do job .
The job-shop problem is to find an assignment of jobs such that is a minimum, that is, there is no such that .
The problem of infinite cost
One of the first problems that must be dealt with in the JSP is that many proposed solutions have infinite cost: i.e., there exists such that . In fact, it is quite simple to concoct examples of such by ensuring that two machines will deadlock, so that each waits for the output of the other's next step.
Major results
Graham had already provided the List scheduling algorithm in 1966, which is (2 - 1/m)-competitive, where m is the number of machines. Also, it was proved that List scheduling is optimum online algorithm for 2 and 3 machines. The Coffman-Graham algorithm (1972) for uniform-length jobs is also optimum for two machines, and is (2 - 2/m)-competitive. In 1992, Bartal, Fiat, Karloff and Vohra presented an algorithm that is 1.986 competitive. A 1.945-competitive algorithm was presented by Karger, Philips and Torng in 1994. In 1992, Albers provided a different algorithm that is 1.923-competitive. Currently, the best known result is an algorithm given by Fleischer and Wahl, which achieves a competitive ratio of 1.9201.
A lower bound of 1.852 was presented by Albers. Taillard instances has an important role in developing job shop scheduling with makespan objective.
In 1976 Garey provided a proof that this problem is NP-complete for m>2, that is, no optimal solution can be computed in polynomial time for three or more machines (unless P=NP).
Offline makespan minimization
Atomic jobs
The simplest form of the offline makespan minimisation problem deals with atomic jobs, that is, jobs that are not subdivided into multiple operations. It is equivalent to packing a number of items of various different sizes into a fixed number of bins, such that the maximum bin size needed is as small as possible. (If instead the number of bins is to be minimised, and the bin size is fixed, the problem becomes a different problem, known as the bin packing problem.)
Dorit S. Hochbaum and David Shmoys presented a polynomial-time approximation scheme in 1987 that finds an approximate solution to the offline makespan minimisation problem with atomic jobs to any desired degree of accuracy.
Jobs consisting of multiple operations
The basic form of the problem of scheduling jobs with multiple (M) operations, over M machines, such that all of the first operations must be done on the first machine, all of the second operations on the second, etc., and a single job cannot be performed in parallel, is known as the open shop scheduling problem. Various algorithms exist, including genetic algorithms.
Johnson's algorithm
A heuristic algorithm by S. M. Johnson can be used to solve the case of a 2 machine N job problem when all jobs are to be processed in the same order. The steps of algorithm are as follows:
Job Pi has two operations, of duration Pi1, Pi2, to be done on Machine M1, M2 in that sequence.
- Step 1. List A = { 1, 2, ..., N }, List L1 = {}, List L2 = {}.
- Step 2. From all available operation durations, pick the minimum.
If the minimum belongs to Pk1,
Remove K from list A; Add K to beginning of List L1.
If minimum belongs to Pk2,
Remove K from list A; Add K to end of List L2.
- Step 3. Repeat Step 2 until List A is empty.
- Step 4. Join List L1, List L2. This is the optimum sequence.
Johnson's method only works optimally for two machines. However, since it is optimal, and easy to compute, some researchers have tried to adopt it for M machines, (M > 2.)
The idea is as follows: Imagine that each job requires m operations in sequence, on M1, M2 ... Mm. We combine the first m/2 machines into an (imaginary) Machining center, MC1, and the remaining Machines into a Machining Center MC2. Then the total processing time for a Job P on MC1 = sum( operation times on first m/2 machines), and processing time for Job P on MC2 = sum(operation times on last m/2 machines).
By doing so, we have reduced the m-Machine problem into a Two Machining center scheduling problem. We can solve this using Johnson's method.
Example
Here is an example of a job shop scheduling problem formulated in AMPL as a mixed-integer programming problem with indicator constraints:
param N_JOBS; param N_MACHINES; set JOBS ordered = 1..N_JOBS; set MACHINES ordered = 1..N_MACHINES; param ProcessingTime{JOBS, MACHINES} > 0; param CumulativeTime{i in JOBS, j in MACHINES} = sum {jj in MACHINES: ord(jj) <= ord(j)} ProcessingTime[i,jj]; param TimeOffset{i1 in JOBS, i2 in JOBS: i1 <> i2} = max {j in MACHINES} (CumulativeTime[i1,j] - CumulativeTime[i2,j] + ProcessingTime[i2,j]); var end >= 0; var start{JOBS} >= 0; var precedes{i1 in JOBS, i2 in JOBS: ord(i1) < ord(i2)} binary; minimize makespan: end; subj to makespan_def{i in JOBS}: end >= start[i] + sum{j in MACHINES} ProcessingTime[i,j]; subj to no12_conflict{i1 in JOBS, i2 in JOBS: ord(i1) < ord(i2)}: precedes[i1,i2] ==> start[i2] >= start[i1] + TimeOffset[i1,i2]; subj to no21_conflict{i1 in JOBS, i2 in JOBS: ord(i1) < ord(i2)}: !precedes[i1,i2] ==> start[i1] >= start[i2] + TimeOffset[i2,i1]; data; param N_JOBS := 4; param N_MACHINES := 3; param ProcessingTime: 1 2 3 := 1 4 2 1 2 3 6 2 3 7 2 3 4 1 5 8; Are You Looking for Products
Here some products related to "Job Shop Scheduling".
Operating System 101 eBoo..
Operating System 101 eBoo..
Theory of Scheduling (Dov..
Amazon.com : CleverLoop B..
Get these at Amazon.com* amzn.to is official short URL for Amazon.com, provided by Bitly
Source of the article : here
EmoticonEmoticon