gh-91048: Reintroduce the memory cache for remote debugging

pablogsal · pablogsal · commit 8847d02c027d · 2025-07-09T00:50:14.000+01:00
diff --git a/Modules/_remote_debugging_module.c b/Modules/_remote_debugging_module.c
@@ -2762,6 +2762,7 @@ _remote_debugging_RemoteUnwinder_get_stack_trace_impl(RemoteUnwinderObject *self
     }
 
 exit:
+   _Py_RemoteDebug_ClearCache(&self->handle);
     return result;
 }
 
@@ -2885,9 +2886,11 @@ _remote_debugging_RemoteUnwinder_get_all_awaited_by_impl(RemoteUnwinderObject *s
         goto result_err;
     }
 
+    _Py_RemoteDebug_ClearCache(&self->handle);
     return result;
 
 result_err:
+    _Py_RemoteDebug_ClearCache(&self->handle);
     Py_XDECREF(result);
     return NULL;
 }
@@ -2954,9 +2957,11 @@ _remote_debugging_RemoteUnwinder_get_async_stack_trace_impl(RemoteUnwinderObject
         goto cleanup;
     }
 
+    _Py_RemoteDebug_ClearCache(&self->handle);
     return result;
 
 cleanup:
+    _Py_RemoteDebug_ClearCache(&self->handle);
     Py_XDECREF(result);
     return NULL;
 }
@@ -2982,6 +2987,7 @@ RemoteUnwinder_dealloc(PyObject *op)
     }
 #endif
     if (self->handle.pid != 0) {
+        _Py_RemoteDebug_ClearCache(&self->handle);
         _Py_RemoteDebug_CleanupProcHandle(&self->handle);
     }
     PyObject_Del(self);
diff --git a/Python/remote_debug.h b/Python/remote_debug.h
@@ -110,6 +110,14 @@ get_page_size(void) {
     return page_size;
 }
 
+typedef struct page_cache_entry {
+    uintptr_t page_addr; // page-aligned base address
+    char *data;
+    int valid;
+    struct page_cache_entry *next;
+} page_cache_entry_t;
+
+#define MAX_PAGES 1024
 
 // Define a platform-independent process handle structure
 typedef struct {
@@ -121,9 +129,27 @@ typedef struct {
 #elif defined(__linux__)
     int memfd;
 #endif
+    page_cache_entry_t pages[MAX_PAGES];
     Py_ssize_t page_size;
 } proc_handle_t;
 
+static void
+_Py_RemoteDebug_FreePageCache(proc_handle_t *handle)
+{
+    for (int i = 0; i < MAX_PAGES; i++) {
+        PyMem_RawFree(handle->pages[i].data);
+        handle->pages[i].data = NULL;
+        handle->pages[i].valid = 0;
+    }
+}
+
+UNUSED static void
+_Py_RemoteDebug_ClearCache(proc_handle_t *handle)
+{
+    for (int i = 0; i < MAX_PAGES; i++) {
+        handle->pages[i].valid = 0;
+    }
+}
 
 #if defined(__APPLE__) && defined(TARGET_OS_OSX) && TARGET_OS_OSX
 static mach_port_t pid_to_task(pid_t pid);
@@ -152,6 +178,10 @@ _Py_RemoteDebug_InitProcHandle(proc_handle_t *handle, pid_t pid) {
     handle->memfd = -1;
 #endif
     handle->page_size = get_page_size();
+    for (int i = 0; i < MAX_PAGES; i++) {
+        handle->pages[i].data = NULL;
+        handle->pages[i].valid = 0;
+    }
     return 0;
 }
 
@@ -170,6 +200,7 @@ _Py_RemoteDebug_CleanupProcHandle(proc_handle_t *handle) {
     }
 #endif
     handle->pid = 0;
+    _Py_RemoteDebug_FreePageCache(handle);
 }
 
 #if defined(__APPLE__) && defined(TARGET_OS_OSX) && TARGET_OS_OSX
