Source-to-Source Compiler for Graph Processing on Many-Core Platforms
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current technologies lack efficient source-to-source compilers to automatically compile and parallelize graph applications for many-core processors, which are necessary for leveraging the higher performance of many-core devices and are error-prone due to specialized programming requirements.
Innovation Solution
A source-to-source compiler transforms graph applications into parallel code variants optimized for different many-core processors, using a graph programming API, and a runtime library dynamically selects and tunes the code variants based on application characteristics and hardware platforms, enabling efficient parallel execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If manual parallelization is used for graph applications on many-core processors, then performance can be optimized, but development time increases and error-proneness increases
Solution Approach 1:
The compiler performs preliminary analysis and transformation of graph applications into parallel code variants before execution. The system pre-processes the application code, generates multiple parallel variants with different optimization strategies, and prepares them for runtime selection, eliminating the need for manual parallelization effort while ensuring optimized performance.
Solution Approach 2:
A runtime component acts as an intermediary between the application and the many-core processor. This intermediary automatically selects and tunes the appropriate parallel code variant based on graph characteristics and hardware platform, bridging the gap between high-level graph applications and low-level parallel execution without requiring manual intervention.
2Productivity
If specialized programming skills are used for many-core processors, then performance can be optimized, but ease of operation decreases
Solution Approach 1:
The system provides self-service by automatically generating, selecting, and tuning parallel code variants without requiring programmer intervention. The compiler and runtime system handle all aspects of parallelization autonomously, allowing developers to write standard graph applications without learning specialized many-core programming techniques while still achieving optimized performance.
Solution Approach 2:
The compiler generates multiple universal parallel code variants that can adapt to different many-core platforms and graph characteristics. This universal approach allows a single application to be executed efficiently across various hardware platforms without requiring platform-specific programming, maintaining ease of operation while achieving high performance.
3Ease of operation
If automatic compilation is implemented for many-core platforms, then ease of operation improves, but device complexity increases
Solution Approach 1:
The compilation system is segmented into distinct modular components: a source-to-source compiler that generates parallel code variants, and a runtime component that selects and tunes them. This segmentation allows each component to specialize in specific tasks, managing overall system complexity while providing automatic compilation capabilities that improve ease of operation for developers.
Data Source
AI summary
Methods are provided for source-to-source transformations for graph processing on many-core platforms. A method includes receiving a graph application including one graph, expressed by a graph application programming interface configured for defining and manipulating graphs. The method further includes transforming, by a source-to-source compiler, the graph application into a plurality of parallel code variants. Each of the plurality of parallel code variants is specifically configured for parallel execution by a target one of a plurality of different many-core processors. The method also includes selecting and tuning, by a runtime component, a particular one of the parallel code variants for the parallel execution responsive to graph application characteristics, graph data, and an underlying code execution platform of the plurality of different many-core processors.