bench(shm): add shm_pool criterion benchmark

Measures the two steady-state paths of ShmSegmentPool:

  alloc/cold/1MB  ~314 µs  shm_open+ftruncate+mmap+mlock per alloc
  alloc/warm/1MB  ~134 ns  ArrayQueue pop+push (two CAS, no syscalls)

Ratio: ~2300x. Demonstrates what pool reuse eliminates on the hot
publish path at 1 MB payload size.

Author: YuanYuYuan

commons/zenoh-shm/Cargo.toml

@@ -60,7 +60,12 @@ win-sys = { workspace = true }
 winapi = { workspace = true }
 
 [dev-dependencies]
+criterion = { workspace = true }
 libc = { workspace = true }
 
+[[bench]]
+name = "shm_pool"
+harness = false
+
 [build-dependencies]
 cfg_aliases = "0.2.1"

commons/zenoh-shm/benches/shm_pool.rs

@@ -0,0 +1,121 @@
+//
+// Copyright (c) 2026 ZettaScale Technology
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+// which is available at https://www.apache.org/licenses/LICENSE-2.0.
+//
+// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+//
+// Contributors:
+//   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
+//
+
+//! Benchmark: SHM segment pool reuse vs. cold allocation.
+//!
+//! # What is measured
+//!
+//! `alloc/cold` — cost of creating a fresh 1 MB SHM segment:
+//!   `shm_open + ftruncate + mmap + mlock` (+ `munmap + shm_unlink` on drop).
+//!   This is the per-message cost WITHOUT pool reuse — paid on every alloc
+//!   when the pool is disabled or on a pool miss (new size / pool full).
+//!
+//! `alloc/warm` — cost of a pool hit after warmup:
+//!   `ArrayQueue::pop` on alloc, `ArrayQueue::push` on drop.
+//!   No kernel calls on the hot path.
+//!
+//! # Interpreting results
+//!
+//! The ratio cold/warm shows how much kernel overhead the pool amortizes.
+//! For 1 MB at 100 Hz with N streams, the cold path would impose:
+//!   N × 100 × cold_cost µs of mmap overhead per second.
+//! With the pool that collapses to N × 100 × warm_cost, paid in CAS cycles only.
+//!
+//! System-level latency impact (ping-pong benchmarks at 100 Hz / 1 MB):
+//!   1 stream: p50 ≈ 2.6 ms → pool has no visible effect (mmap amortised at low rate)
+//!   4 streams: p50 ≈ 4.5 ms → ~16% improvement (contention path exposed)
+//!
+//! Run with:
+//!   cargo bench --bench shm_pool -p zenoh-shm
+
+use std::time::{Duration, Instant};
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use zenoh_core::Wait;
+use zenoh_shm::api::{
+    protocol_implementations::posix::posix_shm_provider_backend_talc::{
+        PosixShmProviderBackendTalc, ShmPoolConfig,
+    },
+    provider::{
+        memory_layout::MemoryLayout, shm_provider_backend::ShmProviderBackend,
+        types::AllocAlignment,
+    },
+};
+
+const PAYLOAD_SIZE: usize = 1024 * 1024; // 1 MB
+
+fn make_layout() -> MemoryLayout {
+    MemoryLayout::new(PAYLOAD_SIZE, AllocAlignment::default()).unwrap()
+}
+
+/// Cold path: a new SHM segment is created for each alloc.
+///
+/// Uses a fresh pool backend per iteration so the pool is always empty and
+/// `alloc` falls through to `PosixShmSegment::create` (shm_open + mmap).
+fn bench_cold(c: &mut Criterion) {
+    let layout = make_layout();
+    let mut group = c.benchmark_group("alloc");
+    group.throughput(Throughput::Elements(1));
+
+    group.bench_function(BenchmarkId::new("cold", "1MB"), |b| {
+        b.iter_custom(|iters| {
+            let mut total = Duration::ZERO;
+            for _ in 0..iters {
+                // Fresh backend every iter → pool always starts empty → alloc is cold.
+                let backend = PosixShmProviderBackendTalc::builder_with_pool(
+                    PAYLOAD_SIZE,
+                    ShmPoolConfig::default(),
+                )
+                .wait()
+                .expect("backend create failed");
+                let start = Instant::now();
+                let chunk = backend.alloc(&layout).expect("alloc failed");
+                drop(chunk);
+                total += start.elapsed();
+                // backend drops here, cleaning up the backing segment
+            }
+            total
+        });
+    });
+
+    group.finish();
+}
+
+/// Warm path: pool holds a cached segment; alloc = one ArrayQueue::pop CAS,
+/// free = one ArrayQueue::push CAS. No syscalls.
+fn bench_warm(c: &mut Criterion) {
+    let backend =
+        PosixShmProviderBackendTalc::builder_with_pool(PAYLOAD_SIZE, ShmPoolConfig::default())
+            .wait()
+            .expect("failed to create pool backend");
+    let layout = make_layout();
+
+    // Warm the pool: first alloc creates the segment; drop returns it to the queue.
+    drop(backend.alloc(&layout).expect("warmup alloc failed"));
+
+    let mut group = c.benchmark_group("alloc");
+    group.throughput(Throughput::Elements(1));
+
+    group.bench_function(BenchmarkId::new("warm", "1MB"), |b| {
+        b.iter(|| {
+            let chunk = backend.alloc(&layout).expect("alloc failed");
+            drop(chunk); // returns segment to pool → available for next iter
+        });
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_cold, bench_warm);
+criterion_main!(benches);

commons/zenoh-shm/src/api/protocol_implementations/posix/posix_shm_provider_backend_talc.rs

@@ -56,7 +56,9 @@ pub struct ShmPoolConfig {
 
 impl Default for ShmPoolConfig {
     fn default() -> Self {
-        Self { max_idle_per_size: 8 }
+        Self {
+            max_idle_per_size: 8,
+        }
     }
 }
 
@@ -108,7 +110,10 @@ impl PosixShmProviderBackendTalc {
     /// pre-allocated SHM segment is used.
     #[zenoh_macros::unstable_doc]
     pub fn builder<Layout>(layout: Layout) -> PosixShmProviderBackendTalcBuilder<Layout> {
-        PosixShmProviderBackendTalcBuilder { layout, pool_config: None }
+        PosixShmProviderBackendTalcBuilder {
+            layout,
+            pool_config: None,
+        }
     }
 
     /// Get the builder to construct a new instance with segment pooling enabled.
@@ -180,12 +185,19 @@ impl ShmProviderBackend for PosixShmProviderBackendTalc {
                 );
                 seg
             } else {
-                Arc::new(PosixShmSegment::create(layout.size()).map_err(|_| ZAllocError::OutOfMemory)?)
+                Arc::new(
+                    PosixShmSegment::create(layout.size()).map_err(|_| ZAllocError::OutOfMemory)?,
+                )
             };
 
             // SAFETY: elem_mut(0) is always valid for a freshly-created or freshly-pooled segment.
             let buf = unsafe { NonNull::new_unchecked(segment.segment.elem_mut(0)) };
-            return Ok(segment.allocated_chunk_pooled(buf, layout, Arc::downgrade(pool), layout.size()));
+            return Ok(segment.allocated_chunk_pooled(
+                buf,
+                layout,
+                Arc::downgrade(pool),
+                layout.size(),
+            ));
         }
 
         // Traditional Talc sub-allocation path (no pool configured).

commons/zenoh-shm/src/api/protocol_implementations/posix/posix_shm_segment.rs

@@ -12,7 +12,11 @@
 //   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
 //
 
-use std::{num::NonZeroUsize, ptr::NonNull, sync::{Arc, Weak}};
+use std::{
+    num::NonZeroUsize,
+    ptr::NonNull,
+    sync::{Arc, Weak},
+};
 
 use zenoh_result::ZResult;
 

commons/zenoh-shm/src/posix_shm/pooled_segment.rs

@@ -36,7 +36,11 @@ pub(crate) struct PooledPosixShmSegment {
 }
 
 impl PooledPosixShmSegment {
-    pub(crate) fn new(inner: Arc<PosixShmSegment>, size: NonZeroUsize, pool: Weak<ShmSegmentPool>) -> Self {
+    pub(crate) fn new(
+        inner: Arc<PosixShmSegment>,
+        size: NonZeroUsize,
+        pool: Weak<ShmSegmentPool>,
+    ) -> Self {
         Self { inner, size, pool }
     }
 }

commons/zenoh-shm/tests/posix_shm_provider.rs

@@ -215,7 +215,9 @@ fn shm_segment_pool_reuse() {
 
     let backend = PosixShmProviderBackendTalc::builder_with_pool(
         layout.size(),
-        ShmPoolConfig { max_idle_per_size: 1 },
+        ShmPoolConfig {
+            max_idle_per_size: 1,
+        },
     )
     .wait()
     .expect("Error creating pooled PosixShmProviderBackendTalc");
@@ -245,7 +247,9 @@ fn shm_segment_pool_cap_enforcement() {
 
     let backend = PosixShmProviderBackendTalc::builder_with_pool(
         layout.size(),
-        ShmPoolConfig { max_idle_per_size: 1 },
+        ShmPoolConfig {
+            max_idle_per_size: 1,
+        },
     )
     .wait()
     .expect("Error creating pooled PosixShmProviderBackendTalc");
@@ -257,14 +261,19 @@ fn shm_segment_pool_cap_enforcement() {
     let seg_b = chunk_b.descriptor.segment;
 
     // They should be distinct segments.
-    assert_ne!(seg_a, seg_b, "Expected two distinct segments for two concurrent allocs");
+    assert_ne!(
+        seg_a, seg_b,
+        "Expected two distinct segments for two concurrent allocs"
+    );
 
     // Drop both — pool can hold at most 1, so one is immediately unmapped.
     drop(chunk_a);
     drop(chunk_b);
 
     // The next allocation should return one of the two segments (whichever was retained).
-    let chunk_c = backend.alloc(&layout).expect("alloc c after cap test failed");
+    let chunk_c = backend
+        .alloc(&layout)
+        .expect("alloc c after cap test failed");
     let seg_c = chunk_c.descriptor.segment;
 
     // seg_c must be one of the two previously-seen IDs (pooled), not a fresh one.
@@ -282,12 +291,10 @@ fn shm_segment_pool_outlived_by_segment() {
     let layout = MemoryLayout::new(4096_usize, AllocAlignment::default()).unwrap();
 
     let chunk = {
-        let backend = PosixShmProviderBackendTalc::builder_with_pool(
-            layout.size(),
-            ShmPoolConfig::default(),
-        )
-        .wait()
-        .expect("Error creating pooled PosixShmProviderBackendTalc");
+        let backend =
+            PosixShmProviderBackendTalc::builder_with_pool(layout.size(), ShmPoolConfig::default())
+                .wait()
+                .expect("Error creating pooled PosixShmProviderBackendTalc");
 
         let chunk = backend.alloc(&layout).expect("alloc failed");
         // backend (and its Arc<ShmSegmentPool>) drops here