Rename BackendArena → Arena and friends

With only one Arena type and a Small/Large pair of range adapters
built on it, drop the redundant 'Backend' prefix and pair the range
adapters by size:

  BackendArena       -> Arena
  BackendArenaBins   -> ArenaBins
  BackendArenaRange  -> LargeArenaRange   (pairs with SmallArenaRange)

Files and test directories renamed to match (git mv, history
preserved). The test-internal 'using Arena = ...<...>;' aliases
become 'TestArena' to avoid colliding with the renamed class
template.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: mjp41

CMakeLists.txt

@@ -549,10 +549,10 @@ if(NOT SNMALLOC_HEADER_ONLY_LIBRARY)
   # against both fast and check testlib variants.
   set(TESTLIB_ONLY_TESTS
     aligned_dealloc
-    backend_arena
-    backend_arena_bins
-    backend_arena_inplace
-    backend_arena_range
+    arena
+    arenabins
+    largearenarange
+    smallarenarange
     bits first_operation memory memory_usage multi_atexit multi_threadatexit
     redblack statistics teardown
     contention external_pointer large_alloc lotsofthreads post_teardown

src/snmalloc/backend/meta_protected_range.h

@@ -33,7 +33,7 @@ namespace snmalloc
     // Global range of memory
     using GlobalR = Pipe<
       Base,
-      BackendArenaRange<
+      LargeArenaRange<
         GlobalCacheSizeBits,
         bits::BITS - 1,
         Pagemap,
@@ -52,7 +52,7 @@ namespace snmalloc
     // would be able to corrupt meta-data.
     using CentralObjectRange = Pipe<
       GlobalR,
-      BackendArenaRange<GlobalCacheSizeBits, bits::BITS - 1, Pagemap>,
+      LargeArenaRange<GlobalCacheSizeBits, bits::BITS - 1, Pagemap>,
       LogRange<3>,
       GlobalRange,
       CommitRange<PAL>,
@@ -68,7 +68,7 @@ namespace snmalloc
       GlobalR,
       SubRange<PAL, SubRangeRatioBits>, // Use SubRange to introduce guard
                                         // pages.
-      BackendArenaRange<
+      LargeArenaRange<
         GlobalCacheSizeBits,
         bits::BITS - 1,
         Pagemap,
@@ -78,7 +78,7 @@ namespace snmalloc
       // page, so commit in the global range.
       stl::conditional_t<
         (max_page_chunk_size_bits > MIN_CHUNK_BITS),
-        BackendArenaRange<
+        LargeArenaRange<
           max_page_chunk_size_bits,
           max_page_chunk_size_bits,
           Pagemap,
@@ -91,7 +91,7 @@ namespace snmalloc
     // Local caching of object range
     using ObjectRange = Pipe<
       CentralObjectRange,
-      BackendArenaRange<
+      LargeArenaRange<
         LocalCacheSizeBits,
         LocalCacheSizeBits,
         Pagemap,
@@ -101,7 +101,7 @@ namespace snmalloc
     // Local caching of meta-data range
     using MetaRange = Pipe<
       CentralMetaRange,
-      BackendArenaRange<
+      LargeArenaRange<
         LocalCacheSizeBits - SubRangeRatioBits,
         bits::BITS - 1,
         Pagemap>,

src/snmalloc/backend/standard_range.h

@@ -30,7 +30,7 @@ namespace snmalloc
     // Global range of memory, expose this so can be filled by init.
     using GlobalR = Pipe<
       Base,
-      BackendArenaRange<
+      LargeArenaRange<
         GlobalCacheSizeBits,
         bits::BITS - 1,
         Pagemap,
@@ -46,11 +46,11 @@ namespace snmalloc
       bits::next_pow2_bits_const(PAL::page_size);
 
   public:
-    // Source for object allocations and metadata
-    // Use buddy allocators to cache locally.
+    // Source for object allocations and metadata; thread-local cache
+    // for chunk-sized ranges.
     using LargeObjectRange = Pipe<
       Stats,
-      StaticConditionalRange<BackendArenaRange<
+      StaticConditionalRange<LargeArenaRange<
         LocalCacheSizeBits,
         LocalCacheSizeBits,
         Pagemap,

…snmalloc/backend_helpers/backend_arena.h src/snmalloc/backend_helpers/arena.hsrc/snmalloc/backend_helpers/backend_arena.h renamed to src/snmalloc/backend_helpers/arena.h src/snmalloc/backend_helpers/backend_arena.h renamed to src/snmalloc/backend_helpers/arena.h

@@ -4,14 +4,14 @@
 #include "../ds_core/sizeclassconfig.h"
 #include "../stl/array.h"
 #include "../stl/utility.h"
-#include "backend_arena_bins.h"
+#include "arenabins.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 namespace snmalloc
 {
-  struct BackendArenaTestAccess;
+  struct ArenaTestAccess;
 
   /**
    * Size encoding for a free block's first pagemap entry.
@@ -21,7 +21,7 @@ namespace snmalloc
    *          placed in a size-1 bin (cannot serve aligned size-2 requests).
    * Large:   3+ chunks; precise size stored in a separate entry.
    */
-  enum class BackendArenaVariant : uint8_t
+  enum class ArenaVariant : uint8_t
   {
     Min = 0,
     EvenTwo = 1,
@@ -45,7 +45,7 @@ namespace snmalloc
    *   - `using RangeRep` — full RBTree Rep for the range tree, same
    *     shape as `BinRep`.
    *   - `get_variant(addr)` / `set_variant(addr, v)` — the
-   *     `BackendArenaVariant` tag for the block starting at `addr`.
+   *     `ArenaVariant` tag for the block starting at `addr`.
    *   - `get_large_size(addr)` / `set_large_size(addr, size)` —
    *     exact byte size for `Large` blocks (3+ units).
    *   - `can_consolidate(higher_addr) -> bool` — whether the block at
@@ -62,7 +62,7 @@ namespace snmalloc
    * returned to the caller.
    */
   template<typename Rep, size_t MIN_SIZE_BITS, size_t MAX_SIZE_BITS>
-  class BackendArena
+  class Arena
   {
     static_assert(MAX_SIZE_BITS > MIN_SIZE_BITS);
     static_assert(MAX_SIZE_BITS < bits::BITS);
@@ -72,7 +72,7 @@ namespace snmalloc
     static constexpr size_t TWO_UNITS = size_t(2) << MIN_SIZE_BITS;
 
     static constexpr size_t B = 2;
-    using Bins = BackendArenaBins<B, MIN_SIZE_BITS>;
+    using Bins = ArenaBins<B, MIN_SIZE_BITS>;
 
     static_assert(
       bits::one_at_bit(MAX_SIZE_BITS) - 1 <= Bins::max_supported_size());
@@ -89,15 +89,15 @@ namespace snmalloc
 
     // ---- Metadata helpers ----
 
-    static BackendArenaVariant variant_of(size_t size, uintptr_t addr)
+    static ArenaVariant variant_of(size_t size, uintptr_t addr)
     {
       if (size == UNIT_SIZE)
-        return BackendArenaVariant::Min;
+        return ArenaVariant::Min;
       if (size == TWO_UNITS)
         return ((addr >> MIN_SIZE_BITS) & 1) == 0 ?
-          BackendArenaVariant::EvenTwo :
-          BackendArenaVariant::OddTwo;
-      return BackendArenaVariant::Large;
+          ArenaVariant::EvenTwo :
+          ArenaVariant::OddTwo;
+      return ArenaVariant::Large;
     }
 
     static stl::Pair<uintptr_t, size_t> range_from_addr(uintptr_t a)
@@ -107,12 +107,12 @@ namespace snmalloc
       auto v = Rep::get_variant(a);
       switch (v)
       {
-        case BackendArenaVariant::Min:
+        case ArenaVariant::Min:
           return {a, UNIT_SIZE};
-        case BackendArenaVariant::EvenTwo:
-        case BackendArenaVariant::OddTwo:
+        case ArenaVariant::EvenTwo:
+        case ArenaVariant::OddTwo:
           return {a, TWO_UNITS};
-        case BackendArenaVariant::Large:
+        case ArenaVariant::Large:
         {
           size_t s = Rep::get_large_size(a);
           SNMALLOC_ASSERT(
@@ -129,7 +129,7 @@ namespace snmalloc
     {
       auto path = bin_trees[0].get_root_path();
       return bin_trees[0].find(path, a) &&
-        Rep::get_variant(a) == BackendArenaVariant::Min;
+        Rep::get_variant(a) == ArenaVariant::Min;
     }
 
     void insert_block(uintptr_t addr, size_t size)
@@ -156,12 +156,12 @@ namespace snmalloc
         bitmap.clear(bin);
     }
 
-    friend struct BackendArenaTestAccess;
+    friend struct ArenaTestAccess;
 
   public:
     using addr_t = uintptr_t;
 
-    constexpr BackendArena() = default;
+    constexpr Arena() = default;
 
     /**
      * Add a free block at `addr` with `size` bytes. The block is
@@ -179,7 +179,7 @@ namespace snmalloc
       // Unit alignment is required: callers feeding parent ranges (e.g.
       // mmap-backed PalRange returns page-aligned but not chunk-aligned
       // memory) must trim their input to UNIT_SIZE before reaching here.
-      // BackendArenaRange::add_range does this trim.
+      // LargeArenaRange::add_range does this trim.
       SNMALLOC_ASSERT((addr & (UNIT_SIZE - 1)) == 0);
       SNMALLOC_ASSERT(size > 0);
       SNMALLOC_ASSERT((size & (UNIT_SIZE - 1)) == 0);
@@ -348,7 +348,7 @@ namespace snmalloc
         uintptr_t prev = 0;
         bool prev_valid = false;
         bin_trees[0].for_each([&](uintptr_t node) {
-          if (Rep::get_variant(node) != BackendArenaVariant::Min)
+          if (Rep::get_variant(node) != ArenaVariant::Min)
             return;
           if (prev_valid)
             SNMALLOC_CHECK(
@@ -414,7 +414,7 @@ namespace snmalloc
           auto v = Rep::get_variant(node);
           auto [a, s] = range_from_addr(node);
           SNMALLOC_CHECK(v == variant_of(s, a));
-          if (v == BackendArenaVariant::Large)
+          if (v == ArenaVariant::Large)
             SNMALLOC_CHECK(Rep::get_large_size(node) == s);
         });
       }

…loc/backend_helpers/backend_arena_bins.h src/snmalloc/backend_helpers/arenabins.hsrc/snmalloc/backend_helpers/backend_arena_bins.h renamed to src/snmalloc/backend_helpers/arenabins.h src/snmalloc/backend_helpers/backend_arena_bins.h renamed to src/snmalloc/backend_helpers/arenabins.h

@@ -8,11 +8,11 @@
 namespace snmalloc
 {
   template<size_t INTERMEDIATE_BITS, size_t MIN_SIZE_BITS>
-  struct BackendArenaBinsTestAccess;
+  struct ArenaBinsTestAccess;
 
   /**
    * Size class enumeration and bin classification used by the
-   * BackendArena.
+   * Arena.
    *
    * Template parameter `B` (mantissa-bit width of snmalloc's
    * non-power-of-two size class scheme) determines the number of
@@ -40,14 +40,14 @@ namespace snmalloc
    *    `add` / `find_for_request` / `clear`.
    *
    * Everything else is private; tests reach it via
-   * `BackendArenaBinsTestAccess<B, MIN_SIZE_BITS>`.
+   * `ArenaBinsTestAccess<B, MIN_SIZE_BITS>`.
    */
   template<size_t INTERMEDIATE_BITS, size_t MIN_SIZE_BITS>
-  class BackendArenaBins
+  class ArenaBins
   {
     static_assert(
       INTERMEDIATE_BITS >= 1 && INTERMEDIATE_BITS <= 3,
-      "BackendArenaBins supports B in {1, 2, 3}");
+      "ArenaBins supports B in {1, 2, 3}");
     static_assert(
       MIN_SIZE_BITS + INTERMEDIATE_BITS < bits::BITS,
       "MIN_SIZE_BITS + INTERMEDIATE_BITS must leave room for at least one "
@@ -73,7 +73,7 @@ namespace snmalloc
     };
 
   private:
-    friend struct BackendArenaBinsTestAccess<INTERMEDIATE_BITS, MIN_SIZE_BITS>;
+    friend struct ArenaBinsTestAccess<INTERMEDIATE_BITS, MIN_SIZE_BITS>;
 
     static constexpr size_t B = INTERMEDIATE_BITS;
 
@@ -309,7 +309,7 @@ namespace snmalloc
      */
     class Bitmap
     {
-      friend struct BackendArenaBinsTestAccess<
+      friend struct ArenaBinsTestAccess<
         INTERMEDIATE_BITS,
         MIN_SIZE_BITS>;
 
@@ -342,7 +342,7 @@ namespace snmalloc
       }
 
       /// Read-only test: is the bit for `bin_id` set?
-      /// Used by `BackendArena::invariant()`.
+      /// Used by `Arena::invariant()`.
       bool test(size_t bin_id) const
       {
         SNMALLOC_ASSERT(bin_id < TOTAL_BINS);
@@ -680,7 +680,7 @@ namespace snmalloc
      * `carve_info[sc]` is the size/alignment record for each in-range
      * sc (consumed by `carve` and by `bin_offset_at`'s `fits`
      * predicate during free-side classification).
-     * `exp_first_sc[e]` is the first raw sc id at BackendArenaBins
+     * `exp_first_sc[e]` is the first raw sc id at ArenaBins
      * exponent e (with `exp_first_sc[bits::BITS] = MAX_SC` as a sentinel
      * so `[exp_first_sc[e], exp_first_sc[e + 1])` is a valid raw range
      * for every `e < bits::BITS`).

src/snmalloc/backend_helpers/backend_helpers.h

@@ -2,7 +2,7 @@
 
 #include "../mem/mem.h"
 #include "authmap.h"
-#include "backend_arena_range.h"
+#include "largearenarange.h"
 #include "commitrange.h"
 #include "commonconfig.h"
 #include "defaultpagemapentry.h"

src/snmalloc/backend_helpers/inplacerep.h

@@ -3,15 +3,15 @@
 #include "../ds_core/bits.h"
 #include "../ds_core/defines.h"
 #include "../ds_core/sizeclassconfig.h"
-#include "backend_arena.h"
+#include "arena.h"
 
 #include <stdint.h>
 
 namespace snmalloc
 {
   /**
    * In-band tree node stored at the head of a free block managed by
-   * `BackendArena`. Two pointer-sized words per unit; bit-packing of
+   * `Arena`. Two pointer-sized words per unit; bit-packing of
    * red and variant tags lives in `word_one`. Stored as `uintptr_t`
    * so we can OR meta bits into the pointer slot without UB on
    * non-capability platforms (on CHERI, capabilities to access these
@@ -25,7 +25,7 @@ namespace snmalloc
   };
 
   /**
-   * In-band `Rep` for `BackendArena`. Each free block carries its
+   * In-band `Rep` for `Arena`. Each free block carries its
    * own tree-node and metadata storage in its first few units:
    *
    *   Unit 0 (addr):                bin-tree node + variant tag.
@@ -34,7 +34,7 @@ namespace snmalloc
    *
    * Bit layout in `word_one` of each unit:
    *   bit 0           : red bit (both trees)
-   *   bits 1..2       : variant tag (`BackendArenaVariant`, unit 0 only)
+   *   bits 1..2       : variant tag (`ArenaVariant`, unit 0 only)
    * `word_two` holds the second child pointer with no packed meta.
    * Both child pointers are unit-aligned, so their low `MIN_BITS`
    * bits are zero — the packed meta occupies bits below
@@ -231,14 +231,14 @@ namespace snmalloc
     using BinRep = TreeRep<0, BIN_META_MASK, BIN_REP_NAME>;
     using RangeRep = TreeRep<1, RANGE_META_MASK, RANGE_REP_NAME>;
 
-    static BackendArenaVariant get_variant(uintptr_t addr)
+    static ArenaVariant get_variant(uintptr_t addr)
     {
       auto w = unit_at<0>(addr)->word_one;
-      return static_cast<BackendArenaVariant>(
+      return static_cast<ArenaVariant>(
         (w & VARIANT_MASK) >> VARIANT_SHIFT);
     }
 
-    static void set_variant(uintptr_t addr, BackendArenaVariant v)
+    static void set_variant(uintptr_t addr, ArenaVariant v)
     {
       auto* w = &unit_at<0>(addr)->word_one;
       *w = (*w & ~VARIANT_MASK) | (static_cast<uintptr_t>(v) << VARIANT_SHIFT);
@@ -265,7 +265,7 @@ namespace snmalloc
      * Refuse consolidation across `MIN_CHUNK_SIZE` boundaries.
      * `SmallArenaRange::add_range_impl` splits incoming ranges at
      * chunk boundaries, but does not eagerly merge across them on
-     * the wrapper side; this check is what stops `BackendArena`
+     * the wrapper side; this check is what stops `Arena`
      * from later merging two adjacent intra-chunk fragments that
      * happen to abut the same chunk boundary, which would create a
      * free block straddling chunks. Chunk-aligned `higher_addr`