Published 3/2023MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHzLanguage: English | Size: 792.99 MB | Duration: 2h 27m

Concurrency, Multithreading, Data Structures, Design Patterns, C11, C14, C17, C20, Architecture, Code review tip

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 C20 is essential:Standardized support for concurrency: C20 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 C20 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 C20, 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: C20 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: C20 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 C20 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 C98/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 C11

Lecture 13 Using once_flag in C11

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 C20 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 44[Bonus 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 Eeers planning to become Tech Leads in near future,All C programmers who have been coding in C for 12 months or more.

HomePage: