US20120159462A1 - Method for checkpointing and restoring program state - Google Patents
Method for checkpointing and restoring program state Download PDFInfo
- Publication number
- US20120159462A1 US20120159462A1 US12/972,792 US97279210A US2012159462A1 US 20120159462 A1 US20120159462 A1 US 20120159462A1 US 97279210 A US97279210 A US 97279210A US 2012159462 A1 US2012159462 A1 US 2012159462A1
- Authority
- US
- United States
- Prior art keywords
- function
- computer readable
- readable instructions
- checkpoint
- program
- 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/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/14—Error detection or correction of the data by redundancy in operation
- G06F11/1402—Saving, restoring, recovering or retrying
- G06F11/1415—Saving, restoring, recovering or retrying at system level
- G06F11/1438—Restarting or rejuvenating
-
- 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
-
- 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/3664—Environments for testing or debugging software
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/461—Saving or restoring of program or task context
Definitions
- the techniques described herein relate to enabling the restoration of execution of a computer process from a point of interruption.
- Program crashes are known to occur in which an application or other computer program terminates unexpectedly or ceases to operate as designed. Some programs save information from time to time so that, when a crash occurs, the amount of data loss can be limited. For example, some word processing programs automatically save drafts of a document at various times as a user works on the document. If the word processing program crashes, the user may be able to restore the document by loading saved data from the most recent point at which the document was automatically saved by the word processing program.
- Some operating systems provide the capability of receiving information from a program as it is running and can restore execution of the program from a saved state. However, in such techniques, cooperation from the operating system is required to allow the execution of the program to be restored.
- Some applications have been specifically designed and programmed to include the capability of saving program data and restoring program data when execution is interrupted. However, it would be time consuming for an application programmer to have to design and program an application to provide such capabilities when a new application is written or an existing application is modified.
- the techniques described herein provide a flexible framework at the program level for enabling the checkpointing and restoration of program execution.
- the Applicants have developed techniques for restoring program execution from the point at which execution was interrupted without the need for cooperation from the computer's operating system. These techniques can be implemented at the program level regardless of the operating system environment in which the program is running.
- code for implementing these techniques can be incorporated into existing program code using an automated tool that modifies the program and adds instructions for enabling restoring interrupted program execution.
- code for enabling restoring interrupted program execution can be automatically incorporated using the automated tool.
- Some embodiments relate to a method, comprising: receiving first computer readable instructions configured to control a microprocessor to perform one or more operations; using a microprocessor, generating second computer readable instructions based on the first computer readable instructions, the second computer readable instructions being configured to perform the one or more operations and to resume execution of a function from a checkpoint by calling the function; loading data for use by the function, the data having been saved at the checkpoint during a prior execution of the function; and skipping a portion of the function that was executed during the prior execution of the function before reaching the checkpoint.
- Some embodiments relate to a computer readable storage medium having stored thereon instructions which, when executed, perform the above-described method.
- Some embodiments relate to a system comprising: a computer readable storage medium having stored thereon computer readable instructions configured to resume execution of function from a checkpoint by calling the function; loading data for use by the function, the data having been saved at the checkpoint during a prior execution of the function; skipping a portion of the function that was executed during the prior execution of the function before reaching the checkpoint; saving data used by the function; and tracking a program stack of a program comprising the function.
- the system also includes at least one microprocessor configured to execute the computer readable instructions.
- FIG. 1 shows a diagram of a software module that includes computer-readable instructions for performing operations as part of a function F of a computer program, according to some embodiments.
- FIG. 2 shows a flowchart of a method of executing a program that includes saving the program state and program data at various checkpoints, according to some embodiments.
- FIG. 3 shows a flowchart of a method of re-building the execution of a function from a checkpoint, according to some embodiments.
- FIG. 4 shows a flowchart of a method of modifying code to enable restoring operation of a program from a checkpoint, according to some embodiments.
- FIG. 5 shows an example of a computing device having a plurality of microprocessors on which the techniques described herein can be implemented.
- FIG. 6 shows an example of a computing environment that includes computing devices on which the techniques described herein can be implemented.
- the techniques described herein enable restoring program execution from a checkpoint when execution is interrupted, without the need for cooperation from the computer's operating system.
- Such techniques can protect against instability in the underlying hardware or software, and can enable restoring program execution after an operating system crash, power failure, or other failure in the system.
- These techniques can be implemented by modifying existing code using an automated tool without requiring a programmer to program the application specifically to include this functionality.
- a compiler or other program translation tool can re-configure existing code to provide the capability of saving and restoring execution of the program after an error occurs.
- these techniques can be robust in a multithreaded, multicore environment and for an environment in which a program runs on multiple machines. When execution is interrupted and is unable to continue, programs can continue execution on a different processor or a different machine, even on a machine that is running a different operating system. These techniques can be used advantageously in a cloud computing environment in which multiple machines are available to execute a program. A detailed discussion of an exemplary embodiment is provided hereafter.
- Commonly-used program languages provide the capability of defining functions that may be called during execution of a program.
- Code defines key aspects of the function, such as the inputs that the function accepts, the operations performed by the function, and the data returned by the function.
- Function F receives integers a and b as input.
- Function F initializes a local variable x to be an integer that is set equal to the product a ⁇ b and initializes variable y to be an integer that is set equal to the return value of function G.
- Function F returns an integer having the value x+y.
- Function G receives integers x and b as inputs which correspond to local variables a and b within function G, respectively.
- Function G initializes a local variable x to be an integer that is set equal to a+b.
- Function G returns an integer equal to the value of x.
- function F When a program is run, function F can be called which then calls function G. If the program crashes or execution otherwise is interrupted during the execution of function F and/or G, the progress made in executing functions F and/or G can be lost. To continue execution, the program needs to be re-started and function F needs to be started again from the beginning, and then function G needs to be called again.
- the amount of processing power needed to execute exemplary functions F and G may not be large, it should be appreciated that, when executing a complex program, significant data may be lost and significant processing may need to be performed a second time to reach the point at which the execution of functions F and/or G was interrupted. The amount of lost work can be particularly significant when executing complex programming tasks such as modeling and simulation, for example.
- additional code can be inserted into a program to enable storing the state of operation of the program at various points, called “checkpoints.”
- Code can be included for tracking the program stack by saving an indication as to which functions are running.
- Code can also be included for storing local variables used by the functions and for saving an indication of the line within a function that has been reached in execution. The addition of these types of code can enable re-building the program by calling one or more functions that were in operation at the checkpoint, loading local variables that were in use by the function(s), and skipping the portion of the function(s) already executed prior to interruption.
- FIG. 1 shows an example of a software module 100 that includes computer-readable instructions for performing operations of function F of a computer program and for enabling restoring program execution.
- the computer readable instructions of software module 100 enable tracking the state of execution of the function within the program, saving data used by the function at various checkpoints during program execution, and restoring execution of the function from a checkpoint when the program is interrupted.
- software module 100 includes helper code 102 , a function preamble 104 , functional code 106 for performing the operations of function F, call site label code 108 , and a function epilogue 110 .
- Helper code 102 can include code 112 that defines a data structure for saving the local variables and input arguments of function F. Helper code 102 can also include code 114 that defines a save function for saving data for function F and code 116 that defines a load function for loading data for function F from storage. The save function appends the saved variables to a checkpoint file. The load function loads the variables from the current point in the checkpoint file and advances the file pointer.
- code 112 defines a data structure for saving the local variables and input arguments of function F.
- Helper code 102 can also include code 114 that defines a save function for saving data for function F and code 116 that defines a load function for loading data for function F from storage.
- the save function appends the saved variables to a checkpoint file.
- the load function loads the variables from the current point in the checkpoint file and advances the file pointer.
- function preamble 104 can include code 118 that instantiates a data structure object for the local variables of function F and code 120 for tracking the program stack by saving an indication that function F is being executed using the push( ) function.
- Function preamble 104 can also include code 122 capable of rebuilding the execution of function F from a checkpoint. If the execution of function F is being rebuilt, code 124 is executed to load the local variables for function F that were saved at the checkpoint. Code 126 is executed to skip a portion of function F that was already executed before reaching the checkpoint. For example, if function G was in execution within the scope of function F when execution of the program was interrupted, code 126 can skip to the line of function F that calls function G.
- An example of a functional preamble 104 that may be used in some embodiments is shown below.
- functional code 106 is included for performing the operations of a function, e.g., function F.
- function F is discussed by way of example, the techniques described herein can be used for any function performing one or more operations of a computer program.
- Functional code 106 can be re-written from that of the original function, e.g., function F, so that local variables are stored in the data structure defined by code 112 to facilitate saving of data during execution so that the variables can be loaded later if it is necessary to re-build the execution of function F.
- An example of functional code 106 for use in some embodiments is shown below.
- variable x is set equal to the product a ⁇ b.
- code 106 the same multiplication operation is performed as in function F, but the code is modified so that the result is stored in the data structure defined by code 112 to facilitate re-loading the local variable if the function needs to be re-built.
- call site label code 130 can include code identifying where other functions are called within function F.
- function F may call another function G, and call site label code 130 can identify the location within function F where function G is called.
- Code 132 is also included in function F for calling function G.
- An example of call site label code 130 for use in some embodiments is shown below.
- additional functional code 106 may be included, such as the following, which is executed to calculate the sum of variables x and y, as in function F above.
- function epilogue 110 can include code 134 for updating tracking of the program stack using the pop( ) function when the execution of function F is to be completed.
- Function epilogue 110 can also include code 136 for returning data by function F.
- An example of a function epilogue 110 that may be used in some embodiments is shown below.
- the following code defines an example of a “Checkpoint” class which has the implementations of LoadLocals( ) and SaveLocals( ) which are in turn used by the Load( ) and Save( )methods of the “Locals” objects.
- FIG. 2 shows an example of a method 200 of executing a program and saving the program state at various checkpoints.
- the stack of locals objects can be traversed and each one can be saved in turn.
- Execution of the program begins at step 202 .
- a checkpoint opportunity is reached at which the program has the option of saving the state of the program.
- the program can make a determination at step 203 as to whether to make use of the checkpoint opportunity to save the program state.
- the decision as to whether the program uses the checkpoint opportunity can be made based upon the amount of time that has elapsed since the last checkpoint, or any other suitable criteria. In some cases, the user may explicitly request a checkpoint.
- There is a tradeoff between the frequency of saving the program state and the performance of the program Increasing the frequency at which the program state is saved can limit the amount of data loss, but can cause decreased program performance.
- the frequency with which checkpoint opportunities are taken can vary depending on the application.
- step 204 If the program decides to use the checkpoint opportunity to save the program state, this information is saved in step 204 .
- the program may use the save function defined by code 114 in helper code 102 .
- step 206 Execution of the program continues until the next checkpoint is reached, at which point the method returns to the next checkpoint opportunity at step 203 .
- Method 200 can continue until the program is terminated.
- FIG. 3 shows a method 300 of restoring the execution of a function from a checkpoint, according to some embodiments.
- the program is re-started after a crash or other failure has occurred.
- the program calls a first function, such as function F discussed above.
- the local variables for function F that were saved at the checkpoint are loaded from storage in step 306 .
- the program skips to the line of function F that was in execution at the checkpoint, and execution of function F is resumed from that point.
- steps 306 and 308 facilitate restoring the execution of function F to the point of execution when the program state was saved at the checkpoint.
- step 310 If function G was in execution at the checkpoint, the program can skip to the line of function F that calls function G, and then function G is called in step 310 . Steps 306 and 308 are then repeated for function G.
- the local variables for function G that were saved at the checkpoint are loaded from storage, and the program skips to the line of function G that was in execution at the checkpoint. If no other functions were in execution within the scope of the previous function, the method ends and program execution continues from the checkpoint. Thus, execution of the program can resume from the checkpoint without requiring re-executing all of the operations that were executed before the checkpoint was reached, prior to interruption of the program.
- FIG. 4 illustrates a method of modifying code to enable restoring operation of a program from a checkpoint, according to some embodiments.
- a program translation tool such as a compiler can modify existing code to enable restoring operation of a program from a checkpoint.
- a compiler or other program translation tool can receive program code that includes code defining one or more functions.
- the program code can be designed to perform any suitable operation, as the techniques described herein are not limited as to the type of operation performed by the program.
- the program code may include code defining functions F and G, as discussed above.
- the code for executing functions F and G is modified to enable the program to restore execution from a checkpoint.
- the compiler or other program translation tool can insert helper code 102 , function preamble 104 , call site label code 108 , and function epilogue 110 , as discussed above.
- Checkpoint opportunities can also be inserted at suitable locations within the code for saving data.
- the functional code 106 can be modified to make use of the data structure for storing local variables defined in helper code 102 . If a compiler is used to perform method 400 , the result produced can be object code that is configured to perform functions F and G, with the additional capability of enabling restoring the execution of functions F and G from a checkpoint when an interruption occurs.
- the techniques described herein can provide fault tolerance and failover schemes which can be very significant for programs with long execution times. This is due to the increased cost of lost work as the size of the computation grows. These techniques can also be very useful for distributed programs that make use of large computing resources, as the likelihood of failure is higher when more hardware is used to perform the computation. Trends in new computing hardware have shifted from a paradigm in which each successive generation of hardware is exponentially faster to one in which each successive generation has exponentially more computational cores.
- the techniques described herein can be used to enable performing large amounts of computational work using multithreaded programs running on multiple computational cores, or a cluster of machines. For example, such techniques can be used in a cloud computing environment in which multiple machines and/or multiple cores are involved in processing program data.
- An advantage of the techniques described herein is that a program can be started on one processor/machine and then processing can continue on another processor/machine when a crash or other failure occurs. If one processor or machine fails, processing can resume on another processor or machine with minimal interruption. Since the techniques described herein do not require the cooperation of the operating system, processing could continue on a processor/machine that is running a different operating system, in some embodiments.
- the program can run on a different operating system if a suitable version is compiled on the new architecture and the file format for checkpoints is portable across architectures.
- FIG. 5 shows an example of a computing device 501 having a plurality of microprocessors 502 and 503 .
- An entire program or a program thread may be running on microprocessor 502 when a crash or other failure occurs that interrupts execution.
- the program or program thread can continue execution of the program on microprocessor 503 using data stored in persistent storage 504 representing the state of execution of the program.
- FIG. 6 shows an example of a computing environment that includes computing device 601 having microprocessor 602 and computing device 603 having microprocessor 604 .
- a program or program thread may be running on microprocessor 602 when a crash or other failure occurs that interrupts execution. Using the techniques described herein, the program or program thread can continue execution of the program on microprocessor 604 of device 603 .
- Devices 601 and 603 may be connected by any suitable communication connection.
- Devices 501 , 601 and 603 may be any suitable computing devices such as general purpose computers, or other devices described herein, for example.
- the above-described embodiments of the present invention can be implemented in any of numerous ways.
- the embodiments may be implemented using hardware, software or a combination thereof.
- the software code can be executed on any suitable processor or collection of processors, whether provided in a single computer or distributed among multiple computers.
- processors may be implemented as integrated circuits, with one or more processors in an integrated circuit component.
- a processor may be implemented using circuitry in any suitable format.
- a computer may be embodied in any of a number of forms, such as a rack-mounted computer, a desktop computer, a laptop computer, or a tablet computer. Additionally, a computer may be embedded in a device not generally regarded as a computer but with suitable processing capabilities, including a Personal Digital Assistant (PDA), a smart phone or any other suitable portable or fixed electronic device.
- PDA Personal Digital Assistant
- a computer may have one or more input and output devices. These devices can be used, among other things, to present a user interface. Examples of output devices that can be used to provide a user interface include printers or display screens for visual presentation of output and speakers or other sound generating devices for audible presentation of output. Examples of input devices that can be used for a user interface include keyboards, and pointing devices, such as mice, touch pads, and digitizing tablets. As another example, a computer may receive input information through speech recognition or in other audible format.
- Such computers may be interconnected by one or more networks in any suitable form, including as a local area network or a wide area network, such as an enterprise network or the Internet.
- networks may be based on any suitable technology and may operate according to any suitable protocol and may include wireless networks, wired networks or fiber optic networks.
- the various methods or processes outlined herein may be coded as software that is executable on one or more processors that employ any one of a variety of operating systems or platforms. Additionally, such software may be written using any of a number of suitable programming languages and/or programming or scripting tools, and also may be compiled as executable machine language code or intermediate code that is executed on a framework or virtual machine.
- the invention may be embodied as a computer readable storage medium (or multiple computer readable media) (e.g., a computer memory, one or more floppy discs, compact discs (CD), optical discs, digital video disks (DVD), magnetic tapes, flash memories, circuit configurations in Field Programmable Gate Arrays or other semiconductor devices, or other non-transitory, tangible computer storage medium) encoded with one or more programs that, when executed on one or more computers or other processors, perform methods that implement various embodiments of the invention.
- the computer readable storage medium or media can be transportable, such that the program or programs stored thereon can be loaded onto one or more different computers or other processors to implement various aspects of the present invention as discussed above.
- non-transitory computer-readable storage medium encompasses only a computer-readable medium that can be considered to be a manufacture (i.e., article of manufacture) or a machine.
- the invention may be embodied as a computer readable medium other than a computer-readable storage medium, such as a propagating signal.
- program or “software” are used herein in a generic sense to refer to any type of computer code or set of computer-executable instructions that can be employed to program a computer or other processor to implement various aspects of the present invention as discussed above. Additionally, it should be appreciated that according to one aspect of this embodiment, one or more computer programs that when executed perform methods of the present invention need not reside on a single computer or processor, but may be distributed in a modular fashion amongst a number of different computers or processors to implement various aspects of the present invention.
- Computer-executable instructions may be in many forms, such as program modules, executed by one or more computers or other devices.
- program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types.
- functionality of the program modules may be combined or distributed as desired in various embodiments.
- the invention may be embodied as a method, of which an example has been provided.
- the acts performed as part of the method may be ordered in any suitable way. Accordingly, embodiments may be constructed in which acts are performed in an order different than illustrated, which may include performing some acts simultaneously, even though shown as sequential acts in illustrative embodiments.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Quality & Reliability (AREA)
- Computer Hardware Design (AREA)
- Retry When Errors Occur (AREA)
- Software Systems (AREA)
- Devices For Executing Special Programs (AREA)
- Debugging And Monitoring (AREA)
Abstract
Description
- 1. Field of Invention
- The techniques described herein relate to enabling the restoration of execution of a computer process from a point of interruption.
- 2. Discussion of the Related Art
- Program crashes are known to occur in which an application or other computer program terminates unexpectedly or ceases to operate as designed. Some programs save information from time to time so that, when a crash occurs, the amount of data loss can be limited. For example, some word processing programs automatically save drafts of a document at various times as a user works on the document. If the word processing program crashes, the user may be able to restore the document by loading saved data from the most recent point at which the document was automatically saved by the word processing program.
- Some operating systems provide the capability of receiving information from a program as it is running and can restore execution of the program from a saved state. However, in such techniques, cooperation from the operating system is required to allow the execution of the program to be restored.
- As discussed above, some existing techniques for restoring execution of a program from a point of interruption require cooperation from the operating system. Such techniques require the operating system to provide an interface suitable for saving application data and restoring the state of operation of an application when execution is interrupted. However, not all operating systems provide such capabilities. It would be advantageous to provide the capability of restoring execution of a program at the application level without requiring cooperation from the operating system.
- Some applications have been specifically designed and programmed to include the capability of saving program data and restoring program data when execution is interrupted. However, it would be time consuming for an application programmer to have to design and program an application to provide such capabilities when a new application is written or an existing application is modified.
- The techniques described herein provide a flexible framework at the program level for enabling the checkpointing and restoration of program execution. The Applicants have developed techniques for restoring program execution from the point at which execution was interrupted without the need for cooperation from the computer's operating system. These techniques can be implemented at the program level regardless of the operating system environment in which the program is running. In some embodiments, code for implementing these techniques can be incorporated into existing program code using an automated tool that modifies the program and adds instructions for enabling restoring interrupted program execution. Thus, a programmer developing an application does not need to design or program the application code to include such features, as code for enabling restoring interrupted program execution can be automatically incorporated using the automated tool.
- Some embodiments relate to a method, comprising: receiving first computer readable instructions configured to control a microprocessor to perform one or more operations; using a microprocessor, generating second computer readable instructions based on the first computer readable instructions, the second computer readable instructions being configured to perform the one or more operations and to resume execution of a function from a checkpoint by calling the function; loading data for use by the function, the data having been saved at the checkpoint during a prior execution of the function; and skipping a portion of the function that was executed during the prior execution of the function before reaching the checkpoint. Some embodiments relate to a computer readable storage medium having stored thereon instructions which, when executed, perform the above-described method.
- Some embodiments relate to a system comprising: a computer readable storage medium having stored thereon computer readable instructions configured to resume execution of function from a checkpoint by calling the function; loading data for use by the function, the data having been saved at the checkpoint during a prior execution of the function; skipping a portion of the function that was executed during the prior execution of the function before reaching the checkpoint; saving data used by the function; and tracking a program stack of a program comprising the function. The system also includes at least one microprocessor configured to execute the computer readable instructions.
- The foregoing is a non-limiting summary of some embodiments.
- In the drawings, each identical or nearly identical component that is illustrated in various figures is represented by a like reference character. For purposes of clarity, not every component may be labeled in every drawing. The drawings are not necessarily drawn to scale, with emphasis instead being placed on illustrating various aspects of the invention.
-
FIG. 1 shows a diagram of a software module that includes computer-readable instructions for performing operations as part of a function F of a computer program, according to some embodiments. -
FIG. 2 shows a flowchart of a method of executing a program that includes saving the program state and program data at various checkpoints, according to some embodiments. -
FIG. 3 shows a flowchart of a method of re-building the execution of a function from a checkpoint, according to some embodiments. -
FIG. 4 shows a flowchart of a method of modifying code to enable restoring operation of a program from a checkpoint, according to some embodiments. -
FIG. 5 shows an example of a computing device having a plurality of microprocessors on which the techniques described herein can be implemented. -
FIG. 6 shows an example of a computing environment that includes computing devices on which the techniques described herein can be implemented. - As discussed above, the techniques described herein enable restoring program execution from a checkpoint when execution is interrupted, without the need for cooperation from the computer's operating system. Such techniques can protect against instability in the underlying hardware or software, and can enable restoring program execution after an operating system crash, power failure, or other failure in the system. These techniques can be implemented by modifying existing code using an automated tool without requiring a programmer to program the application specifically to include this functionality. In some embodiments, a compiler or other program translation tool can re-configure existing code to provide the capability of saving and restoring execution of the program after an error occurs.
- Advantageously, these techniques can be robust in a multithreaded, multicore environment and for an environment in which a program runs on multiple machines. When execution is interrupted and is unable to continue, programs can continue execution on a different processor or a different machine, even on a machine that is running a different operating system. These techniques can be used advantageously in a cloud computing environment in which multiple machines are available to execute a program. A detailed discussion of an exemplary embodiment is provided hereafter.
- Commonly-used program languages provide the capability of defining functions that may be called during execution of a program. Code defines key aspects of the function, such as the inputs that the function accepts, the operations performed by the function, and the data returned by the function.
- For example, the following code defines functions F and G. Function F receives integers a and b as input. Function F initializes a local variable x to be an integer that is set equal to the product a·b and initializes variable y to be an integer that is set equal to the return value of function G. Function F returns an integer having the value x+y. Function G receives integers x and b as inputs which correspond to local variables a and b within function G, respectively. Function G initializes a local variable x to be an integer that is set equal to a+b. Function G returns an integer equal to the value of x.
-
int F(int a, int b) { int x = a*b; int y = G(x,b); return x+y; } int G(int a, int b) { int x = a+b; return x; } - When a program is run, function F can be called which then calls function G. If the program crashes or execution otherwise is interrupted during the execution of function F and/or G, the progress made in executing functions F and/or G can be lost. To continue execution, the program needs to be re-started and function F needs to be started again from the beginning, and then function G needs to be called again. Although the amount of processing power needed to execute exemplary functions F and G may not be large, it should be appreciated that, when executing a complex program, significant data may be lost and significant processing may need to be performed a second time to reach the point at which the execution of functions F and/or G was interrupted. The amount of lost work can be particularly significant when executing complex programming tasks such as modeling and simulation, for example.
- In some embodiments, additional code can be inserted into a program to enable storing the state of operation of the program at various points, called “checkpoints.” Code can be included for tracking the program stack by saving an indication as to which functions are running. Code can also be included for storing local variables used by the functions and for saving an indication of the line within a function that has been reached in execution. The addition of these types of code can enable re-building the program by calling one or more functions that were in operation at the checkpoint, loading local variables that were in use by the function(s), and skipping the portion of the function(s) already executed prior to interruption.
-
FIG. 1 shows an example of asoftware module 100 that includes computer-readable instructions for performing operations of function F of a computer program and for enabling restoring program execution. The computer readable instructions ofsoftware module 100 enable tracking the state of execution of the function within the program, saving data used by the function at various checkpoints during program execution, and restoring execution of the function from a checkpoint when the program is interrupted. In the example ofFIG. 1 ,software module 100 includeshelper code 102, afunction preamble 104,functional code 106 for performing the operations of function F, callsite label code 108, and afunction epilogue 110. -
Helper code 102 can includecode 112 that defines a data structure for saving the local variables and input arguments of functionF. Helper code 102 can also includecode 114 that defines a save function for saving data for function F andcode 116 that defines a load function for loading data for function F from storage. The save function appends the saved variables to a checkpoint file. The load function loads the variables from the current point in the checkpoint file and advances the file pointer. Although shown as source code for purposes of illustrating the concept, it should be appreciated thathelper code 102 and any other code described herein may be implemented as object code, or any other suitable type of code. An example ofhelper code 102 suitable for defining a data structure and providing save and load functions is shown below. -
struct F_Locals : Locals { // local variables int x; int y; // input arguments int a; int b; virtual void Save( ) { g_pCheckpoint->SaveLocals(this); }; virtual void Load( ) { g_pCheckpoint->LoadLocals(this); } }; // Base frame structure from which function-specific versions derive struct Locals { virtual void Save( ) = 0; virtual void Load( ) = 0; int _CallSite; // Next structure. This is used to preserve ordering of stack frames in the example implementation, // but any of several alternative solutions can be used for this, as appropriate. Locals * m_pNext; }; - As shown in
FIG. 1 ,function preamble 104 can includecode 118 that instantiates a data structure object for the local variables of function F andcode 120 for tracking the program stack by saving an indication that function F is being executed using the push( ) function.Function preamble 104 can also includecode 122 capable of rebuilding the execution of function F from a checkpoint. If the execution of function F is being rebuilt,code 124 is executed to load the local variables for function F that were saved at the checkpoint.Code 126 is executed to skip a portion of function F that was already executed before reaching the checkpoint. For example, if function G was in execution within the scope of function F when execution of the program was interrupted,code 126 can skip to the line of function F that calls function G. An example of afunctional preamble 104 that may be used in some embodiments is shown below. -
int F(int a, int b) { F_Locals l; Push(&l); // Checkpointing if (g_RebuildMode) { // Deserialize locals from checkpoint l.Load( ); // Jump to proper line int i = l._CallSite; switch(i) { case 1: goto FunctionCall1; //where G } // is called } - As shown in
FIG. 1 ,functional code 106 is included for performing the operations of a function, e.g., function F. Although function F is discussed by way of example, the techniques described herein can be used for any function performing one or more operations of a computer program.Functional code 106 can be re-written from that of the original function, e.g., function F, so that local variables are stored in the data structure defined bycode 112 to facilitate saving of data during execution so that the variables can be loaded later if it is necessary to re-build the execution of function F. An example offunctional code 106 for use in some embodiments is shown below. - l.x=a*b;
- As discussed above with respect to function F, the variable x is set equal to the product a·b. In
functional code 106, the same multiplication operation is performed as in function F, but the code is modified so that the result is stored in the data structure defined bycode 112 to facilitate re-loading the local variable if the function needs to be re-built. - As shown in
FIG. 1 , callsite label code 130 can include code identifying where other functions are called within function F. For example, function F may call another function G, and callsite label code 130 can identify the location within function F where function G is called.Code 132 is also included in function F for calling function G. An example of callsite label code 130 for use in some embodiments is shown below. -
FunctionCall1: l._CallSite = 1; l.y = G(l.x,b); - At this point, additional
functional code 106 may be included, such as the following, which is executed to calculate the sum of variables x and y, as in function F above. - int temp=l.x+l.y;
- As shown in
FIG. 1 ,function epilogue 110 can includecode 134 for updating tracking of the program stack using the pop( ) function when the execution of function F is to be completed.Function epilogue 110 can also includecode 136 for returning data by function F. An example of afunction epilogue 110 that may be used in some embodiments is shown below. -
Pop( ); return temp; }
Sample implementations of Push( ) and Pop( ) are shown below, by way of example. -
Locals * g_pStack = NULL; void Push(Locals * pNewFrame) { pNewFrame->m_pNext = g_pStack; g_pStack = pNewFrame; } void Pop( ) { Locals * pTop = g_pStack; g_pStack = pTop->m_pNext; pTop->m_pNext = NULL; } - The following code defines an example of a “Checkpoint” class which has the implementations of LoadLocals( ) and SaveLocals( ) which are in turn used by the Load( ) and Save( )methods of the “Locals” objects.
-
// False if running normally. True if rebuilding the stack from a check point. bool g_RebuildMode = false; class Checkpoint { public: Checkpoint( ) { idx = 0; } // // Helpers for reading a checkpoint // // Copy locals out of checkpoint into the data structure template<class T> void LoadLocals(T * p) { Locals * pNext = (Locals*) p; int cb = sizeof(T); memcpy(p, &pBuffer[idx], cb); // Alternatively, read from persistent storage at this step. ((Locals*)p)->m_pNext = pNext; idx+= cb; }; // // Helpers for creating a checkpoint // template<class T> void SaveLocals(T * p) { int cb = sizeof(T); memcpy(&pBuffer[idx], p, cb); // Alternatively, write directly to persistent storage at this step. idx+= cb; }; void Done( ) { idx = 0; } private: int idx; BYTE pBuffer[1000]; // For example purposes, a buffer in memory is used. Can be replaced with allocation of persistent storage. }; Checkpoint * g_pCheckpoint = NULL; -
FIG. 2 shows an example of amethod 200 of executing a program and saving the program state at various checkpoints. To save the program state, the stack of locals objects can be traversed and each one can be saved in turn. Execution of the program begins atstep 202. Atstep 203, a checkpoint opportunity is reached at which the program has the option of saving the state of the program. The program can make a determination atstep 203 as to whether to make use of the checkpoint opportunity to save the program state. The decision as to whether the program uses the checkpoint opportunity can be made based upon the amount of time that has elapsed since the last checkpoint, or any other suitable criteria. In some cases, the user may explicitly request a checkpoint. There is a tradeoff between the frequency of saving the program state and the performance of the program. Increasing the frequency at which the program state is saved can limit the amount of data loss, but can cause decreased program performance. The frequency with which checkpoint opportunities are taken can vary depending on the application. - If the program decides to use the checkpoint opportunity to save the program state, this information is saved in
step 204. For example, the program may use the save function defined bycode 114 inhelper code 102. If the program decides not to use the checkpoint opportunity, execution of the program continues instep 206. Execution of the program continues until the next checkpoint is reached, at which point the method returns to the next checkpoint opportunity atstep 203.Method 200 can continue until the program is terminated. - III. Example of Restoring Program Execution from a Checkpoint
-
FIG. 3 shows amethod 300 of restoring the execution of a function from a checkpoint, according to some embodiments. Instep 302, the program is re-started after a crash or other failure has occurred. Instep 304, the program calls a first function, such as function F discussed above. The local variables for function F that were saved at the checkpoint are loaded from storage instep 306. Instep 308, the program skips to the line of function F that was in execution at the checkpoint, and execution of function F is resumed from that point. Thus, steps 306 and 308 facilitate restoring the execution of function F to the point of execution when the program state was saved at the checkpoint. If function G was in execution at the checkpoint, the program can skip to the line of function F that calls function G, and then function G is called instep 310.Steps - IV. Generating Code Enabling Saving State and Restoring Program Execution from a Checkpoint
-
FIG. 4 illustrates a method of modifying code to enable restoring operation of a program from a checkpoint, according to some embodiments. As discussed above, the techniques described herein advantageously can be incorporated into a program automatically without manual coding by a programmer. A program translation tool such as a compiler can modify existing code to enable restoring operation of a program from a checkpoint. For example, instep 402, a compiler or other program translation tool can receive program code that includes code defining one or more functions. The program code can be designed to perform any suitable operation, as the techniques described herein are not limited as to the type of operation performed by the program. As an example, the program code may include code defining functions F and G, as discussed above. Instep 404, the code for executing functions F and G is modified to enable the program to restore execution from a checkpoint. For example, the compiler or other program translation tool can inserthelper code 102,function preamble 104, callsite label code 108, andfunction epilogue 110, as discussed above. Checkpoint opportunities can also be inserted at suitable locations within the code for saving data. Thefunctional code 106 can be modified to make use of the data structure for storing local variables defined inhelper code 102. If a compiler is used to performmethod 400, the result produced can be object code that is configured to perform functions F and G, with the additional capability of enabling restoring the execution of functions F and G from a checkpoint when an interruption occurs. - The techniques described herein can provide fault tolerance and failover schemes which can be very significant for programs with long execution times. This is due to the increased cost of lost work as the size of the computation grows. These techniques can also be very useful for distributed programs that make use of large computing resources, as the likelihood of failure is higher when more hardware is used to perform the computation. Trends in new computing hardware have shifted from a paradigm in which each successive generation of hardware is exponentially faster to one in which each successive generation has exponentially more computational cores. The techniques described herein can be used to enable performing large amounts of computational work using multithreaded programs running on multiple computational cores, or a cluster of machines. For example, such techniques can be used in a cloud computing environment in which multiple machines and/or multiple cores are involved in processing program data.
- An advantage of the techniques described herein is that a program can be started on one processor/machine and then processing can continue on another processor/machine when a crash or other failure occurs. If one processor or machine fails, processing can resume on another processor or machine with minimal interruption. Since the techniques described herein do not require the cooperation of the operating system, processing could continue on a processor/machine that is running a different operating system, in some embodiments. The program can run on a different operating system if a suitable version is compiled on the new architecture and the file format for checkpoints is portable across architectures.
-
FIG. 5 shows an example of acomputing device 501 having a plurality ofmicroprocessors microprocessor 502 when a crash or other failure occurs that interrupts execution. Using the techniques described herein, the program or program thread can continue execution of the program onmicroprocessor 503 using data stored inpersistent storage 504 representing the state of execution of the program. -
FIG. 6 shows an example of a computing environment that includescomputing device 601 havingmicroprocessor 602 andcomputing device 603 havingmicroprocessor 604. A program or program thread may be running onmicroprocessor 602 when a crash or other failure occurs that interrupts execution. Using the techniques described herein, the program or program thread can continue execution of the program onmicroprocessor 604 ofdevice 603.Devices Devices - Having thus described several aspects of at least one embodiment of this invention, it is to be appreciated that various alterations, modifications, and improvements will readily occur to those skilled in the art.
- Such alterations, modifications, and improvements are intended to be part of this disclosure, and are intended to be within the spirit and scope of the invention. Accordingly, the foregoing description and drawings are by way of example only.
- The above-described embodiments of the present invention can be implemented in any of numerous ways. For example, the embodiments may be implemented using hardware, software or a combination thereof. When implemented in software, the software code can be executed on any suitable processor or collection of processors, whether provided in a single computer or distributed among multiple computers. Such processors may be implemented as integrated circuits, with one or more processors in an integrated circuit component. Though, a processor may be implemented using circuitry in any suitable format.
- Further, it should be appreciated that a computer may be embodied in any of a number of forms, such as a rack-mounted computer, a desktop computer, a laptop computer, or a tablet computer. Additionally, a computer may be embedded in a device not generally regarded as a computer but with suitable processing capabilities, including a Personal Digital Assistant (PDA), a smart phone or any other suitable portable or fixed electronic device.
- Also, a computer may have one or more input and output devices. These devices can be used, among other things, to present a user interface. Examples of output devices that can be used to provide a user interface include printers or display screens for visual presentation of output and speakers or other sound generating devices for audible presentation of output. Examples of input devices that can be used for a user interface include keyboards, and pointing devices, such as mice, touch pads, and digitizing tablets. As another example, a computer may receive input information through speech recognition or in other audible format.
- Such computers may be interconnected by one or more networks in any suitable form, including as a local area network or a wide area network, such as an enterprise network or the Internet. Such networks may be based on any suitable technology and may operate according to any suitable protocol and may include wireless networks, wired networks or fiber optic networks.
- Also, the various methods or processes outlined herein may be coded as software that is executable on one or more processors that employ any one of a variety of operating systems or platforms. Additionally, such software may be written using any of a number of suitable programming languages and/or programming or scripting tools, and also may be compiled as executable machine language code or intermediate code that is executed on a framework or virtual machine.
- In this respect, the invention may be embodied as a computer readable storage medium (or multiple computer readable media) (e.g., a computer memory, one or more floppy discs, compact discs (CD), optical discs, digital video disks (DVD), magnetic tapes, flash memories, circuit configurations in Field Programmable Gate Arrays or other semiconductor devices, or other non-transitory, tangible computer storage medium) encoded with one or more programs that, when executed on one or more computers or other processors, perform methods that implement various embodiments of the invention. The computer readable storage medium or media can be transportable, such that the program or programs stored thereon can be loaded onto one or more different computers or other processors to implement various aspects of the present invention as discussed above. As used herein, the term “non-transitory computer-readable storage medium” encompasses only a computer-readable medium that can be considered to be a manufacture (i.e., article of manufacture) or a machine. Alternatively or additionally, the invention may be embodied as a computer readable medium other than a computer-readable storage medium, such as a propagating signal.
- The terms “program” or “software” are used herein in a generic sense to refer to any type of computer code or set of computer-executable instructions that can be employed to program a computer or other processor to implement various aspects of the present invention as discussed above. Additionally, it should be appreciated that according to one aspect of this embodiment, one or more computer programs that when executed perform methods of the present invention need not reside on a single computer or processor, but may be distributed in a modular fashion amongst a number of different computers or processors to implement various aspects of the present invention.
- Computer-executable instructions may be in many forms, such as program modules, executed by one or more computers or other devices. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Typically the functionality of the program modules may be combined or distributed as desired in various embodiments.
- Various aspects of the present invention may be used alone, in combination, or in a variety of arrangements not specifically discussed in the embodiments described in the foregoing and is therefore not limited in its application to the details and arrangement of components set forth in the foregoing description or illustrated in the drawings. For example, aspects described in one embodiment may be combined in any manner with aspects described in other embodiments.
- Also, the invention may be embodied as a method, of which an example has been provided. The acts performed as part of the method may be ordered in any suitable way. Accordingly, embodiments may be constructed in which acts are performed in an order different than illustrated, which may include performing some acts simultaneously, even though shown as sequential acts in illustrative embodiments.
- Use of ordinal terms such as “first,” “second,” “third,” etc., in the claims to modify a claim element does not by itself connote any priority, precedence, or order of one claim element over another or the temporal order in which acts of a method are performed, but are used merely as labels to distinguish one claim element having a certain name from another element having a same name (but for use of the ordinal term) to distinguish the claim elements.
- Also, the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting. The use of “including,” “comprising,” or “having,” “containing,” “involving,” and variations thereof herein, is meant to encompass the items listed thereafter and equivalents thereof as well as additional items.
Claims (20)
Priority Applications (8)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US12/972,792 US9740562B2 (en) | 2010-12-20 | 2010-12-20 | Method for checkpointing and restoring program state |
CN201110428259.2A CN102736948B (en) | 2010-12-20 | 2011-12-19 | Method for checkpointing and restoring program state |
PCT/US2011/066280 WO2012088171A2 (en) | 2010-12-20 | 2011-12-20 | Method for checkpointing and restoring program state |
CA2821522A CA2821522A1 (en) | 2010-12-20 | 2011-12-20 | Method for checkpointing and restoring program state |
JP2013546344A JP6027020B2 (en) | 2010-12-20 | 2011-12-20 | How to checkpoint and restore program state |
EP11851108.8A EP2656217A4 (en) | 2010-12-20 | 2011-12-20 | Method for checkpointing and restoring program state |
KR1020137015985A KR101903805B1 (en) | 2010-12-20 | 2011-12-20 | Method for checkpointing and restoring program state |
HK13102145.5A HK1175005A1 (en) | 2010-12-20 | 2013-02-20 | A method for checkpointing and restoring program state |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US12/972,792 US9740562B2 (en) | 2010-12-20 | 2010-12-20 | Method for checkpointing and restoring program state |
Publications (2)
Publication Number | Publication Date |
---|---|
US20120159462A1 true US20120159462A1 (en) | 2012-06-21 |
US9740562B2 US9740562B2 (en) | 2017-08-22 |
Family
ID=46236230
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US12/972,792 Active 2032-05-12 US9740562B2 (en) | 2010-12-20 | 2010-12-20 | Method for checkpointing and restoring program state |
Country Status (8)
Country | Link |
---|---|
US (1) | US9740562B2 (en) |
EP (1) | EP2656217A4 (en) |
JP (1) | JP6027020B2 (en) |
KR (1) | KR101903805B1 (en) |
CN (1) | CN102736948B (en) |
CA (1) | CA2821522A1 (en) |
HK (1) | HK1175005A1 (en) |
WO (1) | WO2012088171A2 (en) |
Cited By (8)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9069782B2 (en) | 2012-10-01 | 2015-06-30 | The Research Foundation For The State University Of New York | System and method for security and privacy aware virtual machine checkpointing |
US20150278077A1 (en) * | 2014-03-25 | 2015-10-01 | International Business Machines Corporation | Dynamic code injection |
US9767284B2 (en) | 2012-09-14 | 2017-09-19 | The Research Foundation For The State University Of New York | Continuous run-time validation of program execution: a practical approach |
US9767271B2 (en) | 2010-07-15 | 2017-09-19 | The Research Foundation For The State University Of New York | System and method for validating program execution at run-time |
US20170357558A1 (en) * | 2016-06-13 | 2017-12-14 | Fujitsu Limited | Apparatus and method to enable a corrected program to take over data used before correction thereof |
US10853178B1 (en) * | 2018-05-18 | 2020-12-01 | Amazon Technologies, Inc. | Code function checkpoint and restore |
CN112384895A (en) * | 2018-05-01 | 2021-02-19 | 亚马逊技术公司 | Function portability for implementing a service hub using function checkpoints |
US11368470B2 (en) * | 2019-06-13 | 2022-06-21 | International Business Machines Corporation | Real-time alert reasoning and priority-based campaign discovery |
Families Citing this family (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN108241543B (en) * | 2016-12-30 | 2020-07-07 | 深圳壹账通智能科技有限公司 | Method, service server and system for executing service operation breakpoint |
EP3605374A1 (en) | 2018-08-03 | 2020-02-05 | Hewlett-Packard Development Company, L.P. | Intrusion resilient applications |
WO2020146011A1 (en) * | 2019-01-10 | 2020-07-16 | Mentor Graphics Corporation | Software checkpoint-restoration between distinctly compiled executables |
CN111198689B (en) * | 2019-12-30 | 2023-04-28 | 北京明略软件系统有限公司 | Code execution method, device and computer readable storage medium |
CN113778742A (en) * | 2020-06-09 | 2021-12-10 | 华为技术有限公司 | Program execution method, program processing method, and related apparatus |
US11467850B2 (en) | 2020-11-11 | 2022-10-11 | Micron Technology, Inc. | Computing device reboot |
CN113127248B (en) * | 2021-04-02 | 2022-08-09 | 清华大学 | Automatic crash recovery method and system for ROS program of robot |
US11899546B2 (en) | 2022-05-26 | 2024-02-13 | Red Hat, Inc. | Portability of checkpoints of an application using central processing unit (CPU)-specific functions |
KR102625338B1 (en) * | 2023-03-06 | 2024-01-15 | 주식회사 모레 | Method and system for parallel processing call list associated with artificial intelligence calculation |
Citations (31)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20030088807A1 (en) * | 2001-11-07 | 2003-05-08 | Mathiske Bernd J.W. | Method and apparatus for facilitating checkpointing of an application through an interceptor library |
US6631514B1 (en) * | 1998-01-06 | 2003-10-07 | Hewlett-Packard Development, L.P. | Emulation system that uses dynamic binary translation and permits the safe speculation of trapping operations |
US20040015883A1 (en) * | 2001-04-11 | 2004-01-22 | Robert Hundt | Analysis of executable program code using compiler-generated function entry points and endpoints with other sources of function entry points and endpoints |
US6708288B1 (en) * | 2000-10-31 | 2004-03-16 | Hewlett-Packard Development Company, L.P. | Compiler-based checkpointing for support of error recovery |
US20050034014A1 (en) * | 2002-08-30 | 2005-02-10 | Eternal Systems, Inc. | Consistent asynchronous checkpointing of multithreaded application programs based on semi-active or passive replication |
US6874138B1 (en) * | 2000-11-28 | 2005-03-29 | Hewlett-Packard Development Company, L.P. | Method and apparatus for resuming execution of a failed computer program |
US20050257090A1 (en) * | 2004-04-30 | 2005-11-17 | Santos Jose R | Method of restoring processes within process domain |
US20060206873A1 (en) * | 2005-03-11 | 2006-09-14 | Argade Pramod V | Environment for run control of computer programs |
US20070006047A1 (en) * | 2005-06-15 | 2007-01-04 | The Board Of Trustees Of The University Of Illinois | Architecture support system and method for memory monitoring |
US7240334B1 (en) * | 2000-06-29 | 2007-07-03 | International Business Machines Corporation | Methods, systems, and computer program products for deferred computer program tracing |
US20080052695A1 (en) * | 2006-08-22 | 2008-02-28 | Marc A Dickenson | Method and system for compilation error isolation, optimization and resolution |
US20080086730A1 (en) * | 2005-01-21 | 2008-04-10 | Marc Vertes | Predictive Method for Managing Logging or Replaying Non-Deterministic Operations within the Execution of an Application Process |
US20080282232A1 (en) * | 2007-05-09 | 2008-11-13 | International Business Machines Corporation | Iterative, Non-Uniform Profiling Method for Automatically Refining Performance Bottleneck Regions in Scientific Code |
US20090089610A1 (en) * | 2007-09-27 | 2009-04-02 | Microsoft Corporation | Rapid crash recovery for flash storage |
US20090094582A1 (en) * | 2007-10-04 | 2009-04-09 | David Jones Craft | Checkpoint and restartable applications and system services |
US20090132853A1 (en) * | 2005-08-29 | 2009-05-21 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Hardware-error tolerant computing |
US20090183181A1 (en) * | 2008-01-11 | 2009-07-16 | International Business Machines Corporation | Gathering pages allocated to an application to include in checkpoint information |
US20090183027A1 (en) * | 2008-01-11 | 2009-07-16 | International Business Machines Corporation | Checkpointing and restoring user space data structures used by an application |
US20090254888A1 (en) * | 2008-04-07 | 2009-10-08 | International Business Machines Corporation | Debug tours for software debugging |
US20090282386A1 (en) * | 2008-05-12 | 2009-11-12 | Moir Mark S | System and Method for Utilizing Available Best Effort Hardware Mechanisms for Supporting Transactional Memory |
US20100153776A1 (en) * | 2008-12-12 | 2010-06-17 | Sun Microsystems, Inc. | Using safepoints to provide precise exception semantics for a virtual machine |
US20100169895A1 (en) * | 2008-12-29 | 2010-07-01 | David Dice | Method and System for Inter-Thread Communication Using Processor Messaging |
US20100199128A1 (en) * | 2009-01-30 | 2010-08-05 | International Business Machines Corporation | Fanout connectivity structure for use in facilitating processing within a parallel computing environment |
US20100218167A1 (en) * | 2006-10-20 | 2010-08-26 | Her Majesty The Queen, In Right Of Canada As Represented By The Minister Of Health Through | Method and apparatus for software policy management |
US7814309B1 (en) * | 2000-02-29 | 2010-10-12 | Cisco Technology, Inc. | Method for checkpointing and reconstructing separated but interrelated data |
US20100262812A1 (en) * | 2009-04-08 | 2010-10-14 | Pedro Lopez | Register checkpointing mechanism for multithreading |
US20100293532A1 (en) * | 2009-05-13 | 2010-11-18 | Henrique Andrade | Failure recovery for stream processing applications |
US20110066831A1 (en) * | 2009-09-15 | 2011-03-17 | Ibm Corporation | System and method for software initiated checkpoint operations |
US20110126176A1 (en) * | 2009-11-25 | 2011-05-26 | International Business Machines Corporation | Providing Programming Support to Debuggers |
US8291383B1 (en) * | 2008-10-20 | 2012-10-16 | Google Inc. | Code analysis via dual branch exploration |
US9286109B1 (en) * | 2005-08-26 | 2016-03-15 | Open Invention Network, Llc | Method and system for providing checkpointing to windows application groups |
Family Cites Families (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6044475A (en) | 1995-06-16 | 2000-03-28 | Lucent Technologies, Inc. | Checkpoint and restoration systems for execution control |
US6154877A (en) | 1997-07-03 | 2000-11-28 | The University Of Iowa Research Foundation | Method and apparatus for portable checkpointing using data structure metrics and conversion functions |
US6161219A (en) | 1997-07-03 | 2000-12-12 | The University Of Iowa Research Foundation | System and method for providing checkpointing with precompile directives and supporting software to produce checkpoints, independent of environment constraints |
US6256751B1 (en) | 1998-10-29 | 2001-07-03 | International Business Machines Corporation | Restoring checkpointed processes without restoring attributes of external data referenced by the processes |
US6766471B2 (en) | 2000-12-28 | 2004-07-20 | International Business Machines Corporation | User-level checkpoint and restart for groups of processes |
US20040260678A1 (en) | 2003-06-18 | 2004-12-23 | Microsoft Corporation | State based configuration failure detection using checkpoint comparison |
US7536591B2 (en) | 2003-11-17 | 2009-05-19 | Virginia Tech Intellectual Properties, Inc. | Transparent checkpointing and process migration in a distributed system |
US7634687B2 (en) | 2005-01-13 | 2009-12-15 | Microsoft Corporation | Checkpoint restart system and method |
US7673181B1 (en) | 2006-06-07 | 2010-03-02 | Replay Solutions, Inc. | Detecting race conditions in computer programs |
US7669081B2 (en) | 2006-09-27 | 2010-02-23 | Raytheon Company | Systems and methods for scheduling, processing, and monitoring tasks |
-
2010
- 2010-12-20 US US12/972,792 patent/US9740562B2/en active Active
-
2011
- 2011-12-19 CN CN201110428259.2A patent/CN102736948B/en active Active
- 2011-12-20 WO PCT/US2011/066280 patent/WO2012088171A2/en active Application Filing
- 2011-12-20 KR KR1020137015985A patent/KR101903805B1/en active IP Right Grant
- 2011-12-20 EP EP11851108.8A patent/EP2656217A4/en not_active Ceased
- 2011-12-20 CA CA2821522A patent/CA2821522A1/en not_active Abandoned
- 2011-12-20 JP JP2013546344A patent/JP6027020B2/en active Active
-
2013
- 2013-02-20 HK HK13102145.5A patent/HK1175005A1/en unknown
Patent Citations (31)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6631514B1 (en) * | 1998-01-06 | 2003-10-07 | Hewlett-Packard Development, L.P. | Emulation system that uses dynamic binary translation and permits the safe speculation of trapping operations |
US7814309B1 (en) * | 2000-02-29 | 2010-10-12 | Cisco Technology, Inc. | Method for checkpointing and reconstructing separated but interrelated data |
US7240334B1 (en) * | 2000-06-29 | 2007-07-03 | International Business Machines Corporation | Methods, systems, and computer program products for deferred computer program tracing |
US6708288B1 (en) * | 2000-10-31 | 2004-03-16 | Hewlett-Packard Development Company, L.P. | Compiler-based checkpointing for support of error recovery |
US6874138B1 (en) * | 2000-11-28 | 2005-03-29 | Hewlett-Packard Development Company, L.P. | Method and apparatus for resuming execution of a failed computer program |
US20040015883A1 (en) * | 2001-04-11 | 2004-01-22 | Robert Hundt | Analysis of executable program code using compiler-generated function entry points and endpoints with other sources of function entry points and endpoints |
US20030088807A1 (en) * | 2001-11-07 | 2003-05-08 | Mathiske Bernd J.W. | Method and apparatus for facilitating checkpointing of an application through an interceptor library |
US20050034014A1 (en) * | 2002-08-30 | 2005-02-10 | Eternal Systems, Inc. | Consistent asynchronous checkpointing of multithreaded application programs based on semi-active or passive replication |
US20050257090A1 (en) * | 2004-04-30 | 2005-11-17 | Santos Jose R | Method of restoring processes within process domain |
US20080086730A1 (en) * | 2005-01-21 | 2008-04-10 | Marc Vertes | Predictive Method for Managing Logging or Replaying Non-Deterministic Operations within the Execution of an Application Process |
US20060206873A1 (en) * | 2005-03-11 | 2006-09-14 | Argade Pramod V | Environment for run control of computer programs |
US20070006047A1 (en) * | 2005-06-15 | 2007-01-04 | The Board Of Trustees Of The University Of Illinois | Architecture support system and method for memory monitoring |
US9286109B1 (en) * | 2005-08-26 | 2016-03-15 | Open Invention Network, Llc | Method and system for providing checkpointing to windows application groups |
US20090132853A1 (en) * | 2005-08-29 | 2009-05-21 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Hardware-error tolerant computing |
US20080052695A1 (en) * | 2006-08-22 | 2008-02-28 | Marc A Dickenson | Method and system for compilation error isolation, optimization and resolution |
US20100218167A1 (en) * | 2006-10-20 | 2010-08-26 | Her Majesty The Queen, In Right Of Canada As Represented By The Minister Of Health Through | Method and apparatus for software policy management |
US20080282232A1 (en) * | 2007-05-09 | 2008-11-13 | International Business Machines Corporation | Iterative, Non-Uniform Profiling Method for Automatically Refining Performance Bottleneck Regions in Scientific Code |
US20090089610A1 (en) * | 2007-09-27 | 2009-04-02 | Microsoft Corporation | Rapid crash recovery for flash storage |
US20090094582A1 (en) * | 2007-10-04 | 2009-04-09 | David Jones Craft | Checkpoint and restartable applications and system services |
US20090183027A1 (en) * | 2008-01-11 | 2009-07-16 | International Business Machines Corporation | Checkpointing and restoring user space data structures used by an application |
US20090183181A1 (en) * | 2008-01-11 | 2009-07-16 | International Business Machines Corporation | Gathering pages allocated to an application to include in checkpoint information |
US20090254888A1 (en) * | 2008-04-07 | 2009-10-08 | International Business Machines Corporation | Debug tours for software debugging |
US20090282386A1 (en) * | 2008-05-12 | 2009-11-12 | Moir Mark S | System and Method for Utilizing Available Best Effort Hardware Mechanisms for Supporting Transactional Memory |
US8291383B1 (en) * | 2008-10-20 | 2012-10-16 | Google Inc. | Code analysis via dual branch exploration |
US20100153776A1 (en) * | 2008-12-12 | 2010-06-17 | Sun Microsystems, Inc. | Using safepoints to provide precise exception semantics for a virtual machine |
US20100169895A1 (en) * | 2008-12-29 | 2010-07-01 | David Dice | Method and System for Inter-Thread Communication Using Processor Messaging |
US20100199128A1 (en) * | 2009-01-30 | 2010-08-05 | International Business Machines Corporation | Fanout connectivity structure for use in facilitating processing within a parallel computing environment |
US20100262812A1 (en) * | 2009-04-08 | 2010-10-14 | Pedro Lopez | Register checkpointing mechanism for multithreading |
US20100293532A1 (en) * | 2009-05-13 | 2010-11-18 | Henrique Andrade | Failure recovery for stream processing applications |
US20110066831A1 (en) * | 2009-09-15 | 2011-03-17 | Ibm Corporation | System and method for software initiated checkpoint operations |
US20110126176A1 (en) * | 2009-11-25 | 2011-05-26 | International Business Machines Corporation | Providing Programming Support to Debuggers |
Non-Patent Citations (5)
Title |
---|
Guoqing Xu, Efficient Checkpointing of Java Software Using Context-Sensitive Capture and Replay, 2007, pages 1-10. * |
Jooyong Lee, A Case for Dynamic Reverse-code Generation to Debug Non-deterministic Programs, 2006, pages 1-13. * |
Julia L. Lawall, Efficient Incremental Checkpointing of Java Programs, 2000, pages 1-10. * |
Lukasz Ziarek, Stabilizers: A Modular Checkpointing Abstraction for Concurrent Functional Programs, 2006, pages 1-12. * |
Raphael Y. de Camargo, Checkpointing-based Rollback Recovery for Parallel Applications on the InteGrade Grid Middleware, 2004, pages 1-6. * |
Cited By (15)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9767271B2 (en) | 2010-07-15 | 2017-09-19 | The Research Foundation For The State University Of New York | System and method for validating program execution at run-time |
US9767284B2 (en) | 2012-09-14 | 2017-09-19 | The Research Foundation For The State University Of New York | Continuous run-time validation of program execution: a practical approach |
US9552495B2 (en) | 2012-10-01 | 2017-01-24 | The Research Foundation For The State University Of New York | System and method for security and privacy aware virtual machine checkpointing |
US10324795B2 (en) | 2012-10-01 | 2019-06-18 | The Research Foundation for the State University o | System and method for security and privacy aware virtual machine checkpointing |
US9069782B2 (en) | 2012-10-01 | 2015-06-30 | The Research Foundation For The State University Of New York | System and method for security and privacy aware virtual machine checkpointing |
US9384019B2 (en) * | 2014-03-25 | 2016-07-05 | International Business Machines Corporation | Dynamic code injection |
US9471343B2 (en) * | 2014-03-25 | 2016-10-18 | International Business Machines Corporation | Dynamic code injection |
US20150370585A1 (en) * | 2014-03-25 | 2015-12-24 | International Business Machines Corporation | Dynamic code injection |
US9870240B2 (en) | 2014-03-25 | 2018-01-16 | International Business Machines Corporation | Dynamic code injection |
US20150278077A1 (en) * | 2014-03-25 | 2015-10-01 | International Business Machines Corporation | Dynamic code injection |
US20170357558A1 (en) * | 2016-06-13 | 2017-12-14 | Fujitsu Limited | Apparatus and method to enable a corrected program to take over data used before correction thereof |
CN112384895A (en) * | 2018-05-01 | 2021-02-19 | 亚马逊技术公司 | Function portability for implementing a service hub using function checkpoints |
US10853178B1 (en) * | 2018-05-18 | 2020-12-01 | Amazon Technologies, Inc. | Code function checkpoint and restore |
US11656944B1 (en) * | 2018-05-18 | 2023-05-23 | Amazon Technologies, Inc. | Code function checkpoint and restore |
US11368470B2 (en) * | 2019-06-13 | 2022-06-21 | International Business Machines Corporation | Real-time alert reasoning and priority-based campaign discovery |
Also Published As
Publication number | Publication date |
---|---|
EP2656217A2 (en) | 2013-10-30 |
HK1175005A1 (en) | 2013-06-21 |
WO2012088171A2 (en) | 2012-06-28 |
JP2014500564A (en) | 2014-01-09 |
CN102736948B (en) | 2015-04-01 |
WO2012088171A3 (en) | 2012-10-26 |
KR20140000283A (en) | 2014-01-02 |
JP6027020B2 (en) | 2016-11-16 |
CN102736948A (en) | 2012-10-17 |
KR101903805B1 (en) | 2018-10-02 |
US9740562B2 (en) | 2017-08-22 |
CA2821522A1 (en) | 2012-06-28 |
EP2656217A4 (en) | 2014-07-09 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9740562B2 (en) | Method for checkpointing and restoring program state | |
RU2385484C2 (en) | Reduced frequency of non-corrected errors generation in system of double-module redundancy in inflexibility of configuration | |
US7774636B2 (en) | Method and system for kernel panic recovery | |
US10831616B2 (en) | Resilient programming frameworks for iterative computations | |
CN102609296A (en) | Virtual machine branching and parallel execution | |
EP2356562A1 (en) | Developing applications at runtime | |
CN107016029B (en) | Method, device and system for processing service data | |
US10394561B2 (en) | Mechanism for facilitating dynamic and efficient management of instruction atomicity volations in software programs at computing systems | |
CN112732300A (en) | Data packet updating method and device, electronic equipment and readable storage medium | |
Arora et al. | ITALC: interactive tool for application-level checkpointing | |
JP2012208923A (en) | Method and system for executing application | |
US20210232378A1 (en) | Program calling, electronic device, and storage medium | |
Fanfarillo et al. | Resilient computational applications using Coarray Fortran | |
US10552135B1 (en) | Reducing a size of an application package | |
CN113760491A (en) | Task scheduling system, method, equipment and storage medium | |
WO2023009062A1 (en) | Device and method for re-executing of test cases in software application | |
Hukerikar et al. | A pattern language for high-performance computing resilience | |
CN114697398A (en) | Data processing method and device, electronic equipment, storage medium and product | |
CN113986236A (en) | Engineering compiling method, device, electronic equipment and storage medium | |
US9298449B2 (en) | Composite program history | |
KR101395007B1 (en) | Apparatus and method for processing snapshot image by using snapshot image compression | |
US20170357558A1 (en) | Apparatus and method to enable a corrected program to take over data used before correction thereof | |
US20240004670A1 (en) | Computer system executing multiple operating systems | |
US20240319992A1 (en) | Utilizing multiple analyses to migrate an application to a cloud computing environment | |
Engel et al. | Soft Error Handling for Embedded Systems using Compiler-OS Interaction |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: MICROSOFT CORPORATION, WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:LEIBMAN, STEPHEN;STALL, JONATHON MICHAEL;HUSBANDS, PARRY JONES REGINALD;SIGNING DATES FROM 20101216 TO 20101217;REEL/FRAME:025529/0187 |
|
AS | Assignment |
Owner name: MICROSOFT CORPORATION, WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:LEIBMAN, STEPHEN;STALL, JONATHON MICHAEL;HUSBANDS, PARRY JONES REGINALD;SIGNING DATES FROM 20101217 TO 20101218;REEL/FRAME:026390/0847 |
|
AS | Assignment |
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034544/0001 Effective date: 20141014 |
|
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 |