From 0ca48453a067c7862f0bb6b85f152da826f59af7 Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Tue, 20 Jan 2026 22:25:41 +0100 Subject: lib: Replace rdrbuff with a proper slab allocator MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This is a first step towards the Secure Shared Memory (SSM) infrastructure for Ouroboros, which will allow proper resource separation for non-privileged processes. This replaces the rdrbuff (random-deletion ring buffer) PoC allocator with a sharded slab allocator for the packet buffer pool to avoid the head-of-line blocking behaviour of the rdrb and reduce lock contention in multi-process scenarios. Each size class contains multiple independent shards, allowing parallel allocations without blocking. - Configurable shard count per size class (default: 4, set via SSM_POOL_SHARDS in CMake). The configured number of blocks are spread over the number of shards. As an example: SSM_POOL_512_BLOCKS = 768 blocks total These 768 blocks are shared among 4 shards (not 768 × 4 = 3072 blocks) - Lazy block distribution: all blocks initially reside in shard 0 and naturally migrate to process-local shards upon first allocation and subsequent free operations - Fallback with work stealing: processes attempt allocation from their local shard (pid % SSM_POOL_SHARDS) first, then steal from other shards if local is exhausted, eliminating fragmentation while maintaining low contention - Round-robin condvar signaling: blocking allocations cycle through all shard condition variables to ensure fairness - Blocks freed to allocator's shard: uses allocator_pid to determine target shard, enabling natural load balancing as process allocation patterns stabilize over time Maintains existing robust mutex semantics including EOWNERDEAD handling for dead process recovery. Internal structures exposed in ssm.h for testing purposes. Adds some tests (pool_test, pool_sharding_test.c. etc) verifying lazy distribution, migration, fallback stealing, and multiprocess behavior. Updates the ring buffer (rbuff) to use relaxed/acquire/release ordering on atomic indices. The ring buffer requires the (robust) mutex to ensure cross-structure synchronization between pool buffer writes and ring buffer index publication. Signed-off-by: Dimitri Staessens Signed-off-by: Sander Vrijders --- cmake/utils/HumanReadable.cmake | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 cmake/utils/HumanReadable.cmake (limited to 'cmake/utils/HumanReadable.cmake') diff --git a/cmake/utils/HumanReadable.cmake b/cmake/utils/HumanReadable.cmake new file mode 100644 index 00000000..8bc1722f --- /dev/null +++ b/cmake/utils/HumanReadable.cmake @@ -0,0 +1,17 @@ +# Human-readable size conversion utilities + +# Convert bytes to human-readable format (GB, MB, KB) +# Usage: format_bytes_human_readable( ) +function(format_bytes_human_readable bytes output_var) + math(EXPR size_gb "${bytes} / 1073741824") + math(EXPR size_mb "${bytes} / 1048576") + math(EXPR size_kb "${bytes} / 1024") + + if(size_gb GREATER 0) + set(${output_var} "${size_gb} GB" PARENT_SCOPE) + elseif(size_mb GREATER 0) + set(${output_var} "${size_mb} MB" PARENT_SCOPE) + else() + set(${output_var} "${size_kb} KB" PARENT_SCOPE) + endif() +endfunction() -- cgit v1.2.3