Parallel Code Fragments for Cross-Processor Execution Without Recompilation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Users face difficulties in utilizing processors or computing hardware with different instruction architectures due to the need for translation, recompilation, or additional steps, which can cause downtime and performance penalties.
Innovation Solution
The inclusion of parallel code fragments with foreign code in executable objects allows dynamic execution on different processors without recompilation, enabling seamless utilization of multiple hardware configurations through selection masks and dynamic binary translation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If users translate or recompile code for different instruction architectures, then the code can execute on different processors, but this causes downtime and performance penalties
Solution Approach 1:
The patent applies preliminary action by pre-compiling code into multiple instruction architecture formats (e.g., x86, ARM, RISC-V) and embedding these pre-compiled code fragments within the executable. When the executable runs on a device with different processors, the system dynamically selects and executes the appropriate pre-compiled code fragment without requiring real-time translation or recompilation, thereby eliminating downtime and performance penalties associated with code conversion.
2Ease of manufacture
If a single executable code package is delivered for multiple environments, then distribution is simplified, but dynamic execution on different processors becomes difficult
Solution Approach 1:
The patent applies segmentation by dividing the executable code into multiple independent code fragments, each compiled for a specific instruction architecture (e.g., one fragment for x86 processors, another for ARM processors). These segmented code fragments are embedded within a single executable package alongside selection logic. The selection logic identifies the device's processor type at runtime and directs execution to the appropriate code fragment, enabling a single distributable package to adapt dynamically to different hardware configurations.
3Productivity
If code is compiled for specific processor architectures, then execution efficiency is optimized, but portability to other architectures is reduced
Solution Approach 1:
The patent applies universality by creating a multi-functional executable structure that contains code fragments optimized for multiple processor architectures (x86, ARM, RISC-V, etc.). The executable includes a selection mechanism that automatically identifies the target device's processor type and activates the corresponding optimized code fragment. This allows a single executable to provide architecture-specific performance optimization while maintaining broad portability across diverse hardware platforms.
Data Source
AI summary
In various examples, an executable object including parallel code fragments with foreign code is executed by one or more processors. For example, when a selection mask is enabled, instructions encoded in the executable object are translated for execution by the one or more processors. Continuing this example, the executable object includes the parallel code fragment with the foreign code, once enabled and translated, the foreign code is provided to the target processor for execution.