This program, scheduler.py, allows you to see how different schedulers perform under scheduling metrics such as response time, turnaround time, and total wait time. See the README for details.
- Compute the response time and turnaround time when running three jobs of length 200 with the SJF and FIFO schedulers.
For FIFO:
Turnaround time: 200, 400, 600. Average turnaround time is 400.
Response time: 0, 200, 400. Average turn around time is 200.
$ python3 scheduler.py -p FIFO -l 200,200,200 -c
ARG policy FIFO
ARG jlist 200,200,200
Here is the job list, with the run time of each job:
Job 0 ( length = 200.0 )
Job 1 ( length = 200.0 )
Job 2 ( length = 200.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 200.00 secs ( DONE at 200.00 )
[ time 200 ] Run job 1 for 200.00 secs ( DONE at 400.00 )
[ time 400 ] Run job 2 for 200.00 secs ( DONE at 600.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 200.00 Wait 0.00
Job 1 -- Response: 200.00 Turnaround 400.00 Wait 200.00
Job 2 -- Response: 400.00 Turnaround 600.00 Wait 400.00
Average -- Response: 200.00 Turnaround 400.00 Wait 200.00For SJF:
Turnaround time: 200, 400, 600. Average turnaround time is 400.
Response time: 0, 200, 400. Average turn around time is 200.
$ python3 scheduler.py -p SJF -l 200,200,200 -c
ARG policy SJF
ARG jlist 200,200,200
Here is the job list, with the run time of each job:
Job 0 ( length = 200.0 )
Job 1 ( length = 200.0 )
Job 2 ( length = 200.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 200.00 secs ( DONE at 200.00 )
[ time 200 ] Run job 1 for 200.00 secs ( DONE at 400.00 )
[ time 400 ] Run job 2 for 200.00 secs ( DONE at 600.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 200.00 Wait 0.00
Job 1 -- Response: 200.00 Turnaround 400.00 Wait 200.00
Job 2 -- Response: 400.00 Turnaround 600.00 Wait 400.00
Average -- Response: 200.00 Turnaround 400.00 Wait 200.00
- Now do the same but with jobs of different lengths: 100, 200, and 300.
For FIFO:
Turnaround time: 100, 300, 600. Average turnaround time is 333.33.
Response time: 0, 100, 300. Average turn around time is 133.33.
$ python3 scheduler.py -p FIFO -l 100,200,300 -c
ARG policy FIFO
ARG jlist 100,200,300
Here is the job list, with the run time of each job:
Job 0 ( length = 100.0 )
Job 1 ( length = 200.0 )
Job 2 ( length = 300.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 100.00 secs ( DONE at 100.00 )
[ time 100 ] Run job 1 for 200.00 secs ( DONE at 300.00 )
[ time 300 ] Run job 2 for 300.00 secs ( DONE at 600.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 100.00 Wait 0.00
Job 1 -- Response: 100.00 Turnaround 300.00 Wait 100.00
Job 2 -- Response: 300.00 Turnaround 600.00 Wait 300.00
Average -- Response: 133.33 Turnaround 333.33 Wait 133.33For SJF:
Turnaround time: 100, 300, 600. Average turnaround time is 333.33.
Response time: 0, 100, 300. Average turn around time is 133.33.
$ python3 scheduler.py -p SJF -l 100,200,300 -c
ARG policy SJF
ARG jlist 100,200,300
Here is the job list, with the run time of each job:
Job 0 ( length = 100.0 )
Job 1 ( length = 200.0 )
Job 2 ( length = 300.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 100.00 secs ( DONE at 100.00 )
[ time 100 ] Run job 1 for 200.00 secs ( DONE at 300.00 )
[ time 300 ] Run job 2 for 300.00 secs ( DONE at 600.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 100.00 Wait 0.00
Job 1 -- Response: 100.00 Turnaround 300.00 Wait 100.00
Job 2 -- Response: 300.00 Turnaround 600.00 Wait 300.00
Average -- Response: 133.33 Turnaround 333.33 Wait 133.33
- Now do the same, but also with the RR scheduler and a time-slice of 1.
For RR with time-slice of 1:
Turnaround time: 298, 499, 600. Average turnaround time is 465.67.
Response time: 0, 1, 2. Average turn around time is 1.
$ python3 scheduler.py -p RR -q 1 -l 200,200,200 -c
ARG policy RR
ARG jlist 200,200,200
Here is the job list, with the run time of each job:
Job 0 ( length = 200.0 )
Job 1 ( length = 200.0 )
Job 2 ( length = 200.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 1.00 secs
[ time 1 ] Run job 1 for 1.00 secs
[ time 2 ] Run job 2 for 1.00 secs
[ time 3 ] Run job 0 for 1.00 secs
[ time 4 ] Run job 1 for 1.00 secs
[ time 5 ] Run job 2 for 1.00 secs
[ time 6 ] Run job 0 for 1.00 secs
# skip...
[ time 597 ] Run job 0 for 1.00 secs ( DONE at 598.00 )
[ time 598 ] Run job 1 for 1.00 secs ( DONE at 599.00 )
[ time 599 ] Run job 2 for 1.00 secs ( DONE at 600.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 598.00 Wait 398.00
Job 1 -- Response: 1.00 Turnaround 599.00 Wait 399.00
Job 2 -- Response: 2.00 Turnaround 600.00 Wait 400.00
Average -- Response: 1.00 Turnaround 599.00 Wait 399.00
- For what types of workloads does SJF deliver the same turnaround times as FIFO?
The length of arrival jobs is from short to long.
- For what types of workloads and quantum lengths does SJF deliver the same response times as RR?
Each job of length is same and quantum length is equals to this length.
- What happens to response time with SJF as job lengths increase? Can you use the simulator to demonstrate the trend?
Response time will increase too.
$ python3 scheduler.py -p SJF -l 100,100,100 -c
ARG policy SJF
ARG jlist 100,100,100
Here is the job list, with the run time of each job:
Job 0 ( length = 100.0 )
Job 1 ( length = 100.0 )
Job 2 ( length = 100.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 100.00 secs ( DONE at 100.00 )
[ time 100 ] Run job 1 for 100.00 secs ( DONE at 200.00 )
[ time 200 ] Run job 2 for 100.00 secs ( DONE at 300.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 100.00 Wait 0.00
Job 1 -- Response: 100.00 Turnaround 200.00 Wait 100.00
Job 2 -- Response: 200.00 Turnaround 300.00 Wait 200.00
Average -- Response: 100.00 Turnaround 200.00 Wait 100.00
```console
$ python3 scheduler.py -p SJF -l 200,200,200 -c
ARG policy SJF
ARG jlist 200,200,200
Here is the job list, with the run time of each job:
Job 0 ( length = 200.0 )
Job 1 ( length = 200.0 )
Job 2 ( length = 200.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 200.00 secs ( DONE at 200.00 )
[ time 200 ] Run job 1 for 200.00 secs ( DONE at 400.00 )
[ time 400 ] Run job 2 for 200.00 secs ( DONE at 600.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 200.00 Wait 0.00
Job 1 -- Response: 200.00 Turnaround 400.00 Wait 200.00
Job 2 -- Response: 400.00 Turnaround 600.00 Wait 400.00
Average -- Response: 200.00 Turnaround 400.00 Wait 200.00$ python3 scheduler.py -p SJF -l 300,300,300 -c
ARG policy SJF
ARG jlist 300,300,300
Here is the job list, with the run time of each job:
Job 0 ( length = 300.0 )
Job 1 ( length = 300.0 )
Job 2 ( length = 300.0 )
** Solutions **
Execution trace:
[ time 0 ] Run job 0 for 300.00 secs ( DONE at 300.00 )
[ time 300 ] Run job 1 for 300.00 secs ( DONE at 600.00 )
[ time 600 ] Run job 2 for 300.00 secs ( DONE at 900.00 )
Final statistics:
Job 0 -- Response: 0.00 Turnaround 300.00 Wait 0.00
Job 1 -- Response: 300.00 Turnaround 600.00 Wait 300.00
Job 2 -- Response: 600.00 Turnaround 900.00 Wait 600.00
Average -- Response: 300.00 Turnaround 600.00 Wait 300.00
- What happens to response time with RR as quantum lengths increase? Can you write an equation that gives the worst-case response time, given N jobs?
Response time will increase too.
Assume quantum length is t, so the Nth job response time is (N-1)*t, the average response time is (N-1)*t/2.