METHOD AND SYSTEM OF ASSOCIATING A RUNTIME EVENT WITH A COMPONENT

• US 20090112783A1
• Filed: 09/17/2008
• Published: 04/30/2009
• Est. Priority Date: 09/19/2007
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Hargrave, Bentley John, Teng, Qi Ming, Wood III, David Alvra, Tracey, William J., Qiu, Jie, Li, Ying, Liu, Tian Cheng, Li, Xin Hui
• Granted Patent: US 9,329,969 B2
• Time in Patent Office: Days
• US Class Current: 706/46
• CPC Class Codes: G06F 11/30 Monitoring
• CPC Class Codes: G06F 11/3419 by assessing time
• CPC Class Codes: G06F 11/3447 Performance evaluation by modeling
• CPC Class Codes: G06F 11/3476 Data logging G06F11/14, G06F11/2205 take precedence
• CPC Class Codes: G06F 21/55 Detecting local intrusion or implementing counter-measures
• CPC Class Codes: G06F 2201/86 Event-based monitoring
• CPC Class Codes: G06F 2209/543 Local
• CPC Class Codes: G06F 8/20 Software design
• CPC Class Codes: G06F 9/06 using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
• CPC Class Codes: G06F 9/445 Program loading or initiating bootstrapping G06F9/4401; security arrangements for program loading or initiating G06F21/57
• CPC Class Codes: G06F 9/542 Event management; Broadcasting; Multicasting; Notifications

Abstract

A method and a system of associating a runtime event with a component. The method includes catching the runtime event; catching the context of the current running environment and determining the current component based on said context; and getting the associating policy of current component and determining the responsible component associated with said runtime event based on said associating policy.

Claims

1. A method for associating a runtime event with a component, comprising:

catching a runtime event;

identifying a context of a current running environment and determining a current component based on said context; and

obtaining an associating policy of the current component and determining a responsible component associated with said runtime event based on said associating policy.

2. The method according to claim 1, wherein steps of identifying a context of a current running environment and determining a current component based on said context include at least one of examining a snapshot of an execution stack and examining the execution log, and wherein said determining the current component is based on said snapshot or said log.

3. The method according to claim 1, further comprising:

attaching a policy label to the component;

loading the policy label and the component together to the execution stack or recording the policy label and the component into the execution log; and

wherein the step of obtaining an associating policy of the current component further comprising retrieving said attached policy label from said context.

4. The method according to claim 1, further comprising:

storing at least a set of policy labels of the component in a policy storage device; and

the step of obtaining an associating policy of the current component further comprising reading said policy label from the policy storage device.

5. The method according to claim 1, wherein the step of obtaining an associating policy of the current component further comprises calling a dedicated API to obtain said policy.

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

storing a track of said running environment; and

analyzing recursively the context of the current running environment to determine the responsible component associated with said runtime event.

7. The method according to claim 3 wherein said policy label is one or more of the following:

Parent, Self, Caller, Classloader, Common, Allocater, Boundary, Leakbot and HeapAnalyzer; and

wherein

when the policy label is Self, the current component is determined as the responsible component;

when the policy label is Parent, a parent component creating a thread is determined as the responsible component;

when the policy label is Caller, a component calling the current component is determined as the responsible component;

when the policy label is Classloader, a system component loading the current component is determined as the responsible component;

when the policy label is Common, a component providing common services is determined as the responsible component;

when the policy label is Allocater, an allocater associated with resources is determined as the responsible component; and

when the policy label is Boundary, a top component on the execution stack is determined as the responsible component.

8. The method according to claim 1, further comprising:

upon the context of the current running environment being identified, determining whether at least one of the current component or the associating policy has changed, and if so, determining the responsible component associated with said runtime event.

9. The method according to claim 1, further comprising:

updating statistics on the responsible component.

10. The method according to claim 1, wherein the runtime event is caught initiatively by sampling or passively by being triggered by the event.

11. A system of associating a runtime event with a component, comprising:

an event monitor for catching a runtime event;

a context monitor for identifying a context of a current running environment and determining a current component based on said context; and

an inference engine for obtaining an associating policy of the current component and determining a responsible component associated with said runtime event according to said associating policy.

12. The system according to claim 11, wherein said context monitor further comprises at least one of a stack walker or an execution log updater, the stack walker being for catching a snapshot of the execution stack, and the execution log updater being for updating log information based on a current program execution situation, and wherein said context monitor determines the current component based on said snapshot or said log.

13. The system according to claim 11, further comprising:

an annotator for attaching a policy label to a component; and

a loader for loading the policy label and the component together to an execution stack,

wherein said context monitor further obtains said attached policy label from the context of said running environment.

14. The system according to claim 11, further comprising a policy storage device for storing a policy label for a component, wherein said inference engine further reads said policy label from the policy storage device.

15. The system according to claim 11, wherein said inference engine calls a dedicated API to obtain said policy.

16. The system according to claim 11, wherein

said context monitor further stores a track of said running environment;

and

said inference engine recursively analyzes the context of the current running environment, and determines the responsible component associated with said runtime event.

17. The system according to claim 13, said policy label being one or more labels of the following:

Parent, Self, Caller, Classloader, Common, Allocater, Boundary, Leakbot and HeapAnalyzer; and

wherein;

when the policy label is Self, the inference engine determines the current component as the responsible component;

when the policy label is Parent, the inference engine determines a parent component creating the thread as the responsible component;

when the policy label is Caller, a component calling the current component is determined as the responsible component;

when the policy label is Classloader, the inference engine determines a system component loading the current component as the responsible component;

when the policy label is Common, the inference engine determines a component providing common services as the responsible component;

when the policy label is Allocater, the inference engine determines an allocater associated with resources as the responsible component;

when the policy label is Boundary, the inference engine determines a top component on the execution stack as the responsible component.

18. The system according to claim 11, wherein the inference engine further determines whether the current component or the associating policy has changed, and if so, the inference engine further determines the responsible component associated with said runtime event.

19. The system according to claim 11 wherein said inference engine further updates statistics on the responsible component in a statistics accounting pool.

20. The system according to claim 11, further comprising at least one component for catching a runtime event by sampling or by being triggered by the event.