Parallelism and Concurrency in C++17 and C++20. Rainer Grimm Training, Coaching and, Technology Consulting

Transcription

1 Parallelism and Concurrency in C++17 and C++20 Rainer Grimm Training, Coaching and, Technology Consulting

2 Multithreading and Parallelism in C++

3 Multithreading in C++17

4 Parallel STL The execution policy of the STL algorithm can be chosen. Execution policy std::execution::seq Sequential execution on calling thread std::execution::par Parallel std::execution::par_unseq Parallel and vectorized Performed on multiple data at the same time SIMD

5 Parallel STL using namespace std; vector<int> vec ={1, 2, 3, 4, 5... } // static decision sort(vec.begin(), vec.end()); // sequential as ever sort(execution::seq, vec.begin(), vec.end()); // sequential sort(execution::par, vec.begin(), vec.end()); // parallel sort(execution::par_unseq, vec.begin(), vec.end()); // par + vec // dynamic decision size_t threshold=... execution_policy exec = execution::seq; if(vec.size() > threshold) exec = execution::par; sort(exec, vec.begin(), vec.end());

6 Parallel STL adjacent_difference, adjacent_find, all_of any_of, copy, copy_if, copy_n, count, count_if, equal, exclusive_scan, fill, fill_n, find, find_end, find_first_of, find_if, find_if_not, for_each, for_each_n, generate, generate_n, includes, inclusive_scan, inner_product, inplace_merge, is_heap, is_heap_until, is_partitioned, is_sorted, is_sorted_until, lexicographical_compare, max_element, merge, min_element, minmax_element, mismatch, move, none_of, nth_element, partial_sort, partial_sort_copy, partition, partition_copy, reduce, remove, remove_copy, remove_copy_if, remove_if, replace, replace_copy, replace_copy_if, replace_if, reverse, reverse_copy, rotate, rotate_copy, search, search_n, set_difference, set_intersection, set_symmetric_difference, set_union, sort, stable_partition, stable_sort, swap_ranges, transform, transform_exclusive_scan, transform_inclusive_scan, transform_reduce, uninitialized_copy, uninitialized_copy_n, uninitialized_fill, uninitialized_fill_n, unique, unique_copy

7 Parallel STL std::parallel::transform_reduce Haskells map function is called std::transform in C++ parallel::transform_reduce parallel::map_reduce

8 Multithreading in C++20

9 Atomic Smart Pointers C++11 has a std::shared_ptr: Shared ownership std::weak_ptr: Breaks cyclic references Issues: The control block and the deletion of the resource is thread-safe, but not the resource. C++11 has atomic operations for std::shared_ptr. New atomic data types: std::atomic_shared_ptr std::atomic_weak_ptr

