Calling Functions A Tutorial Klaus Iglberger, CppCon 2020 klaus.iglberger@gmx.de2 Klaus Iglberger C++ Trainer since 2016 Author of the C++ math library (Co-)Organizer of the Munich Two-Phase Lookup Template Argument Deduction SFINAE Overload Resolution (Viable) Candidate Functions Ranking Ambiguous Function Calls Access Labels Function Template Specializations Virtual Two-Phase Lookup Template Argument Deduction SFINAE Overload Resolution (Viable) Candidate Functions Ranking Ambiguous Function Calls Access Labels Function Template Specializations Virtual

for many years -- please provide suggestions, analogies, and other useful ways to think about functions now or in the future!Please do not redistribute slides without prior permission. 4Your Tour Guide for the talk ● Located here: https://github.com/MikeShah/Talks/tree/main/2023/cppcon/functions 6Abstract Functions are one of the first things programmers learn, granting you the ultimate power to 'reuse' overview of functions from the start to the end, on the various powers that are given to us from the ground up. Consider this talk your one stop for learning all of the great things about functions! We'll

From Functions to Coroutines 40 Years Evolution Rainer Grimm Training, Coaching, and Technology Consulting www.ModernesCpp.netEvolution of Callable template T invoke(Func sequence of functions can be changed ▪ Automatically parallelizable ▪ Results can be cachedPure Functions Working with a pure function is based on discipline Use common functions, meta-functions, constexpr constexpr, or consteval functions ▪ Function int powFunc(int m, int n){ if (n == 0) return 1; return m * powFunc(m, n - 1); } ▪ Meta-Function template struct PowMeta { static int const value

virt_duration = end-start;There are interesting technical details and surprising conclusions that virtual functions can be actually faster. Since CPU architectures are mentioned, I'd expect to see deep assembly eritance-vs-other- ways-performanceDoes it even matter?Conclusions ● The notion that “virtual functions are slower” is flat out wrong. ○ Which is not to say they are faster ○ Some of the suggested

… … Stack Traces for Async Code are Unhelpful Threadpool threads: #0 process_file(...) #5 pool.run() #10 __clone … … IO Thread: #0 async_read_some_at(...) #3 ctx Threadpool threads: #0 process_file(...) #5 pool.run() #10 … IO Thread: … #0 async_read_some_at(...) #3 ctx.run() #5 __clone … … Main thread: #0 unifex::sync_wait( … #0 async_read_some_at(...) … #12 unifex::sync_wait(...) #16 main() #19 __libc_start_main() … … Async Stacks are BetterStructured Concurrency Makes Async Stacks Possible

Helmut Hlavacs – Combining Co-Routines and Functions into a Job System - CppCon 2021 1 / 39Helmut Hlavacs – Combining Co-Routines and Functions into a Job System - CppCon 2021 2 / 39 About Myself • Professor Processing) Technical Committee 14 Entertainment ComputingHelmut Hlavacs – Combining Co-Routines and Functions into a Job System - CppCon 2021 3 / 39 Creating Game Engines with C++ • Vienna Game Job System Vulkan Game Engine 2.0 https://github.com/hlavacs 20Helmut Hlavacs – Combining Co-Routines and Functions into a Job System - CppCon 2021 4 / 39 The Game Loop auto prev = high_resolution_clock::now();

Task18/55 Threads - A straightforward solution std::future spawn_task () { return std:: async( outer_function ); }18/55 Threads - A straightforward solution main() spawn task()18/55 Threads multiple functions, we need to suspend them all one by one23/55 C++20 Coroutines Stackless We can only suspend one function at a time If we want to suspend a computation spanning multiple functions, we auto data = co_await async_io (...); co_return IoResult :: from_io_data(data ); }24/55 Suspending nested coroutines Async inner_function () { auto data = co_await async_io (...); co_return

2. Tell Ben the count one digit at a time. 3. When done, yell "End of Line" Exercise 7async/concurrency 8async/concurrency GPIO Timer 1 Timer 2 I2C DMA Half-Duplex Serial core 9Sender World Sender Factories Functions that return senders. auto sndr = async::just(42, 17); 1 18just just_result_of just_error just_error_result_of just_stopped Sender Factories Functions that return senders auto sndr = async::just_result_of( [] { return 42; }, [] { do_something(); }, [] { return 17; }); 1 2 3 4 19schedule Sender Factories Functions that return

One-DNN OneDPC SYCL-BLAS SYCL-Eigen SYCL-DNN SYCL Parallel STL ... C++ templates and lambda functions separate host & accelerated device code Accelerated code passed into device OpenCL compilers std::vector dA{ … }, dB{ … }, dO{ … }; try { sycl::queue gpuQueue{sycl::gpu_selector_v, async_handler{}}; sycl::buffer bufA{dA.data(), sycl::range{dA.size()}}; sycl::buffer bufB{dB std::vector dA{ … }, dB{ … }, dO{ … }; try { sycl::queue gpuQueue{sycl::gpu_selector_v, async_handler{}}; sycl::buffer bufA{dA.data(), sycl::range{dA.size()}}; sycl::buffer bufB{dB

demonstrated to justify switchingCallbacks vs coroutines // read length auto len = make_unique(); async_read(socket, buffer(len.get(), sizeof(int32_t)), [len = move(len)](auto ec, size_t len1){ && len1 == sizeof(int32_t)) { // read data auto buf = make_unique(*len); async_read(socket, buffer(buf.get(), *len), [buf = move(buf), len = *len] (auto read length int32_t len; co_await async_read(s, buffer(&len, sizeof(len)), use_awaitable); // read data auto buf = make_unique(len); co_await async_read(s, buffer(buf.get(), len)