Frequently Asked Questions about HW1
Q1: Does anyone know what are we supposed to calculate for the following
instruction? "the mean number of customers in the system (in the queue +
in service)"
Let N(t) be the number of in the system (in the queue + in service) at
time t. If N(t) is a continuous function of t, then the mean number of
customers in the system between time [T1, T2] is
N0 = integral{from T1 to T2, N(t)dt}/(T2 - T1) (1)
Now in our simulation, since N(t) is discrete, the integral becomes
weighted sum. Let {t0, t1, ..., tn} be the moments when N(t) changes,
where t0 = T1, tn = T2. Then
N0 = suml{i = 1 to n, N(t)(ti - t(i-1))}/(T2 - T1) (2)
Q2: Should a job be counted towards the Mean Number of Jobs during its
overhead time?
A job should be counted towards the Mean Number of Jobs right after it
arrives at the system.
Q3: Is the print out going to be graded by an autograder? If so, can
someone please specify the format in more detail (i.e. tab-delimited
or space-delimited)?
This assignment will not be graded by autograder and there is no
specific format requirement. Just make the output clear and follow
instructions from the homework.
Q4: In addition to generating and using our own times, does our
program have to be able to deal with your supplied time files (other
than debugging purposes)?
Yes you program have to be able to deal with supplied time files, as
specified in the homework.
Q5: Time slice
Both RR and SET alorithms use quantum or timeslice. For simulating
these two algorithms, it is NOT a good idea to use a periodic timer.
This is because these algorithms require that once you start running
a job, you should let it consume all the quantum unless it finishes
first. If the running is interrupted by arrival of new jobs, you
should process the new arrivals first (putting them into the job
queue) and resume the CURRENT job. You need to postpone the ending
of its quantum because the system spent time not servicing this job.
This means the clock that interrupts at the end of each quantum is
not ticking at constant rate. It is much easier to use an "alarm
clock": when you start a job, set an alarm clock that will go off
at the end of the quantum. You then update this alarm clock as you
handle other events.
Overhead Handling
An overhead X can be considered to consists of two parts:
X/2: putting a job into the job queue.
X/2: starting a job
Whenever a job arrives, the system needs to put it into the job
queue first, even if it is the one that will run next.
3. Scheduling Algorithms
You are to simulate the following scheduling algorithms. In
each case, consider three cases: The time X to switch between
processes is either 0.0, 0.01, or 0.10. (I.e. each simulation is
run 3 times.) This overhead is incurred whenever: (a) there is a
task switch from job A to job B or (b) a job arrives to an empty
system. If (c) the clock interrupts at the end of a quantum and
the same job is resumed, the overhead is X/2. (d) When a job
arrives to a busy system, the overhead is X/2 if the currently
running job continues (after the arrival of the new job), and is
X if the running (currently active) job changes. Logically, you
can consider the overhead in item (d) to consist of two parts:
X/2 overhead to accept the new job, and put it in the job queue.
X/2 overhead to start whichever job starts next, if it is a dif-
ferent job.
3.2. Shortest Remaining Processing Time
Please simulate the system using SRPT scheduling. At any
given time, you are to be running the job with the least remain-
ing processing time.
Note: Consider the following case: You are running job A.
Job B arrives, which is shorter than the remaining time of job A.
You enter the task switch overhead to switch to job B. While in
the task switch overhead, job C arrives, and C is shorter than
the remaining time for B. You should process it the following
way: Overhead X/2 to accept job B and put it in the job queue.
Overhead of X/2 to accept job C and put it in the job queue.
Overhead of X/2 to start job C.