90 results about "Just-in-time compilation" patented technology

A method, apparatus, and computer instructions are provided for transforming Java Native Interface function calls to constants, internal just-in-time compiler operations or simpler intermediate representation. A compiler generates a plurality of intermediate representations for a plurality of native interface function calls. During inlining of native code, matching is performed on each native function call (against this list) and a list of native interface function calls is generated. For each native interface function call, a JIT call transformer attempts to replace the native interface function call with a constant, internal just-in-time compiler operation or a simpler intermediate representation depending on the type of native interface function call.

A method, apparatus, and computer instructions are provided for inlining native functions into compiled Java code. A conversion engine is provided by the present invention for converting the intermediate representation of native functions to the just-in-time (JIT) compiler's intermediate representation. With the converted intermediate representation, an inliner recursively inlines the converted JIT compiler's intermediate representation into the native callsite to remove the need of invoking the native function and subsequent native calls made by the function. The inlining process continues until either a call to an opaque function is encountered or until a JIT compiler intermediate representation growth limits are reached. The inliner also replaces calls to most native functions that are non-inlineable or opaque with calls to synthesized native functions that provide access to native libraries containing implementations of the original non-inlineable calls.

The invention provides a method and system for creating a single, common installation file for multiple target device types. In one approach, the method comprises providing a base engine, compiling the engine into an intermediate language code, and just-in-time compiling the intermediate code into executable code. The latter code is executed to gather the appropriate data sets and concatenate the data sets with the engine to form the installation file. The present invention also provides a method and system for utilizing the installation file to retrieve the appropriate data set(s) for the identified target device type, and to install the retrieved data set(s) onto the target device.

An approach is provided that sends a JIT compilation request from a first process that is running on one processor to a JIT compiler that is running on another processor. The processors are based on different instruction set architectures (ISAs), and share a common memory to transfer data. Non-compiled statements are stored in the shared memory. The JIT compiler reads the non-compiled statements and compiles the statements into executable statements and stores them in the shared memory. The JIT compiler compiles the non-compiled statements destined for the first processor into executable instructions suitable for the first processor and statements destined for another type of processor (based on a different ISA) into instructions suitable for the other processor.

Methods and apparatus are disclosed for fusing instructions to provide OR-test and AND-test functionality on multiple test sources. Some embodiments include fetching instructions, said instructions including a first instruction specifying a first operand destination, a second instruction specifying a second operand source, and a third instruction specifying a branch condition. A portion of the plurality of instructions are fused into a single micro-operation, the portion including both the first and second instructions if said first operand destination and said second operand source are the same, and said branch condition is dependent upon the second instruction. Some embodiments generate a novel test instruction dynamically by fusing one logical instruction with a prior-art test instruction. Other embodiments generate the novel test instruction through a just-in-time compiler. Some embodiments also fuse the novel test instruction with a subsequent conditional branch instruction, and perform a branch according to how the condition flag is set.

A computer-implemented method is provided for reducing network traffic associated with live migration. The method comprises selecting a virtual machine on a first physical host for migration to a second physical host, and providing each application running in the selected virtual machine with notification that the migration has started. In response to receiving the notification that the migration has started, each application reducing the number of memory pages in use during the migration. The selected virtual machine and each application is then migrated from the first physical host to the second physical host, wherein the migration of each application includes migration of the reduced number of memory pages. Non-limiting examples of methods that may be used to reduce the number of memory pages includes identifying memory that contains garbage, reducing the size of the heap, increasing the pause time used for garbage collection, deferring just-in-time compilation of hot methods, and releasing caches and buffers.

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.

A system-wide service can simultaneously harden multiple running JITs, for example by hooking into the memory protections of a target operating system and randomizing newly generated code on the fly when marked as executable. Some embodiments preserve the contents of the calling stack, presenting each JIT with the illusion that it is executing its own generated code.

