Get off my thread: Techniques for moving work to background threads Anthony Williams Just Software Solutions Ltd https://www.justsoftwaresolutions.co.uk September 2020Get off my thread: Techniques for current thread? How do we move work off the current thread? Final Guidelines and QuestionsWhy do we need to move work off the current thread?Why do we need to move work off the current thread? Many environments environments have a dedicated thread for processing events: GUIs Client-Server applications Performing extensive processing on the event thread prevents other events from being handled.Why do we need

Back to Basics: Concurrency STD::THREAD int main() { std::thread my_thread{[](int z){ std::cout << "Hello from thread: " << z << "\n"; }, 42}; my_thread.join(); } Hello, world! https://godbolt Calls to acquire() and release() can happen on different threads https://en.cppreference.com/w/cpp/thread/counting_semaphoreCppCon 2023 9 David Olsen - Back to Basics: Concurrency CONCURRENCY “Multiple Make sure your code is thread safe with no data races SummaryCppCon 2023 42 David Olsen - Back to Basics: Concurrency STD::THREAD https://en.cppreference.com/w/cpp/thread/threadCppCon 2023 43 David

programmers? In this talk we provide a gentle introduction to concurrency with the modern C++ std::thread library. We will introduce topics with pragmatic code examples introducing the ideas of threads fundamental building blocks to write for instance a multi-threaded program ○ We are going to focus on std::thread for creating concurrent programs. ■ We will review briefly other methods of writing concurrent programs fundamental building blocks to write for instance a multi-threaded program ○ We are going to focus on std::thread for creating concurrent programs. ■ We will review briefly other methods of writing concurrent programs

Terrible task selection “fairness” Task Thread Thread Thread Task Task Task Task Task Task Task Back Front Task Queue Execute Task() Thread Thread PoolRethinking: Task Queues Problem #2 - starvation, load balancing, work stealing Task Thread Thread Thread Task Task Task Task Task Task Task Back Front Task Queue Execute Task() Thread Thread PoolRethinking: Task Queues Problem #3 - prioritization, etc, as enumerated previously Task Thread Thread Thread Task Task Task Task Task Task Task Back Front Task Queue Execute Task() Thread Thread PoolRethinking: Task Queues Summary: ● Queues

use std::io; use rand::Rng; fn main() { println!("Guess the number!"); let secret_number = rand::thread_rng().gen_range(1, 101); println!("The secret number is: {}", secret_number) ; println!("Please lines in the middle. The rand:: thread_rng function will give us the particular random number gen- erator that we’re going to use: one that is local to the current thread of execution and seeded by the std::cmp::Ordering; use rand::Rng; fn main() { println!("Guess the number!"); let secret_number = rand::thread_rng().gen_range(1, 101); println!("The secret number is: {}", secret_number) ; println!("Please

multithreaded programs? 4 Thread A int x = 0; start_thread_b(); x = 1; Thread B while (x != 1) {} Will this loop ever terminate? Will this write ever become “visible” to Thread B?The compiler can rewrite unambiguously “yes.” No other thread is allowed to look at the variable x while this thread is modifying it; and without some kind of synchronization, there’s no way to ensure that this thread isn’t modifying it new thread In C++03 pthreads, you’d create a new thread by calling a third-party library function. In C++11, the standard library “owns” the notion of creating new threads. To create a thread, you

channel.Reader(); thread xfutures/promises: “buffered channel” Channel channel; Channel::Reader reader = channel.Reader(); reader.Read(); // Blocks! thread xfutures/promises: Reader(); reader.Read(); // Blocks! Channel::Writer writer = channel.Writer(); thread x thread yfutures/promises: “buffered channel” Channel channel; Channel::Reader Channel::Writer writer = channel.Writer(); writer.Write("..."); // Non-blocking! thread x thread yfutures/promises: “buffered channel” Channel channel; Channel::Reader

Each core : 1 thread of execution (MIMD) • Cores share main memory, can share caches • Simultaneous multithreading (x86 / x64) -> 2N virtual cores • Query number of cores: std::thread::hardware_concurrency() System - CppCon 2021 7 / 39 Job Systems and Thread Pools • Starting threads is expensive -> Thread Pool • Job System = Thread Pool + Job Queues • Main Thread calls parallel_for() • Put jobs into queue queue • Threads take jobs out of queue Main Thread P P P P parallel_for() Main Thread I/O or Render Thread (load / store data from disk) Blocking waitHelmut Hlavacs – Combining Co-Routines and

specific programming paradigm or concurrency library. A coroutine is effectively a light-weight thread that can be suspended and resumed later. Coroutines are supported through suspending functions: which is implemented in an external library, kotlinx.coroutines: // runs the code in the background thread pool fun asyncOverlay() = async(CommonPool) { // start two async operations val original suspended while the operation being awaited is executed, and is resumed (possibly on a different thread) when the operation being awaited completes. The standard library uses coroutines to support lazily

paradigm in C++. Modern C++ also adds a lot of tools and methods to its standard library such as std::thread at the level of the language itself, which supports concurrent programming and no longer depends 4) Target: x86_64-apple-darwin18.6.0 9 1.1 Deprecated Features CHAPTER 01: TOWARDS MODERN C++ Thread model: posix InstalledDir: /Library/Developer/CommandLineTools/usr/bin 1.1 Deprecated Features 7.1 Basic of Parallelism std::thread is used to create an execution thread instance, so it is the basis for all concurrent programming. It needs to include the <thread> header file when using it. It