Add o1heapGetMaxAllocationSize(), closes #18

Author: pavel-kirienko

o1heap/o1heap.c

@@ -476,6 +476,14 @@ void o1heapFree(O1HeapInstance* const handle, void* const pointer)
     }
 }
 
+size_t o1heapGetMaxAllocationSize(const O1HeapInstance* const handle)
+{
+    O1HEAP_ASSERT(handle != NULL);
+    // The largest allocation is smaller (up to almost two times) than the arena capacity,
+    // due to the power-of-two padding and the fragment header overhead.
+    return pow2(log2Floor(handle->diagnostics.capacity)) - O1HEAP_ALIGNMENT;
+}
+
 bool o1heapDoInvariantsHold(const O1HeapInstance* const handle)
 {
     O1HEAP_ASSERT(handle != NULL);

o1heap/o1heap.h

@@ -104,6 +104,10 @@ void* o1heapAllocate(O1HeapInstance* const handle, const size_t amount);
 /// The function is executed in constant time.
 void o1heapFree(O1HeapInstance* const handle, void* const pointer);
 
+/// Obtains the maximum theoretically possible allocation size for this heap instance.
+/// This is useful when implementing std::allocator_traits<Alloc>::max_size.
+size_t o1heapGetMaxAllocationSize(const O1HeapInstance* const handle);
+
 /// Performs a basic sanity check on the heap.
 /// This function can be used as a weak but fast method of heap corruption detection.
 /// If the handle pointer is NULL, the behavior is undefined.

tests/internal.hpp

@@ -167,6 +167,11 @@ struct O1HeapInstance final
         validate();
     }
 
+    [[nodiscard]] auto getMaxAllocationSize() const
+    {
+        return o1heapGetMaxAllocationSize(reinterpret_cast<const ::O1HeapInstance*>(this));
+    }
+
     [[nodiscard]] auto doInvariantsHold() const
     {
         return o1heapDoInvariantsHold(reinterpret_cast<const ::O1HeapInstance*>(this));

tests/test_general.cpp

@@ -562,6 +562,27 @@ TEST_CASE("General: random A")
     }
 }
 
+TEST_CASE("General: max allocation size")
+{
+    alignas(128U) std::array<std::byte, 4096U + sizeof(internal::O1HeapInstance) + O1HEAP_ALIGNMENT - 1U> arena{};
+    {
+        auto heap = init(arena.data(), std::size(arena));
+        REQUIRE(heap != nullptr);
+        REQUIRE(heap->diagnostics.capacity == 4096);
+        REQUIRE(4096 - O1HEAP_ALIGNMENT == heap->getMaxAllocationSize());
+        REQUIRE(nullptr == heap->allocate(heap->getMaxAllocationSize() + 1));
+        REQUIRE(nullptr != heap->allocate(heap->getMaxAllocationSize() + 0));
+    }
+    {
+        auto heap = init(arena.data(), std::size(arena) - O1HEAP_ALIGNMENT);
+        REQUIRE(heap != nullptr);
+        REQUIRE(heap->diagnostics.capacity < 4095);
+        REQUIRE(2048 - O1HEAP_ALIGNMENT == heap->getMaxAllocationSize());
+        REQUIRE(nullptr == heap->allocate(heap->getMaxAllocationSize() + 1));
+        REQUIRE(nullptr != heap->allocate(heap->getMaxAllocationSize() + 0));
+    }
+}
+
 TEST_CASE("General: invariant checker")
 {
     using internal::Fragment;