Offload Server Automates GPU Parallelization via OpenACC
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for automatically offloading processing to GPUs, such as those using OpenACC, do not sufficiently improve performance compared to manual acceleration with CUDA, and face challenges in identifying appropriate parallel processing areas and reducing data exchange overhead between CPU and GPU memory.
Innovation Solution
An offload server that analyzes application code, designates GPU processing using OpenACC directives, identifies loop statements, generates parallel processing patterns, measures performance, and selects the most efficient pattern for offloading, thereby extending the scope of application for GPU offloading.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If automatic parallelization is used to offload processing to GPU, then programming complexity is reduced, but performance improvement is insufficient due to data exchange overhead between CPU and GPU memory
Solution Approach 1:
The system performs preliminary code analysis to automatically identify parallelizable loop statements before execution. By pre-determining which loops can be offloaded to GPU and generating appropriate OpenACC directives, the system eliminates the need for manual programming while optimizing performance through automated data transfer management.
Solution Approach 2:
The patent introduces an intermediary layer (the offload server and code analyzer) between the CPU code and GPU execution. This intermediary automatically handles the complex tasks of code analysis, parallelization detection, data transfer optimization, and directive generation, thereby resolving the contradiction between ease of programming and performance improvement.
2Productivity
If manual CUDA optimization is performed to reduce data exchange overhead, then performance is improved, but programming complexity and skill requirements increase
Solution Approach 1:
The system enables self-service optimization where the offload server automatically analyzes application code, identifies parallelizable sections, generates OpenACC directives, and manages data transfers without requiring manual intervention. The system serves itself by performing what would otherwise require skilled manual optimization.
Solution Approach 2:
The patent changes the approach from manual parameter tuning to automated parameter generation. By using code analysis to automatically determine optimization parameters (which loops to parallelize, how to structure data transfers, which directives to generate), the system achieves performance improvement without manual programming complexity.
3Adaptability or versatility
If loop statements are identified for parallel processing, then GPU offloading capability is extended, but compilation errors may occur with certain loop structures
Solution Approach 1:
The system dynamically adapts its behavior based on the code structure. By analyzing each loop statement and determining whether it can be safely parallelized, the system dynamically generates appropriate OpenACC directives or skips problematic loops. This dynamic adaptation maintains high versatility while ensuring compilation success.
Solution Approach 2:
The patent applies partial parallelization by selectively identifying only the loop statements that can be safely offloaded to GPU, rather than attempting to parallelize all loops. This partial action approach extends GPU offloading capability to more applications while avoiding compilation errors in cases where full parallelization would not be appropriate.
Data Source
AI summary
An offload server includes: an application code analysis section configured to analyze source code of an application; a data transfer designation section configured to, on the basis of a result of the code analysis, designate GPU processing for a loop statement by using at least one selected from the group of directive clauses, of OpenACC, consisting of a ‘kernels’ directive clause, a ‘parallel loop’ directive clause, and a ‘parallel loop vector’ directive clause; and a parallel processing designation section configured to identify loop statements in the application, and, for each of the identified loop statements, specify a statement specifying application of parallel processing by the GPU and perform compilation.