Description
In this homework, you are asked to write a multithreaded C++ program that reads numbers from a
file and adds them up concurrently using threads. The program starts after taking some inputs from the
keyboard and continues until all the numbers are added. In your program, you are going to display
some verbose output about addition operations and threads. Please see “Details of the Program”
section for details.
Using Threads
There will be five threads (other than main thread) in your program. All of them will wait their turn
and add the next value. You must ensure that at a given time only one thread will make an addition
operation to prevent race conditions and obtain a correct result in the end. For this, you are required to
use mutexes. In the end, your threads must be joined properly, and your program must terminate
without any complications.
Details of the Program
Before the summation begins, three inputs are entered via keyboard. First, the file name which
contains the numbers to be added, is entered. Then, the minimum and maximum waiting time before
each addition operation for a thread are entered in seconds (two inputs).
After the inputs are entered, your program will read the numbers from the given file name and store
them in a dynamic array. Each line in the file contains only one number. The first line contains the
amount of numbers in the file; you can use this information, which is the size of the array, when
creating your dynamic array. The remaining lines contain numbers to be added.
You may assume that all inputs are correct, including the file structure, so no input checks are
necessary. That means you can assume that the entered file name exists, it has a correct structure, the
min and max waiting times are entered as positive integer values and the first one is less than or equal
to the second one.
In the next step, you can create and start the five threads. The entry point of each of the threads will be
the same function. That means, you will NOT write separate functions for the threads.
At the beginning of the summation, display a message that says that the summation has started and the
time of start (see “Sample Runs” for examples).
For each thread, before each addition operation, the thread must wait a random amount of time (in
seconds). Then a thread will try to enter the critical area marked by a mutex. If it succeeds to get the
lock of the mutex, it will make the next addition operation and store its result in the shared sum. Then
it will increment the shared index count and will exit the critical region. The total number of addition
operation that a particular thread will make is not fixed; it depends on the total number of elements to
be added, random waiting times of the threads and the scheduling of the threads. You have to
implement the entry point function for the threads (remember, there will be only one thread function)
in such a way that in the critical region the next value will be added to the sum. To do so, you have to
keep a shared sum, as well as a shared index counter to track down the element to be added next.
These shared sum and index count could be made as global.
The random waiting times before the addition operation are determined via a function that returns a
random integer between (and including) a minimum and maximum values passed as parameters to the
thread function from main. Do not use the RandGen class from CS201 for random integer
generation in multithreaded applications because it is not thread-safe. Instead, you must use the
following thread-safe function, random_range, for generating random waiting times inside the
threads. This function returns a random number between (and including) min and max parameters. In
the threads, you can call it by passing minimum and maximum waiting times of the corresponding
thread as arguments.
#include
#include
int random_range(const int & min, const int & max) {
static mt19937 generator(time(0));
uniform_int_distribution distribution(min, max);
return distribution(generator);
}
To pause a thread for a certain amount of time, you should use the
this_thread::sleep_for(chrono::seconds(time_in_seconds)) command; you need to
include the thread and chrono libraries in your program for this to work. In order to get the current
time and to display it, we have seen some codes in class; you may use them.
The thread function and consequently the program will end after all of the numbers are added
and the summation result is obtained. At the end of your program, do not forget to join five threads
properly. Moreover, display a message to specify that the summation has ended including the result
and the ending time.
Use of global variables
You may use global variables in this homework. Actually, it would be miserable not to use them in a
program that has several threads. However, we kindly request you not to exaggerate the global usage
since after a certain point you may lose control over your program (as the famous Turkish proverb says
“azı karar, coğu zarar”).
Sample Runs
Some sample runs are given below, but these are not comprehensive, therefore you have to consider all
cases, to get full mark.
Due to the probabilistic nature of the homework and due to the scheduling of threads, same inputs may
yield different outputs for your code. However, the order of the events must be consistent with the
homework requirements and the given inputs.
Sample input files are given together with homework document in the zip file.
The inputs from the keyboard are written in boldface and italic.
Sample Run 1:
Please enter the file name.
input1.txt
Please enter the wait range of threads.
1 3
Starting reading the array at 17:54:52
Array stored in the memory. Starting the summation at 17:54:52
Thread 2 added number index 0 to the total sum at 17:54:53
Current sum: 3
Thread 5 added number index 1 to the total sum at 17:54:53
Current sum: 8
Thread 1 added number index 2 to the total sum at 17:54:54
Current sum: 14
Thread 3 added number index 3 to the total sum at 17:54:54
Current sum: 18
Thread 2 added number index 4 to the total sum at 17:54:54
Current sum: 21
Thread 4 added number index 5 to the total sum at 17:54:55
Current sum: 29
Thread 1 added number index 6 to the total sum at 17:54:55
Current sum: 38
Thread 5 added number index 7 to the total sum at 17:54:56
Current sum: 137
Thread 1 added number index 8 to the total sum at 17:54:56
Current sum: 143
Thread 3 added number index 9 to the total sum at 17:54:57
Current sum: 150
Adding finished at 17:54:59
Sum: 150
Sample Run 2:
Please enter the file name.
input1.txt
Please enter the wait range of threads.
2 2
Starting reading the array at 18:02:31
Array stored in the memory. Starting the summation at 18:02:31
Thread 1 added number index 0 to the total sum at 18:02:33
Current sum: 3
Thread 2 added number index 1 to the total sum at 18:02:33
Current sum: 8
Thread 3 added number index 2 to the total sum at 18:02:33
Current sum: 14
Thread 4 added number index 3 to the total sum at 18:02:33
Current sum: 18
Thread 5 added number index 4 to the total sum at 18:02:33
Current sum: 21
Thread 1 added number index 5 to the total sum at 18:02:35
Current sum: 29
Thread 2 added number index 6 to the total sum at 18:02:35
Current sum: 38
Thread 3 added number index 7 to the total sum at 18:02:35
Current sum: 137
Thread 4 added number index 8 to the total sum at 18:02:35
Current sum: 143
Thread 5 added number index 9 to the total sum at 18:02:35
Current sum: 150
Adding finished at 18:02:37
Sum: 150
Sample Run 3:
Please enter the file name.
input1.txt
Please enter the wait range of threads.
3 8
Starting reading the array at 18:00:55
Array stored in the memory. Starting the summation at 18:00:55
Thread 5 added number index 0 to the total sum at 18:01:00
Current sum: 3
Thread 1 added number index 1 to the total sum at 18:01:01
Current sum: 8
Thread 3 added number index 2 to the total sum at 18:01:01
Current sum: 14
Thread 2 added number index 3 to the total sum at 18:01:02
Current sum: 18
Thread 4 added number index 4 to the total sum at 18:01:03
Current sum: 21
Thread 5 added number index 5 to the total sum at 18:01:03
Current sum: 29
Thread 2 added number index 6 to the total sum at 18:01:06
Current sum: 38
Thread 4 added number index 7 to the total sum at 18:01:06
Current sum: 137
Thread 5 added number index 8 to the total sum at 18:01:06
Current sum: 143
Thread 1 added number index 9 to the total sum at 18:01:08
Current sum: 150
Adding finished at 18:01:14
Sum: 150
Sample Run 4:
Please enter the file name.
input2.txt
Please enter the wait range of threads.
1 9
Starting reading the array at 18:05:59
Array stored in the memory. Starting the summation at 18:05:59
Thread 2 added number index 0 to the total sum at 18:06:00
Current sum: -4
Thread 3 added number index 1 to the total sum at 18:06:01
Current sum: -11
Thread 4 added number index 2 to the total sum at 18:06:02
Current sum: -12
Thread 5 added number index 3 to the total sum at 18:06:06
Current sum: -2
Thread 2 added number index 4 to the total sum at 18:06:06
Current sum: -10
Thread 3 added number index 5 to the total sum at 18:06:06
Current sum: -12
Thread 5 added number index 6 to the total sum at 18:06:07
Current sum: -7
Adding finished at 18:06:13
Sum: -7
Sample Run 5:
Please enter the file name.
input2.txt
Please enter the wait range of threads.
1 1
Starting reading the array at 18:07:38
Array stored in the memory. Starting the summation at 18:07:38
Thread 1 added number index 0 to the total sum at 18:07:39
Current sum: -4
Thread 2 added number index 1 to the total sum at 18:07:39
Current sum: -11
Thread 3 added number index 2 to the total sum at 18:07:39
Current sum: -12
Thread 4 added number index 3 to the total sum at 18:07:39
Current sum: -2
Thread 5 added number index 4 to the total sum at 18:07:39
Current sum: -10
Thread 1 added number index 5 to the total sum at 18:07:40
Current sum: -12
Thread 2 added number index 6 to the total sum at 18:07:40
Current sum: -7
Adding finished at 18:07:41
Sum: -7
Sample Run 6:
Please enter the file name.
input2.txt
Please enter the wait range of threads.
1 2
Starting reading the array at 18:04:59
Array stored in the memory. Starting the summation at 18:04:59
Thread 2 added number index 0 to the total sum at 18:05:00
Current sum: -4
Thread 4 added number index 1 to the total sum at 18:05:00
Current sum: -11
Thread 1 added number index 2 to the total sum at 18:05:01
Current sum: -12
Thread 3 added number index 3 to the total sum at 18:05:01
Current sum: -2
Thread 5 added number index 4 to the total sum at 18:05:01
Current sum: -10
Thread 2 added number index 5 to the total sum at 18:05:01
Current sum: -12
Thread 1 added number index 6 to the total sum at 18:05:02
Current sum: -7
Adding finished at 18:05:03
Sum: -7
Please see the previous homework specifications for the other important rules and
the submission guidelines
Last, but not the least, you have to use Windows for this homework. In
multithreaded applications, there are several dependencies to the underlying
operating system. Thus the behavior that you see while running in a Windows
computer could be totally different than MacOS. For this reason, you have to use a
Windows computer for this homework. In the previous homework assignments, we
kind of tolerated Mac vs. Windows compatibility issues after grading; but in this
homework we will not do so. Your code will be tested in Windows and if it does not
work, even if it works using Mac, you will not be able to object.
Good Luck!