Introduction

In this assignment you will solve a number of synchronisation and locking problems. You will also get experience with data structure and resource management issues.

Please complete the reading exercises for your week 5 tutorial.

Write Readable Code

There is no single right way to organise and document your code. It is not our intent to dictate a particular coding style for this class. The best way to learn about writing readable code is to read other people's code, for example OS/161. When you read someone else's code, note what you like and what you don't like. Pay close attention to the lines of comments which most clearly and efficiently explain what is going on. When you write code yourself, keep these observations in mind.

Here are some general tips for writing better code:

• Split large functions. If a function spans multiple pages, it is probably too long.
• Group related items together, whether they are variable declarations, lines of code, or functions.
• Use descriptive names for variables and procedures. Be consistent with this throughout the program.
• Comments should describe the programmer's intent, not the actual mechanics of the code. A comment which says "Find a free disk block" is much more informative than one that says "Find first non-zero element of array."

Setting Up Assignment 1

Your group account

You will do Assignment 1 as part of a two-person group. If you are not yet in a group, post to the appropriate message board on the cs3231 forum to find a partner. You must nominate your partner, and he or she must nominate you, via the group nomination form (under "Administration" on the left-hand side).

You will be notified by email when your group is created. Check the group nomination page for your group number. A group account will have been created for you in /home/osprjXXX, where XXX is your three-digit group number. For example, if you are a member of group 103, your group account is /home/osprj103.

Set up your group account

For assignment 0, you used the Subversion (SVN) revision control system to keep track of changes and to produce a file that you could submit. For this assignment, you will also use SVN. However, you have to do some extra set-up because you will be collaborating with another person on the assignment.

