#concurrency

26 pages search “concurrency” ↳ all tags

Wiki 21

  • causality.blog Anonymous essay blog on programming-language foundations, concurrency, and the questions the mainstream debate skips
  • CobaltC Speculative C-successor spec from the essay book The Wrong Memory: C syntax over Rust-style ownership, borrowing and inferred lifetimes
  • Data race Unordered concurrent access to one memory location with at least one write; distinct from a general race, and what lockset and vector-clock detectors hunt
  • Data races and the limits of ThreadSanitizer Phil Eaton rebuilds a FastTrack-style race detector, then shows TSan missing obvious races in C and Golang once its fixed budgets run out
  • Epoch-based reclamation Lock-free memory reclamation scheme where freed nodes wait in per-thread limbo until all threads have advanced past the retirement epoch
  • Go Channel Bug Patterns Four failure modes (deadlock, leak, race, protocol violation) that channels reproduce one-for-one from shared-state bugs
  • Golang's goroutine leak profiler Go 1.27's goroutineleak profile reuses the GC's mark phase to find goroutines blocked forever on channels and sync primitives, in production
  • Linearizability The consistency model CAP calls C: an operation sees state at least as new as any operation that completed before it started
  • Message Passing Is Shared Mutable State Tu et al's 2019 Go bug study confirms Edward Lee's 2006 prediction — channels are concurrent queues with all the bugs of shared state
  • Message Passing vs Shared Memory The two camps of concurrency coordination, the case that they fail for the same reason, and what each actually buys you
  • Notify-and-Pull IPC Pattern that combines synchronous message passing with non-blocking notifications to avoid server-to-server deadlock
  • Postgres LISTEN/NOTIFY Can Actually Scale How DBOS took Postgres LISTEN/NOTIFY from 2.9K to 60K writes/sec by batching notifications
  • Rust Send and Sync The two auto-traits that govern thread safety in Rust; `Send` for cross-thread move, `Sync` for cross-thread shared reference, with `&T: Send` ⇔ `T: Sync`
  • Safety in an unsafe { world } joshlf's RustConf talk on teaching Rust safety properties the language cannot reason about
  • Shared memory consistency from scratch, part 1: causality Alloth designs a deliberately permissive multiprocessor to derive memory-model rules, and argues the C++11/20 atomics model gets causality wrong
  • Spinlock Locking by busy-waiting in a tight loop instead of sleeping; cheap when critical sections are short, catastrophic when they aren't
  • Splay list Skip list that adaptively raises hot keys toward the top, reducing search depth to log(1/p) for high-hit-ratio keys (Aksenov 2020)
  • SQLite in Production WAL mode can block short-lived readers, plus a pragma blueprint with two of its claims corrected
  • Tokio gives progress, not ordering Tokio's fairness guarantee assumes a task bound that only the application can supply
  • Why cache padding uses 128 bytes on a 64-byte cache line Ivan Boldyrev benchmarks 64 vs 128-byte atomic padding — Skylake shows it, Ice Lake and M1 don't
  • Write atomicity (multi-copy atomicity) Whether a write is invisible to every processor until all cached copies are invalidated; MCA vs oMCA vs nMCA, and which CPUs guarantee it

Toolbox 1

  • skiplist Header-only C macros for a lock-free skip list with optional splay rebalancing of hot keys

Books 4