Reversible debugging in a runtime environment

Patent metadata

Field	Value
Publication number	US-11113182-B2
Application number	US-201916372210-A
Country	US
Kind code	B2
Filing date	Apr 1, 2019
Priority date	Apr 1, 2019
Publication date	Sep 7, 2021
Grant date	Sep 7, 2021

Abstract

Performing reverse execution debugging of an application. The method includes identifying a snapshot of application state for an application in an application framework. The method further includes emulating execution of the application, using bytecode, in a forward direction from the snapshot to an end point, causing generation of historical execution state at various points along the emulation of the application. The method further includes collecting the historical execution state. The method further includes using the collected historical execution state, emulating reverse execution of the application by substituting collected historical execution state, when needed, to restore previous state needed as a result of emulation of reverse execution of the application.

First claim

What is claimed is:

1. A method of performing reverse execution debugging of an application, the method comprising:
identifying a snapshot of application state for the application;
emulating execution of the application on a debugger virtual machine that emulates functionality of a runtime virtual machine, wherein the debugger virtual machines uses intermediate level code to emulate execution of the application on the runtime virtual machine such that at least a portion of the intermediate level code is not converted to native machine instructions and executed on the runtime virtual machine, in a forward direction from the snapshot to an end point, causing generation of emulated historical execution state at various points along the emulation of the application;
collecting the emulated historical execution state; and
using the collected emulated historical execution state, emulating reverse execution of the application by substituting the collected emulated historical execution state, when needed, to restore previous state needed as a result of emulation of reverse execution of the application.

2. The method of claim 1 , wherein collecting the emulated historical execution state comprises collecting the emulated historical execution state into a stack such that the previous state is restored by popping elements of the emulated historical execution state from the stack.

3. The method of claim 2 , wherein there is a different stack for each thread being emulated.

4. The method of claim 2 , wherein an element is popped from the stack when emulated reverse execution identifies an instruction that changes application state to restore the application state to state that was valid immediately prior to the identified instruction.

5. The method of claim 1 , wherein collecting the emulated historical execution state comprises collecting the emulated historical execution state by iteratively emulating execution from the snapshot toward the endpoint, where each iteration of emulated execution emulates execution of progressively smaller portions of the application, such that reverse execution of the application is emulated by surfacing state as a result of each iteration.

6. The method of claim 5 , wherein each iteration executes one less bytecode instruction than the previous iteration.

7. The method of claim 1 , further comprising collecting runtime virtual machine external state for the application by executing machine code for the application in conjunction with emulating execution of the application.

8. A computer system comprising:
one or more processors; and
one or more computer-readable media having stored thereon instructions that are executable by the one or more processors to configure the computer system to perform reverse execution debugging of an application, including instructions that are executable to configure the computer system to perform at least the following:
identify a snapshot of application state for the application;
emulate execution of the application on an debugger virtual machine that emulates functionality of a runtime virtual machine, wherein the debugger virtual machines uses intermediate level code to emulate execution of the application on the runtime virtual machine such that at least a portion of the intermediate level code is not converted to native machine instructions and executed on the runtime virtual machine, in a forward direction from the snapshot to an end point, causing generation of emulated historical execution state at various points along the emulation of the application;
collect the emulated historical execution state; and
use the collected emulated historical execution state, emulating reverse execution of the application by substituting the collected emulated historical execution state, when needed, to restore previous state needed as a result of emulation of reverse execution of the application.

9. The computer system of claim 8 , wherein collecting the emulated historical execution state comprises collecting the emulated historical execution state into a stack such that the previous state can be restored by popping elements of the historical execution state from the stack.

10. The computer system of claim 9 , wherein there is a different stack for each thread being emulated.

11. The computer system of claim 9 , wherein an element is popped from the stack when emulated reverse execution identifies an instruction that changes application state.

12. The computer system of claim 8 , wherein collecting the emulated historical execution state comprises collecting the emulated historical execution state by iteratively emulating execution from the snapshot toward the endpoint, where each iteration of emulated execution emulates execution of progressively smaller portions of the application, such that reverse execution of the application is emulated by surfacing state as a result of each iteration.

13. The computer system of claim 12 , wherein each iteration executes one less bytecode instruction than the previous iteration.

14. The computer system of claim 8 , wherein one or more computer-readable media further have stored thereon instructions that are executable by the one or more processors to configure the computer system to collect non-deterministic state for the application by executing lower level application code for the application in conjunction with emulating execution of the application.

15. A computer physical readable media having stored thereon instructions that are executable by one or more processors to configure a computer system to perform reverse execution debugging of an application, including instructions that are executable to configure the computer system to perform at least the following:
identify a snapshot of application state for an application in an application framework;
emulate execution of the application on a debugger virtual machine that emulates functionality of a runtime virtual machine, using bytecode, to emulate execution of the application on the runtime virtual machine such that at least a portion of the intermediate level code is not converted to native machine instructions and executed on the runtime virtual machine in a forward direction from the snapshot to an end point, causing generation of emulated historical execution state at various points along the emulation of the application;
collect the emulated historical execution state; and
use the collected emulated historical execution state, emulating reverse execution of the application by substituting the collected emulated historical execution state, when needed, to restore previous state needed as a result of emulation of reverse execution of the application.

16. The computer readable storage media of claim 15 , wherein collecting the emulated historical execution state comprises collecting the emulated historical execution state into a stack such that the previous state can be restored by popping elements of the emulated historical execution state from the stack.

17. The computer readable storage media of claim 16 , wherein there is a different stack for each thread being emulated.

18. The computer readable storage media of claim 16 , wherein an element is popped from the stack when emulated reverse execution identifies an instruction that changes application state.

19. The computer readable storage media of claim 15 , wherein collecting the historical execution state comprises collecting the emulated historical execution state by iteratively emulating execution from the snapshot toward the endpoint, whe

Assignees

• Microsoft Technology Licensing Llc

Inventors

• Nelson Patrick Lothian
• Davis Jackson Michael
• Myers Del
• Lai Thomas

Classifications

• G06F11/3698 Primary

  Environments for analysis, debugging or testing of software · CPC title

• G06F9/45558

  Hypervisor-specific management and integration aspects · CPC title

• G06F2009/45575

  Starting, stopping, suspending or resuming virtual machine instances · CPC title

• G06F11/3636 Primary

  by tracing the execution of the program · CPC title

• G06F2009/45591

  Monitoring or debugging support · CPC title