NVIDIA обявява CUDA Rust с cuda-oxide (SIMT) и cutile-rs (Tile) за безопасни при компилация GPU ядра

NVIDIA обяви CUDA Rust — инициатива, целяща да превърне Rust в пълноправен език за писане на GPU ядра. Rust кодът вече можеше да стартира CUDA ядра, но самото тяло на ядрото обикновено трябваше да бъде написано на друго място. CUDA Rust запълва тази празнина с два проекта с отворен код на NVlabs: cuda-oxide за модела SIMT и cutile-rs за по-новия модел Tile. И двата компилират Rust ядра нативно и използват правилата за притежание на Rust, за да отхвърлят грешките, свързани с псевдонимирането, още по време на компилация.

Може ли да се внедри? Частично. cutile-rs е публикуван в crates.io, работи със стабилна версия на Rust 1.89 или по-нова и вече се използва в Grout — енджина за инференс на Hugging Face — както и в mistral.rs. cuda-oxide е в ранен алфа етап. И двата проекта са в алфа фаза и не са потвърдени за продукционна употреба.

Защо Rust за GPU ядрото

Системният слой на AI — от енджини за инференс до драйвери и среди за изпълнение на агенти — все по-често се пише на Rust. Linux драйверът Nova на NVIDIA е написан на Rust, NVIDIA Dynamo има ядро на Rust, а NVTX разполага с Rust свързвания. GPU ядрото беше изключението.

Двата подхода отразяват двата програмни модела, които CUDA вече предлага. SIMT е моделът, използван в CUDA C++ и numba-cuda: описвате какво прави една нишка и стартирате хиляди такива нишки. Tile е по-новият модел, наличен също в C++ и Python: описвате какво прави един блок от данни, а компилаторът Tile IR обработва съпоставянето на нишките и разпределението на паметта. NVIDIA препоръчва първо Tile, а SIMT — за случаи, изискващи явен контрол върху нишките и паметта. Планираната междусистемна езикова съвместимост означава, че изборът на Rust няма да изключи разработчиците от C++ или Python.

Подходът SIMT: cuda-oxide

cuda-oxide е персонализиран бекенд за генериране на код на rustc. Той прекарва функциите с атрибут #[kernel] през Rust MIR, общностната IR рамка Pliron и LLVM IR до PTX, след което предава всичко останало на стандартния бекенд. NVIDIA е написала GPU диалектите върху Pliron.

Изисквания: Linux, GPU с изчислителна способност 8.0 или по-нова, CUDA 12.x или по-нова, clang с libclang и фиксирана nightly инструментална верига (nightly-2026-04-03). cargo oxide doctor проверява конфигурацията, а cargo oxide new създава шаблон за програма за събиране на вектори, като хост кодът и кодът за устройството са в един файл.

Аргументът за безопасност се основава на сигнатурата на ядрото. Входовете a и b са обикновени споделени срезове. Изходът c е DisjointSlice<f32> — тип, който предоставя на всяка нишка изключителен достъп до нейния собствен елемент. Обикновеният &mut [f32] би изисквал всяка нишка да притежава един и същ променлив заем, което Rust не допуска. c.get_mut(idx) връща Option, така че достъпът извън границите се превръща в обработван клон. Атрибутът #[launch_contract] декларира размерността на блока, а генерираният метод prepare_vecadd проверява конфигурацията за стартиране спрямо нея, преди да бъде извършено безопасното стартиране.

Подходът Tile: cutile-rs

cutile-rs работи на едно ниво по-високо. Всеки Tile блок изпълнява тялото на ядрото веднъж като една логическа нишка върху един подтензор, а компилаторът решава колко реални GPU нишки да го поддържат. Макросът #[cutile::module] вгражда AST на ядрото в хост двоичния файл и го компилира чрез CUDA Tile IR с JIT при първото стартиране на ядрото.

Изискванията са по-леки: изчислителна способност 8.0 или по-нова, CUDA 13.3, стабилна версия на Rust 1.89 или по-нова и Linux, без nightly и без персонализиран LLVM. Настройката се състои от cargo new, последвано от cargo add cutile.

Извикването .partition([128]) от страна на хоста изпълнява 3 задачи. То предоставя на всеки Tile изключително притежание върху неговия фрагмент от 128 елемента, фиксира мрежата на 1 024 / 128 = 8 Tile блока и задава константната ширина на Tile B. Входните тензори използват -1 като динамично измерение, което се определя при стартиране. Генерираният стартер поема притежанието на всички тензори и ги връща, когато GPU приключи. Нищо не се изпълнява преди .sync_on(&stream); всичко преди него е мързеливо описание, записано в една верига.

Какво улавя компилаторът

Подаването на изходния буфер на SIMT ядрото като един от собствените му входове води до грешка с error[E0502]: cannot borrow c_dev as mutable because it is also borrowed as immutable. Същото псевдонимиране от страна на Tile води до error[E0382]: use of moved value: z. cuda-oxide проверява всяко извикване за стартиране; притежанието в cutile-rs следва тензорите през границата на стартирането, което според NVIDIA е по-силната гаранция.

Tile не предоставя споделена памет или индексиране на нишки, които могат да бъдат използвани неправилно. SIMT запазва този контрол, но споделената памет в cuda-oxide понастоящем изисква unsafe.

Основни изводи

• CUDA Rust добавя 2 нативни подхода за GPU ядра в Rust: cuda-oxide (SIMT) и cutile-rs (Tile).
• cuda-oxide компилира Rust MIR чрез Pliron и LLVM до PTX; изисква фиксирана nightly версия.
• cutile-rs работи със стабилна версия на Rust 1.89 или по-нова и CUDA 13.3 и компилира с JIT чрез CUDA Tile IR.
• И двата подхода отхвърлят псевдонимирането на буфери по време на компилация чрез проверката на заемането и системата за притежание на Rust.
• cutile-rs вече захранва Grout и mistral.rs; нито един от двата проекта все още не е готов за продукционна употреба.

---

Вижте техническите подробности тук. Също така можете да ни последвате в Twitter и не забравяйте да се присъедините към нашия SubReddit с над 150 хил. членове за машинно обучение и да се абонирате за нашия бюлетин. Чакайте! В Telegram ли сте? Вече можете да се присъедините към нас и в Telegram.

Имате нужда от партньор за популяризиране на вашето GitHub хранилище ИЛИ страница в Hugging Face ИЛИ продуктово издание ИЛИ уебинар и т.н.? Свържете се с нас