Before you start, both you and your partner will need to modify your umask so you and your partner to share the assignment files (if you're interested, see man umask for details). Do this by modifying your .profile in your home directory. Change the umask command to be the following.

umask 007

Now, whenever you log in, your umask will be set appropriately. Either log out and log back in again now or run the command source .profile to ensure your umask is set.

Obtain the assignment sources

For this assignment, you will set up an SVN repository in your group account directory (/home/osprjXXX). You may remember the repo directory you created for assignment 0. For assignment 1, you will be creating this repository in your group account directory. Initialise this repository now (only one group member needs to do this):

% cd /home/osprjXXX
% svnadmin create repo

Once again, this repository directory will be completely maintained for you by SVN. Now import the sources into your new repository in a similar way to assignment 0 (once again, only one group member should do this step):

% cd /home/cs3231/assigns
% svn import asst1/src file:///home/osprjXXX/repo/asst1/trunk -m "Initial import"

As in assignment 0, make an immediate branch of this import for easy reference when you generate your diff (only one group member should do this step):

% svn copy -m "Tag initial import" file:///home/osprjXXX/repo/asst1/trunk
file:///home/osprjXXX/repo/asst1/initial

You have now set up your repository. Both you and your partner should now check out a working copy:

% cd ~/cs3231
% svn checkout file:///home/osprjXXX/repo/asst1/trunk asst1-src

Configure OS/161 for Assignment 1

Before proceeding further, configure your new sources.

% cd ~/cs3231/asst1-src
% ./configure

We have provided you with a framework to run your solutions for ASST1. This framework consists of driver code (found in kern/asst1 ) and menu items you can use to execute your solutions from the OS/161 kernel boot menu.

You have to reconfigure your kernel before you can use this framework. The procedure for configuring a kernel is the same as in ASST0, except you will use the ASST1 configuration file:

% cd ~/cs3231/asst1-src/kern/conf	
% ./config ASST1

Building for ASST1

% cd ../compile/ASST1
% make depend
% make
% make install

% cd ~/cs3231/root
% sys161 kernel 
sys161: System/161 release 1.1, compiled Jul 28 2003 17:28:51

OS/161 base system version 1.08
Copyright (c) 2000, 2001, 2002, 2003
   President and Fellows of Harvard College.  All rights reserved.

Put-your-group-name-here's system version 0 (ASST1 #6)

Cpu is MIPS r2000/r3000
1876k physical memory available
Device probe...
lamebus0 (system main bus)
emu0 at lamebus0
ltrace0 at lamebus0
ltimer0 at lamebus0
hardclock on ltimer0 (10000 hz)
beep0 at ltimer0
rtclock0 at ltimer0
lrandom0 at lamebus0
random0 at lrandom0
lser0 at lamebus0
con0 at lser0
pseudorand0 (virtual)

OS/161 kernel [? for menu]: 

Command Line Arguments to OS/161

IMPORTANT: Please DO NOT change these menu option strings!

Here are some examples of using command line args to select OS/161 menu items:

sys161 kernel "at;bt;q"

sys161 kernel "q"

"Physical" Memory

In order to execute the tests in this assignment, you will need more than the 512 KB of memory configured into System/161 by default. We suggest that you allocate at least 2MB of RAM to System/161. This configuration option is passed to the busctl device with the ramsize parameter in your ~/cs3231/root/sys161.conf file. Make sure the busctl device line looks like the following:

31 busctl ramsize=2097152 

Concurrent Programming with OS/161

Built-in thread tests

Thread test 1 ( " tt1 " at the prompt or tt1 on the kernel command line) prints the numbers 0 through 7 each time each thread loops. Thread test 2 (" tt2 ") prints only when each thread starts and exits. The latter is intended to show that the scheduler doesn't cause starvation--the threads should all start together, spin for awhile, and then end together.

Debugging concurrent programs

The random number generator used to vary the time between these thread_yield() calls uses the same seed as the random device in System/161. This means that you can reproduce a specific execution sequence by using a fixed seed for the random number generator. You can pass an explicit seed into random device by editing the "random" line in your sys161.conf file. For example, to set the seed to 1, you would edit the line to look like:

	28 random seed=1 

Tutorial Exercises

Code reading

Thread Questions

1. What happens to a thread when it exits (i.e., calls thread_exit() )? What about when it sleeps?
2. What function(s) handle(s) a context switch?
3. How many thread states are there? What are they?
4. What does it mean to turn interrupts off? How is this accomplished? Why is it important to turn off interrupts in the thread subsystem code?
5. What happens when a thread wakes up another thread? How does a sleeping thread get to run again?

Scheduler Questions

Synchronisation Questions

Synchronisation Problems

Identify Deadlocks

semaphore *mutex, *data;
 
void me() {
	P(mutex);
	/* do something */
	
	P(data);
	/* do something else */
	
	V(mutex);
	
	/* clean up */
	V(data);
}
 
void you() {
	P(data)
	P(mutex);
	
	/* do something */
	
	V(data);
	V(mutex);
}

More Deadlock Identification

lock *file1, *file2, *mutex;
 
void laurel() {
	lock_acquire(mutex);
	/* do something */
	
	lock_acquire(file1);
    	/* write to file 1 */
 
	lock_acquire(file2);
	/* write to file 2 */
 
	lock_release(file1);
	lock_release(mutex);
 
	/* do something */
	
	lock_acquire(file1);
 
	/* read from file 1 */
	/* write to file 2 */
 
	lock_release(file2);
	lock_release(file1);
}
 
void hardy() {
    	/* do stuff */
	
	lock_acquire(file1);
	/* read from file 1 */
 
	lock_acquire(file2);
	/* write to file 2 */
	
	lock_release(file1);
	lock_release(file2);
 
	lock_acquire(mutex);
	/* do something */
	lock_acquire(file1);
	/* write to file 1 */
	lock_release(file1);
	lock_release(mutex);
}

Synchronised Queues

This is the assessable component of this assignment. It is worth 40 marks of the 100 available for the class mark component of the course.

Solving Synchronisation Problems

We have provided you with basic driver code that starts a predefined number of threads that execute a predefined activity (in the form of calling functions that you must implement). You are responsible for implementing the functions called.

Remember to specify a seed to use in the random number generator by editing your sys161.conf file, and run your tests using sys161 command line args. It is much easier to debug initial problems when the sequence of execution and context switches is reproducible.

When you configure your kernel for ASST1, the driver code and extra menu options for executing your solutions are automatically compiled in.

Concurrent Mathematics Problem

For the first problem, we ask you to solve a very simple mutual exclusion problem. The code in kern/asst1/math.c counts from 0 to 10000 by starting several threads that increment a common counter.

You will notice that as supplied, the code operates incorrectly and produces results like 345 + 1 = 352 .

Once the count of 10000 is reached, each thread signals the main thread that it is finished and then exits. Once all adder() threads exit, the main (math()) thread cleans up and exits.

Your Job

Note that the number of increments each thread performs is dependent on scheduling and hence will vary. However, the total should equal the final count.

To test your solution, use the "1a" menu choice. Sample output from a correct solution in included below.

% sys161 kernel "1a;q"
sys161: System/161 release 1.1, compiled Feb 24 2003 21:57:51

OS/161 base system version 1.08
Copyright (c) 2000, 2001, 2002, 2003
   President and Fellows of Harvard College.  All rights reserved.

Put-your-group-name-here's system version 0 (ASST1 #28)

Cpu is MIPS r2000/r3000
848k physical memory available
Device probe...
lamebus0 (system main bus)
emu0 at lamebus0
ltrace0 at lamebus0
ltimer0 at lamebus0
hardclock on ltimer0 (10000 hz)
beep0 at ltimer0
rtclock0 at ltimer0
lrandom0 at lamebus0
random0 at lrandom0
lser0 at lamebus0
con0 at lser0
pseudorand0 (virtual)

OS/161 kernel: 1a
Starting 10 adder threads
Adder threads performed 10000 adds
Adder 0 performed 1008 increments.
Adder 1 performed 1032 increments.
Adder 2 performed 998 increments.
Adder 3 performed 1017 increments.
Adder 4 performed 1012 increments.
Adder 5 performed 988 increments.
Adder 6 performed 971 increments.
Adder 7 performed 975 increments.
Adder 8 performed 1027 increments.
Adder 9 performed 972 increments.
The adders performed 10000 increments overall
Operation took 3.665222400 seconds
OS/161 kernel: q
Shutting down.
The system is halted.

Restaurant Synchronisation Problem

Being an operating system expert, you quickly realise that the restaurant's problems are related to concurrency issues between the requesting of tables by tour operators for their buses, and the allocation of tables. You volunteer your services to provide a solution to the restaurant's problems, reduce the chaos, and restore order.

The Basic Restaurant

• Builds a list of requested tables from the current bus load of tourists he manages.
• Submits the request to the restaurant and waits for tables to become available.
• Seats his tourists, and they eat.
• Indicates to the restaurant when the tourists have finished eating and the table(s) are now free again.

• It initialises all the table counters to zero uses.
• It calls restaurant_open, a routine you will provide to set up the restaurant.
• It then creates some threads to run as tour operators. Note these threads obviously run concurrently.
• The driver thread then waits on a semaphore for all the tour operators to finish, after which we print out the table statistics for the day.
• Finally, it calls restaurant_close, a procedure you provide to clean up when the restaurant has closed.

Have a quick look through both restaurant_driver.c and restaurant_driver.h to reinforce your understanding of what is going on (well, at least what is expected to go on).

Your Job

Generally, your solution must result in the following when run_restaurant() is called during testing.

• The restaurant being prepared for opening.
• All tour operators having their tables allocated correctly. "Correct" means that for each non-null entry in the table_request array results in tourists of that operator having exclusive access to the requested tables until they leave.
• The restaurant being suitably cleaned up afterwards (allocated memory or locks, semaphores, etc being freed).
• Statistics kept on table usage are consistent with the requests made.

You can modify restaurant_driver.c and restaurant_driver.h to test different scenarios (e.g vary the number of tour operators or tables requested), but your solution must not rely on any changes you make to the restaurant_driver.c file.

You will have to modify restaurant.c to implement your solution. However, your modifications have the constraint that they must still work with an original restaurant_driver.c.

For testing, we will replace restaurant_driver.c and .h with logically equivalent versions that may vary the numbers of participants, and the tables requested. We may also vary the timing of various functions. A correct solution will work for all variations we test. Sample output from a correct solution is included below.

% sys161 kernel "1b;q"
sys161: System/161 release 1.12, compiled Mar  8 2005 21:30:24

OS/161 base system version 1.10
Copyright (c) 2000, 2001, 2002, 2003
   President and Fellows of Harvard College.  All rights reserved.

Put-your-group-name-here's system version 0 (ASST1 #32)

Cpu is MIPS r2000/r3000
1880k physical memory available
Device probe...
lamebus0 (system main bus)
emu0 at lamebus0
ltrace0 at lamebus0
ltimer0 at lamebus0
hardclock on ltimer0 (10000 hz)
beep0 at ltimer0
rtclock0 at ltimer0
lrandom0 at lamebus0
random0 at lrandom0
lser0 at lamebus0
con0 at lser0
pseudorand0 (virtual)

OS/161 kernel: 1b
Opening the restaurant
The tour operators are starting
OP 0 starting
OP 1 starting
OP 2 starting
OP 3 starting
Op 0 going home after seating 200 tables
OP 4 starting
Op 1 going home after seating 200 tables
Op 2 going home after seating 200 tables
Op 3 going home after seating 200 tables
Op 4 going home after seating 200 tables
The restaurant is closing
Table 1 reserved 1000 times
Table 2 reserved 0 times
Table 3 reserved 0 times
Table 4 reserved 0 times
Table 5 reserved 0 times
Table 6 reserved 0 times
Table 7 reserved 0 times
Table 8 reserved 0 times
Table 9 reserved 0 times
Table 10 reserved 0 times
Table 11 reserved 0 times
Table 12 reserved 0 times
Table 13 reserved 0 times
Table 14 reserved 0 times
Table 15 reserved 0 times
Table 16 reserved 0 times
Table 17 reserved 0 times
Table 18 reserved 0 times
Table 19 reserved 0 times
Table 20 reserved 0 times
Total reservations 1000
The restaurant is closed, bye!!!
Operation took 0.555521080 seconds
OS/161 kernel: q
Shutting down.
The system is halted.

Before Coding!!!!

The following questions may help you develop your solution.

• What are the shared resources?
• Who shares what resources?
• Who produces what and who consumes what?
• What states can the various resources be in?
• What do you need to keep a count of?the shop)?
• How does your solution prevent deadlock or starvation?

