chore(profiling): convert memory profiler to C++

ddtrace/profiling/collector/_memalloc.cpp

@@ -10,7 +10,6 @@
 #include "_memalloc_reentrant.h"
 #include "_memalloc_tb.h"
 #include "_pymacro.h"
-#include "_utils.h"
 
 typedef struct
 {
@@ -135,7 +134,7 @@ memalloc_start(PyObject* Py_UNUSED(module), PyObject* args)
         return NULL;
     }
 
-    if (memalloc_tb_init(global_memalloc_ctx.max_nframe) < 0)
+    if (!traceback_t::init())
         return NULL;
 
     if (object_string == NULL) {
@@ -145,7 +144,8 @@ memalloc_start(PyObject* Py_UNUSED(module), PyObject* args)
         PyUnicode_InternInPlace(&object_string);
     }
 
-    memalloc_heap_tracker_init((uint32_t)heap_sample_size);
+    if (!memalloc_heap_tracker_init((uint32_t)heap_sample_size))
+        return NULL;
 
     PyMemAllocatorEx alloc;
 
@@ -190,7 +190,7 @@ memalloc_stop(PyObject* Py_UNUSED(module), PyObject* Py_UNUSED(args))
     memalloc_heap_tracker_deinit();
 
     /* Finally, we know in-progress sampling won't use the buffer pool, so clear it out */
-    memalloc_tb_deinit();
+    traceback_t::deinit();
 
     memalloc_enabled = false;
 

ddtrace/profiling/collector/_memalloc_debug.h

@@ -1,8 +1,6 @@
-#ifndef _DDTRACE_MEMALLOC_DEBUG_H
-#define _DDTRACE_MEMALLOC_DEBUG_H
+#pragma once
 
-#include <assert.h>
-#include <stdbool.h>
+#include <cassert>
 
 #include <Python.h>
 
@@ -17,47 +15,54 @@ memalloc_debug_gil_release(void)
 #endif
 }
 
-typedef struct
+class memalloc_gil_debug_check_t
 {
-    bool acquired;
-} memalloc_gil_debug_check_t;
+  public:
+    memalloc_gil_debug_check_t() = default;
 
-static void
-memalloc_gil_debug_check_init(memalloc_gil_debug_check_t* c)
-{
-    c->acquired = false;
-}
+    bool acquired = false;
+};
 
 #ifndef NDEBUG
-/* Annotate that we are beginning a critical section where we don't want other
- * memalloc code to run. If compiled assertions enabled, this will check that the
- * GIL is held and that the guard has not already been acquired elsewhere.
- *
- * This is a macro so we get file/line info where it's actually used */
-#define MEMALLOC_GIL_DEBUG_CHECK_ACQUIRE(c)                                                                            \
-    do {                                                                                                               \
-        memalloc_gil_debug_check_t* p = c;                                                                             \
-        assert(PyGILState_Check());                                                                                    \
-        assert(!p->acquired);                                                                                          \
-        p->acquired = true;                                                                                            \
-    } while (0)
-
-/* Annotate that we are ending a critical section where we don't want other
- * memalloc code to run. If compiled assertions enabled, this will check that the
- * guard is acquired.
- *
- * This is a macro so we get file/line info where it's actually used */
-#define MEMALLOC_GIL_DEBUG_CHECK_RELEASE(c)                                                                            \
-    do {                                                                                                               \
-        memalloc_gil_debug_check_t* p = c;                                                                             \
-        assert(p->acquired);                                                                                           \
-        p->acquired = false;                                                                                           \
-    } while (0)
-#else
+/* RAII guard for GIL debug checking. Automatically acquires the guard in the
+ * constructor and releases it in the destructor. */
+class memalloc_gil_debug_guard_t
+{
+  public:
+    explicit memalloc_gil_debug_guard_t(memalloc_gil_debug_check_t& guard)
+      : guard_(guard)
+    {
+        assert(PyGILState_Check());
+        assert(!guard_.acquired);
+        guard_.acquired = true;
+    }
 
-#define MEMALLOC_GIL_DEBUG_CHECK_ACQUIRE(c)
-#define MEMALLOC_GIL_DEBUG_CHECK_RELEASE(c)
+    ~memalloc_gil_debug_guard_t()
+    {
+        assert(guard_.acquired);
+        guard_.acquired = false;
+    }
 
-#endif
+    // Non-copyable, non-movable
+    memalloc_gil_debug_guard_t(const memalloc_gil_debug_guard_t&) = delete;
+    memalloc_gil_debug_guard_t& operator=(const memalloc_gil_debug_guard_t&) = delete;
+    memalloc_gil_debug_guard_t(memalloc_gil_debug_guard_t&&) = delete;
+    memalloc_gil_debug_guard_t& operator=(memalloc_gil_debug_guard_t&&) = delete;
+
+  private:
+    memalloc_gil_debug_check_t& guard_;
+};
+#else
+/* In release builds, the guard is a no-op */
+class memalloc_gil_debug_guard_t
+{
+  public:
+    explicit memalloc_gil_debug_guard_t(memalloc_gil_debug_check_t&) {}
 
+    // Non-copyable, non-movable
+    memalloc_gil_debug_guard_t(const memalloc_gil_debug_guard_t&) = delete;
+    memalloc_gil_debug_guard_t& operator=(const memalloc_gil_debug_guard_t&) = delete;
+    memalloc_gil_debug_guard_t(memalloc_gil_debug_guard_t&&) = delete;
+    memalloc_gil_debug_guard_t& operator=(memalloc_gil_debug_guard_t&&) = delete;
+};
 #endif