Buddy (#468)

# Small changes before rewrite

* Additional bit in remote allocator to prevent type confusion with the backend.
* Move Chunk allocator to backend.
* Improvements to RedBlack tree
* Expose message from Pal

# Complete backend rewrite

This provides two key changes:

* We use buddy allocators to allow memory to reconsolidated
* The backend is factored into a series of small operations that
    allocate and deallocate memory.

The backend now uses "Ranges", there are two ranges that don't require a
parent range:
* EmptyRange - Never returns any memory
* PalRange - Returns memory from the platform.

All other ranges require a parent range to supply memory to them.  Some
ranges support both allocation and deallocation, and some just
deallocation.  For instance,  CommitRange supports both, and maps
requests to the parent range, but will Commit and Decommit the memory.

As the ranges perform only a single task, they are generally small and
easy to follow.  The two exceptions to this are the two BuddyRanges
(Large and Small).  Large is for CHUNK_SIZE and above blocks, while
Small is for below CHUNK_SIZE blocks.  Both are implemented with a buddy
allocator, but the SmallBuddyRange uses in place meta-data, while the
LargeBuddyRange uses the pagemap for its meta-data.  This means the
LargeBuddyRange can keep the majority of memory it is managing
decommitted.

The Backend glues together the various ranges to support the appropriate
way to manage memory on the platform.

src/mem/localalloc.h

@@ -180,13 +180,11 @@ namespace snmalloc
       return check_init([&](CoreAlloc* core_alloc) {
         // Grab slab of correct size
         // Set remote as large allocator remote.
-        auto [chunk, meta] = ChunkAllocator::alloc_chunk<SharedStateHandle>(
+        auto [chunk, meta] = SharedStateHandle::alloc_chunk(
           core_alloc->get_backend_local_state(),
-          core_alloc->chunk_local_state,
-          size_to_sizeclass_full(size),
-          large_size_to_chunk_sizeclass(size),
           large_size_to_chunk_size(size),
-          core_alloc->public_state());
+          core_alloc->public_state(),
+          size_to_sizeclass_full(size));
         // set up meta data so sizeclass is correct, and hence alloc size, and
         // external pointer.
 #ifdef SNMALLOC_TRACING
@@ -201,7 +199,7 @@ namespace snmalloc
         if (zero_mem == YesZero && chunk.unsafe_ptr() != nullptr)
         {
           SharedStateHandle::Pal::template zero<false>(
-            chunk.unsafe_ptr(), size);
+            chunk.unsafe_ptr(), bits::next_pow2(size));
         }
 
         return capptr_chunk_is_alloc(capptr_to_user_address_control(chunk));
@@ -268,7 +266,7 @@ namespace snmalloc
         std::cout << "Remote dealloc post" << p.unsafe_ptr() << " size "
                   << alloc_size(p.unsafe_ptr()) << std::endl;
 #endif
-        MetaEntry entry =
+        const MetaEntry& entry =
           SharedStateHandle::Pagemap::get_metaentry(address_cast(p));
         local_cache.remote_dealloc_cache.template dealloc<sizeof(CoreAlloc)>(
           entry.get_remote()->trunc_id(), p, key_global);
@@ -716,7 +714,7 @@ namespace snmalloc
       // To handle this case we require the uninitialised pagemap contain an
       // entry for the first chunk of memory, that states it represents a
       // large object, so we can pull the check for null off the fast path.
-      MetaEntry entry =
+      const MetaEntry& entry =
         SharedStateHandle::Pagemap::get_metaentry(address_cast(p_raw));
 
       return sizeclass_full_to_size(entry.get_sizeclass());
@@ -761,7 +759,7 @@ namespace snmalloc
     size_t remaining_bytes(const void* p)
     {
 #ifndef SNMALLOC_PASS_THROUGH
-      MetaEntry entry =
+      const MetaEntry& entry =
         SharedStateHandle::Pagemap::template get_metaentry<true>(
           address_cast(p));
 
@@ -790,7 +788,7 @@ namespace snmalloc
     size_t index_in_object(const void* p)
     {
 #ifndef SNMALLOC_PASS_THROUGH
-      MetaEntry entry =
+      const MetaEntry& entry =
         SharedStateHandle::Pagemap::template get_metaentry<true>(
           address_cast(p));