AMDGPU

Lin Han, Youzhi Ren, Hongsheng Wang, Y. Chai, Dan Zhang

Thread parallelism and single-thread’ performance are two important factors affecting the performance of kernel functions, and they are both closely related to register allocation. According to change the thread parallelism to optimize GPU register resource allocation can effectively improve the performance of heterogeneous programs. We obtain the required number of vector registers by counting the number of virtual registers during the compilation of kernel functions, and then combine them with the number of wavefronts used to launch kernel functions for overall performance analysis, proposing a RAW compilation method for collaborative optimization of register allocation and thread management for AMDGPU, which is implemented in the LLVM compiler. It is verified that the method has a speedup ratio of about 1.12x for the Rodinia test set and about 1.4x for the quda application.

V. Miletić, Szilárd Páll, F. Gräter

Luan Arcanjo, David Tadokoro, Marcelo Spessoto, Rafael Passos, Paulo Meirelles

The Don’t Repeat Yourself (DRY) principle is central to software maintainability, but empirical studies challenge its rigid use, describing beneficial cases of duplication. However, these rely on retrospective analyses, leaving a gap in understanding real-time decision-making and socio-technical dynamics. This paper presents an ethnographic study on how the Linux kernel community manages duplication debt via deduplication contributions. We conducted a multimethod ethnographic study by submitting patches to the AMDGPU and IIO subsystems. Our analysis of the patch reviews identified two tolerated duplications, driver-forking (T1) and readability prioritization (T2), that partially contradict the literature and warrant further investigation. Furthermore, these analyses identify two new Linux-specific factors that affect deduplication acceptance: integration overhead (T3) and performance impact (T4). This work offers a fresh discussion, grounded in new empirical observations and perspectives, of the dogmatic adherence to DRY.

Jianan Li, Lin Han, Shaoliang Peng, Yingying Li, Wei Gao

Heterogeneous programming is a critical approach to unleashing the parallel computing potential of GPUs, playing a vital role in fields requiring massive computational resources, such as scientific computing, artificial intelligence, and computer graphics. While OpenMP simplifies parallel programming and offers greater flexibility and portability compared to CUDA and Triton, it still faces challenges in fully leveraging hardware resources for efficient task execution. We propose UniOMP, an OpenMP-based optimization framework designed to enhance kernel launch efficiency and deeply optimize parallel tasks across diverse computational patterns. By integrating machine learning algorithms to select optimal parameters and orchestrate optimization passes, UniOMP seamlessly combines traditional compilation with ML-driven strategies, achieving holistic coordination of fine-grained and global optimizations. Experimental results demonstrate that UniOMP achieves speedups of 1.74x on AMDGPU and 1.34x on NVIDIA platforms for PolyBench, and 1.33x (AMDGPU) and 1.24x (NVIDIA) for SPEC ACCEL. Additionally, it reduces average register usage by 25 %, maximizing the efficient utilization of GPU hardware resources.

John L. Chesterfield

The remote procedure call (RPC) is a simple interface for executing code on a different machine. Almost none of the well known problems inherent to RPC apply on a shared memory system. Further, a shared memory system is sufficient to implement a RPC library, so that said simple interface can be more widely available. This paper includes a minimal implementation of the proposed algorithm, with a real world implementation tested on x86-64, AMDGPU and NVPTX architectures. This can bring host capabilities to the GPU or offload code without using kernel launch APIs. The client and server both compile and run on each architecture.