In this project will

1. design and implement a reader/writer lock using semaphores that does not starve the readers and does not starve the writers;
2. write the main C or C++ program that uses the reader/writer lock;
3. come up with a set of input scenarios that shows the behavior of your nonstarving lock compared to the starving lock.

The readers/writers problem is presented in section 31.5 of the textbook along with the readers/writers lock that starves writers. There may be solutions published in articles over the years – feel free to consult and cite them. It is not acceptable to use code that implements this solution from the Internet or other sources other than your own work. It is acceptable to use the code from the textbook as your starter code, if useful.

This is an individual project.

The deliverables of this project are

• A report (in PDF) that includes
  • A short description of the problem you address in your own words.
  • Both a written description in plain English and pseudocode of your solution.
  • An estimation of the time you spent working on the project.

This is likely to be a very short report – do not try to make it longer than it needs. But do make it neat in presentation.

• A tar file that includes
  • A makefile for easy compilation. The target executable should be rwmain.
  • A README file that describes how to run your project (arguments, etc).
  • A C or C++ program, named readerwriter.c/cpp, that implements the nonstarving locks.
  • A C or C++ program, named main.c/cpp, that uses the locks and shows their
    functionality. Note that the reading/writing parts of the code are only
    simulated: you do not have to read or write a particular data structure;
    instead, you might want to pretend to do it, and take some time such as

reading_writing(){
    int x=0, T;
    T = rand()%10000;
    for(i = 0; i < T; i++)
        for(j = 0; j < T; j++)
            x=i*j;

This function is only meant to waste time for a variable amount of time. Feel free to adjust this code as you see fit (or ignore all together if not useful in your solution).

There are no required inputs to this program. You may use inputs if useful and explain their use in the README file. Output messages useful for testing and debugging may be included as well.

• • An input file, named scenarios.txt, that proves that your lock
    • Is a correct readers/writers lock.
    • Does not starve the writers.
    • Does not starve the readers.
    • Each scenario takes one line (as the traces file in last project)
    • An example and interpretation of this file is below:
      rwrrrrwrr
      wwrrrrwr
      This file contains two scenarios
      1. One in which one reader arrives first, then a writer, then four more readers, another writer, then two more readers.
      2. And the second in which two writers arrive first, then four readers, one more writer, and one more reader.
    • You want these scenarios to test corner cases that are relevant for the point of your design: specifically, that writers will not starve. Thus, you design these test scenarios to make it possible for writers to starve. You do not need lots of readers/writers to make the case. You might want to limit each scenario to 10–15 readers and writers at the very most.

To ease the task of grading, please name your files as requested and put all these files in the same folder. In addition, please hardcode the file name for scenarios.txt with the relative path (not the absolute path) in your main.c/cpp code, e.g.,

FILE* ptr = fopen("scenarios.txt ","r");