constexpred

Author: Conor

src/batteries/slab_stack.cxx

@@ -13,18 +13,17 @@ namespace lf {
 /**
  * @brief A slab_stack is a user-space stack backed by a single fixed-size slab of memory.
  *
- * The ctrl metadata and usable stack space are fused into a single allocation: a header
- * at the front of the slab is followed immediately by the usable nodes.  There is no
- * segmentation, caching, or geometric growth — if the slab is full, push throws.
+ * The ctrl metadata and usable stack space are fused into a single allocation: the first
+ * node of the slab is the header, and the remaining `size` nodes are the usable stack
+ * space.  There is no segmentation, caching, or geometric growth — if the slab is full,
+ * push throws.
  *
  * For this to conform to `worker_stack` the allocators void pointer type must be `void *`
  */
 export template <allocator_of<std::byte> Allocator = std::allocator<std::byte>>
 class slab_stack {
 
-  // Alignment unit — all allocations are a multiple of this size.
-  struct alignas(k_new_align) node {};
-  static_assert(sizeof(node) == k_new_align);
+  struct node; // Forward declaration so type aliases can reference node before its definition.
 
   using node_traits = std::allocator_traits<Allocator>::template rebind_traits<node>;
   using node_alloc_t = node_traits::allocator_type;
@@ -33,22 +32,19 @@ class slab_stack {
   using size_int = node_traits::size_type;
   using diff_int = node_traits::difference_type;
 
-  // Fused ctrl+node header — lives at the very start of every slab allocation.
-  // The usable stack space (size nodes) follows directly after the header region.
-  struct slab {
+  // Fused ctrl+node: the first element of every slab allocation.
+  // node_alloc, sp_cache, and size live here; the `size` nodes that follow are
+  // the usable stack space.  Mirrors how geometric_stack stores ctrl data in its
+  // first node — no reinterpret_cast is ever needed.
+  struct alignas(k_new_align) node {
     [[no_unique_address]]
     node_alloc_t node_alloc; // Propagated to new owners on acquire.
     node_ptr sp_cache;       // Stack pointer saved across release/acquire.
-    diff_int size;           // Usable node count in this slab.
+    diff_int size;           // Usable node count following this header.
   };
 
-  // Number of node-sized units occupied by the header at the front of each allocation.
-  static constexpr diff_int k_header_nodes =
-      safe_cast<diff_int>((sizeof(slab) + sizeof(node) - 1) / sizeof(node));
-
-  // Default capacity: fill one page minus the header.
-  static constexpr diff_int k_default_nodes =
-      safe_cast<diff_int>(k_page_size / sizeof(node)) - k_header_nodes;
+  // Default capacity: one page of usable space (header occupies the first node).
+  static constexpr diff_int k_default_nodes = safe_cast<diff_int>(k_page_size / sizeof(node)) - 1;
 
   static_assert(k_default_nodes > 0);
 
@@ -63,12 +59,13 @@ class slab_stack {
 
    private:
     friend slab_stack;
-    explicit constexpr checkpoint_t(slab *ptr) noexcept : m_slab(ptr) {}
-    slab *m_slab = nullptr;
+    explicit constexpr checkpoint_t(node_ptr ptr) noexcept : m_ctrl(ptr) {}
+    node_ptr m_ctrl = nullptr;
   };
 
  public:
   constexpr slab_stack() : slab_stack(Allocator{}) {}
+  explicit constexpr slab_stack(diff_int num_nodes) : slab_stack(Allocator{}, num_nodes) {}
   explicit constexpr slab_stack(Allocator const &alloc, diff_int num_nodes = k_default_nodes)
       : m_alloc(alloc) {
     init_slab(num_nodes);
@@ -82,7 +79,7 @@ class slab_stack {
 
   constexpr ~slab_stack() noexcept {
     LF_ASSUME(empty());
-    free_slab(m_slab);
+    free_ctrl(m_ctrl);
   }
 
   /**
@@ -98,7 +95,7 @@ class slab_stack {
    */
   [[nodiscard]]
   constexpr auto checkpoint() noexcept -> checkpoint_t {
-    return checkpoint_t{m_slab};
+    return checkpoint_t{m_ctrl};
   }
 
   /**
@@ -142,18 +139,18 @@ class slab_stack {
 
   [[nodiscard]]
   constexpr auto prepare_release() const noexcept -> release_t {
-    // Guard against null release (failed prior allocation).
-    if (m_slab != nullptr) {
-      m_slab->sp_cache = m_sp;
+    // Guard against null ctrl (failed prior allocation in release()).
+    if (m_ctrl != nullptr) {
+      m_ctrl->sp_cache = m_sp;
     }
     return release_t{key()};
   }
 
   constexpr void release([[maybe_unused]] release_t) noexcept {
-    diff_int next_size = (m_slab != nullptr) ? m_slab->size : k_default_nodes;
+    diff_int next_size = (m_ctrl != nullptr) ? m_ctrl->size : k_default_nodes;
 
     // Hand off the current slab to whoever holds the checkpoint; clear local state.
-    m_slab = nullptr;
+    m_ctrl = nullptr;
     m_lo = nullptr;
     m_sp = nullptr;
     m_hi = nullptr;
@@ -169,20 +166,20 @@ class slab_stack {
   constexpr void acquire(checkpoint_t ckpt) noexcept {
     LF_ASSUME(empty());
 
-    if (ckpt.m_slab == nullptr) {
+    if (ckpt.m_ctrl == nullptr) {
       return;
     }
 
     // Discard the fresh empty slab we prepared during release() (may be null on alloc failure).
-    free_slab(m_slab);
+    free_ctrl(m_ctrl);
 
-    m_slab = ckpt.m_slab;
+    m_ctrl = ckpt.m_ctrl;
 
     if constexpr (!node_traits::is_always_equal::value) {
-      m_alloc = node_alloc_t{std::as_const(m_slab->node_alloc)};
+      m_alloc = node_alloc_t{std::as_const(m_ctrl->node_alloc)};
     }
 
-    LF_ASSUME(m_slab != nullptr);
+    LF_ASSUME(m_ctrl != nullptr);
 
     load_local();
   }
@@ -191,46 +188,44 @@ class slab_stack {
   [[no_unique_address]]
   node_alloc_t m_alloc;
 
-  slab *m_slab = nullptr;
-  node_ptr m_lo = nullptr; // Base of usable space in the current slab.
-  node_ptr m_sp = nullptr; // Stack pointer for the current slab.
-  node_ptr m_hi = nullptr; // One-past-the-end of usable space in the current slab.
+  node_ptr m_ctrl = nullptr; // Header node (fused ctrl+first-node of the slab).
+  node_ptr m_lo = nullptr;   // Base of usable space (m_ctrl + 1).
+  node_ptr m_sp = nullptr;   // Stack pointer for the current slab.
+  node_ptr m_hi = nullptr;   // One-past-the-end of usable space.
 
-  // Restore local pointers from the slab header, taking sp from the cache.
+  // Restore local pointers from the header node, taking sp from the cache.
   constexpr void load_local() noexcept {
-    LF_ASSUME(m_slab != nullptr);
-    node_ptr base = reinterpret_cast<node_ptr>(m_slab) + k_header_nodes;
-    m_lo = base;
-    m_hi = base + m_slab->size;
-    m_sp = m_slab->sp_cache;
+    LF_ASSUME(m_ctrl != nullptr);
+    m_lo = m_ctrl + 1;
+    m_hi = m_lo + m_ctrl->size;
+    m_sp = m_ctrl->sp_cache;
   }
 
   // Allocate and construct a fresh slab with num_nodes usable nodes.
   constexpr void init_slab(diff_int num_nodes) {
     LF_ASSUME(num_nodes > 0);
 
-    size_int total = safe_cast<size_int>(k_header_nodes + num_nodes);
-    node_ptr raw = node_traits::allocate(m_alloc, total);
+    size_int total = safe_cast<size_int>(1 + num_nodes);
+    m_ctrl = node_traits::allocate(m_alloc, total);
 
     LF_TRY {
-      m_slab = std::construct_at(reinterpret_cast<slab *>(std::to_address(raw)), m_alloc, nullptr, num_nodes);
+      node_traits::construct(m_alloc, m_ctrl, m_alloc, nullptr, num_nodes);
     } LF_CATCH_ALL {
-      node_traits::deallocate(m_alloc, raw, total);
+      node_traits::deallocate(m_alloc, m_ctrl, total);
+      m_ctrl = nullptr;
       LF_RETHROW;
     }
 
-    node_ptr base = raw + k_header_nodes;
-    m_lo = m_sp = base;
-    m_hi = base + num_nodes;
+    m_lo = m_sp = m_ctrl + 1;
+    m_hi = m_lo + num_nodes;
   }
 
   // Destroy and deallocate a slab (no-op if null).
-  constexpr void free_slab(slab *s) noexcept {
-    if (s != nullptr) {
-      size_int total = safe_cast<size_int>(k_header_nodes + s->size);
-      node_ptr raw = reinterpret_cast<node_ptr>(s);
-      std::destroy_at(s);
-      node_traits::deallocate(m_alloc, raw, total);
+  constexpr void free_ctrl(node_ptr ctrl) noexcept {
+    if (ctrl != nullptr) {
+      size_int total = safe_cast<size_int>(1 + ctrl->size);
+      node_traits::destroy(m_alloc, ctrl);
+      node_traits::deallocate(m_alloc, ctrl, total);
     }
   }
 

test/src/stack.cpp

@@ -54,11 +54,12 @@ constexpr void check_non_empty(auto const &stack) {
 
 } // namespace
 
-TEMPLATE_TEST_CASE("Concept", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>) {
+TEMPLATE_TEST_CASE("Concept", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>, lf::slab_stack<>) {
   STATIC_REQUIRE(worker_stack<TestType>); //
 }
 
-TEMPLATE_TEST_CASE("Basic push and pop", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>) {
+TEMPLATE_TEST_CASE("Basic push and pop", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>,
+                   lf::slab_stack<>) {
   TEST_CONSTEXPR([]() -> bool {
     TestType stack;
     check_empty(stack);
@@ -81,7 +82,8 @@ TEMPLATE_TEST_CASE("Basic push and pop", "[stacks]", lf::geometric_stack<>, lf::
   });
 }
 
-TEMPLATE_TEST_CASE("Checkpoint and Acquire/Release", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>) {
+TEMPLATE_TEST_CASE("Checkpoint and Acquire/Release", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>,
+                   lf::slab_stack<>) {
   TEST_CONSTEXPR([]() -> bool {
     TestType stack1;
     void *p1 = stack1.push(100);
@@ -104,7 +106,7 @@ TEMPLATE_TEST_CASE("Checkpoint and Acquire/Release", "[stacks]", lf::geometric_s
   });
 }
 
-TEMPLATE_TEST_CASE("Single pass", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>) {
+TEMPLATE_TEST_CASE("Single pass", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>, lf::slab_stack<>) {
   for (int k = 0; k < 10; ++k) {
 
     TestType stack;
@@ -122,16 +124,21 @@ TEMPLATE_TEST_CASE("Single pass", "[stacks]", lf::geometric_stack<>, lf::adaptor
       std::vector<entry> entries;
       const std::size_t depth = depth_dist(rng);
 
-      // Push phase
+      // Push phase — break early if slab_stack exhausts its fixed capacity
       for (std::size_t j = 0; j < depth; ++j) {
         std::size_t s = size_dist(rng);
-        void *p = stack.push(s);
+        void *p = nullptr;
+        try {
+          p = stack.push(s);
+        } catch (std::bad_alloc const &) {
+          break;
+        }
         check_alignment(p);
         entries.push_back({.ptr = p, .size = s});
       }
 
-      // Pop phase (FILO)
-      for (std::size_t j = depth; j > 0; --j) {
+      // Pop phase (FILO) — use entries.size() in case push exited early
+      for (std::size_t j = entries.size(); j > 0; --j) {
         auto const &e = entries[j - 1];
         stack.pop(e.ptr, e.size);
       }
@@ -141,7 +148,8 @@ TEMPLATE_TEST_CASE("Single pass", "[stacks]", lf::geometric_stack<>, lf::adaptor
   }
 }
 
-TEMPLATE_TEST_CASE("Randomized push/pop", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>) {
+TEMPLATE_TEST_CASE("Randomized push/pop", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>,
+                   lf::slab_stack<>) {
   TestType stack;
   std::mt19937_64 rng{std::random_device{}()};
   std::bernoulli_distribution push_dist{0.51};
@@ -163,7 +171,12 @@ TEMPLATE_TEST_CASE("Randomized push/pop", "[stacks]", lf::geometric_stack<>, lf:
 
     if (entries.empty() || push_dist(rng)) {
       std::size_t s = size_dist(rng);
-      void *p = stack.push(s);
+      void *p = nullptr;
+      try {
+        p = stack.push(s);
+      } catch (std::bad_alloc const &) {
+        break; // slab_stack exhausted; clean up and finish
+      }
       check_alignment(p);
       entries.push_back({.ptr = p, .size = s});
       total_pushed++;
@@ -184,7 +197,8 @@ TEMPLATE_TEST_CASE("Randomized push/pop", "[stacks]", lf::geometric_stack<>, lf:
   check_empty(stack);
 }
 
-TEMPLATE_TEST_CASE("Spikey randomized push/pop", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>) {
+TEMPLATE_TEST_CASE("Spikey randomized push/pop", "[stacks]", lf::geometric_stack<>, lf::adaptor_stack<>,
+                   lf::slab_stack<>) {
   TestType stack;
   std::mt19937_64 rng{std::random_device{}()};
 
@@ -217,7 +231,12 @@ TEMPLATE_TEST_CASE("Spikey randomized push/pop", "[stacks]", lf::geometric_stack
 
     if (do_push) {
       std::size_t s = size_dist(rng);
-      void *p = stack.push(s);
+      void *p = nullptr;
+      try {
+        p = stack.push(s);
+      } catch (std::bad_alloc const &) {
+        break; // slab_stack exhausted; clean up and finish
+      }
       check_alignment(p);
       entries.push_back({.ptr = p, .size = s});
       total_pushed++;
@@ -238,3 +257,56 @@ TEMPLATE_TEST_CASE("Spikey randomized push/pop", "[stacks]", lf::geometric_stack
   }
   check_empty(stack);
 }
+
+// ---- slab_stack specific ----
+//
+// Tests that exercise behaviour unique to slab_stack's fixed-size design.
+
+TEST_CASE("slab_stack - throws when full", "[stacks]") {
+  // Use a tiny slab (2 usable nodes) to exercise the overflow path precisely.
+  lf::slab_stack<> stack(2);
+
+  void *p1 = stack.push(k_new_align);
+  void *p2 = stack.push(k_new_align);
+  REQUIRE_THROWS_AS(stack.push(k_new_align), std::bad_alloc);
+
+  stack.pop(p2, k_new_align);
+  stack.pop(p1, k_new_align);
+  check_empty(stack);
+}
+
+TEST_CASE("slab_stack - single pass", "[stacks]") {
+  for (int k = 0; k < 10; ++k) {
+    // Slab sized to hold the worst-case live footprint without early exit:
+    // depth_max (5000) * roundup(size_max (200), k_new_align=16) / k_new_align
+    // = 5000 * 13 = 65 000 nodes, with headroom.
+    lf::slab_stack<> stack(70'000);
+    std::mt19937_64 rng{std::random_device{}()};
+    std::uniform_int_distribution<std::size_t> size_dist{1, 200};
+    std::uniform_int_distribution<std::size_t> depth_dist{5, 5000};
+
+    struct entry {
+      void *ptr;
+      std::size_t size;
+    };
+
+    for (int i = 0; i < 2; ++i) {
+      std::vector<entry> entries;
+      const std::size_t depth = depth_dist(rng);
+
+      for (std::size_t j = 0; j < depth; ++j) {
+        std::size_t s = size_dist(rng);
+        void *p = stack.push(s);
+        check_alignment(p);
+        entries.push_back({.ptr = p, .size = s});
+      }
+
+      for (std::size_t j = depth; j > 0; --j) {
+        auto const &e = entries[j - 1];
+        stack.pop(e.ptr, e.size);
+      }
+
+      check_empty(stack);
+    }
+  }
+}