Programming Assignment 3 Version 1.0 - Initial release	CS370: Operating Systems

Description of Task

For this assignment, you will write a C library that implements a semaphore system that you can use to solve the reader/writer problem.

Your library will contain the following calls:

• int sem_init ();
  • Called once by the parent process, it creates global semaphore table in shared memory.
  • Returns success(0) or failure(-1).
  • Assume the global semaphore table can handle 20 semaphores.

• int sem_open (char *name, int initial_value);
  • Returns a sem_id (non-negative integer) associated with the argument name.
  • The sem_id is a local identifier used by the calling thread, much like a file descriptor from open().
  • If the semaphore does not exist when called, the routine will create it.
  • If the routine creates it, the count of the semaphore is set to the initial_value.
  • If the semaphore exists, the initial_value is ignored.
  • Names will be smaller than 8 characters.
  • Error returns -1.

• int sem_close (int semid);
  • Releases the semid so that it is no longer in use by this thread.
  • If no other threads reference the semaphore anymore, the semaphore is removed from the table.
  • Returns success (0) or failure (-1).

• int sem_wait (int semid);
  • If the referenced semaphore is not locked and there are no tasks already waiting for the semaphore, the function returns with the semaphore locked.
  • If the referenced semaphore is locked, the process is added to the wait queue.
  • Returns success (0) or failure (-1).

• int sem_signal(int semid);
  • If the referenced semaphore has waiting processes, the first one on the queue is restarted.
  • If the referenced semaphore has no waiting processes, the semaphore is unlocked.
  • Returns success (0) or failure (-1).

• int sem_destroy();
  • Releases the global semaphore table.
  • Returns success (0) or failure (-1).

• int sem_depth(int semid);
  • Returns the depth of the queue of the semaphore.

Specifications

1. Your makefile shall create an C library file (.a) called libusem.a when make lib is called. If you don't know how to build a static C library, Google it. An example of a Makefile that does so can be found here.
2. The library solution should contain 2 files, usersem.c and usersem.h.
3. The file usersem.c will contain the source code to implement the routines.
4. The file usersem.h will contain the constants, pointer to the global semaphore table, and prototypes necessary to compile and use the routines in usersem.c.
5. Implementation of the semaphores will be done using shared memory and pthread mutexes and condition variables.

Testing

You will test your program by writing the reader/writer problem given in Midterm 1 using the semaphores from your library. This time, implement writer's preference rather than reader's preference.

• Your makefile will also create your test program by typing in make P3.
• Your executable will be called P3 and take two mandatory arguments and one optional argument, described below. These arguments can be passed to the program in any order.
  • -r defines the number of reader threads
  • -w defines the number of writer threads
  • -v optional. turns on verbose.
• Your program should be able to handle up to 1 to 10 writers and 1 to 100 readers (all numbers inclusive).
• Your program will declare a global integer sleepval that will be shared by all readers and writer threads and two global variables to count the number of reads and writes.
  • Initialize this variable to 10.
  • sleepval will be protected by whatever semaphores necessary from your library to implement concurrency.
• Each reader and writer should be seperate threads from main.
• Each reader and writer should perform their activities in a loop until main sets a flag telling them to finish.
• Main should spawn the readers and writers (passing each the ordinal of its creation as a thread id) then wait for 30 seconds and signal the threads to finish. Every 5 seconds, main should print the number of reads and writes that have occurred.
• Each reader will:
  • Perform the actions necessary to begin reading.
  • Safely read the value of sleepval.
  • Increment a global variable indicating the number of reads performed.
  • Sleep for sleepval milliseconds.
  • Perform the actions necessary to end reading.
  • Generate another random number between 100 and 500
  • Sleep for that number of milliseconds.
  • If -v specified, print the depth of the queue of the mutex semaphore protecting readcount before acquiring it and the value read.
• Each writer will:
  • Generate a random number between 100 and 1000
  • Sleep for that number of milliseconds.
  • Generate another random number between 10 and 50.
  • Perform the actions necessary to begin writing.
  • Safely store that number in sleepval.
  • Increment a global variable indicating the number of writes that have been done..
  • Sleep for sleepval number of milliseconds.
  • Perform the actions necessary to stop writing.
  • If -v specified, print the depth of the queue of the semaphore protecting writecount before acquiring it and the value written.

---

What to Submit

Submit your tar file containing your .c and .h files for both the library and the test program, your Makefile, and a README file containing a description of each file and any information you feel the grader needs to grade your program.

The program files should be well documented with both data dictionaries and logic flow descriptions.

Your makefile should perform a make clean, make target, and a make all as well as the actions described above. Name the executables per the requirements.

You are required to work alone on this lab.

Submit all files using the RamCT CS370 Assignment Submission icon

This is Programming Assignment 3.

Late Policy

Please see here for the Late Policy regarding this assignment.