An improved system and method are disclosed for processing Java program code. Java source code is annotated with a Module or a ControlFlow annotation. The Java source code is then compiled to produce Java bytecode, which in turn is compiled by a just-in-time compiler to produce native code, which retains the annotations. The native code with annotations is then executed. If a bug is identified during the execution of the native code, an associated Module is selected for debugging, followed by determining associated Java source code segments within the responsible control flow path. Debugging operations are then performed on the associated Java source code segments.

A method of optimizing the runtime performance of a program written in an interpreted programming language can include loading, within a virtual machine having a Just In Time (JIT) compiler, the program and a file specifying frequency of execution data for at least one component of the program. The program can be executed. The executing step can include reading the file specifying the frequency of execution data, seeding a counter of the virtual machine associated with the component(s) with a value derived from the frequency of execution data, and performing a JIT action upon the component(s) of the program according to the seeded counter of the virtual machine.

A selected group of Guest machine instructions in an emulation environment are translated to a semantic routine of Host machine instructions, wherein Guest cells corresponding to an opcode portion of a Guest instruction are mapped to corresponding Host cells, wherein the semantic routine of Host machine instructions are patched into a Host cell corresponding to the first Guest cell of the group of Guest machine instructions, wherein other Host cells of the corresponding Host cells are patched with semantic routines for emulating single instructions associated with the corresponding Guest cell.

The present invention is directed towards providing a system and method for optimizing HTML output in a just-in-time compiling environment for devices such as mobile devices. A method is provided for optimizing the output in a single pass as device content is rendered. The method delays writing a closing tag until it is determined that a formatting or layout of the next control conflicts. Tags are emitted in a predefined order to minimize the number of tags that will need to be closed to accommodate a following control whose style differs. Object hierarchy is leveraged to predict the order in which tags should be written without looking ahead of the current control in the hierarchy.

A bytecode construction, a method, and a system for optimizing just in time compilation. The bytecode includes several regions wherein a region is a logical sequence of one or more bytecode blocks and the bytecode is annotated with region hints embedded therein. The region hints have a bytecode structure and are designed for instructing a just-in-time, or JIT, runtime environment for JIT compilation of the regions by JIT compilers implemented at nodes of a network. A method and a system for implementing the bytecode construction are also presented.

It is one object of the present invention to provide a program execution method for performing greater optimization. A program execution apparatus according to the present invention performs a transfer from an interpreter process to a compiled code process in the course of the execution of a method. At this time, if no problem occurs when a transfer point is moved to the top of a loop, the transfer point for code is so moved. And when a transfer point is located inside a loop, a point that post-dominates the top of the loop and the transfer point is copied to a position immediately preceding the loop. Then, information for generating recalculation code is provided for the transfer point, and a recalculation is performed.

Fusible instructions and logic provide OR-test and AND-test functionality on multiple test sources. Some embodiments include a processor decode stage to decode a test instruction for execution, the instruction specifying first, second and third source data operands, and an operation type. Execution units, responsive to the decoded test instruction, perform one logical operation, according to the specified operation type, between data from the first and second source data operands, and perform a second logical operation between the data from the third source data operand and the result of the first logical operation to set a condition flag. Some embodiments generate the test instruction dynamically by fusing one logical instruction with a prior-art test instruction. Other embodiments generate the test instruction through a just-in-time compiler. Some embodiments also fuse the test instruction with a subsequent conditional branch instruction, and perform a branch according to how the condition flag is set.

A method to just-in-time (JIT) compile Java software methods, the method having the steps of: initializing a first counter for a first software method to a first value, the first value being adjusted each time the first software method is invoked; initializing a second counter for a second software method to a second value, the second value being different from the first value, and the second value being adjusted each time the second software method is invoked; responsive to a determination that the first value exceeds a particular value, JIT compiling the first software method; responsive to a determination that the second value exceeds the particular value, JIT compiling the second software method.

A computer-implemented method of creating a simulation engine for simulating a circuit design can include receiving a source code contribution from a high level modeling system and receiving a simulation model specified in an interpretive language that specifies the circuit design. The source code contribution can be compiled together with the simulation model using a Just-In-Time compiler. A simulation engine, specified in native machine code, can be output as a single, integrated software component formed from the source code contribution and the simulation model.

