CS560 Final Exam - May 5, 2010

Answer all questions. You should note that although question 5 is by far the most time consuming question, it has a point value roughly equal to questions 2, 3 and 4, and far less than question 1. In other words, save it for last.

Question 1: Short Answers - 18 - 20 points

Part A: The following statement is false. Tell me why (2-3 sentences): "Round Robin scheduling is a good scheduling algorithm for a shared workstation environment like the Cetus lab.
Part B: The following statement is false. Tell me why (1 sentence): "Context switches are expensive because they consume too many CPU instructions."
Part C: Name the four necessary conditions for deadlock (4 terms, no sentences required).
Part D: In a deadlock avoidance scheme, the operating system will sometimes make a process block on a resource allocation request when it is possible to grant that request. Why? (2-3 sentences)
Part E: Define Belady's anomaly, and state how it can be used to detect a buggy page replaement algorithm. (3 sentences)
Part F: Define a working set (1 sentence). How do we approximate it (1-3 sentences)? What is the most useful practical function of a working set? (1-2 sentences).
Part G: I am going to dedicate an entire disk partition to a very large software package that I have purchased. It will be heavily used. Which block allocation scheme is ideal for my partition? (1-5 words).

Question 2: (9 points): Describe RAID-0, RAID-1 and RAID-4, both in words and with pictures. In each, briefly detail the performance of large writes and the tolerance to failures.

Question 3 (10 points): In a demand paging operating system, give a listing of all the steps that the hardware and operating system go through when a user process tries to access a memory location that is not resident in memory, but is on disk. In each step, state whether it is done in the hardware or operating system. My answer had 13 steps, the first of which was "The program issues a load instruction for memory address x," and the last of which was "The instruction is finished." You may assume a standard paging scheme (i.e. not an inverted paging scheme), the specifics of which are unimportant.

Question 4 (8-9 points) In this question, suppose my virtual address space is laid out so that the first page is invalid, there are 2 pages of code, and 3 total pages of globals and heap that directly follow the code. The stack starts at some very large address which will not concern us.

If PTEs are four bytes and pages are 512 bytes, answer the following questions:

Part A: Give me an example of a virtual address in hexadecimal that will cause a segmentation violation when it is written, but not when it is read.
Part B: Suppose that I am using a two-level paging scheme. Break up the virtual address 0xdb9658 into its three constituent parts.
Part C: Again, suppose that I am using a two-level paging scheme. Attempting to access the address 0x0 will cause a segmentation violation. Exactly where in the translation does this segmentation violation occur and why? Be specific.
Part D: Finally, suppose I am using a paged segmentation scheme, where I have four segments indexed off the first two bits of a virtual address. Each of the four segments has a STBR and STLR. The STBR points to the first page of the segment's page table, and the STLR contains the number of pages consumed by the segment's page table. What is the smallest virtual address that will cause a segmentation violation due to a hardware check of STLR-00?

Question 5: (10 points) You are co-writing an operating system with a collection of colleagues. You are responsible for the scheduling algorithm. You are to implement the following four procedures:

void scheduler_setup(). You get to use global variables -- here is where you set them up.
void job_ready(Job *j). This is called whenever a job enters the ready state.
Job *next_job(). This is called whenever the OS wants you to select a ready job to run. The job that you return will be the next running job. If there is no job to run, return NULL.
int do_i_switch(Job *j). This is called whenever a timer interrupt is generated and job j is running. If you decide that there should be no context switch, return 0. Otherwise, you need to return 1, and put the job into your scheduling queues. The caller will call next_job() to schedule the next job.

Note, you don't manage the currently running job -- your job is simply to manage the ready jobs, and to select which of the ready jobs should be run next.

Make the following assumptions:

The timer interrupts the CPU every 10 microseconds.
The observed CDF (cumulative distribution function) of CPU burst times has been plotted below:

Write the four procedures so that they implement a multi-level feedback queue. You may use C or C++, and if you'd like to use the STL, feel free to do so. I've included the syntax of the Dllist and JRB libraries below if you'd rather use them

dllist.h


typedef struct dllist {
  struct dllist *flink;
  struct dllist *blink;
  Jval val;
} *Dllist;

extern Dllist new_dllist();
extern void free_dllist(Dllist);
extern void dll_append(Dllist, Jval);
extern void dll_prepend(Dllist, Jval);
extern void dll_delete_node(Dllist);
extern int dll_empty(Dllist);


typedef struct jrb_node {
  struct jrb_node *flink;
  struct jrb_node *blink;
  Jval key;
  Jval val;
} *JRB;

extern JRB make_jrb();
extern JRB jrb_insert_str(JRB tree, char *key, Jval val);
extern JRB jrb_insert_int(JRB tree, int ikey, Jval val);
extern JRB jrb_insert_dbl(JRB tree, double dkey, Jval val);
extern JRB jrb_find_str(JRB root, char *key);
extern JRB jrb_find_int(JRB root, int ikey);
extern JRB jrb_find_dbl(JRB root, double dkey);
extern JRB jrb_find_gte_str(JRB root, char *key, int *found);
extern JRB jrb_find_gte_int(JRB root, int ikey, int *found);
extern JRB jrb_find_gte_dbl(JRB root, double dkey, int *found);
extern void jrb_delete_node(JRB node);
extern void jrb_free_tree(JRB root);