US20160292061A1 - Time travel debugging for browser components - Google Patents
Time travel debugging for browser components Download PDFInfo
- Publication number
- US20160292061A1 US20160292061A1 US14/751,638 US201514751638A US2016292061A1 US 20160292061 A1 US20160292061 A1 US 20160292061A1 US 201514751638 A US201514751638 A US 201514751638A US 2016292061 A1 US2016292061 A1 US 2016292061A1
- Authority
- US
- United States
- Prior art keywords
- computer
- executable program
- execution
- virtual machine
- interrogative
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/362—Software debugging
- G06F11/3636—Software debugging by tracing the execution of the program
Definitions
- a root cause of a bug is a first point at which a state of a program diverges from an intended state.
- a developer often halts program execution and examines the state of the program.
- Overshooting e.g., late halting of the execution of the program
- a virtual machine can be useful for capturing a state of a program.
- a virtualization layer can act as a boundary for encapsulating program state, which can enable snapshotting, migrating, and resuming complex, multi-level software applications.
- a virtual machine interface (VMI) of a virtual machine can provide an introspection point for logging events that affect program execution.
- Some conventional virtual machines which virtualize at the x86-level, provide strong and efficient isolation. By virtualizing at the x86-level, these conventional virtual machines can provide precise snapshots that capture hardware-level information. However, with these conventional approaches, a full virtual machine snapshot can be on the order of hundreds of MBs in size, and an x86-level event log can grow on the order of hundreds of MBs per day.
- a debugger can be used to halt program execution and examine the state of the program (e.g., via a graphical user interface (GUI)).
- GUI graphical user interface
- tool support for debugging has remained relatively unchanged for many years. Accordingly, the cost of restarting and re-running the program when a breakpoint is placed too late in the execution of the program remains.
- a computer-executable program can be executed.
- the computer-executable program can be executable under control of a virtual machine.
- the virtual machine can interact with a browser system during execution of the computer-executable program.
- nondeterministic events can be logged via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program.
- the nondeterministic events can be logged as part of event logs.
- the interrogative VMI is between the virtual machine and the browser system.
- snapshots of the virtual machine can be captured during the execution of the computer-executable program.
- the snapshots can be captured via the interrogative VMI. At least a portion of the execution of the computer-executable program can be replayed based at least in part on a snapshot and at least a portion of the event logs.
- FIG. 1 illustrates a functional block diagram of an exemplary computing system that performs time travel debugging.
- FIG. 2 illustrates a functional block diagram of an exemplary system that employs interrogative virtualization to enable time travel debugging.
- FIG. 3 illustrates a functional block diagram of another example of a script-based virtual machine.
- FIG. 4 illustrates a functional block diagram of an exemplary system that performs time travel debugging.
- FIG. 5 is a flow diagram that illustrates an exemplary methodology for performing time travel debugging.
- FIG. 6 is a flow diagram that illustrates an exemplary methodology for performing time travel debugging.
- FIG. 7 illustrates an exemplary computing device.
- FIG. 8 illustrates an exemplary computing system.
- the term “or” is intended to mean an inclusive “or” rather than an exclusive “or.” That is, unless specified otherwise, or clear from the context, the phrase “X employs A or B” is intended to mean any of the natural inclusive permutations. That is, the phrase “X employs A or B” is satisfied by any of the following instances: X employs A; X employs B; or X employs both A and B.
- the articles “a” and “an” as used in this application and the appended claims should generally be construed to mean “one or more” unless specified otherwise or clear from the context to be directed to a singular form.
- FIG. 1 illustrates a computing system 102 that performs time travel debugging.
- the computing system 102 includes at least one processor 104 and memory 106 .
- the at least one processor 104 is configured to execute instructions loaded into the memory 106 (e.g., system(s) and/or component(s) loaded into the memory 106 are executable by the processor 104 ).
- the memory 106 includes instructions configured to perform time travel debugging for a browser system 128 .
- the computing system 102 can be or include a computing device.
- the computing device can be a desktop computing device, a mobile computing device (e.g., a laptop computing device, a mobile telephone, a tablet computing device, a wearable computing device, a handheld computing device, a portable gaming device, a personal digital assistant (PDA), etc.), a gaming console, a set-top box, an in-vehicle communications and infotainment system, or the like.
- the computing system 102 can be or include one or more server computing devices.
- the computing system 102 can be or include one or more datacenters, where a datacenter includes a plurality of server computing devices. Additionally or alternatively, the computing system 102 can be a distributed computing system.
- the memory 106 of the computing system 102 includes a computer-executable program 108 and a virtual machine (VM) 110 (e.g., a managed runtime, etc.).
- the computer-executable program 108 can include a sequence of instructions that are executable under control of the virtual machine 110 .
- the virtual machine 110 can compile and/or interpret the computer-executable program 108 for the processor 104 and perform the instructions included in the computer-executable program 108 .
- the memory 106 further includes the browser system 128 (e.g., a web browser).
- the browser system 128 can be configured to retrieve, present, and traverse information available on a network, in a file system (e.g., of the computing system 102 or a disparate computing system), or the like.
- an interrogative virtual machine interface (VMI) 124 is an interface between the virtual machine 110 and the browser system 128 .
- the interrogative VMI 124 enables nondeterministic events to be exposed to the virtual machine 110 .
- the interrogative VMI 124 exposes minimal amounts of state belonging to otherwise opaque black box components. A minimal amount of state from a particular black box component can be a least amount of state for accurately snapshotting and logging events for such black box component.
- the virtual machine 110 can be a process virtual machine that runs as an application inside a host operating system and supports a process.
- the virtual machine 110 can provide a platform-independent programming environment that abstracts details of the underlying hardware or operating system, and enables the computer-executable program 108 to be executed on differing platforms.
- the computer-executable program 108 can be or include a script written in a scripting language (e.g., JavaScript, etc.); following this example, the script can be interpreted and executed by the virtual machine 110 .
- a scripting language e.g., JavaScript, etc.
- the script can be interpreted and executed by the virtual machine 110 .
- other types of computer-executable programs and other types of virtual machines are intended to fall within the scope of the hereto appended claims (e.g., a computer-executable program written in the Java programming language and Java web toolkit (JWt), a computer-executable program written in the C# programming language and Windows Presentation Foundation (WPF), etc.).
- the virtual machine 110 includes an execution component 112 that can be configured to receive the computer-executable program 108 . Moreover, the execution component 112 can be configured to execute the computer-executable program 108 .
- the execution component 112 can be or include an interpreter.
- the interpreter can directly perform the instructions of the computer-executable program 108 .
- the interpreter can translate the instructions of the computer-executable program 108 to an intermediate representation and can execute the intermediate representation.
- the instructions of the computer-executable program 108 can include precompiled code, and the interpreter can execute such precompiled code (e.g., the precompiled code can be machine independent code).
- the interpreter can be a bytecode interpreter; yet, other types of interpreters are intended to fall within the scope of the hereto appended claims.
- the execution component 112 can additionally or alternatively be or include a just-in-time (JIT) compiler.
- JIT just-in-time
- the JIT compiler can convert intermediate language instructions of the computer-executable program 108 to machine instructions for execution by the processor 104 . Further, the JIT compiler can execute the machine instructions.
- the virtual machine 110 can further include a snapshot component 114 configured to record a sequence of snapshots 116 of the virtual machine 110 (e.g., VM snapshots) during execution of the computer-executable program 108 at various times.
- the snapshot component 114 can be configured to record the snapshots 116 via the interrogative VMI 124 Moreover, the snapshots 116 recorded by the snapshot component 114 can be stored in a data store 118 of the computing system 102 .
- the computer-executable program 108 during execution by the execution component 112 , stores data in variables, which represent storage locations in the memory 106 (e.g., call stack, heap, etc.). At a given point during the execution of the computer-executable program 108 , content of the storage locations in the memory 106 can be recorded as a snapshot of the virtual machine 110 .
- the snapshots 116 in the sequence can be periodically recorded by the snapshot component 114 at a predefined time interval.
- a time interval at which the snapshots 116 are sequentially recorded by the snapshot component 114 can be dynamically adjusted; following this example, the time interval can be dynamically adjusted during the execution of the computer-executable program 108 .
- the virtual machine 110 can include an event logger component 120 configured to log nondeterministic events during execution of the computer-executable program 108 as part of event logs 122 .
- the event logs 122 can be stored in the data store 118 .
- the event logger component 120 can log the nondeterministic events that affect execution of the computer-executable program 108 via the interrogative VMI 124 .
- the virtual machine 110 can be extended to define the interrogative VMI 124 , which enables the event logger component 120 to capture various nontraditional events.
- the event logs 122 can enable a variety of debugging analyses.
- the snapshot component 114 and the event logger component 120 can efficiently capture application-level semantics in order to reduce the size of the snapshots 116 and the event logs 122 .
- the snapshot component 114 and/or the event logger component 120 can ignore portions of architectural state in an operating system (OS) and the hardware when capturing the snapshots 116 and/or the event logs 122 .
- OS operating system
- the virtual machine 110 can be a runtime environment layered atop a lower-level runtime environment.
- Such virtualized interfaces can enable various useful services.
- the virtual machine 110 can hide sensitive low-level resources from untrusted applications (e.g., such resources can be hidden from the computer-executable program 108 ), and cause potentially dangerous operations to pass dynamic security checks.
- the event logger component 120 of the virtual machine 110 logs the nondeterministic data that the virtual machine 110 exchanges with the computer-executable program 108 , then the event logs 122 can later be used by a time travel debugger 126 to replay the execution of the computer-executable program 108 ; these replayed executions, for instance, can be useful for security forensics and debugging of the computer-executable program 108 .
- the virtual machine 110 can also define an encapsulation boundary for a state of the computer-executable program 108 (e.g., the snapshots 116 can be useful for suspend/resume services, and for migrating applications across different machines).
- the interrogative VMI 124 can reduce a size of a virtual machine state (in comparison to conventional low-level virtual machines). Smaller virtual machines are faster to snapshot, faster to load, and faster to transfer across a network as compared to larger virtual machines. In turn, this makes it cheaper to perform suspension, resumption, and migration of a virtual machine. Small virtual machines also allow datacenter operators to place more virtual machines on a single physical server, which allows for enhanced server utilization.
- the interrogative VMI 124 can cause a size of the nondeterministic event logs 122 to be reduced (relative to conventional low-level virtual machines).
- static snapshots 116 of the virtual machine 110 may provide insufficient context; thus, the snapshots 116 can be supplemented with the event logs 122 that describe how the virtual machine 110 evolves between the snapshots 116 .
- Small event logs 122 combined with small snapshots 116 , make it feasible to store long-term execution traces for complex applications (e.g., the computer-executable program 108 ).
- the interrogative VMI 124 can enable the snapshots 116 and the event logs 122 to be semantically complete.
- the snapshots 116 and the event logs 122 can include information for understanding the execution history of the computer-executable program 108 by the virtual machine 110 .
- execution analyses can be performed without using heuristics for inferring application state (e.g., such heuristics may be fallible).
- the interrogative VMI 124 enables efficient generation of the snapshots 116 by the snapshot component 114 and the event logs 122 by the event logger component 120 . Accordingly, snapshotting and event logging can be fast and can have low computational overheads due to the interrogative VMI 124 (e.g., as compared to snapshotting and event logging for conventional low-level virtual machines).
- Interrogative virtualization is supported by the interrogative VMI 124 .
- a level of abstraction of the interrogative VMI 124 for the virtual machine 110 is raised as compared to some conventional VMIs for some traditional virtual machines; more particularly, the interrogative VMI 124 is moved away from interfaces presented by the hardware or the operating system, and towards an application-level semantic interface.
- managed language runtimes and application frameworks can mediate a program's interactions with the local machine and the outside world. Virtualizing at the application-visible level of abstraction allows large amounts of architectural state that is oftentimes captured by low-level approaches to be ignored. However, not all of the low-level state can be ignored as is common with conventional managed language runtimes and application frameworks.
- interrogative virtualization makes modifications to the high-level application interface, instead providing the interrogative VMI 124 that exposes events to the virtual machine 110 which are hidden from the computer-executable program 108 .
- the virtual machine 110 can interrogate nominally black box components via the interrogative VMI 124 to enable the snapshot component 114 and the event logger component 120 to capture the application-level semantics while safely ignoring many details at the hardware or operating system level.
- VMIs tend to be designed to provide efficient and strong isolation between different virtual machines. As a result, these traditional VMIs provide narrow, low-level interfaces to minimize the trusted computing base and leverage hardware support for virtualization.
- virtualizing at a low-level involves a trade-off: isolation becomes cheap, but other virtual machine operations become expensive.
- conventional virtual machine snapshots oftentimes are large because they include substantial amounts of architectural state.
- execution traces commonly grow quickly due to the vast number of low-level nondeterministic events.
- application-level program analysis is often overdetermined, since a conventional virtual machine commonly includes data from multiple layers in the software and hardware stack, when often the top layers (without the lower layers) enable understanding execution of a computer-executable program.
- the interrogative VMI 124 for the virtual machine 110 can be high-level and wide enough to capture application semantics. Compared to low-level, narrow virtualization interfaces, the interrogative VMI 124 can enable implementing various virtual machine operations using an order of magnitude less time and space. To provide strong, efficient isolation, the interrogative VMI 124 can be nested within a low-level virtualization framework, which can provide security; thus, security need not be sacrificed for performance.
- the virtual machine 110 can also include the time travel debugger 126 (the time travel debugger 126 can also be referred to as a time travel debugger component).
- the time travel debugger 126 can be configured to test and debug the computer-executable program 108 .
- the time travel debugger 126 is a debugger that steps forwards and backwards through execution of a computer-executable program (e.g., the computer-executable program 108 ) during a debugging session.
- conventional debuggers oftentimes tend to step forwards through execution of a computer-executable program during a debugging session, without being able to step backwards through such execution.
- the time travel debugger 126 allows execution to be reversed during a debugging session (e.g., if a breakpoint is set too late so as to not require re-execution of a computer-executable program with the breakpoint moved to be earlier in time).
- the time travel debugger 126 supports forward and reverse debugging of the computer-executable program 108 .
- the snapshot component 114 can record the snapshots 116 and the event logger component 120 can record nondeterministic events in the event logs 122 to capture the execution of the computer-executable program 108 .
- the time travel debugger 126 can be configured to replay the execution of the computer-executable program 108 by stepping the execution of the computer-executable program 108 both forwards and backwards in time.
- the time travel debugger 126 can be configured to replay at least a portion of the execution of the computer-executable program 108 based at least in part on a snapshot (from the snapshots 116 ) and at least a portion of the event logs 122 .
- the time travel debugger 126 can enable time travel debugging for the browser system 128 .
- time travel debugging often is too expensive to run on production servers or on resource-limited end-user machines with poor network connections.
- the time travel debugger 126 can be configured to perform backwards-facing variants for traditional forward-facing operations like step-forward and step-out.
- the event logger component 120 can log nondeterministic events (e.g., the event logs 122 ) and the snapshot component 114 can capture the snapshots 116 of the virtual machine 110 .
- the time travel debugger 126 can be configured to travel to time t by identifying a snapshot from the snapshots 116 that temporally precedes time t, loading the snapshot that temporally preceded time t, and then replaying the event logs 122 from the snapshot to the time t.
- a most recent snapshot from the snapshots 116 that occurred before t can be loaded by the time travel debugger 126 ; however, it is contemplated that a differing snapshot from the snapshots 116 that occurred before t can alternatively be loaded by the time travel debugger 126 .
- interrogative VMI 124 By logging events and tracking state at the level of the interrogative VMI 124 , storage overheads can be reduced in comparison to systems that introspect at a lower level (e.g., x86 instructions, or systems calls and UNIX signals). With the interrogative VMI 124 , sizes of the snapshots 116 of the state of the virtual machine 110 and the nondeterministic event logs 122 can be decreased as compared to lower-level approaches. For instance, heap-intensive applications can have compressed snapshots that are less than 500 KB in size. Moreover, for interactive games and applications, the event logs may grow at about 1 KB per second.
- the time travel debugger 126 can also provide more robust, higher-fidelity replay than conventional systems that lack the vantage point of the interrogative VMI 124 , and which consequently rely on inference methods to reconstruct state that is readily available in the interrogative system as described herein.
- the virtual machine 110 and the interrogative VMI 124 enable nondeterminism logging of event logs 122 and capturing of snapshots 116 .
- the snapshots 116 and the event logs 122 can be device and address independent.
- the time travel debugger 126 on a program bug, can report an error state as well as a last k-seconds of events before the bug.
- the snapshots 116 and the event logs 122 can be at the JavaScript/HTML level, which can be saved for later debugging or transmitted to another computing system.
- the other computing system need not have the same version of JavaScript/HTML engines or operating system.
- the claimed subject matter is not limited to the foregoing illustration.
- the system 200 includes a script-based virtual machine 202 ; thus, as set forth in the example of FIG. 2 , the virtual machine 110 can be the script-based virtual machine 202 .
- the script-based virtual machine 202 can interpret and execute the computer-executable program 108 .
- the computer-executable program 108 can be a script written in a scripting language (e.g., JavaScript, etc.), and thus, the script-based virtual machine 202 can interpret and execute such script.
- the script-based virtual machine 202 can include the execution component 112 , the snapshot component 114 , the event logger component 120 , and the time travel debugger 126 .
- the system 200 further includes the browser system 128 .
- the browser system 128 can include various components. As depicted, the browser system 128 can include a storage component 204 , a runtime library 206 , a network component 208 , and a renderer component 210 . However, it is contemplated that the browser system 128 may lack one or more of the foregoing components and/or may include differing components.
- the interrogative VMI 124 is an interface between the script-based virtual machine 202 and the browser system 128 .
- the script-based virtual machine 202 can include one or more execution contexts. As illustrated, the script-based virtual machine 202 is shown as including an execution context 212 and an execution context 214 . However, it is contemplated that the script-based virtual machine 202 can include more or less than two execution contexts.
- the execution contexts of the script-based virtual machine 202 are collectively referred to herein as execution contexts 212 - 214 . Each of the execution contexts 212 - 214 can be single-threaded and event-driven.
- execution context 212 (or any of the other execution contexts 212 - 214 ) runs its initialization code
- callback functions that respond to events are defined. After the initialization code terminates, subsequent code execution can be driven by reception of events and firing of associated handlers. Since the execution context 212 is single-threaded, a call chain that is initiated by an event handler is atomic; once started, the call chain runs to completion, and at any given time, the execution context 212 has at most one active call chain.
- different execution contexts 212 - 214 can exchange data using an asynchronous, pass-by-value communication channel (e.g., postMessage( )).
- the components of the browser system 128 can be event-driven black box components. These components can be black boxes because, from the perspective of the computer-executable program 108 , such components hide their implementations behind opaque interfaces. However, the execution contexts 212 - 214 are event-driven, so the black box components can export event-driven interface(s) to interoperate with the computer-executable program 108 .
- the script-based virtual machine 202 can include an interface component 216 configured to interact with the black box components of the browser system 128 via exposed interfaces (e.g., application programming interfaces (APIs)) of the black box components. Accordingly, the black box components of the browser system 128 can be interrogated by the interface component 216 of the script-based virtual machine 202 via the interrogative VMI 124 .
- exposed interfaces e.g., application programming interfaces (APIs)
- the renderer component 210 can be a black box component of the browser system 128 .
- the renderer component 210 can be written in C++, and it may use multiple threads or processes to calculate visual layouts and update a bitmap.
- the renderer component 210 exposes a single-threaded, event-driven API through the Document Object Model (DOM).
- DOM Document Object Model
- the computer-executable program 108 can register callbacks which the renderer component 210 triggers when the relevant state changes.
- the computer-executable program 108 can modify DOM state through a variety of synchronous and asynchronous APIs.
- the synchronous APIs can be implemented as remote procedure call (RPC) messages that trigger event handlers in the renderer component 210 ; to provide synchronous semantics, the browser system 128 can pause the caller until the renderer component 210 has responded to the RPC request.
- RPC remote procedure call
- the script-based virtual machine 202 can include one or more message-driven execution contexts 212 - 214 , some of which may be black boxes with respect to the computer-executable program 108 .
- black box components include the network component 208 (e.g., a network stack in the browser system 128 ) and the storage component 204 (e.g., database interfaces used by server-side scripting language frameworks).
- the interrogative VMI 124 can include an aggregate set of event channels. By interposing on messages exchanged via these channels, the interactions between the various components in the script-based virtual machine 202 may be captured. However, black box components oftentimes do not generate events for various changes to internal state.
- the computer-executable program 108 can request the renderer component 210 to perform a Cascading Style Sheets (CSS) animation that periodically modifies a user-visible DOM state. At any given moment, the computer-executable program 108 can synchronously request the renderer component 210 for a view of the DOM.
- CSS Cascading Style Sheets
- the renderer component 210 typically updates the visual display without triggering script-side notifications, meaning that the script-side view of the DOM can desynchronize from the true DOM state inside the renderer component 210 . This may be sufficient if it is desired to isolate and analyze the execution contexts 212 - 214 . However, if it is desired to isolate and analyze the complete script-based virtual machine 202 (for a client-side web page or a Node application), missing events can impact correctness, performance, or both. Moreover, the script-based virtual machine 202 may include multiple execution contexts 212 - 214 and black box components.
- a debugger for a web page can produce erroneous results if it lacks sufficient insights into rendering events. Further, logging and replay can be more efficient when the VMI event interface is semantically complete, such as the interrogative VMI 124 .
- the black box components can be modified so that these components export a wider variety of events.
- This approach is referred to herein as interrogative virtualization, and includes interrogating the black box components to reveal specific parts of their hidden states.
- Interrogative virtualization extends the virtualization interface itself to improve the performance or correctness of operations upon virtual machines.
- the renderer component 210 can be changed to report a tick count associated with an animation.
- the renderer component 210 can be configured to perform the animation and associate the tick count with the animation, where the tick count can be indicative of how close the animation is to a final repaint.
- the tick count associated with the animation can be exposed to the script-based virtual machine 202 via the interrogative VMI 124 .
- the storage component 204 e.g., the database stack
- the network component 208 can download an external resource (e.g., the renderer component 210 can cause the network component 208 to download the external resource, etc.); following this example, an event indicative of the external resource being downloaded by the network component 208 can be exposed to the script-based virtual machine 202 via the interrogative VMI 124 .
- a callback list managed by the renderer component 210 can be exposed to the script-based virtual machine 202 via the interrogative VMI 124 .
- FIG. 3 illustrates another example of the script-based virtual machine 202 (e.g., the script-based virtual machine 202 can be a JavaScript virtual machine, etc.).
- the script-based virtual machine 202 of FIG. 3 again includes the execution contexts 212 - 214 (e.g., an execution context for abc.com and an execution context for xyz.com).
- the script-based virtual machine 202 can further include the execution component 112 , the snapshot component 114 , the event logger component 120 , and/or the time travel debugger 126 .
- the script-based virtual machine 202 supports nested virtualization.
- large interfaces may negatively impact security.
- Such interfaces can increase a threat surface that is visible to an attacker, and their rich semantics can cause defenders to reason about a variety of corner cases.
- Interrogative virtualization adds communication channels to the virtual interface, so at first glance, interrogative virtualization seems to negatively impact security—there appear to be more opportunities for an attacker to escape an isolation container of the script-based virtual machine 202 .
- the application-visible execution interface need not be conflated with a structural isolation boundary. The former is the interface that applications directly invoke, whereas the latter is the interface at which isolation and security are enforced.
- nested virtualization can be used to layer the interrogative VMI 124 (e.g., with a rich, wide interface) atop a smaller, low-level VMI (e.g., a security monitor VMI 302 ) defined by a virtual machine monitor (VMM) 304 (e.g., a hypervisor).
- VMM virtual machine monitor
- the VMM 304 can provide services that allow multiple operating systems to execute on hardware of a computing system (e.g., the computing system 102 ). Isolation enforcement is performed by the VMM 304 , but other management decisions involving the script-based virtual machine 202 are performed by an interrogative VM VMM 304 .
- the interrogative VMM 304 can be similar to a library OS for the VM; yet, since the interrogative interface is sufficiently expressive to capture the application-level semantics, the library OS's internal state need not be included in the snapshots (e.g., the snapshots 116 ) or the event logs (e.g., the event logs 122 ).
- the interrogative VMI 124 does not expose raw memory addresses, so even though the VMM 304 may internally manipulate raw addresses, those addresses are not mentioned in the event logs or the snapshots. By excluding unnecessary architectural state from the interrogative VMI 124 , sizes of snapshots and event logs can be reduced by an order of magnitude.
- the interrogative VMI 124 can be constructed by extending the script-based virtual machine 202 used by a web browser (e.g., the browser system 128 ). Interfaces (e.g., the interface component 216 ) of the script-based virtual machine 202 to black box components, such as the storage component 204 , the runtime library 206 , the network component 208 (e.g., the network stack), and the renderer component 210 , can be modified to include a number of interrogative APIs to expose hidden state.
- an efficient snapshotting mechanism e.g., executed by the snapshot component 114
- the interrogative VMI 124 can be augmented to record (e.g., via the event logger component 120 ) the nondeterministic events that enter and leave the script-based virtual machine 202 .
- the result can be, for instance, a fully functional interrogative VMI 124 for the client-side of a web application.
- Hidden state can be exposed via the interrogative VMI 124 .
- the script-based virtual machine 202 can allow scripting language code to perform computations. To allow scripting language code to access local storage, exchange network traffic, and interact with the display, the script-based virtual machine 202 can communicate with external input-output (I/O) modules. Runtime information about the IO stack as well as the script-based virtual machine 202 can be captured via the interrogative VMI 124 . Below are some examples that enable application-level semantics to be captured.
- CSS/SVG Animation State Browsers commonly use a dedicated thread to perform CSS and Scalable Vector Graphics (SVG) animations. These animations typically run in parallel with script execution, and once triggered, they conventionally run to completion (e.g., not paused or resumed by scripting language code).
- SVG Scalable Vector Graphics
- the renderer component 210 can associate a tick count with each animation.
- the tick count represents how close the animation is to its final repaint.
- the renderer component 210 can expose these tick counts to the script-based virtual machine 202 via the interrogative VMI 124 .
- the tick counts can be employed as logical clock values to synchronize the concurrent execution of the script-based virtual machine 202 and the renderer component 210 .
- the renderer component 210 can allow the script-based virtual machine 202 to pause or restart an animation from a given tick count via the interrogative VMI 124 .
- the scripting language code can be event-driven. For instance, after a page's initialization code runs, subsequent code can be triggered by the arrival of events like key presses and mouse clicks.
- the scripting language code can register callback functions for events (e.g., using the addEventListener(evtName, callback) method). An application can register multiple callbacks for the same event.
- Callback lists are managed by the renderer component 210 ; such callback lists typically cannot be accessed from a conventional virtual machine.
- the script-based virtual machine 202 can access the callback lists managed by the renderer component 210 via the interrogative VMI 124 .
- the script-based virtual machine 202 can use the interrogative VMI 124 to enumerate and the callback lists and serialize such lists.
- the script-based virtual machine 202 can use an interface of the renderer component 210 that restores the serialized lists.
- Objects in the DOM can refer to resources that are hosted on external servers.
- img elements refer to images
- iframe elements refer to HTML documents.
- the renderer component 210 can bypass the script-based virtual machine 202 and directly communicate with the network component 208 (e.g., the network stack).
- the network component 208 can expose a set of additional events to the script-based virtual machine 202 via the interrogative VMI 124 .
- Examples of such events exposed by the network component 208 include an event that indicates when the network component 208 has finished downloading a resource. This allows the interrogative VMI 124 to be employed by the script-based virtual machine 202 to log the fetched value, as well as determine when the download completed with respect to other concurrent activities like execution of a computer-executable program (e.g., the computer-executable program 108 ).
- Timers Applications can spawn and cancel one-time or recurring timers.
- a setTimeout interface can be used by the script-based virtual machine 202 to spawn a one-time timer
- a setInterval interface can be used by the script-based virtual machine 202 to spawn a recurring timer
- a clearTimeout interface can be used by the script-based virtual machine 202 to cancel a one-time timer
- a clearInterval interface can be used by the script-based virtual machine 202 to cancel a recurring timer.
- the renderer component 210 for instance, can manage these timers; yet, the renderer component 210 typically does not expose their state to conventional virtual machines.
- these four interfaces can be interposed on from within the script-based virtual machine 202 to keep track of and expose active timers and their associated callbacks.
- the renderer component 210 can be modified to expose the timers to the script-based virtual machine 202 via the interrogative VMI 124 .
- the script-based virtual machine 202 can add new active timers when the application creates them and timestamp their creation, and remove them when the application clears them.
- the script-based virtual machine 202 removes it from the active set.
- the script-based virtual machine 202 updates its timestamp.
- State snapshots (e.g., captured by the snapshot component 114 of the script-based virtual machine 202 ) are now described in greater detail.
- the snapshot component 114 can wait for each execution context 212 - 214 to quiesce.
- Each execution context 212 - 214 can be single-threaded, so quiescence can occur when the local event loop has finished executing an event handler; stack state need not be captured since the context has no outstanding call chains.
- the snapshot component 114 can capture black box state using the interrogative APIs of the interrogative VMI 124 .
- a DOM element may have a set of string properties, a nested tree of DOM elements, and event listeners.
- the snapshot component 114 can capture this information using existing DOM interfaces and the VMI extensions. To resurrect the DOM state in a snapshot, each DOM object can be recreated using existing DOM interfaces (e.g., to create an element, to set an attribute, etc.).
- the renderer component 210 can execute in parallel with the script-based virtual machine 202 .
- the renderer component 210 can block during synchronous RPC exchanges with the script-based virtual machine 202 .
- the interface of the renderer component 210 can be extended to support a synchronous, no-op RPC that prevents the renderer component 210 from generating GUI events, repainting the screen, and so on.
- the snapshot component 114 can pause the renderer component 210 before serializing the state of the script-based virtual machine 202 . This ordering can mitigate the execution contexts 212 - 214 from including references to stale renderer-side state.
- Canvas Context Canvas elements in the DOM can have an associated context object that includes the visual state of the canvas.
- the context object can be retrievable using an interface that gets a context object of a canvas.
- the snapshot component 114 can record each canvas's visual state as a bitmap. During snapshot inflation, the bitmap can be reapplied to restore the canvas to its previous state.
- the snapshot component 114 can identify live scripting language objects and serialize such objects. Primitive values like numbers and strings can be serialized. Moreover, arrays and objects can be serialized as bags of properties. Object references (including references to DOM objects) can be rewritten to point to the target object's location in the snapshot.
- Event Queue When the snapshot component 114 runs, execution contexts are quiescent. However, the contexts may have non-empty event queues. Each event can include one or more callbacks to invoke, and one or more arguments to pass to the callbacks. The snapshot component 114 can serialize this information and place it in the snapshot.
- the snapshot component 114 can record the tick count of active CSS and SVG animations. When the snapshot is later inflated, the interrogative interface can be used to resume each animation at the suspension-time tick count.
- the snapshot component 114 can calculate and record the remaining time left on each active timer, the interval duration for recurring timers, and each timer's associated callback.
- One-time timers can be restored during snapshot inflation using an interface that sets a timeout.
- the interface that sets the timeout can be used for initiation to resume the interrupted recurrence. Further, an interface that sets an interval can be used to resume the normal interval.
- Nondeterministic event logging (e.g., performed by the event logger component 120 of the script-based virtual machine 202 ) is now described in greater detail. While snapshots depict the script-based virtual machine 202 at particular moments in time, the nondeterministic event logs describe how the script-based virtual machine 202 evolves between snapshots. Using the interrogative VMI 124 , event logs grow slowly because, compared to raw x86 code, the scripting language code can be more deterministic.
- the event logger component 120 can use the interrogative VMI 124 , during the execution of the computer-executable program, to log an event that is scheduled, a DOM tree difference between events for a DOM change, a tick count associated with an animation, a value change for a window state, a value from a synchronous source, and a timer identifier.
- the event logger component 120 can serialize black box object references.
- Some nondeterministic events can refer to objects that reside in a black box component.
- the network component 208 e.g., the network stack
- HTTP Hypertext Transfer Protocol
- XHR XMLHttpRequest
- Such hosted objects have a scripting language wrapper, but can reside within the black box component.
- Hosted objects can subsequently be referenced by events.
- the network component 208 can pass an event object to the execution context; the target property of the event can be the XMLHttpRequest object that was created via a new operator, where the new operator creates an instance of an object type.
- the identity of the XMLHttpRequest object can be recorded in the event.
- edge relationships between objects in a heap graph can be preserved.
- Object Tagging In general, a hosted object can be created via the new operator before it can appear in an event. For example, an XMLHttpRequest object can be created and initialized before it can generate network events. At logging time, the interrogative VMI 124 interposes on the new operator and assigns a unique integer identifier to each hosted object. By interposing on the event interface, script-based virtual machine 202 can log the identifier of the hosted object in each event.
- the interrogative VMI 124 can be used by the script-based virtual machine 202 to assign identifiers as above; hosted objects can receive the same logging-time identifiers, since replay is deterministic.
- the interrogative VMI 124 also can be used by the script-based virtual machine 202 to maintain a map that associates an identifier with its hosted object.
- the script-based virtual machine 202 can use the interrogative VMI 124 to extract the hosted object identifier from the event log, fetch the associated hosted object from the map, and attach that hosted object to the event that is passed to the execution context.
- DOM Paths Object tagging typically does not work for DOM elements, since a DOM element can be referenced by an event without a prior scripting language call to the new operator. For example, HTML of a page can register a scripting language click handler for a button element. When the button is clicked, the browser can generate an event which references the button. Following this illustration, the execution context has not previously seen that DOM element, and thus, has not been tagged.
- the interrogative VMI 124 can be used to log a DOM element using the element's path in the HTML tree.
- the DOM path ⁇ 2,5 ⁇ represents the DOM node that is found by examining the second child of the ⁇ html> tag, and the fifth child of that tag.
- An event loop of the script-based virtual machine 202 can log each event.
- a type of an event can be a string such as “mouseclick”, and can be logged.
- a target node of an event can be logged using object identifiers or DOM paths.
- a callback function of an event can be logged as the integer index of the callback in a callback list of the target node.
- timers do not have an event object; timers have a callback function.
- timers have a callback function.
- the timer's unique identifier can be logged.
- the interrogative VMI 124 can use this identifier to lookup the callback function associated with the timer during replay.
- Event loop to log event schedules 1. while (webpageIsOpen) ⁇ 2.
- var ev getNextEvent( ); 3. log(browser.getGUIChanges( )); 4. log(ev); 5. dispatchEvent(ev.callback, ev.args); 6. ⁇
- GUI changes can be logged at line 3 and events can be logged at line 4.
- the event loop can ignore real events that are generated by the browser. Instead, the script-based virtual machine 202 can control script execution directly, using the event log.
- the event loop of the script-based virtual machine 202 can re-execute a script during replay.
- scripting language code can force updates to a state of the renderer component 210 (e.g., by dynamically adding an image to the DOM tree).
- an update to the renderer component 210 may not be initiated by an execution context. For example, if the user types a string into a textbox, or selects an item in a drop-down list, a state of the renderer component 210 may be updated.
- the interrogative VMI 124 can be used to capture these state changes in the event log.
- the renderer component 210 can be frozen while an execution context is executing an event handler; during this time, scripting language code can modify a state of the renderer component 210 .
- GUI changes that are not initiated by an execution context can occur between events.
- the script-based virtual machine 202 can log DOM changes that occur between events. Since the DOM is a tree that mirrors an HTML structure of a page, the interrogative VMI 124 can log the DOM changes as a tree diff. At replay time, the script-based virtual machine 202 can replay the changes on live GUI objects.
- a benefit of using a tree diff is that the event log need not record an intermediate state between events, as that state is irrelevant to deterministic program replay.
- This design leads to shorter logs than a na ⁇ ve approach that logs every individual change to the web page's state. For example, consider a scenario where a user types “Jeff” into a text field and hits a “Submit” button that triggers an event. No scripting language code runs while the user is typing into the text field. The text field has four intermediate states corresponding to each additional character added to the text field, but only the full entry is utilized. In this scenario, the log includes one entry for that text field with the string “Jeff”.
- CSS/SVG Animations Modern browsers typically execute CSS/SVG animations in parallel with script execution.
- the interrogative VMI 124 extensions can be used to pause animations while scripting language code executes, and to log the tick counts of active animations as they play. While this changes the semantics of animations in a target browser, it is noted that some browsers do not play animations in parallel with script execution. During replay, the interrogative VMI 124 extensions can be used to explicitly reset animations to appropriate tick counts before dispatching an event from the log.
- a global window object can include a number of properties related to the status of the GUI, such as scrollbar position, currently active DOM element, and size of the browser viewport.
- the interrogative VMI 124 logs these values prior to event execution, and resets these values prior to dispatching a replayed event.
- DOM elements can refer to external network resources.
- img elements refer to images
- iframe elements refer to HTML files.
- the interrogative VMI 124 can record external network fetches at logging time, and return the logged data at replay time.
- GUI may not be the only source of nondeterminism for an execution context. Below are various examples of non-GUI sources of nondeterminism.
- the interrogative VMI 124 can log return values from the nondeterministic functions Date( ) and Math.random( ).
- the interrogative VMI 124 can also log read values from the localStorage interface and from Cookies. During replay, the interrogative VMI 124 interposes on these interfaces to return logged values.
- Timer IDs Each timer created with the setInterval interface and the setTimeout interface can have a unique identifier associated with it, which the renderer component 210 can determine.
- the interrogative VMI 124 can log identifier values returned from these interfaces. During replay, the interrogative VMI 124 can interpose on these interfaces to return the same identifiers, and interact with the VMI's timer extensions to update its active timer state.
- XMLHttpRequest Like DOM elements, XMLHttpRequest objects commonly are frozen while an event executes.
- the interrogative VMI 124 can maintain a list of the live XMLHttpRequest objects, and check them for property changes before a new event is dispatched. If an object's properties have changed, the event log records the changes as a diff from the object's previous state. During replay, the interrogative VMI 124 can use the hosted object map to find the relevant XMLHttpRequest and apply the deltas from the log before handing the associated event to an execution context.
- the script-based virtual machine 202 can be configured to perform a reverse execution of the computer-executable program to a causal event based on the snapshot(s) and/or the event logs.
- the script-based virtual machine 202 can be a JavaScript virtual machine that can include the time travel debugger 126 .
- the interrogative VMI 124 and the time travel debugger 126 can enable a reverse-step to a causal event.
- JavaScript programs frequently utilize callbacks via timers, XHR, promises (e.g., from the ECMAScript Harmony (6th Edition) (ES6) standard), etc. to implement event handling. Similar features exist in other programming languages such as the async construct for C#.
- snapshots and/or event logs can include identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program.
- identities of the callbacks and the corresponding logical times at which the callbacks are set during the execution can be stored.
- the identities of the callbacks and the corresponding logical times can be exposed to the script-based virtual machine 202 via the interrogative VMI 124 during the execution of the computer-executable program.
- the time travel debugger 126 can replay at least a portion of the execution of the computer-executable program based at least in part on the identities of the callbacks and the corresponding logical times. For instance, the time travel debugger 126 can perform a reverse execution of the computer-executable program to a causal event based at least in part on the identities of the callbacks and the corresponding logical times.
- the system 400 includes the virtual machine 110 , the computer-executable program 108 , the snapshots 116 , and the event logs 122 .
- the virtual machine 110 can include the execution component 112 , the snapshot component 114 , the event logger component 120 , and the time travel debugger 126 .
- the time travel debugger 126 can be a time travel debugger for a web browser (e.g., the browser system 128 ).
- the time travel debugger 126 can receive an input (e.g., from a developer) that sets a breakpoint in the computer-executable program 108 .
- the time travel debugger 126 can enable traveling backwards in time from that point to previously executed statements.
- Conventional time travel debuggers often trade replay fidelity for performance, or vice versa.
- the time travel debugger 126 can provide both replay fidelity and performance.
- the time travel debugger 126 can handle interactions with black boxes while still providing efficient logging and replay.
- the time travel debugger 126 can use the snapshots 116 captured by the snapshot component 114 and the event logs 122 captured by the event logger component 120 .
- the time travel debugger 126 can reinflate a snapshot S to return to a time that is represented by S.
- the time travel debugger 126 can load the last snapshot temporally preceding t, and then replay the event logs 122 until t is reached.
- the time travel debugger 126 can enable the event logger component 120 to capture the nondeterministic event logs 122 and can enable the snapshot component 114 to create snapshots 116 (e.g., at regular intervals, etc.).
- the snapshots 116 can be created at quiescent points between events; since handlers may run for a few milliseconds, the snapshots 116 can be captured at regular intervals.
- the snapshot interval can set an upper bound on a cost to seek to an arbitrary point in the execution of the computer-executable program 108 .
- the time travel debugger 126 can include an analysis component 402 configured to evaluate latency of time travel operations. Based on the latency, the analysis component 402 can cause the snapshot component 114 to record one or more additional snapshots of the virtual machine 110 during replay of the execution of the computer-executable program 108 . If the snapshot interval is too large, jumping through time can be slow, since the time travel debugger 126 may have to replay many events to reach the desired execution point. However, if the time travel debugger 126 records too many snapshots during normal program execution, the computer-executable program 108 may suffer poor performance. Thus, at replay time, the analysis component 402 can be configured to opportunistically cause the snapshot component 114 to generate snapshots to reduce the latency of future time travel operations.
- the analysis component 402 can cause the snapshot component 114 to generate a new snapshot at an event that more closely precedes t. This optimization can be based on the common debugging scenario in which a developer explores a set of program states that are temporally nearby.
- the time travel debugger 126 can repeatedly inflate and replay from the same snapshot as the developer interacts with debugger features like step back, which returns to a previously executed statement (e.g., in a script, etc.). If the computer-executable program 108 includes a large amount of state, full snapshot inflation may introduce developer-visible delays.
- the time travel debugger 126 can avoid restoring the entire heap, and instead roll back the memory pages that changed during replay from the last snapshot.
- the claimed subject matter is not limited to the foregoing example.
- the time travel debugger 126 can provide a variety of reverse-facing complements to conventional debugger features. Below, implementation of these features atop the interrogative VMI 124 is described.
- the time travel debugger 126 can employ various interrogative methods to introspect execution of the computer-executable program 108 at the level of individual statements. As set forth below, the time travel debugger 126 can time travel to a particular basic block, a particular statement within that block (or to the last statement of the basic block that jumped to the current block), and so forth.
- Time travel debugger 126 can return to previous execution states using the interrogative VMI 124 , the time travel debugger 126 also can pause execution at an appropriate point during a replayed event handler.
- Existing debuggers commonly allow developers to place conditional breakpoints at specific program statements; in contrast, the time travel debugger 126 can allow for breakpoints to be placed at a desired logical time during execution.
- the interrogative VMI 124 introduces an additional interrogative interface: the interrogative VMI 124 can expose the number of times that a basic block has executed. The time travel debugger 126 can use these logical timestamps in conditional breakpoints to determine when to pause execution during time travel backwards to a particular basic block.
- the time travel debugger 126 can represent logical time as a two-tuple, where the first element is a function call count from the start of program execution, and the second element is the basic block count within the current function call. With this design, the time travel debugger 126 tracks function call counts through the lifetime of the computer-executable program 108 ; however, basic block counts can be discarded once a function call terminates. Function call counts can be included in state snapshots, and can be reset when the time travel debugger 126 loads a snapshot.
- the time travel debugger 126 can further include a step back component 404 configured to identify a previously executed statement prior in the computer-executable program 108 .
- the previously executed statement can be prior to a breakpoint.
- the step back component 404 can be configured to identify the previously executed statement based on one or more of the snapshots 116 and at least a portion of the event logs 122 . Based on such identification, the step back component 404 can provide various step back functionality.
- the previously executed statement is the previous statement in the basic block. However, when the previous statement is a function call, the previously executed statement is the last statement to execute in the called function.
- the interrogative VMI 124 can expose a location and logical time of the previous jump or return statement. If a current statement is at the start of a basic block or follows a function call, then the previous statement is the previous jump or return statement. Otherwise, the previous statement is the previous statement in the current basic block.
- step back component 404 Examples of debugger features that can be provided by the step back component 404 include step back, step back over, and step back out of.
- Step back complements step forward, and lets a developer return to a previously-executed program statement.
- the step back component 404 places a time-aware breakpoint on the previously executed program statement. Then, the step back component 404 replays execution from the previous snapshot that is closest to the logical time of the breakpoint.
- Step back over complements step over, and lets a developers return to a previously executed program statement in a current function.
- the step back component 404 places a time-aware breakpoint on the previous program statement in the current basic block at the current logical time, and replays execution from the nearest snapshot. If the current statement is the first statement in its basic block, then a jump immediately preceded it; in this case, step back over has the same behavior as step back.
- the step back component 404 places a time-aware breakpoint on the call site of the current function using the logical time associated with the caller's stack frame. Then, the step back component 404 replays execution from the previous snapshot closest to the logical time of the breakpoint.
- the time travel debugger 126 can include a reverse execute component 406 configured to perform a reverse execution of the computer-executable program 108 from a current breakpoint in the computer-executable program 108 to a previous breakpoint in the computer-executable program 108 .
- the reverse execute component 406 can be configured to perform the reverse execution based on one or more of the snapshots 116 and at least a portion of the event logs 122 . Reverse execute complements continue execution, and travels back to the previous breakpoint.
- the time travel debugger 126 may not know if/when each of the currently placed breakpoints will execute. Thus, the time travel debugger 126 does not know which will execute closest in logical time to the current program statement.
- the reverse execute component 406 can be configured to perform a temporal search to identify the previous breakpoint.
- the reverse execute component 406 further places a time-aware breakpoint at the current program statement, loads the nearest previous snapshot, and executes until the current program statement.
- the reverse execute component 406 can record the logical time and location of triggered breakpoints. A last breakpoint to trigger before the current program statement can be determined to be the time-travel destination by the reverse execute component 406 .
- the reverse execute component 406 If the reverse execute component 406 does not encounter a breakpoint, it performs the same procedure, but reinflates the program state from two snapshots away instead of one. This process repeats until the reverse execute component 406 finds a breakpoint that triggers, or reaches the beginning of execution. In the latter case, the program uses the first statement in program execution as the time-travel destination. Once the reverse execute component 406 identifies a time-travel destination, it places an appropriate time-aware breakpoint, and replays execution from the closest snapshot to that destination.
- FIGS. 5-6 illustrate exemplary methodologies relating to time travel debugging for a web browser. While the methodologies are shown and described as being a series of acts that are performed in a sequence, it is to be understood and appreciated that the methodologies are not limited by the order of the sequence. For example, some acts can occur in a different order than what is described herein. In addition, an act can occur concurrently with another act. Further, in some instances, not all acts may be required to implement a methodology described herein.
- the acts described herein may be computer-executable instructions that can be implemented by one or more processors and/or stored on a computer-readable medium or media.
- the computer-executable instructions can include a routine, a sub-routine, programs, a thread of execution, and/or the like.
- results of acts of the methodologies can be stored in a computer-readable medium, displayed on a display device, and/or the like.
- FIG. 5 illustrates a methodology 500 for performing time travel debugging.
- a computer-executable program can be executed.
- the computer-executable program can be executable under control of a virtual machine.
- the virtual machine interacts with a browser system during execution of the computer-executable program.
- nondeterministic events can be logged via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program.
- the nondeterministic events can be logged as part of event logs.
- the interrogative VMI is between the virtual machine and the browser system.
- snapshots of the virtual machine can be captured during the execution of the computer-executable program.
- the snapshots can be captured via the interrogative VMI.
- at least a portion of the execution of the computer-executable program can be replayed based at least in part on a snapshot and at least a portion of the event logs.
- FIG. 6 illustrates another methodology 600 for performing time travel debugging.
- a computer-executable program can be executed.
- the computer-executable program can be executable under control of a virtual machine.
- the virtual machine interacts with a browser system during execution of the computer-executable program.
- identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program can be stored.
- the identities of the callbacks and the corresponding logical times can be exposed to the virtual machine via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program.
- VMI interrogative virtual machine interface
- the interrogative VMI is between the virtual machine and the browser system.
- at least a portion of the execution of the computer-executable program can be replayed based at least in part on the identities of the callbacks and the corresponding logical times.
- the computing device 700 may be used in a system that performs time travel debugging.
- the computing device 700 includes at least one processor 702 that executes instructions that are stored in a memory 704 .
- the instructions may be, for instance, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above.
- the processor 702 may access the memory 704 by way of a system bus 706 .
- the memory 704 may also store snapshots, event logs, and so forth.
- the computing device 700 additionally includes a data store 708 that is accessible by the processor 702 by way of the system bus 706 .
- the data store 708 may include executable instructions, snapshots, event logs, etc.
- the computing device 700 also includes an input interface 710 that allows external devices to communicate with the computing device 700 .
- the input interface 710 may be used to receive instructions from an external computer device, from a user, etc.
- the computing device 700 also includes an output interface 712 that interfaces the computing device 700 with one or more external devices.
- the computing device 700 may display text, images, etc. by way of the output interface 712 .
- the external devices that communicate with the computing device 700 via the input interface 710 and the output interface 712 can be included in an environment that provides substantially any type of user interface with which a user can interact.
- user interface types include graphical user interfaces, natural user interfaces, and so forth.
- a graphical user interface may accept input from a user employing input device(s) such as a keyboard, mouse, remote control, or the like and provide output on an output device such as a display.
- a natural user interface may enable a user to interact with the computing device 700 in a manner free from constraints imposed by input device such as keyboards, mice, remote controls, and the like. Rather, a natural user interface can rely on speech recognition, touch and stylus recognition, gesture recognition both on screen and adjacent to the screen, air gestures, head and eye tracking, voice and speech, vision, touch, gestures, machine intelligence, and so forth.
- the computing device 700 may be a distributed system. Thus, for instance, several devices may be in communication by way of a network connection and may collectively perform tasks described as being performed by the computing device 700 .
- FIG. 8 a high-level illustration of an exemplary computing system 800 that can be used in accordance with the systems and methodologies disclosed herein is illustrated.
- the computing system 800 can be or include the computing system 102 .
- the computing system 102 can be or include the computing system 800 .
- the computing system 800 includes a plurality of server computing devices, namely, a server computing device 802 , . . . , and a server computing device 804 (collectively referred to as server computing devices 802 - 804 ).
- the server computing device 802 includes at least one processor and a memory; the at least one processor executes instructions that are stored in the memory.
- the instructions may be, for instance, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above.
- at least a subset of the server computing devices 802 - 804 other than the server computing device 802 each respectively include at least one processor and a memory.
- at least a subset of the server computing devices 802 - 804 include respective data stores.
- Processor(s) of one or more of the server computing devices 802 - 804 can be or include the processor 104 . Further, a memory (or memories) of one or more of the server computing devices 802 - 804 can be or include the memory 106 . Moreover, a data store (or data stores) of one or more of the server computing devices 802 - 804 can be or include the data store 118 .
- the computing system 800 further includes various network nodes 806 that transport data between the server computing devices 802 - 804 .
- the network nodes 802 transport data from the server computing devices 802 - 804 to external nodes (e.g., external to the computing system 800 ) by way of a network 808 .
- the network nodes 802 also transport data to the server computing devices 802 - 804 from the external nodes by way of the network 808 .
- the network 808 for example, can be the Internet, a cellular network, or the like.
- the network nodes 806 include switches, routers, load balancers, and so forth.
- a fabric controller 810 of the computing system 800 manages hardware resources of the server computing devices 802 - 804 (e.g., processors, memories, data stores, etc. of the server computing devices 802 - 804 ).
- the fabric controller 810 further manages the network nodes 806 .
- the fabric controller 810 manages creation, provisioning, de-provisioning, and supervising of virtual machines instantiated upon the server computing devices 802 - 804 .
- a computing system comprising: at least one processor; and memory that comprises a virtual machine that is executable by the processor, the virtual machine comprising: an execution component configured to execute a computer-executable program; an event logger component configured to log nondeterministic events during execution of the computer-executable program as part of event logs, the event logger component further configured to log the nondeterministic events via an interrogative virtual machine interface (VMI), the interrogative VMI being between the virtual machine and a browser system; a snapshot component configured to record a sequence of snapshots of the virtual machine during the execution of the computer-executable program, the snapshot component further configured to record the snapshots via the interrogative VMI; and a time travel debugger configured to replay at least a portion of the execution of the computer-executable program based at least in part on a snapshot from the sequence of snapshots and at least a portion of the event logs.
- VMI virtual machine interface
- Example 1 The computing system according to Example 1, wherein the interrogative VMI enables the snapshots and the event logs to be semantically complete.
- a tick count associated with an animation is exposed to the virtual machine via the interrogative VMI
- the browser system further comprises a renderer component configured to perform the animation and associate the tick count with the animation, the tick count being indicative of how close the animation is to a final repaint.
- the event logger component further configured to use the interrogative VMI to log: an event that is scheduled; a Document Object Model (DOM) tree difference between events for a DOM change; a tick count associated with an animation; a value change for a window state; a value from a synchronous source; and a timer identifier.
- DOM Document Object Model
- the time travel debugger further configured to: identify the snapshot from the sequence of snapshots, the snapshot temporally preceding a time t; load the snapshot that temporally preceded the time t; and replay the event logs from the snapshot to the time t.
- the time travel debugger further configured to perform a reverse execution of the computer-executable program to a causal event based at least in part on the snapshot and the portion of the events logs.
- the time travel debugger further comprising an analysis component configured to: evaluate latency of time travel operations; and based on the latency, cause the snapshot component to record an additional snapshot of the virtual machine during the replay of the portion of the execution of the computer-executable program.
- the time travel debugger further comprising a reverse execute component configured to perform a reverse execution of the computer-executable program from a current breakpoint in the computer-executable program to a previous breakpoint in the computer-executable program, the reverse execute component configured to perform the reverse execution based at least in part on the snapshot and the portion of the event logs.
- the time travel debugger further comprising a step back component configured to identify a previously executed statement prior to a breakpoint in the computer-executable program, the step back component configured to identify the previously executed statement based at least in part on the snapshot and the portion of the event logs.
- a method of performing time travel debugging comprising: executing a computer-executable program, the computer-executable program being executable under control of a virtual machine, the virtual machine interacts with a browser system during execution of the computer-executable program; logging nondeterministic events via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program, the nondeterministic events being logged as part of event logs, the interrogative VMI being between the virtual machine and the browser system; capturing snapshots of the virtual machine during the execution of the computer-executable program, the snapshots being captured via the interrogative VMI; and replaying at least a portion of the execution of the computer-executable program based at least in part on a snapshot and at least a portion of the event logs.
- VMI virtual machine interface
- Example 15 further comprising utilizing the interrogative VMI to log: an event that is scheduled; a Document Object Model (DOM) tree difference between events for a DOM change; a tick count associated with an animation; a value change for a window state; a value from a synchronous source; and a timer identifier.
- DOM Document Object Model
- Example 15-16 further comprising replaying the portion of the execution of the computer-executable program based on identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program, wherein at least one of the snapshots or the event logs comprise the identities of the callbacks and the corresponding logical times.
- replaying the portion of the execution of the computer-executable program further comprising: identifying the snapshot from the snapshots, the snapshot temporally preceding a time t; loading the snapshot that temporally preceded the time t; and replaying the event logs from the snapshot to the time t.
- a method of performing time travel debugging comprising: executing a computer-executable program, the computer-executable program being executable under control of a virtual machine, the virtual machine interacts with a browser system during execution of the computer-executable program; storing identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program, wherein the identities of the callbacks and the corresponding logical times are exposed to the virtual machine via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program, the interrogative VMI being between the virtual machine and the browser system; and replaying at least a portion of the execution of the computer-executable program based at least in part on the identities of the callbacks and the corresponding logical times.
- VMI virtual machine interface
- Example 19 replaying the portion of the execution of the computer-executable program further comprising performing a reverse execution of the computer-executable program to a causal event based at least in part on the identities of the callbacks and the corresponding logical times.
- the terms “component” and “system” are intended to encompass computer-readable data storage that is configured with computer-executable instructions that cause certain functionality to be performed when executed by a processor.
- the computer-executable instructions may include a routine, a function, or the like. It is also to be understood that a component or system may be localized on a single device or distributed across several devices.
- Computer-readable media includes computer-readable storage media.
- a computer-readable storage media can be any available storage media that can be accessed by a computer.
- such computer-readable storage media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store desired program code in the form of instructions or data structures and that can be accessed by a computer.
- Disk and disc include compact disc (CD), laser disc, optical disc, digital versatile disc (DVD), floppy disk, and blu-ray disc (BD), where disks usually reproduce data magnetically and discs usually reproduce data optically with lasers. Further, a propagated signal is not included within the scope of computer-readable storage media.
- Computer-readable media also includes communication media including any medium that facilitates transfer of a computer program from one place to another. A connection, for instance, can be a communication medium.
- the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave
- coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio and microwave
- the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio and microwave
- the functionality described herein can be performed, at least in part, by one or more hardware logic components.
- illustrative types of hardware logic components include Field-programmable Gate Arrays (FPGAs), Program-specific Integrated Circuits (ASICs), Program-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), etc.
Abstract
Various technologies described herein pertain to performing time travel debugging. A computer-executable program can be executed. The computer-executable program can be executable under control of a virtual machine. The virtual machine can interact with a browser system during execution of the computer-executable program. Moreover, nondeterministic events can be logged via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program. The nondeterministic events can be logged as part of event logs. Moreover, the interrogative VMI is between the virtual machine and the browser system. Further, snapshots of the virtual machine can be captured during the execution of the computer-executable program. The snapshots can be captured via the interrogative VMI. At least a portion of the execution of the computer-executable program can be replayed based at least in part on a snapshot and at least a portion of the event logs.
Description
- This application claims priority to U.S. Provisional Patent Application No. 62/143,435, filed on Apr. 6, 2015, and entitled “TIME TRAVEL DEBUGGING FOR BROWSER COMPONENTS”, the entirety of which is incorporated herein by reference.
- Developers commonly spend significant amounts of time debugging programs. Developers often apply the scientific method when debugging programs; for instance, a developer may observe behavior of a program on different inputs, first to reproduce a bug, then to localize the bug in source code of the program. Reproducing, localizing, and then fixing bugs typically involve forming and validating hypotheses about root causes of the bugs. A root cause of a bug is a first point at which a state of a program diverges from an intended state. To validate a hypothesis, a developer often halts program execution and examines the state of the program. Especially early in debugging, when the developer's query is still elusive, execution is commonly halted too soon or too late to validate a hypothesis. Overshooting (e.g., late halting of the execution of the program) can be expensive because returning to an earlier point in an execution of a program commonly involves restarting and re-running the program.
- A virtual machine can be useful for capturing a state of a program. For example, a virtualization layer can act as a boundary for encapsulating program state, which can enable snapshotting, migrating, and resuming complex, multi-level software applications. A virtual machine interface (VMI) of a virtual machine can provide an introspection point for logging events that affect program execution.
- Some conventional virtual machines, which virtualize at the x86-level, provide strong and efficient isolation. By virtualizing at the x86-level, these conventional virtual machines can provide precise snapshots that capture hardware-level information. However, with these conventional approaches, a full virtual machine snapshot can be on the order of hundreds of MBs in size, and an x86-level event log can grow on the order of hundreds of MBs per day.
- A debugger can be used to halt program execution and examine the state of the program (e.g., via a graphical user interface (GUI)). However, tool support for debugging has remained relatively unchanged for many years. Accordingly, the cost of restarting and re-running the program when a breakpoint is placed too late in the execution of the program remains.
- Described herein are various technologies that pertain to performing time travel debugging. A computer-executable program can be executed. The computer-executable program can be executable under control of a virtual machine. The virtual machine can interact with a browser system during execution of the computer-executable program. Moreover, nondeterministic events can be logged via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program. The nondeterministic events can be logged as part of event logs. Moreover, the interrogative VMI is between the virtual machine and the browser system. Further, snapshots of the virtual machine can be captured during the execution of the computer-executable program. The snapshots can be captured via the interrogative VMI. At least a portion of the execution of the computer-executable program can be replayed based at least in part on a snapshot and at least a portion of the event logs.
- The above summary presents a simplified summary in order to provide a basic understanding of some aspects of the systems and/or methods discussed herein. This summary is not an extensive overview of the systems and/or methods discussed herein. It is not intended to identify key/critical elements or to delineate the scope of such systems and/or methods. Its sole purpose is to present some concepts in a simplified form as a prelude to the more detailed description that is presented later.
-
FIG. 1 illustrates a functional block diagram of an exemplary computing system that performs time travel debugging. -
FIG. 2 illustrates a functional block diagram of an exemplary system that employs interrogative virtualization to enable time travel debugging. -
FIG. 3 illustrates a functional block diagram of another example of a script-based virtual machine. -
FIG. 4 illustrates a functional block diagram of an exemplary system that performs time travel debugging. -
FIG. 5 is a flow diagram that illustrates an exemplary methodology for performing time travel debugging. -
FIG. 6 is a flow diagram that illustrates an exemplary methodology for performing time travel debugging. -
FIG. 7 illustrates an exemplary computing device. -
FIG. 8 illustrates an exemplary computing system. - Various technologies pertaining to performing time travel debugging with browser components are now described with reference to the drawings, wherein like reference numerals are used to refer to like elements throughout. In the following description, for purposes of explanation, numerous specific details are set forth in order to provide a thorough understanding of one or more aspects. It may be evident, however, that such aspect(s) may be practiced without these specific details. In other instances, well-known structures and devices are shown in block diagram form in order to facilitate describing one or more aspects. Further, it is to be understood that functionality that is described as being carried out by certain system components may be performed by multiple components. Similarly, for instance, a component may be configured to perform functionality that is described as being carried out by multiple components.
- Moreover, the term “or” is intended to mean an inclusive “or” rather than an exclusive “or.” That is, unless specified otherwise, or clear from the context, the phrase “X employs A or B” is intended to mean any of the natural inclusive permutations. That is, the phrase “X employs A or B” is satisfied by any of the following instances: X employs A; X employs B; or X employs both A and B. In addition, the articles “a” and “an” as used in this application and the appended claims should generally be construed to mean “one or more” unless specified otherwise or clear from the context to be directed to a singular form.
- Referring now to the drawings,
FIG. 1 illustrates acomputing system 102 that performs time travel debugging. Thecomputing system 102 includes at least oneprocessor 104 andmemory 106. The at least oneprocessor 104 is configured to execute instructions loaded into the memory 106 (e.g., system(s) and/or component(s) loaded into thememory 106 are executable by the processor 104). As described in greater detail herein, thememory 106 includes instructions configured to perform time travel debugging for abrowser system 128. - According to various examples, the
computing system 102 can be or include a computing device. Pursuant to various illustrations, the computing device can be a desktop computing device, a mobile computing device (e.g., a laptop computing device, a mobile telephone, a tablet computing device, a wearable computing device, a handheld computing device, a portable gaming device, a personal digital assistant (PDA), etc.), a gaming console, a set-top box, an in-vehicle communications and infotainment system, or the like. In accordance with other examples, thecomputing system 102 can be or include one or more server computing devices. For instance, thecomputing system 102 can be or include one or more datacenters, where a datacenter includes a plurality of server computing devices. Additionally or alternatively, thecomputing system 102 can be a distributed computing system. - The
memory 106 of thecomputing system 102 includes a computer-executable program 108 and a virtual machine (VM) 110 (e.g., a managed runtime, etc.). The computer-executable program 108 can include a sequence of instructions that are executable under control of thevirtual machine 110. Thevirtual machine 110 can compile and/or interpret the computer-executable program 108 for theprocessor 104 and perform the instructions included in the computer-executable program 108. - The
memory 106 further includes the browser system 128 (e.g., a web browser). Thebrowser system 128 can be configured to retrieve, present, and traverse information available on a network, in a file system (e.g., of thecomputing system 102 or a disparate computing system), or the like. Moreover, an interrogative virtual machine interface (VMI) 124 is an interface between thevirtual machine 110 and thebrowser system 128. Theinterrogative VMI 124 enables nondeterministic events to be exposed to thevirtual machine 110. Theinterrogative VMI 124 exposes minimal amounts of state belonging to otherwise opaque black box components. A minimal amount of state from a particular black box component can be a least amount of state for accurately snapshotting and logging events for such black box component. - The
virtual machine 110 can be a process virtual machine that runs as an application inside a host operating system and supports a process. Thevirtual machine 110 can provide a platform-independent programming environment that abstracts details of the underlying hardware or operating system, and enables the computer-executable program 108 to be executed on differing platforms. - According to an example, the computer-
executable program 108 can be or include a script written in a scripting language (e.g., JavaScript, etc.); following this example, the script can be interpreted and executed by thevirtual machine 110. However, it is contemplated that other types of computer-executable programs and other types of virtual machines (other types of managed runtimes) are intended to fall within the scope of the hereto appended claims (e.g., a computer-executable program written in the Java programming language and Java web toolkit (JWt), a computer-executable program written in the C# programming language and Windows Presentation Foundation (WPF), etc.). - The
virtual machine 110 includes anexecution component 112 that can be configured to receive the computer-executable program 108. Moreover, theexecution component 112 can be configured to execute the computer-executable program 108. - According to an example, the
execution component 112 can be or include an interpreter. According to an exemplary scenario, the interpreter can directly perform the instructions of the computer-executable program 108. In accordance with another exemplary scenario, the interpreter can translate the instructions of the computer-executable program 108 to an intermediate representation and can execute the intermediate representation. According to yet another exemplary scenario, the instructions of the computer-executable program 108 can include precompiled code, and the interpreter can execute such precompiled code (e.g., the precompiled code can be machine independent code). Moreover, it is contemplated that a combination of the foregoing exemplary scenarios can be implemented by the interpreter. Further, pursuant to an illustration, it is contemplated that the interpreter can be a bytecode interpreter; yet, other types of interpreters are intended to fall within the scope of the hereto appended claims. - By way of another example, the
execution component 112 can additionally or alternatively be or include a just-in-time (JIT) compiler. The JIT compiler can convert intermediate language instructions of the computer-executable program 108 to machine instructions for execution by theprocessor 104. Further, the JIT compiler can execute the machine instructions. - The
virtual machine 110 can further include asnapshot component 114 configured to record a sequence ofsnapshots 116 of the virtual machine 110 (e.g., VM snapshots) during execution of the computer-executable program 108 at various times. Thesnapshot component 114 can be configured to record thesnapshots 116 via theinterrogative VMI 124 Moreover, thesnapshots 116 recorded by thesnapshot component 114 can be stored in adata store 118 of thecomputing system 102. The computer-executable program 108, during execution by theexecution component 112, stores data in variables, which represent storage locations in the memory 106 (e.g., call stack, heap, etc.). At a given point during the execution of the computer-executable program 108, content of the storage locations in thememory 106 can be recorded as a snapshot of thevirtual machine 110. - According to an example, the
snapshots 116 in the sequence can be periodically recorded by thesnapshot component 114 at a predefined time interval. Pursuant to another example, a time interval at which thesnapshots 116 are sequentially recorded by thesnapshot component 114 can be dynamically adjusted; following this example, the time interval can be dynamically adjusted during the execution of the computer-executable program 108. - Moreover, the
virtual machine 110 can include anevent logger component 120 configured to log nondeterministic events during execution of the computer-executable program 108 as part of event logs 122. The event logs 122, for example, can be stored in thedata store 118. Theevent logger component 120 can log the nondeterministic events that affect execution of the computer-executable program 108 via theinterrogative VMI 124. For instance, thevirtual machine 110 can be extended to define theinterrogative VMI 124, which enables theevent logger component 120 to capture various nontraditional events. Moreover, the event logs 122 can enable a variety of debugging analyses. - Due to the
interrogative VMI 124, thesnapshot component 114 and theevent logger component 120 can efficiently capture application-level semantics in order to reduce the size of thesnapshots 116 and the event logs 122. By raising the abstraction level of theinterrogative VMI 124 to that of the application of interest, thesnapshot component 114 and/or theevent logger component 120 can ignore portions of architectural state in an operating system (OS) and the hardware when capturing thesnapshots 116 and/or the event logs 122. - According to an example, the
virtual machine 110 can be a runtime environment layered atop a lower-level runtime environment. Such virtualized interfaces can enable various useful services. For example, thevirtual machine 110 can hide sensitive low-level resources from untrusted applications (e.g., such resources can be hidden from the computer-executable program 108), and cause potentially dangerous operations to pass dynamic security checks. Moreover, if theevent logger component 120 of thevirtual machine 110 logs the nondeterministic data that thevirtual machine 110 exchanges with the computer-executable program 108, then the event logs 122 can later be used by atime travel debugger 126 to replay the execution of the computer-executable program 108; these replayed executions, for instance, can be useful for security forensics and debugging of the computer-executable program 108. Thevirtual machine 110 can also define an encapsulation boundary for a state of the computer-executable program 108 (e.g., thesnapshots 116 can be useful for suspend/resume services, and for migrating applications across different machines). - Various properties of the
interrogative VMI 124 are now described. Theinterrogative VMI 124 can reduce a size of a virtual machine state (in comparison to conventional low-level virtual machines). Smaller virtual machines are faster to snapshot, faster to load, and faster to transfer across a network as compared to larger virtual machines. In turn, this makes it cheaper to perform suspension, resumption, and migration of a virtual machine. Small virtual machines also allow datacenter operators to place more virtual machines on a single physical server, which allows for enhanced server utilization. - Moreover, the
interrogative VMI 124 can cause a size of thenondeterministic event logs 122 to be reduced (relative to conventional low-level virtual machines). For many debugging and forensics scenarios,static snapshots 116 of thevirtual machine 110 may provide insufficient context; thus, thesnapshots 116 can be supplemented with the event logs 122 that describe how thevirtual machine 110 evolves between thesnapshots 116. Small event logs 122, combined withsmall snapshots 116, make it feasible to store long-term execution traces for complex applications (e.g., the computer-executable program 108). - Further, the
interrogative VMI 124 can enable thesnapshots 116 and the event logs 122 to be semantically complete. Thesnapshots 116 and the event logs 122 can include information for understanding the execution history of the computer-executable program 108 by thevirtual machine 110. Thus, execution analyses can be performed without using heuristics for inferring application state (e.g., such heuristics may be fallible). - Moreover, the
interrogative VMI 124 enables efficient generation of thesnapshots 116 by thesnapshot component 114 and the event logs 122 by theevent logger component 120. Accordingly, snapshotting and event logging can be fast and can have low computational overheads due to the interrogative VMI 124 (e.g., as compared to snapshotting and event logging for conventional low-level virtual machines). - Interrogative virtualization is supported by the
interrogative VMI 124. A level of abstraction of theinterrogative VMI 124 for thevirtual machine 110 is raised as compared to some conventional VMIs for some traditional virtual machines; more particularly, theinterrogative VMI 124 is moved away from interfaces presented by the hardware or the operating system, and towards an application-level semantic interface. For example, managed language runtimes and application frameworks can mediate a program's interactions with the local machine and the outside world. Virtualizing at the application-visible level of abstraction allows large amounts of architectural state that is oftentimes captured by low-level approaches to be ignored. However, not all of the low-level state can be ignored as is common with conventional managed language runtimes and application frameworks. For example, a raw bitmap for a display may be hidden by the application-visible graphics interface, but this state may be needed for understanding the execution history of the computer-executable program 108. Thus, interrogative virtualization makes modifications to the high-level application interface, instead providing theinterrogative VMI 124 that exposes events to thevirtual machine 110 which are hidden from the computer-executable program 108. Thevirtual machine 110 can interrogate nominally black box components via theinterrogative VMI 124 to enable thesnapshot component 114 and theevent logger component 120 to capture the application-level semantics while safely ignoring many details at the hardware or operating system level. - Many traditional VMIs tend to be designed to provide efficient and strong isolation between different virtual machines. As a result, these traditional VMIs provide narrow, low-level interfaces to minimize the trusted computing base and leverage hardware support for virtualization. However, virtualizing at a low-level involves a trade-off: isolation becomes cheap, but other virtual machine operations become expensive. For instance, conventional virtual machine snapshots oftentimes are large because they include substantial amounts of architectural state. Further, execution traces commonly grow quickly due to the vast number of low-level nondeterministic events. Moreover, application-level program analysis is often overdetermined, since a conventional virtual machine commonly includes data from multiple layers in the software and hardware stack, when often the top layers (without the lower layers) enable understanding execution of a computer-executable program.
- In contrast to traditional VMIs, the
interrogative VMI 124 for thevirtual machine 110 can be high-level and wide enough to capture application semantics. Compared to low-level, narrow virtualization interfaces, theinterrogative VMI 124 can enable implementing various virtual machine operations using an order of magnitude less time and space. To provide strong, efficient isolation, theinterrogative VMI 124 can be nested within a low-level virtualization framework, which can provide security; thus, security need not be sacrificed for performance. - The
virtual machine 110 can also include the time travel debugger 126 (thetime travel debugger 126 can also be referred to as a time travel debugger component). Thetime travel debugger 126 can be configured to test and debug the computer-executable program 108. Thetime travel debugger 126 is a debugger that steps forwards and backwards through execution of a computer-executable program (e.g., the computer-executable program 108) during a debugging session. In contrast, conventional debuggers oftentimes tend to step forwards through execution of a computer-executable program during a debugging session, without being able to step backwards through such execution. For instance, thetime travel debugger 126 allows execution to be reversed during a debugging session (e.g., if a breakpoint is set too late so as to not require re-execution of a computer-executable program with the breakpoint moved to be earlier in time). Thetime travel debugger 126 supports forward and reverse debugging of the computer-executable program 108. As noted above, when the computer-executable program 108 is executed by theexecution component 112, thesnapshot component 114 can record thesnapshots 116 and theevent logger component 120 can record nondeterministic events in the event logs 122 to capture the execution of the computer-executable program 108. Thetime travel debugger 126 can be configured to replay the execution of the computer-executable program 108 by stepping the execution of the computer-executable program 108 both forwards and backwards in time. - The
time travel debugger 126 can be configured to replay at least a portion of the execution of the computer-executable program 108 based at least in part on a snapshot (from the snapshots 116) and at least a portion of the event logs 122. Using theinterrogative VMI 124, thetime travel debugger 126 can enable time travel debugging for thebrowser system 128. Conventionally, time travel debugging often is too expensive to run on production servers or on resource-limited end-user machines with poor network connections. - The
time travel debugger 126 can be configured to perform backwards-facing variants for traditional forward-facing operations like step-forward and step-out. By instrumenting theinterrogative VMI 124, theevent logger component 120 can log nondeterministic events (e.g., the event logs 122) and thesnapshot component 114 can capture thesnapshots 116 of thevirtual machine 110. Later, during a debugging session, thetime travel debugger 126 can be configured to travel to time t by identifying a snapshot from thesnapshots 116 that temporally precedes time t, loading the snapshot that temporally preceded time t, and then replaying the event logs 122 from the snapshot to the time t. For example, a most recent snapshot from thesnapshots 116 that occurred before t can be loaded by thetime travel debugger 126; however, it is contemplated that a differing snapshot from thesnapshots 116 that occurred before t can alternatively be loaded by thetime travel debugger 126. - By logging events and tracking state at the level of the
interrogative VMI 124, storage overheads can be reduced in comparison to systems that introspect at a lower level (e.g., x86 instructions, or systems calls and UNIX signals). With theinterrogative VMI 124, sizes of thesnapshots 116 of the state of thevirtual machine 110 and the nondeterministic event logs 122 can be decreased as compared to lower-level approaches. For instance, heap-intensive applications can have compressed snapshots that are less than 500 KB in size. Moreover, for interactive games and applications, the event logs may grow at about 1 KB per second. Thetime travel debugger 126 can also provide more robust, higher-fidelity replay than conventional systems that lack the vantage point of theinterrogative VMI 124, and which consequently rely on inference methods to reconstruct state that is readily available in the interrogative system as described herein. - The
virtual machine 110 and theinterrogative VMI 124 enable nondeterminism logging of event logs 122 and capturing ofsnapshots 116. Further, thesnapshots 116 and the event logs 122 can be device and address independent. According to an example, it is contemplated that thetime travel debugger 126, on a program bug, can report an error state as well as a last k-seconds of events before the bug. Pursuant to an illustration, thesnapshots 116 and the event logs 122 can be at the JavaScript/HTML level, which can be saved for later debugging or transmitted to another computing system. Moreover, the other computing system need not have the same version of JavaScript/HTML engines or operating system. However, the claimed subject matter is not limited to the foregoing illustration. - Turning to
FIG. 2 , illustrated is asystem 200 that employs interrogative virtualization to enable time travel debugging. Thesystem 200 includes a script-basedvirtual machine 202; thus, as set forth in the example ofFIG. 2 , thevirtual machine 110 can be the script-basedvirtual machine 202. The script-basedvirtual machine 202 can interpret and execute the computer-executable program 108. More particularly, the computer-executable program 108 can be a script written in a scripting language (e.g., JavaScript, etc.), and thus, the script-basedvirtual machine 202 can interpret and execute such script. Moreover, the script-basedvirtual machine 202 can include theexecution component 112, thesnapshot component 114, theevent logger component 120, and thetime travel debugger 126. - The
system 200 further includes thebrowser system 128. Thebrowser system 128 can include various components. As depicted, thebrowser system 128 can include astorage component 204, aruntime library 206, anetwork component 208, and arenderer component 210. However, it is contemplated that thebrowser system 128 may lack one or more of the foregoing components and/or may include differing components. Moreover, theinterrogative VMI 124 is an interface between the script-basedvirtual machine 202 and thebrowser system 128. - The script-based
virtual machine 202 can include one or more execution contexts. As illustrated, the script-basedvirtual machine 202 is shown as including anexecution context 212 and anexecution context 214. However, it is contemplated that the script-basedvirtual machine 202 can include more or less than two execution contexts. The execution contexts of the script-basedvirtual machine 202 are collectively referred to herein as execution contexts 212-214. Each of the execution contexts 212-214 can be single-threaded and event-driven. - According to an illustration, as the execution context 212 (or any of the other execution contexts 212-214) runs its initialization code, callback functions that respond to events are defined. After the initialization code terminates, subsequent code execution can be driven by reception of events and firing of associated handlers. Since the
execution context 212 is single-threaded, a call chain that is initiated by an event handler is atomic; once started, the call chain runs to completion, and at any given time, theexecution context 212 has at most one active call chain. Moreover, different execution contexts 212-214 can exchange data using an asynchronous, pass-by-value communication channel (e.g., postMessage( )). - The components of the browser system 128 (e.g., the
storage component 204, theruntime library 206, thenetwork component 208, therenderer component 210, etc.) can be event-driven black box components. These components can be black boxes because, from the perspective of the computer-executable program 108, such components hide their implementations behind opaque interfaces. However, the execution contexts 212-214 are event-driven, so the black box components can export event-driven interface(s) to interoperate with the computer-executable program 108. - The script-based
virtual machine 202 can include aninterface component 216 configured to interact with the black box components of thebrowser system 128 via exposed interfaces (e.g., application programming interfaces (APIs)) of the black box components. Accordingly, the black box components of thebrowser system 128 can be interrogated by theinterface component 216 of the script-basedvirtual machine 202 via theinterrogative VMI 124. - Pursuant to an example, the
renderer component 210 can be a black box component of thebrowser system 128. Internally, therenderer component 210 can be written in C++, and it may use multiple threads or processes to calculate visual layouts and update a bitmap. However, from the perspective of an execution context (e.g., one of the execution contexts 212-214, a frame in a web page), therenderer component 210 exposes a single-threaded, event-driven API through the Document Object Model (DOM). To receive notifications about changes to DOM state by therenderer component 210, the computer-executable program 108 can register callbacks which therenderer component 210 triggers when the relevant state changes. The computer-executable program 108 can modify DOM state through a variety of synchronous and asynchronous APIs. However, even the synchronous APIs can be implemented as remote procedure call (RPC) messages that trigger event handlers in therenderer component 210; to provide synchronous semantics, thebrowser system 128 can pause the caller until therenderer component 210 has responded to the RPC request. - The script-based
virtual machine 202 can include one or more message-driven execution contexts 212-214, some of which may be black boxes with respect to the computer-executable program 108. Other examples of black box components include the network component 208 (e.g., a network stack in the browser system 128) and the storage component 204 (e.g., database interfaces used by server-side scripting language frameworks). - Given the event-driven nature of the script-based
virtual machine 202, theinterrogative VMI 124 can include an aggregate set of event channels. By interposing on messages exchanged via these channels, the interactions between the various components in the script-basedvirtual machine 202 may be captured. However, black box components oftentimes do not generate events for various changes to internal state. For example, the computer-executable program 108 can request therenderer component 210 to perform a Cascading Style Sheets (CSS) animation that periodically modifies a user-visible DOM state. At any given moment, the computer-executable program 108 can synchronously request therenderer component 210 for a view of the DOM. However, these synchronous queries hide the fact that therenderer component 210 executes in parallel with the computer-executable program 108. Therenderer component 210 typically updates the visual display without triggering script-side notifications, meaning that the script-side view of the DOM can desynchronize from the true DOM state inside therenderer component 210. This may be sufficient if it is desired to isolate and analyze the execution contexts 212-214. However, if it is desired to isolate and analyze the complete script-based virtual machine 202 (for a client-side web page or a Node application), missing events can impact correctness, performance, or both. Moreover, the script-basedvirtual machine 202 may include multiple execution contexts 212-214 and black box components. It is to be appreciated that a debugger for a web page can produce erroneous results if it lacks sufficient insights into rendering events. Further, logging and replay can be more efficient when the VMI event interface is semantically complete, such as theinterrogative VMI 124. - To ensure this semantic completeness, the black box components can be modified so that these components export a wider variety of events. This approach is referred to herein as interrogative virtualization, and includes interrogating the black box components to reveal specific parts of their hidden states. Interrogative virtualization extends the virtualization interface itself to improve the performance or correctness of operations upon virtual machines.
- For example, if the script-based
virtual machine 202 runs inside of a web browser (e.g., the browser system 128), therenderer component 210 can be changed to report a tick count associated with an animation. Therenderer component 210 can be configured to perform the animation and associate the tick count with the animation, where the tick count can be indicative of how close the animation is to a final repaint. Following this example, the tick count associated with the animation can be exposed to the script-basedvirtual machine 202 via theinterrogative VMI 124. - According to another example, if the script-based
virtual machine 202 runs within a server-side Node deployment, the storage component 204 (e.g., the database stack) can be modified to enable logging objects that are read and written to storage. Pursuant to a further example, thenetwork component 208 can download an external resource (e.g., therenderer component 210 can cause thenetwork component 208 to download the external resource, etc.); following this example, an event indicative of the external resource being downloaded by thenetwork component 208 can be exposed to the script-basedvirtual machine 202 via theinterrogative VMI 124. By way of yet another example, a callback list managed by therenderer component 210 can be exposed to the script-basedvirtual machine 202 via theinterrogative VMI 124. -
FIG. 3 illustrates another example of the script-based virtual machine 202 (e.g., the script-basedvirtual machine 202 can be a JavaScript virtual machine, etc.). The script-basedvirtual machine 202 ofFIG. 3 again includes the execution contexts 212-214 (e.g., an execution context for abc.com and an execution context for xyz.com). Moreover, although not shown, it is contemplated that the script-basedvirtual machine 202 can further include theexecution component 112, thesnapshot component 114, theevent logger component 120, and/or thetime travel debugger 126. - The script-based
virtual machine 202 supports nested virtualization. In general, large interfaces may negatively impact security. Such interfaces can increase a threat surface that is visible to an attacker, and their rich semantics can cause defenders to reason about a variety of corner cases. Interrogative virtualization adds communication channels to the virtual interface, so at first glance, interrogative virtualization seems to negatively impact security—there appear to be more opportunities for an attacker to escape an isolation container of the script-basedvirtual machine 202. However, the application-visible execution interface need not be conflated with a structural isolation boundary. The former is the interface that applications directly invoke, whereas the latter is the interface at which isolation and security are enforced. - As shown in
FIG. 3 , nested virtualization can be used to layer the interrogative VMI 124 (e.g., with a rich, wide interface) atop a smaller, low-level VMI (e.g., a security monitor VMI 302) defined by a virtual machine monitor (VMM) 304 (e.g., a hypervisor). TheVMM 304 can provide services that allow multiple operating systems to execute on hardware of a computing system (e.g., the computing system 102). Isolation enforcement is performed by theVMM 304, but other management decisions involving the script-basedvirtual machine 202 are performed by aninterrogative VM VMM 304. Theinterrogative VMM 304 can be similar to a library OS for the VM; yet, since the interrogative interface is sufficiently expressive to capture the application-level semantics, the library OS's internal state need not be included in the snapshots (e.g., the snapshots 116) or the event logs (e.g., the event logs 122). For example, theinterrogative VMI 124 does not expose raw memory addresses, so even though theVMM 304 may internally manipulate raw addresses, those addresses are not mentioned in the event logs or the snapshots. By excluding unnecessary architectural state from theinterrogative VMI 124, sizes of snapshots and event logs can be reduced by an order of magnitude. - The
interrogative VMI 124 can be constructed by extending the script-basedvirtual machine 202 used by a web browser (e.g., the browser system 128). Interfaces (e.g., the interface component 216) of the script-basedvirtual machine 202 to black box components, such as thestorage component 204, theruntime library 206, the network component 208 (e.g., the network stack), and therenderer component 210, can be modified to include a number of interrogative APIs to expose hidden state. Using theinterrogative VMI 124, an efficient snapshotting mechanism (e.g., executed by the snapshot component 114) can be implemented for the script-basedvirtual machine 202; this can facilitate VM suspension, migration, and resumption. Further, theinterrogative VMI 124 can be augmented to record (e.g., via the event logger component 120) the nondeterministic events that enter and leave the script-basedvirtual machine 202. The result can be, for instance, a fully functionalinterrogative VMI 124 for the client-side of a web application. - Hidden state can be exposed via the
interrogative VMI 124. The script-basedvirtual machine 202 can allow scripting language code to perform computations. To allow scripting language code to access local storage, exchange network traffic, and interact with the display, the script-basedvirtual machine 202 can communicate with external input-output (I/O) modules. Runtime information about the IO stack as well as the script-basedvirtual machine 202 can be captured via theinterrogative VMI 124. Below are some examples that enable application-level semantics to be captured. - CSS/SVG Animation State: Browsers commonly use a dedicated thread to perform CSS and Scalable Vector Graphics (SVG) animations. These animations typically run in parallel with script execution, and once triggered, they conventionally run to completion (e.g., not paused or resumed by scripting language code).
- Internally, the
renderer component 210 can associate a tick count with each animation. The tick count represents how close the animation is to its final repaint. Therenderer component 210 can expose these tick counts to the script-basedvirtual machine 202 via theinterrogative VMI 124. The tick counts can be employed as logical clock values to synchronize the concurrent execution of the script-basedvirtual machine 202 and therenderer component 210. Moreover, therenderer component 210 can allow the script-basedvirtual machine 202 to pause or restart an animation from a given tick count via theinterrogative VMI 124. - Event Listeners: As described herein, the scripting language code can be event-driven. For instance, after a page's initialization code runs, subsequent code can be triggered by the arrival of events like key presses and mouse clicks. The scripting language code can register callback functions for events (e.g., using the addEventListener(evtName, callback) method). An application can register multiple callbacks for the same event.
- Callback lists are managed by the
renderer component 210; such callback lists typically cannot be accessed from a conventional virtual machine. In contrast, the script-basedvirtual machine 202 can access the callback lists managed by therenderer component 210 via theinterrogative VMI 124. At snapshot time, the script-basedvirtual machine 202 can use theinterrogative VMI 124 to enumerate and the callback lists and serialize such lists. At resurrection time, the script-basedvirtual machine 202 can use an interface of therenderer component 210 that restores the serialized lists. - External Resources: Objects in the DOM can refer to resources that are hosted on external servers. For example, img elements refer to images, and iframe elements refer to HTML documents. To fetch such external content, the
renderer component 210 can bypass the script-basedvirtual machine 202 and directly communicate with the network component 208 (e.g., the network stack). - Accordingly, the
network component 208 can expose a set of additional events to the script-basedvirtual machine 202 via theinterrogative VMI 124. Examples of such events exposed by thenetwork component 208 include an event that indicates when thenetwork component 208 has finished downloading a resource. This allows theinterrogative VMI 124 to be employed by the script-basedvirtual machine 202 to log the fetched value, as well as determine when the download completed with respect to other concurrent activities like execution of a computer-executable program (e.g., the computer-executable program 108). - Timers: Applications can spawn and cancel one-time or recurring timers. According to an example, a setTimeout interface can be used by the script-based
virtual machine 202 to spawn a one-time timer, a setInterval interface can be used by the script-basedvirtual machine 202 to spawn a recurring timer, a clearTimeout interface can be used by the script-basedvirtual machine 202 to cancel a one-time timer, and a clearInterval interface can be used by the script-basedvirtual machine 202 to cancel a recurring timer. Therenderer component 210, for instance, can manage these timers; yet, therenderer component 210 typically does not expose their state to conventional virtual machines. - These four interfaces can be interposed on from within the script-based
virtual machine 202 to keep track of and expose active timers and their associated callbacks. According to another example, therenderer component 210 can be modified to expose the timers to the script-basedvirtual machine 202 via theinterrogative VMI 124. By way of another example, the script-basedvirtual machine 202 can add new active timers when the application creates them and timestamp their creation, and remove them when the application clears them. Following this example, when a one-time timer fires (e.g., upon expiration of the timer), the script-basedvirtual machine 202 removes it from the active set. Moreover, pursuant to this example, when an interval timer fires, the script-basedvirtual machine 202 updates its timestamp. - State snapshots (e.g., captured by the
snapshot component 114 of the script-based virtual machine 202) are now described in greater detail. To capture a snapshot of the script-basedvirtual machine 202, thesnapshot component 114 can wait for each execution context 212-214 to quiesce. Each execution context 212-214 can be single-threaded, so quiescence can occur when the local event loop has finished executing an event handler; stack state need not be captured since the context has no outstanding call chains. Once the execution contexts 212-214 are paused, thesnapshot component 114 can capture black box state using the interrogative APIs of theinterrogative VMI 124. - DOM Elements: A DOM element may have a set of string properties, a nested tree of DOM elements, and event listeners. The
snapshot component 114 can capture this information using existing DOM interfaces and the VMI extensions. To resurrect the DOM state in a snapshot, each DOM object can be recreated using existing DOM interfaces (e.g., to create an element, to set an attribute, etc.). - In general, the
renderer component 210 can execute in parallel with the script-basedvirtual machine 202. However, therenderer component 210 can block during synchronous RPC exchanges with the script-basedvirtual machine 202. Accordingly, to avoid race conditions at snapshot time, the interface of therenderer component 210 can be extended to support a synchronous, no-op RPC that prevents therenderer component 210 from generating GUI events, repainting the screen, and so on. Using this no-op RPC, thesnapshot component 114 can pause therenderer component 210 before serializing the state of the script-basedvirtual machine 202. This ordering can mitigate the execution contexts 212-214 from including references to stale renderer-side state. - Canvas Context: Canvas elements in the DOM can have an associated context object that includes the visual state of the canvas. The context object can be retrievable using an interface that gets a context object of a canvas. The
snapshot component 114 can record each canvas's visual state as a bitmap. During snapshot inflation, the bitmap can be reapplied to restore the canvas to its previous state. - Heap: Managed languages often have garbage collectors that can efficiently walk the heap. The
snapshot component 114 can identify live scripting language objects and serialize such objects. Primitive values like numbers and strings can be serialized. Moreover, arrays and objects can be serialized as bags of properties. Object references (including references to DOM objects) can be rewritten to point to the target object's location in the snapshot. - Event Queue: When the
snapshot component 114 runs, execution contexts are quiescent. However, the contexts may have non-empty event queues. Each event can include one or more callbacks to invoke, and one or more arguments to pass to the callbacks. Thesnapshot component 114 can serialize this information and place it in the snapshot. - CSS/SVG Animation State: The
snapshot component 114 can record the tick count of active CSS and SVG animations. When the snapshot is later inflated, the interrogative interface can be used to resume each animation at the suspension-time tick count. - Timers: The
snapshot component 114 can calculate and record the remaining time left on each active timer, the interval duration for recurring timers, and each timer's associated callback. One-time timers can be restored during snapshot inflation using an interface that sets a timeout. For recurring timers, the interface that sets the timeout can be used for initiation to resume the interrupted recurrence. Further, an interface that sets an interval can be used to resume the normal interval. - Nondeterministic event logging (e.g., performed by the
event logger component 120 of the script-based virtual machine 202) is now described in greater detail. While snapshots depict the script-basedvirtual machine 202 at particular moments in time, the nondeterministic event logs describe how the script-basedvirtual machine 202 evolves between snapshots. Using theinterrogative VMI 124, event logs grow slowly because, compared to raw x86 code, the scripting language code can be more deterministic. Theevent logger component 120 can use theinterrogative VMI 124, during the execution of the computer-executable program, to log an event that is scheduled, a DOM tree difference between events for a DOM change, a tick count associated with an animation, a value change for a window state, a value from a synchronous source, and a timer identifier. - The following table provides an overview of the events that can be tracked via the
interrogative VMI 124. In the text below, these events are described in more detail. -
Category Representative APIs Log Strategy Event Scheduling DOM Events, timers, Event logging XMLHttpRequest DOM Changes Form fields, checkboxes DOM tree diffs between events CSS/SVG animation-* CSS Log animation tick before every Animations properties event, pause during events Window State Window size, scrollbar Log value changes before position every event External iframe src, img src Log data in I/O subsystem Resources Synchronous Date, Math.random Value logging Sources Timer IDs setTimeout, setInterval Value logging XMLHttpRequest XMLHttpRequest Object diffs between events Status - The
event logger component 120 can serialize black box object references. Some nondeterministic events can refer to objects that reside in a black box component. For example, the network component 208 (e.g., the network stack) can expose a Hypertext Transfer Protocol (HTTP) connection to the script-basedvirtual machine 202 using an XMLHttpRequest (XHR) object. When an execution context does var xhr=new XMLHttpRequest( ) thenetwork component 208 can create a new internal object, and then pass that C++ object from thenetwork component 208 to the script-basedvirtual machine 202. Such hosted objects have a scripting language wrapper, but can reside within the black box component. - Hosted objects can subsequently be referenced by events. For example, when HTTP data arrives, the
network component 208 can pass an event object to the execution context; the target property of the event can be the XMLHttpRequest object that was created via a new operator, where the new operator creates an instance of an object type. At logging time, the identity of the XMLHttpRequest object can be recorded in the event. According to an example, edge relationships between objects in a heap graph can be preserved. - Object Tagging: In general, a hosted object can be created via the new operator before it can appear in an event. For example, an XMLHttpRequest object can be created and initialized before it can generate network events. At logging time, the
interrogative VMI 124 interposes on the new operator and assigns a unique integer identifier to each hosted object. By interposing on the event interface, script-basedvirtual machine 202 can log the identifier of the hosted object in each event. - Later, at replay time, the
interrogative VMI 124 can be used by the script-basedvirtual machine 202 to assign identifiers as above; hosted objects can receive the same logging-time identifiers, since replay is deterministic. At replay time, theinterrogative VMI 124 also can be used by the script-basedvirtual machine 202 to maintain a map that associates an identifier with its hosted object. When replaying an event, the script-basedvirtual machine 202 can use theinterrogative VMI 124 to extract the hosted object identifier from the event log, fetch the associated hosted object from the map, and attach that hosted object to the event that is passed to the execution context. - DOM Paths: Object tagging typically does not work for DOM elements, since a DOM element can be referenced by an event without a prior scripting language call to the new operator. For example, HTML of a page can register a scripting language click handler for a button element. When the button is clicked, the browser can generate an event which references the button. Following this illustration, the execution context has not previously seen that DOM element, and thus, has not been tagged.
- To solve the foregoing, the
interrogative VMI 124 can be used to log a DOM element using the element's path in the HTML tree. For example, the DOM path {2,5} represents the DOM node that is found by examining the second child of the <html> tag, and the fifth child of that tag. - Moreover, during execution, various nondeterministic browser interfaces schedule events. As a result, the order of events is nondeterministic, and is to be controlled during program replay.
- Logging Events: An event loop of the script-based
virtual machine 202 can log each event. A type of an event can be a string such as “mouseclick”, and can be logged. Moreover, a target node of an event can be logged using object identifiers or DOM paths. A callback function of an event can be logged as the integer index of the callback in a callback list of the target node. - Unlike most events, timers do not have an event object; timers have a callback function. When a timer fires (e.g., at expiration of the timer), the timer's unique identifier can be logged. The
interrogative VMI 124 can use this identifier to lookup the callback function associated with the timer during replay. - Below is exemplary pseudocode of an unmodified, traditional event loop.
-
Traditional event loop 1. while (webpageIsOpen) { 2. var ev = getNextEvent( ); 3. dispatchEvent(ev.callback, ev.args); 4. } - In comparison, exemplary psuedocode of the event loop of the script-based
virtual machine 202 to log event schedules is now set forth. -
Event loop to log event schedules 1. while (webpageIsOpen) { 2. var ev = getNextEvent( ); 3. log(browser.getGUIChanges( )); 4. log(ev); 5. dispatchEvent(ev.callback, ev.args); 6. } - As set forth in the above pseudocode, GUI changes can be logged at line 3 and events can be logged at line 4.
- Replaying Events: During replay of the script-based
virtual machine 202, the event loop can ignore real events that are generated by the browser. Instead, the script-basedvirtual machine 202 can control script execution directly, using the event log. Below is exemplary pseudocode for the event loop of the script-basedvirtual machine 202 to re-execute a script during replay. -
Event loop for program re-execution 1. while (webpageIsOpen) { 2. applyGUIChanges(log.read( )); 3. var ev = log.read( ); 4. dispatchEvent(ev.callback, ev.args); 5. } - Moreover, scripting language code can force updates to a state of the renderer component 210 (e.g., by dynamically adding an image to the DOM tree). However, an update to the
renderer component 210 may not be initiated by an execution context. For example, if the user types a string into a textbox, or selects an item in a drop-down list, a state of therenderer component 210 may be updated. Theinterrogative VMI 124 can be used to capture these state changes in the event log. - DOM Elements: The
renderer component 210 can be frozen while an execution context is executing an event handler; during this time, scripting language code can modify a state of therenderer component 210. As a result, GUI changes that are not initiated by an execution context can occur between events. Accordingly, the script-basedvirtual machine 202 can log DOM changes that occur between events. Since the DOM is a tree that mirrors an HTML structure of a page, theinterrogative VMI 124 can log the DOM changes as a tree diff. At replay time, the script-basedvirtual machine 202 can replay the changes on live GUI objects. - A benefit of using a tree diff is that the event log need not record an intermediate state between events, as that state is irrelevant to deterministic program replay. This design leads to shorter logs than a naïve approach that logs every individual change to the web page's state. For example, consider a scenario where a user types “Jeff” into a text field and hits a “Submit” button that triggers an event. No scripting language code runs while the user is typing into the text field. The text field has four intermediate states corresponding to each additional character added to the text field, but only the full entry is utilized. In this scenario, the log includes one entry for that text field with the string “Jeff”.
- CSS/SVG Animations: Modern browsers typically execute CSS/SVG animations in parallel with script execution. The
interrogative VMI 124 extensions can be used to pause animations while scripting language code executes, and to log the tick counts of active animations as they play. While this changes the semantics of animations in a target browser, it is noted that some browsers do not play animations in parallel with script execution. During replay, theinterrogative VMI 124 extensions can be used to explicitly reset animations to appropriate tick counts before dispatching an event from the log. - Window State: A global window object can include a number of properties related to the status of the GUI, such as scrollbar position, currently active DOM element, and size of the browser viewport. Like with animations, the
interrogative VMI 124 logs these values prior to event execution, and resets these values prior to dispatching a replayed event. - External Resources: DOM elements can refer to external network resources. For example, img elements refer to images, and iframe elements refer to HTML files. Using the interrogative extensions to the
network component 208, theinterrogative VMI 124 can record external network fetches at logging time, and return the logged data at replay time. - It is further contemplated that the GUI may not be the only source of nondeterminism for an execution context. Below are various examples of non-GUI sources of nondeterminism.
- Synchronous sources: The
interrogative VMI 124 can log return values from the nondeterministic functions Date( ) and Math.random( ). Theinterrogative VMI 124 can also log read values from the localStorage interface and from Cookies. During replay, theinterrogative VMI 124 interposes on these interfaces to return logged values. - Timer IDs: Each timer created with the setInterval interface and the setTimeout interface can have a unique identifier associated with it, which the
renderer component 210 can determine. Theinterrogative VMI 124 can log identifier values returned from these interfaces. During replay, theinterrogative VMI 124 can interpose on these interfaces to return the same identifiers, and interact with the VMI's timer extensions to update its active timer state. - XMLHttpRequest: Like DOM elements, XMLHttpRequest objects commonly are frozen while an event executes. The
interrogative VMI 124 can maintain a list of the live XMLHttpRequest objects, and check them for property changes before a new event is dispatched. If an object's properties have changed, the event log records the changes as a diff from the object's previous state. During replay, theinterrogative VMI 124 can use the hosted object map to find the relevant XMLHttpRequest and apply the deltas from the log before handing the associated event to an execution context. - Pursuant to an example, the script-based
virtual machine 202 can be configured to perform a reverse execution of the computer-executable program to a causal event based on the snapshot(s) and/or the event logs. According to an illustration, the script-basedvirtual machine 202 can be a JavaScript virtual machine that can include thetime travel debugger 126. Theinterrogative VMI 124 and thetime travel debugger 126 can enable a reverse-step to a causal event. For instance, JavaScript programs frequently utilize callbacks via timers, XHR, promises (e.g., from the ECMAScript Harmony (6th Edition) (ES6) standard), etc. to implement event handling. Similar features exist in other programming languages such as the async construct for C#. When debugging these callbacks, a common challenge may be to understand why a particular function was set as a callback and what the call-stack was at that time. In a traditional debugger this information is typically lost by the time the callback code is executed. In contrast, the techniques set forth here can retain the logical time at which each callback is set, and what the callback is. By storing such logical time at which each callback is set and what the callback is, thetime travel debugger 126 can enable direct reverse executing to a causal source. Accordingly, the foregoing functionality can enable a developer to understand where the callback was registered and the state of the program at such point in time. - By way of illustration, snapshots and/or event logs can include identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program. Thus, the identities of the callbacks and the corresponding logical times at which the callbacks are set during the execution can be stored. The identities of the callbacks and the corresponding logical times can be exposed to the script-based
virtual machine 202 via theinterrogative VMI 124 during the execution of the computer-executable program. Further, thetime travel debugger 126 can replay at least a portion of the execution of the computer-executable program based at least in part on the identities of the callbacks and the corresponding logical times. For instance, thetime travel debugger 126 can perform a reverse execution of the computer-executable program to a causal event based at least in part on the identities of the callbacks and the corresponding logical times. - Now turning to
FIG. 4 , illustrated is asystem 400 that performs time travel debugging. Thesystem 400 includes thevirtual machine 110, the computer-executable program 108, thesnapshots 116, and the event logs 122. Thevirtual machine 110 can include theexecution component 112, thesnapshot component 114, theevent logger component 120, and thetime travel debugger 126. Thetime travel debugger 126 can be a time travel debugger for a web browser (e.g., the browser system 128). - The
time travel debugger 126 can receive an input (e.g., from a developer) that sets a breakpoint in the computer-executable program 108. Thetime travel debugger 126 can enable traveling backwards in time from that point to previously executed statements. Conventional time travel debuggers often trade replay fidelity for performance, or vice versa. In contrast, thetime travel debugger 126 can provide both replay fidelity and performance. By leveraging theinterrogative VMI 124, thetime travel debugger 126 can handle interactions with black boxes while still providing efficient logging and replay. - The
time travel debugger 126 can use thesnapshots 116 captured by thesnapshot component 114 and the event logs 122 captured by theevent logger component 120. Thetime travel debugger 126 can reinflate a snapshot S to return to a time that is represented by S. To return to a time t that is between two snapshots, thetime travel debugger 126 can load the last snapshot temporally preceding t, and then replay the event logs 122 until t is reached. - During execution of the computer-
executable program 108 by the execution component 112 (e.g., before a time travel debugging session has started), thetime travel debugger 126 can enable theevent logger component 120 to capture the nondeterministic event logs 122 and can enable thesnapshot component 114 to create snapshots 116 (e.g., at regular intervals, etc.). Thesnapshots 116 can be created at quiescent points between events; since handlers may run for a few milliseconds, thesnapshots 116 can be captured at regular intervals. The snapshot interval can set an upper bound on a cost to seek to an arbitrary point in the execution of the computer-executable program 108. - The
time travel debugger 126 can include ananalysis component 402 configured to evaluate latency of time travel operations. Based on the latency, theanalysis component 402 can cause thesnapshot component 114 to record one or more additional snapshots of thevirtual machine 110 during replay of the execution of the computer-executable program 108. If the snapshot interval is too large, jumping through time can be slow, since thetime travel debugger 126 may have to replay many events to reach the desired execution point. However, if thetime travel debugger 126 records too many snapshots during normal program execution, the computer-executable program 108 may suffer poor performance. Thus, at replay time, theanalysis component 402 can be configured to opportunistically cause thesnapshot component 114 to generate snapshots to reduce the latency of future time travel operations. By way of illustration, if thetime travel debugger 126 is time travelling towards t, and starts from a “far-away” snapshot (where distance is defined in terms of events), theanalysis component 402 can cause thesnapshot component 114 to generate a new snapshot at an event that more closely precedes t. This optimization can be based on the common debugging scenario in which a developer explores a set of program states that are temporally nearby. - When a snapshot exists that is close to t, returning to t can typically be instantaneous (or nearly instantaneous) from the perspective of a human developer. Further, the runtime cost of inflating a snapshot can be a few hundreds of milliseconds, and replaying an individual event may take a few milliseconds.
- According to an exemplary scenario, the
time travel debugger 126 can repeatedly inflate and replay from the same snapshot as the developer interacts with debugger features like step back, which returns to a previously executed statement (e.g., in a script, etc.). If the computer-executable program 108 includes a large amount of state, full snapshot inflation may introduce developer-visible delays. By way of example, in such a scenario, thetime travel debugger 126 can avoid restoring the entire heap, and instead roll back the memory pages that changed during replay from the last snapshot. However, the claimed subject matter is not limited to the foregoing example. - The
time travel debugger 126 can provide a variety of reverse-facing complements to conventional debugger features. Below, implementation of these features atop theinterrogative VMI 124 is described. Thetime travel debugger 126 can employ various interrogative methods to introspect execution of the computer-executable program 108 at the level of individual statements. As set forth below, thetime travel debugger 126 can time travel to a particular basic block, a particular statement within that block (or to the last statement of the basic block that jumped to the current block), and so forth. - Logical timestamps for basic blocks can be used. Although the
time travel debugger 126 can return to previous execution states using theinterrogative VMI 124, thetime travel debugger 126 also can pause execution at an appropriate point during a replayed event handler. Existing debuggers commonly allow developers to place conditional breakpoints at specific program statements; in contrast, thetime travel debugger 126 can allow for breakpoints to be placed at a desired logical time during execution. - To support logical time breakpoints, the
interrogative VMI 124 introduces an additional interrogative interface: theinterrogative VMI 124 can expose the number of times that a basic block has executed. Thetime travel debugger 126 can use these logical timestamps in conditional breakpoints to determine when to pause execution during time travel backwards to a particular basic block. - The
time travel debugger 126 can represent logical time as a two-tuple, where the first element is a function call count from the start of program execution, and the second element is the basic block count within the current function call. With this design, thetime travel debugger 126 tracks function call counts through the lifetime of the computer-executable program 108; however, basic block counts can be discarded once a function call terminates. Function call counts can be included in state snapshots, and can be reset when thetime travel debugger 126 loads a snapshot. - The
time travel debugger 126 can further include a step backcomponent 404 configured to identify a previously executed statement prior in the computer-executable program 108. For instance, the previously executed statement can be prior to a breakpoint. The step backcomponent 404 can be configured to identify the previously executed statement based on one or more of thesnapshots 116 and at least a portion of the event logs 122. Based on such identification, the step backcomponent 404 can provide various step back functionality. Within a particular basic block with no function calls, the previously executed statement is the previous statement in the basic block. However, when the previous statement is a function call, the previously executed statement is the last statement to execute in the called function. - To support the step back
component 404 with low overhead, theinterrogative VMI 124 can expose a location and logical time of the previous jump or return statement. If a current statement is at the start of a basic block or follows a function call, then the previous statement is the previous jump or return statement. Otherwise, the previous statement is the previous statement in the current basic block. - Examples of debugger features that can be provided by the step back
component 404 include step back, step back over, and step back out of. - Step back complements step forward, and lets a developer return to a previously-executed program statement. To implement step back, the step back
component 404 places a time-aware breakpoint on the previously executed program statement. Then, the step backcomponent 404 replays execution from the previous snapshot that is closest to the logical time of the breakpoint. - Step back over complements step over, and lets a developers return to a previously executed program statement in a current function. To implement step back over, the step back
component 404 places a time-aware breakpoint on the previous program statement in the current basic block at the current logical time, and replays execution from the nearest snapshot. If the current statement is the first statement in its basic block, then a jump immediately preceded it; in this case, step back over has the same behavior as step back. - Step back out of complements step out of, and travels back to a statement that called the current function. When implementing step back out of, the step back
component 404 places a time-aware breakpoint on the call site of the current function using the logical time associated with the caller's stack frame. Then, the step backcomponent 404 replays execution from the previous snapshot closest to the logical time of the breakpoint. - Moreover, the
time travel debugger 126 can include a reverse executecomponent 406 configured to perform a reverse execution of the computer-executable program 108 from a current breakpoint in the computer-executable program 108 to a previous breakpoint in the computer-executable program 108. The reverse executecomponent 406 can be configured to perform the reverse execution based on one or more of thesnapshots 116 and at least a portion of the event logs 122. Reverse execute complements continue execution, and travels back to the previous breakpoint. With reverse execution, thetime travel debugger 126 may not know if/when each of the currently placed breakpoints will execute. Thus, thetime travel debugger 126 does not know which will execute closest in logical time to the current program statement. - To implement reverse execute, the reverse execute
component 406 can be configured to perform a temporal search to identify the previous breakpoint. The reverse executecomponent 406 further places a time-aware breakpoint at the current program statement, loads the nearest previous snapshot, and executes until the current program statement. During execution, the reverse executecomponent 406 can record the logical time and location of triggered breakpoints. A last breakpoint to trigger before the current program statement can be determined to be the time-travel destination by the reverse executecomponent 406. - If the reverse execute
component 406 does not encounter a breakpoint, it performs the same procedure, but reinflates the program state from two snapshots away instead of one. This process repeats until the reverse executecomponent 406 finds a breakpoint that triggers, or reaches the beginning of execution. In the latter case, the program uses the first statement in program execution as the time-travel destination. Once the reverse executecomponent 406 identifies a time-travel destination, it places an appropriate time-aware breakpoint, and replays execution from the closest snapshot to that destination. -
FIGS. 5-6 illustrate exemplary methodologies relating to time travel debugging for a web browser. While the methodologies are shown and described as being a series of acts that are performed in a sequence, it is to be understood and appreciated that the methodologies are not limited by the order of the sequence. For example, some acts can occur in a different order than what is described herein. In addition, an act can occur concurrently with another act. Further, in some instances, not all acts may be required to implement a methodology described herein. - Moreover, the acts described herein may be computer-executable instructions that can be implemented by one or more processors and/or stored on a computer-readable medium or media. The computer-executable instructions can include a routine, a sub-routine, programs, a thread of execution, and/or the like. Still further, results of acts of the methodologies can be stored in a computer-readable medium, displayed on a display device, and/or the like.
-
FIG. 5 illustrates amethodology 500 for performing time travel debugging. At 502, a computer-executable program can be executed. The computer-executable program can be executable under control of a virtual machine. Moreover, the virtual machine interacts with a browser system during execution of the computer-executable program. At 504, nondeterministic events can be logged via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program. The nondeterministic events can be logged as part of event logs. Moreover, the interrogative VMI is between the virtual machine and the browser system. At 506, snapshots of the virtual machine can be captured during the execution of the computer-executable program. The snapshots can be captured via the interrogative VMI. At 508, at least a portion of the execution of the computer-executable program can be replayed based at least in part on a snapshot and at least a portion of the event logs. -
FIG. 6 illustrates anothermethodology 600 for performing time travel debugging. At 602, a computer-executable program can be executed. The computer-executable program can be executable under control of a virtual machine. Moreover, the virtual machine interacts with a browser system during execution of the computer-executable program. At 604, identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program can be stored. The identities of the callbacks and the corresponding logical times can be exposed to the virtual machine via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program. Moreover, the interrogative VMI is between the virtual machine and the browser system. At 606, at least a portion of the execution of the computer-executable program can be replayed based at least in part on the identities of the callbacks and the corresponding logical times. - Referring now to
FIG. 7 , a high-level illustration of anexemplary computing device 700 that can be used in accordance with the systems and methodologies disclosed herein is illustrated. For instance, thecomputing device 700 may be used in a system that performs time travel debugging. Thecomputing device 700 includes at least oneprocessor 702 that executes instructions that are stored in amemory 704. The instructions may be, for instance, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above. Theprocessor 702 may access thememory 704 by way of asystem bus 706. In addition to storing executable instructions, thememory 704 may also store snapshots, event logs, and so forth. - The
computing device 700 additionally includes adata store 708 that is accessible by theprocessor 702 by way of thesystem bus 706. Thedata store 708 may include executable instructions, snapshots, event logs, etc. Thecomputing device 700 also includes aninput interface 710 that allows external devices to communicate with thecomputing device 700. For instance, theinput interface 710 may be used to receive instructions from an external computer device, from a user, etc. Thecomputing device 700 also includes anoutput interface 712 that interfaces thecomputing device 700 with one or more external devices. For example, thecomputing device 700 may display text, images, etc. by way of theoutput interface 712. - It is contemplated that the external devices that communicate with the
computing device 700 via theinput interface 710 and theoutput interface 712 can be included in an environment that provides substantially any type of user interface with which a user can interact. Examples of user interface types include graphical user interfaces, natural user interfaces, and so forth. For instance, a graphical user interface may accept input from a user employing input device(s) such as a keyboard, mouse, remote control, or the like and provide output on an output device such as a display. Further, a natural user interface may enable a user to interact with thecomputing device 700 in a manner free from constraints imposed by input device such as keyboards, mice, remote controls, and the like. Rather, a natural user interface can rely on speech recognition, touch and stylus recognition, gesture recognition both on screen and adjacent to the screen, air gestures, head and eye tracking, voice and speech, vision, touch, gestures, machine intelligence, and so forth. - Additionally, while illustrated as a single system, it is to be understood that the
computing device 700 may be a distributed system. Thus, for instance, several devices may be in communication by way of a network connection and may collectively perform tasks described as being performed by thecomputing device 700. - Turning to
FIG. 8 , a high-level illustration of anexemplary computing system 800 that can be used in accordance with the systems and methodologies disclosed herein is illustrated. For instance, thecomputing system 800 can be or include thecomputing system 102. Additionally or alternatively, thecomputing system 102 can be or include thecomputing system 800. - The
computing system 800 includes a plurality of server computing devices, namely, aserver computing device 802, . . . , and a server computing device 804 (collectively referred to as server computing devices 802-804). Theserver computing device 802 includes at least one processor and a memory; the at least one processor executes instructions that are stored in the memory. The instructions may be, for instance, instructions for implementing functionality described as being carried out by one or more components discussed above or instructions for implementing one or more of the methods described above. Similar to theserver computing device 802, at least a subset of the server computing devices 802-804 other than theserver computing device 802 each respectively include at least one processor and a memory. Moreover, at least a subset of the server computing devices 802-804 include respective data stores. - Processor(s) of one or more of the server computing devices 802-804 can be or include the
processor 104. Further, a memory (or memories) of one or more of the server computing devices 802-804 can be or include thememory 106. Moreover, a data store (or data stores) of one or more of the server computing devices 802-804 can be or include thedata store 118. - The
computing system 800 further includesvarious network nodes 806 that transport data between the server computing devices 802-804. Moreover, thenetwork nodes 802 transport data from the server computing devices 802-804 to external nodes (e.g., external to the computing system 800) by way of anetwork 808. Thenetwork nodes 802 also transport data to the server computing devices 802-804 from the external nodes by way of thenetwork 808. Thenetwork 808, for example, can be the Internet, a cellular network, or the like. Thenetwork nodes 806 include switches, routers, load balancers, and so forth. - A
fabric controller 810 of thecomputing system 800 manages hardware resources of the server computing devices 802-804 (e.g., processors, memories, data stores, etc. of the server computing devices 802-804). Thefabric controller 810 further manages thenetwork nodes 806. Moreover, thefabric controller 810 manages creation, provisioning, de-provisioning, and supervising of virtual machines instantiated upon the server computing devices 802-804. - Various examples are now set forth.
- A computing system, comprising: at least one processor; and memory that comprises a virtual machine that is executable by the processor, the virtual machine comprising: an execution component configured to execute a computer-executable program; an event logger component configured to log nondeterministic events during execution of the computer-executable program as part of event logs, the event logger component further configured to log the nondeterministic events via an interrogative virtual machine interface (VMI), the interrogative VMI being between the virtual machine and a browser system; a snapshot component configured to record a sequence of snapshots of the virtual machine during the execution of the computer-executable program, the snapshot component further configured to record the snapshots via the interrogative VMI; and a time travel debugger configured to replay at least a portion of the execution of the computer-executable program based at least in part on a snapshot from the sequence of snapshots and at least a portion of the event logs.
- The computing system according to Example 1, wherein the interrogative VMI enables the snapshots and the event logs to be semantically complete.
- The computing system according to any of Examples 1-2, wherein the snapshots and the event logs are device and address independent.
- The computing system according to any of Examples 1-3, wherein a tick count associated with an animation is exposed to the virtual machine via the interrogative VMI, wherein the browser system further comprises a renderer component configured to perform the animation and associate the tick count with the animation, the tick count being indicative of how close the animation is to a final repaint.
- The computing system according to any of Examples 1-4, wherein a callback list managed by a renderer component of the browser system is exposed to the virtual machine via the interrogative VMI.
- The computing system according to any of Examples 1-5, wherein an event indicative of an external resource being downloaded by a network component of the browser system is exposed to the virtual machine via the interrogative VMI.
- The computing system according to any of Examples 1-6, wherein at least one of the snapshots or the event logs comprise identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program.
- The computing system according to any of Examples 1-7, during the execution of the computer-executable program, the event logger component further configured to use the interrogative VMI to log: an event that is scheduled; a Document Object Model (DOM) tree difference between events for a DOM change; a tick count associated with an animation; a value change for a window state; a value from a synchronous source; and a timer identifier.
- The computing system according to any of Examples 1-8, the time travel debugger further configured to: identify the snapshot from the sequence of snapshots, the snapshot temporally preceding a time t; load the snapshot that temporally preceded the time t; and replay the event logs from the snapshot to the time t.
- The computing system according to any of Examples 1-8, the time travel debugger further configured to perform a reverse execution of the computer-executable program to a causal event based at least in part on the snapshot and the portion of the events logs.
- The computing system according to any of Examples 1-10, the time travel debugger further comprising an analysis component configured to: evaluate latency of time travel operations; and based on the latency, cause the snapshot component to record an additional snapshot of the virtual machine during the replay of the portion of the execution of the computer-executable program.
- The computing system according to any of Examples 1-11, the time travel debugger further comprising a reverse execute component configured to perform a reverse execution of the computer-executable program from a current breakpoint in the computer-executable program to a previous breakpoint in the computer-executable program, the reverse execute component configured to perform the reverse execution based at least in part on the snapshot and the portion of the event logs.
- The computing system according to any of Examples 1-12, the time travel debugger further comprising a step back component configured to identify a previously executed statement prior to a breakpoint in the computer-executable program, the step back component configured to identify the previously executed statement based at least in part on the snapshot and the portion of the event logs.
- The computing system according to any of Examples 1-13, wherein the interrogative VMI is layered atop a low-level VMI defined by a virtual machine monitor.
- A method of performing time travel debugging, comprising: executing a computer-executable program, the computer-executable program being executable under control of a virtual machine, the virtual machine interacts with a browser system during execution of the computer-executable program; logging nondeterministic events via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program, the nondeterministic events being logged as part of event logs, the interrogative VMI being between the virtual machine and the browser system; capturing snapshots of the virtual machine during the execution of the computer-executable program, the snapshots being captured via the interrogative VMI; and replaying at least a portion of the execution of the computer-executable program based at least in part on a snapshot and at least a portion of the event logs.
- The method according to Example 15, further comprising utilizing the interrogative VMI to log: an event that is scheduled; a Document Object Model (DOM) tree difference between events for a DOM change; a tick count associated with an animation; a value change for a window state; a value from a synchronous source; and a timer identifier.
- The method according to any of Examples 15-16, further comprising replaying the portion of the execution of the computer-executable program based on identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program, wherein at least one of the snapshots or the event logs comprise the identities of the callbacks and the corresponding logical times.
- The method according to any of Examples 15-17, replaying the portion of the execution of the computer-executable program further comprising: identifying the snapshot from the snapshots, the snapshot temporally preceding a time t; loading the snapshot that temporally preceded the time t; and replaying the event logs from the snapshot to the time t.
- A method of performing time travel debugging, comprising: executing a computer-executable program, the computer-executable program being executable under control of a virtual machine, the virtual machine interacts with a browser system during execution of the computer-executable program; storing identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program, wherein the identities of the callbacks and the corresponding logical times are exposed to the virtual machine via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program, the interrogative VMI being between the virtual machine and the browser system; and replaying at least a portion of the execution of the computer-executable program based at least in part on the identities of the callbacks and the corresponding logical times.
- The method according to Example 19, replaying the portion of the execution of the computer-executable program further comprising performing a reverse execution of the computer-executable program to a causal event based at least in part on the identities of the callbacks and the corresponding logical times.
- As used herein, the terms “component” and “system” are intended to encompass computer-readable data storage that is configured with computer-executable instructions that cause certain functionality to be performed when executed by a processor. The computer-executable instructions may include a routine, a function, or the like. It is also to be understood that a component or system may be localized on a single device or distributed across several devices.
- Further, as used herein, the term “exemplary” is intended to mean “serving as an illustration or example of something.”
- Various functions described herein can be implemented in hardware, software, or any combination thereof. If implemented in software, the functions can be stored on or transmitted over as one or more instructions or code on a computer-readable medium. Computer-readable media includes computer-readable storage media. A computer-readable storage media can be any available storage media that can be accessed by a computer. By way of example, and not limitation, such computer-readable storage media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to store desired program code in the form of instructions or data structures and that can be accessed by a computer. Disk and disc, as used herein, include compact disc (CD), laser disc, optical disc, digital versatile disc (DVD), floppy disk, and blu-ray disc (BD), where disks usually reproduce data magnetically and discs usually reproduce data optically with lasers. Further, a propagated signal is not included within the scope of computer-readable storage media. Computer-readable media also includes communication media including any medium that facilitates transfer of a computer program from one place to another. A connection, for instance, can be a communication medium. For example, if the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio and microwave are included in the definition of communication medium. Combinations of the above should also be included within the scope of computer-readable media.
- Alternatively, or in addition, the functionality described herein can be performed, at least in part, by one or more hardware logic components. For example, and without limitation, illustrative types of hardware logic components that can be used include Field-programmable Gate Arrays (FPGAs), Program-specific Integrated Circuits (ASICs), Program-specific Standard Products (ASSPs), System-on-a-chip systems (SOCs), Complex Programmable Logic Devices (CPLDs), etc.
- What has been described above includes examples of one or more embodiments. It is, of course, not possible to describe every conceivable modification and alteration of the above devices or methodologies for purposes of describing the aforementioned aspects, but one of ordinary skill in the art can recognize that many further modifications and permutations of various aspects are possible. Accordingly, the described aspects are intended to embrace all such alterations, modifications, and variations that fall within the scope of the appended claims. Furthermore, to the extent that the term “includes” is used in either the details description or the claims, such term is intended to be inclusive in a manner similar to the term “comprising” as “comprising” is interpreted when employed as a transitional word in a claim.
Claims (20)
1. A computing system, comprising:
at least one processor; and
memory that comprises a virtual machine that is executable by the processor, the virtual machine comprising:
an execution component configured to execute a computer-executable program;
an event logger component configured to log nondeterministic events during execution of the computer-executable program as part of event logs, the event logger component further configured to log the nondeterministic events via an interrogative virtual machine interface (VMI), the interrogative VMI being between the virtual machine and a browser system;
a snapshot component configured to record a sequence of snapshots of the virtual machine during the execution of the computer-executable program, the snapshot component further configured to record the snapshots via the interrogative VMI; and
a time travel debugger configured to replay at least a portion of the execution of the computer-executable program based at least in part on a snapshot from the sequence of snapshots and at least a portion of the event logs.
2. The computing system of claim 1 , wherein the interrogative VMI enables the snapshots and the event logs to be semantically complete.
3. The computing system of claim 1 , wherein the snapshots and the event logs are device and address independent.
4. The computing system of claim 1 , wherein a tick count associated with an animation is exposed to the virtual machine via the interrogative VMI, wherein the browser system further comprises a renderer component configured to perform the animation and associate the tick count with the animation, the tick count being indicative of how close the animation is to a final repaint.
5. The computing system of claim 1 , wherein a callback list managed by a renderer component of the browser system is exposed to the virtual machine via the interrogative VMI.
6. The computing system of claim 1 , wherein an event indicative of an external resource being downloaded by a network component of the browser system is exposed to the virtual machine via the interrogative VMI.
7. The computing system of claim 1 , wherein at least one of the snapshots or the event logs comprise identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program.
8. The computing system of claim 1 , during the execution of the computer-executable program, the event logger component further configured to use the interrogative VMI to log:
an event that is scheduled;
a Document Object Model (DOM) tree difference between events for a DOM change;
a tick count associated with an animation;
a value change for a window state;
a value from a synchronous source; and
a timer identifier.
9. The computing system of claim 1 , the time travel debugger further configured to:
identify the snapshot from the sequence of snapshots, the snapshot temporally preceding a time t;
load the snapshot that temporally preceded the time t; and
replay the event logs from the snapshot to the time t.
10. The computing system of claim 1 , the time travel debugger further configured to perform a reverse execution of the computer-executable program to a causal event based at least in part on the snapshot and the portion of the events logs.
11. The computing system of claim 1 , the time travel debugger further comprising an analysis component configured to:
evaluate latency of time travel operations; and
based on the latency, cause the snapshot component to record an additional snapshot of the virtual machine during the replay of the portion of the execution of the computer-executable program.
12. The computing system of claim 1 , the time travel debugger further comprising a reverse execute component configured to perform a reverse execution of the computer-executable program from a current breakpoint in the computer-executable program to a previous breakpoint in the computer-executable program, the reverse execute component configured to perform the reverse execution based at least in part on the snapshot and the portion of the event logs.
13. The computing system of claim 1 , the time travel debugger further comprising a step back component configured to identify a previously executed statement prior to a breakpoint in the computer-executable program, the step back component configured to identify the previously executed statement based at least in part on the snapshot and the portion of the event logs.
14. The computing system of claim 1 , wherein the interrogative VMI is layered atop a low-level VMI defined by a virtual machine monitor.
15. A method of performing time travel debugging, comprising:
executing a computer-executable program, the computer-executable program being executable under control of a virtual machine, the virtual machine interacts with a browser system during execution of the computer-executable program;
logging nondeterministic events via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program, the nondeterministic events being logged as part of event logs, the interrogative VMI being between the virtual machine and the browser system;
capturing snapshots of the virtual machine during the execution of the computer-executable program, the snapshots being captured via the interrogative VMI; and
replaying at least a portion of the execution of the computer-executable program based at least in part on a snapshot and at least a portion of the event logs.
16. The method of claim 15 , further comprising utilizing the interrogative VMI to log:
an event that is scheduled;
a Document Object Model (DOM) tree difference between events for a DOM change;
a tick count associated with an animation;
a value change for a window state;
a value from a synchronous source; and
a timer identifier.
17. The method of claim 15 , further comprising replaying the portion of the execution of the computer-executable program based on identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program, wherein at least one of the snapshots or the event logs comprise the identities of the callbacks and the corresponding logical times.
18. The method of claim 15 , replaying the portion of the execution of the computer-executable program further comprising:
identifying the snapshot from the snapshots, the snapshot temporally preceding a time t;
loading the snapshot that temporally preceded the time t; and
replaying the event logs from the snapshot to the time t.
19. A method of performing time travel debugging, comprising:
executing a computer-executable program, the computer-executable program being executable under control of a virtual machine, the virtual machine interacts with a browser system during execution of the computer-executable program;
storing identities of callbacks and corresponding logical times at which the callbacks are set during the execution of the computer-executable program, wherein the identities of the callbacks and the corresponding logical times are exposed to the virtual machine via an interrogative virtual machine interface (VMI) during the execution of the computer-executable program, the interrogative VMI being between the virtual machine and the browser system; and
replaying at least a portion of the execution of the computer-executable program based at least in part on the identities of the callbacks and the corresponding logical times.
20. The method of claim 19 , replaying the portion of the execution of the computer-executable program further comprising performing a reverse execution of the computer-executable program to a causal event based at least in part on the identities of the callbacks and the corresponding logical times.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US14/751,638 US9588870B2 (en) | 2015-04-06 | 2015-06-26 | Time travel debugging for browser components |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US201562143435P | 2015-04-06 | 2015-04-06 | |
US14/751,638 US9588870B2 (en) | 2015-04-06 | 2015-06-26 | Time travel debugging for browser components |
Publications (2)
Publication Number | Publication Date |
---|---|
US20160292061A1 true US20160292061A1 (en) | 2016-10-06 |
US9588870B2 US9588870B2 (en) | 2017-03-07 |
Family
ID=57016041
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/751,638 Active US9588870B2 (en) | 2015-04-06 | 2015-06-26 | Time travel debugging for browser components |
Country Status (1)
Country | Link |
---|---|
US (1) | US9588870B2 (en) |
Cited By (61)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20170004066A1 (en) * | 2015-06-30 | 2017-01-05 | International Business Machines Corporation | Debugging through causality and temporal pattering in a event processing system |
US20170371769A1 (en) * | 2016-06-28 | 2017-12-28 | Intel Corporation | Virtualizing precise event based sampling |
US9898385B1 (en) * | 2016-10-11 | 2018-02-20 | Green Hills Software, Inc. | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US9934127B1 (en) | 2017-03-08 | 2018-04-03 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of key frames for replay responsiveness |
US9934126B1 (en) | 2017-03-08 | 2018-04-03 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of reverse lookup data structures |
US9940369B1 (en) | 2017-03-08 | 2018-04-10 | Microsoft Technology Licensing, Llc | Searching an indexed time-travel trace |
US9959194B1 (en) | 2017-03-08 | 2018-05-01 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of memory snapshots for replay responsiveness |
US9965376B1 (en) * | 2017-01-06 | 2018-05-08 | Microsoft Technology Licensing, Llc | Speculative replay of executable code |
US9983978B1 (en) | 2017-03-08 | 2018-05-29 | Microsoft Technology Licensing, Llc | Querying an indexed time-travel trace |
US20180176238A1 (en) | 2016-12-15 | 2018-06-21 | Sap Se | Using frequency analysis in enterprise threat detection to detect intrusions in a computer system |
US10031834B2 (en) | 2016-08-31 | 2018-07-24 | Microsoft Technology Licensing, Llc | Cache-based tracing for time travel debugging and analysis |
US10031833B2 (en) | 2016-08-31 | 2018-07-24 | Microsoft Technology Licensing, Llc | Cache-based tracing for time travel debugging and analysis |
US10042737B2 (en) | 2016-08-31 | 2018-08-07 | Microsoft Technology Licensing, Llc | Program tracing for time travel debugging and analysis |
US10169196B2 (en) | 2017-03-20 | 2019-01-01 | Microsoft Technology Licensing, Llc | Enabling breakpoints on entire data structures |
CN109213674A (en) * | 2017-07-07 | 2019-01-15 | 博彦科技股份有限公司 | Test macro, method, storage medium and processor |
US10185645B2 (en) | 2017-03-08 | 2019-01-22 | Microsoft Technology Licensing, Llc | Resource lifetime analysis using a time-travel trace |
US10198341B2 (en) * | 2016-12-21 | 2019-02-05 | Microsoft Technology Licensing, Llc | Parallel replay of executable code |
US10268567B2 (en) * | 2017-04-12 | 2019-04-23 | Microsoft Technology Licensing, Llc | Systems, methods, and computer-readable media for using immutable and copy-on-write data semantics to optimize record and replay frameworks |
US10268558B2 (en) | 2017-01-13 | 2019-04-23 | Microsoft Technology Licensing, Llc | Efficient breakpoint detection via caches |
US10282274B2 (en) | 2017-06-14 | 2019-05-07 | Microsoft Technology Licensing, Llc | Presenting differences between code entity invocations |
US10296442B2 (en) | 2017-06-29 | 2019-05-21 | Microsoft Technology Licensing, Llc | Distributed time-travel trace recording and replay |
US10310977B2 (en) | 2016-10-20 | 2019-06-04 | Microsoft Technology Licensing, Llc | Facilitating recording a trace file of code execution using a processor cache |
US10310963B2 (en) | 2016-10-20 | 2019-06-04 | Microsoft Technology Licensing, Llc | Facilitating recording a trace file of code execution using index bits in a processor cache |
WO2019108461A1 (en) * | 2017-11-28 | 2019-06-06 | Google Llc | Collaborative hosted virtual systems and methods |
US10318332B2 (en) | 2017-04-01 | 2019-06-11 | Microsoft Technology Licensing, Llc | Virtual machine execution tracing |
US10324851B2 (en) | 2016-10-20 | 2019-06-18 | Microsoft Technology Licensing, Llc | Facilitating recording a trace file of code execution using way-locking in a set-associative processor cache |
US20190213102A1 (en) * | 2018-01-08 | 2019-07-11 | Codevalue D.T. Ltd. | Time Travel Source Code Debugger Incorporating Point In Time Links |
US10459824B2 (en) | 2017-09-18 | 2019-10-29 | Microsoft Technology Licensing, Llc | Cache-based trace recording using cache coherence protocol data |
US10482241B2 (en) | 2016-08-24 | 2019-11-19 | Sap Se | Visualization of data distributed in multiple dimensions |
US10489273B2 (en) | 2016-10-20 | 2019-11-26 | Microsoft Technology Licensing, Llc | Reuse of a related thread's cache while recording a trace file of code execution |
US10496537B2 (en) | 2018-02-23 | 2019-12-03 | Microsoft Technology Licensing, Llc | Trace recording by logging influxes to a lower-layer cache based on entries in an upper-layer cache |
US10530794B2 (en) | 2017-06-30 | 2020-01-07 | Sap Se | Pattern creation in enterprise threat detection |
US10534907B2 (en) | 2016-12-15 | 2020-01-14 | Sap Se | Providing semantic connectivity between a java application server and enterprise threat detection system using a J2EE data |
US10534908B2 (en) | 2016-12-06 | 2020-01-14 | Sap Se | Alerts based on entities in security information and event management products |
US10536476B2 (en) | 2016-07-21 | 2020-01-14 | Sap Se | Realtime triggering framework |
US10542016B2 (en) | 2016-08-31 | 2020-01-21 | Sap Se | Location enrichment in enterprise threat detection |
US10540250B2 (en) | 2016-11-11 | 2020-01-21 | Microsoft Technology Licensing, Llc | Reducing storage requirements for storing memory addresses and values |
US10552605B2 (en) | 2016-12-16 | 2020-02-04 | Sap Se | Anomaly detection in enterprise threat detection |
US10558572B2 (en) | 2018-01-16 | 2020-02-11 | Microsoft Technology Licensing, Llc | Decoupling trace data streams using cache coherence protocol data |
US20200089599A1 (en) * | 2018-09-19 | 2020-03-19 | Oracle International Corporation | Configuring test operations on a per-module basis |
CN110990730A (en) * | 2018-09-29 | 2020-04-10 | 北京字节跳动网络技术有限公司 | Webpage operation method and device, electronic equipment and storage medium |
US10630705B2 (en) | 2016-09-23 | 2020-04-21 | Sap Se | Real-time push API for log events in enterprise threat detection |
US10642737B2 (en) | 2018-02-23 | 2020-05-05 | Microsoft Technology Licensing, Llc | Logging cache influxes by request to a higher-level cache |
US10673879B2 (en) * | 2016-09-23 | 2020-06-02 | Sap Se | Snapshot of a forensic investigation for enterprise threat detection |
US10681064B2 (en) | 2017-12-19 | 2020-06-09 | Sap Se | Analysis of complex relationships among information technology security-relevant entities using a network graph |
US10740220B2 (en) | 2018-06-27 | 2020-08-11 | Microsoft Technology Licensing, Llc | Cache-based trace replay breakpoints using reserved tag field bits |
US20200257615A1 (en) * | 2019-02-07 | 2020-08-13 | Microsoft Technology Licensing, Llc | Using historic execution data to visualize tracepoints |
US10764306B2 (en) | 2016-12-19 | 2020-09-01 | Sap Se | Distributing cloud-computing platform content to enterprise threat detection systems |
WO2020205119A1 (en) * | 2019-04-01 | 2020-10-08 | Microsoft Technology Licensing, Llc | Collecting application state in a runtime environment for reversible debugging |
US10949332B2 (en) | 2019-08-14 | 2021-03-16 | Microsoft Technology Licensing, Llc | Data race analysis based on altering function internal loads during time-travel debugging |
US10956304B2 (en) | 2019-01-25 | 2021-03-23 | Microsoft Technology Licensing, Llc | Dynamic diagnostic code instrumentation over a historic program execution |
US10986111B2 (en) | 2017-12-19 | 2021-04-20 | Sap Se | Displaying a series of events along a time axis in enterprise threat detection |
US11113182B2 (en) | 2019-04-01 | 2021-09-07 | Microsoft Technology Licensing, Llc | Reversible debugging in a runtime environment |
US11132280B2 (en) * | 2019-02-08 | 2021-09-28 | Microsoft Technology Licensing, Llc | Automatically identifying and highlighting differences between historic traces |
US11281560B2 (en) * | 2019-03-19 | 2022-03-22 | Microsoft Technology Licensing, Llc | Input/output data transformations when emulating non-traced code with a recorded execution of traced code |
US11307966B2 (en) * | 2020-04-06 | 2022-04-19 | Red Hat, Inc. | Shared software debugging service |
US11327954B2 (en) * | 2017-01-31 | 2022-05-10 | Xactly Corporation | Multitenant architecture for prior period adjustment processing |
US11470094B2 (en) | 2016-12-16 | 2022-10-11 | Sap Se | Bi-directional content replication logic for enterprise threat detection |
GB2593858B (en) * | 2020-01-30 | 2023-03-22 | Retrace Software Ltd | Methods and systems for recreating a program state. |
US11782816B2 (en) * | 2019-03-19 | 2023-10-10 | Jens C. Jenkins | Input/output location transformations when emulating non-traced code with a recorded execution of traced code |
US11907091B2 (en) | 2018-02-16 | 2024-02-20 | Microsoft Technology Licensing, Llc | Trace recording by logging influxes to an upper-layer shared cache, plus cache coherence protocol transitions among lower-layer caches |
Families Citing this family (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8601473B1 (en) | 2011-08-10 | 2013-12-03 | Nutanix, Inc. | Architecture for managing I/O and storage for a virtualization environment |
US11243707B2 (en) | 2014-03-12 | 2022-02-08 | Nutanix, Inc. | Method and system for implementing virtual machine images |
US10698790B1 (en) * | 2016-03-31 | 2020-06-30 | EMC IP Holding Company LLC | Proactive debugging |
US10613947B2 (en) * | 2016-06-09 | 2020-04-07 | Nutanix, Inc. | Saving and restoring storage devices using application-consistent snapshots |
JP6919338B2 (en) * | 2017-05-30 | 2021-08-18 | オムロン株式会社 | Program development support device, program development support system, program development support method, and program development support program |
US10678674B2 (en) * | 2017-06-15 | 2020-06-09 | Silicon Laboratories, Inc. | Wireless debugging |
US10540259B1 (en) * | 2017-08-11 | 2020-01-21 | Amazon Technologies, Inc. | Microservice replay debugger |
US10545853B2 (en) | 2017-11-06 | 2020-01-28 | Oracle International Corporation | Stateless debugging of a script injected into a web application that is located in a mult-node cloud system |
US10824522B2 (en) | 2017-11-27 | 2020-11-03 | Nutanix, Inc. | Method, apparatus, and computer program product for generating consistent snapshots without quiescing applications |
Citations (19)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6598179B1 (en) * | 2000-03-31 | 2003-07-22 | International Business Machines Corporation | Table-based error log analysis |
US20090007111A1 (en) * | 2007-06-27 | 2009-01-01 | Vmware, Inc. | Logging and replaying input/output events for a virtual machine |
US20090119493A1 (en) * | 2007-11-06 | 2009-05-07 | Vmware, Inc. | Using Branch Instruction Counts to Facilitate Replay of Virtual Machine Instruction Execution |
US20090119665A1 (en) * | 2007-11-06 | 2009-05-07 | Vmware, Inc. | Transitioning of virtual machine from replay mode to live mode |
US20100005464A1 (en) * | 2008-07-03 | 2010-01-07 | Vmware, Inc. | Efficient recording and replaying of non-deterministic instructions in a virtual machine and cpu therefor |
US20100138815A1 (en) * | 2008-11-28 | 2010-06-03 | Red Hat, Inc. | Implementing aspects with callbacks in virtual machines |
US20110296245A1 (en) * | 2010-05-26 | 2011-12-01 | Telcordia Technologies, Inc. | System and method for a staggered execution environment |
US20120239987A1 (en) * | 2011-03-16 | 2012-09-20 | Vmware, Inc. | System and Method of Manipulating Virtual Machine Recordings for High-Level Execution and Replay |
US20120246640A1 (en) * | 2011-03-24 | 2012-09-27 | Amazon Technologies, Inc. | Replication of Machine Instances in a Computing Environment |
US8321842B2 (en) * | 2008-06-27 | 2012-11-27 | Vmware, Inc. | Replay time only functionalities in a virtual machine |
US8499299B1 (en) * | 2010-06-29 | 2013-07-30 | Ca, Inc. | Ensuring deterministic thread context switching in virtual machine applications |
US20130263114A1 (en) * | 2012-03-27 | 2013-10-03 | Microsoft Corporation | Detecting a repeating execution time sequence in a virtual machine |
US20130283242A1 (en) * | 2013-04-20 | 2013-10-24 | Concurix Corporation | Tracing Closures in a Callback Environment |
US8839245B1 (en) * | 2012-06-18 | 2014-09-16 | Bromium, Inc. | Transferring files using a virtualized application |
US20140282555A1 (en) * | 2010-06-29 | 2014-09-18 | Ca, Inc. | Ensuring Determinism During Programmatic Replay in a Virtual Machine |
US20140366026A1 (en) * | 2013-06-06 | 2014-12-11 | Fujitsu Limited | Recording medium storing transaction resuming program, information processing apparatus and transaction resuming method |
US9015121B1 (en) * | 2013-01-15 | 2015-04-21 | Emc Corporation | Unified virtual machine and data storage snapshots |
US20160127307A1 (en) * | 2014-11-04 | 2016-05-05 | Rubrik, Inc. | Cluster-based network file server |
US20160154710A1 (en) * | 2014-12-01 | 2016-06-02 | Citrix Systems, Inc. | Live rollback for a computing environment |
Family Cites Families (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9823992B2 (en) * | 2008-06-20 | 2017-11-21 | Vmware, Inc. | Decoupling dynamic program analysis from execution in virtual environments |
US8499297B2 (en) * | 2008-10-28 | 2013-07-30 | Vmware, Inc. | Low overhead fault tolerance through hybrid checkpointing and replay |
US8259118B2 (en) * | 2008-12-12 | 2012-09-04 | Mobitv, Inc. | Event based interactive animation |
US9348624B2 (en) * | 2009-07-23 | 2016-05-24 | International Business Machines Corporation | Monitoring file access of java processes |
US8656222B2 (en) * | 2009-07-30 | 2014-02-18 | Vmware, Inc. | Method and system for recording a selected computer process for subsequent replay |
US8966623B2 (en) * | 2010-03-08 | 2015-02-24 | Vmware, Inc. | Managing execution of a running-page in a virtual machine |
US8407321B2 (en) * | 2010-04-21 | 2013-03-26 | Microsoft Corporation | Capturing web-based scenarios |
US8826273B1 (en) * | 2010-12-22 | 2014-09-02 | Vmware, Inc. | Synchronously logging to disk for main-memory database systems through record and replay |
US9807116B2 (en) * | 2013-05-03 | 2017-10-31 | Vmware, Inc. | Methods and apparatus to identify priorities of compliance assessment results of a virtual computing environment |
-
2015
- 2015-06-26 US US14/751,638 patent/US9588870B2/en active Active
Patent Citations (19)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6598179B1 (en) * | 2000-03-31 | 2003-07-22 | International Business Machines Corporation | Table-based error log analysis |
US20090007111A1 (en) * | 2007-06-27 | 2009-01-01 | Vmware, Inc. | Logging and replaying input/output events for a virtual machine |
US20090119493A1 (en) * | 2007-11-06 | 2009-05-07 | Vmware, Inc. | Using Branch Instruction Counts to Facilitate Replay of Virtual Machine Instruction Execution |
US20090119665A1 (en) * | 2007-11-06 | 2009-05-07 | Vmware, Inc. | Transitioning of virtual machine from replay mode to live mode |
US8321842B2 (en) * | 2008-06-27 | 2012-11-27 | Vmware, Inc. | Replay time only functionalities in a virtual machine |
US20100005464A1 (en) * | 2008-07-03 | 2010-01-07 | Vmware, Inc. | Efficient recording and replaying of non-deterministic instructions in a virtual machine and cpu therefor |
US20100138815A1 (en) * | 2008-11-28 | 2010-06-03 | Red Hat, Inc. | Implementing aspects with callbacks in virtual machines |
US20110296245A1 (en) * | 2010-05-26 | 2011-12-01 | Telcordia Technologies, Inc. | System and method for a staggered execution environment |
US20140282555A1 (en) * | 2010-06-29 | 2014-09-18 | Ca, Inc. | Ensuring Determinism During Programmatic Replay in a Virtual Machine |
US8499299B1 (en) * | 2010-06-29 | 2013-07-30 | Ca, Inc. | Ensuring deterministic thread context switching in virtual machine applications |
US20120239987A1 (en) * | 2011-03-16 | 2012-09-20 | Vmware, Inc. | System and Method of Manipulating Virtual Machine Recordings for High-Level Execution and Replay |
US20120246640A1 (en) * | 2011-03-24 | 2012-09-27 | Amazon Technologies, Inc. | Replication of Machine Instances in a Computing Environment |
US20130263114A1 (en) * | 2012-03-27 | 2013-10-03 | Microsoft Corporation | Detecting a repeating execution time sequence in a virtual machine |
US8839245B1 (en) * | 2012-06-18 | 2014-09-16 | Bromium, Inc. | Transferring files using a virtualized application |
US9015121B1 (en) * | 2013-01-15 | 2015-04-21 | Emc Corporation | Unified virtual machine and data storage snapshots |
US20130283242A1 (en) * | 2013-04-20 | 2013-10-24 | Concurix Corporation | Tracing Closures in a Callback Environment |
US20140366026A1 (en) * | 2013-06-06 | 2014-12-11 | Fujitsu Limited | Recording medium storing transaction resuming program, information processing apparatus and transaction resuming method |
US20160127307A1 (en) * | 2014-11-04 | 2016-05-05 | Rubrik, Inc. | Cluster-based network file server |
US20160154710A1 (en) * | 2014-12-01 | 2016-06-02 | Citrix Systems, Inc. | Live rollback for a computing environment |
Cited By (98)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US10055334B2 (en) * | 2015-06-30 | 2018-08-21 | International Business Machines Corporation | Debugging through causality and temporal patterning in an event processing system |
US20170004067A1 (en) * | 2015-06-30 | 2017-01-05 | International Business Machines Corporation | Debugging through causality and temporal patterning in an event processing system |
US20170004066A1 (en) * | 2015-06-30 | 2017-01-05 | International Business Machines Corporation | Debugging through causality and temporal pattering in a event processing system |
US10083107B2 (en) * | 2015-06-30 | 2018-09-25 | International Business Machines Corporation | Debugging through causality and temporal patterning in an event processing system |
US11157392B2 (en) | 2015-06-30 | 2021-10-26 | International Business Machines Corporation | Debugging through causality and temporal pattering in a event processing system |
US20170371769A1 (en) * | 2016-06-28 | 2017-12-28 | Intel Corporation | Virtualizing precise event based sampling |
US10496522B2 (en) | 2016-06-28 | 2019-12-03 | Intel Corporation | Virtualizing precise event based sampling |
US11055203B2 (en) * | 2016-06-28 | 2021-07-06 | Intel Corporation | Virtualizing precise event based sampling |
US9965375B2 (en) * | 2016-06-28 | 2018-05-08 | Intel Corporation | Virtualizing precise event based sampling |
US10536476B2 (en) | 2016-07-21 | 2020-01-14 | Sap Se | Realtime triggering framework |
US11012465B2 (en) | 2016-07-21 | 2021-05-18 | Sap Se | Realtime triggering framework |
US10482241B2 (en) | 2016-08-24 | 2019-11-19 | Sap Se | Visualization of data distributed in multiple dimensions |
US10963367B2 (en) * | 2016-08-31 | 2021-03-30 | Microsoft Technology Licensing, Llc | Program tracing for time travel debugging and analysis |
US20190018755A1 (en) * | 2016-08-31 | 2019-01-17 | Microsoft Technology Licensing, Llc | Program tracing for time travel debugging and analysis |
US10031833B2 (en) | 2016-08-31 | 2018-07-24 | Microsoft Technology Licensing, Llc | Cache-based tracing for time travel debugging and analysis |
US10042737B2 (en) | 2016-08-31 | 2018-08-07 | Microsoft Technology Licensing, Llc | Program tracing for time travel debugging and analysis |
US10542016B2 (en) | 2016-08-31 | 2020-01-21 | Sap Se | Location enrichment in enterprise threat detection |
US10031834B2 (en) | 2016-08-31 | 2018-07-24 | Microsoft Technology Licensing, Llc | Cache-based tracing for time travel debugging and analysis |
US10630705B2 (en) | 2016-09-23 | 2020-04-21 | Sap Se | Real-time push API for log events in enterprise threat detection |
US10673879B2 (en) * | 2016-09-23 | 2020-06-02 | Sap Se | Snapshot of a forensic investigation for enterprise threat detection |
US11243871B2 (en) | 2016-10-11 | 2022-02-08 | Green Hills Software Llc | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US10592394B2 (en) | 2016-10-11 | 2020-03-17 | Green Hills Software Llc | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US11609840B2 (en) | 2016-10-11 | 2023-03-21 | Green Hills Software Llc | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US9898385B1 (en) * | 2016-10-11 | 2018-02-20 | Green Hills Software, Inc. | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US10324824B2 (en) | 2016-10-11 | 2019-06-18 | Green Hills Software Llc | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US10817404B2 (en) | 2016-10-11 | 2020-10-27 | Green Hills Software Llc | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US9904615B1 (en) * | 2016-10-11 | 2018-02-27 | Green Hills Software, Inc. | Systems, methods, and devices for vertically integrated instrumentation and trace reconstruction |
US10310977B2 (en) | 2016-10-20 | 2019-06-04 | Microsoft Technology Licensing, Llc | Facilitating recording a trace file of code execution using a processor cache |
US10310963B2 (en) | 2016-10-20 | 2019-06-04 | Microsoft Technology Licensing, Llc | Facilitating recording a trace file of code execution using index bits in a processor cache |
US10489273B2 (en) | 2016-10-20 | 2019-11-26 | Microsoft Technology Licensing, Llc | Reuse of a related thread's cache while recording a trace file of code execution |
US10324851B2 (en) | 2016-10-20 | 2019-06-18 | Microsoft Technology Licensing, Llc | Facilitating recording a trace file of code execution using way-locking in a set-associative processor cache |
US10540250B2 (en) | 2016-11-11 | 2020-01-21 | Microsoft Technology Licensing, Llc | Reducing storage requirements for storing memory addresses and values |
US10534908B2 (en) | 2016-12-06 | 2020-01-14 | Sap Se | Alerts based on entities in security information and event management products |
US10530792B2 (en) | 2016-12-15 | 2020-01-07 | Sap Se | Using frequency analysis in enterprise threat detection to detect intrusions in a computer system |
US20180176238A1 (en) | 2016-12-15 | 2018-06-21 | Sap Se | Using frequency analysis in enterprise threat detection to detect intrusions in a computer system |
US10534907B2 (en) | 2016-12-15 | 2020-01-14 | Sap Se | Providing semantic connectivity between a java application server and enterprise threat detection system using a J2EE data |
US11093608B2 (en) | 2016-12-16 | 2021-08-17 | Sap Se | Anomaly detection in enterprise threat detection |
US11470094B2 (en) | 2016-12-16 | 2022-10-11 | Sap Se | Bi-directional content replication logic for enterprise threat detection |
US10552605B2 (en) | 2016-12-16 | 2020-02-04 | Sap Se | Anomaly detection in enterprise threat detection |
US10764306B2 (en) | 2016-12-19 | 2020-09-01 | Sap Se | Distributing cloud-computing platform content to enterprise threat detection systems |
US10198341B2 (en) * | 2016-12-21 | 2019-02-05 | Microsoft Technology Licensing, Llc | Parallel replay of executable code |
US9965376B1 (en) * | 2017-01-06 | 2018-05-08 | Microsoft Technology Licensing, Llc | Speculative replay of executable code |
US10268558B2 (en) | 2017-01-13 | 2019-04-23 | Microsoft Technology Licensing, Llc | Efficient breakpoint detection via caches |
US11327954B2 (en) * | 2017-01-31 | 2022-05-10 | Xactly Corporation | Multitenant architecture for prior period adjustment processing |
US10235273B2 (en) | 2017-03-08 | 2019-03-19 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of key frames for replay responsiveness |
US9959194B1 (en) | 2017-03-08 | 2018-05-01 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of memory snapshots for replay responsiveness |
US10185645B2 (en) | 2017-03-08 | 2019-01-22 | Microsoft Technology Licensing, Llc | Resource lifetime analysis using a time-travel trace |
WO2018164976A1 (en) * | 2017-03-08 | 2018-09-13 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of key frames for replay responsiveness |
US9934127B1 (en) | 2017-03-08 | 2018-04-03 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of key frames for replay responsiveness |
US9983978B1 (en) | 2017-03-08 | 2018-05-29 | Microsoft Technology Licensing, Llc | Querying an indexed time-travel trace |
US9934126B1 (en) | 2017-03-08 | 2018-04-03 | Microsoft Technology Licensing, Llc | Indexing a trace by insertion of reverse lookup data structures |
US9940369B1 (en) | 2017-03-08 | 2018-04-10 | Microsoft Technology Licensing, Llc | Searching an indexed time-travel trace |
US10169196B2 (en) | 2017-03-20 | 2019-01-01 | Microsoft Technology Licensing, Llc | Enabling breakpoints on entire data structures |
EP4033357A1 (en) * | 2017-04-01 | 2022-07-27 | Microsoft Technology Licensing, LLC | Virtual machine execution tracing |
US10318332B2 (en) | 2017-04-01 | 2019-06-11 | Microsoft Technology Licensing, Llc | Virtual machine execution tracing |
US10268567B2 (en) * | 2017-04-12 | 2019-04-23 | Microsoft Technology Licensing, Llc | Systems, methods, and computer-readable media for using immutable and copy-on-write data semantics to optimize record and replay frameworks |
US10282274B2 (en) | 2017-06-14 | 2019-05-07 | Microsoft Technology Licensing, Llc | Presenting differences between code entity invocations |
US10296442B2 (en) | 2017-06-29 | 2019-05-21 | Microsoft Technology Licensing, Llc | Distributed time-travel trace recording and replay |
US11128651B2 (en) | 2017-06-30 | 2021-09-21 | Sap Se | Pattern creation in enterprise threat detection |
US10530794B2 (en) | 2017-06-30 | 2020-01-07 | Sap Se | Pattern creation in enterprise threat detection |
CN109213674A (en) * | 2017-07-07 | 2019-01-15 | 博彦科技股份有限公司 | Test macro, method, storage medium and processor |
US10459824B2 (en) | 2017-09-18 | 2019-10-29 | Microsoft Technology Licensing, Llc | Cache-based trace recording using cache coherence protocol data |
US11550611B2 (en) | 2017-11-28 | 2023-01-10 | Google Llc | Collaborative hosted virtual systems and methods |
US10754678B2 (en) | 2017-11-28 | 2020-08-25 | Google Llc | Collaborative hosted virtual systems and methods |
WO2019108461A1 (en) * | 2017-11-28 | 2019-06-06 | Google Llc | Collaborative hosted virtual systems and methods |
US11789765B2 (en) | 2017-11-28 | 2023-10-17 | Google Llc | Collaborative hosted virtual systems and methods |
US10986111B2 (en) | 2017-12-19 | 2021-04-20 | Sap Se | Displaying a series of events along a time axis in enterprise threat detection |
US10681064B2 (en) | 2017-12-19 | 2020-06-09 | Sap Se | Analysis of complex relationships among information technology security-relevant entities using a network graph |
US10990504B2 (en) | 2018-01-08 | 2021-04-27 | Ozcode Ltd. | Time travel source code debugger incorporating future prediction |
US20190213101A1 (en) * | 2018-01-08 | 2019-07-11 | Codevalue D.T. Ltd. | Time Travel Source Code Debugger Incorporating Pivoting Ability |
US10795801B2 (en) * | 2018-01-08 | 2020-10-06 | Ozcode Ltd | Time travel source code debugger incorporating asynchronous collaboration |
US10789151B2 (en) * | 2018-01-08 | 2020-09-29 | Ozcode Ltd | Time travel source code debugger incorporating pivoting ability |
US10783056B2 (en) * | 2018-01-08 | 2020-09-22 | Ozcode Ltd | Time travel source code debugger incorporating point in time links |
US11048615B2 (en) | 2018-01-08 | 2021-06-29 | Ozcode Ltd. | Time travel source code debugger incorporating visual annotations |
US10783055B2 (en) | 2018-01-08 | 2020-09-22 | Ozcode Ltd. | Time travel source code debugger incorporating live coding ability |
US20190213102A1 (en) * | 2018-01-08 | 2019-07-11 | Codevalue D.T. Ltd. | Time Travel Source Code Debugger Incorporating Point In Time Links |
US11080164B2 (en) | 2018-01-08 | 2021-08-03 | Ozcode Ltd. | Time travel source code debugger incorporating redaction of sensitive information |
US10558572B2 (en) | 2018-01-16 | 2020-02-11 | Microsoft Technology Licensing, Llc | Decoupling trace data streams using cache coherence protocol data |
US11907091B2 (en) | 2018-02-16 | 2024-02-20 | Microsoft Technology Licensing, Llc | Trace recording by logging influxes to an upper-layer shared cache, plus cache coherence protocol transitions among lower-layer caches |
US10496537B2 (en) | 2018-02-23 | 2019-12-03 | Microsoft Technology Licensing, Llc | Trace recording by logging influxes to a lower-layer cache based on entries in an upper-layer cache |
US10642737B2 (en) | 2018-02-23 | 2020-05-05 | Microsoft Technology Licensing, Llc | Logging cache influxes by request to a higher-level cache |
US10740220B2 (en) | 2018-06-27 | 2020-08-11 | Microsoft Technology Licensing, Llc | Cache-based trace replay breakpoints using reserved tag field bits |
US20200089599A1 (en) * | 2018-09-19 | 2020-03-19 | Oracle International Corporation | Configuring test operations on a per-module basis |
US11886326B2 (en) * | 2018-09-19 | 2024-01-30 | Oracle International Corporation | Configuring test operations on a per-module basis |
CN110990730A (en) * | 2018-09-29 | 2020-04-10 | 北京字节跳动网络技术有限公司 | Webpage operation method and device, electronic equipment and storage medium |
US10956304B2 (en) | 2019-01-25 | 2021-03-23 | Microsoft Technology Licensing, Llc | Dynamic diagnostic code instrumentation over a historic program execution |
US10877873B2 (en) * | 2019-02-07 | 2020-12-29 | Microsoft Technology Licensing, Llc | Using historic execution data to visualize tracepoints |
US20200257615A1 (en) * | 2019-02-07 | 2020-08-13 | Microsoft Technology Licensing, Llc | Using historic execution data to visualize tracepoints |
US11132280B2 (en) * | 2019-02-08 | 2021-09-28 | Microsoft Technology Licensing, Llc | Automatically identifying and highlighting differences between historic traces |
US11281560B2 (en) * | 2019-03-19 | 2022-03-22 | Microsoft Technology Licensing, Llc | Input/output data transformations when emulating non-traced code with a recorded execution of traced code |
US11782816B2 (en) * | 2019-03-19 | 2023-10-10 | Jens C. Jenkins | Input/output location transformations when emulating non-traced code with a recorded execution of traced code |
WO2020205119A1 (en) * | 2019-04-01 | 2020-10-08 | Microsoft Technology Licensing, Llc | Collecting application state in a runtime environment for reversible debugging |
US11113182B2 (en) | 2019-04-01 | 2021-09-07 | Microsoft Technology Licensing, Llc | Reversible debugging in a runtime environment |
US11074153B2 (en) | 2019-04-01 | 2021-07-27 | Microsoft Technology Licensing, Llc | Collecting application state in a runtime environment for reversible debugging |
US10949332B2 (en) | 2019-08-14 | 2021-03-16 | Microsoft Technology Licensing, Llc | Data race analysis based on altering function internal loads during time-travel debugging |
US11880279B2 (en) | 2020-01-30 | 2024-01-23 | Retrace Software Limited | Methods and systems for recreating a program state |
GB2593858B (en) * | 2020-01-30 | 2023-03-22 | Retrace Software Ltd | Methods and systems for recreating a program state. |
US11307966B2 (en) * | 2020-04-06 | 2022-04-19 | Red Hat, Inc. | Shared software debugging service |
Also Published As
Publication number | Publication date |
---|---|
US9588870B2 (en) | 2017-03-07 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9588870B2 (en) | Time travel debugging for browser components | |
US10268567B2 (en) | Systems, methods, and computer-readable media for using immutable and copy-on-write data semantics to optimize record and replay frameworks | |
US10990238B2 (en) | Software robots for programmatically controlling computer programs to perform tasks | |
US9875173B2 (en) | Time travel debugging in managed runtime | |
Mickens et al. | Mugshot: Deterministic Capture and Replay for JavaScript Applications. | |
US9063766B2 (en) | System and method of manipulating virtual machine recordings for high-level execution and replay | |
Petrov et al. | Race detection for web applications | |
Komatineni et al. | Pro Android 4 | |
Taivalsaari et al. | Web browser as an application platform | |
Zhang et al. | Panappticon: Event-based tracing to measure mobile application and platform performance | |
Oh et al. | Migration of web applications with seamless execution | |
US10545852B2 (en) | Diagnostics of state transitions | |
US20130275951A1 (en) | Race detection for web applications | |
US20090265719A1 (en) | Application macro recording utilizing method interception | |
Powers et al. | Browsix: Bridging the gap between unix and the browser | |
Marra et al. | Debugging cyber-physical systems with pharo: An experience report | |
Kwon et al. | Framework separated migration for web applications | |
Müller | Web technologies on the desktop: an early look at Flutter | |
Vilk et al. | A gray box approach for high-fidelity, high-speed time-travel debugging | |
Ramgir et al. | Java 9 High Performance: Practical techniques and best practices for optimizing Java applications through concurrency, reactive programming, and more | |
US11847433B2 (en) | Source code editing combining edit and continue with hot reload | |
Fowler | Python Concurrency with asyncio | |
Vilk | Righting Web Development | |
Leija | Leveraging System Call Interposition for Low-Level Process Manipulation | |
Rumsevicius et al. | Sinatra: Stateful Instantaneous Updates for Commercial Browsers Through Multi-Version eXecution |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:MARRON, MARK;MICKENS, JAMES WILLIAMSON;REEL/FRAME:035914/0894 Effective date: 20150626 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
MAFP | Maintenance fee payment |
Free format text: PAYMENT OF MAINTENANCE FEE, 4TH YEAR, LARGE ENTITY (ORIGINAL EVENT CODE: M1551); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY Year of fee payment: 4 |