Interactive debugging environments and methods of providing the same

• US 8,789,020 B2
• Filed: 09/01/2011
• Issued: 07/22/2014
• Est. Priority Date: 09/01/2011
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Chung, Albert Alexander, Gadepalli, Venkata Vishwanath, Osowski, Richard Elwood Jr.
• Primary Examiner(s): Zhen, Wei
• Assistant Examiner(s): Rampuria, Satish
• Application Number:
  US13/223,648
• Publication Number:
  US 20130061210A1
• Time in Patent Office: 1,055 Days
• Field of Search: 717105-109, 717124-135, 717/160, 717/174, 709/206, 709220-231, 714 2- 20, 714/4.3, 714/4.5, 714 41- 48
• 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 active in-memory interactive object 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 active in-memory interactive object; and

reproducing a runtime environment about a region of code related to the program failure from the at least one active in-memory interactive object, 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;

generating a snapshot of an active class related to the captured data, 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;

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

deserializing the file;

reconstructing in-memory values of the object data of the active class;

generating a log file in response to detecting the anomalous condition, 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;

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

instantiating the at least one active in-memory interactive object from the extracted contextual object data; and

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

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

3. 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 active in-memory interactive object.

4. The computer-implemented method of claim 1, wherein the test tool includes a unit-test sandbox.

5. 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, 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;

auto-serializing object data of the active class into a file in response to the abnormal condition;

converting the serialized object data into at least one active in-memory interactive object corresponding to a localized representation of an original environment at which the abnormal condition occurred; and

reproducing a runtime environment about a region of program code related to the software component failure from the at least one active in-memory interactive object, wherein reproducing the runtime environment related to the software component failure includes reflecting a localized representation of an original environment of a program related to the software component failure, the localized representation being proximal to a region of program code of the software component failure;

deserializing the file;

reconstructing in-memory values of the object data of the active class;

generating a log in response to the software component failure, 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;

automatically extracting contextual object data 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;

instantiating the at least one active in-memory interactive object from the extracted contextual object data; and

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

6. The computer-implemented method of claim 5, 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 active in-memory representation of the interactive object.

7. The computer-implemented method of claim 5, wherein the test tool includes a unit-test sandbox.

8. A computer program product for generating active in-memory interactive object from stored program failure data, the computer program product comprising:

a non-transitory 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 active in-memory interactive 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, 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;

computer readable program code configured to generate a snapshot of an active class related to the captured data, 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;

computer readable program code configured to auto-serialize object data of the active class into a file in response to the anomalous condition;

computer readable program code configured to deserialize the file;

computer readable program code configured to reconstruct in-memory values of the object data of the active class;

computer readable program code configured to generate a log file in response to detecting the anomalous condition, 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;

computer readable program code configured to automatically extract contextual object data from the log file proximal to an area of the program failure;

computer readable program code configured to instantiate the at least one active in-memory interactive object from the extracted contextual object data; and

computer readable program code configured to provide the at least one active in-memory interactive object to a test tool for debugging.