WIP: Hack to optimise based on known sizes

If the caller knows the sizes, and knows the allocation is thread local,
 then we can make some significant optimisations.
 This is a brief hack to show where would need changing.

Author: mjp41

src/mem/alloc.h

@@ -1040,7 +1040,8 @@ namespace snmalloc
           allow_reserve == NoReserve ? "noreserve" : "reserve"));
 
       SNMALLOC_ASSUME(size <= SLAB_SIZE);
-      sizeclass_t sizeclass = size_to_sizeclass(size);
+      SNMALLOC_ASSUME(size > 0);
+      sizeclass_t sizeclass = size_to_sizeclass<true>(size);
       return small_alloc_inner<zero_mem, allow_reserve>(sizeclass, size);
     }
 
@@ -1066,6 +1067,13 @@ namespace snmalloc
         return p;
       }
 
+      return small_alloc_inner_slow<zero_mem, allow_reserve>(sizeclass, size);
+    }
+
+    template<ZeroMem zero_mem, AllowReserve allow_reserve>
+    SNMALLOC_FAST_PATH void*
+    small_alloc_inner_slow(sizeclass_t sizeclass, size_t size)
+    {
       if (likely(!has_messages()))
         return small_alloc_next_free_list<zero_mem, allow_reserve>(
           sizeclass, size);
@@ -1228,6 +1236,21 @@ namespace snmalloc
       small_dealloc_offseted_inner(super, p, sizeclass);
     }
 
+    static SNMALLOC_FAST_PATH bool small_local_dealloc(void* p)
+    {
+      auto super = Superslab::get(p);
+      Slab* slab = Metaslab::get_slab(p);
+      return (likely(slab->dealloc_fast(super, p)));
+    }
+
+    SNMALLOC_FAST_PATH void small_local_dealloc_slow(void* p)
+    {
+      auto super = Superslab::get(p);
+      Slab* slab = Metaslab::get_slab(p);
+      small_dealloc_offseted_slow(super, p, slab->get_meta().sizeclass);
+    }
+
+
     SNMALLOC_FAST_PATH void small_dealloc_offseted_inner(
       Superslab* super, void* p, sizeclass_t sizeclass)
     {

src/mem/sizeclass.h

@@ -20,7 +20,7 @@ namespace snmalloc
   constexpr static size_t
   sizeclass_to_inverse_cache_friendly_mask(sizeclass_t sc);
   constexpr static uint16_t medium_slab_free(sizeclass_t sizeclass);
-  static sizeclass_t size_to_sizeclass(size_t size);
+  template<bool ASSUME_SMALL = false> static sizeclass_t size_to_sizeclass(size_t size);
 
   constexpr static inline sizeclass_t size_to_sizeclass_const(size_t size)
   {

src/mem/sizeclasstable.h

@@ -110,9 +110,10 @@ namespace snmalloc
     return sizeclass_metadata.inverse_cache_friendly_mask[sizeclass];
   }
 
+  template <bool ASSUME_SMALL>
   static inline sizeclass_t size_to_sizeclass(size_t size)
   {
-    if ((size - 1) <= (SLAB_SIZE - 1))
+    if ((size - 1) <= (SLAB_SIZE - 1) || ASSUME_SMALL)
     {
       auto index = sizeclass_lookup_index(size);
       SNMALLOC_ASSUME(index <= sizeclass_lookup_index(SLAB_SIZE));

src/override/malloc.cc

@@ -69,6 +69,25 @@ extern "C"
     return ThreadAlloc::get_noncachable()->alloc<ZeroMem::YesZero>(sz);
   }
 
+  SNMALLOC_EXPORT
+  void SNMALLOC_NAME_MANGLE(free_local_small)(void* ptr)
+  {
+    if (Alloc::small_local_dealloc(ptr)) return;
+    ThreadAlloc::get_noncachable()->small_local_dealloc_slow(ptr);
+  }
+
+  SNMALLOC_EXPORT
+  void* SNMALLOC_NAME_MANGLE(malloc_small)(size_t size)
+  {
+    return ThreadAlloc::get_noncachable()->small_alloc<NoZero, YesReserve>(size);
+  }
+
+  SNMALLOC_EXPORT
+  void* SNMALLOC_NAME_MANGLE(malloc_small_64)()
+  {
+    return ThreadAlloc::get_noncachable()->small_alloc<NoZero, YesReserve>(64);
+  }
+
   SNMALLOC_EXPORT
   size_t SNMALLOC_NAME_MANGLE(malloc_usable_size)(
     MALLOC_USABLE_SIZE_QUALIFIER void* ptr)

src/test/func/malloc/malloc.cc

@@ -116,6 +116,12 @@ void test_memalign(size_t size, size_t align, int err, bool null)
   check_result(size, align, p, err, null);
 }
 
+void test_local(size_t size)
+{
+  for (int n = 0; n < 1000; n++)
+    our_free_local_small(our_malloc_small(size));
+}
+
 int main(int argc, char** argv)
 {
   UNUSED(argc);
@@ -125,6 +131,11 @@ int main(int argc, char** argv)
 
   constexpr int SUCCESS = 0;
 
+  for (size_t i = 1; i < SLAB_SIZE; i+=16)
+  {
+    test_local(i);
+  }
+
   test_realloc(our_malloc(64), 4194304, SUCCESS, false);
 
   for (sizeclass_t sc = 0; sc < (SUPERSLAB_BITS + 4); sc++)