10 std::future extensions std::future support no function composition. std::future Improvements Continuation then: Execute the second future, if the first one is done. future<int> f1= async([]() {return 123;}); future<string> f2 = f1.then([](future<int> f) { return f.get().to_string(); // non-blocking }); auto myresult= f2.get(); // blocking

11 std::future extensions when_all: Execute the future when all of the futures are done. future<int> futures[] = { async([]() { return intresult(125); }), async([]() { return intresult(456); })}; future<vector<future<int>>> all_f = when_all(begin(futures), end(futures)); vector<future<int>> myresult= all_f.get(); for (auto fut: myresult): fut.get(); when_any: Execute the future when any of the futures is done. future<int> futures[] = {async([]() { return intresult(125); }), async([]() { return intresult(456); })}; when_any_result<vector<future<int>>> any_f = when_any(begin(futures), end(futures)); future<int>& myresult= any_f.futures[any_f.index]; auto myresult= myresult.get();

12 Latches and Barriers C++ has no semaphores. Latches and barriers Concepts A thread waits eventually at a synchronization point until the counter is 0. latch is a single-use barrier count_down_and_wait: Decrements the counter and block until 0 count_down: Decrements the counter is_ready: Checks the counter wait: Waits until the counter is 0

13 Latches and Barriers barrier is a reusable barrier arrive_and_wait: Waits at the synchronization point. arrive_and_drop: Removes itself from the synchronization set. flex_barrier is a reusable and flexible barrier The constructor can get a callable. The callable will be executed in the completion phase. The callable must return a value which specifies the counter for the next iteration. It's the only barrier that can increase the counter.

14 Latches and Barriers void dowork(threadpool* pool) { latch completion_latch(number_tasks); for (int i = 0; i < NUMBER_TASKS; ++i) { pool->add_task([&] { // perform the work... completion_latch.count_down(); })); } // block until all tasks are done completion_latch.wait(); }

15 Coroutines Coroutines are generalized functions that can suspend and resume execution while keeping their state. Programming concept for Cooperative task Event loops Iterators Infinite lists Pipes

16 Coroutines Design Principles (James McNellis) Scalable, to billions of concurrent coroutines Efficient: Suspend/resume operations comparable in cost to function call overhead Open-Ended: Library designers can develop coroutines libraries Seamless Interaction with existing facilities with no overhead. Usable in environments where exceptions are forbidden or not available.

17 Coroutines: Generators generator<int> generatorfornumbers(int begin, int inc= 1){ for (int i= begin;; i += inc){ co_yield i; } } int main(){ auto numbers= generatorfornumbers(-10); for (int i= 1; i <= 20; ++i) std::cout << numbers << " "; for (auto n: getfornumbers(0,5)) std::cout << n << " "; }

18 Coroutines: Waiting instead of Blocking Blocking Waiting Acceptor accept{443}; Acceptor accept{443}; while (true){ Socket so= accept.accept(); // block auto req= so.read(); // block auto resp= handlerequest(req); so.write(resp); // block } while (true){ Socket soc= co_await accept.accept(); auto req= co_await so.read(); auto resp= handlerequest(req); co_await so.write(resp); }

19 Transactional Memory Transactional Memory is the transaction idea of databases applied to the software development. A transaction has the ACID property excluding Durability atomic{ statement1; statement2; statement3; } Atomicity: All or no statement will be executed. Consistency: The system is always in a consistent state. Isolation: A transaction runs in total isolation. Durability: The result of a committed transaction remains.

20 Transactional Memory Transactions Execute in a single total order Are protected (behave like a global lock) Use optimistic concurrency Locks Workflow Retry Rollback A transaction remembers its initial state. The transaction runs without synchronization. The system detects a conflict with the initial state. The transaction will be committed.

21 Transactional Memory Two forms Synchronized block: Relaxed transactions Are no transactions in the strict sense. Can call transaction-unsafe code Atomic blocks: Atomic transactions Are available in three forms. Can only call transaction-safe code

22 Transactional Memory: Synchronized blocks int i= 0; void inc() { synchronized{ cout << ++i << ","; } } vector<thread> vecsyn(10); for(auto& t: vecsyn) t= thread([]{ for(int n = 0; n < 10; ++n) inc(); });

23 Transactional Memory: Synchronized blocks void inc() { synchronized{ std::cout << ++i << ","; this_thead::sleep_for(1ns); } } vector<thread> vecsyn(10), vecunsyn(10); for(auto& t: vecsyn) t= thread[]{ for(int n = 0; n < 10; ++n) inc(); }); for(auto& t: vecunsyn) t= thread[]{ for(int n = 0; n < 10; ++n) cout << ++i << ","; });

24 Transactional Memory Atomic blocks atomic_<exception_specifier>{ // begin transaction... } // end transaction Exception occurs atomic_noexcept: std::abort is called. atomic_cancel: std::abort is called unless it was a transaction_safe exception. => Cancel the transaction, set the atomic block to is initial state and throw the exception. atomic_commit: Commit the transaction and throw the exception.

25 Transactional Memory: Atomic blocks int i= 0; void func() { atomic_noexcepts{ cout << ++i << ","; // non transaction-safe code } } The transaction can only executed transaction-safe code. Compile time error

26 Transactional memory: transaction_safe A function be be declared transaction_safe have a transaction_unsafe attribute. int transactionsafefunction() transaction_safe; [[transaction_unsafe]] int transactionunsafefunction(); transaction_safe is part of the type of the function.

27 Task Blocks Fork-join parallelism with task blocks.

28 Task Blocks template <typename Func> int traverse(node& n, Func && f){ int left = 0, right = 0; define_task_block( [&](task_block& tb){ if (n.left) tb.run([&]{ left = traverse(*n.left, f); }); if (n.right) tb.run([&]{ right = traverse(*n.right, f); }); } ); return f(n) + left + right; } define_task_block Tasks can potentially run The end of task block joins the tasks run: Runs a task

29 Task Blocks define_task_block_restore_thread... define_task_block([&](auto& tb) tb.run([&]{[] func(); }); define_task_block_restore_thread([&](auto& tb){ tb.run([&]([]{ func2(); }); define_task_block([&](auto& tb){ tb.run([&]{ func3(); } }); }); }); wait define_task_block([&](auto& tb){ tb.run([&]{ process(x1, x2) }); if (x2 == x3) tb.wait(); process(x3, x4); });

30 Multithreading and Parallelism in C++

31 Further Information Modernes C++: Training, coaching, and technology consulting by Rainer Grimm Blog to modern C++ (German) (English)

32 Rainer Grimm Training, Coaching, and Technology Consulting