Try something else with UnwindTracersProvider

Author: gleocadie

profiler/src/ProfilerEngine/Datadog.Profiler.Native.Linux/CMakeLists.txt

@@ -95,6 +95,7 @@ if (ISARM64)
 else()
     list(REMOVE_ITEM LINUX_PROFILER_SRC "${CMAKE_CURRENT_SOURCE_DIR}/HybridUnwinder.cpp")
     list(REMOVE_ITEM LINUX_PROFILER_SRC "${CMAKE_CURRENT_SOURCE_DIR}/UnwinderTracer.cpp")
+    list(REMOVE_ITEM LINUX_PROFILER_SRC "${CMAKE_CURRENT_SOURCE_DIR}/UnwindTracersProvider.cpp")
 endif()
 
 FILE(GLOB COMMON_PROFILER_SRC LIST_DIRECTORIES false "../Datadog.Profiler.Native/*.cpp")

profiler/src/ProfilerEngine/Datadog.Profiler.Native.Linux/TimerCreateCpuProfiler.cpp

@@ -11,13 +11,17 @@
 #include "OpSysTools.h"
 #include "ProfilerSignalManager.h"
 #include "IConfiguration.h"
+#ifdef ARM64
+#include "UnwindTracersProvider.h"
+#endif
 
 #include <sys/syscall.h> /* Definition of SYS_* constants */
 #include <sys/types.h>
 #include <ucontext.h>
 #include <unistd.h>
 
 std::atomic<TimerCreateCpuProfiler*> TimerCreateCpuProfiler::Instance = nullptr;
+thread_local UnwinderTracer* TimerCreateCpuProfiler::Tracer = nullptr;
 
 TimerCreateCpuProfiler::TimerCreateCpuProfiler(
     IConfiguration* pConfiguration,
@@ -261,8 +265,14 @@ bool TimerCreateCpuProfiler::Collect(void* ctx)
         std::tie(stackBase, stackEnd) = threadInfo->GetStackBounds();
     }
 
+#ifdef ARM64
+    auto tracer = UnwindTracersProvider::GetInstance().GetTracer();
+    Tracer = tracer.get();
+#else
+    Tracer = nullptr;
+#endif
     auto buffer = rawCpuSample->Stack.AsSpan();
-    auto count = _pUnwinder->Unwind(ctx, buffer.data(), buffer.size(), stackBase, stackEnd);
+    auto count = _pUnwinder->Unwind(ctx, buffer.data(), buffer.size(), stackBase, stackEnd, Tracer);
     rawCpuSample->Stack.SetCount(count);
 
     if (count == 0)

profiler/src/ProfilerEngine/Datadog.Profiler.Native.Linux/TimerCreateCpuProfiler.h

@@ -23,6 +23,7 @@ class IManagedThreadList;
 class ProfilerSignalManager;
 class CpuSampleProvider;
 class IUnwinder;
+class UnwinderTracer;
 
 class TimerCreateCpuProfiler : public ServiceBase
 {
@@ -63,4 +64,5 @@ class TimerCreateCpuProfiler : public ServiceBase
     std::shared_ptr<DiscardMetrics> _discardMetrics;
     std::atomic<std::uint64_t> _nbThreadsInSignalHandler;
     std::unique_ptr<IUnwinder> _pUnwinder;
+    static thread_local UnwinderTracer* Tracer;
 };

profiler/src/ProfilerEngine/Datadog.Profiler.Native.Linux/UnwindTracersProvider.cpp