Bounded-buffer producer / consumer problem

Your final task in this assignment is to implement a solution to a standard producer / consumer problem. In the producer / consumer problem one or more producer threads put data into a fixed-sized buffer while one or more consumer threads process information from the same buffer.

The code in kern/asst1/producerconsumer_driver.c starts up a number of producer and consumer threads. The producer threads attempt to communicate with the consumer threads by calling the producer_produce() function with a data structure. In turn, the consumer threads attempt to receive information from the consumer threads by calling consumer_consume(). Unfortunately, these functions are currently unimplemented. Your job is to implement them.

Here's what you will see before you have implemented any code:

OS/161 kernel [? for menu]: 1c
run_producerconsumer: starting up
Consumer started
Consumer started
Consumer started
Consumer started
Consumer started
*** Error! Consumer bored, exiting...
Producer started
Producer finished
Producer started
Waiting for producer threads to exit...
Producer finished
All producer threads have exited.
*** Error! Consumer bored, exiting...
*** Error! Consumer bored, exiting...
*** Error! Consumer bored, exiting...
*** Error! Consumer bored, exiting...
Operation took 0.637168200 seconds
OS/161 kernel [? for menu]: 

And here's what you will see with a (possibly partially) correct solution:

OS/161 kernel [? for menu]: 1c
run_producerconsumer: starting up
Consumer started
Consumer started
Consumer started
Waiting for producer threads to exit...
Producer started
Consumer started
Producer started
Producer finished
Consumer started
Producer finished
All producer threads have exited.
Consumer finished normally
Consumer finished normally
Consumer finished normally
Consumer finished normally
Consumer finished normally
Operation took 0.232509280 seconds
OS/161 kernel [? for menu]: 