@@ -1035,6 +1066,53 @@ _Py_RemoteDebug_PagedReadRemoteMemory(proc_handle_t *handle,
                                       size_t size,
                                       void *out)
 {
+    size_t page_size = handle->page_size;
+    uintptr_t page_base = addr & ~(page_size - 1);
+    size_t offset_in_page = addr - page_base;
+
+    if (offset_in_page + size > page_size) {
+        return _Py_RemoteDebug_ReadRemoteMemory(handle, addr, size, out);
+    }
+
+    // Search for valid cached page
+    for (int i = 0; i < MAX_PAGES; i++) {
+        page_cache_entry_t *entry = &handle->pages[i];
+        if (entry->valid && entry->page_addr == page_base) {
+            memcpy(out, entry->data + offset_in_page, size);
+            return 0;
+        }
+    }
+
+    // Find reusable slot
+    for (int i = 0; i < MAX_PAGES; i++) {
+        page_cache_entry_t *entry = &handle->pages[i];
+        if (!entry->valid) {
+            if (entry->data == NULL) {
+                entry->data = PyMem_RawMalloc(page_size);
+                if (entry->data == NULL) {
+                    _set_debug_exception_cause(PyExc_MemoryError,
+                        "Cannot allocate %zu bytes for page cache entry "
+                        "during read from PID %d at address 0x%lx",
+                        page_size, handle->pid, addr);
+                    return -1;
+                }
+            }
+
+            if (_Py_RemoteDebug_ReadRemoteMemory(handle, page_base, page_size, entry->data) < 0) {
+                // Try to just copy the exact ammount as a fallback
+                PyErr_Clear();
+                goto fallback;
+            }
+
+            entry->page_addr = page_base;
+            entry->valid = 1;
+            memcpy(out, entry->data + offset_in_page, size);
+            return 0;
+        }
+    }
+
+fallback:
+    // Cache full — fallback to uncached read
     return _Py_RemoteDebug_ReadRemoteMemory(handle, addr, size, out);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -2762,6 +2762,7 @@ _remote_debugging_RemoteUnwinder_get_stack_trace_impl(RemoteUnwinderObject *self`
`2762`	`2762`	`}`
`2763`	`2763`
`2764`	`2764`	`exit:`
	`2765`	`+ _Py_RemoteDebug_ClearCache(&self->handle);`
`2765`	`2766`	`return result;`
`2766`	`2767`	`}`
`2767`	`2768`
`@@ -2885,9 +2886,11 @@ _remote_debugging_RemoteUnwinder_get_all_awaited_by_impl(RemoteUnwinderObject *s`
`2885`	`2886`	`goto result_err;`
`2886`	`2887`	`}`
`2887`	`2888`
	`2889`	`+ _Py_RemoteDebug_ClearCache(&self->handle);`
`2888`	`2890`	`return result;`
`2889`	`2891`
`2890`	`2892`	`result_err:`
	`2893`	`+ _Py_RemoteDebug_ClearCache(&self->handle);`
`2891`	`2894`	`Py_XDECREF(result);`
`2892`	`2895`	`return NULL;`
`2893`	`2896`	`}`
`@@ -2954,9 +2957,11 @@ _remote_debugging_RemoteUnwinder_get_async_stack_trace_impl(RemoteUnwinderObject`
`2954`	`2957`	`goto cleanup;`
`2955`	`2958`	`}`
`2956`	`2959`
	`2960`	`+ _Py_RemoteDebug_ClearCache(&self->handle);`
`2957`	`2961`	`return result;`
`2958`	`2962`
`2959`	`2963`	`cleanup:`
	`2964`	`+ _Py_RemoteDebug_ClearCache(&self->handle);`
`2960`	`2965`	`Py_XDECREF(result);`
`2961`	`2966`	`return NULL;`
`2962`	`2967`	`}`
`@@ -2982,6 +2987,7 @@ RemoteUnwinder_dealloc(PyObject *op)`
`2982`	`2987`	`}`
`2983`	`2988`	`#endif`
`2984`	`2989`	`if (self->handle.pid != 0) {`
	`2990`	`+ _Py_RemoteDebug_ClearCache(&self->handle);`
`2985`	`2991`	`_Py_RemoteDebug_CleanupProcHandle(&self->handle);`
`2986`	`2992`	`}`
`2987`	`2993`	`PyObject_Del(self);`