@@ -0,0 +1,82 @@
+#include "UnwindTracersProvider.h"
+
+#define NB_TRACER 50
+
+UnwindTracersProvider::UnwindTracersProvider(std::size_t nbTracers)
+    : _headTracer(nullptr)
+{
+    for (std::size_t i = 0; i < nbTracers; ++i)
+    {
+        auto* node = new TracerNode();
+        node->tracer = new UnwinderTracer();
+        node->next.store(_headTracer.load(std::memory_order_relaxed), std::memory_order_relaxed);
+        _headTracer.store(node, std::memory_order_relaxed);
+    }
+}
+
+UnwindTracersProvider::~UnwindTracersProvider()
+{
+    auto* current = _headTracer.load(std::memory_order_relaxed);
+    while (current != nullptr)
+    {
+        auto* next = current->next.load(std::memory_order_relaxed);
+        delete current->tracer;
+        delete current;
+        current = next;
+    }
+}
+
+UnwindTracersProvider& UnwindTracersProvider::GetInstance()
+{
+    static UnwindTracersProvider instance(NB_TRACER);
+    return instance;
+}
+
+UnwindTracersProvider::ScopedTracer UnwindTracersProvider::GetTracer()
+{
+    return ScopedTracer(*this);
+}
+
+UnwindTracersProvider::ScopedTracer::ScopedTracer(UnwindTracersProvider& provider)
+    : _provider(provider), _node(_provider.AcquireTracer())
+{
+}
+
+UnwindTracersProvider::ScopedTracer::~ScopedTracer()
+{
+    if (_node != nullptr)
+    {
+        _provider.ReleaseTracer(_node);
+    }
+}
+
+UnwinderTracer* UnwindTracersProvider::ScopedTracer::get()
+{
+    return _node->tracer;
+}
+
+UnwindTracersProvider::TracerNode* UnwindTracersProvider::AcquireTracer()
+{
+    TracerNode* head = _headTracer.load(std::memory_order_acquire);
+    while (head != nullptr)
+    {
+        if (_headTracer.compare_exchange_weak(head, head->next.load(std::memory_order_relaxed),
+                                               std::memory_order_acq_rel, std::memory_order_relaxed))
+        {
+            head->next.store(nullptr, std::memory_order_relaxed);
+            return head;
+        }
+    }
+    return nullptr;
+}
+
+void UnwindTracersProvider::ReleaseTracer(TracerNode* node)
+{
+    TracerNode* head = _headTracer.load(std::memory_order_relaxed);
+    node->tracer->Reset();
+    do
+    {
+        node->next.store(head, std::memory_order_relaxed);
+    } while (!_headTracer.compare_exchange_weak(head, node,
+                                                 std::memory_order_release, std::memory_order_relaxed));
+}

profiler/src/ProfilerEngine/Datadog.Profiler.Native.Linux/UnwindTracersProvider.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <atomic>
+#include <cstddef>
+
+#include "UnwinderTracer.h"
+
+class UnwindTracersProvider
+{
+public:
+    ~UnwindTracersProvider();
+
+    UnwindTracersProvider(UnwindTracersProvider&& other) noexcept = delete;
+    UnwindTracersProvider(const UnwindTracersProvider& other) = delete;
+    UnwindTracersProvider& operator=(UnwindTracersProvider&& other) noexcept = delete;
+    UnwindTracersProvider& operator=(const UnwindTracersProvider& other) = delete;
+
+    static UnwindTracersProvider& GetInstance();
+
+    struct TracerNode
+    {
+        UnwinderTracer* tracer;
+        std::atomic<TracerNode*> next;
+    };
+
+    struct ScopedTracer
+    {
+        ScopedTracer(UnwindTracersProvider& provider);
+        ~ScopedTracer();
+
+        UnwinderTracer* get();
+
+    private:
+        UnwindTracersProvider& _provider;
+        TracerNode* _node;
+    };
+
+    ScopedTracer GetTracer();
+
+private:
+    UnwindTracersProvider(std::size_t nbTracers);
+    TracerNode* AcquireTracer();
+    void ReleaseTracer(TracerNode* node);
+
+    friend class ScopedTracer;
+    std::atomic<TracerNode*> _headTracer;
+};

profiler/src/ProfilerEngine/Datadog.Profiler.Native/CorProfilerCallback.cpp

@@ -58,6 +58,7 @@
 #ifdef LINUX
 #ifdef ARM64
 #include "HybridUnwinder.h"
+#include "UnwindTracersProvider.h"
 #else
 #include "Backtrace2Unwinder.h"
 #endif
@@ -626,6 +627,8 @@ void CorProfilerCallback::InitializeServices()
     if (_pConfiguration->IsCpuProfilingEnabled() && _pConfiguration->GetCpuProfilerType() == CpuProfilerType::TimerCreate)
     {
 #ifdef ARM64
+        // Initialize the UnwindTracersProvider
+        UnwindTracersProvider::GetInstance();
         _pUnwinder = std::make_unique<HybridUnwinder>(_managedCodeCache.get());
 #else
         _pUnwinder = std::make_unique<Backtrace2Unwinder>();