Homogeneous default allocators (#552)

Homogeneous default allocators

Author: JohanMabille

include/sparrow/buffer/buffer.hpp

@@ -71,10 +71,10 @@ namespace sparrow
         constexpr buffer_base(const A& a) noexcept;
 
         template <allocator A = allocator_type>
-        constexpr buffer_base(size_type n, const A& a = A(xsimd::aligned_allocator<T>()));
+        constexpr buffer_base(size_type n, const A& a);
 
         template <allocator A = allocator_type>
-        constexpr buffer_base(pointer p, size_type n, const A& a = A(xsimd::aligned_allocator<T>()));
+        constexpr buffer_base(pointer p, size_type n, const A& a);
 
         ~buffer_base();
 
@@ -122,6 +122,7 @@ namespace sparrow
     public:
 
         using allocator_type = typename base_type::allocator_type;
+        using default_allocator = std::allocator<T>;
         using value_type = T;
         using reference = value_type&;
         using const_reference = const value_type&;
@@ -143,22 +144,22 @@ namespace sparrow
         {
         }
 
-        template <allocator A = allocator_type>
+        template <allocator A = default_allocator>
         constexpr explicit buffer(size_type n, const A& a = A());
 
-        template <allocator A = allocator_type>
+        template <allocator A = default_allocator>
         constexpr buffer(size_type n, const value_type& v, const A& a = A());
 
-        template <allocator A = allocator_type>
+        template <allocator A = default_allocator>
         constexpr buffer(pointer p, size_type n, const A& a = A());
 
-        template <allocator A = allocator_type>
+        template <allocator A = default_allocator>
         constexpr buffer(std::initializer_list<value_type> init, const A& a = A());
 
-        template <class It, allocator A = allocator_type>
+        template <class It, allocator A = default_allocator>
         constexpr buffer(It first, It last, const A& a = A());
 
-        template <std::ranges::input_range Range, allocator A = allocator_type>
+        template <std::ranges::input_range Range, allocator A = default_allocator>
             requires(std::same_as<std::ranges::range_value_t<Range>, T> && !is_buffer_view<Range>)
         constexpr buffer(const Range& range, const A& a = A());
 

include/sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp

@@ -59,9 +59,10 @@ namespace sparrow
 
         using base_type = dynamic_bitset_base<buffer<T>>;       ///< Base class type
         using storage_type = typename base_type::storage_type;  ///< Underlying storage container type
-        using block_type = typename base_type::block_type;      ///< Type of each storage block (same as T)
-        using value_type = typename base_type::value_type;      ///< Type of individual bit values (bool)
-        using size_type = typename base_type::size_type;        ///< Type used for sizes and indices
+        using default_allocator = typename storage_type::default_allocator;  ///< Type of default allocator
+        using block_type = typename base_type::block_type;  ///< Type of each storage block (same as T)
+        using value_type = typename base_type::value_type;  ///< Type of individual bit values (bool)
+        using size_type = typename base_type::size_type;    ///< Type used for sizes and indices
 
         /**
          * @brief Constructs a dynamic_bitset from an input range of convertible values.
@@ -71,7 +72,9 @@ namespace sparrow
          * values result in set bits (1), while zero/false values result in unset bits (0).
          *
          * @tparam R Input range type that must satisfy std::ranges::input_range
+         * @tparam A Allocator type that must satisfy sparrow::allocator
          * @param r The input range whose elements will be converted to bits
+         * @param a The allocator used internally
          *
          * @pre The range elements must be convertible to value_type (bool)
          * @pre The range must have a computable size via std::ranges::size
@@ -82,10 +85,10 @@ namespace sparrow
          * dynamic_bitset<std::uint8_t> bits(values);  // Results in: 10101
          * @endcode
          */
-        template <std::ranges::input_range R>
+        template <std::ranges::input_range R, allocator A = default_allocator>
             requires std::convertible_to<std::ranges::range_value_t<R>, value_type>
-        constexpr explicit dynamic_bitset(const R& r)
-            : dynamic_bitset(std::ranges::size(r), true)
+        constexpr explicit dynamic_bitset(const R& r, const A& a = A())
+            : dynamic_bitset(std::ranges::size(r), true, a)
         {
             std::size_t i = 0;
             for (auto value : r)
@@ -104,7 +107,9 @@ namespace sparrow
          * Constructs a bitset with zero bits. The bitset can later be resized
          * or bits can be added using the provided methods.
          */
-        constexpr dynamic_bitset();
+        template <class A = default_allocator>
+            requires(not std::same_as<A, dynamic_bitset<T>> and allocator<A>)
+        constexpr dynamic_bitset(const A& a = A());
 
         /**
          * @brief Constructs a bitset with n bits, all initialized to false.
@@ -114,7 +119,8 @@ namespace sparrow
          * @post size() == n
          * @post All bits are set to false
          */
-        constexpr explicit dynamic_bitset(size_type n);
+        template <allocator A = default_allocator>
+        constexpr explicit dynamic_bitset(size_type n, const A& a = A());
 
         /**
          * @brief Constructs a bitset with n bits, all initialized to the specified value.
@@ -125,7 +131,8 @@ namespace sparrow
          * @post size() == n
          * @post All bits are set to v
          */
-        constexpr dynamic_bitset(size_type n, value_type v);
+        template <allocator A = default_allocator>
+        constexpr dynamic_bitset(size_type n, value_type v, const A& a = A());
 
         /**
          * @brief Constructs a bitset using existing memory.
@@ -142,7 +149,8 @@ namespace sparrow
          * @warning The caller must ensure the memory pointed to by p remains valid
          *          and contains properly formatted bit data.
          */
-        constexpr dynamic_bitset(block_type* p, size_type n);
+        template <allocator A = default_allocator>
+        constexpr dynamic_bitset(block_type* p, size_type n, const A& a = A());
 
         /**
          * @brief Constructs a bitset using existing memory with null count tracking.
@@ -159,12 +167,19 @@ namespace sparrow
          * @post size() == n
          * @post null_count() == null_count
          */
-        constexpr dynamic_bitset(block_type* p, size_type n, size_type null_count);
+        template <allocator A = default_allocator>
+        constexpr dynamic_bitset(block_type* p, size_type n, size_type null_count, const A& a = A());
 
         constexpr ~dynamic_bitset() = default;
         constexpr dynamic_bitset(const dynamic_bitset&) = default;
         constexpr dynamic_bitset(dynamic_bitset&&) noexcept = default;
 
+        template <allocator A>
+        constexpr dynamic_bitset(const dynamic_bitset& rhs, const A& a);
+
+        template <allocator A>
+        constexpr dynamic_bitset(dynamic_bitset&& rhs, const A& a);
+
         constexpr dynamic_bitset& operator=(const dynamic_bitset&) = default;
         constexpr dynamic_bitset& operator=(dynamic_bitset&&) noexcept = default;
 
@@ -179,23 +194,27 @@ namespace sparrow
     };
 
     template <std::integral T>
-    constexpr dynamic_bitset<T>::dynamic_bitset()
-        : base_type(storage_type(), 0u)
+    template <class A>
+        requires(not std::same_as<A, dynamic_bitset<T>> and allocator<A>)
+    constexpr dynamic_bitset<T>::dynamic_bitset(const A& a)
+        : base_type(storage_type(a), 0u)
     {
         base_type::zero_unused_bits();
     }
 
     template <std::integral T>
-    constexpr dynamic_bitset<T>::dynamic_bitset(size_type n)
-        : dynamic_bitset(n, false)
+    template <allocator A>
+    constexpr dynamic_bitset<T>::dynamic_bitset(size_type n, const A& a)
+        : dynamic_bitset(n, false, a)
     {
         base_type::zero_unused_bits();
     }
 
     template <std::integral T>
-    constexpr dynamic_bitset<T>::dynamic_bitset(size_type n, value_type value)
+    template <allocator A>
+    constexpr dynamic_bitset<T>::dynamic_bitset(size_type n, value_type value, const A& a)
         : base_type(
-              storage_type(this->compute_block_count(n), value ? block_type(~block_type(0)) : block_type(0)),
+              storage_type(this->compute_block_count(n), value ? block_type(~block_type(0)) : block_type(0), a),
               n,
               value ? 0u : n
           )
@@ -204,20 +223,36 @@ namespace sparrow
     }
 
     template <std::integral T>
