US20040034814A1 - Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions - Google Patents
Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions Download PDFInfo
- Publication number
- US20040034814A1 US20040034814A1 US10/644,619 US64461903A US2004034814A1 US 20040034814 A1 US20040034814 A1 US 20040034814A1 US 64461903 A US64461903 A US 64461903A US 2004034814 A1 US2004034814 A1 US 2004034814A1
- Authority
- US
- United States
- Prior art keywords
- code
- program
- generating
- code segments
- segments
- 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.)
- Abandoned
Links
- 238000000034 method Methods 0.000 title claims abstract description 48
- 238000005457 optimization Methods 0.000 claims description 82
- 238000011084 recovery Methods 0.000 claims description 8
- 238000004590 computer program Methods 0.000 claims description 2
- 238000004519 manufacturing process Methods 0.000 claims 1
- 230000009466 transformation Effects 0.000 description 4
- 238000000844 transformation Methods 0.000 description 4
- 230000006399 behavior Effects 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- 230000001052 transient effect Effects 0.000 description 2
- 238000004364 calculation method Methods 0.000 description 1
- 230000001186 cumulative effect Effects 0.000 description 1
- 238000001514 detection method Methods 0.000 description 1
- 230000008030 elimination Effects 0.000 description 1
- 238000003379 elimination reaction Methods 0.000 description 1
- 238000013507 mapping Methods 0.000 description 1
- 238000012552 review Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
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/1479—Generic software techniques for error detection or fault masking
- G06F11/1489—Generic software techniques for error detection or fault masking through recovery blocks
-
- 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/3628—Software debugging of optimised code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/443—Optimisation
-
- 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/1471—Saving, restoring, recovering or retrying involving logging of persistent data for recovery
Definitions
- the present invention generally relates to techniques for recovering from fatal errors encountered in executing computer program code, and more particularly to compilation techniques for addressing the possibility of fatal software errors.
- Some compilers include an optimization phase for producing code that is fast and small. Code can be optimized in a variety of situations. For example, commonly used sub-expressions may be identified and code generated to evaluate the sub-expression once rather than generating code that repeatedly evaluates the same sub-expression. In another example, a repeated address calculation can be identified and code generated to calculate the address once.
- Programming loops are also candidates for optimization.
- An example optimization of a programming loop is to move loop invariants from within the loop to outside the loop.
- a loop invariant is a computation that produces the same result in each iteration. By moving a loop invariant to a point in the program just before the loop is entered, the computation is performed once rather than repeatedly in the loop.
- optimization may expose program behavior that is potentially erroneous.
- a program may have variables that are not initialized or asynchronously reference memory locations that have not been properly declared (i.e., volatile in C or C++). These examples may result in code that operates correctly when un-optimized, but fails when optimized.
- a first set of object code segments are generated and optimized at a first optimization level
- a second set of object code segments are generated and optimized at a second optimization level.
- the second set of object code segments are respectively associated with the first object code segments.
- execution of the first set of segments fails, the second set of object code modules are available as alternative code segments to execute.
- checkpoints in the program code are identified by a compiler, and the checkpoints are used to delineate the segments of object code.
- the first set of segments are optimized at a greater level than the second set of segments.
- FIG. 1 is a block diagram that illustrates the code that results from compilation of a program in accordance with one embodiment of the invention
- FIG. 2 is a flowchart of a an example process for compiling a program in accordance with one embodiment of the invention
- FIG. 3 is a flowchart of an example process for compiling a program in accordance with another embodiment of the invention.
- FIG. 4 is a flowchart of an example process for error recovery in accordance with the program compilation techniques of the present invention.
- Compiler-based program optimization is popular because of the drive for ever increasing program performance.
- users demand software reliability. It has been recognized, however that as optimization techniques become more complicated, there may be an accompanying decrease in reliability. From a user's perspective, this is unacceptable. Since the demands for increased performance are unlikely to abate, and it is impracticable to guarantee that compiler optimization of a program will not introduce any errors, recovery from fatal program errors that may be related to program optimization is desirable.
- the present invention provides a method and apparatus for generating alternative code that supports recovery from a fatal program error.
- the program code is optimized at different levels, and corresponding object code is generated. If a fatal program error is encountered in executing the program code that is optimized at a first level, then the program state is recovered and alternative program code that is optimized at a second level is executed. In other embodiments, the code may be optimized at more than two levels to provide even more alternatives for program recovery.
- FIG. 1 is a block diagram that illustrates the code that results from compilation of a program in accordance with one embodiment of the invention.
- Block 102 represents program source code that is to be compiled and is comprised of n segments of source code.
- Checkpoints are used to delineate the multiple segments.
- a checkpoint is a location in the code at which execution can recommence should the program encounter a fatal error.
- the state of data elements used by the program are stored so that in the event of program failure the state information can be recovered and execution resumed immediately after the checkpoint from which the state was recovered.
- the checkpoints can be user-programmed or identified by the compiler using recognized techniques.
- program object code 104 that includes two sets of object segments, object segments 1 -n and object segments 1 -n′.
- the object segments in each set correspond to the source segments of program source code 102 .
- Each set of object segments is code that is generated in compiling the source code with a selected level of optimization.
- object segments 1 -n are optimized at a first level
- object segments 1 ′-n′ are optimized at a different level. If the program fails during execution of segment i, for example, then the state of the checkpoint data can be recovered from checkpoint that precedes segment i and execution can resume at segment i′.
- FIG. 2 is a flowchart of an example process for compiling a program in accordance with one embodiment of the invention.
- the process generally entails optimizing the program code in generating a first set of object code segments and undoing the optimizations of the first set of object code segments in generating a second set of object code segments.
- the second set of object code segments are available for execution in the event that the a fatal program error is encountered in executing the first set of segments.
- program source code is compiled using known compilation techniques.
- the flow includes performing lexical and syntactical analysis of the source code and generating intermediate code.
- the intermediate code is partitioned into segments as described in the co-pending patent application entitled, “Compiler-based Checkpointing for Support of Error Recovery” by Ziegler et al. and filed concurrent herewith, which has attorney docket number 10001159, is commonly assigned to the assignee of the present invention, and the contents of which are incorporated herein by reference.
- checkpoint code is generated for storing the state of program data at each checkpoint (the end of a segment).
- the intermediate code is optimized and the first set of object code segments are generated.
- the level of optimization performed on the intermediate code may be selected according to the desired runtime performance. For example, most compilers will perform either no optimization or only limited optimization by default, but will perform a broad range of optimizing transformations when the user provides an optimization option (e.g. ⁇ O for most Unix compilers). On HP-UX compilers from Hewlett-Packard, the user can specify a +On option, where n is a number from 0 to 4 that specifies the level of optimization to apply (0 means no optimization and 4 means the highest level of optimization).
- an alternative set of object code segments is generated by undoing the optimizations made in generating the first set of segments. For example, common sub-expressions and loop invariants which would have been reused from a previous segment are recomputed. In addition, user-visible variables that were promoted to registers are demoted to memory for the duration of the segment. This requires that that the compiler record the optimizations performed, along with the necessary information to undo them. For example, for common sub-expression elimination, the information could simply be a pointer to the previous computation, or it could be the instruction(s) necessary to re-compute the expression. This information must be stored in order so that the transformations can be undone in reverse of the order in which the transformations were originally applied. This is because the optimizing transformations may be cumulative.
- code is also generated that directs program execution to the optimized code when the program is started.
- the non-optimized code segments are available for execution if execution of the optimized segments fails.
- FIG. 3 is a flowchart of an example process for compiling a program in accordance with another embodiment of the invention.
- the process of FIG. 3 processes the intermediate code on a segment-by-segment basis in generating the optimized and non-optimized code. This eliminates the step of undoing the optimizations, which may introduce errors. Since the code segments are processed individually, an optimized object code segment can be generated from an intermediate segment, and from the same intermediate code segment an alternative object code segment can then be generated without performing any optimization. Optimizing the intermediate code on a segment-by-segment basis, however, eliminates the opportunity to optimize the intermediate code across segment boundaries.
- Steps 252 and 254 perform the processing as described above with reference to steps 202 and 204 of FIG. 2.
- Step 256 obtains the first or next (depending on the iteration of the process loop) segment of intermediate code for processing.
- the selected segment of intermediate code is optimized. It will be appreciated that since the intermediate code is being processed segment-by-segment, no optimization will be performed across segment boundaries.
- an alternative segment of object code is generated from the selected segment of intermediate code.
- the alternative segment of object code is generated without optimization.
- Decision step 262 returns control to step 256 until all the segments of intermediate code have been processed.
- FIG. 4 is a flowchart of an example process for error recovery in accordance with the compiler techniques of the present invention.
- the process generally entails recovering from a fatal program error by restoring checkpoint data and resuming execution of the program using the non-optimized code segments.
- Fatal errors are detected by the operating system, which invokes the appropriate signal handler.
- the execution environment for this invention registers signal handlers for those fatal errors which arise due to application program behavior (e.g. out of bounds memory reference, as opposed to a hardware error). These signal handlers identify the code segment being executed, restore the program state from the most recent checkpoint, and either re-invoke the code segment or invoke a non-optimized segment. The identification of the current and alternate code segments is accomplished through mapping tables (not shown) produced by the compiler which map the range of program addresses for the optimized segments to that of the non-optimized segments.
- the process begins with the detection of a fatal program error.
- the point of program execution at which the program failed determines the checkpoint data to be restored.
- checkpoint data is restored from the most recent checkpoint.
- checkpoint data may be restored from a checkpoint prior to the most recent checkpoint.
- the program counter is reset to the selected checkpoint at step 306 , and the optimized code is re-executed at step 308 . Since some errors are transient or timing related, the optimized code may be retried before invoking the alternative code. If the program executes the segment without error, decision step 310 and step 312 illustrate that the program continues with execution of the optimized code.
- control is directed to decision step 314 , which determines whether the alternative non-optimized code should be tried.
- the optimized segment of code may be re-executed a selected number of times before trying execution of the non-optimized code.
- Control is directed to step 316 when the decision is made to execute the non-optimized code.
- step 316 checkpoint data is restored from the most recent checkpoint, and at step 318 , the address of the non-optimized segment of object code is selected for execution.
- step 320 the non-optimized segment of object code is executed, and execution of the non-optimized segments of code continues at step 322 .
- decision step 324 tests whether execution of the segment optimized code should be attempted again. If so, control is returned to step 304 to restore the checkpoint data and try again. Otherwise, the program is exited with an error.
- the optimized code may be re-executed a selected number of times before aborting.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Quality & Reliability (AREA)
- Software Systems (AREA)
- Computer Hardware Design (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions. Checkpoints in program code are identified by a compiler, and the checkpoints are used to delineate segments of object code. Two sets of segments of object code are generated, where the first and second sets of object code segments are optimized at different levels. In one embodiment, the first set of segments is optimized at a greater level than the second set of segments. Upon detecting a program error in executing the first set of segments, state information of the program is recovered from a checkpoint, and an object code module is selected from either the first set or second set for execution.
Description
- The present invention generally relates to techniques for recovering from fatal errors encountered in executing computer program code, and more particularly to compilation techniques for addressing the possibility of fatal software errors.
- Certain types of software errors are fatal to program execution. For example, a reference to a memory address that is beyond the address domain of a program will likely result in a fatal error. Certain timing or other transient conditions may also trigger fatal errors.
- While certain errors may be within the control of the software developer, the developer may be unable to guard against certain other errors in developing the software. Though rare, there is a possibility that certain other errors may be introduced in the compilation of the source code. Since the software developer assumes that a compiler will not introduce errors, the developer will have limited opportunity to identify and limited insight into compiler-introduced errors.
- Some compilers include an optimization phase for producing code that is fast and small. Code can be optimized in a variety of situations. For example, commonly used sub-expressions may be identified and code generated to evaluate the sub-expression once rather than generating code that repeatedly evaluates the same sub-expression. In another example, a repeated address calculation can be identified and code generated to calculate the address once.
- Programming loops are also candidates for optimization. An example optimization of a programming loop is to move loop invariants from within the loop to outside the loop. A loop invariant is a computation that produces the same result in each iteration. By moving a loop invariant to a point in the program just before the loop is entered, the computation is performed once rather than repeatedly in the loop.
- While it is a clear objective that any compiler-based code optimization not change the logic of the original source code, it is recognized that complicated optimization techniques have a greater possibility of introducing an error than do straightforward optimization techniques. In addition, optimization may expose program behavior that is potentially erroneous. For example, a program may have variables that are not initialized or asynchronously reference memory locations that have not been properly declared (i.e., volatile in C or C++). These examples may result in code that operates correctly when un-optimized, but fails when optimized.
- A method and apparatus that address the aforementioned problems, as well as other related problems, are therefore desirable.
- In various embodiments, methods and apparatus are provided for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions. In one embodiment, a first set of object code segments are generated and optimized at a first optimization level, and a second set of object code segments are generated and optimized at a second optimization level. The second set of object code segments are respectively associated with the first object code segments. In the event that execution of the first set of segments fails, the second set of object code modules are available as alternative code segments to execute.
- In another embodiment, checkpoints in the program code are identified by a compiler, and the checkpoints are used to delineate the segments of object code. In one embodiment, the first set of segments are optimized at a greater level than the second set of segments. Upon detecting a program error in executing the first set of segments, state information of the program is recovered from a checkpoint, and an object code module is selected from either the first set or second set for execution.
- It will be appreciated that various other embodiments are set forth in the Detailed Description and Claims which follow.
- Various aspects and advantages of the invention will become apparent upon review of the following detailed description and upon reference to the drawings in which:
- FIG. 1 is a block diagram that illustrates the code that results from compilation of a program in accordance with one embodiment of the invention;
- FIG. 2 is a flowchart of a an example process for compiling a program in accordance with one embodiment of the invention;
- FIG. 3 is a flowchart of an example process for compiling a program in accordance with another embodiment of the invention; and
- FIG. 4 is a flowchart of an example process for error recovery in accordance with the program compilation techniques of the present invention.
- Compiler-based program optimization is popular because of the drive for ever increasing program performance. At the same time, users demand software reliability. It has been recognized, however that as optimization techniques become more complicated, there may be an accompanying decrease in reliability. From a user's perspective, this is unacceptable. Since the demands for increased performance are unlikely to abate, and it is impracticable to guarantee that compiler optimization of a program will not introduce any errors, recovery from fatal program errors that may be related to program optimization is desirable.
- In various embodiments, the present invention provides a method and apparatus for generating alternative code that supports recovery from a fatal program error. In one embodiment, the program code is optimized at different levels, and corresponding object code is generated. If a fatal program error is encountered in executing the program code that is optimized at a first level, then the program state is recovered and alternative program code that is optimized at a second level is executed. In other embodiments, the code may be optimized at more than two levels to provide even more alternatives for program recovery.
- FIG. 1 is a block diagram that illustrates the code that results from compilation of a program in accordance with one embodiment of the invention. One purpose for compiling code in the manner taught herein is to enable recovery from fatal program errors.
Block 102 represents program source code that is to be compiled and is comprised of n segments of source code. Checkpoints are used to delineate the multiple segments. A checkpoint is a location in the code at which execution can recommence should the program encounter a fatal error. At each checkpoint, the state of data elements used by the program are stored so that in the event of program failure the state information can be recovered and execution resumed immediately after the checkpoint from which the state was recovered. In various embodiments the checkpoints can be user-programmed or identified by the compiler using recognized techniques. - Compilation of the program source code results in
program object code 104 that includes two sets of object segments, object segments 1-n and object segments 1-n′. The object segments in each set correspond to the source segments ofprogram source code 102. - Each set of object segments is code that is generated in compiling the source code with a selected level of optimization. In other words, object segments1-n are optimized at a first level, and object segments 1′-n′ are optimized at a different level. If the program fails during execution of segment i, for example, then the state of the checkpoint data can be recovered from checkpoint that precedes segment i and execution can resume at segment i′.
- FIG. 2 is a flowchart of an example process for compiling a program in accordance with one embodiment of the invention. The process generally entails optimizing the program code in generating a first set of object code segments and undoing the optimizations of the first set of object code segments in generating a second set of object code segments. The second set of object code segments are available for execution in the event that the a fatal program error is encountered in executing the first set of segments.
- At
steps step 206, the intermediate code is optimized and the first set of object code segments are generated. - The level of optimization performed on the intermediate code may be selected according to the desired runtime performance. For example, most compilers will perform either no optimization or only limited optimization by default, but will perform a broad range of optimizing transformations when the user provides an optimization option (e.g. −O for most Unix compilers). On HP-UX compilers from Hewlett-Packard, the user can specify a +On option, where n is a number from 0 to 4 that specifies the level of optimization to apply (0 means no optimization and 4 means the highest level of optimization).
- At
step 208, an alternative set of object code segments is generated by undoing the optimizations made in generating the first set of segments. For example, common sub-expressions and loop invariants which would have been reused from a previous segment are recomputed. In addition, user-visible variables that were promoted to registers are demoted to memory for the duration of the segment. This requires that that the compiler record the optimizations performed, along with the necessary information to undo them. For example, for common sub-expression elimination, the information could simply be a pointer to the previous computation, or it could be the instruction(s) necessary to re-compute the expression. This information must be stored in order so that the transformations can be undone in reverse of the order in which the transformations were originally applied. This is because the optimizing transformations may be cumulative. - In conjunction with the generation of the optimized and non-optimized code as described above, code is also generated that directs program execution to the optimized code when the program is started. The non-optimized code segments are available for execution if execution of the optimized segments fails.
- FIG. 3 is a flowchart of an example process for compiling a program in accordance with another embodiment of the invention. The process of FIG. 3 processes the intermediate code on a segment-by-segment basis in generating the optimized and non-optimized code. This eliminates the step of undoing the optimizations, which may introduce errors. Since the code segments are processed individually, an optimized object code segment can be generated from an intermediate segment, and from the same intermediate code segment an alternative object code segment can then be generated without performing any optimization. Optimizing the intermediate code on a segment-by-segment basis, however, eliminates the opportunity to optimize the intermediate code across segment boundaries.
- Steps252 and 254 perform the processing as described above with reference to
steps - At step260, an alternative segment of object code is generated from the selected segment of intermediate code. The alternative segment of object code is generated without optimization. Decision step 262 returns control to step 256 until all the segments of intermediate code have been processed.
- FIG. 4 is a flowchart of an example process for error recovery in accordance with the compiler techniques of the present invention. The process generally entails recovering from a fatal program error by restoring checkpoint data and resuming execution of the program using the non-optimized code segments.
- Fatal errors are detected by the operating system, which invokes the appropriate signal handler. In one embodiment, the execution environment for this invention registers signal handlers for those fatal errors which arise due to application program behavior (e.g. out of bounds memory reference, as opposed to a hardware error). These signal handlers identify the code segment being executed, restore the program state from the most recent checkpoint, and either re-invoke the code segment or invoke a non-optimized segment. The identification of the current and alternate code segments is accomplished through mapping tables (not shown) produced by the compiler which map the range of program addresses for the optimized segments to that of the non-optimized segments.
- At
step 302, the process begins with the detection of a fatal program error. In one embodiment, the point of program execution at which the program failed determines the checkpoint data to be restored. For example atstep 304, checkpoint data is restored from the most recent checkpoint. In other embodiments, checkpoint data may be restored from a checkpoint prior to the most recent checkpoint. - Before reverting to execution of the non-optimized code, the program counter is reset to the selected checkpoint at
step 306, and the optimized code is re-executed atstep 308. Since some errors are transient or timing related, the optimized code may be retried before invoking the alternative code. If the program executes the segment without error,decision step 310 and step 312 illustrate that the program continues with execution of the optimized code. - If an error recurs in executing the optimized segment of code, control is directed to
decision step 314, which determines whether the alternative non-optimized code should be tried. In one embodiment, the optimized segment of code may be re-executed a selected number of times before trying execution of the non-optimized code. Control is directed to step 316 when the decision is made to execute the non-optimized code. - At
step 316, checkpoint data is restored from the most recent checkpoint, and atstep 318, the address of the non-optimized segment of object code is selected for execution. Atstep 320, the non-optimized segment of object code is executed, and execution of the non-optimized segments of code continues atstep 322. - Returning now to
decision step 314, if the decision is made to not execute the non-optimized code, control is directed todecision step 324.Decision step 324 tests whether execution of the segment optimized code should be attempted again. If so, control is returned to step 304 to restore the checkpoint data and try again. Otherwise, the program is exited with an error. In one embodiment, the optimized code may be re-executed a selected number of times before aborting. - The present invention is believed to be applicable to compilers for a variety of programming languages. Other aspects and embodiments of the present invention will be apparent to those skilled in the art from consideration of the specification and practice of the invention disclosed herein. It is intended that the specification and illustrated embodiments be considered as examples only, with a true scope and spirit of the invention being indicated by the following claims.
Claims (30)
1. A computer-implemented method for compiling program code, comprising:
generating first object code segments optimized at a first optimization level;
generating second object code segments optimized at a second optimization level, wherein the second object code segments are respectively associated with the first object code segments;
checkpoints in the program code, the checkpoints delineating the object code segments; and
generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program.
2. The method of claim 1 , wherein the second optimization level includes no optimizations.
3. The method of claim 2 , wherein the first optimization level includes more optimizations than the second optimization level.
4. The method of claim 1 , wherein the first optimization level includes more optimizations than the second optimization level.
5. The method of claim 1 , further comprising undoing optimizations made in generating the first object code segments in generating the second object code segments.
6. The method of claim 5 , further comprising:
identifying checkpoints in the program code, the checkpoints delineating the object code segments; and
generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program.
7. The method of claim 1 , further comprising:
generating segments of intermediate code;
for each segment of intermediate code,
optimizing the segment of intermediate code in generating a corresponding one of the first object code segments; and
undoing optimizations of intermediate code in generating a corresponding one of the second object code segments.
8. The method of claim 7 , further comprising:
identifying checkpoints in the program code, the checkpoints delineating the object code segments; and
generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program.
9. The method of claim 1 , further comprising:
identifying checkpoints in the program code, the checkpoints delineating the object code segments; and
generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program.
10. The method of claim 9 , wherein the second optimization level includes no optimizations.
11. The method of claim 10 , wherein the first optimization level includes more optimizations than the second optimization level.
12. The method of claim 9 , wherein the first optimization level includes more optimizations than the second optimization level.
13. A computer-implemented method for recovery from a program execution error, comprising:
identifying checkpoints in the program code;
generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program;
generating first object code segments optimized at a first optimization level, the object code segments delineated by the checkpoints;
generating second object code segments optimized at a second optimization level, wherein the second object code segments are respectively associated with the first object code segments;
upon detecting a program error, recovering state information of the program from a checkpoint; and
selecting for execution between a first and second object code segment associated with the checkpoint of the recovering step.
14. The method of claim 13 , wherein the first optimization level includes more optimizations than the second optimization level, and further comprising:
initially executing the first object code segments; and
retrying execution of a first object code segment associated with the checkpoint from the recovering step before selecting a second object code segment for execution.
15. The method of claim 13 , wherein the second optimization level includes no optimizations.
16. The method of claim 15 , wherein the first optimization level includes more optimizations than the second optimization level.
17. The method of claim 13 , wherein the first optimization level includes more optimizations than the second optimization level.
18. The method of claim 13 , further comprising undoing optimizations made in generating the first object code segments in generating the second object code segments.
19. An apparatus for compiling program code, comprising:
means for generating first object code segments optimized at a first optimization level;
means for generating second object code segments optimized at a second optimization level, wherein the second object code segments are respectively associated with the first object code segments;
means for identifying checkpoints in the program code, the checkpoints delineating the object code segments; and
means for generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program.
20. An apparatus for recovery from a program execution error, comprising:
means for identifying checkpoints in the program code;
means for generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program;
means for generating first object code segments optimized at a first optimization level, the object code segments delineated by the checkpoints;
means for generating second object code segments optimized at a second optimization level, wherein the second object code segments are respectively associated with the first object code segments;
means for upon detecting a program error, recovering state information of the program from a checkpoint; and
means for selecting for execution between a first and second object code segment associated with the checkpoint of the recovering step.
21. A computer program product configured for causing a computer to perform the steps of:
generating first object code segments optimized at a first optimization level;
generating second object code segments optimized at a second optimization level, wherein the second object code segments are respectively associated with the first object code segments;
identifying checkpoints in the program code, the checkpoints delineating the object code segments; and
generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program.
22. A computer-implemented method for compiling program code, comprising:
generating during compilation of the program code first machine code segments optimized at a first optimization level; and
generating during compilation of the program code second machine code segments optimized at a second optimization level, wherein the second machine code segments are respectively associated with the first machine code segments.
23. The method of claim 22 , wherein the second optimization level includes no optimizations.
24. The method of claim 23 , wherein the first optimization level includes more optimizations than the second optimization level.
25. The method of claim 22 , wherein the first optimization level includes more optimizations than the second optimization level.
26. The method of claim 22 , further comprising undoing optimizations made in generating the first machine code segments in generating the second machine code segments.
27. The method of claim 26 , further comprising:
identifying checkpoints in the program code, the checkpoints delineating the object code segments; and
generating checkpoint code for execution at the checkpoints, wherein the checkpoint code saves state information of the program.
28. The method of claim 22 , further comprising:
generating segments of intermediate code;
for each segment of intermediate code,
optimizing the segment of intermediate code in generating a corresponding one of the first machine code segments; and
undoing optimizations of intermediate code in generating a corresponding one of the second machine code segments.
29. An apparatus for compiling program code, comprising:
means for generating during compilation of the program code first machine code segments optimized at a first optimization level; and
means for generating during compilation of the program code second machine code segments optimized at a second optimization level, wherein the second machine code segments are respectively associated with the first machine code segments.
30. An article of manufacture, comprising:
a computer-readable medium configured with instructions for causing a processor-based arrangement to perform the steps of,
generating during compilation of the program code first machine code segments optimized at a first optimization level; and
generating during compilation of the program code second machine code segments optimized at a second optimization level, wherein the second machine code segments are respectively associated with the first machine code segments.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US10/644,619 US20040034814A1 (en) | 2000-10-31 | 2003-08-20 | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/702,592 US6658656B1 (en) | 2000-10-31 | 2000-10-31 | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
US10/644,619 US20040034814A1 (en) | 2000-10-31 | 2003-08-20 | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/702,592 Continuation US6658656B1 (en) | 2000-10-31 | 2000-10-31 | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
Publications (1)
Publication Number | Publication Date |
---|---|
US20040034814A1 true US20040034814A1 (en) | 2004-02-19 |
Family
ID=29550448
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/702,592 Expired - Fee Related US6658656B1 (en) | 2000-10-31 | 2000-10-31 | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
US10/644,619 Abandoned US20040034814A1 (en) | 2000-10-31 | 2003-08-20 | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US09/702,592 Expired - Fee Related US6658656B1 (en) | 2000-10-31 | 2000-10-31 | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
Country Status (1)
Country | Link |
---|---|
US (2) | US6658656B1 (en) |
Cited By (19)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20050132250A1 (en) * | 2003-12-16 | 2005-06-16 | Hewlett-Packard Development Company, L.P. | Persistent memory device for backup process checkpoint states |
US20050216552A1 (en) * | 2004-03-24 | 2005-09-29 | Samuel Fineberg | Communication-link-attached persistent memory system |
US20060282741A1 (en) * | 2003-03-18 | 2006-12-14 | Mehdi-Laurent Akkar | Method to secure an electronic assembly executing any algorithm against attacks by error introduction |
US20070300213A1 (en) * | 2003-07-10 | 2007-12-27 | International Business Machines Corporation | Method and Apparatus for Generating Computer Programming Code Selectively Optimized for Execution Performance and Not Optimized for Serviceability |
KR100866211B1 (en) | 2007-01-03 | 2008-10-30 | 삼성전자주식회사 | Apparatus and method for developing programs and a method of updating programs |
US20100011243A1 (en) * | 2006-04-17 | 2010-01-14 | The Trustees Of Columbia University | Methods, systems and media for software self-healing |
DE102008043374A1 (en) * | 2008-10-31 | 2010-05-06 | Robert Bosch Gmbh | Device and method for generating redundant but different machine codes from a source code for verification for a safety-critical system |
US20100293407A1 (en) * | 2007-01-26 | 2010-11-18 | The Trustees Of Columbia University In The City Of | Systems, Methods, and Media for Recovering an Application from a Fault or Attack |
US20100325618A1 (en) * | 2009-06-22 | 2010-12-23 | Sun Microsystems, Inc. | Fault tolerant compilation with automatic error correction |
US20100325619A1 (en) * | 2009-06-22 | 2010-12-23 | Sun Microsystems, Inc. | Fault tolerant compilation with automatic optimization adjustment |
US20120017070A1 (en) * | 2009-03-25 | 2012-01-19 | Satoshi Hieda | Compile system, compile method, and storage medium storing compile program |
WO2012040742A3 (en) * | 2010-09-25 | 2012-06-14 | Intel Corporation | Apparatus, method, and system for dynamically optimizing code utilizing adjustable transaction sizes based on hardware limitations |
WO2012040715A3 (en) * | 2010-09-25 | 2012-06-21 | Intel Corporation | Apparatus, method, and system for providing a decision mechanism for conditional commits in an atomic region |
US8543907B1 (en) * | 2009-10-16 | 2013-09-24 | Google Inc. | Context-sensitive optimization level selection |
US8893094B2 (en) | 2011-12-30 | 2014-11-18 | Intel Corporation | Hardware compilation and/or translation with fault detection and roll back functionality |
US20150347240A1 (en) * | 2014-06-02 | 2015-12-03 | Red Hat, Inc. | Using an object retain block in a virtual machine |
US9235390B1 (en) * | 2008-03-31 | 2016-01-12 | Symantec Corporation | Application optimization for use based on feature popularity |
US10466989B2 (en) | 2011-09-02 | 2019-11-05 | Microsoft Technology Licensing, Llc. | Fast presentation of markup content having script code |
US10481876B2 (en) | 2017-01-11 | 2019-11-19 | Microsoft Technology Licensing, Llc | Methods and systems for application rendering |
Families Citing this family (15)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6658656B1 (en) * | 2000-10-31 | 2003-12-02 | Hewlett-Packard Development Company, L.P. | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
US7392515B2 (en) * | 2001-02-09 | 2008-06-24 | International Business Machines Corporation | Program components having multiple selectable implementations |
US7340741B2 (en) * | 2003-02-28 | 2008-03-04 | International Business Machines Corporation | Auto-restart processing in an IMS batch application |
US7299450B2 (en) * | 2003-06-17 | 2007-11-20 | Microsoft Corporation | Undoing changes in a software configuration management system |
US20060271920A1 (en) * | 2005-05-24 | 2006-11-30 | Wael Abouelsaadat | Multilingual compiler system and method |
US7752606B2 (en) * | 2005-08-10 | 2010-07-06 | Capital One Financial Corporation | Software development tool using a structured format to generate software code |
US7810071B2 (en) * | 2006-07-18 | 2010-10-05 | Sap Ag | Automated error analysis |
US8271958B2 (en) | 2008-12-12 | 2012-09-18 | Microsoft Corporation | Remapping debuggable code |
US8495607B2 (en) * | 2010-03-01 | 2013-07-23 | International Business Machines Corporation | Performing aggressive code optimization with an ability to rollback changes made by the aggressive optimizations |
US8561045B2 (en) | 2010-07-30 | 2013-10-15 | Apple Inc. | Constructing runtime state for inlined code |
US9146759B2 (en) | 2010-07-30 | 2015-09-29 | Apple Inc. | Assumption-based compilation |
US9195486B2 (en) * | 2010-07-30 | 2015-11-24 | Apple Inc. | Observation and analysis based code optimization |
US9569185B2 (en) * | 2014-02-07 | 2017-02-14 | Oracle International Corporation | Changing de-optimization guard representation during the compilation process |
CN105335279B (en) * | 2014-06-27 | 2018-04-20 | 比亚迪股份有限公司 | The automatic detection of FLASH program and restorative procedure and device in microcontroller |
US10289394B2 (en) | 2016-10-11 | 2019-05-14 | Oracle International Corporation | Selective generation of multiple versions of machine code for source code functions for execution on different processor versions and/or architectures |
Citations (18)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5768595A (en) * | 1993-10-29 | 1998-06-16 | International Business Machines Corporation | System and method for recompiling computer programs for enhanced optimization |
US5850554A (en) * | 1995-12-29 | 1998-12-15 | Intel Corporation | Compiler tool set for efficiently generating and easily managing multiple program versions of different types |
US5930510A (en) * | 1996-11-19 | 1999-07-27 | Sun Microsystems, Inc. | Method and apparatus for an improved code optimizer for pipelined computers |
US5933635A (en) * | 1997-10-06 | 1999-08-03 | Sun Microsystems, Inc. | Method and apparatus for dynamically deoptimizing compiled activations |
US5956479A (en) * | 1995-11-13 | 1999-09-21 | Object Technology Licensing Corporation | Demand based generation of symbolic information |
US5995754A (en) * | 1997-10-06 | 1999-11-30 | Sun Microsystems, Inc. | Method and apparatus for dynamically optimizing byte-coded programs |
US6059839A (en) * | 1997-01-09 | 2000-05-09 | Silicon Graphics, Inc. | Apparatus and method for compiler identification of address data |
US6078744A (en) * | 1997-08-01 | 2000-06-20 | Sun Microsystems | Method and apparatus for improving compiler performance during subsequent compilations of a source program |
US6105148A (en) * | 1995-06-16 | 2000-08-15 | Lucent Technologies Inc. | Persistent state checkpoint and restoration systems |
US6260190B1 (en) * | 1998-08-11 | 2001-07-10 | Hewlett-Packard Company | Unified compiler framework for control and data speculation with recovery code |
US6287765B1 (en) * | 1998-05-20 | 2001-09-11 | Molecular Machines, Inc. | Methods for detecting and identifying single molecules |
US6400475B1 (en) * | 1997-11-14 | 2002-06-04 | Hitachi, Ltd. | Optical transmission system and optical communications device |
US20020104076A1 (en) * | 1998-06-30 | 2002-08-01 | Nik Shaylor | Code generation for a bytecode compiler |
US6651246B1 (en) * | 1999-11-08 | 2003-11-18 | International Business Machines Corporation | Loop allocation for optimizing compilers |
US6658656B1 (en) * | 2000-10-31 | 2003-12-02 | Hewlett-Packard Development Company, L.P. | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
US20040015911A1 (en) * | 1999-09-01 | 2004-01-22 | Hinsley Christopher Andrew | Translating and executing object-oriented computer programs |
US6944852B2 (en) * | 2000-04-06 | 2005-09-13 | International Business Machines Corporation | Compiler |
US7080366B2 (en) * | 1998-11-16 | 2006-07-18 | Esmertec Ag | Dynamic compiler and method of compiling code to generate dominant path and to handle exceptions |
Family Cites Families (1)
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 |
-
2000
- 2000-10-31 US US09/702,592 patent/US6658656B1/en not_active Expired - Fee Related
-
2003
- 2003-08-20 US US10/644,619 patent/US20040034814A1/en not_active Abandoned
Patent Citations (20)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5768595A (en) * | 1993-10-29 | 1998-06-16 | International Business Machines Corporation | System and method for recompiling computer programs for enhanced optimization |
US6105148A (en) * | 1995-06-16 | 2000-08-15 | Lucent Technologies Inc. | Persistent state checkpoint and restoration systems |
US5956479A (en) * | 1995-11-13 | 1999-09-21 | Object Technology Licensing Corporation | Demand based generation of symbolic information |
US6067641A (en) * | 1995-11-13 | 2000-05-23 | Object Technology Licensing Corporation | Demand-based generation of symbolic information |
US5850554A (en) * | 1995-12-29 | 1998-12-15 | Intel Corporation | Compiler tool set for efficiently generating and easily managing multiple program versions of different types |
US5930510A (en) * | 1996-11-19 | 1999-07-27 | Sun Microsystems, Inc. | Method and apparatus for an improved code optimizer for pipelined computers |
US6059839A (en) * | 1997-01-09 | 2000-05-09 | Silicon Graphics, Inc. | Apparatus and method for compiler identification of address data |
US6078744A (en) * | 1997-08-01 | 2000-06-20 | Sun Microsystems | Method and apparatus for improving compiler performance during subsequent compilations of a source program |
US6240547B1 (en) * | 1997-10-06 | 2001-05-29 | Sun Microsystems, Inc. | Method and apparatus for dynamically deoptimizing compiled activations |
US5995754A (en) * | 1997-10-06 | 1999-11-30 | Sun Microsystems, Inc. | Method and apparatus for dynamically optimizing byte-coded programs |
US5933635A (en) * | 1997-10-06 | 1999-08-03 | Sun Microsystems, Inc. | Method and apparatus for dynamically deoptimizing compiled activations |
US6400475B1 (en) * | 1997-11-14 | 2002-06-04 | Hitachi, Ltd. | Optical transmission system and optical communications device |
US6287765B1 (en) * | 1998-05-20 | 2001-09-11 | Molecular Machines, Inc. | Methods for detecting and identifying single molecules |
US20020104076A1 (en) * | 1998-06-30 | 2002-08-01 | Nik Shaylor | Code generation for a bytecode compiler |
US6260190B1 (en) * | 1998-08-11 | 2001-07-10 | Hewlett-Packard Company | Unified compiler framework for control and data speculation with recovery code |
US7080366B2 (en) * | 1998-11-16 | 2006-07-18 | Esmertec Ag | Dynamic compiler and method of compiling code to generate dominant path and to handle exceptions |
US20040015911A1 (en) * | 1999-09-01 | 2004-01-22 | Hinsley Christopher Andrew | Translating and executing object-oriented computer programs |
US6651246B1 (en) * | 1999-11-08 | 2003-11-18 | International Business Machines Corporation | Loop allocation for optimizing compilers |
US6944852B2 (en) * | 2000-04-06 | 2005-09-13 | International Business Machines Corporation | Compiler |
US6658656B1 (en) * | 2000-10-31 | 2003-12-02 | Hewlett-Packard Development Company, L.P. | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions |
Cited By (38)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20060282741A1 (en) * | 2003-03-18 | 2006-12-14 | Mehdi-Laurent Akkar | Method to secure an electronic assembly executing any algorithm against attacks by error introduction |
US7774653B2 (en) * | 2003-03-18 | 2010-08-10 | Gemalto Sa | Method to secure an electronic assembly executing any algorithm against attacks by error introduction |
US20070300213A1 (en) * | 2003-07-10 | 2007-12-27 | International Business Machines Corporation | Method and Apparatus for Generating Computer Programming Code Selectively Optimized for Execution Performance and Not Optimized for Serviceability |
US8108849B2 (en) * | 2003-07-10 | 2012-01-31 | International Business Machines Corporation | Method and apparatus for generating computer programming code selectively optimized for execution performance and not optimized for serviceability |
US20050132250A1 (en) * | 2003-12-16 | 2005-06-16 | Hewlett-Packard Development Company, L.P. | Persistent memory device for backup process checkpoint states |
US9213609B2 (en) * | 2003-12-16 | 2015-12-15 | Hewlett-Packard Development Company, L.P. | Persistent memory device for backup process checkpoint states |
US20110082992A1 (en) * | 2004-03-24 | 2011-04-07 | Hewlett-Packard Development Company, L.P. | Communication-link-attached persistent memory system |
US20050216552A1 (en) * | 2004-03-24 | 2005-09-29 | Samuel Fineberg | Communication-link-attached persistent memory system |
US9405680B2 (en) | 2004-03-24 | 2016-08-02 | Hewlett Packard Enterprise Development Lp | Communication-link-attached persistent memory system |
US20100011243A1 (en) * | 2006-04-17 | 2010-01-14 | The Trustees Of Columbia University | Methods, systems and media for software self-healing |
US7962798B2 (en) * | 2006-04-17 | 2011-06-14 | The Trustees Of Columbia University In The City Of New York | Methods, systems and media for software self-healing |
KR100866211B1 (en) | 2007-01-03 | 2008-10-30 | 삼성전자주식회사 | Apparatus and method for developing programs and a method of updating programs |
US20100293407A1 (en) * | 2007-01-26 | 2010-11-18 | The Trustees Of Columbia University In The City Of | Systems, Methods, and Media for Recovering an Application from a Fault or Attack |
US9218254B2 (en) | 2007-01-26 | 2015-12-22 | The Trustees Of Columbia University In The City Of New York | Systems, methods, and media for recovering an application from a fault or attack |
US8924782B2 (en) | 2007-01-26 | 2014-12-30 | The Trustees Of Columbia University In The City Of New York | Systems, methods, and media for recovering an application from a fault or attack |
US9235390B1 (en) * | 2008-03-31 | 2016-01-12 | Symantec Corporation | Application optimization for use based on feature popularity |
DE102008043374A1 (en) * | 2008-10-31 | 2010-05-06 | Robert Bosch Gmbh | Device and method for generating redundant but different machine codes from a source code for verification for a safety-critical system |
US20120017070A1 (en) * | 2009-03-25 | 2012-01-19 | Satoshi Hieda | Compile system, compile method, and storage medium storing compile program |
US9207921B2 (en) * | 2009-06-22 | 2015-12-08 | Oracle America, Inc. | Fault tolerant compilation with automatic optimization adjustment |
US20100325618A1 (en) * | 2009-06-22 | 2010-12-23 | Sun Microsystems, Inc. | Fault tolerant compilation with automatic error correction |
US9274770B2 (en) * | 2009-06-22 | 2016-03-01 | Oracle America, Inc. | Fault tolerant compilation with automatic error correction |
US20100325619A1 (en) * | 2009-06-22 | 2010-12-23 | Sun Microsystems, Inc. | Fault tolerant compilation with automatic optimization adjustment |
US9134978B1 (en) * | 2009-10-16 | 2015-09-15 | Google Inc. | Context-sensitive optimization level selection |
US8543907B1 (en) * | 2009-10-16 | 2013-09-24 | Google Inc. | Context-sensitive optimization level selection |
KR101524446B1 (en) * | 2010-09-25 | 2015-06-01 | 인텔 코포레이션 | Apparatus, method, and system for dynamically optimizing code utilizing adjustable transaction sizes based on hardware limitations |
AU2011305091B2 (en) * | 2010-09-25 | 2014-09-25 | Intel Corporation | Apparatus, method, and system for dynamically optimizing code utilizing adjustable transaction sizes based on hardware limitations |
CN103119556A (en) * | 2010-09-25 | 2013-05-22 | 英特尔公司 | Apparatus, method, and system for providing a decision mechanism for conditional commits in an atomic region |
WO2012040715A3 (en) * | 2010-09-25 | 2012-06-21 | Intel Corporation | Apparatus, method, and system for providing a decision mechanism for conditional commits in an atomic region |
WO2012040742A3 (en) * | 2010-09-25 | 2012-06-14 | Intel Corporation | Apparatus, method, and system for dynamically optimizing code utilizing adjustable transaction sizes based on hardware limitations |
US8549504B2 (en) | 2010-09-25 | 2013-10-01 | Intel Corporation | Apparatus, method, and system for providing a decision mechanism for conditional commits in an atomic region |
US9146844B2 (en) | 2010-09-25 | 2015-09-29 | Intel Corporation | Apparatus, method, and system for providing a decision mechanism for conditional commits in an atomic region |
US11288048B2 (en) | 2011-09-02 | 2022-03-29 | Microsoft Technology Licensing, Llc. | Fast presentation of markup content having script code |
US10466989B2 (en) | 2011-09-02 | 2019-11-05 | Microsoft Technology Licensing, Llc. | Fast presentation of markup content having script code |
US8893094B2 (en) | 2011-12-30 | 2014-11-18 | Intel Corporation | Hardware compilation and/or translation with fault detection and roll back functionality |
US9317263B2 (en) * | 2011-12-30 | 2016-04-19 | Intel Corporation | Hardware compilation and/or translation with fault detection and roll back functionality |
US9552260B2 (en) * | 2014-06-02 | 2017-01-24 | Red Hat, Inc. | Using an object retain block in a virtual machine |
US20150347240A1 (en) * | 2014-06-02 | 2015-12-03 | Red Hat, Inc. | Using an object retain block in a virtual machine |
US10481876B2 (en) | 2017-01-11 | 2019-11-19 | Microsoft Technology Licensing, Llc | Methods and systems for application rendering |
Also Published As
Publication number | Publication date |
---|---|
US6658656B1 (en) | 2003-12-02 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6658656B1 (en) | Method and apparatus for creating alternative versions of code segments and dynamically substituting execution of the alternative code versions | |
US6874138B1 (en) | Method and apparatus for resuming execution of a failed computer program | |
Hennessy | Symbolic debugging of optimized code | |
US6223337B1 (en) | Random test generation for compiler optimization | |
JP3654910B2 (en) | Error correction method and apparatus in computer system | |
Alkhalifa et al. | Design and evaluation of system-level checks for on-line control flow error detection | |
KR100290269B1 (en) | Handling of exceptions in speculative instructions | |
US7757237B2 (en) | Synchronization of threads in a multithreaded computer program | |
US6434741B1 (en) | Method and apparatus for debugging of optimized code using emulation | |
US8935678B2 (en) | Methods and apparatus to form a resilient objective instruction construct | |
US20040025088A1 (en) | Software application test coverage analyzer | |
US20080244354A1 (en) | Apparatus and method for redundant multi-threading with recovery | |
US6505296B2 (en) | Emulated branch effected by trampoline mechanism | |
US20020170034A1 (en) | Method for debugging a dynamic program compiler, interpreter, or optimizer | |
US10423397B2 (en) | Systems and/or methods for type inference from machine code | |
JPH02217926A (en) | Compiler | |
US7003762B2 (en) | Computer-implemented exception handling system and method | |
US7937695B2 (en) | Reducing number of exception checks | |
Akgul et al. | Assembly instruction level reverse execution for debugging | |
US7257805B2 (en) | Restoring debugging breakpoints subsequent to program code modifications | |
US20090235234A1 (en) | Determining minimal sets of bugs solutions for a computer program | |
US5987626A (en) | Precise detection of errors using hardware watchpoint mechanism | |
JPH10133884A (en) | Method for executing programming code including conjectural code | |
Jaramillo et al. | Debugging and testing optimizers through comparison checking | |
US7448029B2 (en) | Modification of array access checking in AIX |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |