ENHANCED THREAD STEPPING

• US 20100242026A1
• Filed: 03/18/2009
• Published: 09/23/2010
• Est. Priority Date: 03/18/2009
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: BATES, CARY L., SANTOSUOSSO, JOHN M.
• Granted Patent: US 8,327,336 B2
• Time in Patent Office: Days
• US Class Current: 717/128
• CPC Class Codes: G06F 11/362 Software debugging

Abstract

Embodiments of the invention provide debugging techniques for multithreaded programs. For example, a debugger may reduce the time required to release inactive threads that hold resources needed by an active thread. For example, if a timer expires before a line of code finishes executing, the debugger assumes that the active thread requires a resource locked by an inactive thread and releases other threads. During subsequent execution of the line of code, the debugger reduces the timer length of the timer. In doing so, inactive threads are released sooner, thereby reducing the wait time a user experiences when debugging lines of code.

Claims

1. A computer implemented method for debugging a multithreaded program, comprising:

receiving a first request to execute a current line of code for a first thread of the multithread program actively being debugged, wherein executing the current line of code requires access, by the first thread, to a shared resource shared by a plurality of threads of the multithreaded program;

initiating a debug timer with a first predetermined time limit; and

upon determining that the debug timer expires before the current line of code in the first thread is executed by the debugger;

recording an indication that the debug timer expired for the first thread while waiting for access to the shared resource, and

reducing the amount of time reflected by the first predetermined time limit.

2. The method of claim 1, further comprising, releasing at least a second thread, of the plurality, for execution wherein the second thread has exclusive access to the shared resource.

3. The method of claim 2, further comprising:

executing the second thread at least until the shared resource is freed by the second thread;

accessing, by the first thread being actively debugged, the shared resource; and

subsequently, executing the line of code for the first thread.

4. The method of claim 1, further comprising:

receiving a second request to execute the current line of code by one of the plurality of threads of the multithreaded program; and

initiating a second debug timer for the reduced amount of time;

upon determining that the second debug timer expires before the current line of code in the first thread is executed by the debugger, releasing at least a second thread, of the plurality, for execution wherein the second thread has exclusive access to the shared resource.

5. The method of claim 1, further comprising:

upon determining that the debug timer expires before the current line of code in the first thread is executed by the debugger, initiating the debug timer with the first predetermined time limit during subsequent execution of the line of source code.

6. The method of claim 1, wherein the shared resource is a mutex lock engaged by one of the plurality of threads.

7. The method of claim 1, wherein the plurality of threads are suspended from being scheduled for execution as a result of the first thread actively being debugged.

8. A computer implemented method for debugging a multithreaded program, comprising:

receiving a first request to execute a current line of code for a first thread of the multithread program actively being debugged, wherein executing the current line of code requires access, by the first thread, to a shared resource shared by a plurality of threads of the multithreaded program;

prior to the executing the current line of code, receiving a message that a second thread has exclusive access to the shared resource, wherein the second thread is suspended from being scheduled for execution as a result of the first thread actively being debugged;

releasing at least the second thread for execution;

executing the second thread at least until the shared resource is freed by the second thread;

accessing, by the first thread being actively debugged, the shared resource; and

subsequently, executing the line of code for the first thread.

9. A computer readable storage medium containing a program, which, when executed performs an operation for debugging a multithreaded program, the operation comprising:

receiving a first request to execute a current line of code for a first thread of the multithread program actively being debugged, wherein executing the current line of code requires access, by the first thread, to a shared resource shared by a plurality of threads of the multithreaded program;

initiating a debug timer with a first predetermined time limit; and

upon determining that the debug timer expires before the current line of code in the first thread is executed by the debugger;

recording an indication that the debug timer expired for the first thread while waiting for access to the shared resource, and

reducing the amount of time reflected by the first predetermined time limit.

10. The computer readable storage medium of claim 9, wherein the operation further comprises, releasing at least a second thread, of the plurality, for execution wherein the second thread has exclusive access to the shared resource.

11. The computer readable storage medium of claim 10, wherein the operation further comprises:

executing the second thread at least until the shared resource is freed by the second thread;

accessing, by the first thread being actively debugged, the shared resource; and

subsequently, executing the line of code for the first thread.

12. The computer readable storage medium of claim 9, wherein the operation further comprises:

receiving a second request to execute the current line of code by one of the plurality of threads of the multithreaded program; and

initiating a second debug timer for the reduced amount of time;

upon determining that the second debug timer expires before the current line of code in the first thread is executed by the debugger, releasing at least a second thread, of the plurality, for execution wherein the second thread has exclusive access to the shared resource.

13. The computer readable storage medium of claim 9, wherein the operation further comprises:

upon determining that the debug timer expires before the current line of code in the first thread is executed by the debugger, initiating the debug timer with the first predetermined time limit during subsequent execution of the line of source code.

14. The computer readable storage medium of claim 9, wherein the shared resource is a mutex lock engaged by one of the plurality of threads.

15. The computer readable storage medium of claim 9, wherein the plurality of threads are suspended from scheduling for executing as a result of the first thread actively being debugged.

16. A system, comprising:

a processor; and

a memory containing a debugging program, which when executed by the processor performs an operation for debugging a multithreaded program, the operation comprising;

receiving a first request to execute a current line of code for a first thread of the multithread program actively being debugged, wherein executing the current line of code requires access, by the first thread, to a shared resource shared by a plurality of threads of the multithreaded program,

initiating a debug timer with a first predetermined time limit, and

upon determining that the debug timer expires before the current line of code in the first thread is executed by the debugger;

recording an indication that the debug timer expired for the first thread while waiting for access to the shared resource;

reducing the amount of time reflected by the first predetermined time limit; and

releasing at least a second thread, of the plurality, for execution wherein the second thread has exclusive access to the shared resource.

17. The system of claim 16, wherein the operation further comprises:

executing the second thread at least until the shared resource is freed by the second thread;

accessing, by the first thread being actively debugged, the shared resource; and

subsequently, executing the line of code for the first thread.

18. The system of claim 17, wherein the operation further comprises:

receiving a second request to execute the current line of code by one of the plurality of threads of the multithreaded program; and

initiating a second debug timer for the reduced amount of time;

upon determining that the second debug timer expires before the current line of code in the first thread is executed by the debugger, releasing at least a second thread, of the plurality, for execution wherein the second thread has exclusive access to the shared resource.

19. The system of claim 16, wherein the operation further comprises:

upon determining that the debug timer expires before the current line of code in the first thread is executed by the debugger, initiating the debug timer with the first predetermined time limit during subsequent execution of the line of source code.

20. The system of claim 16, wherein the plurality of threads are suspended from scheduling for executing as a result of the first thread actively being debugged.