• producerconsumer_driver.c: Starts the producer / consumer simulation by creating appropriate producer and consumer threads that will call producer_produce() and consumer_consume(). You are welcome to (in fact, you are encouraged to) modify this simulation when testing your implementation, but remember that it will be overwritten with a standard copy when your solution is tested.
• producerconsumer_driver.h: Contains prototypes for the functions in producerconsumer.c, as well as the description of the data structure that is passed from producer to consumer (uninterestingly named pc_data). This file will also be overwritten when your solution is tested.
• producerconsumer.c: Contains your implementation of producer_produce() and consumer_consume(). It also contains the functions producerconsumer_startup() and producerconsumer_shutdown(), which you can implement to initialise your data structure and any synchronisation primitives you may need.

How to implement your solution

You must implement a data structure representing a buffer capable of holding at least BUFFER_SIZE struct pc_data items. This means that calling producer_produce() BUFFER_SIZE times should not block (or overwrite existing items, of course), but calling producer_produce one more time should block, until data has been removed from the buffer using consumer_consume(). A simple way to implement this data structure is to use an array, though you will of course have to use appropriate synchronisation primitives to ensure that concurrent access is handled safely.

Your data structure should function as a circular buffer with first-in, first-out semantics.

Evaluating your solutions

Performance will be judged in at least the following areas.

• Do all the tour operators participate?
• Can tourists from different operators eat in parallel if they do not require the same tables?
• Do you define critical sections larger than needed?
• Does your solution to part 3 work with different numbers of producers and consumers?
• Does your solution to part 3 avoid starvation? That is, if an item is produced, will it eventually be consumed, and is the delay between "produced" and "consumed" roughly the same for all data items?

Documenting your solutions

The document will be used to guide our markers in their evaluation of your solution to the assignment. In the case of a poor results in the functional testing combined with a poor design document, we will base our assessment on these components alone. If you can't describe your own solution clearly, you can't expect us to reverse engineer the code to a poor and complex solution to the assignment.

Create your design document to the top of the source tree to OS/161 (~/cs3231/asst1-src), and include it in svn as follows.

% cd ~/cs3231/asst1-src
% svn add design.txt

When you later commit your changes into your repository, your design doc will be included in the commit, and later in your submission.

You should first commit your changes back to the repository using the following command. Note: You will have to supply a comment on your changes. You also need to coordinate with your partner that the changes you have (or potentially both have) made are committed consistently by you and your partner, such that the repository contains the work you want from both partners.

% cd ~/cs3231/asst1-src
% svn commit

Once your solution is committed, generate a diff.

% svn diff file:///home/osprjXXX/repo/asst1/initial
file:///home/osprjXXX/repo/asst1/trunk >~/asst1.diff

Submitting Your Assignment

% cd ~
% give cs3231 asst1 asst1.diff