Awesome Concurrency

Sub-lists

• Libraries

Memory consistency models

• Atomic vs. Non-Atomic Operations
• Atomic reference counting (with Zig code samples)
• Memory Barriers: a Hardware View for Software Hackers
• Memory Models: A Case For Rethinking Parallel Languages and Hardware
• Java Memory Model
• Foundations of the C++ Concurrency Memory Model
• Explanation of the Linux-Kernel Memory Consistency Model
  • Frightening Small Children and Disconcerting Grown-ups: Concurrency in the Linux Kernel
• Memory Models by Russ Cox
  • Hardware MM
  • Programming Language MM
  • Updating the Go MM
• Repairing Sequential Consistency in C/C++11 + P0668R5: Revising the C++ memory model
• A Promising Semantics for Relaxed-Memory Concurrency
• Bounding Data Races in Space and Time + Multicore OCaml Memory model
• C++ Memory Ordering at Compile Time
• The Problem of Programming Language Concurrency Semantics
• Understandnig Atomics and Memory Ordering
• Weak memory concurrency in C/C++11
• Weak Memory Consistency
• Weakly Consistent Concurrency
• Memory Order in C++
• Atomics And Concurrency
• A Relaxed Guide to memory_order_relaxed - by Paul McKenney & Hans Boehm

Examples

C++

• intro.multithread
• atomics.order
• atomics.fences
• std::memory_order
• C++ reference - Memory Model

Index

Rust

• The Rust Reference / Memory model
• The Rustonomicon / Atomics

Java

• Java Memory Model

Go

• Go Memory Model
• Don't be clever

D

• D Memory Model
• D Wiki - C++ to D Concurrency

LLVM

• LLVM Atomic Instructions and Concurrency Guide

Atomics impl

• C/C++11 mappings to processors
• The JSR-133 Cookbook for Compiler Writers

Futures

• Futures and Promises
• Your Server as a Function, Systems Programming at Twitter, Finagle – Concurrent Programming with Futures
• Futures for C++11 at Facebook, Folly Futures,
• Zero-cost futures in Rust, Designing futures for Rust, RFC

Fibers

• Fibers in C++: Understanding the basics
• Fibers, Oh My!
• Project Loom: Fibers and Continuations for the Java Virtual Machine
• State of Loom, Part 1, Part 2
• C++ / Distinguishing coroutines and fibers
• C++ / Fibers under the magnifying glass
• Lightweight concurrency in lua
• D - Fibers

Coroutines

Stackless

• Stackless Coroutine in Asio
• On Duff's Device and Coroutines

Assymmetric Transfer

• Coroutine Theory
• Writing custom C++20 coroutine systems
• Revisiting Coroutines by Ana Lúcia de Moura and Roberto Ierusalimschy

Stacks

• Segmented Stacks in LLVM
• Rust / Abandoning segmented stacks in Rust
• Go / How Stacks are Handled in Go, Continious Stacks Design Doc
• Rust / Futures and Segmented Stacks
• Continuation Passing for C - A space-efficient implementation of concurrency
• C++ / call/cc (call-with-current-continuation): A low-level API for stackful context switching

Schedulers

• Making the Tokio scheduler 10x faster
• Rust / Work-Stealing Scheduler Discussion
• Scalable Go Scheduler Design Doc
• Dmitry Vyukov — Go scheduler: Implementing language with lightweight concurrency
• GopherCon 2020: Austin Clements - Pardon the Interruption: Loop Preemption in Go 1.14
• "Runtime scheduling: theory and reality" by Eben Freeman

Impls

• [Golang] Runtime
• [Rust] Tokio Multi-Threaded Runtime
• [Dlang] Phobos - Multiple Declarations
• [Kotlin] Coroutine Runtime
• [Scala] Cats Effect

Channels

• Go channels on steroids
• Scalable FIFO Channels for Programming via Communicating Sequential Processes
• Fast and Scalable Channels in Kotlin Coroutines

Asynchronous Programming

• Асинхронность в программировании
• Асинхронность: назад в будущее
• Kotlin Coroutines Proposal
• Zero-cost futures in Rust, Designing futures for Rust

Async / await

• C#: Механика asnyc/await в C#
• Kotlin: Coroutines / Implementation details
• C++:
  • Understanding operator co_await
  • Understanding the promise type
  • Understanding the Compiler Transform
  • Understanding Symmetric Transfer

