An introduction to the C++ programming language for game engine development.

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. }