- Naglunsad ang NVIDIA ng isang inisyatibo upang katutubong isama ang Rust sa pagbuo ng GPU kernel, na nag-aalis ng pagdepende sa ibang mga wika.
- Ang ecosystem ay nahahati sa dalawang pangunahing ruta: cuda-oxide para sa kabuuang kontrol sa pamamagitan ng SIMT at cutile-rs para sa isang pinasimpleng pamamaraan batay sa Tiles.
- Ang parehong tool ay nagdadala ng mga garantiya sa seguridad at pagmamay-ari ng Rust sa hardware, na tumutukoy sa mga error sa memorya at pagpapatakbo ng data sa oras ng pag-compile.
Ang imprastrakturang sumusuporta sa modernong artificial intelligence ay umuunlad sa napakabilis na bilis, at upang makasabay, nagpasya ang NVIDIA na mamuhunan nang malaki sa native programming sa Rust . Bagama't ang CUDA C++ at CUDA Python ay mga matatag at matatag na tool para sa sektor ng enterprise, ang industriya ay lumilipat patungo sa Rust dahil sa kakayahan nitong alisin ang mga kritikal na error sa memorya bago pa man tumakbo ang code, nang hindi isinasakripisyo ang raw performance.
Hanggang kamakailan lamang, ginamit ang Rust sa mga panlabas na layer tulad ng mga inference engine o driver, ngunit ang mga GPU kernel ay nanatiling "blind spot" kung saan kinailangang gumamit ng ibang mga wika ang mga developer. Sa pagdating ng CUDA Rust, hinahangad ng NVIDIA na isara ang teknolohikal na puwang na ito , na nagpapahintulot sa mga developer na direktang magsulat ng device logic sa Rust at i-compile ito sa PTX, sa gayon ay naiiwasan ang masalimuot na wrapper na nagpapakomplikado sa workflow.
Ang dalawang landas para sa pagsakop sa GPU
Upang umangkop sa magkakaibang pangangailangan ng mga programmer, gumamit ang NVIDIA ng dalawang magkaibang pamamaraan na ginagaya ang kagalingan ng CUDA. Sa isang banda, nariyan ang modelo ng SIMT, at sa kabilang banda, ang modelo ng Tile. Ang pangkalahatang rekomendasyon ay magsimula sa pamamaraan ng Tile , dahil ino-optimize ng compiler kung paano inima-map ang data sa bawat arkitektura, na pumipigil sa programmer na gumawa ng manu-mano at nakakapagod na mga desisyon tungkol sa mga partikular na hardware.
Ganap na kontrol gamit ang cuda-oxide (SIMT)
Para sa mga ayaw magbitiw ng kontrol at nangangailangan ng tumpak na katumpakan sa mga thread at shared memory, nariyan ang cuda-oxide . Ang tool na ito ay gumaganap bilang isang custom code generation backend para sa rustc. Ang proseso ay kumplikado: ang mga function na minarkahan bilang mga kernel ay dumadaan sa MIR ng Rust, dumadaan sa Pliron framework at LLVM IR, at sa wakas ay kino-convert sa PTX code na executable sa GPU.
Kung tungkol sa mga teknikal na kinakailangan, hindi ito ganoon kadali; kailangan mo ng Linux, isang GPU na may kakayahan sa pag-compute na 8.0 o mas mataas, at isang set ng toolchain panggabiIsa sa mga hiyas ng sistemang ito ay ang paggamit ng DisjointSliceisang uri ng datos na nagsisiguro na ang bawat thread ay mayroong eksklusibong access sa iyong elementopinipigilan ang Rust compiler na harangan ang code para sa pagtatangkang gumawa ng mga hindi tugmang mutable borrows.
Kasimplehan at seguridad gamit ang cutile-rs (Tile)
Kung mas gusto mo ang katulad ng paggamit ng NumPy o PyTorch, ang cutile-rs ang pinakamahusay mong opsyon. Dito, hindi ka magpo-program ng mga indibidwal na thread, kundi nagpapatakbo sa mga "tile" o bloke ng data. Ang compiler ang magpapasya kung gaano karaming aktwal na thread ang kailangan upang ilipat ang block na iyon, na ginagawang mas maayos ang pag-develop at hindi gaanong madaling kapitan ng mga error sa pag-index.
Hindi tulad ng kapatid nitong SIMT, mas madaling ma-access ang proyektong ito dahil tumatakbo ito sa stable na Rust at hindi nangangailangan ng manu-manong pag-install ng LLVM. Gumagamit ito ng macro na nagko-compile ng kernel gamit ang CUDA Tile IRs sa oras mismo ng unang paglulunsad (JIT). Isang napakagandang tampok ang lazy operation management nito : nagrerehistro ang programa ng command string at isinasagawa lamang ang buong set kapag ginamit ang synchronization method, na nag-o-optimize ng komunikasyon sa pagitan ng CPU at GPU.
Ang mahika ng compiler: Paalam sa Data Races
Ang tunay na nagpapabago sa CUDA Rust ay kung paano nito pinangangasiwaan ang memorya. Sa tradisyonal na GPU programming, ang mga aliasing error (kapag ang dalawang thread ay nagsusulat sa parehong lokasyon) ay mga bangungot na lumilitaw lamang sa produksyon. Nilulutas ito ng Rust sa pamamagitan ng pagpapatupad ng mga patakaran sa pagmamay-ari nito sa hangganan ng paglabas ng kernel.
- Sa modelo ng SIMT, kung susubukan mong gamitin ang output buffer bilang input, magtatapon ang compiler ng error. nababagong error sa pautang (E0502).
- Sa modelong Tile, ang katangiang tensor ay inililipat, at ang anumang pagtatangkang gumamit ng inilipat na halaga ay magdudulot ng E0382 error.
Nangangahulugan ito na ang software ay seguro para sa konstruksyonSamantalang sa SIMT, ang shared memory ay nangangailangan pa rin ng mga bloke unsafeTinatanggal ng modelong Tile ang pangangailangang manu-manong pamahalaan ang mga index ng thread, inaalis ang posibilidad na makagawa ng mga klasikong pagkakamali mula sa equation.
Kasalukuyang kalagayan at kinabukasan ng proyekto
Mahalagang panatilihing makatotohanan ang mga bagay-bagay: parehong proyekto ay nasa yugto ng eksperimento . Ang cuda-oxide ay nasa maagang alpha, habang ang cutile-rs ay mas advanced at ginagamit na sa mga proyektong tulad ng Grout inference engine ng HuggingFace. Nilinaw ng NVIDIA na maaaring magbago ang mga API at marami pa ring dapat gawin bago maging angkop ang mga tool na ito para sa malawakang kapaligiran ng produksyon.
Bagama't bago, ang ecosystem na ito ay nabubuhay at nakikipagtulungan sa mga naunang pagsisikap tulad ng rust-gpu at CubeCL. Ang layunin ay gawing primera klaseng wika ang Rust para sa pinabilis na computing, na nagpapahintulot sa GPU code na maging kasingtatag at kasing-maintainable ng system code. Ang kakayahang mag-interoperate sa pagitan ng Tile at SIMT kernels sa iisang stream ay tinitiyak na ang mga developer ay hindi nakakulong sa iisang metodolohiya.
Ang pangako ng NVIDIA na isama ang Rust sa core ng CUDA ay kumakatawan sa isang kinakailangang ebolusyon para sa imprastraktura ng AI, na naglilipat ng seguridad mula sa runtime patungo sa oras ng pag-compile. Sa pamamagitan ng pag-aalok ng mga pathway para sa parehong granular thread control at pinasimpleng tensor manipulation, ginagawang demokrasya nito ang access sa matinding performance ng mga GPU sa pamamagitan ng pag-aalis ng karaniwang kahinaan ng memorya sa C++, kaya naman ipinakikilala nito ang isang panahon kung saan ang kahusayan at kabuuang seguridad ay magkakasamang umiiral sa loob ng iisang binary.
Mga madalas itanong
Ano ang pagkakaiba ng cuda-oxide at cutile-rs?
Nakatuon ang Cuda-oxide sa modelong SIMT para sa mga nangangailangan ng ganap na kontrol sa mga thread at memorya, habang ginagamit naman ng cutile-rs ang modelong Tile para mas madali at ligtas na mapatakbo ang mga tensioner.
Posible bang gamitin ang CUDA Rust sa mga proyektong pangproduksyon ngayon?
Hindi ito inirerekomenda para sa produksyon dahil ang parehong proyekto ay eksperimental pa lamang, nasa mga unang yugto pa lamang, at ang kanilang mga API ay maaaring sumailalim sa mga makabuluhang pagbabago.
Anong mga kinakailangan sa hardware ang kailangan ko para patakbuhin ang mga kernel na ito?
Kinakailangan ang isang NVIDIA GPU na may kakayahang mag-compute ng 8.0 o mas mataas pa at ang paggamit ng mga operating system ng Linux.
Paano pinipigilan ng Rust ang mga error sa memorya ng GPU?
Ginagamit nito ang sistema ng pagmamay-ari at paghiram upang matukoy ang mga conflict sa aliasing at pagpapatakbo ng data habang nagko-compile, na pumipigil sa hindi ligtas na code na tumakbo.
Kailangan ko bang gumamit ng panggabing bersyon ng Rust para sa lahat ng bagay?
Tanging ang cuda-oxide path ang nangangailangan ng nightly toolchain, habang ang cutile-rs ay tugma sa mga stable na bersyon ng Rust 1.89 o mas bago.
Maaari ko bang paghaluin ang mga kernel ng iba't ibang modelo sa iisang aplikasyon?
Oo, ang Tile at SIMT kernels ay interoperable at maaaring tumakbo sa iisang stream gamit ang mga shared device buffers.
Ano ang PTX code sa konteksto ng CUDA Rust?
Ito ang intermediate assembly language kung saan kino-compile ang mga Rust kernel upang mapatakbo ito nang mahusay ng GPU driver.




