VectorWare mapea el SIMD portátil de Rust sobre los warps de GPU de NVIDIA

Why it matters

VectorWare is moving GPU programming toward familiar systems code. Portable SIMD fills the lane-level gap, though Rust's API and VectorWare's compiler remain experimental.

VectorWare el 10 de agosto demostró la API portable SIMD de Rust ejecutándose en una GPU de NVIDIA, dando al fundador Christian Legnitto (@legneato) otra pieza del modelo de programación que quiere que los desarrolladores usen para aplicaciones nativas en GPU. En una publicación técnica, VectorWare mostró código ordinario de core::simd compilando en operaciones repartidas a lo largo de los 32 carriles de un warp de GPU.

El trabajo llena un hueco específico en la pila de VectorWare. VectorWare previamente mapeó threads de Rust sobre warps de GPU, permitiendo que warps separados se comportaran como hilos de CPU con planificación independiente. Ese enfoque dejó los carriles dentro de cada warp subutilizados a menos que los desarrolladores recurrieran a programación específica de GPU. Portable SIMD da al código Rust una forma familiar de dirigirse a esos carriles.

Legnitto ha pasado su carrera alrededor de transiciones de plataforma. VectorWare lista roles previos en Apple, Mozilla, Facebook y Robinhood, mientras que el inversor principal The General Partnership le atribuye el lanzamiento de la primera app móvil nativa de Facebook. También mantiene rust-gpu y rust-cuda, los proyectos de compilador de código abierto que sustentan el trabajo de VectorWare.

Ese trasfondo dio forma a la apuesta central de VectorWare: la programación en GPU debería convertirse en una extensión del desarrollo de software convencional en lugar de permanecer como una colección de kernels especializados, APIs e intrínsecos específicos de cada proveedor. VectorWare anunció su formación el 23 de octubre de 2025, tras levantar una ronda semilla liderada por The General Partnership. VectorWare nombró a John Lilly, Patrick Kavanagh y Nick Candito como inversionistas ángeles.

Llenando los carriles

La core::simd de Rust provee un tipo genérico Simd<T, N> para expresar operaciones sobre un número fijo de valores. En CPUs, el compilador puede bajar ese código a las instrucciones vectoriales disponibles en hardware x86-64 o Arm. Los desarrolladores pueden escribir una suma, comparación o reducción una vez en lugar de mantener implementaciones separadas para cada conjunto de instrucciones.

VectorWare trata un warp de GPU como otro objetivo vectorial. NVIDIA organiza los hilos de GPU en warps de 32 carriles. VectorWare mapea un valor Simd<i16, 32> a través de esos carriles, colocando un elemento en cada carril. Una suma entre dos valores de ese tipo puede entonces convertirse en una instrucción a lo ancho del warp.

La demostración va más allá de la aritmética elemento a elemento. El ejemplo de VectorWare calcula un pequeño producto punto estilo ReLU usando multiplicación, una máscara de comparación, una selección condicional y una reducción. El compilador mapea las reducciones a instrucciones de shuffle de warp y usa operaciones de vote y ballot de GPU para consultas de máscaras como all y any.

El encuadre de VectorWare requiere una salvedad. NVIDIA distingue SIMT del SIMD tradicional porque los hilos individuales de GPU pueden mantener su propio flujo de control. VectorWare está usando las características de ejecución compartida de un warp como objetivo para la abstracción vectorial de Rust. El mapeo es directo para muchas operaciones, mientras que el flujo de control divergente y el movimiento irregular de carriles todavía conllevan costos específicos de GPU.

El hito también completa una jerarquía de programación que VectorWare ha estado ensamblando desde enero. VectorWare primero llevó la biblioteca estándar de Rust a la GPU, seguida por async y await en febrero y std::thread el 24 de marzo. En el modelo de VectorWare, los threads de Rust distribuyen trabajo a través de warps, mientras que portable SIMD distribuye datos a través de los carriles dentro de cada warp. El código async puede coordinar operaciones concurrentes alrededor de ambos niveles.

VectorWare compite en la abstracción

