Remove at_least

The Pal was providing policy for overallocating a block of memory to
achieve alignment make that part of the backend.
The backend should be responsible for layout policy.

src/pal/pal_concept.h

@@ -52,11 +52,10 @@ namespace snmalloc
    * Absent any feature flags, the PAL must support a crude primitive allocator
    */
   template<typename PAL>
-  concept ConceptPAL_reserve_at_least =
-    requires(PAL p, void* vp, std::size_t sz)
+  concept ConceptPAL_reserve =
+    requires(PAL p, std::size_t sz)
   {
-    { PAL::reserve_at_least(sz) } noexcept
-      -> ConceptSame<std::pair<void*, std::size_t>>;
+    { PAL::reserve(sz) } noexcept -> ConceptSame<void*>;
   };
 
   /**
@@ -102,10 +101,11 @@ namespace snmalloc
     (!pal_supports<LowMemoryNotification, PAL> ||
       ConceptPAL_mem_low_notify<PAL>) &&
     (pal_supports<NoAllocation, PAL> ||
-     (pal_supports<AlignedAllocation, PAL> &&
-        ConceptPAL_reserve_aligned<PAL>) ||
-     (!pal_supports<AlignedAllocation, PAL> &&
-          ConceptPAL_reserve_at_least<PAL>));
+     (
+       (!pal_supports<AlignedAllocation, PAL> ||
+         ConceptPAL_reserve_aligned<PAL>) &&
+      ConceptPAL_reserve<PAL>)
+    );
 
 } // namespace snmalloc
 #endif

src/pal/pal_posix.h

@@ -253,44 +253,32 @@ namespace snmalloc
      * POSIX does not define a portable interface for specifying alignment
      * greater than a page.
      */
-    static std::pair<void*, size_t> reserve_at_least(size_t size) noexcept
+    static void* reserve(size_t size) noexcept
     {
-      SNMALLOC_ASSERT(bits::is_pow2(size));
-
-      // Magic number for over-allocating chosen by the Pal
-      // These should be further refined based on experiments.
-      constexpr size_t min_size =
-        bits::is64() ? bits::one_at_bit(31) : bits::one_at_bit(27);
-
 #ifdef SNMALLOC_CHECK_CLIENT
       auto prot = PROT_NONE;
 #else
       auto prot = PROT_READ | PROT_WRITE;
 #endif
 
-      for (size_t size_request = bits::max(size, min_size);
-           size_request >= size;
-           size_request = size_request / 2)
-      {
-        void* p = mmap(
-          nullptr,
-          size_request,
-          prot,
-          MAP_PRIVATE | MAP_ANONYMOUS | DefaultMMAPFlags<OS>::flags,
-          AnonFD<OS>::fd,
-          0);
+      void* p = mmap(
+        nullptr,
+        size,
+        prot,
+        MAP_PRIVATE | MAP_ANONYMOUS | DefaultMMAPFlags<OS>::flags,
+        AnonFD<OS>::fd,
+        0);
 
-        if (p != MAP_FAILED)
-        {
+      if (p != MAP_FAILED)
+      {
 #ifdef SNMALLOC_TRACING
-          std::cout << "Pal_posix reserved: " << p << " (" << size_request
-                    << ")" << std::endl;
+        std::cout << "Pal_posix reserved: " << p << " (" << size << ")"
+                  << std::endl;
 #endif
-          return {p, size_request};
-        }
+        return p;
       }
 
-      OS::error("Out of memory");
+      return nullptr;
     }
 
     /**

src/pal/pal_windows.h

@@ -185,26 +185,9 @@ namespace snmalloc
     }
 #  endif
 
-    static std::pair<void*, size_t> reserve_at_least(size_t size) noexcept
+    static void* reserve(size_t size) noexcept
     {
-      SNMALLOC_ASSERT(bits::is_pow2(size));
-
-      // Magic number for over-allocating chosen by the Pal
-      // These should be further refined based on experiments.
-      constexpr size_t min_size =
-        bits::is64() ? bits::one_at_bit(32) : bits::one_at_bit(28);
-      for (size_t size_request = bits::max(size, min_size);
-           size_request >= size;
-           size_request = size_request / 2)
-      {
-        void* ret =
-          VirtualAlloc(nullptr, size_request, MEM_RESERVE, PAGE_READWRITE);
-        if (ret != nullptr)
-        {
-          return std::pair(ret, size_request);
-        }
-      }
-      error("Failed to allocate memory\n");
+      return VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
     }
 
     /**