A lock-free, single-producer single-consumer (SPSC) byte channel backed by a flat arena buffer. Designed for nanosecond-scale inter-thread communication where every cache miss counts.

• Zero-copy reads — consumer callback borrows directly from the arena; no intermediate allocation or copy
• Single atomic publish — one Release store on the write position completes a send
• Cache-line isolation — write_pos and read_pos live on separate 64-byte-aligned cache lines to eliminate false sharing
• Inline variable-length messages — [len: u32][data][padding] layout; no fixed-slot waste for mixed-size workloads
• Scatter-gather send — send_parts(header, payload) writes two slices into one arena slot with no temp buffer
• Non-blocking try_recv — poll-friendly try_recv() for multiplexing multiple channels
• THP + pre-fault — Linux allocations use mmap with MADV_HUGEPAGE and touch every page at init to eliminate runtime page-fault jitter
• Cross-platform prefetch — PREFETCHT0 on x86_64, PRFM PLDL1KEEP on aarch64
• CPU pinning — built-in pin_to_core() for Linux (sched_setaffinity) and macOS (thread_policy_set)

Add to your Cargo.toml:

[dependencies]
arena-spsc = "0.1.0"

use arena_spsc::{channel, spin_pause};
use std::sync::{Arc, Barrier};

let (mut producer, mut consumer) = channel(2 * 1024 * 1024);
let start = Arc::new(Barrier::new(2));
let start_c = Arc::clone(&start);

let worker = std::thread::spawn(move || {
    let mut received = Vec::new();
    start_c.wait();
    while received.len() < 2 {
        consumer.recv_spin(|data| {
            received.push(data.to_vec());
        });
    }
    received
});

start.wait();
while !producer.send(b"hello") { spin_pause(); }
while !producer.send(b"world") { spin_pause(); }

let received = worker.join().unwrap();
assert_eq!(received, vec![b"hello".to_vec(), b"world".to_vec()]);

GitHub Actions now runs cargo test --all-targets --locked on pull requests and pushes to main.

To publish to crates.io automatically:

1. Add a repository secret named CARGO_REGISTRY_TOKEN with your crates.io API token.
2. Bump version in Cargo.toml.
3. Push a matching Git tag such as v0.1.0.

git tag v0.1.0
git push origin main --follow-tags

 ┌──────────────────────────── arena (power-of-2, ≥ 2 MiB) ────────────────────────────┐
 │ [len=48][data··pad]  [len=120][data·····pad]  [len=0 wrap]  [len=64][data··pad] ...  │
 │ ◄── 64B aligned ──►  ◄──── 128B aligned ────►              ◄── 64B aligned ──►      │
 └──────────────────────────────────────────────────────────────────────────────────────-┘
         ▲ read_pos                                                    ▲ write_pos

• Each slot: [len: u32][payload][zero-padding to 64B boundary]
• len = 0 is the wrap sentinel — consumer jumps back to offset 0
• Power-of-2 capacity enables offset = pos & (capacity - 1) (no modulo)

The producer caches read_pos locally and only refreshes it when the arena appears full, amortizing atomic loads on the hot path.

All benchmarks were run on the following hardware:

CPU: Intel Xeon Platinum 8375C @ 2.90 GHz (8 cores / 16 threads) RAM: 123 GB  |  OS: Amazon Linux 2 (kernel 4.14) Rust: 1.90.0  |  Profile: lto = true, opt-level = 3, codegen-units = 1

500K messages per iteration, 50 samples, producer and consumer pinned to separate cores.

small60/60B — fixed 60-byte messages (arena-spsc sweet spot: 4B header + 60B = 64B, one cache line, zero padding):

small/64B — fixed 64-byte messages (worst case for arena-spsc: 4B header + 64B = 128B, wastes 60B padding per message):

mixed/128–512B — variable-length messages (exposes fixed-slot padding waste):

Throughput insight: Arena-spsc's performance depends heavily on how well message sizes align to 64B cache-line boundaries. At 60B (4B header + 60B = exactly 64B), it leads all competitors by 2.4x. At 64B (4B + 64B = 128B, 47% wasted), fixed-slot queues like rtrb/ringbuf have the advantage since their slot size matches the message size exactly. In mixed/variable-length workloads — the real-world scenario — arena-spsc dominates because fixed-slot queues must allocate worst-case slots for every message.

Per-message latency sampled every Nth message. Burst mode sends 100M messages at full speed; paced mode rate-limits to 1 msg/μs (1M msg/s).

Burst mode (100M messages, sample every 1000th):

Paced mode (5M messages at 1 msg/μs, sample every 100th):

