Job Scheduling using Greedy Algorithm

Whai is Job scheduling?

Job scheduling is the problem of scheduling jobs out of a set of N jobs on a single
processor which maximizes profit as much as possible. Consider N jobs, each taking
unit time for execution. Each job is having some profit and deadline associated with
it. Profit earned only if the job is completed on or before its deadline. Otherwise, we
have to pay a profit as a penalty. Each job has deadline di ≥ 1 and profit pi ≥ 0. At a
time, only one job can be active on the processor.
The job is feasible only if it can be finished on or before its deadline. A feasible
solution is a subset of N jobs such that each job can be completed on or before its
deadline. An optimal solution is a solution with maximum profit.

The greedy approach produces an optimal result in fairly less time. As each job
takes the same amount of time, we can think of the schedule S consisting of a
sequence of job slots 1, 2, 3, …, N, where S(t) indicates job scheduled in slot t. Slot t
has a span of (t – 1) to t. S(t) = 0 implies no job is scheduled in slot t.
Schedule S is an array of slots S(t), S(t) ∈ {1, 2, 3, …, N} for each t ∈ {1, 2, 3, …, N}

Schedule S is feasible if,

▪ S(t) = i, then t ≤ di (Scheduled job must meet its deadline)
▪ Each job can be scheduled at max once.
Our goal is to find a feasible schedule S which maximizes the profit of scheduled
job. The goal can be achieved as follow: Sort all jobs in decreasing order of profit.
Start with the empty schedule, select one job at a time and if it is feasible then
schedule it in the latest possible slot.

Algorithm for Job Scheduling

Problem: Solve the following instance of “job scheduling with deadlines”

problem : n = 7, profits (p1, p2, p3, p4, p5, p6, p7) = (3, 5, 20, 18, 1, 6, 30) and
deadlines (d1, d2, d3, d4, d5, d6, d7) = (1, 3, 4, 3, 2, 1, 2). Schedule the jobs in
such a way to get maximum profit.

Solution:

Given that,

Jobs j1 j
2 j
3 j4 j5 j
6 j7
 Profit 3 5 20 18 1 6 30
Deadline 1 3 4 3 2 1 2

Sort all jobs in descending order of profit.

So, P = (30, 20, 18, 6, 5, 3, 1), J = (J7, J3, J4, J6, J2, J1, J5) and D = (2, 4, 3, 1, 3, 1, 2). We
shall select one by one job from the list of sorted jobs J, and check if it satisfies the
deadline. If so, schedule the job in the latest free slot. If no such slot is found, skip
the current job and process the next one. Initially,

Profit of scheduled jobs, SP = 0

Iteration 1:
Deadline for job J7 is 2. Slot 2 (t = 1 to t = 2) is free, so schedule it in slot 2. Solution
set S = {J7}, and Profit SP = {30}

Iteration 2:
Deadline for job J3 is 4. Slot 4 (t = 3 to t = 4) is free, so schedule it in slot 4. Solution
set S = {J7, J3}, and Profit SP = {30, 20}

Iteration 3:
Deadline for job J4 is 3. Slot 3 (t = 2 to t = 3) is free, so schedule it in slot 3.
Solution set S = {J7, J3, J4}, and Profit SP = {30, 20, 18}
Iteration 4:
Deadline for job J6 is 1. Slot 1 (t = 0 to t = 1) is free, so schedule it in slot 1.
Solution set S = {J7, J3, J4, J6}, and Profit
SP = {30, 20, 18, 6}

First, all four slots are occupied and none of the remaining jobs has deadline lesser
than 4. So none of the remaining jobs can be scheduled. Thus, with the greedy
approach, we will be able to schedule four jobs {J7, J3, J4, J6}, which give a profit of
(30 + 20 + 18 + 6) = 74 units.

# Python3 code for the above approach

# function to schedule the jobs take 2

# arguments array and no of jobs to schedule

def printJobScheduling(arr, t):

# length of array
n = len(arr)

# Sort all jobs according to

# decreasing order of profit
for i in range(n):
for j in range(n - 1 - i):
if arr[j][2] < arr[j + 1][2]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]

# To keep track of free time slots

result = [False] * t
 # To store result (Sequence of jobs)
job = ['-1'] * t

# Iterate through all given jobs

for i in range(len(arr)):

# Find a free slot for this job

# (Note that we start from the
# last possible slot)
for j in range(min(t - 1, arr[i][1] - 1), -1, -1):

# Free slot found

if result[j] is False:
result[j] = True
job[j] = arr[i][0]
break

# print the sequence

print(job)

# Driver's Code
if __name__ == '__main__':
arr = [['a', 2, 100], # Job Array
['b', 1, 19],
['c', 2, 27],
['d', 1, 25],
['e', 3, 15]]

print("Following is maximum profit sequence of jobs")

# Function Call
printJobScheduling(arr, 3)

Time Complexity: O(N2)

Application:
A job scheduler is a computer application for controlling unattended background
program execution of jobs.

Conclusion:
In this assignment we have learnt and successfully implemented Job Scheduling algorithm
using Greedy Approach