INTERACTIVE DEBUGGING ENVIRONMENTS AND METHODS OF PROVIDING THE SAME

• US 20130061210A1
• Filed: 09/01/2011
• Published: 03/07/2013
• Est. Priority Date: 09/01/2011
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Chung, Albert Alexander, Gadepalli, Venkata Vishwanath, Osowski, Richard Elwood Jr.
• Granted Patent: US 8,789,020 B2
• Time in Patent Office: Days
• US Class Current: 717/125
• CPC Class Codes: G06F 11/3664 Environments for testing or debugging software
• CPC Class Codes: G06F 8/30 Creation or generation of source code

Abstract

Described are systems and methods for generating interactive in memory objects from stored program failure data. An anomalous condition related to a program failure is detected. Data is captured regarding the anomalous condition. The captured data is stored. The stored data is converted into at least one in-memory object. A runtime environment is reproduced about a region of code related to the program failure from the at least one in-memory object.

Claims

1. A computer-implemented method for generating interactive in memory objects from stored program failure data, comprising:

detecting an anomalous condition related to a program failure;

capturing data regarding the anomalous condition;

storing the captured data;

converting the stored data into at least one in-memory object; and

reproducing a runtime environment about a region of code related to the program failure from the at least one in-memory object.

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

generating a snapshot of an active class related to the captured data;

auto-serializing objects of the active class into a file in response to the anomalous condition;

deserializing the file; and

reconstructing in-memory values of objects of the active class.

3. The computer-implemented method of claim 2, wherein deserializing the file includes restoring the objects to a state at the time of the anomalous condition.

4. The computer-implemented method of claim 2, wherein the snapshot includes at least one of values of member fields of the active class, values of input parameters of at least one method corresponding to the active class, and local member fields.

5. The computer-implemented method of claim 1, further comprising reproducing the runtime environment in response to receiving a driver class, referenced object classes, and the at least one in-memory object.

6. The computer-implemented method of claim 1, wherein reproducing the runtime environment includes reflecting a localized representation of an original environment of a program related to the program failure, the localized representation being proximal to the region of program code of the program failure.

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

generating a log file in response to detecting the anomalous condition;

automatically extracting contextual object data from the log file proximal to an area of the program failure; and

instantiating the objects in memory from the extracted contextual object data.

8. The computer-implemented method of claim 7, wherein the log file includes at least one of a character-based log, a trace file, an operating system log file, and a dump file.

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

providing the at least one in-memory object to a test tool for debugging.

10. The computer-implemented method of claim 9, wherein the test tool includes a Junit or similar unit-test sandbox.

11. A computer-implemented method of debugging a software program, comprising:

generating a snapshot of an active class in response to an abnormal condition generated from a software component failure;

auto-serializing object data captured from the snapshot;

converting the serialized object data into at least one in-memory object; and

reproducing a runtime environment about a region of program code related to the software component failure from the at least one in-memory object.

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

generating a log in response to the software component failure; and

automatically extracting contextual objects of the object data from the log, the contextual objects extracted from a section of the log proximal to the region of program code of the software component failure.

13. The computer-implemented method of claim 12, wherein the log includes at least one of a character-based log file, a trace file, an operating system log file, and a dump file.

14. The computer-implemented method of claim 11, further comprising reproducing the environment related to the failure in response to receiving a driver class, one or more referenced object classes, and the at least one in-memory object.

15. The computer-implemented method of claim 11, wherein reproducing an environment related to the program failure includes reflecting a localized representation of an original environment of a program related to the program failure, the localized representation being proximal to a region of program code of the software component failure.

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

providing the at least one in-memory object to a test tool for debugging.

17. The computer-implemented method of claim 16, wherein the test tool includes a Junit or similar unit-test sandbox.

18. An in-memory interactive object generator, comprising:

an object extraction module that extracts contextual object data related to a program failure from a passive log file; and

an object inflation module that instantiates corresponding objects in memory from the extracted contextual object data.

19. The in-memory interactive object generator of claim 18, wherein the extracted contextual object data is proximal to an area of program code where the component failed.

20. A computer program product for generating interactive in memory objects from stored program failure data, the computer program product comprising:

a computer readable storage medium having computer readable program code embodied therewith, the computer readable program code comprising;

computer readable program code configured to detect an anomalous condition related to a program failure;

computer readable program code configured to capture data regarding the anomalous condition;

computer readable program code configured to store the captured data;

computer readable program code configured to convert the stored data into at least one in-memory object; and

computer readable program code configured to reproduce a runtime environment about a region of code related to the program failure from the at least one in-memory object.