Systems and methods are described for utilizing script chunks in client-side browsing applications. A script chunking service divides scripts into smaller portions, and generates precompiled chunks of code that correspond to the portions. The service may then request compilation of only those portions of a script that do not have a corresponding precompiled chunk. Portions may be determined based on length, script keywords, or other criteria, and chunks may be identified by applying a hashing function to the portions. Scripts may be filtered to identify differing portions of source code that compile to functionally identical instructions, and the chunking service may use supplemental hashes, hashes of hashes, and complier state information to facilitate identification and compilation of precompiled chunks.

In some examples, just-in-time (JIT) control instructions upon execution cause a system to initiate a plurality of instances of JIT compilation of a first code called by a program, where the initiating of the plurality of instances of the JIT compilation of the first code is under control of the JIT control instructions that are outside the program, and the plurality of instances of the JIT compilation of the first code use respective different compilation settings, and are to produce respective JIT compiled instances of the first code.

Aspects of the disclosure relate to managing a set of warning data with respect to an execution phase in a computing environment. In embodiments, the computing environment may include a distributed computing environment or a stream computing environment. The set of warning data may be detected with respect to the execution phase. In embodiments, the set of warning data may be coupled with a computing artifact. In embodiments, the computing artifact may include a compilation which has a computing object in association with the set of warning data. Using the set of warning data, an execution action which pertains to the computing artifact may be determined. In embodiments, the execution action may include a code deployment to a set of computing units, a run-time check modification, or a process attribute modification. The execution action which pertains to the computing artifact may be performed.

In an example, a computing device may include a trusted execution environment (TEE) for executing signed and verified code. The device may receive a trusted binary object in a first form, but the object may need to be converted to a second format, either on-the-fly, or in advance. This may include, for example, a bytecode interpreter, script interpreter, runtime engine, compiler, just-in-time compiler, or other species of binary translator. The binary translator may be run from the TEE, and the output may then be signed by the TEE and treated as a new trusted binary.

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.

A receiving node in a computer system that includes a plurality of types of execution units receives an active message from a sending node. The receiving node compiles an intermediate language message handler corresponding to the active message into a machine instruction set architecture (ISA) message handler and the receiver executes the ISA message handler on a selected one of the execution units. If the active message handler is not available at the receiver, the sender sends an intermediate language version of the message handler to the receiving node. The execution unit selected to execute the message handler is chosen based on a field in the active message or on runtime criteria in the receiving system.

Methods and systems for program code conversion for cross-platform compatibility are disclosed. A plurality of original function calls are identified in an original program. The original program is targeted to a first platform, and the original function calls comprise invocations of a plurality of functions implemented on the first platform. It is determined whether individual ones of the original function calls correspond to alternative function calls in an index. For the original function calls that correspond to the alternative function calls in the index, the original function calls are replaced with corresponding alternative function calls in a modified program. The modified program is targeted to a second platform, and the alternative function calls comprise invocations of a plurality of functions implemented on the second platform.

Resource processing during run time can be performed asynchronously from emulation of an application by a central processing unit. For example, an emulator can include a main processing thread that performs emulation processes. In response to encountering a shader, or other resource, to be processed, the emulator can invoke a separate asynchronous thread to perform such processing. Processed resources, such as translated shaders and generated textures, can be stored in a cache. In response to a command that uses a resource, such as a draw command that invokes a shader or other resource, the emulator can use the processed resource in the cache. If the processed resource is not in the cache, the emulator can skip processing the command that uses the resource. If processed resources can be obtained from other sources and loaded in the cache, processing of resources by the emulator can be eliminated.

A system is provided for monitoring, regenerating and replacing the code of running applications with semantically equivalent, specialized code versions that reflect the demands of the execution environment. The system includes a co-designed compiler and runtime system that virtualizes a selected set of edges in a host program, where these edges provide hooks through which the runtime system may redirect execution into an intermediate representation utilized to optimize introspective and extrospective processes.

Embodiments according to the present invention introduce a high-level abstraction for specifying and operating dynamic filtering at runtime without service interruption. A CustomFilterAdapter implementation of the javax.servlet.Filter interface is added to the target servlet's configuration. A configuration file and/or data structure are used to establish a chain of responsibility pattern and options for existing and for newly added or removed filters. When the chain of responsibility pattern changes, the filters are started and the CustomFilterAdapter reloads the chain of responsibility. When an HTTP request is received, CustomFilterAdapter processes the filters in the chain of responsibility in the chain order.