Debugging techniques in a multithreaded environment

A computer-readable medium containing instructions for causing a computer system to debug a task executing on a computing device that has a processor with multiple streams for executing threads of the task, by:

• executing a debugger nub using a thread of the task that has a breakpoint handler distinct from breakpoint handlers of the other task threads;
• when the debugger nub receives a request from a debugger to set a breakpoint at a specified location in the task, replacing an executable instruction identified at the specified location with an inserted instruction that when executed will create a break;
• when a thread other than the debugger nub thread encounters the inserted instruction, executing the identified instruction by,
• transferring control of execution for the thread to the breakpoint handler for the thread;
• notifying the debugger of the encounter with the inserted instruction;
• and
• after receiving an indication from the debugger to resume execution, emulating the execution of the identified instruction at the specified location;
• when the debugger nub thread encounters the inserted instruction, executing the identified instruction by,
• transferring control of execution for the nub thread to the breakpoint handler for the nub thread;
• and
• without notifying the debugger of the encounter and without receiving an indication from the debugger to resume execution, emulating the execution of the identified instruction at the specified location;
• and
• when the debugger nub thread receives a request from another thread to perform an action for the another thread, masking exceptions that occur during performing of the action so that execution of the debugger nub is not halted.

A computer system including components to debug a task executing on multiple processor streams each executing a thread of the task, comprising:

• an executing debugger nub that uses a task thread with a breakpoint handler distinct from breakpoint handlers of the other task threads, and that is capable of,
• when a request is received from a debugger to set a breakpoint in the task, identifying an executable instruction corresponding to the breakpoint and setting the breakpoint such that attempted execution of the identified instruction will generate a break;
• when a request is received from another thread to perform an action, masking exceptions that occur during performance of the action so that execution of the debugger nub is not halted;
• and
• when attempting execution of the identified instruction, generating the break such that the breakpoint handler of the debugger nub thread executes the identified instruction without halting execution of the debugger nub;
• and
• multiple executing tasks threads other than the debugger nub thread that are each capable of, when attempting execution of the identified instruction, generating the break such that the breakpoint handler for the task thread halts execution of the task thread and, after receiving an indication from the debugger, continues the execution of the task thread in order to execute the identified instruction.

A computer-implemented method for debugging an executing target program using a debugger nub, the target program having multiple software threads each able to execute without halting execution of the other threads, the method comprising:

• executing a debugger nub using a thread of the target program;
• executing the target program using the other target program threads;
• and
• under control of the executing debugger nub, repeatedly responding to an executing debugger by,
• receiving a request from the executing debugger to provide indicated information about a current state of the executing target program;
• in response and without support from an operating system, obtaining the requested information from the executing target program;
• and
• sending the obtained information to the debugger.

A computer-readable medium whose contents cause a computing device to debug a target program having multiple software threads each able to execute without halting execution of the other threads, by:

• executing a debugger nub using a thread of the target program;
• and
• under control of the executing debugger nub,
• receiving a request from an executing debugger to provide indicated information about a current state of the executing target program or to provide an indicated functionality related to the executing target program;
• when the request is to provide the indicated information, responding to the request by obtaining the indicated information from the executing target program and sending the obtained information to the debugger;
• and
• when the request is to provide the indicated functionality, responding to the request by providing the indicated functionality.

A computer-implemented method for debugging an executing target program using a debugger nub, the 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 debugger nub using a thread of the target program;
• executing the target program using the other target program threads;
• 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, halting execution of the thread until an indication is received from the debugger nub to resume execution;
• and
• when the executing debugger nub thread encounters one of the set breakpoints and causes a break to occur, continuing execution of the thread without receiving an external indication to continue the execution.

A computer-readable medium whose contents cause a computing device to debug a target program having multiple software threads each able to execute without halting execution of the other threads, the executing target program having at least one breakpoint set in such a manner that encountering the breakpoint causes a break to occur, by:

• executing a debugger nub using a thread of the target program;
• executing the target program using the other target program threads;
• and
• when one of the executing other target program threads encounters one of the set breakpoints and causes a break to occur, suspending execution of the thread until an indication is received from the debugger nub to resume execution;
• and
• when the executing debugger nub thread encounters one of the set breakpoints and causes a break to occur, continuing execution of the thread without suspension of the execution.

A computer-implemented method for debugging multiple executing tasks by using debugger nubs, the tasks each having multiple software threads executing on a first computer having multiple processors and each having at least one breakpoint set in such a manner that encountering the breakpoint causes a break to occur, the processors each having multiple protection domains that are each able to execute one of the multiple tasks and each having multiple hardware streams each able to execute at least one of the software threads, the method comprising:

• for each of the multiple tasks,
• executing a debugger nub for the task using a thread of the task, the debugger nub being of a debugger nub type that is selected based on a type of the task;
• executing the task using the other task threads;
• when one of the executing other task threads of the task encounters one of the breakpoints set for the task and causes a break to occur, halting execution of the thread until an indication is received from the debugger nub for the task to resume execution;
• and
• under control of the executing debugger nub for the task,
• responding to requests from an executing debugger to provide indicated information about a current state of the executing task, the executing debugger distinct from the executing debugger nub, the responding by obtaining the requested information from the executing task in a manner specific to the debugger nub type of the debugger nub for the task;
• upon encountering one of the breakpoints set for the task, continuing execution without halting;
• and
• providing indications to the executing other task threads of the task to control execution of those threads.