Configurable client meta-data

src/test/func/client_meta/client_meta.cc

@@ -0,0 +1,58 @@
+#include "test/setup.h"
+
+#include <iostream>
+
+#include <snmalloc/snmalloc_core.h>
+#include <snmalloc/backend/globalconfig.h>
+
+namespace snmalloc
+{
+    using Alloc = snmalloc::LocalAllocator<
+        snmalloc::StandardConfigClientMeta<ArrayClientMetaDataProvider<std::atomic<size_t>>>>;
+}
+#define SNMALLOC_PROVIDE_OWN_CONFIG
+#include <snmalloc/snmalloc.h>
+
+
+
+int main()
+{
+#ifdef SNMALLOC_PASS_THROUGH
+    // This test does not make sense in pass-through
+    return 0;
+#else
+  std::vector<void*> ptrs;
+  for (size_t i = 0; i < 10000; i++)
+  {
+    auto p = snmalloc::libc::malloc(1024);
+    auto& meta = snmalloc::libc::get_client_meta_data(p);
+    meta = i;
+    ptrs.push_back(p);
+    memset(p, (uint8_t)i, 1024);
+  }
+
+  for (size_t i = 0; i < 10000; i++)
+  {
+    auto p = ptrs[i];
+    auto& meta = snmalloc::libc::get_client_meta_data(p);
+    if (meta != i)
+    {
+        std::cout << "Failed at index " << i << std::endl;
+        abort();
+    }
+    for (size_t j = 0; j < 1024; j++)
+    {
+      if (reinterpret_cast<uint8_t*>(p)[j] != (uint8_t)i)
+      {
+        std::cout << "Failed at index " << i << " byte " << j << std::endl;
+        abort();
+      }
+    }
+    snmalloc::libc::free(p);
+  }
+
+  auto& meta = snmalloc::libc::get_client_meta_data_const(&ptrs);
+  std::cout << "meta for stack" << meta << std::endl;
+  return 0;
+#endif
+}

src/test/func/miracle_ptr/miracle_ptr.cc

@@ -0,0 +1,188 @@
+/**
+ * This file demonstrates how the snmalloc library could be implemented to
+ * provide a miracle pointer like feature.  This is not a hardened
+ * implementation and is purely for illustrative purposes.
+ *
+ * Do not use as is.
+ */
+
+#include "test/setup.h"
+
+#include <iostream>
+#include <memory>
+#include <snmalloc/backend/globalconfig.h>
+#include <snmalloc/snmalloc_core.h>
+
+namespace snmalloc
+{
+  // Instantiate the allocator with a client meta data provider that uses an
+  // atomic size_t to store the reference count.
+  using Alloc = snmalloc::LocalAllocator<snmalloc::StandardConfigClientMeta<
+    ArrayClientMetaDataProvider<std::atomic<size_t>>>>;
+}
+#define SNMALLOC_PROVIDE_OWN_CONFIG
+#include <snmalloc/snmalloc.h>
+
+SNMALLOC_SLOW_PATH void error(std::string msg)
+{
+  std::cout << msg << std::endl;
+  abort();
+}
+
+SNMALLOC_FAST_PATH void check(bool b, std::string msg)
+{
+  if (SNMALLOC_UNLIKELY(!b))
+    error(msg);
+}
+
+namespace snmalloc::miracle
+{
+  // snmalloc meta-data representation
+  //   * 2n + 1:  Represents an object that has not been deallocated with n
+  //              additional references to it
+  //   * 2n    :  Represents a deallocated object that
+  //              has n additional references to it
+
+  inline void* malloc(size_t size)
+  {
+    auto p = snmalloc::libc::malloc(size);
+    if (SNMALLOC_UNLIKELY(p == nullptr))
+      return nullptr;
+
+    snmalloc::libc::get_client_meta_data(p) = 1;
+    return p;
+  }
+
+  inline void free(void* ptr)
+  {
+    if (ptr == nullptr)
+      return;
+
+    // TODO could build a check into this that it is the start of the object?
+    auto previous =
+      snmalloc::libc::get_client_meta_data(ptr).fetch_add((size_t)-1);
+
+    if (SNMALLOC_LIKELY(previous == 1))
+    {
+      std::cout << "Freeing " << ptr << std::endl;
+      snmalloc::libc::free(ptr);
+      return;
+    }
+
+    check((previous & 1) == 1, "Double free detected");
+
+    // We have additional references to this object.
+    // We should not free it.
+    // TOOD this assumes this is not an internal pointer.
+    memset(ptr, 0, snmalloc::libc::malloc_usable_size(ptr));
+  }
+
+  inline void acquire(void* p)
+  {
+    auto previous =
+      snmalloc::libc::get_client_meta_data(p).fetch_add((size_t)2);
+
+    // Can we take new pointers to a deallocated object?
+    check((previous & 1) == 1, "Acquiring a deallocated object");
+  }
+
+  inline void release(void* p)
+  {
+    auto previous =
+      snmalloc::libc::get_client_meta_data(p).fetch_add((size_t)-2);
+
+    if (previous > 2)
+      return;
+
+    check(previous == 2, "Releasing an object with insufficient references");
+
+    std::cout << "Freeing from release " << p << std::endl;
+    snmalloc::libc::free(p);
+  }
+};
+
+/**
+ * Overload new and delete to use the "miracle pointer" implementation.
+ */
+void* operator new(size_t size)
+{
+  return snmalloc::miracle::malloc(size);
+}
+
+void operator delete(void* p)
+{
+  snmalloc::miracle::free(p);
+}
+
+/**
+ * This class can be used to replace a raw pointer. It will automatically use
+ * the underlying backup reference counting design from the miracle pointer
+ * docs.
+ */
+template<typename T>
+class raw_ptr
+{
+  T* p;
+
+public:
+  raw_ptr() : p(nullptr) {}
+
+  raw_ptr(T* p) : p(p)
+  {
+    snmalloc::miracle::acquire(p);
+  }
+
+  T& operator*()
+  {
+    return *p;
+  }
+
+  ~raw_ptr()
+  {
+    if (p == nullptr)
+      return;
+    snmalloc::miracle::release(p);
+  }
+
+  raw_ptr(const raw_ptr& rp) : p(rp.p)
+  {
+    snmalloc::miracle::acquire(p);
+  }
+
+  raw_ptr& operator=(const raw_ptr& other)
+  {
+    p = other.p;
+    snmalloc::miracle::acquire(other.p);
+    return *this;
+  }
+
+  raw_ptr(raw_ptr&& other) : p(other.p)
+  {
+    other.p = nullptr;
+  }
+
+  raw_ptr& operator=(raw_ptr&& other)
+  {
+    p = other.p;
+    other.p = nullptr;
+    return *this;
+  }
+};
+
+int main()
+{
+#ifndef SNMALLOC_PASS_THROUGH
+  raw_ptr<int> p;
+  {
+    auto up = std::make_unique<int>(42);
+    auto up2 = std::make_unique<int>(41);
+    p = up.get();
+    check(*p == 42, "Failed to set p");
+  }
+  // Still safe to access here.  The unique_ptr has been destroyed, but the
+  // raw_ptr has kept the memory live.
+  // Current implementation zeros the memory when the unique_ptr is destroyed.
+  check(*p == 0, "Failed to keep memory live");
+#endif
+  return 0;
+}