The document discusses parallel programming concepts in C++ including threads, synchronization using mutexes, condition variables for producer-consumer problems, and futures/promises for asynchronous function calls. It provides examples of spawning threads to execute functions concurrently, protecting shared data with mutexes, notifying condition variables to signal events, and getting values from futures after asynchronous tasks have completed.

2.  Concurrency
 Thread
 Synchronization

3.  Thread
 Mutex
 Look
 Packaged tasks
 Future , Promise

4. 01. void f(); // function
02.
03. struct F { // function object
04. void operator()(); // F's call operator (§3.4.3)
05. };
06.
07. void user()
08. {
09. thread t1 {f}; // f() executes in separate thread
10. thread t2 {F()}; // F()() executes in separate thread
11. t1.join(); // wait for t1
12. t2.join(); // wait for t2
13. }

5. 01. void f() { cout << "Hello "; }
02.
03. struct F {
04. void operator()() { cout << "Parallel World!n"; }
05. };
PaHerallllel o World!

6. 01. void f(vector<double>& v); // function do something with v
02. struct F { // function object: do something with v
03. vector<double>& v;
04. F(vector<double>& vv) :v{vv} { }
05. void operator()(); // application operator; §3.4.3
06. };
07.
08. int main()
09. {
10. vector<double> some_vec {1,2,3,4,5,6,7,8,9};
11. vector<double> vec2 {10,11,12,13,14};
12. thread t1 {f,some_vec}; // f(some_vec) execs in a separate thread
13. thread t2 {F{vec2}}; // F(vec2)() executes in a separate thread
14. t1.join();
15. t2.join();
16. }

7. 01. void f(const vector<double>& v, double* res);
02. class F {
03. public:
04. F(const vector<double>& vv, double* p) : v{vv}, res{p} { }
05. void operator()(); // place result in *res
06. private:
07. const vector<double>& v; // source of input
08. double* res; // target for output
09. };
10.
11. int main()
12. {
13. vector<double> some_vec;
14. vector<double> vec2;
15. double res1, res2;
16. thread t1 {f,some_vec,&res1};
17. thread t2 {F{vec2,&res2}};
18. t1.join();
19. t2.join();
20. cout << res1 << ' ' << res2 << 'n';
21. }

8. 01. mutex m; // controlling mutex
02. int sh; // shared data
03.
04. void f()
05. {
06. unique_lock<mutex> lck {m}; // acquire mutex
07. sh += 7; // manipulate shared data
08. } // release mutex implicitly

9. 01. void f()
02. {
03. // ...
04. // defer_lock: don't yet try to acquire the mutex
05. unique_lock<mutex> lck1 {m1,defer_lock};
06. unique_lock<mutex> lck2 {m2,defer_lock};
07. unique_lock<mutex> lck3 {m3,defer_lock};
08. // ...
09. lock(lck1,lck2,lck3); // acquire all three locks
10. // ... manipulate shared data ...
11. } // implicitly release all mutexes
T 1
M 1
M 2
T 2

10. 01. using namespace std::chrono; // see §35.2
02.
03. auto t0 = high_resolution_clock::now();
04. this_thread::sleep_for(milliseconds{20});
05. auto t1 = high_resolution_clock::now();
06. cout << duration_cast<nanoseconds>(t1–t0).count()
07. << " nanoseconds passedn";

11. 01. class Message { // object to be communicated
02. // ...
03. };
04.
05. queue<Message> mqueue; // the queue of messages
06. condition_variable mcond; // the variable communicating events
07. mutex mmutex; // the locking mechanism
01. void consumer()
02. {
03. while(true) {
04. unique_lock<mutex> lck{mmutex}; // acquire mmutex
05. while (mcond.wait(lck)) /* do nothing */; // release lck and wait;
06. // re-acquire lck upon wakeup
07. auto m = mqueue.front(); // get the message
08. mqueue.pop();
09. lck.unlock(); // release lck
10. // ... process m ...
11. }
12. }

12. 01. void producer()
02. {
03. while(true) {
04. Message m;
05. // ... fill the message ...
06. unique_lock<mutex> lck {mmutex}; // protect operations
07. mqueue.push(m);
08. mcond.notify_one(); // notify
09. } // release lock (at end of scope)
10. }

13.  future ‫و‬ promise
 packaged_task
 async()

14. 01. X v = fx.get(); // if necessary, wait for the value to get computed
02.
03. void f(promise<X>& px) // a task: place the result in px
04. {
05. // ...
06. try {
07. X res;
08. // ... compute a value for res ...
09. px.set_value(res);
10. }
11. catch (...) { // oops: couldn't compute res
12. // pass the exception to the future's thread:
13. px.set_exception(current_exception());
14. }
15. }

15. 01. void g(future<X>& fx) // a task: get the result from fx
02. {
03. // ...
04. try {
05. X v = fx.get(); // if necessary, wait for the value to get computed
06. // ... use v ...
07. }
08. catch (...) { // oops: someone couldn't compute v
09. // ... handle error ...
10. }
11. }

16. 01. double comp2(vector<double>& v)
02. {
03. // type of task
04. using Task_type = double(double*,double*,double);
05. // package the task (i.e., accum)
06. packaged_task<Task_type> pt0 {accum};
07. packaged_task<Task_type> pt1 {accum};
08. // get hold of pt0's future
09. future<double> f0 {pt0.get_future()};
10. // get hold of pt1's future
11. future<double> f1 {pt1.get_future()};
12. double* first = &v[0];
13. // start a thread for pt0
14. thread t1 {move(pt0),first,first+v.size()/2,0};
15. // start a thread for pt1
16. thread t2 {move(pt1),first+v.size()/2,first+v.size(),0};
17. // ...
18. return f0.get()+f1.get(); // get the results
19. }

17. 01. double comp4(vector<double>& v)
02. // spawn many tasks if v is large enough
03. {
04. if (v.size()<10000) return accum(v.begin(),v.end(),0.0);
05. auto v0 = &v[0];
06. auto sz = v.size();
07. auto f0 = async(accum,v0,v0+sz/4,0.0); // first quarter
08. auto f1 = async(accum,v0+sz/4,v0+sz/2,0.0); // second quarter
09. auto f2 = async(accum,v0+sz/2,v0+sz*3/4,0.0); // third quarter
10. auto f3 = async(accum,v0+sz*3/4,v0+sz,0.0); // fourth quarter
11. // collect and combine the results
12. return f0.get()+f1.get()+f2.get()+f3.get();
13. }