Runtime System Caching Compute Kernels for Parallel Processing

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Current parallel-processing computer systems lack an efficient, stable, and user-friendly software development and execution platform that provides easy-to-use program interfaces, rich library resources, and supports program debugging and profiling, making it difficult to execute programs across different types of parallel-processing computer systems.

Innovation Solution

A runtime system that includes a Language-Specific Interface (LSI) for easy integration with various programming languages, a compiler scheduler for dynamic processing element selection, and caching mechanisms like the trace cache and macro cache to optimize compute kernel execution, allowing for efficient execution of programs on multiple processing elements.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Speed

If compute kernels are compiled and executed directly on parallel-processing computer systems, then execution speed is improved, but compilation time and system overhead increase

Engineering Contradiction:
Improveexecute speedVSAvoidcompilation time
Core Design Contradiction:
SpeedVSLoss of time

Solution Approach 1:

The patent pre-compiles compute kernels into a common intermediate representation (IR) format that can be executed on multiple parallel-processing architectures. This preliminary compilation action eliminates the need for repeated compilation on target systems, reducing compilation time while maintaining fast execution through the use of pre-processed, architecture-agnostic code that can be quickly loaded and run.

Inventive Principle:
Principle #10Preliminary action

2Speed

If compute kernels are optimized for specific processor architectures, then execution performance is improved, but portability across different architectures deteriorates

Engineering Contradiction:
Improveexecution performanceVSAvoidportability
Core Design Contradiction:
SpeedVSAdaptability or versatility

Solution Approach 1:

The patent creates a universal intermediate representation (IR) format that serves multiple functions: it preserves architecture-specific optimizations while enabling portability across different parallel-processing architectures. The common IR acts as a universal interface that can be translated to various target architectures, allowing the same compiled kernel to execute efficiently on different processor types without requiring architecture-specific compilation.

Inventive Principle:
Principle #6Universality (Multi-functionality)

3Adaptability or versatility

If a software platform supports multiple programming languages and architectures, then adaptability is improved, but system complexity increases

Engineering Contradiction:
Improvemulti-language supportVSAvoidsoftware platform complexity
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent introduces a common intermediate representation (IR) as an intermediary layer between diverse programming languages and parallel-processing architectures. This mediator translates high-level language constructs into a standardized IR format, which then serves as the basis for generating optimized code for different target architectures. This intermediary approach simplifies the software platform by providing a uniform interface that abstracts away the complexity of supporting multiple languages and architectures simultaneously.

Inventive Principle:
Principle #24Intermediary (Mediator)

Data Source

PatentUS8448156B2Systems and methods for caching compute kernels for an application running on a parallel-processing computer system
Publication Date: 2013.05.21 GOOGLE LLC
  • US8448156B2 patent drawing
  • US8448156B2 patent drawing
  • US8448156B2 patent drawing

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.