Performing call stack sampling by setting affinity of target thread to a current process to prevent target thread migration

• US 8,843,684 B2
• Filed: 06/11/2010
• Issued: 09/23/2014
• Est. Priority Date: 06/11/2010
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Jones, Scott T., Kuiper, Kean G., Levine, Frank E., Pineda, Enio M.
• Primary Examiner(s): PHAN, RAYMOND NGAN
• Application Number:
  US12/813,706
• Publication Number:
  US 20110307640A1
• Time in Patent Office: 1,565 Days
• Field of Search: 710260-269
• US Class Current: 710/267
• CPC Class Codes: G06F 13/24 using interrupt G06F13/32 takes precedence
• CPC Class Codes: G06F 9/4812 by interrupt, e.g. masked

Abstract

A sample is generated based on an event. Further, an interrupt handler captures information for an interrupted thread on a current processor. In addition, an affinity of the interrupted thread is set such that the interrupted thread runs only on the current processor without being able to migrate to a different processor. A sampler thread that runs on the current processor retrieves a call stack associated with the interrupted thread after the affinity of the interrupted thread has been set to the current processor. The affinity of the interrupted thread is restored after the call stack has been retrieved.

Claims

1. A computer program product comprising a computer useable medium having a computer readable program, wherein the computer readable program when executed on a computer causes the computer to:

generate an interrupt based on an event;

capture information, with an interrupt handler, for an interrupted thread on a current processor from among a plurality of processors;

set an affinity of the interrupted thread such that the interrupted thread runs only on the current processor without being able to migrate to a different processor from among the plurality of processors;

retrieve, with a profiler thread that runs on the current processor, a call stack associated with the interrupted thread after the affinity of the interrupted thread has been set to the current processor; and

restore the affinity of the interrupted thread after the call stack has been retrieved.

2. The computer program product of claim 1, wherein a signal handler is utilized to set the affinity of the interrupted thread.

3. The computer program product of claim 1, wherein the computer is further caused to suspend the interrupted thread after the interrupted thread is identified.

4. The computer program product of claim 1, wherein the computer is further caused to resume the interrupted thread after the affinity is set.

5. The computer program product of claim 1, wherein the computer is further caused to detect thread drift and correct the thread drift upon the detection by comparing a current instruction pointer to an instruction pointer captured at a time of the interrupt.

6. The computer program product of claim 1, wherein the computer is further caused to register, with a profiler, the event to identify a load address and a length for generated code.

7. The computer program product of claim 2, wherein the profiler thread retrieves the call stack based upon receiving a signal from the signal handler.

8. The computer program product of claim 2, wherein the interrupted thread is bound to the current processor, irrespective of an operating system attempting to schedule the signal handler to execute on the different processor, by searching a processor table for the current processor to bind the interrupted thread.

9. A method comprising:

generating a sample based on an event;

capture information, with an interrupt handler, for an interrupted thread on a current processor from among a plurality of processors;

setting an affinity of the interrupted thread such that the interrupted thread runs only on the current processor without being able to migrate to a different processor from among the plurality of processors;

retrieving, with a profiler thread that runs on the current processor, a call stack associated with the interrupted thread after the affinity of the interrupted thread has been set to the current processor; and

restoring the affinity of the interrupted thread after the call stack has been retrieved.

10. The method of claim 9, wherein a signal handler is utilized to set the affinity of the interrupted thread.

11. The method of claim 9, further comprising suspending the interrupted thread after the interrupted thread is identified.

12. The method of claim 9, further comprising resuming the interrupted thread after the affinity is set.

13. The method of claim 9, further comprising detecting thread drift and correcting the thread drift upon the detection by comparing a current instruction pointer to an instruction pointer captured at a time of the interrupt.

14. The method of claim 9, further comprising registering, with a profiler, the event to identify a load address and a length for generated code.

15. The method of claim 10, wherein the profiler thread retrieves the call stack based upon receiving a signal from the signal handler.

16. The method of claim 10, wherein the interrupted thread is bound to the current processor, irrespective of an operating system attempting to schedule the signal handler to execute on the different processor, by searching a processor table for the current processor to bind the interrupted thread.

17. A system comprising:

a current processor from among a plurality of processors that generates an interrupt based on an event;

an operating system that (i) captures information, with an interrupt handler, for an interrupted thread on the current processor and (ii) sets an affinity of the interrupted thread such that the interrupted thread runs only on the current processor without being able to migrate to a different processor from among the plurality of processors;

a profiler that (i) retrieves, with a profiler thread that runs on the current processor, a call stack associated with the interrupted thread after the affinity of the interrupted thread has been set to the current processor.

18. The system of claim 17, further comprising a signal handler that is utilized to set the affinity of the interrupted thread.

19. The system of claim 17, wherein the interrupted thread is suspended after the interrupted thread is identified.

20. The system of claim 17, wherein the interrupted thread is resumed the after the affinity is set.

21. The system of claim 17, wherein thread drift is detected and the thread drift is corrected upon the detection by comparing a current instruction pointer to an instruction pointer captured at a time of the interrupt.

22. The system of claim 17, wherein the profiler further registers the event to identify a load address and a length for generated code.

23. The system of claim 18, wherein the profiler thread retrieves the call stack based upon receiving a signal from the signal handler.

24. The system of claim 18, wherein the interrupted thread is bound to the current processor, irrespective of an operating system attempting to schedule the signal handler to execute on the different processor, by searching a processor table for the current processor to bind the interrupted thread.

25. A computer program product comprising a computer useable medium having a computer readable program, wherein the computer readable program when executed on a computer causes the computer to:

generate, with a current processor from among a plurality of processors, an interrupt based on an event;

capture information, with an interrupt handler, for an interrupted thread on the current processor;

set an affinity of the interrupted thread such that the interrupted thread runs only on the current processor without being able to migrate to a different processor from among the plurality of processors;

retrieve, with a profiler thread that runs on the current processor, a call stack associated with the interrupted thread after the affinity of the interrupted thread has been set to the current processor; and

restore the affinity of the interrupted thread after the call stack has been retrieved;

compare a current instruction pointer to an instruction pointer captured at a time of the interrupt to detect thread drift; and

correct the thread drift upon the detection.