adt: use the smallest possible type to encode the vector size as a function of its capacity

F

Author: faluco

include/srsran/adt/static_vector.h

@@ -14,19 +14,31 @@
 #include "srsran/support/srsran_assert.h"
 #include <array>
 #include <iterator>
+#include <limits>
 #include <memory>
 
 namespace srsran {
 
 namespace detail {
 
+/// Selects the smallest unsigned integer type that can represent the range [0, N].
+template <size_t N>
+using size_type_selector = std::conditional_t<
+    (N < std::numeric_limits<uint8_t>::max()),
+    uint8_t,
+    std::conditional_t<
+        (N < std::numeric_limits<uint16_t>::max()),
+        uint16_t,
+        std::conditional_t<(N < std::numeric_limits<uint32_t>::max()),
+                           uint32_t,
+                           std::conditional_t<(N < std::numeric_limits<uint64_t>::max()), uint64_t, size_t>>>>;
+
 template <typename T, size_t Capacity>
 struct trivial_storage {
-  static_assert(std::is_trivial<T>::value, "Implementation only works for trivial types");
+  static_assert(std::is_trivial_v<T>, "Implementation only works for trivial types");
 
-  using array_type     = std::conditional_t<std::is_const<T>::value,
-                                            const std::array<std::remove_const_t<T>, Capacity>,
-                                            std::array<T, Capacity>>;
+  using array_type = std::
+      conditional_t<std::is_const_v<T>, const std::array<std::remove_const_t<T>, Capacity>, std::array<T, Capacity>>;
   using iterator       = T*;
   using const_iterator = const T*;
 
@@ -89,16 +101,16 @@ struct trivial_storage {
     // do nothing.
   }
 
-  array_type array;
-  size_t     sz = 0;
+  array_type                   array;
+  size_type_selector<Capacity> sz = 0;
 };
 
 template <typename T, size_t Capacity>
 struct non_trivial_storage {
-  static_assert(not std::is_trivial<T>::value, "Implementation only works for non-trivial types");
+  static_assert(not std::is_trivial_v<T>, "Implementation only works for non-trivial types");
 
   using element_storage_t = std::aligned_storage_t<sizeof(T), alignof(T)>;
-  using array_type        = std::conditional_t<std::is_const<T>::value,
+  using array_type        = std::conditional_t<std::is_const_v<T>,
                                                const std::array<element_storage_t, Capacity>,
                                                std::array<element_storage_t, Capacity>>;
   using iterator          = T*;
@@ -148,7 +160,7 @@ struct non_trivial_storage {
   const_iterator end() const noexcept { return begin() + sz; }
 
   template <typename... Args>
-  constexpr void construct_(size_t idx, Args&&... args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
+  constexpr void construct_(size_t idx, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args...>)
   {
     static_assert(std::is_constructible<T, Args...>::value, "T(Args...) does not exist");
     new (&array[idx]) T(std::forward<Args>(args)...);
@@ -157,13 +169,13 @@ struct non_trivial_storage {
   void destroy_(size_t idx) noexcept { (*this)[idx].~T(); }
   void destroy_(iterator it) noexcept { (*it).~T(); }
 
-  array_type array;
-  size_t     sz = 0;
+  array_type                   array;
+  size_type_selector<Capacity> sz = 0;
 };
 
 template <typename T, size_t Capacity>
 using static_vector_storage =
-    std::conditional_t<std::is_trivial<T>::value, trivial_storage<T, Capacity>, non_trivial_storage<T, Capacity>>;
+    std::conditional_t<std::is_trivial_v<T>, trivial_storage<T, Capacity>, non_trivial_storage<T, Capacity>>;
 
 } // namespace detail
 
@@ -173,7 +185,7 @@ using static_vector_storage =
 /// @tparam T type of the elements
 /// @tparam MAX_N Maximum number of elements of the static_vector
 template <typename T, std::size_t MAX_N>
-class static_vector : private detail::static_vector_storage<T, MAX_N>
+class static_vector : public detail::static_vector_storage<T, MAX_N>
 {
   using base_type = detail::static_vector_storage<T, MAX_N>;
 
@@ -197,7 +209,7 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
   ///
   /// Note: The ctor needs to be user-defined to forbid zero-initialization of the storage via = {}.
   constexpr static_vector() noexcept {}
-  explicit constexpr static_vector(size_type count) noexcept(std::is_nothrow_default_constructible<T>::value)
+  explicit constexpr static_vector(size_type count) noexcept(std::is_nothrow_default_constructible_v<T>)
   {
     static_assert(std::is_default_constructible<T>::value, "T must be default-constructible");
     srsran_assert(count <= MAX_N, "static vector maximum size={} was exceeded", MAX_N);
@@ -208,18 +220,17 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
     }
     this->sz = count;
   }
-  constexpr static_vector(size_type count,
-                          const T&  initial_value) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr static_vector(size_type count, const T& initial_value) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     static_assert(std::is_copy_constructible<T>::value, "T must be copy-constructible");
     assign_unsafe_(count, initial_value);
   }
-  constexpr static_vector(const static_vector& other) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr static_vector(const static_vector& other) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     static_assert(std::is_copy_constructible<T>::value, "T must be copyable");
     assign_unsafe_(other.begin(), other.end());
   }
-  constexpr static_vector(static_vector&& other) noexcept(std::is_nothrow_move_constructible<value_type>::value)
+  constexpr static_vector(static_vector&& other) noexcept(std::is_nothrow_move_constructible_v<value_type>)
   {
     static_assert(std::is_move_constructible<T>::value, "T must be move-constructible");
     assign_unsafe_(std::make_move_iterator(other.begin()), std::make_move_iterator(other.end()));
@@ -233,14 +244,14 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
   }
   constexpr static_vector(std::initializer_list<T> init) : static_vector(init.begin(), init.end()) {}
   ~static_vector() = default;
-  constexpr static_vector& operator=(const static_vector& other) noexcept(std::is_nothrow_copy_assignable<T>::value)
+  constexpr static_vector& operator=(const static_vector& other) noexcept(std::is_nothrow_copy_assignable_v<T>)
   {
     if (this != &other) {
       assign(other.begin(), other.end());
     }
     return *this;
   }
-  constexpr static_vector& operator=(static_vector&& other) noexcept(std::is_nothrow_move_assignable<value_type>::value)
+  constexpr static_vector& operator=(static_vector&& other) noexcept(std::is_nothrow_move_assignable_v<value_type>)
   {
     size_t min_common_size = std::min(other.size(), size());
     if (min_common_size > 0) {
@@ -266,21 +277,21 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
 
   // modifiers
   template <typename... Args>
-  constexpr T& emplace_back(Args&&... args) noexcept(std::is_nothrow_constructible<T, Args...>::value)
+  constexpr T& emplace_back(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args...>)
   {
     srsran_assert(size() < MAX_N, "Cannot emplace back in full vector");
     this->construct_(size(), std::forward<Args>(args)...);
     this->sz++;
     return this->back();
   }
 
-  constexpr void push_back(const T& value) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr void push_back(const T& value) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     static_assert(std::is_copy_constructible<T>::value, "T must be copy-constructible");
     emplace_back(value);
   }
 
-  constexpr void push_back(T&& value) noexcept(std::is_nothrow_move_constructible<T>::value)
+  constexpr void push_back(T&& value) noexcept(std::is_nothrow_move_constructible_v<T>)
   {
     static_assert(std::is_move_constructible<T>::value, "T must be move-constructible");
     emplace_back(std::move(value));
@@ -331,7 +342,7 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
     this->sz = new_size;
   }
 
-  constexpr iterator erase(iterator pos) noexcept(std::is_move_assignable<T>::value)
+  constexpr iterator erase(iterator pos) noexcept(std::is_move_assignable_v<T>)
   {
     srsran_assert(pos >= this->begin() and pos < this->end(), "Iterator to erase is out-of-bounds");
     iterator ret = pos;
@@ -340,7 +351,7 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
     return ret;
   }
 
-  constexpr iterator erase(iterator it_start, iterator it_end) noexcept(std::is_move_assignable<T>::value)
+  constexpr iterator erase(iterator it_start, iterator it_end) noexcept(std::is_move_assignable_v<T>)
   {
     srsran_assert(it_start <= it_end, "Trying to erase invalid range");
     srsran_assert(it_start >= begin() and it_end <= end(), "Range to erase is out-of-bounds");
@@ -353,20 +364,20 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
     return ret;
   }
 
-  constexpr void assign(size_type nof_elems, const T& value) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr void assign(size_type nof_elems, const T& value) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     clear();
     assign_unsafe_(nof_elems, value);
   }
 
   template <typename Iterator>
-  constexpr void assign(Iterator it_start, Iterator it_end) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr void assign(Iterator it_start, Iterator it_end) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     clear();
     assign_unsafe_(it_start, it_end);
   }
 
-  constexpr void assign(std::initializer_list<T> ilist) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr void assign(std::initializer_list<T> ilist) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     assign(ilist.begin(), ilist.end());
   }
@@ -404,7 +415,7 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
       this->destroy_(it);
     }
   }
