debugpy: Performance improvements.

Signed-off-by: Jos Verlinde <jos_verlinde@hotmail.com>

Author: Josverl

python-ecosys/debugpy/debugpy/common/constants.py

@@ -1,60 +1,67 @@
 """Constants used throughout debugpy."""
+from micropython import const
 
 # Default networking settings
 DEFAULT_HOST = "127.0.0.1"
 DEFAULT_PORT = 5678
 
 # DAP message types
-MSG_TYPE_REQUEST = "request"
-MSG_TYPE_RESPONSE = "response"
-MSG_TYPE_EVENT = "event"
+MSG_TYPE_REQUEST = const("request")
+MSG_TYPE_RESPONSE = const("response")
+MSG_TYPE_EVENT = const("event")
 
 # DAP events
-EVENT_INITIALIZED = "initialized"
-EVENT_STOPPED = "stopped"
-EVENT_CONTINUED = "continued"
-EVENT_THREAD = "thread"
-EVENT_BREAKPOINT = "breakpoint"
-EVENT_OUTPUT = "output"
-EVENT_TERMINATED = "terminated"
-EVENT_EXITED = "exited"
+EVENT_INITIALIZED = const("initialized")
+EVENT_STOPPED = const("stopped")
+EVENT_CONTINUED = const("continued")
+EVENT_THREAD = const("thread")
+EVENT_BREAKPOINT = const("breakpoint")
+EVENT_OUTPUT = const("output")
+EVENT_TERMINATED = const("terminated")
+EVENT_EXITED = const("exited")
 
 # DAP commands
-CMD_INITIALIZE = "initialize"
-CMD_LAUNCH = "launch"
-CMD_ATTACH = "attach"
-CMD_SET_BREAKPOINTS = "setBreakpoints"
-CMD_CONTINUE = "continue"
-CMD_NEXT = "next"
-CMD_STEP_IN = "stepIn"
-CMD_STEP_OUT = "stepOut"
-CMD_PAUSE = "pause"
-CMD_STACK_TRACE = "stackTrace"
-CMD_SCOPES = "scopes"
-CMD_VARIABLES = "variables"
-CMD_EVALUATE = "evaluate"
-CMD_DISCONNECT = "disconnect"
-CMD_CONFIGURATION_DONE = "configurationDone"
-CMD_THREADS = "threads"
-CMD_SOURCE = "source"
+CMD_INITIALIZE = const("initialize")
+CMD_LAUNCH = const("launch")
+CMD_ATTACH = const("attach")
+CMD_SET_BREAKPOINTS = const("setBreakpoints")
+CMD_CONTINUE = const("continue")
+CMD_NEXT = const("next")
+CMD_STEP_IN = const("stepIn")
+CMD_STEP_OUT = const("stepOut")
+CMD_PAUSE = const("pause")
+CMD_STACK_TRACE = const("stackTrace")
+CMD_SCOPES = const("scopes")
+CMD_VARIABLES = const("variables")
+CMD_EVALUATE = const("evaluate")
+CMD_DISCONNECT = const("disconnect")
+CMD_CONFIGURATION_DONE = const("configurationDone")
+CMD_THREADS = const("threads")
+CMD_SOURCE = const("source")
 
 # Stop reasons
-STOP_REASON_STEP = "step"
-STOP_REASON_BREAKPOINT = "breakpoint"
-STOP_REASON_EXCEPTION = "exception"
-STOP_REASON_PAUSE = "pause"
-STOP_REASON_ENTRY = "entry"
+STOP_REASON_STEP = const("step")
+STOP_REASON_BREAKPOINT = const("breakpoint")
+STOP_REASON_EXCEPTION = const("exception")
+STOP_REASON_PAUSE = const("pause")
+STOP_REASON_ENTRY = const("entry")
 
 # Thread reasons
-THREAD_REASON_STARTED = "started"
-THREAD_REASON_EXITED = "exited"
+THREAD_REASON_STARTED = const("started")
+THREAD_REASON_EXITED = const("exited")
 
 # Trace events
-TRACE_CALL = "call"
-TRACE_LINE = "line"
-TRACE_RETURN = "return"
-TRACE_EXCEPTION = "exception"
+TRACE_CALL = const("call")
+TRACE_LINE = const("line")
+TRACE_RETURN = const("return")
+TRACE_EXCEPTION = const("exception")
+
+# Step modes
+STEP_INTO = const("into")
+STEP_OVER = const("over")
+STEP_OUT = const("out")
+
 
 # Scope types
-SCOPE_LOCALS = "locals"
-SCOPE_GLOBALS = "globals"
+SCOPE_LOCALS = const("locals")
+SCOPE_GLOBALS = const("globals")

