Modern C++ Concurrency in Depth ( C++17/20)

  • Category Other
  • Type Tutorials
  • Language English
  • Total size 2.1 GB
  • Uploaded By tutsnode
  • Downloads 371
  • Last checked 6 days ago
  • Date uploaded 4 years ago
  • Seeders 12
  • Leechers 1

Infohash : F6DFDF554DEABB55B7E402DA8BCCDAB6804A29C5




Description

C++ programming language can be categorized under many topics. Some say its a general purpose programming language, some say its a object oriented version of C. But I liked to categorized it under system programming language. One characteristic of any system programming language including C++ is that language should be able to execute faster compare to other languages like java etc.

C++ paradigm took sharp turn with the introduction of C++11 standards. The most notable difference with previous version is the introduction of new memory model. Memory model is the key part of any language, and the performance of all the functionalities depends on that language memory model. With new c++ memory model, we can exploit tremendous power of modern multi core processors.

Programming a proper C++ code with better memory reclaim mechanism is tough task. But if we want to code thread safe code which can harvest underline processors true power is much more difficult task. In this course we will have in depth discussion on C++ concurrency features including memory model. We will implements thread safe data structures and algorithms, both lock based manner and lock free manner. Proper lock free implementations of data structures and algorithms will provide unprecedented performance output. Let me listed down key aspects we cover in this course below.

1.Basics of C++ concurrency(threads, mutex, package_task, future ,async, promise)

2.Lock based thread safe implementation of data structures and algorithms.

3.C++ memory model.

4.Lock free implementation of data structures and algorithms.

5.C++20 concurrency features.

5. Proper memory reclaim mechanism for lock free data structures.

6. Design aspects of concurrent code.

7. In depth discussion on thread pools.

8. Bonus section on CUDA programming with C and C++.
Who this course is for:

Anyone who wants to widen you skills with c++ programming.

Requirements

Basic of c++ programming , some knowledge about data structures and algorithms would be helpful

Last Updated 3/2021

Files:

Modern C++ Concurrency in Depth ( C++1720) [TutsNode.com] - Modern C++ Concurrency in Depth ( C++1720) 1 - Thread management guide
  • 1 - Setting up the environment for the course.mp4 (106.1 MB)
  • 3 - Quiz Parallel programming in general_en.srt (1.4 KB)
  • 18 - Debugging a application in Visual studio_en.srt (15.5 KB)
  • 5 - Programming exercise 1 Launching the threads_en.srt (1.2 KB)
  • 2 - Introduction to parallel computing_en.srt (13.8 KB)
  • 9 - Programming exercise 2 Trivial sale a ship model_en.srt (2.6 KB)
  • 1 - Setting up the environment for the course_en.srt (11.0 KB)
  • 16 - Parallel accumulate algorithm implementation_en.srt (10.7 KB)
  • 14 - Programming excersice 3 Sail a ship with work queues_en.srt (2.5 KB)
  • external-assets-links.txt (0.4 KB)
  • 8 - How to handle join, in exception scenarios_en.srt (7.1 KB)
  • 13 - Some useful operations on thread_en.srt (6.9 KB)
  • 4 - How to launch a thread_en.srt (6.7 KB)
  • 6 - Joinability of threads_en.srt (5.6 KB)
  • 7 - Join and detach functions_en.srt (5.5 KB)
  • 10 - How to pass parameters to a thread_en.srt (5.3 KB)
  • 15 - Parallel accumulate - algorithm explanation_en.srt (4.8 KB)
  • 17 - Thread local storage_en.srt (4.4 KB)
  • 12 - Transferring ownership of a thread_en.srt (4.2 KB)
  • 11 - Problematic situations may arise when passing parameters to a thread_en.srt (4.1 KB)
  • 18 - Debugging a application in Visual studio.mp4 (65.9 MB)
  • 2 - Introduction to parallel computing.mp4 (43.4 MB)
  • 4 - How to launch a thread.mp4 (34.0 MB)
  • 16 - Parallel accumulate algorithm implementation.mp4 (26.4 MB)
  • 8 - How to handle join, in exception scenarios.mp4 (23.6 MB)
  • 15 - Parallel accumulate - algorithm explanation.mp4 (22.1 MB)
  • 13 - Some useful operations on thread.mp4 (15.2 MB)
  • 12 - Transferring ownership of a thread.mp4 (12.6 MB)
  • 7 - Join and detach functions.mp4 (11.9 MB)
  • 6 - Joinability of threads.mp4 (10.1 MB)
  • 10 - How to pass parameters to a thread.mp4 (10.0 MB)
  • 17 - Thread local storage.mp4 (9.2 MB)
  • 11 - Problematic situations may arise when passing parameters to a thread.mp4 (8.5 MB)
  • 14 - Programming excersice 3 Sail a ship with work queues.mp4 (3.9 MB)
  • 9 - Programming exercise 2 Trivial sale a ship model.mp4 (3.8 MB)
  • 5 - Programming exercise 1 Launching the threads.mp4 (1.7 MB)
  • 3 - Quiz Parallel programming in general.mp4 (1.5 MB)
9 - Bonus section Parallel programming in massively parallel devices with CUDA
  • 2 - Elements of CUDA program_en.srt (20.0 KB)
  • 9 - CUDA memory transfer_en.srt (12.8 KB)
  • 10 - Sum array example_en.srt (10.9 KB)
  • 5 - Unique index calculation for threads in a grid_en.srt (10.9 KB)
  • 3 - Organization of threads in CUDA program 1_en.srt (9.6 KB)
  • 8 - Timing a CUDA program_en.srt (9.1 KB)
  • 6 - Unique index calculation for threads in a 2D grid_en.srt (7.2 KB)
  • 4 - Organization of threads in CUDA program 2_en.srt (7.0 KB)
  • 1 - Setting up the environment for CUDA_en.srt (6.7 KB)
  • 12 - CUDA device properties_en.srt (6.4 KB)
  • 7 - Unique index calculation for threads in a 2D grid 2_en.srt (5.8 KB)
  • 11 - Error handling in a CUDA program_en.srt (5.4 KB)
  • 1 - Setting up the environment for CUDA.mp4 (40.4 MB)
  • 2 - Elements of CUDA program.mp4 (32.9 MB)
  • 6 - Unique index calculation for threads in a 2D grid.mp4 (31.3 MB)
  • 10 - Sum array example.mp4 (28.5 MB)
  • 8 - Timing a CUDA program.mp4 (26.1 MB)
  • 12 - CUDA device properties.mp4 (25.7 MB)
  • 9 - CUDA memory transfer.mp4 (24.9 MB)
  • 5 - Unique index calculation for threads in a grid.mp4 (23.3 MB)
  • 11 - Error handling in a CUDA program.mp4 (22.4 MB)
  • 4 - Organization of threads in CUDA program 2.mp4 (21.7 MB)
  • 7 - Unique index calculation for threads in a 2D grid 2.mp4 (19.4 MB)
  • 3 - Organization of threads in CUDA program 1.mp4 (18.6 MB)
7 - Lock free data structures and algorithms
  • 4 - Stack memory reclaim mechanism using thread counting_en.srt (19.7 KB)
  • 5 - Stack memory reclaim mechanism using hazard pointers_en.srt (17.5 KB)
  • 6 - Stack memory reclaim mechanism using reference counting_en.srt (16.2 KB)
  • 3 - Simple lock free thread safe stack_en.srt (11.1 KB)
  • 2 - Stack recap_en.srt (9.5 KB)
  • 4 - Stack memory reclaim mechanism using thread counting.mp4 (84.2 MB)
  • 6 - Stack memory reclaim mechanism using reference counting.mp4 (77.6 MB)
  • 1 - Introduction and some terminology_en.srt (2.8 KB)
  • 5 - Stack memory reclaim mechanism using hazard pointers.mp4 (77.3 MB)
  • 3 - Simple lock free thread safe stack.mp4 (22.0 MB)
  • 2 - Stack recap.mp4 (12.7 MB)
  • 1 - Introduction and some terminology.mp4 (4.0 MB)
4 - Lock based thread safe data structures and algorithm implementation
  • 5 - parallel quick sort algorithm implementation_en.srt (16.0 KB)
  • 11 - Introduction to Matrix_en.srt (15.4 KB)
  • 14 - Factors affecting the performance of concurrent code_en.srt (14.4 KB)
  • 4 - Parallel STL introduction_en.srt (14.0 KB)
  • 10 - Partial sum algorithm parallel implementation_en.vtt (12.5 KB)
  • 6 - parallel for each implementation_en.srt (10.4 KB)
  • 9 - Partial sum algorithm introduction_en.srt (9.1 KB)
  • 13 - Parallel matrix transpose_en.srt (8.3 KB)
  • 7 - parallel find algorithm implementation with package task_en.srt (8.2 KB)
  • 2 - queue data structure implementation using linked list data structure_en.srt (8.1 KB)
  • 7 - parallel find algorithm implementation with package task_en.vtt (7.5 KB)
  • 10 - Partial sum algorithm parallel implementation_en.srt (7.1 KB)
  • 12 - Parallel Matrix multiplication_en.srt (5.5 KB)
  • 1 - introduction to lock based thread safe data structures and algorithms_en.srt (5.2 KB)
  • 8 - parallel find algorithm implementation with async_en.srt (4.3 KB)
  • 3 - thread safe queue implementation_en.srt (3.4 KB)
  • 4 - Parallel STL introduction.mp4 (58.9 MB)
  • 5 - parallel quick sort algorithm implementation.mp4 (44.8 MB)
  • 13 - Parallel matrix transpose.mp4 (37.1 MB)
  • 10 - Partial sum algorithm parallel implementation.mp4 (33.3 MB)
  • 6 - parallel for each implementation.mp4 (32.2 MB)
  • 9 - Partial sum algorithm introduction.mp4 (29.2 MB)
  • 11 - Introduction to Matrix.mp4 (21.8 MB)
  • 7 - parallel find algorithm implementation with package task.mp4 (18.8 MB)
  • 14 - Factors affecting the performance of concurrent code.mp4 (16.9 MB)
  • 12 - Parallel Matrix multiplication.mp4 (14.6 MB)
  • 2 - queue data structure implementation using linked list data structure.mp4 (13.8 MB)
  • 8 - parallel find algorithm implementation with async.mp4 (10.5 MB)
  • 3 - thread safe queue implementation.mp4 (9.6 MB)
  • 1 - introduction to lock based thread safe data structures and algorithms.mp4 (8.6 MB)
8 - Thread pools
  • 3 - Thread pool with waiting tasks_en.srt (12.4 KB)
  • 5 - Thread pool with work stealing_en.srt (11.4 KB)
  • 1 - Simple thread pool_en.srt (11.1 KB)
  • 2 - Thread pool which allowed to wait on submitted tasks_en.srt (8.5 KB)
  • 4 - Minimizing contention on work queue_en.srt (7.0 KB)
  • 5 - Thread pool with work stealing.mp4 (67.1 MB)
  • 3 - Thread pool with waiting tasks.mp4 (31.6 MB)
  • 1 - Simple thread pool.mp4 (29.2 MB)
  • 2 - Thread pool which allowed to wait on submitted tasks.mp4 (23.3 MB)
  • 4 - Minimizing contention on work queue.mp4 (18.1 MB)
5 - C++20 Concurrency features
  • 3 - C++ coroutines Introduction_en.srt (11.1 KB)
  • 1 - Jthread Introduction_en.srt (9.8 KB)
  • 4 - C++ coroutines resume functions_en.srt (8.8 KB)
  • 5 - C++ coroutines Generators_en.srt (7.8 KB)
  • external-assets-links.txt (0.1 KB)
  • 2 - Jthread Our own version implementation_en.srt (7.5 KB)
  • 6 - C++ Barriers_en.srt (7.4 KB)
  • 1 - Jthread Introduction.mp4 (45.9 MB)
  • 5 - C++ coroutines Generators.mp4 (36.3 MB)
  • 3 - C++ coroutines Introduction.mp4 (26.3 MB)
  • 4 - C++ coroutines resume functions.mp4 (25.4 MB)
  • 2 - Jthread Our own version implementation.mp4 (20.6 MB)
  • 6 - C++ Barriers.mp4 (19.3 MB)
2 - Thread safe access to shared data and locking mechanisms
  • 6 - Thread safe stack implementation implementation_en.srt (8.4 KB)
  • 3 - mutexes_en.srt (7.6 KB)
  • 7 - Thread safe stack implementation race condition inherit from the interface_en.srt (7.1 KB)
  • 5 - Thread safe stack implementation introduction to stack_en.srt (6.1 KB)
  • 8 - Dead locks_en.srt (5.5 KB)
  • 2 - Concept of invarient_en.srt (4.2 KB)
  • 1 - Introduction to locking mechanisms_en.srt (3.5 KB)
  • 4 - Things to remember when using mutexes_en.srt (3.4 KB)
  • 9 - unique locks_en.srt (3.4 KB)
  • 7 - Thread safe stack implementation race condition inherit from the interface.mp4 (18.3 MB)
  • 8 - Dead locks.mp4 (16.2 MB)
  • 9 - unique locks.mp4 (15.3 MB)
  • 2 - Concept of invarient.mp4 (13.5 MB)
  • 6 - Thread safe stack implementation implementation.mp4 (12.8 MB)
  • 3 - mutexes.mp4 (12.4 MB)
  • 1 - Introduction to locking mechanisms.mp4 (9.8 MB)
  • 5 - Thread safe stack implementation introduction to stack.mp4 (7.4 MB)
  • 4 - Things to remember when using mutexes.mp4 (5.9 MB)
6 - C++ memory model and atomic operations
  • 5 - atomic pointers_en.srt (8.3 KB)
  • 6 - General discussion on atomic types_en.srt (2.2 KB)
  • 16 - Concept of release sequence_en.srt (7.2 KB)
  • 3 - Functionality of std atomic_bool_en.srt (7.1 KB)
  • 9 - Discussion on memory_order_seq_cst_en.srt (6.8 KB)
  • 12 - Discussion on memory_order_acquire and memory_order_release_en.srt (5.9 KB)
  • 11 - Discussion on memory_order_relaxed_en.srt (5.9 KB)
  • 17 - Implementation of spin lock mutex_en.srt (5.9 KB)
  • 4 - Explanation of compare_exchange functions_en.srt (5.9 KB)
  • 10 - Introduction to instruction reordering_en.srt (5.3 KB)
  • 7 - Important relationships related to atomic operations between threads_en.srt (4.8 KB)
  • 2 - Functionality of std atomic_flag_en.srt (4.8 KB)
  • 1 - Introduction to atomic operations_en.srt (3.6 KB)
  • 14 - Concept of transitive synchronization_en.srt (3.6 KB)
  • 15 - Discussion on memory_order_consume_en.srt (3.3 KB)
  • 8 - Introduction to memory ordering options_en.srt (3.0 KB)
  • 13 - Important aspects of memory_order_acquire and memory_order_release_en.srt (2.9 KB)
  • 5 - atomic pointers.mp4 (22.7 MB)
  • 14 - Concept of transitive synchronization.mp4 (17.5 MB)
  • 16 - Concept of release sequence.mp4 (16.5 MB)
  • 4 - Explanation of compare_exchange functions.mp4 (15.6 MB)
  • 3 - Functionality of std atomic_bool.mp4 (14.3 MB)
  • 9 - Discussion on memory_order_seq_cst.mp4 (13.9 MB)
  • 17 - Implementation of spin lock mutex.mp4 (12.5 MB)
  • 2 - Functionality of std atomic_flag.mp4 (12.2 MB)
  • 15 - Discussion on memory_order_consume.mp4 (11.8 MB)
  • 11 - Discussion on memory_order_relaxed.mp4 (11.6 MB)
  • 12 - Discussion on memory_order_acquire and memory_order_release.mp4 (10.8 MB)
  • 7 - Important relationships related to atomic operations between threads.mp4 (9.1 MB)
  • 1 - Introduction to atomic operations.mp4 (8.7 MB)
  • 6 - General discussion on atomic types.mp4 (7.0 MB)
  • 10 - Introduction to instruction reordering.mp4 (6.7 MB)
  • 13 - Important aspects of memory_order_acquire and memory_order_release.mp4 (6.0 MB)
  • 8 - Introduction to memory ordering options.mp4 (5.4 MB)
3 - Communication between thread using condition variables and futures
  • 4 - Thread safe queue implementation implementation_en.srt (6.9 KB)
  • 1 - introduction to condition variables_en.srt (6.4 KB)
  • 3 - Thread safe queue implementation introduction to queue data structure_en.srt (6.3 KB)
  • 6 - async tasks detailed discussion_en.srt (6.1 KB)
  • 5 - introduction to futures and async tasks_en.srt (5.6 KB)
  • 2 - Details about condition variables_en.srt (5.6 KB)
  • 7 - Parallel accumulate algorithm implementation with async task_en.srt (5.1 KB)
  • 11 - std shared_futures_en.srt (5.0 KB)
  • 8 - Introduction to package_task_en.srt (4.5 KB)
  • 9 - Communication between threads using std promises_en.srt (3.9 KB)
  • 10 - Retrieving exception using std futures_en.srt (3.6 KB)
  • 4 - Thread safe queue implementation implementation.mp4 (25.8 MB)
  • 5 - introduction to futures and async tasks.mp4 (22.0 MB)
  • 9 - Communication between threads using std promises.mp4 (17.9 MB)
  • 6 - async tasks detailed discussion.mp4 (16.4 MB)
  • 7 - Parallel accumulate algorithm implementation with async task.mp4 (15.3 MB)
  • 1 - introduction to condition variables.mp4 (14.6 MB)
  • 3 - Thread safe queue implementation introduction to queue data structure.mp4 (13.1 MB)
  • 2 - Details about condition variables.mp4 (13.0 MB)
  • 11 - std shared_futures.mp4 (10.7 MB)
  • 8 - Introduction to package_task.mp4 (10.6 MB)
  • 10 - Retrieving exception using std futures.mp4 (7.0 MB)
  • TutsNode.com.txt (0.1 KB)
  • [TGx]Downloaded from torrentgalaxy.to .txt (0.6 KB)
    • .pad
    • 0 (0.1 KB)
    • 1 (1.5 KB)
    • 2 (402.2 KB)
    • 3 (213.8 KB)
    • 4 (435.1 KB)
    • 5 (141.1 KB)
    • 6 (88.9 KB)
    • 7 (59.0 KB)
    • 8 (199.0 KB)
    • 9 (140.5 KB)
    • 10 (66.4 KB)
    • 11 (413.4 KB)
    • 12 (240.1 KB)
    • 13 (9.7 KB)
    • 14 (189.1 KB)
    • 15 (126.2 KB)
    • 16 (330.5 KB)
    • 17 (359.4 KB)
    • 18 (242.8 KB)
    • 19 (327.3 KB)
    • 20 (334.9 KB)
    • 21 (2.8 KB)
    • 22 (134.5 KB)
    • 23 (215.1 KB)
    • 24 (411.7 KB)
    • 25 (195.5 KB)
    • 26 (354.1 KB)
    • 27 (70.4 KB)
    • 28 (99.9 KB)
    • 29 (382.5 KB)
    • 30 (172.2 KB)
    • 31 (214.5 KB)
    • 32 (330.5 KB)
    • 33 (142.4 KB)
    • 34 (389.8 KB)
    • 35 (502.8 KB)
    • 36 (507.7 KB)
    • 37 (173.7 KB)
    • 38 (328.8 KB)
    • 39 (360.9 KB)
    • 40 (116.2 KB)
    • 41 (191.8 KB)
    • 42 (174.1 KB)
    • 43 (447.2 KB)
    • 44 (158.3 KB)
    • 45 (368.0 KB)
    • 46 (72.4 KB)
    • 47 (486.7 KB)
    • 48 (73.9 KB)
    • 49 (510.6 KB)
    • 50 (125.5 KB)
    • 51 (307.5 KB)
    • 52 (418.1 KB)
    • 53 (223.0 KB)
    • 54 (252.0 KB)
    • 55 (264.9 KB)
    • 56 (401.3 KB)
    • 57 (427.2 KB)
    • 58 (189.9 KB)
    • 59 (75.9 KB)
    • 60 (213.7 KB)
    • 61 (508.9 KB)
    • 62 (392.0 KB)
    • 63 (1.9 KB)
    • 64 (245.9 KB)
    • 65 (281.0 KB)
    • 66 (402.4 KB)
    • 67 (19.5 KB)
    • 68 (93.3 KB)
    • 69 (261.5 KB)
    • 70 (138.2 KB)
    • 71 (244.8 KB)
    • 72 (367.4 KB)
    • 73 (162.6 KB)
    • 74 (293.2 KB)
    • 75 (437.3 KB)
    • 76 (461.6 KB)
    • 77 (388.8 KB)
    • 78 (481.8 KB)
    • 79 (254.4 KB)
    • 80 (396.8 KB)
    • 81 (331.9 KB)
    • 82 (426.5 KB)
    • 83 (358.1 KB)
    • 84 (364.9 KB)
    • 85 (22.5 KB)
    • 86 (140.7 KB)
    • 87 (501.0 KB)
    • 88 (33.6 KB)
    • 89 (325.3 KB)
    • 90 (511.7 KB)
    • 91 (120.2 KB)
    • 92 (65.6 KB)
    • 93 (29.7 KB)
    • 94 (118.0 KB)
    • 95 (203.6 KB)
    • 96 (322.4 KB)

There are currently no comments. Feel free to leave one :)

Code:

  • udp://open.stealth.si:80/announce
  • udp://tracker.tiny-vps.com:6969/announce
  • udp://fasttracker.foreverpirates.co:6969/announce
  • udp://tracker.opentrackr.org:1337/announce
  • udp://explodie.org:6969/announce
  • udp://tracker.cyberia.is:6969/announce
  • udp://ipv4.tracker.harry.lu:80/announce
  • udp://tracker.uw0.xyz:6969/announce
  • udp://opentracker.i2p.rocks:6969/announce
  • udp://tracker.birkenwald.de:6969/announce
  • udp://tracker.torrent.eu.org:451/announce
  • udp://tracker.moeking.me:6969/announce
  • udp://tracker.dler.org:6969/announce
  • udp://9.rarbg.me:2970/announce
GDRIVE-CACHE 📁 GD (hit) | ID: 1V1wyDjDXf... 📄 torrent 🕐 25 Jan 2026, 09:13:11 am IST ⏰ 19 Feb 2026, 09:13:11 am IST ⚠️ Expired 6d 20h ago 🔄 Refresh Cache