LLM-driven Translation of GPU Code Across Parallel Execution Models

Abstract

Aufgrund der Dominanz von NVIDIA im Bereich der Grafikprozessoren (GPUs) hat sich deren proprietäres Framework CUDA als Standard für Allzweck-Berechnung auf Grafikprozessoreinheiten (GPGPU) etabliert. GPUs bieten erhebliche Leistungsverbesserungen für hochgradig parallele Anwendungen, wie beispielsweise wissenschaftliche Software. Jedoch mangelt es CUDA an Leistungsportabilität, da die Anwendungen nur auf NVIDIA GPUs ausgeführt werden können. Moderne Supercomputer nutzen zunehmend alternative Hardwareplattformen. SYCL ist ein offenes, auf C++ basierendes Programmiermodell, das eine portable Alternative für die Ausführung auf CPUs, GPUs und anderen Hardware-Beschleunigern bietet. Zwar gibt es bereits regelbasierte Transpiler, die laut Herstellerangaben etwa 90–95 % des CUDA-Codes automatisch nach SYCL übersetzen können, jedoch müssen die restlichen Abschnitte manuell portiert werden. Aktuelle Fortschritte im Bereich der Large Language Models (LLMs) eröffnen neue Möglichkeiten für die automatisierte Codeübersetzung. Das Ziel dieser Arbeit ist die Entwicklung einer ausführungsgesteuerten iterativen Übersetzungs-Pipeline auf Basis von LLMs, die parallele Programme automatisch von CUDA nach SYCL übersetzen kann. Der Ansatz kombiniert die iterative Übersetzung mit der automatisierten Ausführung von Quell- und Zielprogrammen in einer realen High-Performance-Computing (HPC)-Umgebung. In diesem Ansatz nutzen wir die Informationen aus der Analyse und Ausführung des Quellprogramms, um die Übersetzung zu verbessern. Durch die wiederholte Ausführung der übersetzten Programme wird das Feedback direkt in nachfolgende Iterationen einbezogen, was iterativ zur funktionalen Korrektheit führt. Um unseren Übersetzungsansatz zu evaluieren, haben wir 30 Programme aus dem HeCBench-Datensatz von CUDA nach SYCL übersetzt. Die Ergebnisse zeigen, dass fortschrittliche LLMs bis zu 29 von 30 Beispielen innerhalb der ersten beiden Iterationen funktional korrekt übersetzen können und damit beinahe die Leistung regelbasierter Transpiler erreichen. In den meisten Fällen ist die Laufzeit der übersetzten Programme jedoch langsamer als die von Referenzimplementierungen.

Due to the dominance of NVIDIA in the field of graphics processing units (GPUs), their proprietary framework CUDA is the established standard for general-purpose computing on graphics processing units (GPGPU). GPUs enable significant performance improvements for massively parallel applications, such as scientific software. However, CUDA lacks performance portability because applications can only be executed on NVIDIA GPUs. Modern supercomputers are increasingly utilizing alternative hardware platforms. SYCL is an open C++-based programming model that offers a portable alternative for execution on CPUs, GPUs, and other accelerators. While rule-based transpilers already exist and, according to the manufacturers, can automatically translate around 90–95% of CUDA code to SYCL, the remaining parts require manual porting. However, recent advances in the field of Large Language Models (LLMs) open up new possibilities for automated code translation. The goal of this work is to develop an execution-guided iterative translation pipeline based on LLMs that can automatically translate parallel programs from CUDA to SYCL. The approach combines iterative translation with the automated execution of source and target programs in a real high-performance computing (HPC) environment. This involves analyzing and executing the source program and using the information gained to improve the translation. By repeatedly executing the translated programs, feedback is directly integrated into subsequent iterations, enabling a progressive approach toward functional correctness. In order to evaluate our translation approach, 30 programs from the HeCBench dataset were translated from CUDA to SYCL. The results demonstrate that advanced LLMs can translate up to 29 out of 30 examples functionally correctly within the first two iterations, thereby nearly matching the performance of rule-based transpilers. However, in most cases, the runtime of the translated programs remains slower than that of reference implementations.