150 results about "Dynamic compilation" patented technology

This invention describes a method and several variants for compiling programs or components of programs in a mixed static and dynamic environment, so as to reduce the amount of time and memory spent in run-time compilation, or to exercise greater control over testing of the executable code for the program, or both. The invention involves generating persistent code images prior to program execution based on static compilation or dynamic compilation from a previous run, and then, adapting those images during program execution. We describe a method for generating auxiliary information in addition to the executable code that is recorded in the persistent code image. Further, we describe a method for checking the validity of those code images, adapting those images to the new execution context, and generating new executable code to respond to dynamic events, during program execution. Our method allows global interprocedural optimizations to be performed on the program, even if the programming language supports, or requires, dynamic binding. Variants of the method show how one or several of the features of the method may be performed. The invention is particularly useful in the context of implementing Java Virtual Machines, although it can also be used in implementing other programming languages.

The present invention is a method and system to support debug. A function is compiled. The function includes a byte code sequence having a field byte code that accesses or modifies a field. The compiled function provides a native code and occupies a code space. An instrumentation code corresponding to a field match of a field is generated. The instrumentation code is inserted to the native code.

One embodiment provides a system that protects translated guest program code in a virtual machine that supports self-modifying program code. While executing a guest program in the virtual machine, the system uses a guest shadow page table associated with the guest program and the virtual machine to map a virtual memory page for the guest program to a physical memory page on the host computing device. The system then uses a dynamic compiler to translate guest program code in the virtual memory page into translated guest program code (e.g., native program instructions for the computing device). During compilation, the dynamic compiler stores in a compiler shadow page table and the guest shadow page table information that tracks whether the guest program code in the virtual memory page has been translated. The compiler subsequently uses the information stored in the guest shadow page table to detect attempts to modify the contents of the virtual memory page. Upon detecting such an attempt, the system invalidates the translated guest program code associated with the virtual memory page.

A method for dynamic recompilation of source software instructions for execution by a target processor, which considers not only the specific source instructions, but also the intent and purpose of the instructions, to translate and optimize a set of equivalent code for the target processor. The dynamic recompiler determines what the source operation code is trying to accomplish and the optimum way of doing it at the target processor, in an "interpolative" and context sensitive fashion. The source instructions are processed in blocks of varying sizes by the dynamic recompiler, which considers the instructions that come before and after a current instruction to determine the most efficient approach out of several available approaches for encoding the operation code for the target processor to perform the equivalent tasks specified by the source instructions. The dynamic compiler comprises a decoding stage, an optimization stage and an encoding stage.

In a dynamically compiling computer system, a system and method for efficiently transferring control from execution of an instruction in a first representation to a second representation of the instruction is disclosed. The system and method include the setting of a tag for entry points of each instruction in a first representation that has been translated to a second representation. The tag is stored in memory in association with each such instruction. When a given instruction in a first representation is to be executed, the tag is examined, and if it indicates that a translated version of the instruction has previously been generated, control is passed to execution of the instruction in the second representation. The second representation can be a different instruction set representation, or an optimized representation in the same instruction set as the original instruction.

The present invention reduces overhead in a VLIW type microprocessor including a dynamic compiler or controls a memory capacity for storing an object code after scheduling. The present invention relates to a VLIW microprocessor including a dynamic compiler and improves operation performance of a microprocessor by executing instructions more efficiently. Specifically, one feature of the present invention is to reduce overhead accompanying execution of a dynamic compiler and to control a memory capacity for storing an object code after scheduling internal instructions by using genetic algorithm (GA) in an execution of instructions in a VLIW microprocessor including a dynamic compiler.

A dynamic compiler analyzes the frequency of execution of selective code paths within a program procedure, and selectively compiles code paths to different memory locations based on the observed frequency of execution. Preferably, code is dynamically compiled in two stages. In a first compilation stage, the compiler instruments selective code paths to count the number of times each path is taken. A second stage compilation is thereafter triggered when the procedure has been called some threshold number of times. In the second stage, the compiler selectively re-compiles the more frequently executed code paths to a primary location, and re-compiles the remaining code paths to an alternate location. Placing infrequently executed code in an alternate location reduces the size of the primary code area, improving execution efficiency.

A method for conditionally sharing dynamically compiled code between different class loaders is provided. In this method, bytecodes of a first class type are compiled into a compiled code if the bytecodes have not been compiled. The locations of sequence of instructions in the compiled code that are loader dependent are then recorded. Thereafter, the loader dependencies in the compiled code are compared to determine whether the compiled code can be used by a method of a second class type. If the loader dependencies of the second class type are different from the loader dependencies of the first class type, the compiled code for the method of the first class type is cloned. Subsequently, portions of the cloned code that are loader dependent are modified to enable the method of the second class type to use the cloned code.

A process and system for dynamically compiling a partially interpreted method is provided. A set of bytecodes for a method is interpreted within a virtual machine. During the interpretation of the method, it is determined, according to the satisfaction of predetermined criteria, that the method contains an execution hot spot and should be just-in-time compiled (JITed) in order to increase the processing speed of the method. The interpretation of the method is halted with a halted execution state and at a halted execution location. Another method is constructed using information from the partially interpreted method and its execution state. The newly constructed method is just-in-time compiled and invoked in such a manner that the newly constructed method recreates the execution state of the partially interpreted method. Once the newly constructed method recreates the execution state of the partially interpreted method, the execution flow follows the bytecode sequence of the partially interpreted method.

