Detection of method calls to streamline diagnosis of custom code through dynamic instrumentation

• US 8,566,800 B2
• Filed: 05/11/2010
• Issued: 10/22/2013
• Est. Priority Date: 05/11/2010
• Status: Active Grant

• Current Assignee: CA, Inc. (d/b/a CA Technologies) (Broadcom, Inc.)
• Original Assignee: CA, Inc. (d/b/a CA Technologies) (Broadcom, Inc.)
• Inventors: Gagliardi, Marco
• Primary Examiner(s): Nam, Hyun
• Application Number:
  US12/777,496
• Publication Number:
  US 20110283264A1
• Time in Patent Office: 1,260 Days
• Field of Search: None
• US Class Current: 717/130
• CPC Class Codes: G06F 11/3612 by runtime analysis performance monitoring G06F11/3466
• CPC Class Codes: G06F 11/3644 by instrumenting at runtime

Abstract

A technique for analyzing software in which un-instrumented components can be discovered and dynamically instrumented during a runtime of the software. Initially, an application configured with a baseline set of instrumented components such as methods. As the application runs, performance data is gathered from the instrumentation, and it may be learned that the performance of some methods is an issue. To analyze the problem, any methods which are callable from a method at issue are discovered by inspecting the byte code of loaded classes in a JAVA Virtual Machine (JVM). Byte code of the class is parsed to identify opcodes which invoke byte code to call other methods. An index to an entry in a constants pool table is identified based on an opcode. A decision can then be made to instrument and/or report the discovered methods.

Claims

1. A computer-implemented method, comprising:

identifying a method to analyze in an application;

determining a class of the method to analyze from among loaded classes in memory;

loading a byte code representation of the class of the method to analyze from a resource location;

parsing the byte code representation of the class of the method to analyze, the parsing identifies an instance of an invoke byte code in the byte code representation of the class of the method to analyze;

based on the instance of the invoke byte code in the byte code representation of the class of the method to analyze, identifying a child referenced method of, the method to analyze;

storing the child referenced method as a string;

determining a class of the child referenced method;

loading a byte code representation of the class of the child referenced method from a resource location;

parsing the byte code representation of the class of the child referenced method to identify an instance of an invoke byte code in the byte code representation of the class of the child referenced method;

based on the instance of the invoke byte code in the byte code representation of the class of the child referenced method, identifying a grandchild referenced method of the method to analyze; and

storing the grandchild referenced method as a string.

2. The computer-implemented method of claim 1, wherein:

for at least one of the method to analyze or the child referenced method, the invoke byte code comprises one or more of invokevirtual, invokespecial, invokestatic or invokeinterface.

3. The computer-implemented method of claim 1, further comprising:

for at least one of the child referenced method or the grandchild referenced method, instrumenting the referenced method in the application, in response to the identifying of the referenced method.

4. The computer-implemented method of claim 1, wherein:

for at least one of the method to analyze or the child referenced method, the instance of the invoke byte code is identified from an opcode in the byte code representation of the class.

5. The computer-implemented method of claim 4, wherein, for at least one of the method to analyze or the child referenced method:

the opcode is associated with an index to an entry in a constant pool table; and

the referenced method is identified using the index.

6. The computer-implemented method of claim 1, wherein:

it is not known whether the child referenced method has been called by the method to analyze at a time of the identifying of the child referenced method.

7. The computer-implemented method of claim 1, wherein:

for at least one of the method to analyze or the child referenced method, the class is determined using a JAVA Instrument API.

8. The computer-implemented method of claim 1, wherein:

for at least one of the method to analyze or the child referenced method, the loading uses a JAVA class ClassLoader.

9. The computer-implemented method of claim 1, wherein:

the method to analyze is identified by instrumenting methods in the application, wherein the methods in the application comprise the method to analyze, and analyzing performance data obtained from the instrumenting.

10. The computer-implemented method of claim 1, further comprising:

for at least one of the child referenced method or the grandchild referenced method, providing information using a JAVA Reflection API to assist in a determination of whether to add instrumentation to the referenced method.

14. The computer-implemented method of claim 1, further comprising:

for at least one of the child referenced method or the grandchild referenced method, reporting the referenced method from a first application server to a central manager, the central manager pushes an identification of the referenced method to another instance of the application at a second application server for use by the second application server in instrumenting another instance of the referenced method in the another instance of the application.

11. A computer-implemented method, comprising:

identifying an instrumented method to analyze in a first instance of an application at a first application server;

determining a class of the instrumented method from among loaded classes in memory;

loading a byte code representation of the class from a resource location;

parsing the byte code representation of the class to identify an instance of an invoke byte code;

based on the instance of the invoke byte code, identifying an un-instrumented method which is referenced by the instrumented method; and

reporting the un-instrumented method from the first application server to a central manager, the central manager pushes an identification of the un-instrumented method to a second instance of the application at a second application server.

12. The computer-implemented method of claim 11, further comprising:

instrumenting the un-instrumented method in the first and second instances of the application, in response to the identifying of the un-instrumented method.

13. The computer-implemented method of claim 11, wherein:

the un-instrumented method can be called by the instrumented method.

15. A tangible computer-readable memory comprising computer readable software embodied thereon for programming a processor to perform a method, the method comprising:

loading code of an application into memory of a computer system, the loading comprises configuring the code of the application with a baseline set of instrumented components comprising instrumented methods, the code of the application also comprises un-instrumented methods;

while executing the code of the application in the memory, obtaining performance data from the instrumented methods;

based on the performance data, selecting an instrumented method of the instrumented methods to analyze;

based on the selecting, identifying a referenced method of the un-instrumented methods which is referenced by the instrumented method to analyze, the identifying the referenced method comprises;

determining a class of the instrumented method to analyze from among loaded classes in the memory;

loading a byte code representation of the class into the memory from a resource location;

parsing the byte code representation of the class to identify an instance of an invoke byte code; and

identifying the referenced method based on the instance of the invoke byte code; and

providing information to assist in a determination of whether to add instrumentation to the referenced method, the information indicates at least one of whether the referenced method should not be instrumented, whether the referenced method is already instrumented or whether the referenced method refers to an interface.

16. The tangible computer-readable storage memory of claim 15, wherein:

the instance of the invoke byte code is identified from an opcode in the byte code representation of the class;

the opcode is associated with an index to an entry in a constant pool table; and

the referenced method is identified using the index.

17. A system, comprising:

a processor-readable storage device comprising instructions; and

a processor, the processor configured to execute the instructions to;

determine a class of a method of an application from among loaded classes of the application in memory;

load a byte code representation of the class from a resource location;

parse the byte code representation of the class to identify an instance of an invoke byte code;

based on the instance of the invoke byte code, identify a referenced method;

store the referenced method as a string; and

provide information to assist in a determination of whether to add instrumentation to the referenced method, the information indicates at least one of whether the referenced method should not be instrumented, whether the referenced method is already instrumented or whether the referenced method refers to an interface.

18. The system of claim 17, wherein:

the instance of the invoke byte code is identified from an opcode in the byte code representation of the class.

19. The system of claim 18, wherein:

the opcode is associated with an index to an entry in a constant pool table; and

the referenced method is using the index.