All values in nanoseconds.

Key takeaway: arena-spsc delivers the tightest p99 tail latency across both modes — its p99-to-p50 spread is only ~100ns in paced mode, compared to 200ns+ for alternatives. This is the payoff from single-atomic-store publishing and batch-drain consuming.

Compares zero-copy send_parts(header, payload) vs allocating a Vec, concatenating, then sending.

send_parts is 4.3x faster — the difference is one heap allocation + memcpy per message.

Fixed-slot queues like rtrb and ringbuf store elements in a tightly-packed [T; N] array with no alignment padding. Performance depends on whether sizeof(T) happens to be a multiple of the cache line size (64 bytes):

[u8; 64] — slot = 64B = cache line size (lucky alignment)

  cache line 0          cache line 1          cache line 2
  ├───────────────────┤├───────────────────┤├───────────────────┤
  │    element 0       ││    element 1       ││    element 2       │
  │     64 bytes       ││     64 bytes       ││     64 bytes       │
  └────────────────────┘└────────────────────┘└────────────────────┘
  Every element fits in exactly one cache line ✓


[u8; 60] — slot = 60B ≠ multiple of 64 (cache line straddling)

  cache line 0          cache line 1          cache line 2
  ├───────────────────┤├───────────────────┤├───────────────────┤
  │  element 0  │elem 1▐▐ element 1│elem 2 ▐▐ element 2│elem 3 ▐
  │   60 bytes  │ 4B   ▐▐  56B     │ 8B    ▐▐  52B     │ 12B   ▐
  └─────────────┴──────┘└──────────┴───────┘└──────────┴───────┘
                ▲                   ▲                    ▲
            straddling!         straddling!           straddling!

  Only 1 in 16 elements is cache-line aligned (LCM(60,64)/60 = 16)
  → 93.75% of elements straddle two cache lines
  → every read/write touches 2 cache lines instead of 1

Arena-spsc is immune to this because every message is padded to a 64B boundary by design, not by coincidence:

arena-spsc — 60B message → align64(4 + 60) = 64B slot

  cache line 0          cache line 1          cache line 2
  ├───────────────────┤├───────────────────┤├───────────────────┤
  │ len│ 60B payload    ││ len│ 60B payload    ││ len│ 60B payload    │
  │ 4B │               ││ 4B │               ││ 4B │               │
  └────┴───────────────┘└────┴───────────────┘└────┴───────────────┘
  Always one cache line per message, regardless of payload size ✓

The 64B throughput numbers for rtrb/ringbuf are a coincidence — they happen to work because sizeof([u8; 64]) == cache line size. Arena-spsc's alignment is a design guarantee that holds for any message size.

# Throughput (500K messages × 50 samples)
cargo bench --bench throughput

# Per-message latency — burst & paced modes
cargo bench --bench latency

# send_parts vs concat-then-send
cargo bench --bench send_parts

This channel is purpose-built for pinned-core, spin-wait, nanosecond-budget pipelines:

The key decision factor is data lifetime after receipt:

Packet arrives from NIC
  ├─ Process synchronously in callback, discard → arena-spsc ✓
  └─ Retain / forward / fan-out / async process  → Bytes + channel ✓

Use arena-spsc when the consumer completes all work inside the callback:

consumer.recv_spin(|pkt| {
    let msg = parse(pkt);
    order_book.apply(msg);  // done — pkt is not retained
});

Use Bytes + channel when data must outlive the receive call:

let bytes = Bytes::copy_from_slice(&raw_pkt);
tx.send(bytes.clone()).unwrap();  // refcount bump, zero-copy fan-out

All platforms pre-fault the arena at creation time to eliminate runtime page faults.

// Create a channel (arena_capacity must be power-of-2, ≥ 2 MiB)
let (mut producer, mut consumer) = arena_spsc::channel(64 * 1024 * 1024);

// Send a single message (returns false if arena is full)
producer.send(b"payload");

// Send header + payload as one message, zero intermediate allocation
producer.send_parts(b"header", b"payload");

// Non-blocking receive — returns true if at least one message was processed
consumer.try_recv(|data: &[u8]| { /* process data */ });

// Busy-wait receive — spins until data is available, then drains the batch
consumer.recv_spin(|data: &[u8]| { /* process data */ });

// Infinite receive loop
consumer.run(|data: &[u8]| { /* process data */ });

// Pin current thread to a CPU core
arena_spsc::pin_to_core(0);

// Spin-loop hint (PAUSE on x86_64, YIELD on aarch64)
arena_spsc::spin_pause();

Licensed under the MIT License.