Breakpoint logging and constraint mechanisms for parallel computing systems

• US 7,634,761 B2
• Filed: 10/29/2004
• Issued: 12/15/2009
• Est. Priority Date: 10/29/2004
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Cunningham, John A, Buschardt, Cameron S
• Primary Examiner(s): Vo; Ted T
• Application Number:
  US10/977,416
• Publication Number:
  US 20060101405A1
• Time in Patent Office: 1,873 Days
• Field of Search: 717124-135
• US Class Current: 717/129
• CPC Class Codes: G06F 11/3636 by tracing the execution of the program

Abstract

A system that facilitates debugging of a computing cluster and/or distributed applications environment. A debugger component receives a debugging expression, and a constraint component includes both a static constraint engine (SCE) and a dynamic constraint engine (DCE) processes the debugging expression to automatically perform a debugging process on at least two processes of a plurality of processes. When the user creates a tracepoint or constraint breakpoint the expression is sent directly to the SCE, which parses the constraint and tracepoint expressions, reduces the expression by evaluating parts of the expression based on static values (such as process ID or filename), and passes the remainder on to each of the applicable DCEs. The DCEs register a breakpoint at the applicable location in the process, and upon receiving a breakpoint event, evaluates the remainder of the constraint expression on the dynamic data, and sends log and/or break event data back to the user for viewing.

Claims

1. A system that facilitates debugging an application with parallel processes running on several machines in a computing cluster or distributed applications environment, the system comprising:

a memory;

a plurality of machines, which are executing the application in parallel;

a plurality of application processes, running in parallel, including at least one application process running on each of the plurality of machines;

a debugger user interface engine;

a debugging engine that receives a debugging expression from the debugger user interface engine and that transmits log data and break event data back to the debugger user interface engine, wherein the received debugging expression comprises at least one of a tracepoint expression and a constraint expression, wherein the debugging engine processes the debugging expression to automatically perform a debugging process on at least two application processes of the plurality of application processes, and wherein the debugging engine comprises

a static constraint engine; and

a plurality of dynamic constraint engines that interface to the static constraint engine, wherein for each machine of the plurality of machines there is at least one corresponding dynamic constraint engine, and wherein each of the plurality of dynamic constraint engines is associated with one or more of the at least one application processes running on the machine;

wherein when a user creates the debugging expression via the debugger user interface, the debugging expression is sent directly to the static constraint engine;

wherein the static constraint engine receives and parses the debugging expression, reducing the expression by evaluating parts of the expression based on static values, extracting static information, and treating as

ambiguous any term that relies on a variable whose value is not yet known,

wherein the static constraint engine automatically generates, for the received debugging expression, breakpoint information corresponding to a breakpoint or a tracepoint, wherein the breakpoint information includes may-break/must-break/must-not-break information, and the static constraint engine forwards the breakpoint information to at least one selected dynamic constraint engine of the plurality of dynamic constraint engines when it is determined that the breakpoint or tracepoint is reachable by the one or more application processes associated with the selected dynamic constraint engine, such that the static constraint engine does not forward the breakpoint information to the selected dynamic constraint engine when the breakpoint or tracepoint is unreachable by the one or more associated application processes, and further wherein the static constraint engine forwards the breakpoint information to the selected dynamic constraint engine when interruption to the running application, as a whole, is below a predetermined interruption value, and

wherein the selected dynamic constraint engine, upon receiving the breakpoint information from the static constraint engine, registers the corresponding breakpoint or tracepoint at one or more applicable locations in at least one of the one or more associated application processes, and

wherein, the selected dynamic constraint engine, upon receiving a breakpoint event from one of the one or more associated application processes, evaluates dynamically the breakpoint event in light of the breakpoint information, wherein the selected dynamic constraint engine dynamically performs one of (i) applying the tracepoint to minimize a stop time associated with stopping the application process, sending a log back to the user interface engine for at least presentation to the user and storage, or (ii) applying the breakpoint and returning break event information to the user interface engine for presentation to the user.

