EVAL Problem 1

In this EVAL problem, we will study the behavior of a system with a configurable FIFO vs.  SJN queue dispatch (a.k.a.  scheduling) policy.  The goal of this EVAL is to demonstrate that despite no changes are made to the workload, some key system metrics might change if the system is able to meaningfully reorder the pending workload for processing.

a)  First thing first, let us understand the overhead of using SJN as the queue scheduling policy.  Measuring overheads is always hard, but luckily for you when things are implemented on a real machine like these assignments, measuring the true machine behavior becomes possible!

We are going to measure overheads in two situations:  (1) at low utilization, and (2) at high utilization. In both cases, you will run the commands provided below 10 times and extract the average server runtime. We will then compare the average obtained under FIFO vs. those obtained under SJN.

(1) Low Utilization. In the low-utilization test, run 10 times the following command for the FIFO experiment:

/usr/bin/time  -v  ./server_pol  -w  2  -q  100  -p  FIFO  2222  &  ./client  -a  10  -s  20  -n  1500  2222 As you can see the /usr/bin/time utility is prefixed to the server to obtain the final runtime statistics.

You should parse the 10 results from this command that are found in the “Elapsed (wall clock) time” statistic reported by the /usr/bin/time utility at the end of the run, and compute an average of these values.

Now, repeat the same thing by replacing -p  FIFO with -p  SJN in the command above.  Collect the new 10 values of wall-clock times and compute the average.  Finally, compare the average runtime computed for FIFO vs. SJN.

(2) High Utilization. In the high-utilization test, we follow an identical procedure as above, with the only difference that we change the amount of workload sent by the client.  The new command template will be:

/usr/bin/time  -v  ./server_pol  -w  2  -q  100  -p    2222  &  ./client  -a  40  -s  20  -n  1500  2222 where  should be set to FIFO in the first 10 runs, and to SJN in the last 10 runs.

Compare the average runtime under FIFO and SJN at low and high utilization, reasoning on the extra per-request time spent by the server under the two policies.

b)  Okay, we have understood the cost of SJN with the measurements above.  Now let us quantify the benefits.  In a way similar to what we did in HW1, we can measure the average response time as a function of the server utilization.  Recall that the utilization is computed as the sum of the length of all the processed requests over the total server runtime. With only one worker, that should be a number less than or equal to 1, with two workers it should be less than or equal to 2, and so on.

For this experiment, we will always set -w  2 to spawn two workers.  Next, do a series of experiments where you run the following template command 10 times:

./server_pol  -w  2  -q  100  -p  FIFO  2222  &  ./client  -a    -s  20  -n  1500  2222

Where the parameter  goes from a value of 22 (first run) to a value of 40 (10th run), thus increasing by 2 at every run. Use these experiments to construct a curve of the request response time as a function of the server utilization.

Now, do 10 more runs with the same strategy as described above, but where the server policy is set to SJN, thus the new command template will be:

./server_pol  -w  2  -q  100  -p  SJN  2222  &  ./client  -a    -s  20  -n  1500  2222

Plot the two curves (one from the FIFO experiments, and the other from the SJN experiments) in the same plot and try to quantify which queueing policy works better and by how much.