CSc 422 Home

Play Fair

This threding assignment is a bit of an investigation. You will find on this page an implementation of the readers/writers problem using semaphores in C++. The links are near the bottom of the page, including the full package download. The solution works, but, as noted in class, it tends to favor readers. When there are many readers, writers tend to starve.

The program contains the readers/writers solution (which is not a lot of code) and a test application (which is most of the code). The test application maintains a shared linked list of nodes containing a string and a value, and methods for manipulating the shared structure. There are two update methods: update adds or increments an item, and remove_node does just that. There are three reading methods, one that just finds the value associated with a name, one that takes an average of the values, and one that finds their range. In all cases, the values are chosen at random. Names are chosen at random from a pre-defined list.

The program contains three types of threads: a reading thread, a writing thread, and a monitor thread. The reading and writing thread each repeatedly choose at random a method of the appropriate type and execute it, printing (or maybe not printing) the result. (The types are not chosen with equal probabilities. The item lookup is a more likely reader, update is a more likely writer.) The progress monitor periodically prints a message showing how far each of the other threads has run. The program starts several reader and several writer threads, and one monitor thread. The numbers can be controlled from the command line. When run without any parameters, it runs 10 each of the reader and writer threads, and each thread performs 10 operations an exits, for a total of 200 operations on the shared data structure. It looks something like this, though I'll omit much of the lengthy output:

The program is designed to measure progress of reading v. writing, but to do that you need to use larger numbers. It also helps to use the -q parameter, which basically turns off output except from the progress thread. For instance,

and greater when more:

The project is to modify the program to make it fairer to writers, so the output is more along these lines:

Create a version of the program in which both readers and writers will proceed at similar rates. When run with the same numbers of reader and writer thread, the percentage progress should of each side should be similar at each report. When the number of readers and writers is very different, the best result would still be similar progress (as a percentage) on each side, but that might not be possible. If there are lots of readers and just a few writers, the writers may progress faster just because they have less to do. If this is the case, a good solution should be symmetrical, so that giving either side fewer threads speeds it up by about the same amount. Most points will be just for trying something reasonable without breaking the program, but do try to create a good solution.

The file rw3.cpp contains the test application. You probably don't want to change this. The file readerwriter.h contains the procedures that readers and writers execute when starting and finishing reading. This is the place to change. The semaphore implementation is also there (semaphore.h/semaphore.cpp), and could perhaps be changed.

Building the Program

To build the program on Linux, simply unpack the zip into a directory, go there, and say make. The executable is rw3, which just means I was experimenting a bit. Macs should work the same if g++ is installed, but I don't have one, so I can't try it. Type the name to run the program. The command line flags are as discussed above. Say rw3 -h to get a summary of them.

The program will build on Windows with CodeBlocks. First, check the compiler flags under Settings/Compiler/Compiler Settings/Compiler Flags. Make sure to tick the box that says “Have g++ follow the C++11 ISO C++ language standard [-std=c++11]”. It may already be set, but I'm not sure what the default is. Then,

1. Download and unpack the zip file.
2. Create a project. File/New/Project/Console Application, then press Go. Choose a C++ application, and name it and store it where you like. Probably makes the most sense to store it inside the folder where you unpacked the program.
3. Open each of the code files (.cpp and .h), and add them to the project. Right click its tab, and add to the current project.
4. The project will appear in the left-hand pane. Expand it.
5. Find the file main.cpp which the program has added automatically in an attempt to helpful. Right click on it and remove it from the project.
6. You should be able to build the project from the Build menu.

To run the program, you should open a command window, go do the directory where the executable is located, and run it from there by typing its name. This will give you easy control of the command-line parameters so you can experiment with the program's behavior.

The program will behave differently each time it is run because of the random numbers it uses, and because the threads will be scheduled differently. It may also behave differently on different systems (or even different C++ compilers) because of differences in the scheduling. If you find a system that exhibits some sort odd performance behavior, please let me know about it.

Submission

When your program works, and is properly commented and indented, submit it over the web using this form. You probably only want to send one file, the modified reader/writer entry methods, but you can send other files if you happened to have changed them. Note that they are all optional on the submit form.