Run-time wait tracing using byte code insertion

• US 7,275,239 B2
• Filed: 02/10/2003
• Issued: 09/25/2007
• Est. Priority Date: 02/10/2003
• Status: Expired due to Fees

• Current Assignee: Google LLC (Alphabet Inc.)
• Original Assignee: International Business Machines Corporation
• Inventors: Daughtrey, Erik A., Fraenkel, Michael L., Cuomo, Gennaro A.
• Primary Examiner(s): Dam; Tuan
• Assistant Examiner(s): DAO, THUY CHAN
• Application Number:
  US10/361,325
• Publication Number:
  US 20040158819A1
• Time in Patent Office: 1,688 Days
• Field of Search: 717/114, 717/127, 717/130, 717/128, 717/124, 717/131, 717/158, 705/71
• US Class Current: 717/130
• CPC Class Codes: G06F 11/3624 by performing operations on the source code, e.g. via a compiler

Abstract

Methods, systems, computer program products, and methods of doing business whereby programmatically-generated byte code insertion is used to perform run-time tracing of code that potentially encounters a wait during execution. The byte code insertion is performed at load time, and inserts byte codes before and after a located (potential) wait point. The inserted byte code functions to gather execution statistics, such as a time stamp before invoking a located wait point and a time stamp after invoking the located wait point. Preferred embodiments allow this tracing to be selectively activated/deactivated.

Claims

1. A method of tracing run-time waits to measure time spent waiting due to synchronization, comprising steps of:

programmatically performing code analysis prior to execution of an application, further comprising steps of;

comparing byte code of the application to stored patterns that describe known wait points where code may wait to get a monitor that synchronizes access to a shared resource, thereby locating one or more locations in the code where a wait due to synchronization may occur at run time; and

recording the located locations; and

programmatically instrumenting the located locations, during execution of the application at run time, further comprising steps of;

intercepting load requests for executable elements of the application, as each executable element is to be loaded for execution; and

invoking an augmented class loader to carry out each of the intercepted load requests, wherein the augmented class loader creates an instrumented version of the executable element that is to be loaded by consulting the recorded locations to determine ones thereof which are found in the executable element and programmatically inserting pre-invocation byte code before each of the determined ones and post-invocation byte code after each of the determined ones, wherein the pre-invocation byte code and the post-invocation byte code are executable to generate data for measuring the time spent waiting at each of the determined ones due to synchronization, and then loads the instrumented version for execution instead of loading the executable element.

2. The method according to claim 1, wherein the comparing step consults a specification of operation code patterns to be included when locating the location where a wait may occur.

3. The method according to claim 1, wherein the comparing step consults a specification of operation code patterns to be excluded when locating the locations where a wait may occur.

4. The method according to claim 1, further comprising the step of modifying the recorded locations to exclude one or more thereof prior to the execution of the application.

5. The method according to claim 1, wherein the augmented class loader programmatically inserts the pre-invocation byte code before, and the post-invocation byte code after, only the determined ones for which a variable setting indicates that run-time tracing is to be performed.

6. The method according to claim 1, further comprising the step of selectively deactivating operation of the programmatically inserted pre-invocation byte code and the programmatically inserted post-invocation byte code for one or more of the determined ones at run time.

7. The method according to claim 1, further comprising steps of:

executing the pre-invocation byte code and the post-invocation byte code to generate the data for measuring the time spent waiting at at least one of the determined ones due to synchronization;

computing, from the generated data for each of the at least one of the determined ones, the time spent waiting at that determined one; and

recording, for each of the at least one of the determined ones, the computed time spent waiting.

8. The method according to claim 1, wherein the stored patterns that describe known wait points further comprise where code may wait for a notification from other code to thereby enforce an order of execution.

9. A system for tracing run-time waits to measure time spent waiting due to synchronization in a computing environment, comprising:

means for programmatically performing code analysis prior to execution of an application, further comprising;

means for comparing byte code of the application to stored patterns that describe known wait points where code may wait to get a monitor that synchronizes access to a shared resource, thereby locating one or more locations in the code where a wait due to synchronization may occur at run time; and

means for recording the located locations; and

means for programmatically instrumenting the located locations, during execution of the application at run time, further comprising;

means for intercepting load requests for executable elements of the application, as each executable element is to be loaded for execution; and

means for invoking an augmented class loader to carry out each of the intercepted load requests, wherein the augmented class loader creates an instrumented version of the executable element that is to be loaded by consulting the recorded locations to determine ones thereof which are found in the executable element and programmatically inserting pre-invocation byte code before each of the determined ones and post-invocation byte code after each of the determined ones, wherein the pre-invocation byte code and the post-invocation byte code are executable to generate data for measuring the time spent waiting at each of the determined ones due to synchronization, and then loads the instrumented version for execution instead of loading the executable element.

10. The system according to claim 9, wherein the means for comparing consults a specification of operation code patterns to be included when locating the location where a wait may occur.

11. The system according to claim 9, wherein the means for comparing consults a specification of operation code patterns to be excluded when locating the locations where a wait may occur.

12. The system according to claim 9, further comprising means for modifying the recorded locations to exclude one or more thereof prior to the execution of the application.

