Question 2: Memory Management (Max Mark: 20 / 100)

It is sometimes useful to know which pages in a user program’s virtual address space have been accessed (read or write or both). This assignment requires you to write a system call for xv6 that checks which  page  in  a  process’s virtual address space has been accessed. Note that a good understanding of Task 6.2 will be helpful. The kernel function ptableprint() could be useful for debugging the code for this assignment. Therefore, you may want to use the same copy of xv6 that you have used for Task 6.2 for this question.

Task:  Write a system call named pageAccess() that will modify a bitmap that indicates which of the 64 physical memory  pages have been accessed.  The function prototype of this system call for user programs will be:

int pageAccess(char* buf, unsigned int npages, unsigned int* bmp);

This function should return a negative value if unsuccessful (for any reason).

Any other returned value indicates success. buf points to the start address of the virtual address space that needs to be checked for access.

npages gives the number of pages that should be examined. It should be not larger than 64.

bmp is a pointer to an unsigned integer that acts as a bitmap which indicates if a page has been accessed. Each bit of the unsigned integer corresponds to a page. Since an unsigned integer is 64 bits in size, npages is limited to 64.

As an example, if pages 1, 2, and 30 have been accessed, the lower 32 bits of this integer should have 1’s only for bits 1, 2 and 30 (the rest are 0’s), giving a decimal value of 230+22+21  = 1073741830 (hexadecimal $40000006) as shown below.

This function should return a negative value if unsuccessful (for any reason). Any other returned value indicates success. An example test program for your system call has been provided in the file pgaccess_test.c. This program should be compiled as a user program in xv6. It also serves as an example of how the system call is to be used. The bitmap should be set to the above value for this  example test program.  But you should check that your system call returns the values correspondingly if other pages have been accessed.

A skeleton code of your kernel function of this system call, sys_pageAcess(), can be found in the file sys_pageAccess.c.  Note that sys_pageAcess()  does not take any arguments. This is because the call to pageAccess is made in the user program (in user mode). Therefore, these arguments cannot be passed   directly to a kernel function (in kernel mode) in the usual way. Instead, you will need to  access the  arguments  in  sys_pageAcess() using argaddr and argint as demonstrated in the skeleton code. With the bitmap pointer, it is easier to store it in a variable in this function and then copy it to the user space before returning using copyout(). The code to do this has also been provided.   The remaining code to implement this kernel function will need to be supplied by you.

Submission  Requirements:   Clean up (remove) all the object files and executable files using the command make clean (in the directory where the Makefile  is  located). Then, in the parent  directory  of xv6-riscv,  run the  tar command to  archive  the  whole xv6riscv  directory  (with  its  sub-directories including user, kernel, and mkfs). Name this tar file q2-<std ID>.tar where <std ID> is your student ID. 

Question 4: CPU Scheduling Implementation (Max Mark: 40 / 100)

In this lab assignment, you will be implementing a Priority Scheduler for xv6. The default process scheduling policy of xv6 is Round Robin. In Lab 7, you have gone through the  process  of  implementing  a  First-Come-First-Served  (FCFS) scheduler. You will need to start with the code you have from Lab 7.

Task 1: To implement priority scheduling, you will first need to do the following:

(1) Add a variable in struct proc to indicate the nice level of a process. Use a range of 0 to 20, with 20 being the lowest and 0 the highest priority.

(2)  Determine the default priority of a process when it is created and add the code to do so. Usually, it is somewhere in the middle of the range.

(3)  Implement a system call:

int setnice(int pid, int n);

to change the nice value of process pid to n. The returned value should be the original nice value of this process.

(4)  Implement a second system call: int getnice(int pid); that returns the nice value of a process.

Task 2: Add code to implement priority scheduling if PRIORITY (rather than RR or FCFS) is defined. Do not remove the RR and FCFS codes from Lab 7. Use #ifdef to determine which code should be compiled from the compiler command line as   you   have   done   in    Lab   7.   Use   schedtest2.c    provided   to   test   your implementation.

Task 3: Obtain the average run time, waiting time and sleep times with Round Robin, FCFS, and Priority scheduling for 1, 2, and 3 CPUs. You will be compiling xv6-riscv with, for example,

make qemu SCHEDULER=PRIORITY CPUS=2 for Priority scheduling and 2 CPUs. You should use SCHEDULER=RR and SCHEDULER=FCFS to compile for Round Robin and FCFS respectively (same as what was done in Lab 7).

Tabulate your results and answer the following questions:

(a)  Comparing these average timings you have obtained, are they that you would expect?

(b)  Provide justifications for your answer to (a) above.

Note that you will need to use the user program schedtest for Round Robin and FCFS, and schedtest2 for Priority scheduling.

Submission   Requirements:   Clean   up   (remove)   all   the   object   files   and executable files using the command make clean (in the directory where the Makefile  is  located). Then,  in  the  parent  directory  of xv6-riscv,  run the  tar command to  archive  the  whole xv6riscv  directory  (with  its  sub-directories including user, kernel, and mkfs). Name this tar file q4-<std ID>.tar where <std ID> is your student ID.

The  code  you  added/modified  should   be   documented   with   appropriate comments. Your tabulated timing results and answers to the questions should be provided in a Microsoft Word or PDF file separate from the tar file. 

Question 5: Pipes (Max Mark: 12 / 100)

This question requires you to implement  a  user program in xv6-riscv. This program will make use of system calls fork, pipe, read, and write.

Task: Write a user program in xv6, name it pingpong. It should do the following:

(a) Create a child process.

(b) The parent will send an integer to this child process.

(c)  Upon receiving this integer, the child process prints its PID followed by the value of the integer it received.

(d) The child process should multiply the received integer by 4 and send the resulting integer back to the parent.

(e) The parent prints its PID followed by the value of the integer it received from the child.

Example of usage:

$ pingpong

4 Integer from parent = 4

3 Integer from child = 16

Requirements: Communication between the parent and child process should be through pipe. Your implementation must only establish a single pipe. Marks could be deducted for lack of comments in your program.

Submission   Requirements:   Clean   up   (remove)   all   the   object   files   and executable files using the command make clean (in the directory where the Makefile  is  located). Then,  in  the  parent  directory  of xv6-riscv,  run the  tar command to  archive  the  whole xv6riscv  directory  (with  its  sub-directories including user, kernel, and mkfs). Name this tar file q5-<std ID>.tar where <std ID> is your student ID.