Debugging techniques in a multithreaded environment

• US 20050034024A1
• Filed: 09/09/2004
• Published: 02/10/2005
• Est. Priority Date: 11/13/1998
• Status: Active Grant

• Current Assignee: CRAY Incorporated (Hewlett-Packard Enterprise Company)
• Original Assignee: CRAY Incorporated (Hewlett-Packard Enterprise Company)
• Inventors: Alverson, Gail A., Smith, Burton J., Kaplan, Laurence S., Niehaus, Mark L.
• Granted Patent: US 7,428,727 B2
• Time in Patent Office: Days
• US Class Current: 714/38
• CPC Class Codes: G06F 11/362 Software debugging

Abstract

A system for debugging targets using various techniques, some of which are particularly useful in a multithread environment. These techniques include implementing breakpoints using out-of-line instruction emulation so that an instruction replaced with a breakpoint instruction does not need to be returned to its original location for single-step execution, executing a debugger nub for each target as part of the target task but using a nub task thread for the nub execution that is separate from the target task threads, providing immunity from breakpoints for specified threads such as the nub thread via specialized breakpoint handlers used by those threads, and virtualizing the debugger nub such that a shared root nub provides a uniform interface between the debugger and the target while specialized nubs provide differing functionality based on the type of target being debugged.

Claims

1-3. -3. (Cancelled)

4. A computer-implemented method for executing a breakpoint instruction without removing the breakpoint instruction from an executing target program, the target program having a multiple software threads each able to execute without halting execution of the other threads, the method comprising:

executing the target program using a target program thread;

placing a breakpoint at a first location of a first instruction in the target program;

installing an OOL instruction emulation group for the first instruction replaced by the breakpoint in an area of memory different from the first location;

responsive to receiving an indication to assume execution of the target program, executing the OOL instruction emulation group at its installed location; and

subsequent to executing the OOL instruction emulation group, resuming execution of the target program by executing a second instruction at a second location immediately after the first location in the target program.

5. The method of claim 4, wherein the target program is an application program.

6. The method of claim 4, wherein the target program is an operating system.

7. The method of claim 4, wherein the OOL instruction emulation group is generated by a front-end debugger program.

8. The method of claim 4, wherein the OOL instruction emulation group is generated by a debugger nub.

9. The method of claim 4, wherein the OOL instruction emulation group is generated by the target program thread.

10. The method of claim 4, wherein the OOL instruction emulation group is installed by a debugger nub.

11. The method of claim 4, wherein the OOL instruction emulation group is installed by the target thread program.

12. The method of claim 4, wherein the OOL instruction emulation group is a subroutine of the target program.

13. The method of claim 4, wherein the OOL instruction emulation group is executed by a breakpoint handler.

14. A computer-implemented method for executing a breakpoint instruction without removing the breakpoint instruction from an executing target program, the target program having a multiple software threads each able to execute without halting execution of the other threads, the method comprising:

in an executing target program, receiving a request to add a breakpoint for a first instruction at a first location in the target program;

generating an OOL instruction emulation group for the first instruction;

installing the OOL instruction emulation group in a free area of memory separate from the first location;

saving an indication of the location of the OOL instruction emulation group; and

replacing the first instruction with a break instruction.

15. The method of claim 14 further comprising:

in the executing target program, executing the break instruction causes the target program thread to;

halt execution of the target program; and

transfer control to a breakpoint handler for the target program thread.

16. The method of claim 14, wherein the OOL instruction emulation group comprises instructions for:

retrieving information about the state of the target program thread just prior to the breakpoint;

restoring the target program thread execution environment; and

executing the first instruction from its location within the OOL instruction emulation group.

17. A computer-readable medium having stored thereon computer instructions that, when executed by a computer, cause the computer to:

generate an OOL instruction emulation group for an instruction in an area of memory in an executing target program in a target program thread;

install the OOL instruction emulation group in an area of memory different from the area of memory in the executing target program;

save an indication of the area of memory in which the OOL instruction emulation group is installed; and

replace the instruction in the area of memory in the executing target program with a break instruction.

18. The computer-readable medium of claim 17 further comprising instructions that, when executed by a computer, cause the computer to:

halt execution of the target program thread upon encountering the break instruction; and

transfer control to a breakpoint handler for the target program thread, such that the breakpoint handler transfers flow of execution to the OOL instruction emulation group in response to an instruction to resume execution of the target program.

19. The computer-readable medium of claim 17, wherein the OOL instruction emulation group is executed in the area of memory different from the area of memory in the executing target program.

20. The computer-readable medium of claim 17, wherein the OOL instruction emulation group ensures that the target program resumes execution after the replaced instruction.

21. The computer-readable medium of claim 17, wherein the OOL instruction emulation group retrieves state information of the target program thread just before encountering the breakpoint instruction.

22. The computer-readable medium of claim 17, wherein the OOL instruction emulation group is a subroutine of the target program.

23. A system for executing a breakpoint instruction comprising:

a target program operable to execute in a target program thread, the target program having a break instruction at a first location, the break instruction replacing a first instruction formerly located at the first location;

an OOL instruction emulation group comprising a plurality of instructions including the first instruction, the OOL instruction emulation group operable to execute in a free area of memory separate from the first location; and

a breakpoint handler operable to interact with a debugger program, the breakpoint handler operable to transfer flow of execution to the OOL instruction group subsequent to interacting with the debugger program.

24. The system of claim 23 further comprising a front-end debugger program operable to generate the OOL instruction emulation group.

25. The system of claim 23 further comprising a nub operable to generate the OOL instruction emulation group.

26. The system of claim 23, wherein the breakpoint handler is operable to interact with the debugger program through a nub.

27. The system of claim 26, wherein the nub executes as part of the target program thread.

28. The system of claim 23, wherein the breakpoint instruction is a conditional breakpoint instruction.

29. The system of claim 26, wherein the nub executes using a separate thread within the target program thread.

30. A computer-implemented method for debugging an executing target program having multiple software threads each able to execute without halting execution of the other threads and having at least one breakpoint set in such a manner that encountering the breakpoint causes a break to occur, the method comprising:

executing a first program using a thread of the target program;

executing the target program using the other target program threads;

when one of the other target program threads encounters one of the set breakpoints during execution of the target program and causes a break to occur, halting execution of the one of the other target program thread until an indication is received from the first program to resume execution; and

when the executing first program thread encounters one of the set breakpoints and causes a break to occur, continuing execution of the first program thread without receiving an external indication to continue the execution.

31. The method of claim 30 including, when one of the executing other target program threads encounters one of the set breakpoints during execution of the target program and causes a break to occur, notifying a debugger of the encounter.

32. The method of claim 31 wherein the indication that is received by the other target program thread from the first program to resume execution is forwarded from the debugger to that other target program thread by the first program.

33. The method of claim 31 wherein the notifying of the debugger includes notifying the first program so that the first program can notify the debugger.

34. The method of claim 30 wherein, when the executing first program thread encounters one of the set breakpoints and causes a break to occur, the continuing of the execution of the thread is performed without notifying a debugger of the encounter.

35. The method of claim 30 wherein the target program includes multiple executable instructions that are stored in memory, wherein the setting of a breakpoint includes replacing an executable instruction stored in memory with a breakpoint instruction, and wherein the encounter of the set breakpoint includes attempting to execute one of the target program instructions that was replaced by a breakpoint instruction.

36. The method of claim 35 wherein the resuming of the execution includes executing that one replaced target program instruction without returning that one replaced target program instruction to its original memory location.

37. The method of claim 35 wherein the continuing of the execution includes executing that one replaced target program instruction without returning that one replaced target program instruction to its original memory location.

38. The method of claim 30 including:

when one of the executing other target program threads performs an operation that triggers an exception, immediately transferring control of execution for that thread to an exception handler for that thread so that the exception handler can process the exception; and

when the executing first program thread performs an operation that triggers an exception, deferring transferring control of execution for the first program thread to an exception handler for the thread until the first program has completed a specified assignment.

39. The method of claim 38 wherein the deferring of the transferring of the control includes masking exceptions that occur during performance of the specified assignment.

40. The method of claim 38 wherein the deferring of the transferring of the control is permanent such that the specified assignment continues until execution of the first program is completed.

41. The method of claim 38 including, when the executing first program thread performs an operation that triggers an exception, notifying an executing debugger of the exception.

42. The method of claim 30 including:

when one of the executing other target program threads performs an operation that triggers a fatal trap, immediately transferring control of execution for that thread to a trap handler for that thread to halt execution of the thread; and

when the executing first program thread performs an operation that triggers a fatal trap, blocking transferring control of execution for the first program thread to a trap handler that will halt execution of the thread.

43. The method of claim 42 including, before the performance of the operation by the executing first program thread that triggers the fatal trap, rebinding the trap handler for the first program thread to a different trap handler that will not halt execution of the thread, and wherein the blocking of the transferring of the control includes transferring the control of execution for the first program thread to the different trap handler.

44. The method of claim 42 wherein the blocking of the transferring of the control includes notifying an executing debugger of the fatal trap.

45. The method of claim 30 wherein the set breakpoint encountered by one of the executing other target program threads during the execution of the target program is a conditional breakpoint that includes a condition, and wherein the halting of the execution of the thread includes requesting the first program to evaluate the condition.

46. The method of claim 45 wherein the received indication from the first program to resume execution is an indication that the condition is evaluated to be false, so that conditional breakpoints with false conditions are treated as if a break did not occur.

47. The method of claim 30 wherein the set breakpoint encountered by one of the executing other target program threads during the execution of the target program is a conditional breakpoint that includes a condition, and including, before the halting:

under control of that executing other target program thread,

evaluating the condition to determine if the condition is satisfied; and

when it is determined that the condition is not satisfied, resuming the execution of that executing other target program thread without halting the execution, such that the halting of the execution of that executing other target program thread occurs only when the condition is determined to be satisfied.

48. The method of claim 30 wherein a debugger in communication with the first program is executing on a remote computer.

49. The method of claim 30 wherein the target program executes on a processor that has multiple hardware streams each able to execute at least one of the target program threads.

50. The method of claim 49 wherein the processor has multiple protection domains that are each able to execute a program, and wherein the target program executes in at least one of the protection domains.