2. The system of claim 1, wherein the one or more application processes associated with the selected dynamic constraint engine comprise a plurality of processes, and wherein the selected dynamic constraint engine processes the received breakpoint information to determine on which of the plurality of associated processes the debugging process will be performed.

3. The system of claim 1, wherein the debugger user interface engine receives at least one of log and breakpoint data from the plurality of application processes.

4. The system of claim 3, wherein the at least one of log and breakpoint data is transmitted asynchronously back to the debugger user interface engine.

5. The system of claim 1, further comprising an artificial intelligence component that interfaces to the static constraint engine and the plurality of dynamic constraint engines to facilitate automation that employs a probabilistic and/or statistical-based analysis to prognose or infer where to place breakpoints in a given process.

6. The system of claim 1, wherein the selected dynamic constraint engine is part of an operating system.

7. The system of claim 1, wherein the computing cluster or distributed applications environment is a computing cluster and wherein the plurality of machines are cluster machines, each having a processor and a memory.

8. The system of claim 1, wherein when the debugging engine processes the debugging expression to automatically perform the debugging process on the at least two application processes of the plurality of application processes, the at least two application processes are processes running on at least two different machines of the plurality of machines.

9. In a computing cluster or distributed applications environment that includes a plurality of processing units with corresponding memories, a method of debugging a parallel application that is running with a plurality of parallel application processes across a plurality of machines, including at least one application process on each machine, the method comprising:

generating, at a debugger user interface engine, a debugging expression that includes at least one of a tracepoint expression corresponding to a tracepoint and a breakpoint expression corresponding to a breakpoint;

receiving the debugging expression at a debugging engine, wherein the debugging engine comprises a static constraint engine and a plurality of dynamic constraint engines that interface to the static constraint engine, wherein for each machine of the plurality of machines there is at least one corresponding dynamic constraint engine of the plurality of dynamic constraint engines, and wherein each dynamic constraint engine is associated with one or more of the at least one application processes running on the machine;

processing the debugging expression at the static constraint engine, wherein said processing includes

extracting static information and non-static information from the debugging expression, wherein static information defines select ones of the plurality of machines on which a debugging operation is to be performed;

treating as ambiguous any term in the debugging expression that relies on a variable whose value is not yet known; and

generating breakpoint information for the debugging expression corresponding to at least one of the breakpoint and the tracepoint, including may-break/must-break/must-not-break information;

forwarding, for each machine of the select ones of the machines, the breakpoint information from the static constraint engine to at least one selected dynamic constraint engine corresponding to the machine, when it is determined (i) that the breakpoint or the tracepoint is reachable by the one or more application processes associated with the selected dynamic constraint engine, such that breakpoint information is not forwarded to the selected dynamic constraint engine when the breakpoint or tracepoint is unreachable by the one or more associated application processes, and (ii) that interruption to the running application, as a whole, is below a predetermined interruption value; and

performing, in parallel, the debugging operation on a plurality of application processes corresponding to the select ones of the machines.

10. The method of claim 9, further comprising transmitting debugging results back to the debugger user interface engine for presentation to a user.

11. The method of claim 9, further comprising determining whether to employ at least one of the tracepoint and the breakpoint based upon interruption time information.

12. The method of claim 9, further comprising applying the tracepoint to minimize a stop time associated with stopping a process of the parallel application.

13. The method of claim 12, further comprising transmitting asynchronously to the debugger user interface engine log information associated with the act of applying the tracepoint.

14. The method of claim 13, further comprising determining whether to show break information via the debugger user interface engine or ignore it.

15. The method of claim 9, further comprising processing the non-static information against dynamic data received from the debugging operation on the plurality of application processes.

16. The method of claim 15, wherein the dynamic data include at least one of a thread ID, a call-stack location, and a user variable.

17. The method of claim 9, wherein for performing, in parallel, the debugging operation on a plurality of application processes corresponding to the select ones of the machines comprises, for each process,

registering, by means of the dynamic constraint engines associated with the processes, a breakpoint at an applicable location in one or more of the application processes;

receiving, at the associated dynamic constraint engine, a breakpoint event from a corresponding application process of the application processes;