Los desarrolladores de Rust ya tienen varias rutas hacia el hardware GPU. CubeCL ofrece una extensión del lenguaje Rust, compilador y runtime que puede apuntar a NVIDIA, AMD, Apple, Vulkan, WebGPU y CPUs. El experimental cuda-oxide de NVIDIA compila kernels de Rust a PTX y expone conceptos de CUDA a través de APIs en Rust.

VectorWare persigue una tesis más amplia de compatibilidad de código fuente. En lugar de pedir a los desarrolladores que escriban dentro de una extensión de lenguaje enfocada en GPU o adopten un modelo separado de kernel, VectorWare quiere que facilidades familiares de Rust como std, threads, futures y core::simd conserven su significado cuando se compilan para una GPU. Las librerías existentes escritas alrededor de esas abstracciones podrían entonces convertirse en candidatas para ejecución en GPU con menos cambios estructurales.

Esa distinción importa porque la familiaridad con el lenguaje por sí sola no hace que el desarrollo en GPU sea ordinario. Los desarrolladores aún tienen que razonar sobre movimiento de memoria, sincronización, occupancy, utilización de carriles y comportamiento específico del hardware. VectorWare está tratando de colocar más de esa complejidad bajo el compilador y el sistema de tipos de Rust, donde las formas de ejecución inválidas y las operaciones no soportadas pueden ser rechazadas antes.

VectorWare dice que construyó una representación intermedia tipada para operaciones a nivel de carril incluyendo shuffles, reducciones, scans, gathers, scatters y atomics. La representación usa tipos Rust, genéricos y límites de traits para describir la forma de ejecución. VectorWare también construyó un intérprete determinista para CPU para pruebas diferenciales del comportamiento en GPU.

Las restricciones de eficiencia siguen siendo visibles

La demostración del 10 de agosto es un hito del compilador más que un resultado de rendimiento de producción. El ejemplo de VectorWare establece que las operaciones portable SIMD pueden bajarse a instrucciones de GPU preservando el código fuente ordinario de Rust. La ejecución eficiente depende en gran medida de cómo el ancho vectorial y el patrón de operaciones encajan con el hardware.

Un vector de 32 elementos se mapea limpiamente a un warp de NVIDIA. Vectores más angostos dejan carriles inactivos. Vectores más anchos requieren que cada carril procese múltiples elementos. El hardware de AMD puede usar wavefronts de 32 o 64 carriles, creando otra decisión de portabilidad para código que codifique un N fijo en su tipo.

Las operaciones entre carriles también varían en costo. Los shuffles amigables con el hardware pueden bajar eficientemente, mientras que permutaciones arbitrarias pueden requerir varias instrucciones o memoria compartida. Reducciones y operaciones horizontales de máscara introducen puntos de sincronización. VectorWare dice que el caso de costo cero ocurre cuando el ancho SIMD coincide con el ancho del hardware, una afirmación más limitada que la promesa general de que la misma fuente puede ejecutarse en CPUs y GPUs.

La API portable SIMD de Rust sigue siendo inestable y requiere la feature nightly portable_simd. VectorWare también dice que se necesitaron cambios en el compilador para preservar la solidez cuando SIMD interactúa con otras características de Rust. Esas restricciones ubican el trabajo en una cadena de herramientas de compilador experimental en lugar de un canal de lanzamiento general.

VectorWare actualmente apunta al hardware NVIDIA, aunque los ingenieros de Legnitto argumentan que la representación subyacente puede mapearse a wavefronts de AMD y subgrupos de Vulkan. VectorWare también explora el lowering a tensor cores y la auto-vectorización guiada por compilador, lo que eventualmente podría permitir que bucles escalares de Rust usen paralelismo a nivel de warp sin que los desarrolladores escriban tipos Simd explícitos.

El valor estratégico radica en la composición. El acceso a la biblioteca estándar, la ejecución async, los threads a nivel de warp y el SIMD a nivel de carril resuelven cada uno una parte diferente de la programación en GPU. Si VectorWare puede lograr que esas abstracciones funcionen juntas sin borrar las ventajas de rendimiento del hardware, Legnitto tendrá la base para la plataforma más amplia prometida en el lanzamiento de VectorWare: software construido alrededor de la GPU como la computadora primaria, usando herramientas de programación que los desarrolladores de sistemas ya reconocen.