GPU Long Instruction Tracing for Low-Overhead Kernel Profiling

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing GPU profiling tools are inefficient in dynamically analyzing GPU workload at the level of each specific GPU instruction without compromising performance, limiting the ability to optimize GPU operation.

Innovation Solution

Generate and analyze GPU long instruction traces (GLITs) to capture GPU states during kernel execution, allowing for the measurement of operating parameters such as execution time, busy/idle time, and utilization, enabling dynamic optimization of GPU operation.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Measurement precision

If existing GPU profiling tools are used to analyze GPU workload at the level of each specific GPU instruction, then measurement precision is improved, but productivity deteriorates due to inefficiency and performance compromise

Engineering Contradiction:
ImproveGPU instruction-level analysis precisionVSAvoidProfiling efficiency
Core Design Contradiction:
Measurement precisionVSProductivity

Solution Approach 1:

The patent creates a copy of the GPU execution pipeline through software simulation. The GLIT engine captures actual GPU execution traces and replays them in software, allowing detailed instruction-level analysis without impacting actual GPU performance. This copying approach enables precise measurement of each GPU instruction while maintaining productivity by performing analysis on the replicated execution data rather than interfering with the original execution.

Inventive Principle:
Principle #26Copying

2Measurement precision

If detailed GPU state capture is implemented to measure operating parameters, then measurement precision is improved, but device complexity increases

Engineering Contradiction:
ImproveOperating parameter measurement precisionVSAvoidProfiling system complexity
Core Design Contradiction:
Measurement precisionVSDevice complexity

Solution Approach 1:

The patent introduces an intermediary GLIT engine that sits between the GPU execution and the analysis tools. This intermediary component captures GPU states and instruction traces in a standardized format, then provides this data to various analysis tools. The intermediary approach improves measurement precision by systematically capturing detailed GPU states while managing device complexity by centralizing the instrumentation logic in the GLIT engine rather than distributing it throughout the entire system.

Inventive Principle:
Principle #24Intermediary (Mediator)

3Measurement precision

If profiling instructions are inserted into GPU kernel to store execution information, then measurement precision is improved, but loss of time increases due to overhead

Engineering Contradiction:
ImproveCode execution measurement precisionVSAvoidExecution time overhead
Core Design Contradiction:
Measurement precisionVSLoss of time

Solution Approach 1:

The patent performs preliminary action by capturing complete GPU execution traces before any detailed analysis is performed. The GLIT engine records instruction-level data and GPU states during a single execution pass, storing this information for subsequent offline analysis. This preliminary capture approach improves measurement precision by having all execution data available for analysis while minimizing time loss, since the tracing overhead is incurred only once during the initial execution rather than during each analysis operation.

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentEP4009176B1Methods and apparatus to generate graphics processing unit long instruction traces
Publication Date: 2026.02.25 INTEL CORP
  • EP4009176B1 patent drawingFigure 1
  • EP4009176B1 patent drawingFigure 2
  • EP4009176B1 patent drawingFigure 3

AI summary

Methods, apparatus, systems and articles of manufacture are disclosed to generate a graphics processing unit (GPU) long instruction trace (GLIT). An example apparatus includes at least one memory, and at least one processor to execute instructions to at least identify a first routine based on an identifier of a second routine executed by the GPU, the first routine based on an emulation of the second routine, execute the first routine to determine a first value of a GPU state of the GPU, the first routine having (i) a first argument associated with the second routine and (ii) a second argument corresponding to a second value of the GPU state prior to executing the first routine, and control a workload of the GPU based on the first value of the GPU state.