JIT Controller Managing Parallel Compilation Instances

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

In large programs, especially those in massively parallel computing environments, the overhead of programming and execution is increased due to the need for explicit instructions to control Just-In-Time (JIT) compilation, leading to variability in execution time across parallel instances and inefficiencies in resource utilization.

Innovation Solution

A separate JIT controller manages JIT compilation for functions, allowing multiple instances of JIT compilation with different settings and dynamically selecting the appropriate instance at runtime based on performance measurements, using a patch point array to direct function calls to optimized JIT compiled instances.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Extent of automation

If explicit JIT compilation instructions are added to program source code, then JIT compilation control is enabled, but programming overhead increases

Engineering Contradiction:

ImproveJIT compilation controlVSAvoidprogramming overhead

Core Design Contradiction:

Extent of automationVSDevice complexity

Solution Approach 1:

The JIT compilation control logic is extracted from the program source code and placed in a separate JIT controller. The program simply calls functions through a patch point array, while the JIT controller autonomously manages compilation decisions, triggering multiple compilation instances with different settings and selecting the best one at runtime.

Inventive Principle:

Principle #2Taking out (Extraction)

2Productivity

If JIT compilation is implemented in parallel programs, then code optimization is achieved, but execution time variability increases

Engineering Contradiction:

Improvecode optimizationVSAvoidexecution time variability

Core Design Contradiction:

ProductivityVSLoss of time

Solution Approach 1:

The JIT controller performs preliminary actions by pre-compiling multiple instances of functions with different compilation settings before they are needed during execution. This allows the parallel program to access optimized code instances without causing execution time variability, as the compilation work is done in advance or independently.

Inventive Principle:

Principle #10Preliminary action

Solution Approach 2:

The JIT controller measures the execution performance of different JIT compiled instances and uses this feedback to select the optimal instance for subsequent function calls. This feedback mechanism ensures consistent performance across parallel instances by adapting to actual execution conditions.

Inventive Principle:

Principle #23Feedback

3Productivity

If multiple JIT compilation instances with different settings are created, then function optimization is improved, but resource utilization efficiency decreases

Engineering Contradiction:

Improvefunction optimizationVSAvoidresource utilization efficiency

Core Design Contradiction:

ProductivityVSLoss of energy

Solution Approach 1:

The JIT controller changes compilation parameters (settings) to create multiple instances of functions with different optimization characteristics. By varying parameters such as optimization level, target architecture, or execution model, the system can select the most appropriate instance for each execution context, improving resource utilization efficiency.

Inventive Principle:

Principle #35Parameter changes

Data Source

PatentUS11487565B2Instances of just-in-time (JIT) compilation of code using different compilation settings

Publication Date: 2022.11.01 HEWLETT PACKARD ENTERPRISE DEV LP

AI summary

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.