Join us for an exclusive evening of networking, bites, and cocktails on January 7, 2027, during CES week! Connect with Thread members, industry leaders, and smart home innovators in an engaging settin...

YouTube video by Broadband Forum

Coming to #Unify2026? Don't miss our VP of Certification, Tom Sciorilli, talk all things certification and the path to interoperability and market readiness! It's not too late to register: https://cs...

Summary TQ3_1S (3-bit, 4.0 BPW) and TQ4_1S (4-bit, 5.0 BPW) weight quantization using WHT rotation + Lloyd-Max centroids V2.1 fused Metal kernel: zero threadgroup memory, cooperative SIMD rotation...

Summary TQ3_1S (3-bit, 4.0 BPW) and TQ4_1S (4-bit, 5.0 BPW) weight quantization using WHT rotation + Lloyd-Max centroids V2.1 fused Metal kernel: zero threadgroup memory, cooperative SIMD rotation...

An HLSL implementation of a thread group wide bitonic sort for GPU - pm4rtx/threadgroup_bitonic_sort_hlsl

Thanks for the comments, that’s all very valuable input! Extending on the name for the group of threads that runs on a SIMD unit, warp/wave/wavefront/subgroup * Warp is coined by nvidia (comes from weaving as jdahlstrom mentioned above) * Wavefront is coined by amd * Subgroup is from Khronos (the vendor-crossing APIs like OpenCL) * Wave is from DirectX * Simdgroup is from Apple/Metal * Maybe threadgroup? (but that means workgroup on Apple/Metal) * Maybe executiongroup? I feel like none of these choices is particularly appealing. Subgroup does not feel fitting (analogous on CPUs, something running on a core is not a subprocess, but called a _thread_). Warp doesn’t resonate with me so far (in its original meaning in weaving, it describes a single, orthogonal thread, but we want to describe a certain _group_ of threads). Simdgroup doesn’t make sense to me as it’s not a group of SIMDs (that sounds like a better name for an SM on nvidia or WGP on amd). With the lack of self-explanatory names, I’m currently leaning towards _wave_ as it’s short and unambiguous. A slightly refined structured API, without nesting and extended with launch_sized_workgroup_mem: /// Everything from launch scope struct Launch {} impl Launch { /// Workgroup id (x/y/z) fn workgroup_x() -> u32; /// Number of launched workgroups (x/y/z) fn workgroups_x_len() -> u32; } /// Everything from workgroup scope struct Workgroup {} impl Workgroup { /// Number of waves in a workgroup fn waves_len() -> u32; /// Number of threads in the workgroup (x/y/z) fn threads_x_len() -> u32; /// Thread id inside workgroup (x/y/z) fn thread_x() -> u32; /// Maybe makes sense to expose gpu_launch_sized_workgroup_mem() here /// as it is on the workgroup scope? fn launch_sized_mem<T>() -> *mut T; } /// Everything from wave scope struct Wave {} impl Wave { /// Number of threads in the wave /// ~= Number of lanes in a SIMD unit fn len() -> u32; /// Thread/lane id inside wave fn thread_id() -> u32; // Could include wave intrinsics like ballot, read_first_lane, reduces, etc. here } As a place for writing this down, I think the module documentation of `core::gpu` would fit well. New/changed naming: * workgroup-shared memory → **workgroup memory** * The thing that launches a gpu-kernel: **runtime** (i.e. an application calls into the runtime, which then launches the gpu-kernel on the GPU) ### Regarding address spaces I agree that something like `AddrspacePtr<T, const /* enum? */ Addrspace ADDRSPACE>` akin to `VolatilePtr` would be nice. I tried to take a look at implementing it but didn’t get very far. I didn’t find an easy way to define a type where the implementation is in the compiler. We want an `AddrspacePtr` to be Sized but the size depends on the generic ADDRSPACE argument (in that sense it’s different from `extern type` which doesn’t have a size and cannot be stored by value). Adding it as `ty::AddrspacePtr` turned out to be a rather large change (maybe adding an addrspace argument to `ty::RawPtr` would make it easier?). But that can be a separate discussion. ### Misc > In my opinion for vendor specific things we should stick to the vendor specific naming. […] I agree. > However, for the code in `core::intrinsics` this approach was never taken, so I do not know if this approach is possible and desirable for _rustc_intrinsics_. So this might rather be the way for intrinsic wrappers. Right, the `core::gpu` module should be a wrapper for (vendor specific) intrinsics. I think it’s something we can eventually stabilize (compared to (rustc)intrinsics, which are mostly not stabilized). > `gpu::available_*_parallelism` I agree to the other answer above, the _available parallelism_ doesn’t match what we want here (the name does make sense in std::thread for ~cpu-count). The GPU launch/workgroup sizes are specified on the CPU when launching a gpu-kernel and the kernel wants to get these exact, specified sizes.