Multi-thread Runtime System for Parallel Processing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current parallel-processing computer systems lack an efficient, stable, and user-friendly software development and execution platform that supports easy program interface, rich library resources, program debugging, and profiling, and enables seamless execution across different types of parallel-processing systems.
Innovation Solution
A runtime system with multiple execution threads that dynamically manage compute kernels, schedule processing, and execute operations across various processing elements, featuring a Language-Specific Interface, Front End, compilation scheduler, trace cache, macro cache, and execution scheduler to optimize compute kernel generation and execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a parallel-processing computer system is used to provide tremendous computing capacity, then processing power and productivity are improved, but the complexity of software development and execution platform increases
Solution Approach 1:
The runtime system is designed to be architecture-agnostic and language-agnostic, providing a universal execution platform that can run compute kernels on different types of processing elements (CPUs, GPUs, FPGAs) and support multiple programming languages through language-specific interfaces. This universality allows the same application to execute on various parallel-processing systems without modification, reducing software development complexity while maintaining high computing capacity
Solution Approach 2:
The runtime system acts as an intermediary layer between the high-level application code and the underlying parallel-processing hardware. It includes components such as the compilation scheduler, execution scheduler, and kernel management system that translate user-friendly program interfaces into optimized executeable code for diverse hardware architectures. This intermediary abstraction shields developers from hardware complexity while enabling efficient utilization of parallel-processing capacity
2Adaptability or versatility
If a unified runtime system is designed to support execution on any type of parallel-processing computer system, then adaptability is improved, but device complexity increases
Solution Approach 1:
The runtime system implements a universal execution model that can adapt to different processing element architectures through standardized interfaces. The system includes architecture-specific backends that handle the complexities of different hardware platforms while presenting a unified interface to applications. This allows the same runtime system to manage execution on CPUs, GPUs, FPGAs, and other parallel-processing devices without requiring separate systems for each architecture
Solution Approach 2:
The runtime system is segmented into modular components including language-specific interfaces, front ends, compilation schedulers, execution schedulers, and kernel management systems. Each module handles specific aspects of the execution process and can be independently configured for different target architectures. This segmentation allows the system to maintain high adaptability across different platforms while managing complexity through modular design, where each segment can be optimized for its specific function
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.