Cloud Debugger Code Block Re-Compilation for Non-Invasive Breakpoint Debugging
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Debugging server-side code is challenging due to remoteness from the programmer's debugger, leading to logistical issues with breakpoint data and execution suspension, especially under load, causing inefficiencies and complexity in debugging server-side services.
Innovation Solution
Re-compiling specific code blocks of the target program without optimizations to include executable instructions for generating snapshots of debugger information at breakpoints, allowing non-blocking and non-invasive debugging by conditioning breakpoints on logical execution contexts, thus minimizing disruption and sorting efforts.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If traditional debugging techniques are applied to server-side code executing under load, then breakpoint data can be collected, but execution of the target program stops and substantial time is required to sort out the debugging data
Solution Approach 1:
The patent segments the monolithic breakpoint handling process into distinct components: identification of logical execution context, conditional evaluation, selective snapshot generation, and continuous execution. By dividing the debugging process into these manageable segments, the system can collect breakpoint data without stopping the entire program execution, thus resolving the contradiction between measurement precision and productivity
Solution Approach 2:
The patent introduces an intermediary conditional logic layer between the breakpoint trigger and the snapshot generation. This intermediary evaluates logical execution context conditions to determine whether to generate breakpoint data, acting as a mediator that filters breakpoint events. This allows the system to maintain execution continuity while still collecting necessary debugging information selectively
2Loss of information
If breakpoints are set in server-side code servicing multiple users, then debugging information can be obtained, but all users pause and execution stops
Solution Approach 1:
The patent applies local quality by making breakpoint behavior context-dependent rather than uniform. Different logical execution contexts receive different treatments based on evaluated conditions. This allows debugging information to be captured for specific contexts while other user sessions continue uninterrupted, maintaining service availability while obtaining necessary debugging information
Solution Approach 2:
The patent implements partial action by selectively generating breakpoint snapshots only when logical execution context conditions are met. Instead of capturing all breakpoint events universally, the system applies conditional filtering to capture only the necessary subset of debugging information. This partial approach maintains service availability while still providing adequate debugging data
3Measurement precision
If code is re-compiled without optimizations to include breakpoint instructions, then debugging information can be generated, but processing time increases
Solution Approach 1:
The patent applies preliminary action by re-compiling code blocks with debugging instructions in advance, before actual debugging sessions. The system pre-processes identified code blocks, embedding breakpoint and snapshot generation instructions during off-peak times or as part of the deployment process. This preliminary preparation eliminates the need for time-consuming recompilation during active debugging, thus reducing execution time loss while maintaining measurement precision
Data Source
Figure 1
Figure 2
Figure 3
AI summary
Systems and methods for processing breakpoints in a target program executing on a remotely located server computer are presented. In one embodiment, upon receiving instructions to set a breakpoint in a target program, a code block of the target program is identified in which the execution location of the breakpoint is to be set. The identified code block of the target program is re-compiled. Re-compiling the code block of the target program comprises re-compiling the code block without optimizations and including executable instructions at the execution location of the breakpoint to generate a snapshot of debugger information regarding the target program upon the breakpoint triggering. The re-compiled code block is then bound in the target program.