Add thread name back in (#21791)

Author: jvolmer

arangod/SystemMonitor/AsyncRegistry/PrettyPrinter/src/asyncregistry/gdb_data.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 from typing import Iterable
 from dataclasses import dataclass
+import gdb
 
 @dataclass
 class State:
@@ -23,7 +24,6 @@ def __str__(self):
 class Thread:
     posix_id: gdb.Value
     lwpid: gdb.Value
-    # TODO is there a way to get the thread name?
 
     @classmethod
     def from_gdb(cls, value: gdb.Value | None):
@@ -34,6 +34,18 @@ def from_gdb(cls, value: gdb.Value | None):
     def __str__(self):
         return f"LWPID {self.lwpid} (pthread {self.posix_id})"
 
+@dataclass
+class ThreadInfo:
+    lwpid: gdb.Value
+    name: gdb.Value
+
+    @classmethod
+    def from_gdb(cls, value: gdb.Value):
+        return cls(value['kernel_id'], value['name'])
+
+    def __str__(self):
+        return f"{self.name} (LWPID {self.lwpid})"
+
 @dataclass
 class SourceLocation:
     file_name: gdb.Value
@@ -49,18 +61,26 @@ def __str__(self):
 
 @dataclass
 class Requester:
-    content: Thread | PromiseId
+    content: ThreadInfo | PromiseId
 
     @classmethod
     def from_gdb(cls, value: gdb.Value):
-       alternative = value['_M_index']
-       if alternative == 0:
-           content = Thread.from_gdb(value['_M_u']['_M_first']['_M_storage'])
-       elif alternative == 1:
-           content = PromiseId(value['_M_u']['_M_rest']['_M_first']['_M_storage'])
-       else:
-           return "wrong input"
-       return cls(content)
+        num_flag_bits = 1
+        flag_mask = (1 << num_flag_bits) - 1
+        BIT_WIDTH_64 = 64
+        all_ones_64_bit_mask = (1 << BIT_WIDTH_64) - 1
+        data_mask_64bit = flag_mask ^ all_ones_64_bit_mask
+        if value & flag_mask:
+            return cls(ThreadInfo.from_gdb(
+                (value & data_mask_64bit)
+                .cast(gdb.lookup_type("arangodb::containers::SharedResource<arangodb::basics::ThreadInfo>").pointer())
+                .dereference()['_data']
+            ))
+        else:
+            return cls(PromiseId(
+                (value & data_mask_64bit)
+                .cast(gdb.lookup_type("void").pointer())
+            ))
 
     def __str__(self):
         return str(self.content)
@@ -81,7 +101,8 @@ def __str__(self):
 @dataclass
 class Promise:
     id: PromiseId
-    thread: Optional[Thread]
+    owning_thread: ThreadInfo
+    running_thread: Optional[Thread]
     source_location: SourceLocation
     requester: Requester
     state: State
@@ -90,18 +111,19 @@ class Promise:
     def from_gdb(cls, ptr: gdb.Value, value: gdb.Value):
         return cls(
             PromiseId(ptr),
+            ThreadInfo.from_gdb(value["owning_thread"]["_resource"].dereference()["_data"]),
             Thread.from_gdb(GdbOptional.from_gdb(value["running_thread"])._value),
             SourceLocation.from_gdb(value["source_location"]),
-            Requester.from_gdb(value["requester"]["_M_i"]),
+            Requester.from_gdb(value["requester"]["_resource"]["_M_i"]),
             State.from_gdb(value["state"])
         )
 
     def is_valid(self):
         return not self.state.is_deleted()
 
     def __str__(self):
-        thread_str = f" on {self.thread}" if self.thread else ""
-        return str(self.source_location) + ", " + str(self.state) + thread_str
+        thread_str = f" on {self.running_thread}" if self.running_thread else ""
+        return str(self.source_location) + ", owned by " + str(self.owning_thread) + ", " + str(self.state) + thread_str
 
 @dataclass
 class GdbOptional:

arangod/SystemMonitor/AsyncRegistry/PrettyPrinter/src/asyncregistry/gdb_forest.py

@@ -1,5 +1,5 @@
 from typing import Iterable, Any
-from asyncregistry.gdb_data import Promise, PromiseId, Thread
+from asyncregistry.gdb_data import Promise, PromiseId, ThreadInfo
 
 Id = str
 class Forest:
@@ -31,7 +31,7 @@ def children(self, id: Id) -> Iterable[Id]:
                 yield child
 
     @classmethod
-    def from_promises(cls, promises: Iterable[tuple[PromiseId, PromiseId, Any]]):
+    def from_promises(cls, promises: Iterable[tuple[PromiseId, ThreadInfo | PromiseId, Any]]):
         parents: [Id] = [] # all parents promise ids
         nodes: [Any] = [] # all nodes
         positions: {Id: int} = {} # lookup table for parent and node per promise id
@@ -42,7 +42,7 @@ def from_promises(cls, promises: Iterable[tuple[PromiseId, PromiseId, Any]]):
             promise_id = str(promise.id)
             positions[promise_id] = count
             nodes.append(data)
-            if type(parent) == Thread:
+            if type(parent) == ThreadInfo:
                 parents.append(None)
                 roots.append(promise_id)
             else:

arangod/SystemMonitor/AsyncRegistry/PrettyPrinter/src/pretty-printer.py

@@ -24,6 +24,16 @@ def from_json(cls, blob: dict):
     def __str__(self):
         return f"LWPID {self.id} (pthread {self.posix_id})"
 
+class ThreadInfo(object):
+    def __init__(self, lwpid: int, name: str):
+        self.lwpid = lwpid
+        self.name = name
+    @classmethod
+    def from_json(cls, blob: dict):
+        return cls(blob["LWPID"], blob["name"])
+    def __str__(self):
+        return f"{self.name} (LWPID {self.lwpid})"
+
 class SourceLocation(object):
     def __init__(self, file_name: str, line: int, function_name: str):
         self.file_name = file_name
@@ -34,43 +44,52 @@ def from_json(cls, blob: dict):
         return cls(blob["file_name"], blob["line"], blob["function_name"])
     def __str__(self):
         return self.function_name + " (" + self.file_name + ":" + str(self.line) + ")"
+
+class PromiseId(object):
+    def __init__(self, id):
+        self.id = id
+    @classmethod
+    def from_json(cls, blob: dict):
+        return cls(blob["id"])
+    def __str__(self):
+        return self.id
 
 class Requester(object):
-    def __init__(self, is_sync: bool, item: int):
+    def __init__(self, is_sync: bool, item: ThreadInfo | PromiseId):
         self.is_sync = is_sync
         self.item = item
     @classmethod
     def from_json(cls, blob: dict):
         if not blob:
             return None
-        sync = blob.get("thread")
-        if sync is not None:
-            return cls(True, sync)
+        if "LWPID" in blob:
+            return cls(True, ThreadInfo.from_json(blob))
         else:
-            return cls(False, blob["promise"])
+            return cls(False, PromiseId.from_json(blob))
     def __str__(self):
         if self.is_sync:
             # a sync requester is always at the bottom of a tree,
             # but has no entry on its own,
             # therefore just add it here in a new line
-            return "\n" + "─ " + str(Thread.from_json(self.item))
+            return "\n" + "─ " + str(self.item)
         else:
             return ""
 
 class Data(object):
-    def __init__(self, running_thread: Optional[Thread], source_location: SourceLocation, id: int, state: str, requester: Requester):
+    def __init__(self, owning_thread: ThreadInfo, running_thread: Optional[Thread], source_location: SourceLocation, id: int, state: str, requester: Requester):
+        self.owning_thread = owning_thread
         self.running_thread = running_thread
         self.source_location = source_location
         self.id = id
         self.waiter = requester
         self.state = state
     @classmethod
     def from_json(cls, blob: dict):
-        return cls(Thread.from_json(blob["running_thread"]) if "running_thread" in blob else None, SourceLocation.from_json(blob["source_location"]), blob["id"], blob["state"], Requester.from_json(blob["requester"]))
+        return cls(ThreadInfo.from_json(blob["owning_thread"]), Thread.from_json(blob["running_thread"]) if "running_thread" in blob else None, SourceLocation.from_json(blob["source_location"]), blob["id"], blob["state"], Requester.from_json(blob["requester"]))
     def __str__(self):
         waiter_str = str(self.waiter) if self.waiter != None else ""
         thread_str = f" on {self.running_thread}" if self.running_thread else ""
-        return str(self.source_location) + ", " + self.state + thread_str + waiter_str
+        return str(self.source_location) + ", owned by " + str(self.owning_thread) + ", " + self.state + thread_str + waiter_str
 
 class Promise(object):
     def __init__(self, hierarchy: int, data: Data):

arangod/SystemMonitor/AsyncRegistry/RestHandler.cpp

@@ -72,12 +72,12 @@ auto all_undeleted_promises() -> ForestWithRoots<PromiseSnapshot> {
   registry.for_node([&](PromiseSnapshot promise) {
     if (promise.state != State::Deleted) {
       std::visit(overloaded{
-                     [&](PromiseId async_waiter) {
-                       forest.insert(promise.id, async_waiter, promise);
+                     [&](PromiseId const& async_waiter) {
+                       forest.insert(promise.id.id, async_waiter.id, promise);
                      },
-                     [&](basics::ThreadId sync_waiter_thread) {
-                       forest.insert(promise.id, nullptr, promise);
-                       roots.emplace_back(promise.id);
+                     [&](basics::ThreadInfo const& sync_waiter_thread) {
+                       forest.insert(promise.id.id, nullptr, promise);
+                       roots.emplace_back(promise.id.id);
                      },
                  },
                  promise.requester);

lib/Async/Registry/promise.cpp

@@ -28,17 +28,21 @@
 
 using namespace arangodb::async_registry;
 
-Promise::Promise(Requester requester, std::source_location entry_point)
-    : owning_thread{basics::ThreadId::current()},
-      requester{requester},
+Promise::Promise(CurrentRequester requester, std::source_location entry_point)
+    : owning_thread{basics::ThreadInfo::current()},
+      requester{
+          AtomicRequester::from(requester)},  // TODO hand this in via function
       state{State::Running},
       running_thread{basics::ThreadId::current()},
       source_location{entry_point.file_name(), entry_point.function_name(),
                       entry_point.line()} {}
 
-auto arangodb::async_registry::get_current_coroutine() noexcept -> Requester* {
+// TODO return either SharedPtr<ThreadInfo> or *void but does not need to be
+// atomic
+auto arangodb::async_registry::get_current_coroutine() noexcept
+    -> CurrentRequester* {
   struct Guard {
-    Requester identifier = Requester::current_thread();
+    CurrentRequester identifier = {basics::ThreadInfo::current()};
   };
   // make sure that this is only created once on a thread
   static thread_local auto current = Guard{};
@@ -55,16 +59,22 @@ AddToAsyncRegistry::~AddToAsyncRegistry() {
     node_in_registry->list->mark_for_deletion(node_in_registry.get());
   }
 }
-auto AddToAsyncRegistry::update_requester(Requester new_requester) -> void {
+auto AddToAsyncRegistry::update_requester(std::optional<PromiseId> requester)
+    -> void {
+  if (node_in_registry != nullptr && requester.has_value()) {
+    node_in_registry->data.requester.store(requester.value().id);
+  }
+}
+auto AddToAsyncRegistry::update_requester_to_current_thread() -> void {
   if (node_in_registry != nullptr) {
-    node_in_registry->data.requester.store(new_requester);
+    node_in_registry->data.requester.store(basics::ThreadInfo::current());
   }
 }
-auto AddToAsyncRegistry::id() -> void* {
+auto AddToAsyncRegistry::id() -> std::optional<PromiseId> {
   if (node_in_registry != nullptr) {
-    return node_in_registry->data.id();
+    return {node_in_registry->data.id()};
   } else {
-    return nullptr;
+    return std::nullopt;
   }
 }
 auto AddToAsyncRegistry::update_source_location(std::source_location loc)