NVIDIA משיקה CUDA Rust עם שני פרויקטים פתוחים לכתיבת קרנלים בטוחים בזמן הידור

הסיפור בקצרה

NVIDIA הכריזה על CUDA Rust, מהלך שהופך את Rust לשפה ראשונה לכתיבת קרנלים של GPU. עד עכשיו קוד Rust יכול היה רק לשגר קרנלים, אבל גוף הקרנל עצמו נכתב בשפה אחרת. שני פרויקטי קוד פתוח של NVlabs סוגרים את הפער: cuda-oxide למודל SIMT ו-cutile-rs למודל Tile החדש. שניהם מקמפלים קרנלי Rust באופן נייטיבי ומנצלים את כללי הבעלות של השפה כדי לפסול באגי אליאסינג (aliasing) כבר בזמן הקימפול.

למה דווקא עכשיו

שכבת המערכות של AI, ממנועי אינפרנס דרך דרייברים ועד ראנטיים של סוכנים, נכתבת יותר ויותר ב-Rust. הדרייבר Nova Linux של NVIDIA כבר ב-Rust, ל-Dynamo יש ליבה ב-Rust, ול-NVTX יש בנדינגס לשפה. הקרנל של GPU נשאר החריג היחיד. שני המסלולים משקפים את שני מודלי התכנות ש-CUDA כבר מציעה: SIMT, המודל הקלאסי שבו מתארים מה תרד אחד עושה ומשגרים אלפים כאלה, ו-Tile, המודל החדש יותר שבו מתארים מה אריח נתונים אחד עושה והמקמפל של Tile IR מטפל במיפוי תרדים ובפריסת זיכרון. NVIDIA ממליצה להתחיל עם Tile, ולשמור את SIMT למקרים שדורשים שליטה מפורשת בתרדים ובזיכרון. תאימות בין-שפתית מתוכננת מבטיחה שבחירה ב-Rust לא תנעל מפתחים מחוץ ל-C++ או Python.

המסלול הראשון: cuda-oxide

cuda-oxide הוא בקאנד קודגן מותאם של rustc. הוא מנתב פונקציות המסומנות ב-#[kernel] דרך MIR של Rust, דרך מסגרת Pliron הקהילתית, דרך LLVM IR ועד PTX (האסמבלי של NVIDIA), ואת שאר הקוד מעביר לבקאנד הסטנדרטי. NVIDIA כתבה את הדיאלקטים של GPU מעל Pliron. הדרישות: לינוקס, GPU עם יכולת חישוב 8.0 ומעלה, CUDA 12.x ומעלה, clang עם libclang, ו-toolchain לילי מקובע (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 שנוצרת אוטומטית מאמתת את תצורת השיגור נגדו לפני ההפעלה הבטוחה.

המסלול השני: cutile-rs

cutile-rs עובד רמה אחת מעל. כל בלוק אריח מריץ את גוף הקרנל פעם אחת כתרד לוגי יחיד על תת-טנזור, והמקמפל מחליט כמה תרדים אמיתיים של GPU יגבו אותו. המאקרו #[cutile::module] מטמיע את ה-AST של הקרנל בבינארי המארח ומקמפל JIT דרך CUDA Tile IR בשיגור הראשון. הדרישות קלות יותר: יכולת חישוב 8.0 ומעלה, CUDA 13.3, Rust יציב 1.89 ומעלה, ולינוקס, בלי נייטלי ובלי LLVM מותאם. ההגדרה היא cargo new ואז cargo add cutile. הקריאה partition([128]) בצד המארח עושה שלוש עבודות: נותנת לכל אריח בעלות בלעדית על הצ'אנק שלו של 128 אלמנטים, קובעת את הגריד על 1,024 / 128 = 8 אריחים, ומספקת את רוחב האריח הקבוע B. טנזורי קלט משתמשים ב-1 כממד דינמי שנפתר בשיגור. הלאנצ'ר שנוצר לוקח בעלות על כל הטנזורים ומחזיר אותם כשה-GPU מסיים. שום דבר לא רץ עד .sync_on(&stream); כל מה שלפניו הוא תיאור עצל שנרשם בשרשרת אחת.

מה המקמפל תופס

העברת מאגר הפלט של קרנל SIMT כאחד הקלטים שלו נכשלת עם error[E0502]: אי אפשר לשאול את c_dev כמשתנה כי הוא גם מושאל כבלתי-משתנה. אותו אליאסינג בצד Tile נכשל עם error[E0382]: שימוש בבעלות שהועברה. בשני המקרים הבאג נתפס בקימפול, לא בזמן ריצה על ה-GPU.

סטטוס: אלפא, לא פרודקשן

שני הפרויקטים בשלב אלפא ולא מאושרים לפרודקשן. cutile-rs כבר מפורסם ב-crates.io, רץ על Rust יציב 1.89 ומעלה, ומשמש במנוע האינפרנס Grout של Hugging Face וב-mistral.rs. cuda-oxide עדיין אלפא מוקדמת ודורש שרשרת כלים לילית מקובעת.