chore(profiling): remove native from echion

Author: KowalskiThomas

ddtrace/internal/datadog/profiling/stack_v2/echion/echion/config.h

@@ -17,9 +17,6 @@ inline int cpu = 0;
 // Set this to false to unwind all threads.
 inline bool ignore_non_running_threads = true;
 
-// Native stack sampling
-inline int native = 0;
-
 // Maximum number of frames to unwind
 inline unsigned int max_frames = 2048;
 
@@ -59,24 +56,6 @@ static PyObject* set_cpu(PyObject* Py_UNUSED(m), PyObject* args)
     Py_RETURN_NONE;
 }
 
-// ----------------------------------------------------------------------------
-static PyObject* set_native(PyObject* Py_UNUSED(m), PyObject* Py_UNUSED(args))
-{
-#ifndef UNWIND_NATIVE_DISABLE
-    int new_native;
-    if (!PyArg_ParseTuple(args, "p", &new_native))
-        return NULL;
-
-    native = new_native;
-#else
-    PyErr_SetString(PyExc_RuntimeError,
-                    "Native profiling is disabled, please re-build/install echion without "
-                    "UNWIND_NATIVE_DISABLE env var/preprocessor flag");
-    return NULL;
-#endif  // UNWIND_NATIVE_DISABLE
-    Py_RETURN_NONE;
-}
-
 // ----------------------------------------------------------------------------
 static PyObject* set_max_frames(PyObject* Py_UNUSED(m), PyObject* args)
 {

ddtrace/internal/datadog/profiling/stack_v2/echion/echion/frame.h

@@ -17,7 +17,7 @@
 #if PY_VERSION_HEX >= 0x030d0000
 #define Py_BUILD_CORE
 #include <internal/pycore_code.h>
-#endif  // PY_VERSION_HEX >= 0x030d0000
+#endif // PY_VERSION_HEX >= 0x030d0000
 #if PY_VERSION_HEX >= 0x030b0000
 #define Py_BUILD_CORE
 #include <internal/pycore_frame.h>
@@ -28,24 +28,18 @@
 #include <cstring>
 #include <functional>
 
-#ifndef UNWIND_NATIVE_DISABLE
-#include <cxxabi.h>
-#define UNW_LOCAL_ONLY
-#include <libunwind.h>
-#endif  // UNWIND_NATIVE_DISABLE
-
 #include <echion/cache.h>
 #include <echion/mojo.h>
 #if PY_VERSION_HEX >= 0x030b0000
 #include <echion/stack_chunk.h>
-#endif  // PY_VERSION_HEX >= 0x030b0000
+#endif // PY_VERSION_HEX >= 0x030b0000
 #include <echion/strings.h>
 #include <echion/vm.h>
 
 // ----------------------------------------------------------------------------
 class Frame
 {
-public:
+  public:
     using Ref = std::reference_wrapper<Frame>;
     using Ptr = std::unique_ptr<Frame>;
     using Key = uintptr_t;
@@ -68,31 +62,28 @@ class Frame
 #endif
 
     // ------------------------------------------------------------------------
-    Frame(StringTable::Key filename, StringTable::Key name) : filename(filename), name(name) {}
-    Frame(StringTable::Key name) : name(name) {};
+    Frame(StringTable::Key filename, StringTable::Key name)
+      : filename(filename)
+      , name(name)
+    {
+    }
+    Frame(StringTable::Key name)
+      : name(name) {};
     Frame(PyObject* frame);
     [[nodiscard]] static Result<Frame::Ptr> create(PyCodeObject* code, int lasti);
-#ifndef UNWIND_NATIVE_DISABLE
-    [[nodiscard]] static Result<Frame::Ptr> create(unw_cursor_t& cursor, unw_word_t pc);
-#endif  // UNWIND_NATIVE_DISABLE
 
 #if PY_VERSION_HEX >= 0x030b0000
-    [[nodiscard]] static Result<std::reference_wrapper<Frame>> read(
-        _PyInterpreterFrame* frame_addr, _PyInterpreterFrame** prev_addr);
+    [[nodiscard]] static Result<std::reference_wrapper<Frame>> read(_PyInterpreterFrame* frame_addr,
+                                                                    _PyInterpreterFrame** prev_addr);
 #else
-    [[nodiscard]] static Result<std::reference_wrapper<Frame>> read(PyObject* frame_addr,
-                                                                    PyObject** prev_addr);
+    [[nodiscard]] static Result<std::reference_wrapper<Frame>> read(PyObject* frame_addr, PyObject** prev_addr);
 #endif
 
-    [[nodiscard]] static Result<std::reference_wrapper<Frame>> get(PyCodeObject* code_addr,
-                                                                   int lasti);
+    [[nodiscard]] static Result<std::reference_wrapper<Frame>> get(PyCodeObject* code_addr, int lasti);
     static Frame& get(PyObject* frame);
-#ifndef UNWIND_NATIVE_DISABLE
-    [[nodiscard]] static Result<std::reference_wrapper<Frame>> get(unw_cursor_t& cursor);
-#endif  // UNWIND_NATIVE_DISABLE
     static Frame& get(StringTable::Key name);
 
-private:
+  private:
     [[nodiscard]] Result<void> inline infer_location(PyCodeObject* code, int lasti);
     static inline Key key(PyCodeObject* code, int lasti);
     static inline Key key(PyObject* frame);
@@ -105,5 +96,7 @@ inline auto C_FRAME = Frame(StringTable::C_FRAME);
 // We make this a raw pointer to prevent its destruction on exit, since we
 // control the lifetime of the cache.
 inline LRUCache<uintptr_t, Frame>* frame_cache = nullptr;
-void init_frame_cache(size_t capacity);
-void reset_frame_cache();
+void
+init_frame_cache(size_t capacity);
+void
+reset_frame_cache();

ddtrace/internal/datadog/profiling/stack_v2/echion/echion/signals.h

@@ -12,11 +12,6 @@
 #include <unordered_map>
 #include <unordered_set>
 
-#ifndef UNWIND_NATIVE_DISABLE
-#define UNW_LOCAL_ONLY
-#include <libunwind.h>
-#endif  // UNWIND_NATIVE_DISABLE
-
 #include <echion/config.h>
 #include <echion/frame.h>
 #include <echion/mojo.h>
@@ -69,34 +64,8 @@ class FrameStack : public std::deque<Frame::Ref>
 // ----------------------------------------------------------------------------
 
 inline FrameStack python_stack;
-inline FrameStack native_stack;
 inline FrameStack interleaved_stack;
 
-// ----------------------------------------------------------------------------
-#ifndef UNWIND_NATIVE_DISABLE
-inline void unwind_native_stack()
-{
-    unw_cursor_t cursor;
-    unw_context_t context;
-
-    unw_getcontext(&context);
-    unw_init_local(&cursor, &context);
-
-    native_stack.clear();
-
-    while (unw_step(&cursor) > 0 && native_stack.size() < max_frames)
-    {
-        auto maybe_frame = Frame::get(cursor);
-        if (!maybe_frame)
-        {
-            break;
-        }
-
-        native_stack.push_back(*maybe_frame);
-    }
-}
-#endif  // UNWIND_NATIVE_DISABLE
-
 // ----------------------------------------------------------------------------
 static size_t unwind_frame(PyObject* frame_addr, FrameStack& stack)
 {
@@ -246,75 +215,6 @@ static void unwind_python_stack(PyThreadState* tstate)
     unwind_python_stack(tstate, python_stack);
 }
 
-// ----------------------------------------------------------------------------
-static Result<void> interleave_stacks(FrameStack& cur_python_stack)
-{
-    interleaved_stack.clear();
-
-    auto p = cur_python_stack.rbegin();
-    // The last two frames are usually the signal trampoline and the signal
-    // handler. We skip them.
-    for (auto n = native_stack.rbegin(); n != native_stack.rend() - 2; ++n)
-    {
-        auto native_frame = *n;
-
-        auto maybe_name = string_table.lookup(native_frame.get().name);
-        if (!maybe_name)
-        {
-            return ErrorKind::LookupError;
-        }
-
-        const auto& name = maybe_name->get();
-        if (name.find("PyEval_EvalFrameDefault") != std::string::npos)
-        {
-            if (p == cur_python_stack.rend())
-            {
-                // We expected a Python frame but we found none, so we report
-                // the native frame instead.
-                std::cerr << "Expected Python frame(s), found none!" << std::endl;
-                interleaved_stack.push_front(native_frame);
-            }
-            else
-            {
-                // We skip the PyEval_EvalFrameDefault frame because it is the
-                // function that calls the Python code.
-#if PY_VERSION_HEX >= 0x030b0000
-                int cframe_count = 0;
-                while (p != cur_python_stack.rend())
-                {
-                    // The Python stack will start with an entry frame at the top.
-                    // We stop popping at the next entry frame.
-                    cframe_count += (*p).get().is_entry;
-                    if (cframe_count >= 2)
-                        break;
-
-                    interleaved_stack.push_front(*p++);
-                }
-#else
-                interleaved_stack.push_front(*p++);
-#endif
-            }
-        }
-        else
-            interleaved_stack.push_front(native_frame);
-    }
-
-    if (p != cur_python_stack.rend())
-    {
-        std::cerr << "Python stack not empty after interleaving!" << std::endl;
-        while (p != python_stack.rend())
-            interleaved_stack.push_front(*p++);
-    }
-
-    return Result<void>::ok();
-}
-
-// ----------------------------------------------------------------------------
-static Result<void> interleave_stacks()
-{
-    return interleave_stacks(python_stack);
-}
-
 // ----------------------------------------------------------------------------
 class StackInfo
 {

ddtrace/internal/datadog/profiling/stack_v2/echion/echion/stacks.h

@@ -11,13 +11,6 @@
 #include <cstdint>
 #include <string>
 
-#ifndef UNWIND_NATIVE_DISABLE
-#include <cxxabi.h>
-#define UNW_LOCAL_ONLY
-#include <libunwind.h>
-#endif  // UNWIND_NATIVE_DISABLE
-
-
 #include <echion/long.h>
 #include <echion/render.h>
 #include <echion/vm.h>
@@ -153,66 +146,6 @@ class StringTable : public std::unordered_map<uintptr_t, std::string>
         return k;
     };
 
-#ifndef UNWIND_NATIVE_DISABLE
-    // Native filename by program counter
-    [[nodiscard]] inline Key key(unw_word_t pc)
-    {
-        const std::lock_guard<std::mutex> lock(table_lock);
-
-        auto k = static_cast<Key>(pc);
-
-        if (this->find(k) == this->end())
-        {
-            char buffer[32] = {0};
-            std::snprintf(buffer, 32, "native@%p", reinterpret_cast<void*>(k));
-            this->emplace(k, buffer);
-            Renderer::get().string(k, buffer);
-        }
-
-        return k;
-    }
-
-    // Native scope name by unwinding cursor
-    [[nodiscard]] inline Result<Key> key(unw_cursor_t& cursor)
-    {
-        const std::lock_guard<std::mutex> lock(table_lock);
-
-        unw_proc_info_t pi;
-        if ((unw_get_proc_info(&cursor, &pi)))
-            return ErrorKind::UnwindError;
-
-        auto k = reinterpret_cast<Key>(pi.start_ip);
-
-        if (this->find(k) == this->end())
-        {
-            unw_word_t offset;  // Ignored. All the information is in the PC anyway.
-            char sym[256];
-            if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset))
-                return ErrorKind::UnwindError;
-
-            char* name = sym;
-
-            // Try to demangle C++ names
-            char* demangled = NULL;
-            if (name[0] == '_' && name[1] == 'Z')
-            {
-                int status;
-                demangled = abi::__cxa_demangle(name, NULL, NULL, &status);
-                if (status == 0)
-                    name = demangled;
-            }
-
-            this->emplace(k, name);
-            Renderer::get().string(k, name);
-
-            if (demangled)
-                std::free(demangled);
-        }
-
-        return Result<Key>(k);
-    }
-#endif  // UNWIND_NATIVE_DISABLE
-
     [[nodiscard]] inline Result<std::reference_wrapper<std::string>> lookup(Key key)
     {
         const std::lock_guard<std::mutex> lock(table_lock);