*Scheduling in Batch Systems*

It is now time to turn from general scheduling issues to specific scheduling algorithms. In this section we will study algorithms used in batch systems. In the following ones we will study interactive and real-time systems. It is worth pointing out that some algorithms are used in both batch and interactive systems. We will study these later.

### First-Come First-Served

Perhaps the simplest of all scheduling algorithms is nonpreemptive first-come first-served. With this algorithm, processes are assigned the CPU in the order they request it. Essentially, there is a single queue of ready processes. When the first job enters the system from the outside in the morning, it is started at once and allowed to run as long as it wants to. It is not interrupted because it has run too long. As other jobs come in, they are put onto the end of the queue. When the running process blocks, the first process on the queue is run next. When a blocked process becomes ready, like a newly arrived job, it is put on the end of the queue.The great strength of this algorithm is that it is easy to understand and equally easy to program. It is also fair in the same sense that allocating scarce sports or concert tickets to people who are willing to stand on line starting at 2 A.M. is fair. With this algorithm, a single linked list keeps track of all ready processes. Picking a process to run just requires removing one from the front of the queue. Adding a new job or unblocked process just requires attaching it to the end of the queue. What could be simpler to understand and implement?

Unluckily, first-come first-served also has a powerful drawback. Assume that there is one compute-bound process that runs for 1 sec at a time and many I/O-bound processes that use little CPU time but each have to perform 1000 disk reads to complete. The compute-bound process runs for 1 sec, then it reads a disk block. All the I/O processes now run and start disk reads. When the compute-bound process gets its disk block, it runs for another 1 sec, followed by all the I/O-bound processes in quick succession. The net result is that each I/O-bound process gets to read 1 block per second and will take 1000 sec to finish. With a scheduling algorithm that preempted the compute-bound process every 10 msec, the I/O-bound processes would finish in 10 sec instead of 1000 sec, and without slowing down the compute-bound process very much.

### Shortest Job First

Now let us look at another nonpreemptive batch algorithm that assumes the run times are known in advance. In an insurance company, for instance, people can predict quite accurately how long it will take to run a batch of 1000 claims, since similar work is done every day. When many equally important jobs are sitting in the input queue waiting to be started, the scheduler picks the shortest job first. Look at Figure 1. Here we find four jobs A, B, C and D with run times of 8, 4, 4, and 4 minutes, respectively. By running them in that order, the turnaround time for A is 8 minutes, for B is 12 minutes, for C is 16 minutes, and for D is 20 minutes for an average of 14 minutes.Now let us consider running these four jobs using shortest job first, as shown in Figure 1(b). The turnaround times are now 4, 8, 12 and 20 minutes for an average of 11 minutes. Shortest job first is provably optimal. Consider the case of four jobs, with run times of a, b, c and d respectively. The first job finishes at time a, the second finishes at time a + b, and so on. The mean turnaround time is (4a + 3b + 2c + d)/4. It is clear that a contributes more to the average than the other times, so it should be the shortest job, with b next, then c and finally d as the longest as it affects only its own turnaround time. The same argument applies equally well to any number of jobs.

It is worth pointing out that shortest job first is only optimal when all the jobs are available at the same time. As a counterexample, consider five jobs, A through E, with run times of 2, 4, 1, 1, and 1, respectively. Their arrival times are 0, 0, 3, 3, and 3. In the beginning, only A or B can be chosen, since the other three jobs have not arrived yet. Using shortest job first we will run the jobs in the order A, B, C, D, E, for an average wait of 4.6. However, running them in the order B, C, D, E, A has an average wait of 4.4.

### Shortest Remaining Time Next

A preemptive version of shortest job first is shortest remaining time next. With this algorithm, the scheduler always chooses the process whose remaining run time is the shortest. Again here, the run time has to be known in advance. When a new job arrives, its total time is compared to the current process remaining time. If the new job requires less time to finish than the current process, the current process is suspended and the new job started. This scheme allows new short jobs to get good service.### Tags

batch systems, scheduler, interactive systems, algorithm- Stable Storage
- Separation of Policy and Mechanism
- Backing Store
- Load Control
- Summary of Page Replacement Algorithms
- The WSClock Page Replacement Algorithm
- The Least Recently Used (LRU) Page Replacement Algorithm
- The Not Recently Used Page Replacement Algorithm
- PAGE REPLACEMENT ALGORITHMS
- Managing Free Memory
- RESEARCH ON PROCESSES AND THREADS
- CLASSICAL IPC PROBLEMS
- Shortest Process Next
- Scheduling Algorithm Goals
- When to Schedule
- SCHEDULING