Warm Up Project: Multithreaded Programming and Synchronization

COP 5614 – Operating Systems

1. Summary

The warm up project is regarding several important topics on process management. We will do it

in user space using a widely-used threads programming interface, POSIX Threads (Pthreads). You

should implement this in Linux (such as Ubuntu 16.04), which supports Pthreads as part of the

GNU C library. And implement a loadable kernel module (LKM) to get the statistic information

about processes and threads.

You should submit the required deliverable materials to Canvas before 11:59pm, September 6,

2020 (Sunday).

2. Description

In this assignment, you will be working with the “threads” subsystem of Linux. This is the part of

Linux that supports multiple concurrent activities within the kernel. In the exercises below, you

will write a simple program that creates multiple threads to control the synchronization and fulfill

the requirement.

2.1 Environment Set Up

It’s recommendable to use Ubuntu as operating system to accomplish this project. Ubuntu is an

open source operating system software for computers. It is one of the distribution systems of Linux,

and is based on the Debian architecture. For those who don’t have Ubuntu installed in their

computers, it’s doable to use virtual machine (Virtual Box) and install the virtual Ubuntu in your

local operating system.

2.2 Multi-Thread Programming

Step 1: Write A Program to Finish Below Requirement

You are to write code to help synchronize a professor and his/her students during office hours. The

professor, of course, wants to take a nap if no students are around to ask questions; if there are

students who want to ask questions, they must synchronize with each other and with the professor

so that

(i) No more than a certain number of students can be in the office at the same time because

the office has limited capacity.

(ii) Only one person is speaking at a time.

(iii) Each student question is answered by the professor.

(iv) No student asks another question before the professor is done answering the previous

one.

(v) Once a student finishes asking all his/her questions, he/she must leave the office to

make room for other students waiting outside the professor’s office.

You are to provide the following functions:

Professor(). This functions starts a thread that runs a loop calling AnswerStart() and

AnswerDone(). See below for the specification of these two functions. AnswerStart() blocks

when there are no students around.

Student(int id). This function creates a thread that represents a new student with identifier

id that asks the professor one or more questions (the identifier given to your function can be

expected to be greater or equal to zero and the first student’s id is zero).

First, each student needs to enter the professor’s office by calling EnterOffice(). If the office

is already full, the student must wait. After a student enters the office, he/she loops running the

code QuestionStart() and QuestionDone() for the number of questions that he/she wants to ask.

The number of questions is determined by calculating (student identifier modulo 4 plus 1). That

is, each student can ask between 1 and 4 questions, depending on the id. For example, a student

with id 2 asks 3 questions, a student with id 11 asks 4 questions and a student with id 4 asks a

single question. Once the student has got the answer for all his/her questions, he/she must call

LeaveOffice(). As a result, another student waiting on EnterOffice() may be able to proceed.

AnswerStart(). The professor starts to answer a question of a student. Print …

Professor starts to answer question for student x.

AnswerDone(). The professor is done answering a question of a student. Print …

Professor is done with answer for student x.

EnterOffice(). It is the student’s turn to enter the professor’s office to ask questions. Print …

Student x enters the office.

LeaveOffice(). The student has no more questions to ask, so he/she leaves the professor’s

office. Print …

Student x leaves the office.

QuestionStart(). It is the turn of the student to ask his/her next question. Print …

Student x asks a question.

Wait to print out the message until it is really that student’s turn.

QuestionDone(). The student is satisfied with the answer to his most recent question. Print …

Student x is satisfied.

Since professor considers it rude for a student not to wait for an answer, QuestionDone() should

not print anything until the professor has finished answering the question.

A student can ask only one question each time. i.e., a student should not expect to ask all his/her

questions in a contiguous batch. In other words, once a student gets the answer to one of his/her

questions, he/she may have to wait for the next turn if another student starts to ask a question

before he/she does.

In the above list, x is a placeholder for the student identifier.

Your program must accept one command line parameter that represents the total number of

students coming to the professor’s office, and a second command line parameter that represents

the capacity of the professor’s office (i.e., how many students can be in the office at the same

time). For simplicity, you can assume that the Student threads are created at the ascending

of their identifiers.

Your program must validate the command line parameters to make sure that they are numeric

values.

Your program must be able to run properly with any reasonable number of students (e.g., 200)

and room capacity (e.g., 8, 20, 50).

Your program must show randomness of events. For example, groups of students entering

office at various points in the simulation.

Your program must reach a completion state and terminate gracefully. A proper message

should be output to indicate end of simulation,

One acceptable output of your program is (assuming 3 students and a room capacity of 2):

Step 2: Use an LKM (loadable kernel module) To Get Process Information

In this step, you will write an LKM for the Linux kernel that displays the following details for the

Step 1’s process. You need to know how to install, remove and test the LKM. You also need to

find the related build in system files which are related to process and thread. Then use them to get

the process information.

The information includes:

(i) Process Name

(ii) Process ID

(iii) Parent Process ID

(iv) Number of Threads

Step 3: The Required Deliverable Materials

(1) A README file, which describes how we can compile and run your code.

(2) Your source code, must include a Makefile.

(3) Your report, which discusses the output of your program with the output screenshots.

3. Submission Requirements

You need to strictly follow the instructions listed below:

1) Submit a .zip file that contains all files. (source code files, MakeFile, README, report)

2) Do not submit your compiled binary code. We will compile and test your code.

3) Your code must be able to compile; otherwise, you will receive a grade of zero.

4) Your code should not produce anything else other than the required information in the output.

5) Your code must validate command line parameters to make sure the meaningful inputs.

6) If you code is partially completed, also explain in the report what has been completed and the

status of the missing parts.

7) Provide sufficient comments in your code to help the TA understand your code. This is

important for you to get at least partial credit in case your submitted code does not work properly.

4. Policies

1) Late submissions will be graded based on our policy discussed in the course syllabus.

2) Code-level discussion is prohibited. We will use anti-plagiarism tools to detect violations of

this policy.

5. Resources

The Pthreads tutorials at https://computing.llnl.gov/tutorials/pthreads and

http://pages.cs.wisc.edu/~travitch/pthreads_primer.html are good references to learn Pthreads

programming.

LKM online manual: http://tldp.org/HOWTO/Module-HOWTO/

6. References

[1] POSIX Threads Programming: https://computing.llnl.gov/tutorials/pthreads/

[2] Pthreads Primer: http://pages.cs.wisc.edu/~travitch/pthreads_primer.html

[3] POSIX thread (pthread) libraries:

http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html