Ensuring determinism during programmatic replay in a virtual machine

Patent metadata

Field	Value
Publication number	US-10083046-B2
Application number	US-201715401387-A
Country	US
Kind code	B2
Filing date	Jan 9, 2017
Priority date	Jun 29, 2010
Publication date	Sep 25, 2018
Grant date	Sep 25, 2018

Abstract

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.

First claim

What is claimed is:

1. A method implemented with a processor equipped with memory-stored instructions for carrying out process of statically initializing classes supportive of a replay core context, where the instructions upon being executed by the processor, perform the initialization process comprising steps of:
prior to initialization of a class associated with application code, determining that the class contains a static initialization method, wherein the static initialization method has a first name and contains a blocking call;
in response to determining that the class contains a static initialization method, renaming the static initialization method to have a second name instead of the first name, wherein a thread that executes the static initialization method having the second name releases a global application lock before making the blocking call;
injecting, into the class, an empty method that has the first name and causes a virtual machine to obtain a class lock on the class upon invocation of the empty method;
injecting, into the class, a checking method which, when executed, determines whether the method having the second name has already been executed, and executes the method having the second name only if the method having the second name has not yet been executed; and
injecting, into the application code, at points of execution at which an invocation of the method having the first name could be triggered by the virtual machine, an invocation of the checking method;
wherein in response to the virtual machine invoking the static initialization method that has the first name, the empty method returns without performing the blocking call;
wherein said steps are performed by a replay core that executes in a computing system.

2. The method of claim 1 , wherein the injecting, into application code, at points of execution at which an invocation of the method having the first name could be triggered by the virtual machine, an invocation of the checking method comprises:
injecting, at a beginning of each static code block of the class, an invocation of the checking method.

3. The method of claim 1 , wherein the injecting, into application code, at points of execution at which an invocation of the method having the first name could be triggered by the virtual machine, an invocation of the checking method comprises:
injecting, at a beginning of each constructor method of the class, an invocation of the checking method.

4. The method of claim 1 , wherein the injecting, into application code, at points of execution at which an invocation of the method having the first name could be triggered by the virtual machine, an invocation of the checking method comprises:
into each class that contains a static field access of a static field of an accessed class, injecting, into said class, prior to said static field access, an invocation of the checking method into which a name of the accessed class is passed as input.

5. The method of claim 1 , wherein the injecting, into application code, at each point of execution at which an invocation of the method having the first name could be triggered by the virtual machine, an invocation of the checking method comprises:
injecting an invocation of the checking method into code of a function that is used to perform reflection relative to the class.

6. The method of claim 1 , wherein invocation, by the checking method, of the static initialization method having the second name initializes the class without the virtual machine obtaining the class lock on the class.

7. The method of claim 1 , wherein the empty method returning causes the virtual machine to assume that the class has been initialized and to release the class lock on the class.

8. A system comprising:
a processor configured to:
determine that a class associated with application code contains a static initialization method, wherein the static initialization method has a first name and contains a blocking call;
rename the static initialization method to have a second name instead of the first name in response to determining that the class contains a static initialization method, wherein a thread that executes the static initialization method having the second name releases a global application lock before making the blocking call;
inject, into the class, an empty method that has the first name and causes a virtual machine to obtain a class lock on the class upon invocation of the empty method;
inject, into the class, a checking method which, when invoked, determines whether the method having the second name has already been invoked, and invokes the method having the second name only if the method having the second name has not yet been invoked; and
inject, into the application code, at points of execution at which an invocation of the static initialization method by a virtual machine could be triggered by a virtual machine, an invocation of the checking method;
wherein, in response to the virtual machine invoking the static initialization method that has the first name, the empty method returns without performing the blocking call.

9. The system of claim 8 , wherein to inject the checking method into the class the processor is configured to:
inject, at a beginning of each static code block of the class, an invocation of the checking method.

10. The system of claim 8 , wherein to inject the checking method into the class the processor is configured to:
inject, at a beginning of each constructor method of the class, an invocation of the checking method.

11. The system of claim 8 , wherein to inject the checking method into the class the processor is configured to:
into each class that contains a static field access of a static field of an accessed class, inject, into said class, prior to said static field access, an invocation of the checking method into which a name of the accessed class is passed as input.

12. The system of claim 8 , wherein to inject the checking method into the class the processor is configured to:
inject an invocation of the checking method into code of a function that is used to perform reflection relative to the class.

13. The system of claim 8 , wherein the processor is configured to:
maintain a set of classes that have had a checking method injected that determines whether a method having an alternative name to a static initialization method of that class has already been executed.

14. The system of claim 13 , wherein the processor is configured to:
determine that a class that is not in the set of classes contains a static field access of a field of a class in the set of classes; and
inject, prior to any static field access contained in a body of the class that is not in the set of classes, an invocation of a checking method into which an identity of the class associated with the static field access is passed as input.

15. The system of claim 8 , wherein invocation, by the checking method, of the static initialization method having the second name initializes the class without the virtual machine obtaining the class lock on the class.

16. A non-transitory computer-readable storage medium storing instructions which, when executed by a processor, cause the processor to:
prior to initialization of a class associated with application code, determine that the class contains a static initialization method, wherein the static initialization method has a first name and contains a blocking call that requires release of a global application lock;
rename the static initialization method to have a second name instead of the first name in response to determi

Assignees

• Ca Inc

Inventors

• Daudel Jeffrey
• Cherukuri Suman
• Yeverino Humberto
• Singh Dickey
• Jakab Arpad
• Justice Marvin
• Lindo Jonathan

Classifications

• G06F9/44589

  Program code verification, e.g. Java bytecode verification, proof-carrying code (high-level semantic checks G06F8/43; prevention of errors by analysis, debugging or testing of software G06F11/36) · CPC title

• G06F9/445 Primary

  Program loading or initiating (bootstrapping G06F9/4401; security arrangements for program loading or initiating G06F21/57) · CPC title

• G06F11/3636

  by tracing the execution of the program · CPC title

• G06F9/44521 Primary

  Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading · CPC title

• G06F9/542

  Event management; Broadcasting; Multicasting; Notifications · CPC title