Embodiments of a system, program product and method are presented to perform automatic partitioning of work between host processor (such as, e.g., a CPU) and at least one additional heterogeneous processing element (such as, e.g., a GPU) through run-time adaptive mapping. The adaptive mapping may be performed by a dynamic compiler, based on projected execution times predicted by curve fitting based on actual execution times generated during a profile run of the program. Other embodiments are described and claimed.

Methods and apparatus for dynamically compiling byte codes associated with methods during idle periods in the execution of a computer program are disclosed. The described methods are particularly suitable for use in computer systems that are arranged to execute both interpreted and compiled byte codes. In some embodiments, methods to be dynamically compiled are referenced in one or more lists. The lists may be prioritized to facilitate the compilation of the highest priority methods first. In one embodiment, a pair of compilation lists are provided with a first one of the compilation lists being created prior to processing the computer program while the other is created during the processing of the computer program.

An apparatus includes a processor for executing instructions at runtime and instructions for dynamically compiling the set of instructions executing at runtime. A memory device stores the instructions to be executed and the dynamic compiling instructions. A memory device serves as a trace buffer used to store traces during formation during the dynamic compiling. The dynamic compiling instructions includes a next-executing-cycle (N-E-C) trace selection process for forming traces for the instructions executing at runtime. The N-E-C trace selection process continues through an existing trace-head when forming traces without terminating a recording of a current trace if an existing trace-head is encountered.

A computer-implemented method for memory access monitoring, implemented by a managed runtime environment computer system including a controller that monitors application behavior and determines actions to be taken to change a behavior of an application, and a runtime, dynamic compiler that analyzes the application and generates code sequences to access a memory access monitoring (MAM) mechanism, includes determining monitor information of a plurality of fields of a memory block to drive an optimization of the application.

A system, method, and computer program product are provided for performing scalar operations using a SIMD data parallel execution unit. With the mechanisms of the illustrative embodiments, scalar operations in application code are identified that may be executed using vector operations in a SIMD data parallel execution unit. The scalar operations are converted, such as by a static or dynamic compiler, into one or more vector load instructions and one or more vector computation instructions. In addition, control words may be generated to adjust the alignment of the scalar values for the scalar operation within the vector registers to which these scalar values are loaded using the vector load instructions. The alignment amounts for adjusting the scalar values within the vector registers may be statically or dynamically determined.

Synchronizing clones of a software method to be executed by at least one thread while the software method is compiled. The software method is cloned to generate a software method clone. At least one transition is created between equivalent program points in the software method and the software method clone. A lock object is inserted into one of the software method and the software method clone. Then, code that controls the at least one transition between a profiling clone and a non-profiling clone is changed to access thread-local storage. The non-profiling clone is the one of the software method and the software method clone into which the lock object was inserted. A first synchronization operation is performed at or after an entry point of the non-profiling clone. Then, the profiling clone is executed using thread-local storage.

A method for sharing dynamically compiled code between different class loaders is provided. In this method, loader-reentrant compiled code is produced from bytecodes by generating native code implementing a class initialization barrier when compiling bytecodes that require a class to be initialized, by generating native code implementing a link resolution barrier when compiling bytecodes that require a symbolic link to be resolved, and by generating code to retrieve loader-dependent data from a loader-dependent table when compiling bytecodes that use data computed from a resolved symbolic link.

The same executable instruction stream as an executable instruction stream generated by a dynamic compiler is reproduced to facilitate debugging of the dynamic compiler. Provides compiler program for computer functioning as: an execution status obtaining section for obtaining an execution status of the program; a dynamic compilation section for compiling one of the partial programs to be executed during execution of the program; an execution status recording section for recording the execution status in a memory area allocated on a memory of the computer; a file reading section for reading a file containing contents of the memory area allocated on the memory; and a replay compilation section for compiling the one partial program on the basis of the execution status obtained from the file to generate the same executable instruction stream as the executable instruction stream generated by the dynamic compilation section during the execution of the program.

The invention discloses a method and a system for dynamically converting telecommunications service data. The method comprises the following steps of: obtaining a preset telecommunications service data converting rule; dynamically generating a JAVA source code in a service realizing type according to the data converting rule and a preset service realizing type template; compiling and generating aJAVA program code; dynamically loading and executing the service realizing type; and generating a source data file into an object data file. The invention aims at the characteristics of the telecommunications service data to establish a rich function set, provides a function self-defining interface at the same time and is convenient to user self definition and function set expansion. Different from the current script interpretative type ETL (Extract-Transform-Load) tool, the invention adopts dynamic compiling, dynamic loading and a JAVA reflection technology, increases data conversion efficiency and has stronger cross-platform property and application flexibility.

