CSE-381留学生程序讲解、C++语言编程调试、C/C++程序讲解

日期：2020-11-09 09:41

DUE Before: Before the end of your lab session
Page 1 of 5
CSE-381: Systems 2
Exercise #12
Max Points: 40
Objective: The objective of this exercise is to:
? Practice for Exam #2
? Self-assess your preparedness on concepts and programming skills for Exam #2
? Build self-confidence and skills for technical part of job interviews
Submission: This exercise consists must be submitted separately:
? Programming part – submit via the Canvas CODE plug-in.
Have an exam like setting for yourself in this exercise. Only when you are really stuck, seek
help from your instructor or TA.
When working on these programming problems try to stick to information
included in CommonMethodsAndCommands.pdf on Canvas. This will help
you prepare for the exam and importantly for interviews.
Quick review
Estimated time to complete: < 15 minutes
It would be helpful for you to review the following video that
summarizes key threading concepts in this exercise and Exam #2:
https://youtu.be/kOP2wr7XSiE. Please watch this video at 1.5′ or 2′
speed.
Setup
Estimated time to complete: < 5 minutes
1. Via NetBeans, on the Linux server os1.csi.miamioh.edu, create a Miami
University C++ Project named exercise12.
2. Download the supplied files and scp them to your NetBeans project folder on the server.
Of course, you can scp all of the files in one shot as shown below –
scp main.cpp exercise12.cpp os1.csi.miamioh.edu:NetBeansProject/exercise12
3. Add source files to your NetBeans project.
4. Note: You should not be modifying main.cpp (or submitting main.cpp)
DUE Before: Before the end of your lab session
Page 2 of 5
Testing
You can test your solution for each one of the questions by setting the following command-line
arguments in NetBeans as shown below:
In the command-line arguments above, change q1, to q2, q3 or q4 for testing the other
questions.
Q1: Coordinating threads (sleep-wake up)
Estimated time to complete: 15 minutes
The threadMain method is called on many threads, with id (i.e., 0, 1, 2, …) indicating the
logical number of the thread. The method has been implemented to print data in order of id
value, as shown in the adjacent sample output. Rewrite the method to use a sleep-wakeup approach
(instead of the busy-wait) by modifying
the starter code below. [10 points]



// Assume all necessary headers are included.
using namespace std;
// Add global variables as needed.

void printInOrder(const int id, const std::string data) {
// Of course, you should be typing the solution in
// exercise1.cpp. Testing it to ensure it works correctly.
// Of course, you can always upload your complete/partial
// solutions to the CODE plug-in for extra testing.
}
id 0: data 0
id 1: data 1
id 2: data 2
…
void printInOrder (int id, std::string data) {
static std::atomic turn;
// Wait for my turn
while (turn != id) {}
std::cout << "id " << id
<< ": " << data << std::endl;
turn++; // Next thread's turn
}
Expected output:
$ ./exercise12 q1 3
id 0: q1: 0
id 1: q1: 1
id 2: q1: 2
id 0: data 0
id 1: data 1
id 2: data 2
…
In a 300-level course full points are reserved for concise/precise solutions.
DUE Before: Before the end of your lab session
Page 3 of 5
Q2: Working with unordered_map
Estimated time to complete: 20 minutes
The following method printMTprocs is given a map of
thread-ids or TID (key in the map) and the corresponding
process-id or PID (value in the map). The method must
suitably process the given tidPid map and print all
processes with at least n (i.e., >= n) threads. For example,
given the adjacent map and n==2, the printMTprocs
method should generate the adjacent example output. Note:
This method does not require multithreading. [10 points]
// Assume all necessary headers are included.
using namespace std;
// Add global variables as needed
using IntIntMap = std::unordered_map;
// Add global variables or
// helper methods as needed.
void printMTprocs(const IntIntMap& tidPid, const int n) {
// Implement this method
}
TID PID Expected output
2375 15 (order may vary):
375 5474
$ ./exercise12 q2 0
7936
15
$ ./exercise12 q2 50
15
27
38
3348 7936
3347 7936
3354 7936
2240 15
…
In a 300-level course full points are reserved for concise/precise solutions.
DUE Before: Before the end of your lab session
Page 4 of 5
Q3: Working with std::async
Estimated time to complete: 20 minutes
The following isGoodVaccine method uses 3 different algorithms (that do not use any shared
data) to detect if a vaccine is a match for the novel COVID-19 virus. Currently, it is running very
slowly. Suitably accelerate the isGoodVaccine method by programming it to use
multithreading (hint: async). [10 points]
// Assume all the necessary headers are included
using namespace std;
// Add global variables as needed
// Prototype declaration for the 3 complex algorithms
bool isSameEpitope(const std::string& strain);
bool isSimilarSeq(const std::string& strain);
bool isEquProtien(const std::string& strain);
// Multithread the following method
// to make it run faster
bool isGoodVaccine(const std::string& virus) {
return isSameEpitope(virus) || isSimilarSeq(virus) ||
isEquProtien(virus);
}
Expected outputs:
$ ./exercise12 q3 10
isGoodVaccine = true
$ ./exercise12 q3 11
isGoodVaccine = false
bool isGoodVaccine(const std::string& virus) {
// return isSameEpitope(virus) || isSimilarSeq(virus) ||
// isEquProtien(virus);
}
In a 300-level course full points are reserved for concise/precise solutions.
DUE Before: Before the end of your lab session
Page 5 of 5
Q4: Data parallel multithreading via reduction
Estimated time to complete: 20 minutes
Convert the adjacent sum method to run as a data
parallel multithreaded program using k threads. [10
points]
// Assume all necessary headers are included.
using namespace std;
using IntVec = std::vector;
// Add global variables or
// helper methods as needed.
int sum(const IntVec& nums, int k) {

// Implement this method to run as a data parallel multithreaded
// program using k threads.
}
Submit to Canvas
Estimated time to complete: 5 minutes
This exercise must be turned-in electronically via Canvas CODE plug-in. Ensure your program
compiles (without any warnings or style errors) successfully. Ensure you have tested operations of
your program as indicated. Once you have tested your implementation, upload the following onto
Canvas:
? The 1 C++ source file exercise12.cpp you modified for this exercise.
Ensure you actually complete the submission by clicking the button on Canvas
CODE plug-in.
using IntVec = std::vector;
int sum(const IntVec& nums, int k) {
sum = 0;
for(auto i : nums) {
sum += i;
}
return sum;
}
Expected output:
$ ./exercise12 q4 5
sum = 112492500
$ ./exercise12 q4 10
sum = 449985000
In a 300-level course full points are reserved for concise/precise solutions.