Rust GPU Offload: Safe, Portable, and Fast
GPU Offload in Rust: Portable, Safe, and Fast
A new framework built into rustc and LLVM enables zero-overhead, multi-vendor GPU programming in Rust without sacrificing memory safety. By leveraging Rust's ownership and strict aliasing, it manages data transfers through LLVM's offload infrastructure, overcoming cross-vendor ABI mismatches with a two-pass compilation pipeline. Benchmarks on RAJAPerf show competitive kernel performance against hand-optimized CUDA and HIP C++ baselines.
High-performance GPU programming has traditionally forced a compromise between execution efficiency and memory safety.
- whateverboat
> This module is under active development. Once upstream, it should allow Rust developers to run Rust code on GPUs. We aim to develop a rusty GPU programming interface, which is safe, convenient and sufficiently fast by default. This includes automatic data movement to and from the GPU, in a efficient way. We will (later) also offer more advanced, possibly unsafe, interfaces which allow a higher degree of control.
I really appreciate the work and the effort that went into this. However, such an approach has previously not really worked for C++ with LLVM offload. Why would it work for Rust?
- YuechenLi
So... why go through LLVM at all instead of having the MIR target PTX/HIP C directly then?
If they really wanted a vendor neutral solution for Rust GPU, that already exists: you write the CPU side code, including buffering, allocation, concurrency, etc through Vulkan binding and consume the compute kernel in SPIR-V from HLSL/GLSL/WGSL etc. As it stands, the way they use Rust here feels more like using it like TypeScript types/interfaces than anything else.
Again, the size of most operations that should be done on the GPU is known ahead of time before compilation, so it's very much possible to statically allocate memory at compile time instead of going through all this trouble to write what's essentially a Rust shaped DSL for GPU compute.
- bicepjai
I write all my code in Rust because I am a Rustacean. In many of my custom LLM inference engine projects, the biggest fight has always been bindings. I don’t want to maintain and write bindings; also, if I use an existing project that provides bindings, then I have to wait for the owner to update or fork it and then maintain it on top. It has been a big headache. Running Rust core on GPU sounds like something I will try from day one. Kudos to the team and will watch it closely.
- Thomashuet
That's promising but did they publish any code? I can't find anything in the abstract.
- boywitharupee
is this mainly about making host binaries self-contained for heterogenous workloads?
also, seems like this is mostly targeted towards HPC audience?