Dynamic Compiler Parallelism for GPU Utilization

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Conventional computing devices with GPUs have limited utilization, restricting the potential processing performance due to specialized processing capabilities, necessitating increased GPU utilization for enhanced performance.

Innovation Solution

The implementation of inline parallelism and re-targetable parallel processing techniques through a compiler and runtime library that dynamically offloads and compiles C++ applications to execute on either the CPU or GPU, utilizing just-in-time compilation for sequential or parallel execution on either processing unit, thereby maximizing GPU utilization.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Power

If GPU is used for specialized processing only, then processing capability for specific tasks is improved, but overall utilization of GPU is reduced

Engineering Contradiction:

Improveprocessing capabilityVSAvoidGPU utilization

Core Design Contradiction:

PowerVSProductivity

Solution Approach 1:

The patent enables the GPU to perform multiple functions by allowing execution of both specialized graphics processing and general-purpose parallel computing tasks. The compiler system translates standard C++ code into GPU-executable code, making the GPU a universal processor that can handle diverse workloads including scientific computing, data processing, and traditional graphics rendering, thereby resolving the contradiction between specialized capability and overall utilization.

Inventive Principle:

Principle #6Universality (Multi-functionality)

2Adaptability or versatility

If C++ applications are compiled for CPU execution, then code portability is maintained, but processing performance is limited

Engineering Contradiction:

Improvecode portabilityVSAvoidprocessing performance

Core Design Contradiction:

Adaptability or versatilityVSProductivity

Solution Approach 1:

The patent introduces a compiler as an intermediary system that translates standard C++ code into GPU-executable code without requiring changes to the source code. This intermediary compiler enables portability maintenance while unlocking GPU processing performance, as it automatically adapts the code for different target architectures (CPU or GPU) based on compilation flags or runtime decisions.

Inventive Principle:

Principle #24Intermediary (Mediator)

3Productivity

If GPU execution is enabled for C++ applications, then processing performance is improved, but implementation complexity increases

Engineering Contradiction:

Improveprocessing performanceVSAvoidimplementation complexity

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The patent implements a self-service approach where the compiler automatically handles the complex task of code translation and optimization for GPU execution. Developers simply add compilation flags or use predefined macros in their existing C++ code, and the compiler system autonomously performs the complex work of generating GPU-compatible code, managing memory, and optimizing parallel execution, thereby minimizing the burden on developers while achieving performance improvement.

Inventive Principle:

Principle #25Self-service

Data Source

PatentUS20190121625A1Dynamic compiler parallelism techniques

Publication Date: 2019.04.25 NVIDIA CORP

AI summary

Compiler techniques lot inline parallelism and re-targetable parallel runtime execution of logic iterators enables selection thereof from the source code or dynamically during the object code execution.