[Paper Review] Programming Massively Parallel Architectures using MARTE: a Case Study

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

Parallel Computing and Optimization Techniques4 references3 citations

TL;DR

This paper proposes a model-driven engineering approach using UML and the MARTE profile to automatically generate optimized OpenCL code for GPU-accelerated signal processing applications. By applying performance-aware transformations to model-to-text code generation, the framework achieves up to 10x speedup over sequential CPU code and 25% improvement over non-optimized GPU code, demonstrating the viability of MDE for high-performance computing on massively parallel architectures.

ABSTRACT

Nowadays, several industrial applications are being ported to parallel architectures. These applications take advantage of the potential parallelism provided by multiple core processors. Many-core processors, especially the GPUs(Graphics Processing Unit), have led the race of floating-point performance since 2003. While the performance improvement of general- purpose microprocessors has slowed significantly, the GPUs have continued to improve relentlessly. As of 2009, the ratio between many-core GPUs and multicore CPUs for peak floating-point calculation throughput is about 10 times. However, as parallel programming requires a non-trivial distribution of tasks and data, developers find it hard to implement their applications effectively. Aiming to improve the use of many-core processors, this work presents an case-study using UML and MARTE profile to specify and generate OpenCL code for intensive signal processing applications. Benchmark results show us the viability of the use of MDE approaches to generate GPU applications.

Motivation & Objective

• To address the difficulty of effective parallel programming on many-core GPUs, especially for non-expert developers.
• To explore the feasibility of using model-driven engineering (MDE) with UML and MARTE to generate high-performance GPU code.
• To automatically optimize memory transfers between host and device, a major performance bottleneck in GPU computing.
• To evaluate whether automatically generated OpenCL code can achieve performance close to manually hand-optimized implementations.

Proposed method

• The approach uses a UML-based application model enhanced with the MARTE profile to specify software components, hardware architecture, and data allocation.
• A transformation chain based on QVTO converts the high-level model into an intermediate model with performance annotations.
• Acceleo templates generate OpenCL code from the intermediate model, with optimizations applied during transformation.
• Performance-aware transformations detect and eliminate redundant host-to-device and device-to-host data transfers.
• The framework supports automatic topology generation for work-groups and work-items based on task multiplicity.
• Memory hierarchy awareness is integrated into the model to assign variables to appropriate memory regions (global, local, private, constant).

Experimental results

Research questions

• RQ1 Can MDE techniques with UML and MARTE generate OpenCL code that achieves competitive performance on GPU architectures?
• RQ2 How effective are automatic optimizations—particularly in reducing memory transfer overhead—in model-driven GPU code generation?
• RQ3 To what extent can automatically generated code match the performance of manually optimized OpenCL implementations?
• RQ4 Can the model-driven approach abstract away low-level GPU programming complexity while maintaining high performance?

Key findings

• The optimized OpenCL code generated via the MDE pipeline achieved a 10x speedup over the sequential CPU implementation.
• The framework reduced host-to-device data transfer time by approximately 30%, and device-to-host transfer time by 70% through intelligent memory transfer optimization.
• The optimized version achieved a 25% performance improvement over the non-optimized generated OpenCL code.
• The automatically generated code's structure and optimization decisions closely mirrored those of a human-optimized implementation, indicating strong expressiveness of the model-driven approach.
• Memory transfer overhead accounted for over 70% of total GPU execution time in the non-optimized version, highlighting its critical impact on performance.
• The results confirm that MDE with MARTE can effectively model and generate high-performance GPU code, even for complex signal processing workloads like H.263 downscaling.