CSE551 -- Programming Assignment #2

Out: Thursday February 3rd, 2011
Due: Thursday February 17th, 2011, before class

[ overview | details | bonus | partners | what to turn in ]


In this assignment, you will investigate the impact of system call overhead on application performance. Your ultimate goal is to produce a set of graphs that looks something like the following:

This graph shows some application-level benchmark performance as a function of system call latency. To generate this graph, you will modify the linux kernel so that you can add a specifiable amount of overhead to every system call. By varying this overhead, you can measure benchmark performance as a function of this overhead to generate the curve.

Choice of OS: Note that this assignment is written with the assumption that you'll modify the Linux kernel. If you'd prefer to do this assignment on another OS, such as Windows, you are welcome to do this. However, you will need to be careful of intellectual property and confidentiality issues. If you modify Windows kernel code, instead of submitting your code patches, please instead give us a little more written explanation of how your code patches work and the performance or coding complexity implications of it. Do NOT submit any confidential information. Talk to your instructor or TA if you have concerns.

Assignment details

Here are the steps we recommend that you should follow:
  1. Set up an environment in which you can install linux and compile linux kernels. I strongly recommend using VMware for this. (It is true that VMware will affect your benchmark performance, but let's ignore that for this assignment.) You'll need to:

  2. Download and install the linux kernel source code. You can get source code for different kernel versions from www.kernel.org.

  3. Practice compiling and installing a new kernel based on the kernel source code you downloaded. If you've never compiled/installed a kernel, you can find plenty of help on the Web, for example, from here.

  4. Modify the linux kernel so that you can add overhead to every system call that occurs. To do this, you'll need to:

  5. Make it possible for user-level programs to change the amount of system call overhead introduced by your code. I suggest that you add something to the /proc virtual file system to do this -- i.e., by writing a number to a file you create in proc, your code will vary the amount of loop overhead according to that number. There are plenty of web pages that will help you learn how to add something to the /proc filesystem; see, for example, here.

  6. Calibrate your system call overhead by measuring the latency of a simple system call (e.g., close(100)) as a function of your variable overhead.

  7. Measure the performance of the following three benchmarks as a function of system call overhead:

    Be careful of caching effects when running your benchmarks, in particular, of the file system buffer cache!


If you want some extra credit, find a way to add a similar delay loop (including another /proc interface) on the ethernet packet reception and transmission paths. Calibrate this delay loop. Devise an experiment to measure the impact of this delay on the throughput and latency of serving a small, static web page from Apache. Devise another experiment to measure the impact of this delay on the throughput and latency of serving a large, static web page from Apache. Explain your results.

Partnering up

You have the choice of doing this assignment solo, or in teams of two. If you'd like to do it in a team, first try to find your own teammate. If you can't, then try posting a note to the course message board seeking a partner. If nobody bites, talk to your instructor or TA to see if they can help you find a partner.

What to turn in

You should submit your assignment by emailing a single .tar.gz/.zip archive to Steve and Dane containing the following elements: