Practical Concurrent Data Structure Design With Modern C++ – Download Free

Free Download What you'll learn
Designing concurrent data structures using Modern C++
Using C++ memory model to build lock free data strcutures
Using the Modern C++ features to build high performance data structures
Pitfalls and challenges to avoid while designing concurrent systems using C++
Requirements
Should be aware the C++ concurrency syntax
Should be able to compile codes independently
No domain specific niche knowledge required
Willing to followup syntax on cppreference website and tryout snippets independently
Description
Welcome to "Practical Concurrent Data Structure Design using Modern C++"!In this course, you will learn how to design and implement efficient concurrent data structures in C++ using the latest techniques and best practices.Concurrency is becoming increasingly important in modern software development, and designing data structures that multiple threads can safely and efficiently access is essential. In this course, you will start by understanding the basic concepts of concurrency and the challenges of designing concurrent data structures.Next, you will learn about the different types of concurrent data structures and how to select the right one for your use case. Finally, you will explore the various synchronization techniques and mechanisms in C++ to ensure thread safety, such as mutexes, condition variables, and atomics.You will also learn about the different memory models and how to design lock-free and wait-free data structures. You will study the principles of memory reclamation and garbage collection, which are critical for creating efficient lock-free data structures.Throughout the course, you will work on practical examples and hands-on exercises to reinforce your understanding of the material. In addition, you will design and implement concurrent data structures such as queues, stacks, hash tables, and trees using the latest C++ features, such as the Standard Template Library (STL), smart pointers, and lambda expressions.By the end of this course, you will have a solid understanding of designing and implementing efficient concurrent data structures in C++. As a result, you can confidently create high-performance software that scales well on multi-core systems and can handle a high degree of concurrency.Here are five reasons why learning concurrency using C++20 is essential:Standardized support for concurrency: C++20 has introduced new features and enhancements that support concurrent programming. The Standard Template Library (STL) now supports parallel algorithms, atomic operations, and memory models. This means that C++20 provides a standardized way to write concurrent programs, making it easier for developers to write correct and efficient code.High-performance: C++ is a high-performance language, and with the new concurrency features in C++20, it is possible to write concurrent programs that are both correct and fast. Using atomics, for example, allows for lock-free synchronization, which can improve performance by reducing the overhead of acquiring and releasing locks.Memory model improvements: C++20 introduces a new memory model that provides stronger guarantees for concurrent access to shared memory. This makes it easier to reason about the behavior of concurrent programs and helps prevent subtle bugs that can be hard to find and fix.Better type safety: C++20 introduces new features that improve type safety in concurrent programs. For example, the atomic_ref class provides safer access to shared variables without explicit synchronization.Practical applications: Concurrency is becoming increasingly important in modern software development as multi-core processors become more common. Learning how to write concurrent programs using C++20 can give you a competitive advantage in the job market and enable you to develop high-performance software that can handle a high degree of concurrency.
Overview
Section 1: Introduction
Lecture 1 Introduction
Lecture 2 C++ standard features overview C++98/11/14/17/20/23
Lecture 3 Amdahl's law in concurrent programs
Lecture 4 When to use concurrency or multithreading optimally
Section 2: Lock Free Design fundamentals
Lecture 5 Wait free concpets
Lecture 6 Lock Free concept
Lecture 7 Obstruction Free Concept
Lecture 8 Thinking in Transactions like ACID
Lecture 9 C++ Atomic semantics quick refresher
Lecture 10 Considerations while using C++ atomics
Section 3: Double Check Locking with modern C++
Lecture 11 The concept in a nutshell in a single threaded context
Lecture 12 Concurrent implementation using mutex and atomics using standard C++11
Lecture 13 Using once_flag in C++11
Lecture 14 The cleanest concurrent initalization solution
Lecture 15 Locks, atomics and concurrent design
Section 4: Singly Linked List using Modern C++
Lecture 16 Design Goals
Lecture 17 Class overview using Modern C++ features
Lecture 18 Constructor, Destructor and Find implementation code walkthrough
Lecture 19 push_front function code walkthrough
Lecture 20 pop_front function code walkthrough
Section 5: ABA problem, RCU, Hazard pointers. Concurrent Solutions using Modern C++
Lecture 21 ABA Problem explained
Lecture 22 Overview of possible solutions for ABA problem
Lecture 23 Overview of solutions for deletetion related problems
Lecture 24 Singly Linked List using the Reference class and other modern C++ features
Lecture 25 Implementation details for using the reference class
Lecture 26 Concurrency analysis of mutlithreading events in the class
Lecture 27 Read, Copy, and Update (RCU) design goals
Lecture 28 RCU example with concurrent dynamic array design using Modern C++
Lecture 29 Hazard pointer
Lecture 30 Thread pool design considerations when using C++20 or higher.
Lecture 31 Apply theory in concurrent applications
Section 6: Design considerations for building multithreading solutions using modern c++
Lecture 32 Important assumptions before going further
Lecture 33 Challenges in concurrent design using modern c++
Lecture 34 Design advice for dealing with multithreading in production
Lecture 35 Concurrent architecture overview
Section 7: Testing and debugging challengers with concurrent data structures
Lecture 36 Common types of bugs in multithreaded programs
Lecture 37 Bugs related to unwanted blocking
Lecture 38 Bugs releated to Race conditions
Lecture 39 Code review techniques for dealing with multithreading
Lecture 40 Challenges in testing multithreaded code
Lecture 41 Design for testability
Lecture 42 Testing Techniques
Section 8: Conclusion
Lecture 43 Libraries, Tool and closing remarks
Lecture 44onus Lecture
Intermediate C++ programmers exploring concurrey in modern C++,Intermediate C++ programmers looking to grow in their roles from developer to Leads,Intermediate C++ programmers curious to understand practical implementation of modern c++ concurrency tools,C++ programmers aware of syntax but looking for opportunities to build personal projects using advanced language features.,Senior Software Engineers planning to become Tech Leads in near future,All C++ programmers who have been coding in C++ for 12 months or more.




Homepage

https://www.udemy.com/course/concurrent-data-structure-design-with-modern-cpp/