This patent application has not been assigned to a company or institution.
"For example, lack of type information may prohibit optimal compilation to avoid dynamic type conversion for a variable. Runtime profiling has been adopted to provide additional type information to improve execution performance. Typical runtime profiling, however, relies on recording types of values encountered and requires complicated data structures and extensive profiling operations. As a result, effectiveness of the compilation is adversely affected for overall performance improvement.
"Further, when current runtime values encountered no longer match the previous profiling results, optimally compiled code based on the previous profiling results may cost more processing cycles to execute than a corresponding non-optimally compiled code. Such discrepancies between current runtime values and previous profiling results can severely tax execution performance.
"Furthermore, dynamically typed code may be linked with an external library already compiled from non-dynamically typed language based source code. An interface layer is usually created in the dynamically typed code to allow the external library to access data owned by the dynamically typed based code. As a result, runtime performance may be degraded with the overhead incurred by data loading/updating through the interface layer.
"Therefore, existing runtime compilation and execution for dynamically typed code tends to introduce performance cost which may be unnecessary, wasteful and avoidable."
In addition to the background information obtained for this patent application, VerticalNews journalists also obtained the inventors' summary information for this patent application: "An executable code can be continuously optimized by tracking probability of success rate of speculatively optimized instructions in the executable code during runtime. The speculatively optimized instructions or optimizing code may be replaced or invalidated if found to be of low success rate according to the tracking. Runtime information regarding failures of the optimizing code may be recorded or gathered to provide additional optimization information for re compilation of the executable code. Profile information may be accumulated from previous iterations of compilation to identify optimization opportunities. Continued compilation can ensure a high success rate (e.g. 90%) of speculative optimized code. Recompilation schedule may be dynamically adjusted to aggressively apply optimizing code with high success rate (e.g. >=90%).
"In one embodiment, a code can be executed to access an untyped variable. The code can be compiled in a speculatively optimized manner from a source code according to a type prediction of runtime values of the untyped variable. Failures of the type prediction during the execution can be dynamically tracked. Each failure may be associated a runtime value with a type outside of the type prediction. The type prediction may be adjusted according to the failures tracked for future runtime values of the untyped variable. The source code can be recompiled for execution to optimize the access to the untyped variable for the future runtime values according to the adjusted type prediction.
"In another embodiment, a type prediction of runtime values of an untyped variable can be provided via an execution of a baseline code block compiled without optimization for an access to the untyped variable in a source code. Failures of the type prediction can be tracked via an execution of an optimized code block speculatively optimized for the access according to the type prediction. The tracking can indicate how successful the type prediction is. The source code can be recompiled if the failures indicate a failure rate exceeding a threshold. The recompiled code can include the baseline code block for the access without the optimized code block.
"In another embodiment, a runtime history for a sequence of executions or cycles of execution can be collected dynamically. Each cycle of execution may perform a data processing task specified in a source code based on a code compiled from the source code. The runtime history can include a number of invocations of the data processing task for each execution. A setting can be dynamically configured for each execution to specify a condition to initiate next execution in the sequence. The source code can be recompiled for the next execution if the runtime history matches the condition. The recompiled code may be optimized based on the runtime history. In one embodiment, the number of invocations of the data processing tasks for each execution may increase following the sequence.
"Other features of the present invention will be apparent from the accompanying drawings and from the detailed description that follows.
BRIEF DESCRIPTION OF THE DRAWINGS
"The present invention is illustrated by way of example and not limitation in the figures of the accompanying drawings, in which like references indicate similar elements and in which:
"FIG. 1 is a network diagram illustrating an exemplary runtime optimization for source code retrieved from networked devices;
"FIG. 2 is a block diagram illustrating one embodiment of a system for runtime optimization for dynamic programming languages;
"FIG. 3 is a flow diagram illustrating one embodiment of a process to profile runtime values;
"FIG. 4 is a flow diagram illustrating one embodiment of a process to sporadically record runtime values for code optimization;
"FIG. 5 illustrates exemplary profile instructions associated with storage locations according to one embodiment described herein;
"FIG. 6 is a flow diagram illustrating one embodiment of a process to track failures of type predictions used in an optimized code for recompilation;
"FIG. 7 is a flow diagram illustrating one embodiment of a process to dynamically recompile code optimized based on runtime history;
"FIG. 8 is a flow diagram illustrating one embodiment of a process to detect invalidity of type prediction to update an optimized code;
"FIG. 9 is a flow diagram illustrating one embodiment of a process to detect invalidity of type prediction to update an optimized function code;
"FIG. 10 illustrates one example of runtime data and optimized code for identifying validity of a type prediction based on structure transitions in the runtime data according to one embodiment described herein;
"FIG. 11 is a flow diagram illustrating one embodiment of a process for performing moving and non-moving garbage collections concurrently on separate portions of a heap;
"FIG. 12 is a flow diagram illustrating one embodiment of a process to scan a stack to identify live memory slots and pinned memory slots to reclaim memory slots which are not live and not pinned by moving the live memory slots without moving the pinned memory slots;
"FIG. 13 illustrates one example of split partitions in a heap for executing a code according to one embodiment described herein;
"FIG. 14 illustrates one example of a data processing system such as a computer system, which may be used in conjunction with the embodiments described herein."
URL and more information on this patent application, see: Pizlo, Filip J.; Barraclough, Gavin. Failure Profiling for Continued Code Optimization. Filed
Keywords for this news article include: Patents, Information Technology, Information and Data Processing.
Our reports deliver fact-based news of research and discoveries from around the world. Copyright 2014, NewsRx LLC
Most Popular Stories
- Obama Administration Releases Proposal to Regulate For-Profit Colleges
- Koch Brothers Step up Anti-Obamacare Campaign
- Elizabeth Vargas' Husband Marc Cohn Addresses Rumors
- Keurig Adds Peet's coffee, Alters Starbucks deal
- U.S. to Relinquish Gov't Control Over Internet
- Quiznos Files for Chapter 11
- SoCalGas Reaches Record Spend on Diversity Suppliers
- U.S. Consumer Sentiment Falls in Early March
- Vybz Kartel Convicted of Murder
- FDIC Sues Big Banks Over Rate Manipulation