-    constexpr dynamic_bitset<T>::dynamic_bitset(block_type* p, size_type n)
-        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0), n)
+    template <allocator A>
+    constexpr dynamic_bitset<T>::dynamic_bitset(block_type* p, size_type n, const A& a)
+        : base_type(storage_type(p, p != nullptr ? this->compute_block_count(n) : 0, a), n)
     {
         base_type::zero_unused_bits();
     }
 
     template <std::integral T>
-    constexpr dynamic_bitset<T>::dynamic_bitset(block_type* p, size_type n, size_type null_count)
-        : base_type(storage_type(p, this->compute_block_count(n)), n, null_count)
+    template <allocator A>
+    constexpr dynamic_bitset<T>::dynamic_bitset(block_type* p, size_type n, size_type null_count, const A& a)
+        : base_type(storage_type(p, this->compute_block_count(n), a), n, null_count)
     {
         base_type::zero_unused_bits();
         SPARROW_ASSERT_TRUE(base_type::null_count() == base_type::size() - base_type::count_non_null());
     }
 
+    template <std::integral T>
+    template <allocator A>
+    constexpr dynamic_bitset<T>::dynamic_bitset(const dynamic_bitset& rhs, const A& a)
+        : base_type(storage_type(rhs, a))
+    {
+    }
+
+    template <std::integral T>
+    template <allocator A>
+    constexpr dynamic_bitset<T>::dynamic_bitset(dynamic_bitset&& rhs, const A& a)
+        : base_type(storage_type(std::move(rhs), a))
+    {
+    }
+
     /**
      * @brief Type alias for a validity bitmap using 8-bit storage blocks.
      *

include/sparrow/u8_buffer.hpp

@@ -107,10 +107,11 @@ namespace sparrow
     {
     public:
 
-        using holder_type = detail::holder<buffer<std::uint8_t>>;
-        using buffer_adaptor_type = buffer_adaptor<T, buffer<std::uint8_t>&>;
+        using buffer_type = buffer<std::uint8_t>;
+        using holder_type = detail::holder<buffer_type>;
+        using buffer_adaptor_type = buffer_adaptor<T, buffer_type&>;
         using holder_type::extract_storage;
-        using default_allocator_type = std::allocator<std::uint8_t>;
+        using default_allocator = buffer_type::default_allocator;
 
         /**
          * Move constructor.
@@ -183,12 +184,26 @@ namespace sparrow
          * Especially, one should not mixed operator new[] and std::allocator, as this
          * later is not guaranteed to free the memory with a call to operator delete[] only.
          *
+         * The recommended way to allocate data_ptr is to use the default allocator
+         * provided by u8_buffer:
+         * \code{.cpp}
+         * using allocator = u8_buffer::default_allocator;
+         * auto* data_ptr = reinterpret_cast<T*>(default_allocator().allocate(sizeof(uint8_t) * count));
+         * u8_buffer buf(data_ptr, count);
+         * \endcode
+         *
+         * However, if you prefer to provide your own allocator, you must ensure that:
+         * - either it allocates and returns a buffer or std::uint8_t
+         * - or it accepts a std::uint8_t* as its deallocate argument
+         * The first option is safer and more conformant to the standard allocator,
+         * but requires and extract cast in the client code.
+         *
          * @tparam A The allocator type.
          * @param data_ptr Pointer to the storage.
          * @param count Number of elements in the storage.
          * @param a The allocator to use.
          */
-        template <allocator A = default_allocator_type>
+        template <allocator A = default_allocator>
         constexpr u8_buffer(T* data_ptr, std::size_t count, const A& a = A());
     };
 

test/test_primitive_array.cpp

@@ -818,7 +818,8 @@ namespace sparrow
 #    pragma GCC diagnostic ignored "-Wcast-align"
 #endif
             size_t num_rows = 100000;
-            uint8_t* data_ptr = std::allocator<uint8_t>().allocate(sizeof(uint64_t) * num_rows);
+            using allocator_type = sparrow::u8_buffer<uint64_t>::default_allocator;
+            uint8_t* data_ptr = allocator_type().allocate(sizeof(uint64_t) * num_rows);
             auto cast_ptr = reinterpret_cast<uint64_t*>(data_ptr);
             for (size_t idx = 0; idx < num_rows; ++idx)
             {