## +23 ## Single Producer Single Consumer Lock-free FIFO From the Ground Up CHARLES FRASCH Charlie Frasch charles.frasch@gmail.com Senior Core Developer - IEX Group https://www.iex.io/ Code at: https://github Single Producer Single Consumer Lock-Free Wait-Free Fifo - Single producer: one producer (aka writer) thread - Single consumer: one consumer (aka reader) thread - Lock-free: it doesn’t use mutex locks. Pikus Taking a Byte Out of C++ - Avoiding Punning by Starting Lifetimes - Robert Leahy Awesome Lock-Free - Erik Rigtorp What is Low Latency C++? (Part 1) - Timur Doumler - CppNow 2023 What is Low Latency

## +23 ## Lock-free Atomic Shared Pointers Without a Split Reference Count? It Can Be Done! DANIEL ANDERSON  Daniel Anderson Deferred reclamation, i.e., garbage collection in C++ ## Some assumed knowledge • You’ve heard of lock-free programming and know what a compare_exchange is • You know roughly what atomic does and what it Deferred reclamation, i.e., garbage collection in C++ ## Some assumed knowledge • You’ve heard of lock-free programming and know what a compare_exchange is • You know roughly what atomic does and what it

## +24 ## When Lock-Free Still Isn’t Enough: An Introduction to Wait-Free Programming and Concurrency Techniques DANIEL ANDERSON ![Image](/uploads/documents/8/1/9/6/8196edda7947eb664cc5baa424f75eec/p2_1 What we'll learn today • Very quick review of concurrency and lock-free programming • Review the “bread and butter” of lock-free design patterns • Define wait-free algorithms, understand the definition assumed knowledge • You know what std::atomic does and what it is used for • You’ve heard of lock-free programming and know what a compare_exchange is Carnegie Mellon University ## Our motivating problem

handle = spawn_background_task(); handle.wait(); // no benefit } ## Aside: Non-Blocking vs Lock-free In lots of cases, short-term blocking (e.g. with short-lived std::mutex locks) is OK. ⇒ for those those cases, Non-Blocking means Not waiting for a lengthy task to run. ## Aside: Non-Blocking vs Lock-free In lots of cases, short-term blocking (e.g. with short-lived std::mutex locks) is OK. ⇒ for those but one thread at any point, that one thread will complete its task. ⇒ for those cases, you need Lock-free allocators, message queues, etc. ## How do we move work off the current thread? How ## How do we

|000|00000|00000||| |000|000|00000||| ## Persistent concurrent hash Map (PMap) ## Non-volatile ## Lock-free Guaranteed system-wide progress Scales up with multiple threads ## Open addressing In-place |000|00000|00000||| |000|000|00000||| ## Resizing ## ▶ Adapted from Cliff Click’s hash map [14] Lock-free resizing is challenging ▶ Keys and values are separate atomics ▶ Partial operations are possible |000|000000|000000||| |000|0000|000000||| ## Related Works Compared ## ▶ Concurrent level hashing (level) Lock-free Open addressing (of pointers) ▶ Resize (but only expansion) OneFile hash map (OneFile) Wait-free

System/Subsystem Design (Defines API boundaries and behavior) Implementation details (e.g., “lock-free” and “wait-free” algorithms provide guarantees for system-wide or per-thread progress) ## Levels System/Subsystem Design (Defines API boundaries and behavior) Implementation details (e.g., “lock-free” and “wait-free” algorithms provide guarantees for system-wide or per-thread progress) Examples: System/Subsystem Design (Defines API boundaries and behavior) • Implementation details (e.g., “lock-free” and “wait-free” algorithms provide guarantees for system-wide or per-thread progress) Examples:

integrity. Efficient and safe concurrent updates to shared variables. Enable the implementation of lock-free data structures, leading to improved performance and scalability. Useful in various applications in data-parallel algorithms, statistics collection, and optimization processes. Useful for: • Lock-free data structures • Parallel reductions (OpenMP) • Optimization algorithms • Statistics collection

fetch_and(&self, val: bool, order: Ordering) -> bool ## Why Atomic Operation? High Performance Lock-free programming Shared Variable Access When Multi-threading Lock - context switch Atomic - no context

jpg) Hardware DLB-Assist Channel removes the penalty of CAS to achieve a safety-guaranteed, lock-free and scalable channel. ## DLB-Assist Channel Overview Producer Consumer Senders Message-Ownership

按channel结构体的地址顺序加锁  - 研究课题：能否实现lock-free channels? ## 大纲 - 并发 - 接口 - 垃圾回收 - 调度 - 死锁检测 ## 接口 • 接口定义了一系列方法 - 如果类型实现了这些方法，它就实现了这个接口