Parallel Processing Runtime System for Dynamic Compilation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
There is a lack of an efficient, stable, and user-friendly software development and execution platform for parallel-processing computer systems, which hinders the effective utilization of their computing capacity due to inadequate program interfaces, debugging, and profiling tools.
Innovation Solution
A runtime system is developed that includes a Language-Specific Interface, Front End, compilation scheduler, trace cache, macro cache, and execution scheduler to dynamically compile and execute applications on parallel-processing computer systems, supporting multiple programming languages and processing elements, and allowing for easy integration with standard libraries and tools.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Power
If a parallel-processing computer system is equipped with multiple processing elements, then computing capacity is increased, but software development complexity and execution platform stability deteriorate
Solution Approach 1:
The patent introduces a runtime system as an intermediary layer between the application and the parallel-processing hardware. This runtime system includes a language-specific interface, front end, compilation scheduler, trace cache, macro cache, and execution scheduler that collectively manage the complexity of parallel processing, shielding developers from hardware-specific details while maintaining high computing capacity utilization
Solution Approach 2:
The runtime system is designed to support multiple programming languages (C, C++, Fortran, MATLAB) and multiple processing element types (CPUs, GPUs, FPGAs) through a unified architecture. The language-specific interface and front end provide universal access to parallel processing capabilities across different languages and hardware platforms, reducing software development complexity
2Productivity
If a parallel-processing computer system lacks efficient software development tools, then hardware capacity remains underutilized, but developing and maintaining such tools increases system complexity
Solution Approach 1:
The patent merges debugging, profiling, and compilation functionalities into the runtime system that already manages execution. The front end and compilation scheduler are integrated with debugging and profiling tools, allowing these features to share common infrastructure and data structures, thereby improving hardware utilization without proportionally increasing system complexity
Solution Approach 2:
The runtime system provides self-service capabilities through automatic compilation scheduling, trace caching, and macro caching. The compilation scheduler automatically manages the compilation of compute kernels, while the trace and macro caches automatically store and retrieve compiled code, reducing the need for manual intervention and simplifying the toolchain
3Speed
If applications are compiled statically for specific parallel-processing architectures, then execution efficiency is improved, but portability across different systems deteriorates
Solution Approach 1:
The patent implements dynamic compilation through the compilation scheduler, which compiles compute kernels at runtime based on the target processing element architecture. This allows the same application to be efficiently compiled for different hardware platforms (CPUs, GPUs, FPGAs) while maintaining optimal execution performance, resolving the conflict between execution efficiency and portability
Solution Approach 2:
The runtime system changes compilation parameters dynamically based on the target processing element. The compilation scheduler adjusts optimization flags, instruction sets, and compilation strategies according to the specific architecture being targeted, enabling the same source code to achieve high execution efficiency across diverse hardware platforms
4Ease of operation
If debugging and profiling tools are integrated into the runtime system, then user-friendliness is improved, but runtime overhead increases
Solution Approach 1:
The debugging and profiling tools are integrated into the continuous execution flow of the runtime system. The front end and compilation scheduler continuously collect trace information and profiling data during normal operation without interrupting the computation stream, maintaining user-friendliness while minimizing runtime overhead through seamless data collection
Data Source
AI summary
A runtime system implemented in accordance with the present invention provides an application platform for parallel-processing computer systems. Such a runtime system enables users to leverage the computational power of parallel-processing computer systems to accelerate/optimize numeric and array-intensive computations in their application programs. This enables greatly increased performance of high-performance computing (HPC) applications.