sleipnirgroup-jormungandr 0.6.7.dev44__tar.gz → 0.6.7.dev46__tar.gz

{sleipnirgroup_jormungandr-0.6.7.dev44 → sleipnirgroup_jormungandr-0.6.7.dev46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sleipnirgroup-jormungandr
-Version: 0.6.7.dev44
+Version: 0.6.7.dev46
 Summary: Reverse mode autodiff library and NLP solver DSL
 License-Expression: BSD-3-Clause
 License-File: LICENSE.txt

{sleipnirgroup_jormungandr-0.6.7.dev44 → sleipnirgroup_jormungandr-0.6.7.dev46}/include/sleipnir/autodiff/expression.hpp

@@ -772,8 +772,7 @@ constexpr void dec_ref_count(Expression<Scalar>* expr) {
       // refcounts, which was already done above.
       if constexpr (USE_POOL_ALLOCATOR) {
         auto alloc = global_pool_allocator<Expression<Scalar>>();
-        std::allocator_traits<decltype(alloc)>::deallocate(
-            alloc, elem, sizeof(Expression<Scalar>));
+        std::allocator_traits<decltype(alloc)>::deallocate(alloc, elem, 1);
       } else {
         operator delete(elem);
       }

{sleipnirgroup_jormungandr-0.6.7.dev44 → sleipnirgroup_jormungandr-0.6.7.dev46}/include/sleipnir/util/intrusive_shared_ptr.hpp

@@ -272,7 +272,7 @@ IntrusiveSharedPtr<T> make_intrusive_shared(Args&&... args) {
 /// @param args Constructor arguments for T.
 template <typename T, typename Alloc, typename... Args>
 IntrusiveSharedPtr<T> allocate_intrusive_shared(Alloc alloc, Args&&... args) {
-  auto ptr = std::allocator_traits<Alloc>::allocate(alloc, sizeof(T));
+  auto ptr = std::allocator_traits<Alloc>::allocate(alloc, 1);
   std::allocator_traits<Alloc>::construct(alloc, ptr,
                                           std::forward<Args>(args)...);
   return IntrusiveSharedPtr<T>{ptr};

{sleipnirgroup_jormungandr-0.6.7.dev44 → sleipnirgroup_jormungandr-0.6.7.dev46}/include/sleipnir/util/pool.hpp

@@ -2,7 +2,6 @@
 
 #pragma once
 
-#include <algorithm>
 #include <cstddef>
 #include <memory>
 
@@ -24,8 +23,10 @@ class SLEIPNIR_DLLEXPORT PoolResource {
   /// Constructs a default PoolResource.
   ///
   /// @param blocks_per_chunk Number of blocks per chunk of memory.
-  explicit PoolResource(size_t blocks_per_chunk)
-      : blocks_per_chunk{blocks_per_chunk} {}
+  explicit PoolResource(size_t blocks_per_chunk);
+
+  /// Destructor.
+  ~PoolResource();
 
   /// Copy constructor.
   PoolResource(const PoolResource&) = delete;
@@ -36,12 +37,12 @@ class SLEIPNIR_DLLEXPORT PoolResource {
   PoolResource& operator=(const PoolResource&) = delete;
 
   /// Move constructor.
-  PoolResource(PoolResource&&) = default;
+  PoolResource(PoolResource&&);
 
   /// Move assignment operator.
   ///
   /// @return This pool resource.
-  PoolResource& operator=(PoolResource&&) = default;
+  PoolResource& operator=(PoolResource&&);
 
   /// Returns a block of memory from the pool.
   ///
@@ -50,27 +51,7 @@ class SLEIPNIR_DLLEXPORT PoolResource {
   ///     than alignof(std::max_align_t).
   /// @return A block of memory from the pool.
   [[nodiscard]]
-  void* allocate(size_t bytes, size_t alignment = alignof(std::max_align_t)) {
-    // Round up to a multiple of the alignment so consecutive blocks in a chunk
-    // stay aligned. `alignment` is a power of two, so `alignment - 1` is a mask
-    // of the bits below it.
-    //
-    // 1. Add `alignment - 1` so the round-down in step 4 becomes a round-up
-    // 2. Create mask `alignment - 1` with every bit below the alignment set
-    // 3. Invert mask via `~(alignment - 1)` so only higher bits are set
-    // 4. Bitwise AND to zero out lower bits, rounding down to a multiple of the
-    //    alignment
-    size_t block_size = (bytes + alignment - 1) & ~(alignment - 1);
-
-    auto& pool = get_pool(block_size);
-    if (pool.free_list.empty()) {
-      add_chunk(pool);
-    }
-
-    auto ptr = pool.free_list.back();
-    pool.free_list.pop_back();
-    return ptr;
-  }
+  void* allocate(size_t bytes, size_t alignment = alignof(std::max_align_t));
 
   /// Gives a block of memory back to the pool.
   ///
@@ -80,17 +61,8 @@ class SLEIPNIR_DLLEXPORT PoolResource {
   /// @param p A pointer to the block of memory.
   /// @param bytes Number of bytes in the block (unused).
   /// @param alignment Alignment of the block (unused).
-  void deallocate(
-      void* p, [[maybe_unused]] size_t bytes,
-      [[maybe_unused]] size_t alignment = alignof(std::max_align_t)) {
-    // Find the last chunk that starts at or before p
-    auto chunk = std::upper_bound(
-        m_chunks.begin(), m_chunks.end(), static_cast<std::byte*>(p),
-        [](const std::byte* ptr, const Chunk& c) { return ptr < c.begin; });
-    --chunk;
-
-    m_pools[chunk->pool_index].free_list.emplace_back(p);
-  }
+  void deallocate(void* p, size_t bytes,
+                  size_t alignment = alignof(std::max_align_t));
 
   /// Returns true if this pool resource has the same backing storage as
   /// another.
@@ -144,35 +116,13 @@ class SLEIPNIR_DLLEXPORT PoolResource {
   ///
   /// @param block_size Number of bytes per block.
   /// @return The pool for the given block size.
-  Pool& get_pool(size_t block_size) {
-    for (auto& pool : m_pools) {
-      if (pool.block_size == block_size) {
-        return pool;
-      }
-    }
-
-    return m_pools.emplace_back(Pool{block_size, {}});
-  }
+  Pool& get_pool(size_t block_size);
 
   /// Adds a memory chunk to the given pool, partitions it into blocks with the
   /// pool's block size, and appends pointers to them to the pool's free list.
   ///
   /// @param pool The pool.
-  void add_chunk(Pool& pool) {
-    auto begin =
-        m_buffer.emplace_back(new std::byte[pool.block_size * blocks_per_chunk])
-            .get();
-
-    size_t pool_index = &pool - m_pools.data();
-    auto pos = std::upper_bound(
-        m_chunks.begin(), m_chunks.end(), begin,
-        [](const std::byte* ptr, const Chunk& c) { return ptr < c.begin; });
-    m_chunks.insert(pos, Chunk{begin, pool_index});
-
-    for (int i = blocks_per_chunk - 1; i >= 0; --i) {
-      pool.free_list.emplace_back(begin + pool.block_size * i);
-    }
-  }
+  void add_chunk(Pool& pool);
 };
 
 /// This class is an allocator for the pool resource.
@@ -199,19 +149,20 @@ class PoolAllocator {
 
   /// Returns a block of memory from the pool.
   ///
-  /// @param n Number of bytes in the block.
+  /// @param n Number of objects in the block.
   /// @return A block of memory from the pool.
   [[nodiscard]]
   constexpr T* allocate(size_t n) {
-    return static_cast<T*>(m_memory_resource->allocate(n, alignof(T)));
+    return static_cast<T*>(
+        m_memory_resource->allocate(n * sizeof(T), alignof(T)));
   }
 
   /// Gives a block of memory back to the pool.
   ///
   /// @param p A pointer to the block of memory.
-  /// @param n Number of bytes in the block.
+  /// @param n Number of objects in the block.
   constexpr void deallocate(T* p, size_t n) {
-    m_memory_resource->deallocate(p, n, alignof(T));
+    m_memory_resource->deallocate(p, n * sizeof(T), alignof(T));
   }
 
  private:

{sleipnirgroup_jormungandr-0.6.7.dev44 → sleipnirgroup_jormungandr-0.6.7.dev46}/python/src/sleipnir/__init__.py

@@ -2,4 +2,4 @@
 
 from ._sleipnir import *
 
-__version__ = "0.6.7.dev44"
+__version__ = "0.6.7.dev46"

sleipnirgroup_jormungandr-0.6.7.dev46/src/util/pool.cpp

@@ -0,0 +1,79 @@
+// Copyright (c) Sleipnir contributors
+
+#include "sleipnir/util/pool.hpp"
+
+#include <algorithm>
+#include <cstddef>
+
+slp::PoolResource::PoolResource(size_t blocks_per_chunk)
+    : blocks_per_chunk{blocks_per_chunk} {}
+
+slp::PoolResource::~PoolResource() = default;
+
+slp::PoolResource::PoolResource(PoolResource&&) = default;
+
+slp::PoolResource& slp::PoolResource::operator=(PoolResource&&) = default;
+
+void* slp::PoolResource::allocate(size_t bytes, size_t alignment) {
+  // Round up to a multiple of the alignment so consecutive blocks in a chunk
+  // stay aligned. `alignment` is a power of two, so `alignment - 1` is a mask
+  // of the bits below it.
+  //
+  // 1. Add `alignment - 1` so the round-down in step 4 becomes a round-up
+  // 2. Create mask `alignment - 1` with every bit below the alignment set
+  // 3. Invert mask via `~(alignment - 1)` so only higher bits are set
+  // 4. Bitwise AND to zero out lower bits, rounding down to a multiple of the
+  //    alignment
+  size_t block_size = (bytes + alignment - 1) & ~(alignment - 1);
+
+  auto& pool = get_pool(block_size);
+  if (pool.free_list.empty()) {
+    add_chunk(pool);
+  }
+
+  auto ptr = pool.free_list.back();
+  pool.free_list.pop_back();
+  return ptr;
+}
+
+void slp::PoolResource::deallocate(void* p, [[maybe_unused]] size_t bytes,
+                                   [[maybe_unused]] size_t alignment) {
+  // Find the last chunk that starts at or before p
+  auto chunk = std::upper_bound(
+      m_chunks.begin(), m_chunks.end(), static_cast<std::byte*>(p),
+      [](const std::byte* ptr, const Chunk& c) { return ptr < c.begin; });
+  --chunk;
+
+  m_pools[chunk->pool_index].free_list.emplace_back(p);
+}
+
+slp::PoolResource::Pool& slp::PoolResource::get_pool(size_t block_size) {
+  for (auto& pool : m_pools) {
+    if (pool.block_size == block_size) {
+      return pool;
+    }
+  }
+
+  return m_pools.emplace_back(Pool{block_size, {}});
+}
+
+void slp::PoolResource::add_chunk(Pool& pool) {
+  auto begin =
+      m_buffer.emplace_back(new std::byte[pool.block_size * blocks_per_chunk])
+          .get();
+
+  size_t pool_index = &pool - m_pools.data();
+  auto pos = std::upper_bound(
+      m_chunks.begin(), m_chunks.end(), begin,
+      [](const std::byte* ptr, const Chunk& c) { return ptr < c.begin; });
+  m_chunks.insert(pos, Chunk{begin, pool_index});
+
+  for (int i = blocks_per_chunk - 1; i >= 0; --i) {
+    pool.free_list.emplace_back(begin + pool.block_size * i);
+  }
+}
+
+slp::PoolResource& slp::global_pool_resource() {
+  thread_local PoolResource pool{16384};
+  return pool;
+}

sleipnirgroup_jormungandr-0.6.7.dev44/src/util/pool.cpp

@@ -1,8 +0,0 @@
-// Copyright (c) Sleipnir contributors
-
-#include "sleipnir/util/pool.hpp"
-
-slp::PoolResource& slp::global_pool_resource() {
-  thread_local PoolResource pool{16384};
-  return pool;
-}