small cleanp

Author: pablogsal

Lib/profiling/sampling/sample.py

@@ -296,18 +296,14 @@ def _print_unwinder_stats(self):
         print(f"    Hits:             {code_hits:n} ({ANSIColors.GREEN}{fmt(code_hits_pct)}%{ANSIColors.RESET})")
         print(f"    Misses:           {code_misses:n} ({ANSIColors.RED}{fmt(code_misses_pct)}%{ANSIColors.RESET})")
 
-        # Batched remote read stats
         batched_attempts = stats.get('batched_read_attempts', 0)
         batched_successes = stats.get('batched_read_successes', 0)
         batched_misses = stats.get('batched_read_misses', 0)
         segments_requested = stats.get('batched_read_segments_requested', 0)
         segments_completed = stats.get('batched_read_segments_completed', 0)
-        if batched_attempts > 0 or segments_requested > 0:
+        if batched_attempts > 0:
             batched_success_rate = stats.get('batched_read_success_rate', 0.0)
-            batched_miss_rate = (
-                (batched_misses / batched_attempts * 100)
-                if batched_attempts > 0 else 0
-            )
+            batched_miss_rate = 100.0 - batched_success_rate
             segment_completion_rate = stats.get(
                 'batched_read_segment_completion_rate', 0.0
             )

Modules/_remote_debugging/_remote_debugging.h

@@ -244,6 +244,10 @@ typedef struct {
     uintptr_t thread_state_addr;
 } InterpreterThreadCacheEntry;
 
+// Carries already-read thread state and/or frame buffers across helpers so the
+// downstream callee can skip a remote read. Address fields are caller-supplied
+// inputs; buffer pointers (tstate, frame) are NULL unless a prior batched read
+// successfully populated them.
 typedef struct {
     const char *tstate;
     uintptr_t tstate_addr;
@@ -350,8 +354,10 @@ typedef struct {
     int cache_frames;
     int collect_stats;  // whether to collect statistics
     uint32_t stale_invalidation_counter;  // counter for throttling frame_cache_invalidate_stale
-    uintptr_t cached_tstate_interpreter_addr;  // hot last-interpreter prediction
-    uintptr_t cached_tstate_addr;  // hot first-thread prediction
+    // L1 single-entry shortcut over cached_tstates[]: most workloads sample one
+    // interpreter, so check this pair before hashing into the table below.
+    uintptr_t cached_tstate_interpreter_addr;
+    uintptr_t cached_tstate_addr;
     RemoteDebuggingState *cached_state;
     FrameCacheEntry *frame_cache;  // preallocated array of FRAME_CACHE_MAX_THREADS entries
     UnwinderStats stats;  // statistics for performance analysis

Modules/_remote_debugging/module.c

@@ -477,7 +477,7 @@ _remote_debugging_RemoteUnwinder___init___impl(RemoteUnwinderObject *self,
     return 0;
 }
 
-static size_t
+static inline size_t
 interpreter_thread_cache_index(uintptr_t interpreter_addr)
 {
     // Direct-mapped table indexed by the remote interpreter address. Each entry
@@ -487,7 +487,7 @@ interpreter_thread_cache_index(uintptr_t interpreter_addr)
         & (INTERPRETER_THREAD_CACHE_SIZE - 1);
 }
 
-static uintptr_t
+static inline uintptr_t
 get_cached_tstate_for_interpreter(
     RemoteUnwinderObject *self,
     uintptr_t interpreter_addr)
@@ -510,7 +510,7 @@ get_cached_tstate_for_interpreter(
     return 0;
 }
 
-static void
+static inline void
 set_cached_tstate_for_interpreter(
     RemoteUnwinderObject *self,
     uintptr_t interpreter_addr,
@@ -759,7 +759,7 @@ _remote_debugging_RemoteUnwinder_get_stack_trace_impl(RemoteUnwinderObject *self
             // Target specific thread (only process first interpreter)
             current_tstate = self->tstate_addr;
         }
-        if (current_tstate != 0) {
+        if (current_tstate != 0 && self->cache_frames) {
             set_cached_tstate_for_interpreter(self, current_interpreter, current_tstate);
         }
 

Modules/_remote_debugging/threads.c

@@ -338,11 +338,12 @@ unwind_stack_for_thread(
     PyObject *result = NULL;
     StackChunkList chunks = {0};
 
-    char ts[SIZEOF_THREAD_STATE];
+    char local_ts[SIZEOF_THREAD_STATE];
     char local_prefetched_frame[SIZEOF_INTERP_FRAME];
+    const char *ts;
     RemoteReadPrefetch ctx_prefetch = {0};
     if (prefetch->tstate && prefetch->tstate_addr == *current_tstate) {
-        memcpy(ts, prefetch->tstate, (size_t)unwinder->debug_offsets.thread_state.size);
+        ts = prefetch->tstate;
         if (prefetch->frame) {
             ctx_prefetch.frame = prefetch->frame;
             ctx_prefetch.frame_addr = prefetch->frame_addr;
@@ -356,33 +357,35 @@ unwind_stack_for_thread(
             predicted_frame_addr = entry->addrs[0];
         }
 
-        int bytes_read = read_thread_state_and_maybe_frame(
+        int rc = read_thread_state_and_maybe_frame(
             unwinder,
             *current_tstate,
             (size_t)unwinder->debug_offsets.thread_state.size,
-            ts,
+            local_ts,
             predicted_frame_addr,
             local_prefetched_frame,
             &have_prefetched_frame);
-        if (bytes_read < 0) {
+        if (rc < 0) {
             set_exception_cause(unwinder, PyExc_RuntimeError, "Failed to read thread state");
             goto error;
         }
+        ts = local_ts;
         if (have_prefetched_frame) {
             ctx_prefetch.frame = local_prefetched_frame;
             ctx_prefetch.frame_addr = predicted_frame_addr;
         }
     }
     else {
-        int bytes_read = _Py_RemoteDebug_ReadRemoteMemory(
+        int rc = _Py_RemoteDebug_ReadRemoteMemory(
             &unwinder->handle,
             *current_tstate,
             (size_t)unwinder->debug_offsets.thread_state.size,
-            ts);
-        if (bytes_read < 0) {
+            local_ts);
+        if (rc < 0) {
             set_exception_cause(unwinder, PyExc_RuntimeError, "Failed to read thread state");
             goto error;
         }
+        ts = local_ts;
     }
     STATS_INC(unwinder, memory_reads);
     STATS_ADD(unwinder, memory_bytes_read, unwinder->debug_offsets.thread_state.size);