The present invention provides a novel execution environment for optimizing the efficiency of the distributed object system. In one embodiment, the invention includes a compiler with ability to interpret, just-in-time compile or pre-compile any object of the distributed object system. An object is provided in a tagged file format that allows a compiler to identify critical sections of the object code for immediate one-time compiles while delaying compiling of the non-tagged, non-critical code until actually required by the system. The object code includes at least one dynamic base object which includes an interface dynamic base object and a implementation base object. The implementation dynamic base object fulfills the object system requested tasks transmitted over by the interface dynamic base object via a message bus.

An object oriented mechanism and method allow allocating Java objects on a method's invocation stack in a dynamic compilation environment under certain conditions. When a class is dynamically compiled by a just-in-time (JIT) compiler (as the program runs), one or more of its methods may create objects that may be placed on the method's invocation stack. During the compilation of the class, only the information relating to the previously-loaded classes is taken into account. After compilation, as each new class is loaded, the class is analyzed to see if loading the class might change the analysis used to allocate objects on the invocation stacks of previously-compiled methods. If so, the previous object allocations are analyzed in light of the object reference(s) in the newly loaded class, and the previous object allocations are changed from the invocation stack to the heap, if required. In this manner objects may be allocated to a method's invocation stack based on information that is available from the classes that have been loaded, and can then be changed to be allocated from the heap if information in new classes shows that the previous decision (to allocate on the invocation stack) is no longer valid.

A system, method, and computer program product are provided for performing scalar operations using a SIMD data parallel execution unit. With the mechanisms of the illustrative embodiments, scalar operations in application code are identified that may be executed using vector operations in a SIMD data parallel execution unit. The scalar operations are converted, such as by a static or dynamic compiler, into one or more vector load instructions and one or more vector computation instructions. In addition, control words may be generated to adjust the alignment of the scalar values for the scalar operation within the vector registers to which these scalar values are loaded using the vector load instructions. The alignment amounts for adjusting the scalar values within the vector registers may be statically or dynamically determined.

The invention discloses a method for recovering Java serialized file data. The method comprises steps as follows: S1, identifiers about data types and structures are analyzed and recorded; S2, intermediate structures are defined and used for storing data type names, domain names and values of nodes; S3, an intermediate result of the uppermost layer is acquired, and a class definition ID list is maintained; S4, the intermediate result is spread and converted into json character strings; S5, structures of classes are extracted, and class templates are generated and used for recovering memory data; S6, complete serialized data are recovered to an memory. The method has the beneficial effects as follows: standard Java serialized files are parsed into general data in an JSON format or XML format under the condition that raw data structures cannot be obtained; original entity classes are generated for a target platform on the basis that the serialized files are parsed in an JSON format or an XML format, and the parsed data are called by the target platform in an object form; the recovered entity classes can be dynamically compiled as .class files for the target platform to use during follow-up data processing.

One embodiment of the present invention provides a system that dynamically compiles byte codes into native code to facilitate faster execution. This method operates in a mixed-mode system that supports execution of both compiled code and interpreter code. During operation, the system periodically determines if a currently executing thread is executing through the interpreter. If so, the system locates the method being executed by the thread and compiles the byte codes of the method into native code. Subsequent executions of the method utilize the faster-executing native code.

Dynamically compiled computer program code containing virtual calls can reduce the options for optimization during compilation. A virtual call can affect sections of the program code that are compiled subsequent to the virtual call. Therefore, the state under which the effected sections are to be executed may not be known at the time of compilation thus complicating optimization of these sections. If assumptions are made about the state of an effected section, then this section can be optimized. In order to provide proper operation of the executing program code given the optimization, a check of the validity of the assumptions is performed prior to execution of the optimized section. If an assumption does not hold true then the original un-optimized section can be executed to reduce adverse program performance.

Modern programming languages have stimulated work on systems that dynamically compile or optimize frequently executed portions of programs. In practice, such systems typically rely on ad hoc heuristics. For example, a system may optimize (or compile) some code once its execution count exceeds a given threshold. An analytical model has been developed that expresses performance of such a system. In one embodiment, the model is based on a bytecode frequency histogram, which indicates (for a given program) how many bytecodes run for how many times. It predicts that the optimal compilation threshold will occur where the hazard rate falls through the reciprocal of the break-even point, the number of times a compiled bytecode must be executed to recoup its compilation time. Based on the insight provided by the model, a dynamic compilation control technique has been developed.

Template-generated classes in program code are compiled efficiently through a process of lazy compilation resulting in improved compilation times. Lazy compilation includes the generation of objects representing a class template and a template-generated class as well as the selective compilation of class methods that are invoked in the program code. Code sharing is a further enhancement for increasing compilation speed by providing a system and method for sharing executable object code for compatible methods among different classes generated from the same class template.

Space occupied by native code associated with a first method and stored within a native code space is reclaimed by determining whether the native code space exceeds a threshold in response to the invocation of a second method. Once the determination is made, byte code is compiled into native code associated with the second method and the native code associated with the first method may be reclaimed. In one embodiment, this reclamation occurs in response to a determination that the threshold has been exceeded and that the first method is inactive. In another embodiment, reclamation occurs in response to a determination that the threshold has been exceeded and that the first method is cold.