Tools and techniques for instrumenting interfaces of units of a software program

• US 7,984,429 B2
• Filed: 04/01/2005
• Issued: 07/19/2011
• Est. Priority Date: 10/02/1998
• Status: Expired due to Fees

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Hunt, Galen C.
• Primary Examiner(s): Kendall; Chuck O
• Application Number:
  US11/097,636
• Publication Number:
  US 20050183090A1
• Time in Patent Office: 2,300 Days
• Field of Search: None
• US Class Current: 717/130
• CPC Class Codes: G06F 9/449 Object-oriented method invocation or resolution
• CPC Class Codes: G06F 9/465 Distributed object oriented systems remote method invocation [RMI] G06F9/548
• CPC Class Codes: G06F 9/5066 Algorithms for mapping a plurality of inter-dependent sub-tasks onto a plurality of physical CPUs mappping at compile time, see G06F8/451
• CPC Class Codes: H04L 43/0864 Round trip delays
• CPC Class Codes: H04L 43/0894 Packet rate
• CPC Class Codes: H04L 67/10 in which an application is distributed across nodes in the network software deployment G06F8/60; multiprogramming arrangements G06F9/46

Abstract

A method of instrumenting one or more units of an application program is disclosed. Each unit can have one or more interfaces through which communications pass through the unit. Client units can request creation of a server unit. When they do so, the call is intercepted and sent to a unit creation function, which creates the server unit and returns a reference to an interface of the server unit. When a reference to an interface of the server unit is detected, an interface wrapper is created for the interface, the interface wrapper comprising a reference to instrumentation, the reference to the interface, and a reference to a type description of the interface. The client receives a reference to the interface wrapper in place of a reference to the interface, and thereafter is able to treat the reference to the interface wrapper as if it were a reference to the interface.

Claims

1. A method of instrumenting one or more units of an application program, wherein a unit comprises one or more interfaces through which communications to and from the unit pass, and wherein a client unit requests creation of a server unit, the method comprising, with an instrumentation tool that includes a processor and memory:

intercepting a call from a client unit to a unit creation function to create a server unit;

routing the call to the unit creation function, wherein the unit creation function creates the server unit and returns a reference to an interface of the server unit;

detecting the reference to the interface returned from the unit creation function;

creating an interface wrapper for the interface, the interface wrapper comprising a reference to instrumentation, the reference to the interface, and a reference to a type description of the interface; and

returning to the client unit a reference to the interface wrapper in place of the reference to the interface, wherein the client unit treats the reference to the interface wrapper as the reference to the interface.

2. A computer-readable storage medium having stored therein computer-executable instructions for performing the method of claim 1.

3. The method of claim 1 wherein an interface comprises at least one function, the method further comprising:

receiving from the client unit an invocation of the instrumentation that is based upon the reference that the client unit received, wherein the client unit treats the invocation as a call to a function of the interface, and wherein the client unit passes one or more parameters for the function; and

executing the instrumentation, wherein the instrumentation parses and measures the one or more parameters based upon the type description of the interface, producing a measurement.

4. The method of claim 3 further comprising:

calling the function of the interface using the reference to the interface in the interface wrapper, wherein the function performs an operation and returns one or more return parameters;

executing the instrumentation, wherein the instrumentation parses and measures the one or more return parameters based upon the type description of the interface, producing a second measurement; and

returning execution to the client unit.

5. A computer-readable storage medium having stored therein computer-executable instructions for performing the method of claim 4.

6. The method of claim 4 wherein the reference to instrumentation comprises a pointer to a table of at least one pointer to one or more instrumentation functions, and wherein the invocation of the instrumentation comprises a call to an instrumentation function.

7. The method of claim 4 further comprising:

before the step of executing the instrumentation, comparing the reference to the interface wrapper with the invocation of the instrumentation to calculate an offset;

determining from the offset the identity of the function of the interface to be called;

during the step of executing the instrumentation, parsing and measuring based upon type description for the function to be called; and

during the step of calling the function, applying the offset to the reference to the interface when referencing the function of the interface.

8. The method of claim 4 wherein the interface wrapper further comprises data identifying the server unit, the method further comprising:

associating the measurements with the server unit.

9. The method of claim 4 wherein the interface wrapper further comprises data identifying the server unit, and wherein a local variable stores an identifier for the client unit, the method further comprising:

associating the measurements with the client unit and the server unit.

10. The method of claim 9 wherein the local variable is a stack, and wherein an identifier for the client unit is at the top of the stack, the method further comprising:

