Laboratory Exercise on Process Scheduling

Background:

• the specific algorithm used to determine the next job to be scheduled,
• whether or not a process is allowed to run to completion once it is started (i.e., whether nor not scheduling is preemptive), and
• the time slice given to a process, if preemptive scheduling is used.

Goals:

This lab has four basic goals:

• provide first-hand experience implementing several scheduling algorithms,
• study a style of simulation (event-driven simulation) for gathering data about events (in this case, the effectiveness of scheduling algorithms),
• obtain comparative data on waiting times for computer processes, according to varying scheduling algorithms and alternative times for processing overhead. and
• expand student programming experience with C and list structures.

Resources:

1. Many elements of this laboratory exercise are based on Lab Exercise 7.1 in Nutt's text. In particular, students should read that material carefully for an explanation of the approach of event-driven simulation.

2. Program ~walker/213/c-examples/simulation-sched.c and include-file ~walker/213/c-examples/fcfs_scheduler.c provides a basic framework for an event-driven simulation for the first-come, first-served (FCFS) non-preemptive scheduling algorithm.

Looking at the above code in more detail,

• ~walker/213/c-examples/fcfs_scheduler.c includes the structures, variables, and functions specific to job scheduling.
  • int jobQueueIsEmpty (void) returns true or false, according to whether any jobs are waiting in a ready state for scheduling and execution,
  • void initializeJobQueue (void) sets up the job queue with no jobs currently pending,
  • void insertJob (struct Event * job) adds the specified job to the job queue, and
  • struct Event * selectJob (void) selects the next job to run from the job queue, removes the job from the queue, and returns it.

  The current details of these functions implement the FCFS scheduling algorithms. To change the FCFS scheduler to Shortest Job Next (SJN) or Priority scheduling, only the internals of these functions need be altered.

• simulation-sched.c incorporates the fcfs_scheduler.c into an event-based simulation.
  • Altogether, the program handles three types of events
    • When a job enters the system, it creates a registerJob event that enters the job into the system's data structure for ready processes.
    • A scheduler event triggers the scheduler. If jobs are pending, the scheduler event retrieves the next job using the select operation and runs the job. If no jobs are pending, time is advanced until the next event will occur.
    • When a process is scheduled, a processEvent event is triggered. This adds any required administrative overhead to the clock. If processes run without preemption, then the process is run to completion. If preemption is allowed, then the process runs for its time slice. When the process stops, a new scheduler event is triggered.
  • To generate registerJob events, the program reads a sequence of jobs (arrival time, required processing time, priority) from a file for use in the simulation. (As given, the file is /home/walker/213/c-examples/simulation-sched-data.txt.) Each job arrival generates an event, placed on an eventList.
  • Constant preemptiveAlg is 0 for nonpreemptive scheduling or the basic time quantum for a time slice for preemptive scheduling.
  • Constant schedulerOverhead specifies the amount of administrative overhead required by the scheduler each time it is called.
  • After initialization, the main loop removes an event from the eventList and executes it. The scheduler is treated as another event that occurs at the start, and after each turn for a job.
  • Statistics on waiting times and processing times are updated whenever a process finishes.

This program contains three debugging flags that can provide on-going information as the simulation runs:

• Flag input prints the input cases as they are read from the file
• Flag eventlist prints the event list each time through the main simulation loop
• flag timemonitor prints the waiting and processing times of completed jobs each time through the main simulation loop.

Any combination of these flags can be invoked at compile time. For example, the following line invokes the input and timemonitor flags:

gcc -o simulation-sched -Dinput -Dtimemonitor simulation-sched.c && simulation-sched

Part A: Nonpreemptive Scheduling Algorithms

1. Run the existing program to get timings for the FCFS scheduling algorithm, using schedulerOverhead as 0.0, 0.01, 0.02, 0.03, and 0.04 seconds.
   For this testing, you may use the test data from the text (as copied to two decimal digits of accuracy in simulation-sched.data.txt) or you may expand this file to include further processes.

2. Change the include file from fcfs_scheduler.c to another that implements the SJN scheduling algorithm.

3. Test the simulation with SJN for the same cases you did in Step 1.

4. Compare the waiting times for FCFS and SJN. Does this suggest any conclusions regarding the relative effectiveness of these two scheduling algorithms?

Part B: Preemptive Scheduling Algorithms

1. A simple Round-Robin (RR) scheduling can be obtained, using the FCFS scheduler you are given, but changing the processJob event handler. In this case, if the time quantum preemptiveAlg is positive, then a job is allowed to run continuously only for that time slice. If the job finishes in a time slice, then statistics for the job are compiled. Otherwise, the time remaining for the job is reduced by the time slice, and the scheduler is invoked again.

2. Run the RR scheduling simulation for the same job sequence you defined in Part A, with the time quanta being 0.05, 0.1, 0.15, and 0.2 seconds .

3. Change the include file from fcfs_scheduler.c to another than implements a multi-queue, priority system. Assume priorities are between 1 (most pressing importance) through 10 (not very important). In this variation, vary the time allocated to a job according to its priority:

   
     time interval = preemptiveAlg / 2^(priority-1)
   

4. Again, run the resulting priority algorithm for the same job sequence defined in Part A and with the same time quanta listed in step B2.

5. Compare the run times for the nonpreemptive and preemptive algorithms you obtained in your simulations. Can you make any conclusions regarding the relative effectiveness of these algorithms?

Work to be turned in:

• Part A: a program implementing Shortest-Job Next and running timings for the nonpreemptive algorithms (FCFS and SJN) - due Friday, October 1
• Part B: a program implementing the preemptive algorithms and running them - due Monday, October 4

This document is available on the World Wide Web as

     http://www.cs.grinnell.edu/~walker/courses/213.fa04/lab-scheduling.shtml

created September 26, 2004 last revised September 27, 2004
For more information, please contact Henry M. Walker at (walker@cs.grinnell.edu)