Graph Compiler IR Optimization for Parallel Execution

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Compilers do not effectively implement graph-specific optimizations for graph analysis algorithms, leading to inefficient executable code generation, as they lack the flexibility to optimize graph processing tasks, especially when using conventional programming languages.

Innovation Solution

A system architecture that includes a frontend compiler, a host compiler, and an annotation library, which identifies target expressions in source code and generates graph-specific intermediate representation (IR) instructions for parallel execution, using a graph optimization API to optimize IR instructions for graph processing, such as creating multiple threads and managing race conditions.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Ease of operation

If conventional programming languages and compilers are used for graph analysis algorithms, then ease of operation is improved, but productivity deteriorates due to inefficient code generation

Engineering Contradiction:

Improveease of operationVSAvoidproductivity

Core Design Contradiction:

Ease of operationVSProductivity

Solution Approach 1:

The patent introduces an intermediary layer (graph analysis library with domain-specific constructs) between the conventional programming language and the compiler. This intermediary enables developers to write high-level graph analysis code using conventional languages while the library translates these constructs into optimized intermediate representation that compilers can process efficiently, thereby resolving the contradiction between ease of operation and productivity

Inventive Principle:

Principle #24Intermediary (Mediator)

Solution Approach 2:

The patent changes the representation parameters of graph analysis algorithms by introducing domain-specific intermediate representation constructs that capture graph processing semantics. These parameter changes allow the compiler to generate more efficient object code while maintaining the ease of writing high-level code, thus improving productivity without sacrificing ease of operation

Inventive Principle:

Principle #35Parameter changes

2Productivity

If domain-specific languages are used for graph algorithms, then productivity is improved, but device complexity increases due to custom compilers and syntax definitions

Engineering Contradiction:

ImproveproductivityVSAvoiddevice complexity

Core Design Contradiction:

ProductivityVSDevice complexity

Solution Approach 1:

The patent makes the conventional programming language compiler multi-functional by enabling it to handle both general-purpose code and graph analysis algorithms through the graph analysis library. The library acts as a universal interface that translates domain-specific graph constructs into standard intermediate representation, allowing the existing compiler to perform graph optimization without requiring a separate custom compiler, thus improving productivity while limiting complexity increase

Inventive Principle:

Principle #6Universality (Multi-functionality)

Solution Approach 2:

The patent implements a nested structure where the graph analysis library (with its domain-specific constructs) is embedded within the conventional programming language ecosystem. The library's intermediate representation is nested within the standard compilation pipeline, allowing graph-specific optimizations to be applied through the existing compiler infrastructure rather than requiring a completely separate language system, thereby improving productivity while containing device complexity

Inventive Principle:

Principle #7Nested doll (Nesting)

3Ease of manufacture

If internal DSLs are used based on host language, then ease of manufacture is improved, but productivity deteriorates due to host language optimization constraints

Engineering Contradiction:

Improveease of manufactureVSAvoidproductivity

Core Design Contradiction:

Ease of manufactureVSProductivity

Solution Approach 1:

The patent applies preliminary action by transforming host language code into an optimized intermediate representation before compilation. The graph analysis library pre-processes the code, inserting graph-specific optimization hints and restructuring operations early in the compilation pipeline, allowing the compiler to generate more efficient object code without requiring changes to the host language syntax or compilation rules, thus improving productivity while maintaining ease of manufacture

Inventive Principle:

Principle #10Preliminary action

Data Source

PatentUS11379200B2Method for applying graph-specific compiler optimizations to graph analysis programs

Publication Date: 2022.07.05 ORACLE INT CORP

AI summary

Techniques are described for compiling source code to generate graph-optimized intermediate representation instructions of the source code that implement techniques for optimizing algorithms for graph analysis. A compiler, executing on a computing device, receives source code instructions for a program to be compiled. The compiler identifies a target expression, within the source code instructions, that invokes a particular method call on a particular object type. The target expression contains a target block of code to be translated into an intermediate representation using graph-optimized compilation techniques. The compiler generates a block of graph-specific intermediate representation instructions to replace the target expression. The compiler compiles the source code instructions to generate intermediate representation instructions, where the intermediate representation instructions include the block of graph-specific intermediate representation instructions in place of the target expression.