The present invention provides a method, system and computer program product for optimizing computer program execution during class loading phase. As a code method of the program is received for compiling prior to execution, a check is performed whether program execution is in class loading phase. Program execution is in class loading phase where the class loading rate exceeds a pre-determined level during a pre-determined interval. If the program is in class loading phase, then compiling is reduced by lowering frequency of JIT compilation, lowering optimization level of just-in-time compilation, or a combination of the two. The code method may also be passed to an interpreter to be interpreted.

A system and method is provided to perform code handling, such as interpreting language instructions or performing “just-in-time” compilation using a heterogeneous processing environment that shares a common memory. In a heterogeneous processing environment that includes a plurality of processors, one of the processors is programmed to perform a dedicated code-handling task, such as perform just-in-time compilation or interpretation of interpreted language instructions, such as Java. The other processors request code handling processing that is performed by the dedicated processor. Speed is achieved using a shared memory map so that the dedicated processor can quickly retrieve data provided by one of the other processors.

A computer implemented method, apparatus, and computer program product for managing just-in-time compilation. The process designates a set of compilation threads for exclusively performing compilation functions associated with an application. A set of computation threads is designated for executing the application. Processor cycles are dynamically allocated during runtime between the set of compilation threads and the set of computation threads to maintain a ratio of processor cycles consumed by the set of compilation threads to processor cycles consumed by the set of computation threads.

The invention provides a real-time compiling system self-adapting adjusting and optimizing method which comprises the following steps: providing a resource library which is across application programs and is used repeatedly, wherein information in the resource library is separated to each running instance, and therefore the informations of all running instances in the resource library are not mutually affected; judging if the current running instance needs to gather relevant information of a real-time compiling process in an on-line mode, wherein a real-time compiling system writes in untreated runtime information to the resource library through a runtime information output, and / or reading the runtime information which is run across the application programs from the resource library; statically analyzing the gathered untreated runtime information in an off-line mode in the resource library to form a precalculated online running strategy; reading the precalculated online running strategy which is read and calculated from the resource library through a runtime optimizing strategy; confirming an optimization method of the real-time compiling system according to the precalculated online running strategy; and running application programs in an on-line mode combining an existing self-adapting optimizing system according to the confirmed optimization method.

In a virtual machine that uses a just-in-time complier (JITC) as a software execution environment, an idle time of a core to which the JITC is allocated is utilized to generate machine code in advance, thereby reducing a load on an interpreter. Accordingly, code execution performance of the interpreter is improved, and the utilization of a multi-core system that executes applications is increased.

Methods and apparatuses are provided for facilitating execution of kernels requiring runtime compilation. A method may include implementing a driver for a framework for handling kernels requiring runtime compilation. The method may further include receiving, by the driver, code for a kernel requiring at least partial runtime compilation for execution using the framework. The method may additionally include obtaining, by the driver, a compiled executable version of the kernel. The obtained compiled executable version of the kernel may not have been locally compiled. The method may also include causing, by the driver, the compiled executable version of the kernel to be provided for execution. Corresponding apparatuses are also provided.

Apparatuses and methods that allow a virtual machine on a device to overcome method cache overloads in dynamic just-in-time (JIT) compilation are disclosed. The apparatuses and methods dynamically adjust the size of a buffer caching compiled native code according to the effective run-time behavior of running applications on the device. Modules in the device monitor the method calls associated with the buffer to detect non-performance-critical and performance-critical overload conditions. The size of the buffer is increase, decreased, or not changed accordingly.

Using stored information about the compilation environment during compilation of a code segment to improve performance of just-in-time compilers. A set of characteristic(s) of a compilation environment is measured during compilation of a code segment. Information that may be relevant to how the compilation is performed is derived from at least one of the measured characteristics and stored in a persistent storage device. Upon a subsequent request to compile that code segment, the information is retrieved and used to change compilation behavior. The set of characteristic(s) relate to at least either compilation backlog or peak memory usage. The changed compilation behavior involves at least adjusting the scheduling of the subsequent compilation request or adjusting the compiler optimization level.