13. The system according to claim 9, wherein the augmented class loader programmatically inserts the pre-invocation byte code before, and the post-invocation byte code after, only the determined ones for which a variable setting indicates that run-time tracing is to be performed.

14. The system according to claim 9, further comprising means for selectively deactivating operation of the programmatically inserted pre-invocation byte code and the programmatically inserted post-invocation byte code for one or more of the determined ones at run time.

15. The system according to claim 9, further comprising:

means for executing the pre-invocation byte code and the post-invocation byte code to generate the data for measuring the time spent waiting at at least one of the determined ones due to synchronization;

means for computing, from the generated data for each of the at least one of the determined ones, the time spent waiting at that determined one; and

means for recording, for each of the at least one of the determined ones, the computed time spent waiting.

16. The system according to claim 9, wherein the stored patterns that describe known wait points further comprise where code may wait for a notification from other code to thereby enforce an order of execution.

17. A computer program product for tracing run-time waits to measure time spent waiting due to synchronization, the computer program product embodied on one or more computer-readable media and comprising:

computer-readable program code for programmatically performing code analysis prior to execution of an application, further comprising;

computer-readable program code for comparing byte code of the application to stored patterns that describe known wait points where code may wait to get a monitor that synchronizes access to a shared resource, thereby locating one or more locations in the code where a wait due to synchronization may occur at run time; and

computer-readable program code means for recording the located locations; and

computer-readable program code for programmatically instrumenting the located locations, during execution of the application at run time, further comprising;

computer-readable program code for intercepting load requests for executable elements of the application, as each executable element is to be loaded for execution; and

computer-readable program code for invoking an augmented class loader to carry out each of the intercepted load requests, wherein the augmented class loader creates an instrumented version of the executable element that is to be loaded by consulting the recorded locations to determine ones thereof which are found in the executable element and programmatically inserting pre-invocation byte code before each of the determined ones and post-invocation byte code after each of the determined ones, wherein the pre-invocation byte code and the post-invocation byte code are executable to generate data for measuring the time spent waiting at each of the determined ones due to synchronization, and then loads the instrumented version for execution instead of loading the executable element.

18. The computer program product according to claim 17, wherein the computer-readable program code for comparing consults a specification of operation code patterns to be included when locating the location where a wait may occur.

19. The computer program product according to claim 17, wherein the computer-readable program code for comparing consults a specification of operation code patterns to be excluded when locating the locations where a wait may occur.

20. The computer program product according to claim 17, further comprising computer-readable program code for modifying the recorded locations to exclude one or more thereof prior to the execution of the application.

21. The computer program product according to claim 17, wherein the augmented class loader programmatically inserts the pre-invocation byte code before, and the post-invocation byte code after, only the determined ones for which a variable setting indicates that run-time tracing is to be performed.

22. The computer program product according to claim 17, further comprising computer-readable program code for selectively deactivating operation of the programmatically inserted pre-invocation byte code and the programmatically inserted post-invocation byte code for one or more of the determined ones at run time.

23. The computer program product according to claim 17, further comprising:

computer-readable program code for executing the pre-invocation byte code and the post-invocation byte code to generate the data for measuring the time spent waiting at at least one of the determined ones due to synchronization;

computer-readable program code for computing, from the generated data for each of the at least one of the determined ones, the time spent waiting at that determined one; and

computer-readable program code for recording, for each of the at least one of the determined ones, the computed time spent waiting.

24. The computer program product according to claim 17, wherein the stored patterns that describe known wait points further comprise where code may wait for a notification from other code to thereby enforce an order of execution.

25. A method of doing business by tracing wait points in an executing application to measure time spent waiting due to synchronization, comprising steps of:

performing programmatic code analysis prior to execution of an application, further comprising steps of;

programmatically comparing byte code of the application to stored patterns that describe known wait points where code may wait to get a monitor that synchronizes access to a shared resource, thereby locating one or more locations in the code where a wait due to synchronization may occur at run time; and

programmatically recording the located locations;

programmatically instrumenting the located locations, during execution of the application at run time, further comprising steps of;

intercepting load requests for executable elements of the application, as each executable element is to be loaded for execution; and

invoking an augmented class loader to carry out each of the intercepted load requests, wherein the augmented class loader creates an instrumented version of the executable element that is to be loaded by consulting the recorded locations to determine ones thereof which are found in the executable element and programmatically inserting pre-invocation byte code before each of the determined ones and post-invocation byte code after each of the determined ones, wherein the pre-invocation byte code and the post-invocation byte code are executable to generate data for measuring the time spent waiting at each of the determined ones due to synchronization, and then loads the instrumented version for execution instead of loading the executable element;

executing the pre-invocation byte code and the post-invocation byte code to generate the data for measuring the time spent waiting at at least one of the determined ones due to synchronization;

computing, from the generated data for each of the at least one of the determined ones, the time spent waiting at that determined one;

programmatically recording, for each of the at least one of the determined ones, the computed time spent waiting; and

charging a fee for carrying out the steps of performing programmatic code analysis, programmatically instrumenting, executing, computing, and programmatically recording.