Graph Program Acceleration System for Hardware-Independent Analysis

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Developing scalable graph analysis applications that can efficiently handle a wide range of graph data sets is a non-trivial technical challenge, especially for machine learning algorithms used in various problem domains, as existing technologies struggle to optimize graph analysis algorithms for execution across different hardware platforms.

Innovation Solution

A high-level hardware-platform-independent programming language, such as GPALang, is used to express graph analysis algorithms, which are then optimized and executed across various hardware platforms, including GPUs, CPUs, and FPGAs, through a graph program acceleration system (GPAS) that parses and transforms the source code into optimized intermediary data structures and executable code modules tailored for specific hardware platforms.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Productivity

If graph analysis algorithms are optimized for specific hardware platforms, then execution speed and efficiency are improved, but device complexity and difficulty of implementation increase

Engineering Contradiction:
Improveexecution speedVSAvoidoptimization complexity
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent introduces an intermediary layer (graph analysis system) that sits between the high-level algorithm description and the hardware-specific execution. This system automatically performs platform-specific optimizations, transformations, and code generation, allowing algorithms to achieve hardware-optimized performance without requiring developers to directly handle hardware complexity. The intermediary handles tasks such as partitioning graph data, selecting appropriate algorithms, and generating optimized code for different platforms.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Ease of operation

If graph analysis programs are written in high-level languages, then ease of programming is improved, but execution efficiency deteriorates

Engineering Contradiction:
Improveease of programmingVSAvoidexecution efficiency
Core Design Contradiction:
Ease of operationVSProductivity

Solution Approach 1:

The system performs preliminary actions by automatically analyzing the high-level graph analysis program, generating optimized intermediate representations, and preparing platform-specific code before execution. This includes pre-processing steps such as graph partitioning, algorithm selection, and code transformation that convert high-level descriptions into efficient low-level code, thereby maintaining ease of programming while achieving high execution efficiency.

Inventive Principle:
Principle #10Preliminary action

3Adaptability or versatility

If graph analysis applications are made scalable to handle large data sets, then applicability to real-world problems is improved, but memory usage and computational resources increase

Engineering Contradiction:
ImprovescalabilityVSAvoidmemory usage
Core Design Contradiction:
Adaptability or versatilityVSQuantity of substance

Solution Approach 1:

The patent applies segmentation by dividing large graph data sets into smaller partitions or chunks that can be processed independently or in parallel. This allows the system to handle large-scale graphs by breaking them down into manageable pieces, processing each partition with appropriate algorithms, and combining results. This segmentation approach enables scalability to large data sets while controlling memory usage by processing data in smaller units rather than loading entire graphs into memory.

Inventive Principle:
Principle #1Segmentation

Data Source

PatentUS11900079B2Acceleration techniques for graph analysis programs
Publication Date: 2024.02.13 AMAZON TECH INC
  • US11900079B2 patent drawing
  • US11900079B2 patent drawing
  • US11900079B2 patent drawing

AI summary

Source code of a graph analysis program expressed in a platform-independent language which supports linear algebra primitives is obtained. An executable version of the program is generated, which includes an invocation of a function of a parallel programming library optimized for a particular hardware platform. A result of executing the program is stored.