[Paper Review] A Modeling Approach based on UML/MARTE for GPU Architecture

Antônio Wendell De Oliveira Rodrigues, Frédéric Guyomarc'h+1 more|arXiv (Cornell University)|May 23, 2011

Model-Driven Software Engineering Techniques5 references3 citations

TL;DR

This paper proposes a UML/MARTE-based metamodel extension and GPU architecture model to enable model-driven code generation for GPGPU applications in embedded systems. By specifying task and data allocation across GPU memory hierarchies, the approach supports automatic OpenCL code generation, achieving up to 8.34x speedup over sequential MATLAB implementations on multi-GPU setups.

ABSTRACT

Nowadays, the High Performance Computing is part of the context of embedded systems. Graphics Processing Units (GPUs) are more and more used in acceleration of the most part of algorithms and applications. Over the past years, not many efforts have been done to describe abstractions of applications in relation to their target architectures. Thus, when developers need to associate applications and GPUs, for example, they find difficulty and prefer using API for these architectures. This paper presents a metamodel extension for MARTE profile and a model for GPU architectures. The main goal is to specify the task and data allocation in the memory hierarchy of these architectures. The results show that this approach will help to generate code for GPUs based on model transformations using Model Driven Engineering (MDE).

Motivation & Objective

• To address the lack of abstractions for mapping applications to GPU architectures in embedded systems.
• To improve productivity and portability in GPU-accelerated embedded systems by enabling model-driven engineering (MDE).
• To support automatic code generation for GPU kernels using model transformations.
• To model GPU-specific characteristics such as memory hierarchy and task scheduling.
• To validate the approach through a case study on the Conjugate Gradient solver using OpenCL.

Proposed method

• Extending the MARTE profile with a custom metamodel to represent GPU-specific architectural features.
• Defining a platform-specific model (PSM) for GPU architectures, including processors, memory hierarchy, and data allocation.
• Using model transformations to generate OpenCL kernels from UML/MARTE models.
• Applying task partitioning and data distribution across multiple GPU devices based on model-driven allocation strategies.
• Leveraging the Gaspard2 environment for RTES and ISP application development to integrate the model and transformations.
• Validating the approach via a case study on the Conjugate Gradient algorithm with sequential and multi-GPU OpenCL implementations.

Experimental results

Research questions

• RQ1 How can GPU architectures be effectively modeled using UML and MARTE for embedded systems?
• RQ2 What metamodel extensions are required to represent GPU-specific features such as memory hierarchy and task scheduling?
• RQ3 Can model-driven transformations generate efficient GPU code for scientific kernels?
• RQ4 How does automatic code generation compare to hand-optimized implementations in terms of performance and scalability?
• RQ5 What is the impact of multi-GPU deployment on performance and data transfer overhead?

Key findings

• The proposed metamodel and model successfully represent GPU architecture details, including memory hierarchy and task allocation.
• Automatic code generation via model transformations produced OpenCL kernels that achieved 4.81x speedup over sequential MATLAB code on a single GPU.
• With two GPUs, the implementation achieved 6.87x speedup, and with four GPUs, it reached 8.34x speedup on the same conjugate gradient problem.
• Performance gains were limited by data transfer overhead between CPU and GPUs, preventing linear scaling.
• The approach enables scalable, portable, and automatic code generation for GPU-accelerated embedded applications.
• The model-based approach supports efficient data alignment and bandwidth utilization, critical for GPU performance.