chore(profiling): improve readability/add comments

Author: KowalskiThomas

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

@@ -13,6 +13,8 @@
 #include <echion/errors.h>
 #include <echion/timing.h>
 
+#include <Python.h>
+
 // Forward declaration
 class Frame;
 
@@ -29,27 +31,52 @@ class RendererInterface
     virtual void close() = 0;
     virtual void header() = 0;
     virtual void metadata(const std::string& label, const std::string& value) = 0;
+
     // If a renderer has its own caching mechanism for frames, this can be used
     // to store frame information.
     virtual void
     frame(uintptr_t key, uintptr_t filename, uintptr_t name, int line, int line_end, int column, int column_end) = 0;
-    // Refers to the frame stored using above function
+
+    // Refers to the frame stored using the renderer's frame function
     virtual void frame_ref(uintptr_t key) = 0;
     virtual void frame_kernel(const std::string& scope) = 0;
-    // Simlar to frame/frame_ref functions, helpers for string tables
+
+    // If a renderer has its own caching mechanism for strings, this can be used
+    // to store string information.
     virtual void string(uintptr_t key, const std::string& value) = 0;
+
+    // Refers to the string stored using the renderer's string function
     virtual void string_ref(uintptr_t key) = 0;
 
+    // Called to render a message from the profiler.
     virtual void render_message(std::string_view msg) = 0;
+
+    // Called once for each Thread being sampled.
+    // Pushes the Thread state but not its current Stack(s).
     virtual void render_thread_begin(PyThreadState* tstate,
                                      std::string_view name,
                                      microsecond_t cpu_time,
                                      uintptr_t thread_id,
                                      unsigned long native_id) = 0;
+
+    // Called once for each Task being sampled on the Thread.
+    // Called after render_thread_begin and before render_stack_begin.
     virtual void render_task_begin(std::string task_name, bool on_cpu) = 0;
+
+    // Called once for each Stack being sampled on the Task.
+    // Called after render_task_begin and before render_frame.
     virtual void render_stack_begin(long long pid, long long iid, const std::string& thread_name) = 0;
+
+    // Called once for each Frame being sampled on the Stack.
+    // Called after render_stack_begin and before render_stack_end.
     virtual void render_frame(Frame& frame) = 0;
+
+    // Called once for each CPU time being sampled on the Thread.
+    // Called after render_frame and before render_stack_end.
     virtual void render_cpu_time(uint64_t cpu_time) = 0;
+
+    // Called once for each Stack being sampled on the Thread.
+    // Called after render_stack_begin, all render_frame calls and all render_cpu_time calls.
     virtual void render_stack_end(MetricType metric_type, uint64_t delta) = 0;
 
     // The validity of the interface is a two-step process

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

@@ -395,23 +395,13 @@ ThreadInfo::sample(int64_t iid, PyThreadState* tstate, microsecond_t delta)
 
     Renderer::get().render_cpu_time(thread_is_running ? cpu_time - previous_cpu_time : 0);
 
-    unwind(tstate);
+    this->unwind(tstate);
 
-    // Asyncio tasks
-    if (current_tasks.empty()) {
-        // If we don't have any asyncio tasks, we check that we don't have any
-        // greenlets either. In this case, we print the ordinary thread stack.
-        // With greenlets, we recover the thread stack from the active greenlet,
-        // so if we don't skip here we would have a double print.
-        if (current_greenlets.empty()) {
-            // Print the PID and thread name
-            Renderer::get().render_stack_begin(pid, iid, name);
-            // Print the stack
-            python_stack.render();
-
-            Renderer::get().render_stack_end(MetricType::Time, delta);
-        }
-    } else {
+    // Render in this order of priority
+    // 1. asyncio Tasks stacks (if any)
+    // 2. Greenlets stacks (if any)
+    // 3. The normal thread stack (if no asyncio tasks or greenlets)
+    if (!current_tasks.empty()) {
         for (auto& task_stack_info : current_tasks) {
             auto maybe_task_name = string_table.lookup(task_stack_info->task_name);
             if (!maybe_task_name) {
@@ -428,10 +418,7 @@ ThreadInfo::sample(int64_t iid, PyThreadState* tstate, microsecond_t delta)
         }
 
         current_tasks.clear();
-    }
-
-    // Greenlet stacks
-    if (!current_greenlets.empty()) {
+    } else if (!current_greenlets.empty()) {
         for (auto& greenlet_stack : current_greenlets) {
             auto maybe_task_name = string_table.lookup(greenlet_stack->task_name);
             if (!maybe_task_name) {
@@ -449,6 +436,19 @@ ThreadInfo::sample(int64_t iid, PyThreadState* tstate, microsecond_t delta)
         }
 
         current_greenlets.clear();
+    } else {
+        // If we don't have any asyncio tasks, we check that we don't have any
+        // greenlets either. In this case, we print the ordinary thread stack.
+        // With greenlets, we recover the thread stack from the active greenlet,
+        // so if we don't skip here we would have a double print.
+        if (current_greenlets.empty()) {
+            // Print the PID and thread name
+            Renderer::get().render_stack_begin(pid, iid, name);
+            // Print the stack
+            python_stack.render();
+
+            Renderer::get().render_stack_end(MetricType::Time, delta);
+        }
     }
 
     return Result<void>::ok();