Ca, Inc.

Replay Solutions, Inc.

Arpad Jakab

Suman Cherukuri

Jeffrey Daudel

Jonathan Lindo

Humberto Yeverino

Dickey B Singh

Marvin Justice

Jean David Dahan

Johnathan Lindo

Aspects of an application program's execution which might be subject to non-determinism are performed in a deterministic manner while the application program's execution is being recorded in a virtual machine environment so that the application program's behavior, when played back in that virtual machine environment, will duplicate the behavior that the application program exhibited when originally executed and recorded. Techniques disclosed herein take advantage of the recognition that only minimal data needs to be recorded in relation to the execution of deterministic operations, which actually can be repeated 'verbatim' during replay, and that more highly detailed data should be recorded only in relation to non-deterministic operations, so that those non-deterministic operations can be deterministically simulated (rather than attempting to re-execute those operations under circumstances where the outcome of the re-execution might differ) based on the detailed data during replay.

Ensuring determinism during programmatic replay in a virtual machine

Transaction data is received from a software-based agent instrumented on a particular software component in a system comprising a plurality of software components. The transaction data can describe characteristics of a particular transaction involving the particular software component and another software component in the plurality of software components as observed by the agent during operation of the system, the particular transaction is contemporaneous with another transaction involving software components in the system. From the transaction data, the particular transaction is determined to fall within a defined transaction boundary for the system. A profiler is automatically invoked to profile the particular transaction based on determining that the particular transaction falls within the transaction boundary.

Transactional boundaries for software system profiling

A replay core ensures that references to objects are removed at the same relative times and in the same relative order within a program's execution during both record time and replay time. A register method of a Finalizer class is modified to cause the register method to pass, to a specified programmatic mechanism, an object that was passed to the register method; modifying a finalize method of a class of the object to (a) cause the object to invoke a first method of the programmatic mechanism when the finalize method is invoked by a virtual machine and (b) prevent a remainder of the finalize method from completing under specified conditions, thereby causing a call to the finalize method to remain undispatched. The first method, when invoked, (a) adds, to the object, a reference that temporarily prevents the object from being deleted and (b) records an identifier of the object.

In an embodiment, a data processing system comprises a storage system coupled to a unit under test comprising a heap memory, a static memory and a stack; second logic operable to perform: detecting one or more changes in a first state of the heap memory and the static memory; storing, in the storage system, as a state point of the unit under test, the one or more changes in the first state of the heap memory and the static memory; third logic operable to perform: receiving a request to change the memory under test to a particular state point; in response to the request, loading the particular state point from the storage system and applying the particular state point to the heap memory and the static memory to result in changing the heap memory and the static memory to a second state that is substantially equivalent to the first state.

Advancing and rewinding a replayed program execution

A computer program execution record and replay system providing recorded execution event breakpoints is described. In one embodiment, for example, in the record and replay system, a method for providing recorded execution event breakpoints, the method comprising: recording information about one or more execution events that occur during a recorded execution of a computer program; during a replay execution of the computer program in which a particular execution event of the one or more execution events is faithfully reproduced, determining whether a breakpoint is to be set in the replay execution of the computer program based on the recorded information about the particular execution event; and if the breakpoint is to be set, then setting a breakpoint in the replay execution of the computer program such that the replay execution breaks at a point corresponding to the faithful reproduction of the particular execution event.

Recording and replaying computer program execution with log amplification logic

Recording and replaying computer program execution with recorded execution event breakpoints

Techniques for ensuring deterministic thread context switching in a virtual machine application program include, in one embodiment, providing a single application-level mutex that threads of the executing application program are forced to acquire to execute application code of the virtual machine application program. During a first recorded execution of the virtual machine application program, a record is created and stored in a computer that indicates the order in which threads acquire the application-level mutex. In a subsequent replay execution of the virtual machine application program from the recording, threads of the virtual machine application program are managed to ensure that the application-level mutex is acquired by threads in the same order indicated in the record such that any race conditions that occurred during the recorded execution as a result of executing application code are reproduced during the subsequent replay execution thereby aiding application development personnel in identifying and isolating program errors and bugs related to race conditions.

Ensuring deterministic thread context switching in virtual machine applications

In an embodiment, a data processing system comprises a storage system coupled to a unit under test comprising a heap memory, a static memory and a stack; second logic operable to perform: detecting one or more changes in a first state of the heap memory and the static memory; storing, in the storage system, as a state point of the unit under test, the one or more changes in the first state of the heap memory and the static memory; third logic operable to perform: receiving a request to change the memory under test to a particular state point; in response to the request, loading the particular state point from the storage system and applying the state point to the heap memory and the static memory to result in changing the heap memory and the static memory to a second state that is substantially equivalent to the first state.

Growing community of inventors

Oakland, CA, United States of America

Arpad Jakab