CS372H Spring 2011 Homework 6 Solutions
Problem 1
Most round-robin schedulers use a fixed size quantum.
Give an argument in favor of and against a small quantum.
Solution:
An argument against a small time quantum: Efficiency. A small
time quantum requires the timer to generate interrupts with short
intervals. Each interrupt causes a context switch, so overhead increases
with a larger number of interrupts.
An argument for a small time quantum: Response time. A large
time quantum will reduce the overhead of context switching since
interrupts will be generated with relatively long intervals, hence
there will be fewer interrupts. However, a short job will have to wait
longer time on the ready queue before it can get to execute on the
processor. With a short time quantum, such a short job will finish
quicker and produces the result to the end user faster than with a
longer time quantum.
Problem 2
As a system administrator you have noticed that
usage peaks between 10:00AM to 5:00PM and between 7:00PM to 10:00PM. The
company's CEO decided to call on you to design a system where during these
peak hours there will be three levels of users. Users in level 1 are to
enjoy better response time than users in level 2, who in turn will enjoy
better response time than users in level 3. You are to design such a system
so that all users will still get some progress, but with the indicated
preferences in place.
-
Will a fixed priority scheme with pre-emption
and 3 fixed priorities work? Why, or why not?
-
Will a UNIX-style multi-feedback queue work? Why,
or why not?
-
If none of the above works, could you design a
scheduling scheme that meets the requirements?
Solution:
1. No, it will not work. A fixed priority scheme
can cause starvation. The required solution should enable all users to
make progress. Fixed priority does not guarantee
progress for processes with low priorities.
2. No, it will not work. The multi-feedback queuing
system will cause processes in level 1 to get less time on the CPU if
they stay in the system for very long. So, even
though a level-1 process may start at the highest level in the feedback
queue, its priority will degrade over time. So
this solution does not satisfy the requirements.
3. A process of level-1 will have 3 entries in
the ready queue, distributed evenly over the queue. A process of level-2
will
have 2 entries, while a process of level 3 will
have one entry. In a run, a process at level 1 will get 3 times as much
as a
process at level 3 on the CPU. Care should be
taken such that when a process requests an I/O operation, that all its
entries would be removed from the ready queue
simultaneously. Also, when a process is added to the ready queue, it has
to be entered with all its entries even distributed
over the entire queue. Other solutions such as a lottery scheduler are
possible.
Problem 3
A periodic task
is one that is characterized with a period T, and a CPU time C, such that
for every period T of real time, the task executes C time on the CPU. Periodic
tasks occur in real-time applications such as multimedia. For example,
a video display process needs to draw a picture every 40 msec (outside
the US, Japan and Canada). To do so, such a process will have a period
of 40 msec, and within each, it will require some time to do the data copying
and drawing the picture after getting it from the video stream.
Admission control is
a policy implemented by the process manager in which the manager decides
whether it will be able to run a task with given parameters and with the
existing load. Of course, if the process manager over commits itself, a
periodic task will not be able to meet its processing requirement every
period. For the video display process example, the picture flow will slow
down and a viewer will notice and get irritated.
Assume that a system has 5 processes, an editor,
a mail checking program, a video display process, a network browser and
a clock display. The requirements are such that the mail checking program
has to execute for 10 msec every 1sec, the video display must execute 25
msec every 40 msec, and the clock display must execute for 10 msec every
1 sec.
-
What scheduling policy would you use for such a
system?
-
Two process schedulers are available for you. The
first would consume about 5 msec of overhead in context switching every
40 msec, while the second consumes 0.5 msec of overhead in context switching
every 40 msec. The first ensures that the periodic processes will get time
on the CPU every 40 msec if they are ready, while the second uses simple
round-robin scheduling. Which one is better suited for this application
batch? Which one is more efficient?
-
Assume that the clock display program actually
underestimated
the time it wanted to run, and instead has now to run for 20 msec every
40 msec. What should the system do? How could it do it? Explain your
answers.
If an audio unit is to be installed with an audio
playback processing requiring 15 msec every 40 msec, would you be able
to admit the process into the system? If yes explain why, and if not, explain
why and suggest what the system could do.
Solution:
1. A fixed priority scheme in which the video display
would have the highest priority, followed by the clock, then followed
by the rest.
2. While the second scheduling algorithm is more
efficient than the first, it is practically useless for such a batch of
applications because simple round-robin does
not give the necessary guarantees that the video display program will run
every 40- msec.
3. The system has to be able to stop the offending
process. To do so, the system must set timers that would generate
interrupts at the time limit by which a task
has to finish. So, if the task has not finished after its allotted time
has expired, then it is simply switched out and another application
is run. This requires a very complex implementation to ensure that
the timers are being handled properly.
4. The system cannot admit such a process, because
it does not have the capacity to handle the workload and guarantee
the time limits required for the other processes.
In situations like this, the system may simply tell the user "sorry", or
it may give her the ability to stop some of the existing
applications so that the freed capacity be used to run the new application.
Or, it may simply tell the user "we will not
run this as it should, do you want to continue anyway?".
Problem 4
Comparison of FIFO, RR and SRTF Algorithms.
Given the following mix of job, job lengths, and arrival times, assume a
time slice of 10 and compute the completion for each job and average
response time for the FIFO, RR, and SRTF algorithms.
Solution:
|
Scheduling Algorithms |
Job |
Length (secs) |
Arrival time |
FIFO |
RR |
SRTF |
| | |
Completion time |
Response time |
Completion time |
Response time |
Completion time | Response time |
0 | 85 | 0 |
85 |
85 |
220 |
220 |
220 | 220 |
1 | 30 | 10 |
115 |
105 |
80 |
70 |
40 | 30 |
2 | 35 | 10 |
150 |
140 |
125 |
115 |
75 | 65 |
3 | 20 | 80 |
170 |
90 |
145 |
65 |
100 | 20 |
4 | 50 | 85 |
220 |
135 |
215 |
130 |
150 | 65 |
Average Response Time |
111 |
120 |
80 |
Note:
RR's scheduling is:
0: 0
10: 1
* if scheduling 0, the result is listed below.
20: 2
30: 0
40: 1
50: 2
60: 0
70: 1
80: 2
-------->Job1 completes
90: 0
100: 3
110: 4
120: 2
125: 0
--------->Job2 completes
135: 3
145: 4
--------->Job3 completes
155: 0
165: 4
175: 0
185: 4
195: 0
205: 4
215: 0
--------->Job4 completes
220:
--------->Job0 completes
RR can also be:
|
Scheduling Algorithms |
Job |
Length (secs) |
Arrival time |
FIFO |
RR |
SRTF |
| | |
Completion time |
Response time |
Completion time |
Response time |
Completion time | Response time |
0 | 85 | 0 |
85 |
85 |
220 |
220 |
220 | 220 |
1 | 30 | 10 |
115 |
105 |
90 |
80 |
40 | 30 |
2 | 35 | 10 |
150 |
140 |
135 |
125 |
75 | 65 |
3 | 20 | 80 |
170 |
90 |
155 |
75 |
100 | 20 |
4 | 50 | 85 |
220 |
135 |
220 |
135 |
150 | 65 |
Average Response Time |
111 |
125 |
80 |
Problem 5
Consider the following preemptive priority-scheduling
algorithm based on dynamically changing priorities. Larger priority numbers
imply higher priority. When a process is waiting for CPU (in the ready
queue, but not running), its priority changes at a rate of a (i.e., P(t)
= P0 +a * (t - t0) where t0 is the time
at which the process joins the ready queue) . Similarly, when it is running,
its priority changes at a rate b. All processes are given a priority 0
when they enter the ready queue. The parameters a and b can be set to obtain
many different scheduling algorithms.
-
What is the algorithm that results from b > a > 0 ?
-
What is the algorithm that results from a < b < 0 ?
Solution:
-
FCFS (First-come, first-served).
All the processes in the ready queue has the same inital priorty 0 (P0
=0)
. Their priority increases at the same rate a(a>0). Thus, the earlier
the process enters the ready quese(t0) , the higher its priority
will be (P(t) = a * (t - t0) ) .
Once the process with the highest priority (first-come compared to other
process in the ready queue) is running, its priority increases at a higher
rate (b>a>0) than the priorities of those processes in the ready queue.
So no other process will preempt it and it will run to its completion.
-
LCFS (Last-come, first-served).
All the processes in the ready queue has the same initial priority 0
(P0 =0) . Their priority decreases at the same rate a(a<0).
Thus, the earlier the process enters the ready quese(t0) , the
lower its priority will be (P(t) = a * (t - t0) ) .
Once the process with the highest priority(last-come compared to other
process in the ready queue) is running, no other process in the ready queue
will preempt it since its priority decreases at a lower rate (a<b<0)
than the priorities of those processes in the ready queue. But it will
be preempted by any new coming process because the new process's priority
is 0 which is the highest possible priority.
Problem 6
Many scheduling algorithms are parameterized. For instance, the
round-robin algorithm requires a parameter to indicate the time quantum.
The multi-level feedback (MLF) scheduling algorithm requires
parameters to define the number of queues, the scheduling algorithm
for each queue, and the criteria to move processes between queues
(and perhaps others. . .).
Hence, each of these algorithms represents a set of algorithms
(e.g., the set of round-robin algorithms with
different quantum sizes).
Further, one set of algorithms may simulate
another (e.g., round-robin with infinite quantum duration is the
same as first-come, first-served (FCFS)). For each of the following pairs of
algorithms, answer the following questions:
- Priority scheduling and shortest job first (SJF)
- State the parameters and behavior of priority scheduling
Solution
Parameter: Each job has a priority P
Behavior: Choose the job with the lowest numerical priority
- State the parameters and behavior of SJF
Solution
Parameter: Each job has a remaining time T
Behavior: Choose the job with the lowest remaining T
- Can SJF simulate priority scheduling for all possible parameters of
priority scheduling? (How or why not: State how to set SJF scheduling
parameters as a function of priority scheduling parameters or explain why
this cannot be done.)
Solution
2 possible answers: (1) No - although both schedulers are priority queues,
SJF is more restrictive than a general priority scheduler
since a job's time may not correspond to its priority. (2) Yes - "spoof" the
scheduler by passing priority in place of time.
- Can priority scheduling simulate SJF for all possible parameters of SJF?
(How or why not.)
Solution
Yes - set the priority P to the remaining time T
-
Multilevel feedback queues and first come first served (FCFS)
- State the parameters and behavior of multi-level feedback queues
Solution
Parameters: N (# queues), scheduling algorithm for each queue, function that
selects in which queue to place a job, criteria to interrupt a running job
Behavior: Always schedule the job from the head of the lowest #'d
non-empty queue according to that
queue's scheduling algorithm; interrupt a running job when told to by the
interrupt criteria; place newly
arrived jobs or interrupted jobs in a queue based on the selection function
- State the parameters and behavior of FCFS
Solution
No parameters
Behavior: Place arriving jobs at the back of a FIFO queue; when scheduling a
new job, choose the one from the front of the FIFO queue;
never interrupt a running job
- Can FCFS simulate multi-level feedback for all possible parameters of
multi-level feedback? (How or why not?)
Solution
No. Counterexample: make the top queue of MLF run RR with a short time quantum.
If two jobs arrive and each is longer than the quantum, the MLF scheduler
will allow both jobs to run for at least one
quantum before either completes, but FCFS can never interrupt a running job,
so one of the two will complete before the other has a chance to run.
- Can multi-level feedback scheduling simulate FCFS for all possible
parameters of FCFS?
(How or why not?)
Solution
Yes. Make MLF have 1 queue and have that one queue run FCFS.
Function to select which queue - always choose that queue.
Policy to interrupt - Never.
-
Priority scheduling and first come first served (FCFS)
- Can FCFS simulate priority scheduling for all possible parameters
of priority scheduling? (How or why not?)
Solution
No. Counterexample: Suppose job 1 arrives at time 1 with priority 10
and length 1,000,000 and job 2 arrives at time 2 with priority 1
and length 1,000,000. FCFS will run job 1 to completion, then job 2 to
completion. Priority will run job 1 for 1 unit, then job 2 to completion,
then job 1 to completion.
- Can priority scheduling simulate FCFS for all possible
parameters of FCFS? (How or why not?)
Solution
Yes. Set all jobs to equal priority (we assume that the priority queue
breaks ties with FCFS and infinite time quantum)
- Round-robin and shortest job first (SJF)
- State the parameters and behavior of round robin
Solution
Parameter: Quantum Q
Behavior: Run FIFO queue, but interrupt a running job Q units after it begins
running and move it to the end of the FIFO queue
- Can round robin simulate SJF for all possible parameters
of SJF? (How or why not?)
Solution
No. Counterexample. 3 jobs arrive: job 1 at time 0 is 10 seconds long,
job 2 arrives at time 1 and is 100 seconds long,
job 3 at time 2 is 10 seconds long. SJF must run 1 to completion,
then 3 to completion, and then 2 to completion.
Claim: RR must run at least one quantum of job 2
before running any job 3.
- Can SJF simulate round robin for all possible parameters
of round robin? (How or why not?)
Solution
No. Same counterexample.