Syntax

• What Color is Your Function?, Hacker news
• C#: Asynchrony in C# 5 Part Six: Whither async?
• Rust: A final proposal for await syntax, Await Syntax Write Up
• Kotlin: How do you color your functions?
• Zig: What is Zig's “Colorblind” Async/Await?

Structured Concurrency

• Notes on structured concurrency, or: Go statement considered harmful
• Structured Concurrency Group, Resources
• Roman Elizarov – Structured concurrency
• Lewis Baker – Structured Concurrency: Writing Safer Concurrent Code with Coroutines and Algorithms
• Eric Niebler – Structured Concurrency
• Josua Wuyts - Tree-Structured Concurrency
• Sebastiaan Koppe - Structured Concurrency in D(Video)

Cancellation

• Timeouts and cancellation for humans

Data race detection

• ThreadSanitizer – data race detection in practice, compiler-rt/lib/tsan/rtl
• FastTrack: Efficient and Precise Dynamic Race Detection

Verification

• Dynamic Partial-Order Reduction for Model Checking Software
• Finding and Reproducing Heisenbugs in Concurrent Programs
• CDSCHECKER: Checking Concurrent Data Structures Written with C/C++ Atomics
• How We Test Concurrent Primitives in Kotlin Coroutines

Tools

• Rust: Loom - concurrency permutation testing
• Kotlin: Lincheck - framework for testing concurrent

Fearless Concurrency

• Rust: Fearless Concurrency
• Pony: Reference capabilities
• C++: Clang Thread-Safety Analysis
• D: Fearless - Safe Concurrency in D
• Joe Duffy (Project Midori) – 15 Years of Concurrency

Consistency models for concurrent objects

• Linearizability: A Correctness Condition for Concurrent Objects
• Consistency Models Map
• Linearizability versus Serializability
• Strong consistency models

Lock-freedom

Data Structures / Algorithms

• Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms
• A Scalable Lock-free Stack Algorithm
• The Baskets Queue
• Lock-free deques and doubly linked lists
• A Practical Multi-Word Compare-and-Swap Operation

Memory Management

• Hazard Pointers: Safe Memory Reclamation for Lock-Free Objects
• Epoch-Based Memory Reclamation
• Differential Reference Counting
• Implementing a Lock-free atomic_shared_ptr
• folly / AtomicSharedPtr
• Automem Hands Free RAII in D

Misc

• Roman Elizarov — Lock-Free Algorithms for Kotlin Coroutines
• Lock-free структуры данных
• LockFree Programming a_Mental Model - Xorvoid
• Zig's I/O and Concurrency Story by King Protty [Video]
• CppCon 2016 - "Elegant Asynchronous Code" by Nat Goodspeed [Video]

Transactions

• Martin Kleppmann – Transactions: myths, surprises and opportunities, slides & references
• A Critique of ANSI SQL Isolation Levels
• Serializable Isolation for Snapshot Databases
• What Write Skew Looks Like
• A Read-Only Transaction Anomaly Under Snapshot Isolation
• Google Percolator
• Serializable Snapshot Isolation in PostgreSQL
• PostgreSQL SSI Implementation Notes
• A History of Transaction Histories

Demystifying Database Systems

• An Introduction to Transaction Isolation Levels
• Correctness Anomalies Under Serializable Isolation
• Introduction to Consistency Levels
• Isolation levels vs. Consistency levels

Hardware Transactional Memory

• Maurice Herlihy – Transactional Memory, slides
• Gil Tene – Understanding Hardware Transactional Memory
• Is Parallel Programming Hard, And, If So, What Can You Do About It?, 17.3
• Глава 16 – Programming with Intel Transactional Synchronization Extensions
• Глава 15 – Intel TSX Recommendations
• TSX Anti-Patterns
• Lock Elision Implementation Guide

Software Transactional Memory

• [D] Software Transactional Memory in D (Video) by Brad Roberts
• [C++] CppCon 2015 - “Transactional Memory in Practice" by Brett Hall
• [Scala, ZIO] Introduction to Software Transactional Memory
• A (brief) retrospective on transactional memory by Joe Duffy

IO

• Lord of io_uring
• A Universal I/O Abstraction for C++
• A Programmer-Friendly I/O Abstraction Over io_uring and kqueue

Acknowledgments

Author: Roman Lipovsky Original repository: from Gitlab - Awesome-Concurrency