evaluating dynamically the breakpoint event in light of the breakpoint information; and

applying, based on the dynamic evaluation of the breakpoint event, one of a tracepoint expression to minimize a stop time associated with stopping the application process, wherein a log is sent back to the user interface engine for at least presentation to the user and storage, or a breakpoint expression, returning break event information to the user interface engine for presentation to the user.

18. The method of claim 17, wherein the corresponding application process is stopped when the breakpoint event from the process is received;

and wherein evaluating dynamically the breakpoint event comprises determining whether to hold the process for breakpoint analysis or tracepoint analysis, and wherein if it is determined that tracepoint analysis should be employed, applying the tracepoint expression comprises logging desired tracepoint information, releasing the process for execution and transmitting the logged tracepoint information back to the debugging user interface engine, whereas, if it is determined that breakpoint analysis should be employed, applying the breakpoint expression comprises performing breakpoint analysis and transmitting breakpoint event information back to the debugger user interface engine.

19. The method of claim 9, further comprising implementing, with an AI component comprising an automatic classifier system and process, with the AI component interfaced to the static constraint engine and plurality of dynamic constraint engines, an AI based scheme to determine where to automatically place breakpoints, wherein the automatic classifier system uses a classifier function that maps an input attribute vector to a confidence that the input belongs to a class in order to employ a probabilistic and statistical-based analysis to prognose and infer where breakpoint should be placed.

20. The method of claim 19, wherein the automatic classifier system further comprises a support vector machine that is trained in a training phase with training data, wherein the trained support vector machine is used to automatically prognose and infer where the breakpoint should be placed by finding a hypersurface in the space of possible inputs and attempting to split triggering criteria from non-triggering events to make classifications for testing data that is near, but not identical to training data.

21. The method of claim 9, further comprising

implementing, using an AI component comprising an automatic classifier system and process, with the AI component interfaced to the static constraint engine and plurality of dynamic constraint engines, an AI based scheme to determine optimal minimum process interruption time for any single process of the parallel application such that program interruption is minimized, and

determining automatically whether to employ tracepoint or breakpoint processing on the plurality of the application processes running on two or more of the plurality of machines, wherein the AI component first obtains program calibration information by performing breakpoint and tracepoint insertions during a calibration phase and then uses the program calibration information to make the automatic determination of whether to employ tracepoint or breakpoint processing by estimating the interruption time for each process according to the calibration information.

22. A computer program product, comprising one or more computer-readable computer storage media, that when executed by one or more processors of one or more computing systems, causes the one or more computing systems to perform at least the following:

generate, at a debugger user interface engine, a debugging expression that includes at least one of a tracepoint expression corresponding to a tracepoint and a breakpoint expression corresponding to a breakpoint;

receive the debugging expression at a debugging engine, wherein the debugging engine comprises a static constraint engine and a plurality of dynamic constraint engines that interface to the static constraint engine, wherein for each machine of the plurality of machines there is at least one corresponding dynamic constraint engine of the plurality of dynamic constraint engines, and wherein each dynamic constraint engine is associated with one or more of the at least one application processes running on the machine;

process the debugging expression at the static constraint engine, wherein said processing includes

extracting static information and non-static information from the debugging expression, wherein static information defines select ones of the plurality of machines on which a debugging operation is to be performed;

treating as ambiguous any term in the debugging expression that relies on a variable whose value is not yet known; and

generating breakpoint information for the debugging expression corresponding to at least one of the breakpoint and the tracepoint, including may-break/must-break/must-not-break information;

forward, for each machine of the select ones of the machines, the breakpoint information from the static constraint engine to at least one selected dynamic constraint engine corresponding to the machine when it is determined (i) that the breakpoint or the tracepoint is reachable by the one or more application processes associated with the selected dynamic constraint engine, such that breakpoint information is not forwarded to the selected dynamic constraint engine when the breakpoint or tracepoint is unreachable by the one or more associated application processes, and (ii) that interruption to the running application, as a whole, is below a predetermined interruption value; and

perform, in parallel, the debugging operation on a plurality of application processes corresponding to the select ones of the machines.