Merge pull request #252 from Libvisual/c++17-mem-alloc

Core (Memory): Streamline AlignedAllocator for C++17 and add aligned allocation unit tests.

Author: kaixiong

libvisual/libvisual/lv_aligned_allocator.hpp

@@ -1,104 +1,59 @@
 #ifndef _LV_ALIGNED_ALLOCATOR_HPP
 #define _LV_ALIGNED_ALLOCATOR_HPP
 
-#include <cstddef>
-#include <cstdlib>
-#include <new>
 #include <libvisual/lv_mem.h>
+#include <cstdlib>
+#include <limits>
+#include <memory>
+#include <stdexcept>
 
-namespace LV {
-
-  template <typename T, std::size_t alignment>
-  struct AlignedAllocator;
-
-  template <std::size_t alignment>
-  struct AlignedAllocator<void, alignment>
-  {
-      typedef void        value_type;
-      typedef void*       pointer;
-      typedef void const* const_pointer;
-
-      template <typename U>
-      struct rebind { typedef AlignedAllocator<U, alignment> other; };
-  };
-
+namespace LV
+{
   //! Aligned memory allocator.
   //!
-  //! @tparam T         type of object to allocate
   //! @tparam alignment alignment boundary
+  //! @tparam T         type of object to allocate
   //!
   //! AlignedAllocator is an implementation of the C++ Allocator concept for use with standard library containers.
   //!
-  template <typename T, std::size_t alignment>
+  template <std::size_t alignment, typename T = std::byte>
   struct AlignedAllocator
   {
-      typedef T*             pointer;
-      typedef T&             reference;
-      typedef T const*       const_pointer;
-      typedef T const&       const_reference;
-      typedef T              value_type;
-      typedef std::size_t    size_type;
-      typedef std::ptrdiff_t difference_type;
+      using value_type = T;
 
-      template <typename U>
-      struct rebind { typedef AlignedAllocator<U, alignment> other; };
-
-      AlignedAllocator ()
-      {}
+      AlignedAllocator () = default;
 
       template <typename U>
-      AlignedAllocator (AlignedAllocator<U, alignment>&)
+      constexpr AlignedAllocator (AlignedAllocator<alignment, U> const&) noexcept
       {}
 
-      pointer address (reference x) const
+      [[nodiscard]] T* allocate (std::size_t n)
       {
-          return &x;
-      }
+          if (n > std::numeric_limits<std::size_t>::max () / sizeof (T))
+              throw std::bad_array_new_length {};
 
-      const_pointer address (const_reference x) const
-      {
-          return &x;
-      }
-
-      pointer allocate (size_type n, typename AlignedAllocator<void, alignment>::pointer = nullptr)
-      {
-          void* ptr = visual_mem_malloc_aligned (n * sizeof (T), alignment);
+          auto ptr = visual_mem_malloc_aligned (n * sizeof (T), alignment);
 
           if (!ptr)
-              throw std::bad_alloc ();
+              throw std::bad_alloc {};
 
-          return pointer (ptr);
+          return static_cast<T*> (ptr);
       }
 
-      void deallocate (pointer ptr, size_type) noexcept
+      void deallocate (T* ptr, std::size_t) noexcept
       {
           visual_mem_free_aligned (ptr);
       }
-
-      size_type max_size () const
-      {
-          return size_type (-1) / sizeof (T);
-      }
-
-      void construct (pointer p, const_reference x)
-      {
-          new (p) T (x);
-      }
-
-      void destroy (pointer p)
-      {
-          p->~T ();
-      }
   };
 
   template <typename T, typename U, std::size_t alignment>
-  bool operator== (AlignedAllocator<T, alignment> const&, AlignedAllocator<U, alignment> const&)
+  bool operator== (AlignedAllocator<alignment, T> const&, AlignedAllocator<alignment, U> const&)
   {
       return true;
   }
 
   template <typename T, typename U, std::size_t alignment>
-  bool operator!= (AlignedAllocator<T, alignment> const&, AlignedAllocator<U, alignment> const&)
+  bool operator!= (AlignedAllocator<alignment, T> const&, AlignedAllocator<alignment, U> const&)
   {
       return false;
   }

libvisual/tests/CMakeLists.txt

@@ -5,5 +5,6 @@ INCLUDE_DIRECTORIES(
 )
 
 ADD_SUBDIRECTORY(audio_test)
+ADD_SUBDIRECTORY(mem_test)
 ADD_SUBDIRECTORY(video_test)
 ADD_SUBDIRECTORY(time_test)

libvisual/tests/mem_test/CMakeLists.txt

@@ -0,0 +1,3 @@
+LV_BUILD_TEST(aligned_allocation_test
+  SOURCES aligned_allocation_test.cpp
+)

libvisual/tests/mem_test/aligned_allocation_test.cpp

@@ -0,0 +1,63 @@
+#include "test.h"
+#include <libvisual/libvisual.h>
+#include <libvisual/lv_aligned_allocator.hpp>
+#include <string>
+#include <vector>
+#include <cstdint>
+
+namespace
+{
+  inline bool ptr_is_aligned (void* ptr, std::size_t alignment)
+  {
+      return (reinterpret_cast<std::intptr_t> (ptr) % alignment) == 0;
+  }
+
+  void test_allocation ()
+  {
+      std::array<std::size_t, 6> constexpr alignments { 4, 8, 16, 32, 64, 128 };
+
+      for (auto alignment = alignments.begin (); alignment != alignments.end(); ++alignment) {
+          std::size_t const test_block_size = *alignment * 2 + 1;
+
+          void* ptr = visual_mem_malloc_aligned (test_block_size, *alignment);
+          LV_TEST_ASSERT (ptr_is_aligned (ptr, *alignment));
+
+          visual_mem_free_aligned (ptr);
+      }
+  }
+
+  template <std::size_t alignment>
+  void test_cxx_allocator ()
+  {
+      constexpr size_t test_count = 3;
+
+      LV::AlignedAllocator<alignment, std::string> allocator;
+      using allocator_traits = std::allocator_traits<decltype(allocator)>;
+
+      std::string* strings = allocator_traits::allocate (allocator, test_count);
+
+      LV_TEST_ASSERT (ptr_is_aligned (strings, alignment));
+
+      allocator_traits::deallocate (allocator, strings, test_count);
+  }
+
+  void test_cxx_allocators ()
+  {
+      test_cxx_allocator<4> ();
+      test_cxx_allocator<8> ();
+      test_cxx_allocator<16> ();
+      test_cxx_allocator<32> ();
+      test_cxx_allocator<64> ();
+      test_cxx_allocator<128> ();
+  }
+}
+
+int main (int argc, char* argv[])
+{
+    LV::System::init (argc, argv);
+
+    test_allocation ();
+    test_cxx_allocators ();
+
+    LV::System::destroy ();
+}