python-ecosys/debugpy/debugpy/common/messaging.py

@@ -86,25 +86,46 @@ def recv_message(self):
         if self.closed:
             return None
 
+        # Quick bail-out: if buffer is empty, do a non-blocking peek to see if data is available
+        if not self._recv_buffer:
+            try:
+                # Try to read a small amount non-blocking to see if anything is available
+                peek_data = self.sock.recv(1)
+                if not peek_data:
+                    return None  # No data available
+                # Put the peeked data back into buffer
+                self._recv_buffer = peek_data
+            except OSError as e:
+                # Handle non-blocking socket errors (no data available)
+                if hasattr(e, "errno") and e.errno in (11, 35):  # EAGAIN, EWOULDBLOCK
+                    return None  # No data available, quick exit
+                # Other errors
+                self.closed = True
+                return None
+
+        # Cache frequently accessed attributes
+        recv_buffer = self._recv_buffer
+        sock_recv = self.sock.recv
+
         try:
             # Read headers
-            while b"\r\n\r\n" not in self._recv_buffer:
+            while b"\r\n\r\n" not in recv_buffer:
                 try:
-                    data = self.sock.recv(1024)
+                    data = sock_recv(1024)
                     if not data:
                         self.closed = True
                         return None
-                    self._recv_buffer += data
+                    recv_buffer += data
                 except OSError as e:
                     # Handle timeout and other socket errors
                     if hasattr(e, "errno") and e.errno in (11, 35):  # EAGAIN, EWOULDBLOCK
                         return None  # No data available
                     self.closed = True
                     return None
 
-            header_end = self._recv_buffer.find(b"\r\n\r\n")
-            header_str = self._recv_buffer[:header_end].decode("utf-8")
-            self._recv_buffer = self._recv_buffer[header_end + 4 :]
+            header_end = recv_buffer.find(b"\r\n\r\n")
+            header_str = recv_buffer[:header_end].decode("utf-8")
+            recv_buffer = recv_buffer[header_end + 4 :]
 
             # Parse Content-Length
             content_length = 0
@@ -114,24 +135,26 @@ def recv_message(self):
                     break
 
             if content_length == 0:
+                self._recv_buffer = recv_buffer
                 return None
 
             # Read body
-            while len(self._recv_buffer) < content_length:
+            while len(recv_buffer) < content_length:
                 try:
-                    data = self.sock.recv(content_length - len(self._recv_buffer))
+                    data = sock_recv(content_length - len(recv_buffer))
                     if not data:
                         self.closed = True
                         return None
-                    self._recv_buffer += data
+                    recv_buffer += data
                 except OSError as e:
                     if hasattr(e, "errno") and e.errno in (11, 35):  # EAGAIN, EWOULDBLOCK
+                        self._recv_buffer = recv_buffer
                         return None
                     self.closed = True
                     return None
 
-            body = self._recv_buffer[:content_length]
-            self._recv_buffer = self._recv_buffer[content_length:]
+            body = recv_buffer[:content_length]
+            self._recv_buffer = recv_buffer[content_length:]
 
             # Parse JSON
             try:

python-ecosys/debugpy/debugpy/server/debug_session.py

@@ -424,11 +424,13 @@ def _handle_source(self, seq, args):
                 #  message=f"Could not read source: {e}"
             )
 
-    def _trace_function(self, frame, event, arg):
+    def _trace_function(self, frame, event:str, arg):
         """Trace function called by sys.settrace."""
+        # https://docs.python.org/3/library/sys.html#sys.settrace
+        global _twiddel
         # Process any pending DAP messages frequently
+      
         self.process_pending_messages()
-
         # Handle breakpoints and stepping
         if self.pdb.should_stop(frame, event, arg):
             self._send_stopped_event(
@@ -441,6 +443,10 @@ def _trace_function(self, frame, event, arg):
             # Wait for continue command
             self.pdb.wait_for_continue()
 
+        # The trace function is invoked (with event set to 'call') whenever a new local scope is entered; 
+        # it should return a reference to a local trace function to be used for the new scope, 
+        # or None if the scope shouldn’t be traced.
+
         return self._trace_function
 
     def _send_stopped_event(self, reason):

python-ecosys/debugpy/debugpy/server/pdb_adapter.py

@@ -3,10 +3,13 @@
 import sys
 import time
 import os
-import json
+from micropython import const
 
 Any = object
 from ..common.constants import (
+    STEP_INTO,
+    STEP_OUT,
+    STEP_OVER,
     TRACE_CALL,
     TRACE_LINE,
     TRACE_RETURN,
@@ -15,14 +18,14 @@
     SCOPE_GLOBALS,
 )
 
-VARREF_LOCALS = 1
-VARREF_GLOBALS = 2
-VARREF_LOCALS_SPECIAL = 3
-VARREF_GLOBALS_SPECIAL = 4
+VARREF_LOCALS = const(1)
+VARREF_GLOBALS = const(2)
+VARREF_LOCALS_SPECIAL = const(3)
+VARREF_GLOBALS_SPECIAL = const(4)
 
 # New constants for complex variable references
-VARREF_COMPLEX_BASE = 10000  # Base for complex variable references
-MAX_CACHE_SIZE = 50  # Limit cache size for memory constraints
+VARREF_COMPLEX_BASE = const(10000)  # Base for complex variable references
+MAX_CACHE_SIZE = const(50)  # Limit cache size for memory constraints
 
 
 class VariableReferenceCache:
@@ -54,17 +57,12 @@ def _cleanup_oldest(self) -> None:
         """Remove oldest entries to free memory - optimized for MicroPython."""
         if not self.cache or not self.insertion_order:
             return
-            
-        # More aggressive cleanup for memory-constrained environments
-        to_remove = max(1, len(self.cache) // 3)  # Remove 1/3 instead of 1/4
-        
+        to_remove = max(1, len(self.cache) // 3)  
         # Direct list slicing is more memory efficient than iteration
         keys_to_remove = self.insertion_order[:to_remove]
-        
         # Batch delete for efficiency
         for key in keys_to_remove:
             self.cache.pop(key, None)  # Use pop with default to avoid KeyError
-        
         # Update insertion order in one operation
         self.insertion_order = self.insertion_order[to_remove:]
 
@@ -188,16 +186,8 @@ def set_breakpoints(self, filename: str, breakpoints: list[dict]):
                 if local_name != filename:
                     self.breakpoints[local_name] = {}
                     self._debug_print(f"[>>>] Setting breakpoints for local: {local_name}:{line}")
-                    self.breakpoints[local_name][line] = {
-                        "line": line,
-                        "verified": True,
-                        "source": {"path": filename},
-                    }
-                self.breakpoints[filename][line] = {
-                    "line": line,
-                    "verified": True,
-                    "source": {"path": filename},
-                }
+                    self.breakpoints[local_name][line] = {}
+                self.breakpoints[filename][line] = {}
                 actual_breakpoints.append(
                     {"line": line, "verified": True, "source": {"path": filename}}
                 )
@@ -208,20 +198,19 @@ def set_breakpoints(self, filename: str, breakpoints: list[dict]):
 
     def should_stop(self, frame, event: str, arg):
         """Determine if execution should stop at this point."""
+        # HOT path - no debug printing here
         self.current_frame = frame
         self.hit_breakpoint = False
 
-        # Get frame information
-        filename = frame.f_code.co_filename
+        # Cache frame attributes to reduce lookup overhead
+        frame_code = frame.f_code
+        filename = frame_code.co_filename
         lineno = frame.f_lineno
+        
         # Check for exact filename match first
         if filename in self.breakpoints and lineno in self.breakpoints[filename]:
-            self._debug_print(f"[PDB] HIT BREAKPOINT (exact match) at {filename}:{lineno}")
-            # Record the path mapping (in this case, they're already the same)
-            # self.file_mappings[filename] = self._filename_as_debugger(filename)
             self.hit_breakpoint = True
             return True
-            # path/file.py matched - but not the line number - keep running
         else:
             # file not (yet) matched - this is slow so we do not want to do this often.
             # TODO: use builins - sys.path method to find the file
@@ -230,17 +219,17 @@ def should_stop(self, frame, event: str, arg):
                 self.breakpoints[filename] = {}  # Ensure the filename is in the breakpoints dict
             if not filename in self.file_mappings:
                 self.file_mappings[filename] = self._filename_as_debugger(filename)
-                self._debug_print(
-                    f"[PDB] add mapping for :'{filename}' -> '{self.file_mappings[filename]}'"
-                )
+                # self._debug_print(
+                #     f"[PDB] add mapping for :'{filename}' -> '{self.file_mappings[filename]}'"
+                # )
 
         # Check stepping
-        if self.step_mode == "into":
+        if self.step_mode == STEP_INTO:
             if event in (TRACE_CALL, TRACE_LINE):
                 self.step_mode = None
                 return True
 
-        elif self.step_mode == "over":
+        elif self.step_mode == STEP_OVER:
             if event == TRACE_LINE and frame == self.step_frame:
                 self.step_mode = None
                 return True
@@ -251,7 +240,7 @@ def should_stop(self, frame, event: str, arg):
                 else:
                     self.step_mode = None
 
-        elif self.step_mode == "out":
+        elif self.step_mode == STEP_OUT:
             if event == TRACE_RETURN and frame == self.step_frame:
                 self.step_mode = None
                 return True