[2026-09-11] lint | Unescaped pipes in table-row wikilinks
Trigger: building a static HTML rendering of the wiki (site/build.mjs) surfaced markdown that Obsidian also renders wrong.
Fixed (4 pages): 7 wikilinks written as [[target|Display]] inside markdown table rows, where the alias pipe has to be escaped as \| or GFM reads it as a cell boundary.
shard-per-core-runtimes-compared — the worst case: three unescaped links in the header row of the central comparative-architecture table gave it 7 cells against a 4-cell delimiter row, so GFM rejected the table outright and all 13 rows rendered as a paragraph of pipe soup. A fourth violation sat in the "Production users" row.
spsc-queue, the-fastest-queue — [[rtrb\|ringbuffer-spsc]] produced one cell too many, silently dropping the trailing "Apple M4" hardware column from the benchmark table.
swiss-table — [[folly-f14\|folly F14]], same class, one column lost.
Not a renderer bug: the escaped form (\|) was already used correctly in 48 other links, concentrated in kernel-bypass. These 7 were simply written without the backslash.
Guarded: site/build.test.mjs now asserts the invariant over every page — no unescaped | inside a wikilink on a table row — and separately asserts that every |---| delimiter in the corpus still produces a real <table>. Both fail the build, so ingest #18 cannot reintroduce this.
Open questions:
Worth a convention note in CLAUDE.md? The rule "inside a table cell, write [[page\|Alias]]" is invisible until a table silently collapses, and the failure mode is a whole table vanishing rather than one broken link.
Two wikilinks carry heading fragments (io-uring#cancellation-safety, thread-per-core#queueing-theory) whose anchors match no actual heading — the renderer drops the fragment and links the page, but the intent was to deep-link. Either fix the anchors or drop them from the source.
lazy-lock's frontmatter lists a crate tag that its Index.md row omits; the other 228 agree. Frontmatter is treated as the source of truth. Worth reconciling the index row.
[2026-05-29] ingest | High-Level Rust: Getting 80% of the Benefits with 20% of the Pain
Source: Raw/Rust/High-Level Rust: Getting 80% of the Benefits with 20% of the Pain.md
Created (3 pages):
high-level-rust (source summary — the three pillars (type-first, functionalish, DDD-via-Arc<dyn Trait>), the 10–30% perf hit, the explicit "not a fit" list, and the framing as a coherent counter-position to expert-rust-design rather than a competence ladder below it)
clone-cost-stratification — the opaque-.clone() problem; the cheap/moderate/expensive/catastrophic strata; mitigations (bytes, Arc<str>, im/champ-backed collections, Cow); the LightClone proposal as the latest in a long line of "Rust needs a clone-aliasing story" discussions
functional-core-imperative-shell — Bernhardt 2012 / Seemann ImPureIm sandwich pattern named explicitly because high-level-rust makes it a pillar; the cross-language lineage table (hexagonal, onion, clean, IO a); the borrow checker as built-in enforcement
Updated (5 pages):
rust-allocation-patterns — added the "high-level fallback" section: inverts the borrow→Cow→owned hierarchy when productivity dominates; links to clone-cost-stratification for the discipline that makes the inversion survivable
rust-concurrency-patterns — added the Arc<dyn Trait> services alternative to the perf-first decision framework; framed as answering a different question, not contradicting the existing framework
rust-abstraction-boundaries — added section on how high-level-rust deliberately chooses the trait-object column of the enums/generics/trait-objects table; preserved coherence by framing as agreement on the rule (abstract along the variation axis that exists) and disagreement on which axis is most common in application code
type-driven-development — added "As an onboarding ramp" section: technique 4 (illegal states unrepresentable) is the trailhead, typestate is the peak; the seven techniques are a depth ladder, not a prerequisite chain
expert-rust-design — added closing "Not every project gets here" section naming the two-position spectrum explicitly: A+ Rust optimizes the cost of indirection, high-level Rust optimizes the cost of the team not shipping; both correct for their target workloads
Index: added 3 new entries (high-level-rust, clone-cost-stratification, functional-core-imperative-shell)
Key insight: "idiomatic Rust" is not one thing. Before this ingest, the wiki implicitly took the expert-rust-design position as the destination — every page on allocation, concurrency, and abstraction pointed at the borrow-aware, monomorphization-friendly, lifetime-precise endpoint. This source explicitly names the other coherent destination: a Rust written with the type system but without the borrow-checker athletics, accepting Arc<dyn Trait> services and generous cloning as the price of approximating C# velocity. Both endpoints satisfy "the type system does the thinking" — they diverge on what else the type system has to do. Integrated as the closing framing of expert-rust-design and as a deliberate counter-position throughout rust-allocation-patterns, rust-concurrency-patterns, and rust-abstraction-boundaries — the existing perf-first guidance stays correct, but is now scoped to the workloads it was always implicitly written for.
Secondary insight: Rust's .clone() is the language's most consequential under-stratified operation. A single syntactic form spans free (Copy), cheap (Arc bump ~2 ns), moderate (small String/Vec, ~100 ns), expensive (Vec<String>, µs), and catastrophic (nested collections in a loop, unbounded) — five orders of magnitude with no type-level signal. This sits alongside await (yield vs no-yield), dyn Trait (call vs vtable), generics (one fn vs many), and macros (call vs expansion) as the recurring Rust pattern: honest costs, but no lexical stratification. Worth tracking whether the LightClone-style proposals ever reach mainline — the underlying ask has been live since at least the 2018 Cheap/claim RFC threads. Integrated as a self-contained section in clone-cost-stratification and as the cost-discipline link from rust-allocation-patterns.
Tertiary insight: The "functional core, imperative shell" pattern was already the de facto Rust style — it just wasn't named. Most idiomatic Rust pushes effects to async handlers and keeps domain logic in synchronous pure functions, but the wiki had no page for it, and the pattern was scattered across parse-dont-validate, railway-oriented-programming, and type-driven-development without integration. Naming it as functional-core-imperative-shell makes the cross-language lineage visible (Bernhardt 2012, Seemann sandwich, hexagonal/onion/clean architecture, Haskell's IO) and gives high-level-rust something concrete to point at when describing its second pillar.
Open questions:
Does LightClone (or any successor proposal) actually ship? The underlying problem has been recognized for ~8 years across multiple RFC threads (claim, Cheap, Owned/Shared variants); none have crossed the line into stabilization. The high-level Rust style depends on a discipline the type system declines to enforce, which is exactly the kind of gap that historically gets closed once the cost is widely felt — but "widely felt" requires adoption, and adoption is gated on the missing tool. Track the cargo-mutants/Clippy lint coverage as the partial-mitigation frontier.
How does the high-level-rust style interact with shard-per-core runtimes (Compio, Monoio, Glommio)? Shard-per-core's whole point is to eliminate Arc<dyn Trait> cross-shard sharing; high-level Rust's third pillar is built on it. There may be a clean answer (use the high-level style per-shard, the shard boundary is the natural cut point) or it may be that the two styles are fundamentally incompatible — worth surfacing in the next shard-per-core ingest.
When does the Rust ecosystem produce a recognized "persistent collections crate" the way Clojure has? im, rpds, archery, and imbl all exist but none has won — and the high-level-rust style materially depends on one. The C++ equivalent is also missing (no Boost.Persistent, no standardized champ container), which suggests the underlying language ergonomics aren't quite there yet in either ecosystem.
Does the functional-core-imperative-shell pattern need a Rust-specific refinement for cancellation-safe async code? The shell-is-thin assumption breaks when the shell is a long-running async task with structured cancellation (structured-concurrency, tokioJoinSet). A pure core that takes a snapshot and produces a delta is well-defined; threading that through cancellation-safe Stream machinery without losing the sandwich's testability isn't obviously solved — worth a focused page once a concrete source lands on it.
[2026-05-11] ingest | Modern C++ Design Patterns (C++23 and Beyond)
Source: Raw/C++/Modern C++ Design Patterns (C++23 and Beyond).md
Created (16 pages):
modern-cpp-design-patterns (source summary — the ten patterns, three philosophical shifts, C++26 as the bigger leap, convergence-with-Rust framing)
deducing-this — C++23 this auto&& explicit object parameters; CRTP killer; recursive lambdas trivial; collapses the four-way ref-qualified accessor overload set
std-expected — C++23 monadic Result type; and_then / transform / or_else; 1–2% overhead on success path vs 50–100× exception cost; the open frontier of context-attachment libraries
std-generator — C++23 coroutine-based lazy sequences; HALO heap-elision in Clang/GCC; the boilerplate-deleting case study
crtp — Curiously Recurring Template Pattern; historical CRTP page; the cases where it still wins (Eigen-style expression templates, sizeof-dependent layouts)
cpp-coroutines — the library-customizable coroutine machinery underlying generator and senders; cppcoro, folly::coro, libunifex, stdexec ecosystem
railway-oriented-programming — Wlaschin's metaphor; the cross-language consensus (Rust Result, C++ expected, Swift, Kotlin); the stack-trace trap and context-attachment problem
design-by-contract — Meyer/Eiffel lineage; the Liskov connection; refinement types as the static-proof alternative; the slow-uptake question
structured-concurrency — Nathaniel Smith's 2018 framing; "go statement considered harmful"; the implementations across Kotlin, Swift, Trio, Rust JoinSet, C++ senders
Updated (4 pages):
rust-error-handling — opened with cross-language convergence framing; std::expected mirror, shared open problem of pipeline context attachment
type-driven-development — added "cross-language convergence" section pairing each Rust technique with its C++23/26 counterpart; added C++ source
Key insight: C++23/26 is the C++ side of the same convergence Rust drove a decade ago. Read the ten patterns and the parallels are unmistakable — std::expected is Result<T, E>, std::generator is a Rust generator block, std::move_only_function is Box<dyn FnOnce>, std::visit + overloaded is match, contracts echo typestate/newtype discipline. The convergence is on the same answers (value semantics, sum types, monadic error flow, structured concurrency, compile-time metaprogramming) because those answers are correct. Each language retains a durable advantage: C++ ships zero overhead by default; Rust ships the borrow checker. Integrated as the closing framing of modern-cpp-design-patterns and as cross-language sections in type-driven-development and expert-rust-design.
Secondary insight: C++26 is the bigger leap than C++23. C++23 mostly refines (expected, generator, mdspan, move_only_function, if consteval); C++26 introduces categorical shifts — cpp26-static-reflection eliminates macro/codegen serialization, senders-receivers replaces the patchwork of std::async/std::future/executor-libraries with structured concurrency, cpp26-contracts adds Design-by-Contract as a language feature with optimizer integration. Together they pull C++ much closer to Rust/Swift/Kotlin in expressiveness while keeping its zero-overhead default.
Tertiary insight: CRTP is the cleanest "language feature retires a pattern" case study. Three decades of canonical idiom, taught as a C++ rite of passage, retired by a single C++23 feature (deducing-this) — with a small residual surface (Eigen-style expression templates, sizeof-dependent base layouts) where it still wins. This is the same lifecycle as auto_ptr → unique_ptr, callback-driven function pointers → lambdas/move_only_function, enable_if SFINAE → concepts. The lesson: durable C++ design lives in principles (zero-cost abstraction, static polymorphism, value semantics), and idioms come and go as the language absorbs the workarounds they represented.
Open questions:
When does the C++ analog of snafu / anyhow / error-stack emerge for std::expected? The error-context-attachment problem that Rust solved across 2018–2022 is the open frontier in C++ as of 2026. tl::expected lacks the idioms; P2952 extensions are not shipped.
Will inspect (P2688 pattern matching) land in C++29 as currently scheduled, and will it cleanly subsume the overloaded-visit-pattern? Early proposals look promising but the C++26 cutoff slip suggests further slippage is possible.
When does the third-party scheduler ecosystem for senders-receivers mature? io_uring senders, Asio interop, file I/O senders are not in the standard; libunifex and stdexec provide them but adoption is early. The structural similarity to shard-per-core Rust runtimes suggests a similar landscape of competing schedulers — worth tracking whether cuda::std::execution (the GPU showcase) drives convergence or fragmentation.
Does the cpp26-contracts optimizer-integration story hold up in production? The bet that cheap, optional, optimizer-aware contracts can clear the adoption bar that mandatory Eiffel-style contracts couldn't — early data is from 2027–2028.
How does the reflection-based serialization layer interact with C++ modules? Modules' translation-unit boundaries change reflection's reach across compilation units in subtle ways. The proposal addresses this but real-world implications won't be clear until both features ship and are exercised together.
[2026-05-08] ingest | The fastest linked lists ever built
intrusive-list — Linux kernel list.h pattern; 5–29× over std::list via zero allocation and shared cache lines; Linus removed prefetch() in 2.6.40 because hardware prefetchers were better
unrolled-linked-list — m elements per cache-line-sized node; 60% fewer misses, 2–4× traversal; concurrent variant (Platz et al. JPDC 2020) 300% over alternatives; DULL (OPODIS 2024) for persistent memory
vector-backed-list — index-based linking inside a std::vector; jsl::vector_list 7.8× with compaction; orx-linked-list 25× over Rust's std::collections::LinkedList; GlueList beats even ArrayList
slab-list — GPU warp-cooperative design (Ashkiani IPDPS 2018); 512M updates/s on Tesla K40c via coalesced 32-thread access
hazard-pointers — Maged Michael's bounded-memory reclamation; standardized in C++26; complement to EBR for stalled-thread tolerance
crystalline-reclamation — PLDI 2024; wait-free reclamation with bounded memory simultaneously, previously thought impossible
persistent-functional-list — singly-linked cons list with structural sharing; Haskell/Clojure backbone; lock-free reads via immutability; the rank-1 case of the persistent-collection design philosophy
Updates (4 pages):
fastest-data-structures — added linked-list and lock-free ordered linked list rows; refreshed sources
crossbeam-epoch — promoted from a paragraph to a full reclamation-landscape entry; added EBR-vs-hazard-pointers-vs-Crystalline trade-off table
michael-scott-queue — added "the bigger pattern" section pairing Michael-Scott with Harris as twin retraversal-on-CAS-failure designs both superseded by the same insight
mechanical-sympathy — added the 125× memory-layout benchmark as the cleanest single demonstration of the principle (identical code, identical algorithm, layout alone moves runtime 125×)
Index: added 10 new entries
Key insight: the fastest "linked lists" no longer look like linked lists. Every winner in the hierarchy — plf-list (block allocation), unrolled-linked-list (cache-line-sized array nodes), vector-backed-list (index-based linking inside a contiguous buffer), intrusive-list (pointers embedded in the data), slab-list (warp-aligned slabs) — fights the same fight: make node memory layout match access order. The 2024 "RIP Linked List" paper's ArrayBlock structure beats every linked-list variant even on benchmarks designed to favor linked lists. The "linked list" name is increasingly archaeological. Integrated as the central thread of fastest-linked-lists and reinforced in fastest-data-structures.
Secondary insight: memory reclamation is the dominant cost factor for lock-free linked structures, often beating the algorithmic cost. The 2024 Crystalline result — wait-free reclamation with bounded memory simultaneously — joins elastic-hashing and the optimistic-locking-beats-lock-freedom result as 2024–2026 "settled lower bound was wrong" results. C++26 standardizing hazard-pointers is the production-side counterpart: a primitive long confined to per-runtime libraries is now in the standard. Integrated into crossbeam-epoch as a full landscape page.
Tertiary insight: the same retraversal-on-CAS-failure weakness defines both Michael-Scott and Harris — the queue and the ordered-set instances of the lock-free linked list. Both got fixed by the same insight: replace contended CAS with fetch_and_add (LCRQ for queues) or fetch_or (Träff-Pöter for ordered sets). The structural symmetry deepens faa-vs-cas as the dominant lever in concurrent linked-shape design.
Open questions:
When does Crystalline reach production runtimes? folly, JCTools, and crossbeam are the natural integration points; the algorithm is published, the integration work is the bottleneck.
Will Linus's "no software prefetch" rule for kernel list.h hold against Linkey (2025)? Linkey uses compiler-provided structural hints rather than naive prefetch — the failure mode that motivated the 2.6.40 removal is exactly what Linkey claims to fix.
Does the Harris-Träff-Pöter design family port cleanly to Rust? crossbeam-skiplist exists but a full Träff-Pöter ordered concurrent linked list does not — the gap mirrors the missing Rust lcrq / wcq ports.
For persistent functional lists specifically, do modern allocators (mimalloc, jemalloc) close the gap to contiguous structures enough that pure-functional code is competitive on cache-bound traversal? The traditional answer is no; the allocator-dominates-container insight from the 2026-05-04 ingest suggests it's worth re-measuring.
[2026-05-08] ingest | The fastest ordered maps in computer science
Source: Raw/Fastest CS/The fastest ordered maps in computer science.md
algorithmica-s-tree — Slotin's reference SIMD B-tree; 7–18× over std::set in <150 lines C++; AVX2 branchless intra-node search, compile-time height, hugepages
bs-tree — ICDE 2026 AVX-512 B-tree; 16 keys/node in 2 instructions; gapped nodes for branchless updates (lifts the static-only restriction)
fb-plus-tree — VLDB 2025 SIMD B+-tree for variable-length keys via byte-wise prefix matching with AVX-512
bp-tree — VLDB 2023 concurrent B+-tree with OLC; 7.4× Masstree on points, 30× on range scans
art-olc — ART with optimistic lock coupling; 4.8× fewer instructions and 3.6× fewer L3 misses than lock-coupled B+-trees; readers never write shared cache lines
congee — Rust port of ART-OLC; 150 Mops/sec on 32 cores; closest Rust gets to global concurrent-ordered-map frontier
masstree — trie-of-B+-trees; cache-craftiness readers; best for string keys at high contention; 6–10 Mops/sec on 16 cores YCSB
bw-tree — lock-free B+-tree (MSR ICDE 2013); 1.5–4.5× slower than alternatives because lock-freedom ≠ cache-coherence-freedom; the 2018 OpenBw-Tree result
hot-trie — Height Optimized Trie (Binna et al., SIGMOD 2018); varies bits per node by distribution; beats ART/B-tree/Masstree on string keys
cuckoo-trie — 2021 trie exploiting memory-level parallelism for 20–360% gains via independent miss streams
b-epsilon-tree — fractal tree index; 32× fewer write I/Os than B-trees; TokuDB lineage; principle survives in LSM variants
b-tree — promoted from a paragraph-and-table page to a full ordered-map landscape entry; added SIMD-tier hierarchy, concurrent variants section, write-optimized variants section, decision guide
adaptive-radix-tree — added O(k) lookup framing as the defining property; concurrent ART-OLC section; HOT/Cuckoo Trie/learned-index frontier; expanded comparisons
Updates (5 pages):
learned-indexes — added LITS (2024) for learned models on HOT tries (2.4× over HOT) — current frontier for learned string indexing
fastest-data-structures — refreshed ordered-container row to point to BS-tree/Algorithmica S+; added concurrent-ordered-map row; added "optimistic readers that never write shared memory" as a fifth core principle alongside FAA-over-CAS
swiss-table — wikified BS-tree and FB+-tree as further demonstrations of SIMD-parallel scanning beyond hash maps
cache-oblivious-structures — added explicit "tuned cache-conscious beats cache-oblivious in practice" note; added Bε-tree as the parameterized COLA descendant
rust-concurrent-data-structures — added concurrent ordered maps section anchored on Congee; positioned C++ frontier (BP-Tree, Masstree, ART-OLC) for context
Index: added 13 new entries; revised b-tree, adaptive-radix-tree descriptions
Key insight: lock-freedom is not cache-coherence-freedom. The lock-free bw-tree loses 1.5–4.5× to lock-using designs because every CAS dirties a shared cache line, generating coherence traffic that dwarfs the cost of the locks it avoids. art-olc and masstree win precisely because their version-counter readers write nothing to shared memory. This is the same insight behind rcu (zero read-side overhead), FAA-over-CAS in queues (FAA's success-on-first-try beats CAS retry), and swiss-table's read-only metadata scans. Integrated as a fifth core principle in fastest-data-structures and as a recurring thread across the new concurrent-ordered-map pages.
Secondary insight: the practical winners are all the same recipe. SIMD-parallel intra-node scanning + cache-line-sized contiguous nodes + branch elimination produces the entire Tier 1 list — Algorithmica S+, BS-tree, FB+-tree — and the 7–18× gap to red-black trees is fully explained by ~6× fewer cache misses, ~3× more keys per cycle, and ~10× fewer branch mispredictions. The theoretical sub-logarithmic structures (Van Emde Boas, fusion trees) lose because their constants drown in the 100 ns reality of a single cache miss. Integrated into fastest-ordered-maps and reinforced in b-tree.
Tertiary insight: memory-level parallelism is an under-used lever. The cuckoo-trie gets 20–360% over state-of-the-art by issuing independent memory accesses per lookup rather than serializing them through pointer chasing. Most published indexes assume the cost model is "instructions" or "cache lines touched," but on real hardware the cost is closer to "longest dependency chain of misses." The same observation explains why swiss-table group probing and LCRQ FAA producers beat their dependency-chained alternatives.
Open questions:
When does a Rust port of BP-Tree or masstree arrive? congee covers the integer-keyed point-op tier but the Rust ecosystem has no equivalent for range-scan-heavy or string-keyed concurrent ordered workloads.
Will LITS (learned models on HOT) hold up under broader benchmarking? 2.4× over HOT is striking; if it survives independent reproduction, it suggests learned indexing applies more broadly than the original numerical-key work indicated.
Does the BS-tree's gapped-node design extend cleanly to concurrent operation? The gap reservation is exactly the kind of slot that an OLC-style concurrent insert wants — there's a natural composition with art-olc's reader-version protocol.
What is AMD's answer to Intel CLDEMOTE? With 3D V-Cache pushing L3 to 96–128 MB, the boundary between "fits in L3" and "spills to DRAM" is moving — but only Intel currently has an instruction to actively place data in shared cache.
[2026-05-07] ingest | The fastest ways to talk between threads
Source: Raw/Fastest CS/The fastest ways to talk between threads.md
Created (9 pages):
inter-thread-communication (source summary — full latency hierarchy from 16 ns hardware floor to 50 µs scheduler wake)
synchronization-primitives — the cost ladder; futex fast path 25 ns vs slow path 5 µs; eventfd is slower than UNIX sockets
flat-combining — Hendler-Incze-Shavit-Tzafrir 2010; combiner thread batches operations; antidote to CAS retry meltdown
core-pinning — taskset, isolcpus, SCHED_FIFO, disable SMT; cuts P99.9 from 120 µs to 30 µs; full HFT recipe
mechanical-sympathy — Martin Thompson's design philosophy; Java 50 ns vs C++ 45 ns proves language barely matters at this layer
memory-ordering — x86 TSO vs ARM relaxed; acquire/release free on x86; DMB ~10–20 ns on ARM; PAUSE vs YIELD vs WFE per arch
huge-pages — 2 MB / 1 GB pages; 32× / 16,384× more address space per TLB entry; THP vs explicit hugetlb; allocator integration
kernel-bypass — DPDK pattern; 5 µs UDP vs 9 µs kernel; same principles as inter-thread (poll-mode, pre-alloc, pinning)
busy-spin — PAUSE instruction; 15× generational variance on Intel (9 cycles Broadwell → 140 cycles Skylake); ARM YIELD vs Apple WFE
Updated (7 pages):
cache-coherency — added topology table (Zen 3 16 ns vs Sapphire Rapids 150 ns), MESIF/MOESI distinction, CLDEMOTE 7.3→22 GB/s data point, hyperthread 16.5 ns figure
spsc-queue — added Lamport 1977 lineage in opener, Erik Rigtorp attribution for cached indices (5.5M → 112M ops/s), huge-page backing section
lmax-disruptor — wikified mechanical-sympathy section, added Java vs C++ ping-pong (50 ns vs 45 ns) section establishing language convergence
faa-vs-cas — added Schweizer-Besta-Hoefler ETH Zurich finding that CAS/FAA/swap have identical instruction latency (6 vs 7 ns); the gap is semantic
rtrb — added cross-language section noting essentially identical machine code to C++ and JCTools; safety not speed is Rust's edge
kanal — added Go channels comparison (5–10× faster than Go chan); language-level features add fixed costs
Index: added 9 new entries
Key insight: topology trumps algorithm — the same SPSC ring buffer varies 5–10× in latency depending on whether threads share an L3 cache (16 ns) or cross an interconnect fabric (107 ns AMD, 150 ns cross-socket Intel). The single highest-leverage optimization in any inter-thread system is taskset, not the queue choice. Integrated as a recurring thread across core-pinning, cache-coherency, inter-thread-communication, and mechanical-sympathy.
Secondary insight: the synchronization cost ladder spans six orders of magnitude, but the boundary that matters is between Level 2 (userspace futex fast path, 25 ns) and Level 3 (syscall, 5 µs) — a 50× cliff. Modern adaptive mutexes (>80% userspace completion) make std::mutex faster than folklore suggests. Surprising data: eventfd (4,353 ns) is slower than UNIX domain sockets (1,439 ns) for thread signaling.
Tertiary insight: languages converge at the hardware. Java volatile 50 ns vs C++ atomic 45 ns is rounding error compared to the 100× cost of a single mechanical-sympathy violation. The lmax-disruptor beats most C/C++ queues from Java by aligning every decision with the cache coherence protocol.
Open questions:
Will Apple Silicon's WFE/SEV pattern get more ergonomic library support? Current Rust spin_loop() emits YIELD rather than WFE — for long waits, that's leaving power and latency on the table.
Does Intel's CLDEMOTE (Sapphire Rapids+) get an AMD equivalent? The 3× core-to-core bandwidth boost from one instruction is significant; AMD's silence on this is conspicuous.
For Rust specifically, is there a path to a futex(2)-aware adaptive mutex matching glibc's? parking_lot is close but lacks the per-CPU adaptive spin tuning glibc 2.35+ has.
Where does ARM's relaxed memory ordering actually cost in real benchmarks? The DMB ~10–20 ns figure suggests up to 30% overhead in tight atomic loops, but published cross-architecture inter-thread benchmarks remain rare.
[2026-05-06] ingest | The fastest queue in all of computer science
Source: Raw/Fastest CS/The fastest queue in all of computer science.md
Created (22 pages):
the-fastest-queue (source summary — 2025 hierarchy from SPSC ring buffer to LCRQ+Funnels)
lcrq — Linked Concurrent Ring Queue (Morrison & Afek, PPoPP 2013); FAA-on-a-ring; 3× over Michael-Scott
aggregating-funnels — software FAA combining (PPoPP 2025); up to 2.5× over plain LCRQ at high thread counts
elimination-backoff-stack — Hendler-Shavit-Yerushalmi 2004; matches push/pop in randomized array; 100K+ ops/msec at 64 threads
(no separate page for Cyclic Memory Protection — mentioned inline in mpmc-queue and the-fastest-queue as a 2025 preprint)
Major rewrites (2 pages):
concurrent-queues — promoted from thin survey to full 2025 hierarchy with MPMC table, SPSC tier, ecosystem tables, specialized contexts, stacks
lmax-disruptor — refreshed comparisons; positioned as "bounded pipeline tail-latency king" rather than throughput king (ceded to LCRQ+Funnels); 128-byte rule integrated; cross-links throughout
Updates (5 pages):
kanal — added throughput-in-global-context paragraph; channel ≠ queue distinction; pointers to bare-queue alternatives
cache-coherency — integrated FAA-vs-CAS as a cache-coherence story; corrected 64-byte → 128-byte padding guidance
fastest-data-structures — added MPMC and SPSC queue rows; added FAA-vs-CAS as a fourth core principle; refreshed default-stack
rust-concurrent-data-structures — added bare-queues table; "where Rust sits globally for queues" paragraph noting absence of native LCRQ port
Index: added 22 new entries; refreshed 2 descriptions
Key insight: the FAA-over-CAS principle is the dominant lever in concurrent queue design from 2013 onward, and the throughput improvements since then have come from chipping away at FAA's own limits — first by making it portable (SCQ, LPRQ), then wait-free (wCQ), and most recently by software-combining the FAA itself (aggregating-funnels). Combined with the 128-byte cache-line rule and SPSC topology privilege, this fully accounts for the ~7× gap between modern queues and the 1996 michael-scott-queue still in many standard libraries. Integrated as a recurring thread across the new pages and into fastest-data-structures as a fourth core principle alongside SIMD-parallel scanning, contiguous layouts, and branch elimination.
Open questions:
Will a native Rust port of LCRQ / SCQ / LPRQ appear? The ecosystem gap is significant for >32-thread MPMC workloads; nothing in crossbeam-queue matches LCRQ-class throughput. The closest current path is crossbeam-epoch plus a custom implementation.
Does the November 2025 "No Cords Attached" CMP preprint hold up under peer review? 6.49M items/s with coordination-free reclamation is striking; if it survives, it could displace crossbeam-epoch for some use cases.
Will aggregating-funnels be plugged into lprq / wcq? The combining technique is independent of the underlying queue; combining it with wait-freedom would be a significant theoretical result.
Does the 128-byte cache-line rule hold on Apple Silicon and ARM server chips? The source emphasizes x86 adjacent-line prefetching — ARM behavior may differ enough to change the optimal padding.
[2026-05-04] ingest | The fastest dynamic arrays in computer science
Source: Raw/Fastest CS/The fastest dynamic arrays in computer science.md
Created (16 pages):
fastest-dynamic-arrays (source summary — the hierarchy from C+realloc through fbvector down to Java/Python)
Key insight: the allocator dominates the container. C, Rust, and C++ vectors all land within ~10% of each other, but switching glibc → jemalloc/mimalloc moves benchmarks 2-3×. This recontextualizes much of the previous "fastest hash map" / "fastest data structure" hierarchy — and integrates as a recurring thread across mimalloc, jemalloc, fastest-data-structures, and rust-memory-allocators.
Open questions:
When will P1144 (trivial relocatability) actually land in C++? Once it does, the std::vector vs fbvector gap closes substantially.
Project Valhalla in Java has been promised for over a decade — does it close the boxing gap meaningfully when it ships?
Does the realloc/mremap advantage hold on macOS and Windows, or is it Linux-specific? The source emphasizes Linux but doesn't characterize the others.
For containers-of-containers in Rust, is Vec<SmallVec<...>> actually beaten by Vec<Vec<...>> once mimalloc is in play?
[2026-04-29] ingest | The fastest hash map in computer science, 2025
Source: Raw/Fastest CS/The fastest hash map in computer science, 2025.md
Created (10 pages):
fastest-hash-map-2025 (source summary — 2025 hash map landscape across single-threaded, concurrent, and theoretical frontiers)
boost-unordered-flat-map — 2025 consensus winner; overflow byte vs Abseil's tombstones; 3.2× fewer comparisons on negative lookup
Key insight: the hash function often matters more than the hash table — switching SipHash → foldhash in Rust beats any single table-level optimization. This was integrated as a recurring thread across hashbrown, foldhash, rapidhash, swiss-table, and the source summary.
Open questions:
Will elastic/funnel hashing produce a benchmark-competitive implementation, or will the constants prevent it from displacing Swiss Tables? Worth tracking attractivechaos and Jackson Allan benchmark suites for elastic-hashing entries.
Does Rust have a path to a ParlayHash-class concurrent map (epoch-based reclamation + parallel internal ops)? Crossbeam-epoch provides the foundation; nothing currently composes it with parlaylib-style internal parallelism.
When does FrozenDictionary's break-even (5K–630K reads) get exceeded in practice? Worth measuring on real config-loading workloads.
[2026-04-17] ingest | The fastest data structures in computer science, benchmarked
Source: Raw/Fastest CS/General.md
Created (19 pages):
fastest-data-structures (source summary — benchmarked survey of 10 data structure categories)