perf: interpreter state field read (#123)

The interpreter state is a large structure that spans across
multiple memory pages. Remote reads of this structure in a single
chunk suffer a performance penalty that can be avoided because we
only need a bunch of fields from it. It is therefore more
efficient to read the single fields than all the pages backing the
full structure.

Author: P403n1x87

echion/coremodule.cc

@@ -44,7 +44,7 @@ static void do_where(std::ostream& stream)
     WhereRenderer::get().render_message("\r🐴 Echion reporting for duty");
     WhereRenderer::get().render_message("");
 
-    for_each_interp([](PyInterpreterState* interp) -> void {
+    for_each_interp([](InterpreterInfo& interp) -> void {
         for_each_thread(interp, [](PyThreadState* tstate, ThreadInfo& thread) -> void {
             thread.unwind(tstate);
             WhereRenderer::get().render_thread_begin(tstate, thread.name, /*cpu_time*/ 0,
@@ -214,9 +214,9 @@ static inline void _sampler()
         {
             microsecond_t wall_time = now - last_time;
 
-            for_each_interp([=](PyInterpreterState* interp) -> void {
+            for_each_interp([=](InterpreterInfo& interp) -> void {
                 for_each_thread(interp, [=](PyThreadState* tstate, ThreadInfo& thread) {
-                    thread.sample(interp->id, tstate, wall_time);
+                    thread.sample(interp.id, tstate, wall_time);
                 });
             });
         }

echion/interp.h

@@ -20,10 +20,34 @@
 #include <echion/state.h>
 #include <echion/vm.h>
 
-static void for_each_interp(std::function<void(PyInterpreterState* interp)> callback)
+
+class InterpreterInfo
+{
+public:
+    int64_t id = 0;
+    void* tstate_head = NULL;
+    void* next = NULL;
+};
+
+static void for_each_interp(std::function<void(InterpreterInfo& interp)> callback)
 {
-    PyInterpreterState interp;
-    for (PyInterpreterState* interp_addr = runtime->interpreters.head;
-         !copy_type(interp_addr, interp); interp_addr = interp.next)
-        callback(&interp);
+    InterpreterInfo interpreter_info = {0};
+
+    for (char* interp_addr = (char*)runtime->interpreters.head; interp_addr != NULL;
+         interp_addr = (char*)interpreter_info.next)
+    {
+        if (copy_type(interp_addr + offsetof(PyInterpreterState, id), interpreter_info.id))
+            continue;
+#if PY_VERSION_HEX >= 0x030b0000
+        if (copy_type(interp_addr + offsetof(PyInterpreterState, threads.head),
+#else
+        if (copy_type(interp_addr + offsetof(PyInterpreterState, tstate_head),
+#endif
+                      interpreter_info.tstate_head))
+            continue;
+        if (copy_type(interp_addr + offsetof(PyInterpreterState, next), interpreter_info.next))
+            continue;
+
+        callback(interpreter_info);
+    };
 }

echion/threads.h

@@ -471,7 +471,7 @@ void ThreadInfo::sample(int64_t iid, PyThreadState* tstate, microsecond_t delta)
 }
 
 // ----------------------------------------------------------------------------
-static void for_each_thread(PyInterpreterState* interp,
+static void for_each_thread(InterpreterInfo& interp,
                             std::function<void(PyThreadState*, ThreadInfo&)> callback)
 {
     std::unordered_set<PyThreadState*> threads;
@@ -481,7 +481,7 @@ static void for_each_thread(PyInterpreterState* interp,
     seen_threads.clear();
 
     // Start from the thread list head
-    threads.insert(PyInterpreterState_ThreadHead(interp));
+    threads.insert((PyThreadState*)interp.tstate_head);
 
     while (!threads.empty())
     {