-  constexpr void assign_unsafe_(size_t N, const T& val) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr void assign_unsafe_(size_t N, const T& val) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     srsran_assert(N <= MAX_N, "static vector maximum size={} was exceeded", MAX_N);
     // Note: Gcc 11 fails compilation without this hint. Potentially a bug.
@@ -415,8 +426,7 @@ class static_vector : private detail::static_vector_storage<T, MAX_N>
     this->sz = N;
   }
   template <typename Iterator>
-  constexpr void assign_unsafe_(Iterator it_begin,
-                                Iterator it_end) noexcept(std::is_nothrow_copy_constructible<T>::value)
+  constexpr void assign_unsafe_(Iterator it_begin, Iterator it_end) noexcept(std::is_nothrow_copy_constructible_v<T>)
   {
     size_type N = std::distance(it_begin, it_end);
     srsran_assert(N <= MAX_N, "static vector maximum size={} was exceeded", MAX_N);

tests/unittests/adt/static_vector_test.cpp

@@ -21,18 +21,18 @@
 
 using namespace srsran;
 
-static_assert(std::is_same<static_vector<int, 5>::value_type, int>::value, "Invalid traits");
-static_assert(std::is_trivially_destructible<static_vector<int, 5>>::value, "Invalid traits");
-static_assert(std::is_default_constructible<static_vector<int, 5>>::value, "Invalid traits");
-static_assert(not std::is_trivially_destructible<static_vector<moveonly_test_object, 5>>::value, "Invalid traits");
-static_assert(std::is_default_constructible<static_vector<moveonly_test_object, 5>>::value, "Invalid traits");
-static_assert(std::is_default_constructible<static_vector<nondefault_ctor_test_object, 5>>::value, "Invalid traits");
+static_assert(std::is_same_v<static_vector<int, 5>::value_type, int>, "Invalid traits");
+static_assert(std::is_trivially_destructible_v<static_vector<int, 5>>, "Invalid traits");
+static_assert(std::is_default_constructible_v<static_vector<int, 5>>, "Invalid traits");
+static_assert(not std::is_trivially_destructible_v<static_vector<moveonly_test_object, 5>>, "Invalid traits");
+static_assert(std::is_default_constructible_v<static_vector<moveonly_test_object, 5>>, "Invalid traits");
+static_assert(std::is_default_constructible_v<static_vector<nondefault_ctor_test_object, 5>>, "Invalid traits");
 
 std::vector<int> create_test_vector(size_t sz)
 {
   std::vector<int> v(sz);
-  for (unsigned i = 0; i != v.size(); ++i) {
-    v[i] = test_rgen::uniform_int<int>();
+  for (int& i : v) {
+    i = test_rgen::uniform_int<int>();
   }
   return v;
 }
@@ -165,8 +165,8 @@ TYPED_TEST(static_vector_tester, push_back_creates_new_element_at_the_back)
   std::vector<int>     expected = create_test_vector(test_rgen::uniform_int<size_t>(0, 10));
   static_vector<T, 10> vec;
 
-  for (unsigned i = 0; i != expected.size(); ++i) {
-    vec.push_back(T(expected[i]));
+  for (int i : expected) {
+    vec.push_back(T(i));
   }
 
   ASSERT_EQ(vec.size(), expected.size());