before the step of calling the function, pushing an identifier for the server unit on the stack; and

after the step of calling the function, popping the identifier of the server unit off the stack.

11. A computer-readable storage medium having stored therein computer-executable instructions for performing the method of claim 10.

12. The method of claim 1 wherein a dynamic structure tracks the state of the application program, and wherein a local variable stores an identifier for the client unit, the method further comprising:

before the step of routing the call to the unit creation function,

dynamically classifying the server unit based upon the dynamic structure and the local variable, resulting in a unit classifier;

mapping the unit classifier to a location in a distributed computing environment; and

during the step of routing the call to the unit creation function, routing the call to the location.

13. The method of claim 12 wherein the dynamic structure is a call stack comprising one or more client unit invocation frames, and wherein the step of dynamically classifying the server unit comprises:

traversing the call stack;

noting a return address for an invocation frame;

examining the local variable;

noting the identifier for the client unit; and

creating a unit classifier based upon the return address and the identifier.

14. The method of claim 1 further comprising:

receiving from the client unit an invocation of the instrumentation that is based upon the reference that the client unit received, wherein the client unit treats the invocation as a call to a function of the interface;

determining if the interface is documented based upon the interface wrapper;

if the interface is undocumented,

transferring execution to the function of the interface using the reference to the interface in the interface wrapper, wherein the function performs an operation and finishes; and

returning execution to the client unit.

15. The method of claim 1 wherein the interface wrapper further comprises an identifier for the server unit that exposes the interface, and wherein a local variable stores an identifier for the client unit, the method further comprising:

receiving from the client unit an invocation of the instrumentation based upon the reference that the client unit received;

determining if the interface is documented based upon the interface wrapper;

if the interface is undocumented,

noting the relationship of the undocumented interface to the client unit and the server unit based upon the identifiers; and

noting a pair-wise location constraint between the client unit and the server unit.

16. An application program unit instrumentation creator, comprising a processor, memory and storage storing computer-executable instructions for:

means to intercept a call from a client unit to a unit creation function;

means to route the call to the unit creation function;

means for the unit creation function to create a server unit and return a reference to an interface of the server unit;

means to intercept the reference to the interface of the server unit;

means to create an interface wrapper which comprises a reference to instrumentation, and the reference to the interface; and

means to return to the client unit the interface wrapper in place of the interface reference.

17. A method of instrumenting one or more units of an application program, wherein a unit comprises one or more interfaces, through which communications to and from the unit pass, and wherein a client unit requests creation of a server unit, wherein at least one interface comprises one or more functions, wherein a call stack holds one or more parameters of a call to a function from a client unit, wherein the call stack holds a return address for the client unit, and wherein a stack pointer points to the top of the stack, the method comprising, with an instrumentation tool that includes a processor and memory:

receiving from the client unit an invocation of an instrumentation function that is based upon a reference to an interface wrapper that the client unit received, wherein the client unit treats the invocation as a call to a function of the interface, wherein the client unit pushes the one or more parameters for the call to the function on the call stack, and wherein the client unit pushes a return address for the client unit on the call stack;

determining if the interface is documented based upon the interface wrapper;

if the interface is undocumented,

storing the value of the stack pointer;

storing the return address for the client unit;

replacing the return address for the client unit on the call stack with a return address for an instrumentation function;

transferring execution to the function of the interface using the reference to the interface in the interface wrapper, wherein the function performs an operation;

after the function finishes,

popping the return address for the instrumentation function from the call stack;

popping the one or more parameters from the call stack;

transferring execution to the instrumentation function;

calculating the size of the one or more parameters based upon the stored value of the stack pointer and the current value of the stack pointer;

storing the calculated size in the type description of the interface wrapper;

transferring execution to the client unit.

18. The method of claim 17 wherein determining if the interface is documented comprises:

examining the type description referenced in the interface wrapper; and

if the type description contains no type information, indicating that the interface is undocumented.

19. The method of claim 17 wherein determining if the interface is documented comprises:

examining a type description referenced in the interface wrapper; and

if the type description contains opaque type information, indicating that the interface is undocumented.

20. The method of claim 17 wherein the interface wrapper comprises an identifier for the server unit that exposes the interface, and wherein a local variable stores an identifier for the client unit, the method further comprising:

if the interface is undocumented,

noting the relationship of the undocumented interface to the client unit and the server unit based upon the identifiers; and

noting a pair-wise location constraint between the client unit and the server unit.