# Computer Science 322 Operating Systems

### Mount Holyoke College Spring 2010

Lab 6: Working Set Simulator
Due: 2:40 PM, Wednesday, April 21, 2010

Your final regular lab task will investigate the ideas of working sets to allocate frames of physical memory to a (simulated) process in execution.

You may work individually or in groups of two or three.

Page Reference String

In order to investigate working set allocation scheme through simulation, we use a page reference string that represents a sequence of memory accesses, and simulate what would happen in a working set allocation given that access string.

We will consider a "pseudo-realistic" page reference string that corresponds to the following program segment, written in a C-like language:

```  const int n=10;
int i, j, A[n], B[n], C[n], temp;

for (i=1; i<=n; i++) {
A[i]=i;
B[i]=n-i+1;
}
for (i=1; i<=n; i++) {
temp=0;
for (j=i; j<=n; j++) {
temp=temp+A[n+i-j]*B[j];
}
C[i]=temp;
}
```

Using a hypothetical machine with registers denoted by Ri and a fixed instruction size of 1 word per instruction, the machine language version of this program is loaded in virtual address space (with page size 4K, i.e., 1024 words) as follows:

```0x2FBC  (R1) <- ONE            Index i
0x2FC0  (R2) <- n              Loop bound
0x2FC4  compare R1,R2          Test i>n
0x2FC8  branch_greater * + 0x20
0x2FCC  A(R1) <- (R1)          Compute A[i]
0x2FD0  (R0) <- n              Compute B[i]
0x2FD4  (R0) <- (R0) - (R1)
0x2FD8  (R0) <- (R0) + ONE
0x2FDC  B(R1) <- (R0)
0x2FE0  (R1) <- (R1) + ONE     Increment i
0x2FE4  branch * - 0x20
0x2FE8  (R1) <- ONE            Index i
0x2FEC  (R2) <- n              Loop bound
0x2FF0  compare R1,R2          Test i>n
0x2FF4  branch_greater * + 0x50
0x2FF8  (R0) <- ZERO           temp <- 0
0x2FFC  temp <- (R0)
0x3000  (R3) <- (R1)           Index j
0x3004  (R4) <- n              Loop bound
0x3008  compare R3,R4          Test j>n
0x300C  branch_greater * + 0x20
0x3010  (R0) <- n              Compute A[n+i-j]
0x3014  (R0) <- (R0) + (R1)
0x3018  (R0) <- (R0) - (R3)
0x301C  (R5) <- A(R0)
0x3020  (R6) <- B(R3)          Compute B[j]
0x3024  (R5) <- (R5) * (R6)
0x3028  (R5) <- (R5) + temp
0x302C  temp <- (R5)
0x3030  (R3) <- (R3) + ONE     Increment j
0x3034  branch * - 0x20
0x3038  C(R1) <- (R5)          Compute C[i]
0x303C  (R1) <- (R1) + ONE     Increment i
0x3040  branch * - 0x50
...
0x6000  Storage for C
0x7000  Storage for ONE
0x7004  Storage for n
0x7008  Storage for temp
0x700C  Storage for ZERO
0x8000  Storage for A
0x9000  Storage for B
```

Upon execution of this program segment, the following reference string is generated:

omega = 272722(28272272927222)n272722(272733733(373338393373737333)n-i+13637322)n

Write a program (in the language of your choice) that simulates (yes, another simulator) the run-time behavior of this program segment when a working set memory management policy is used. The program should print values:

 Delta = window size P(Delta) = total number of page faults W(Delta) = average working set size F(Delta) = (P(Delta))/(|omega|) = average page fault rate

The main program should take the value of Delta as a command-line parameter. This will allow you to write a script (in your favorite scripting language) that runs the program repeatedly for the values of Delta required. The value of Delta should be specified with the -d flag. A debugging mode should be turned on by -D, which should show how the working set changes as each page is referenced. The program also takes a flag -n to specify n in the reference string used. The default is 10, and you may use that to generate your plots. You are encouraged to try other values of n, but you need only plot for n=10.

Note that as each entry in the reference string (page) is processed, one of four things will happen to the working set. (i) the page is added to the set, and none is removed, (ii) the page is added to the set and one old page is removed, (iii) the page is already in the set and another page is removed, or (iv) the page is already in the set and no other page is removed.

Your program may hard-code the reference string (or generate it on the fly) but at least design your program to be modular enough that you could replace one function to generate a different reference string.

A Brief Simulation Study

Use this program to plot the following curves:

1. Delta vs. P(Delta),
2. Delta vs. W(Delta), and
3. Delta vs. 1/F(Delta),

for values of Delta ranging from 1 to 200.

From the plot of Delta vs. 1/F(Delta), explain the cause of all knees in the graph in terms of program (or reference string) structure.

Is the strategy used by this program one that could be used by a real system to keep track of a process' working set? Why or why not?

If you do not get your simulator working in time, you may use my program to generate your plots and answer the questions for the simulation study.

Submission and Evaluation

This lab is graded out of 20 points.

By 2:40 PM, Wednesday, April 21, 2010, submit documented source code, a Makefile to allow easy compilation, and a document (PDF file preferred) that contains your simulation study. All necessary files should be submitted by email to jteresco AT mtholyoke.edu.

 Grading Breakdown Reference string generation 2 points Correct and efficient working set simulation 6 points Program design and style 2 points Program documentation 2 points Simulation study and writeup 8 points