Refactor: Remove unused features and functions, and move most allocator operations to a global namespace. (#750)

* Factor out explicit Config type

Instead of using snmalloc::Alloc::Config, expose snmalloc::Config, which is then used to derive the allocator type.

* Move globalalloc to front end.

* Remove unneed template parameter from global snmalloc functions.

* Remove SNMALLOC_PASS_THROUGH

VeronaRT now has an abstraction layer which can easily replace the allocator.
Having such a complex integration still in snmalloc does not make sense.

* Take some global functions off of local alloc.

* Drop comparison overloads on atomic Capptr.

Performing a comparison on two atomic ptr is a complex operation, and should not be implicit.  The memory model order and such things needs to be considered by the caller.

* Remove function_ref and use templates

The implementation prefers to use templates over the function_ref.  This now only exists in the Pal for a currently unused feature.

* Removing function_ref reduces stl needs.

* Remove use of __is_convertible to support older g++

* Inline function that is only used once.

* Remove unused function

* Restrict ThreadAlloc usage to globalalloc

This commit introduces various inline functions on snmalloc:: that perform allocation/deallocation using the thread local allocator.

They remove all usage from a particular test.

* Move cheri checks to own file.

* Refactor is_owned checks.

* Move alloc_size and check_size to globalalloc.

* Minor simplification of dealloc path

* Fix up is_owned to take a config

* Improve usage of scoped allocator.

* Handle Config_ in globalalloc.

src/test/perf/msgpass/msgpass.cc

@@ -36,46 +36,6 @@ void chatty(const char* p, ...)
   }
 }
 
-/*
- * Interpret SNMALLOC_PASS_THROUGH ourselves to make this a bit more fair of a
- * comparison, since relying of snmalloc itself to do the passing through
- * results in it imposing its own idea of alignment onto the underlying
- * allocator, which might result in it taking less optimized paths.
- */
-#ifdef SNMALLOC_PASS_THROUGH
-struct MyAlloc
-{
-  MyAlloc() {}
-
-  void* alloc(size_t sz)
-  {
-    return malloc(sz);
-  }
-
-  void dealloc(void* p)
-  {
-    free(p);
-  }
-};
-#else
-struct MyAlloc
-{
-  snmalloc::Alloc& a;
-
-  MyAlloc() : a(ThreadAlloc::get()) {}
-
-  void* alloc(size_t sz)
-  {
-    return a.alloc(sz);
-  }
-
-  void dealloc(void* p)
-  {
-    a.dealloc(p);
-  }
-};
-#endif
-
 /*
  * FreeListMPSCQ make for convenient MPSC queues, so we use those for sending
  * "messages".  Each consumer or proxy has its own (source) queue.
@@ -106,7 +66,6 @@ freelist::HeadPtr domesticate_nop(freelist::QueuePtr p)
 
 void consumer(const struct params* param, size_t qix)
 {
-  MyAlloc a{};
   auto& myq = param->msgqueue[qix];
 
   chatty("Cl %zu q is %p\n", qix, &myq);
@@ -118,13 +77,11 @@ void consumer(const struct params* param, size_t qix)
     if (myq.can_dequeue(domesticate_nop, domesticate_nop))
     {
       myq.dequeue(
-        domesticate_nop,
-        domesticate_nop,
-        [qix, &a, &reap](freelist::HeadPtr o) {
+        domesticate_nop, domesticate_nop, [qix, &reap](freelist::HeadPtr o) {
           UNUSED(qix);
           auto p = o.as_void().unsafe_ptr();
           chatty("Cl %zu free %p\n", qix, p);
-          a.dealloc(p);
+          snmalloc::dealloc(p);
           reap++;
           return true;
         });
@@ -145,7 +102,7 @@ void consumer(const struct params* param, size_t qix)
            producers_live || (queue_gate > param->N_CONSUMER));
 
   chatty("Cl %zu fini\n", qix);
-  a.dealloc(myq.destroy().unsafe_ptr());
+  snmalloc::dealloc(myq.destroy().unsafe_ptr());
 }
 
 void proxy(const struct params* param, size_t qix)
@@ -178,13 +135,12 @@ void proxy(const struct params* param, size_t qix)
 
   chatty("Px %zu fini\n", qix);
 
-  MyAlloc().dealloc(myq.destroy().unsafe_ptr());
+  snmalloc::dealloc(myq.destroy().unsafe_ptr());
   queue_gate--;
 }
 
 void producer(const struct params* param, size_t pix)
 {
-  MyAlloc a{};
   static constexpr size_t msgsizes[] = {48, 64, 96, 128};
   static constexpr size_t nmsgsizes = sizeof(msgsizes) / sizeof(msgsizes[0]);
 
@@ -206,7 +162,7 @@ void producer(const struct params* param, size_t pix)
     /* Allocate batch and form list */
     for (size_t msgix = 0; msgix < nmsg; msgix++)
     {
-      auto msg = a.alloc(msgsize);
+      auto msg = snmalloc::alloc(msgsize);
       chatty("Pd %zu make %p\n", pix, msg);
 
       auto msgc = capptr::Alloc<void>::unsafe_from(msg)