Moar tests

Author: LegNeato

crates/cuda_std/src/warp/shuffle.rs

@@ -473,7 +473,12 @@ const SHUFFLE_MODE_IDX: u32 = 3;
 macro_rules! impl_shuffle_op {
     ($fn_name:ident, $mode:expr) => {
         #[gpu_only]
-        unsafe fn $fn_name(mask: WarpMask, value: Self, param: u32, width: u32) -> ShuffleResult<Self> {
+        unsafe fn $fn_name(
+            mask: WarpMask,
+            value: Self,
+            param: u32,
+            width: u32,
+        ) -> ShuffleResult<Self> {
             let result = warp_shuffle_32($mode, mask.raw(), value as u32, param, width);
             ShuffleResult::new(result.value as Self, result.valid)
         }
@@ -502,7 +507,12 @@ impl_shuffle_32! {
 macro_rules! impl_shuffle_float_op {
     ($fn_name:ident, $bits_ty:ty, $to_bits:ident, $from_bits:ident) => {
         #[gpu_only]
-        unsafe fn $fn_name(mask: WarpMask, value: Self, param: u32, width: u32) -> ShuffleResult<Self> {
+        unsafe fn $fn_name(
+            mask: WarpMask,
+            value: Self,
+            param: u32,
+            width: u32,
+        ) -> ShuffleResult<Self> {
             let bits = value.$to_bits();
             let result = <$bits_ty as ShuffleValue>::$fn_name(mask, bits, param, width);
             ShuffleResult::new(Self::$from_bits(result.value), result.valid)
@@ -522,7 +532,12 @@ impl ShuffleValue for f32 {
 macro_rules! impl_shuffle_64_op {
     ($fn_name:ident) => {
         #[gpu_only]
-        unsafe fn $fn_name(mask: WarpMask, value: Self, param: u32, width: u32) -> ShuffleResult<Self> {
+        unsafe fn $fn_name(
+            mask: WarpMask,
+            value: Self,
+            param: u32,
+            width: u32,
+        ) -> ShuffleResult<Self> {
             let lo = (value & 0xFFFFFFFF) as u32;
             let hi = (value >> 32) as u32;
             let lo_result = <u32 as ShuffleValue>::$fn_name(mask, lo, param, width);
@@ -561,11 +576,16 @@ impl ShuffleValue for f64 {
     impl_shuffle_float_op!(shuffle_idx, u64, to_bits, from_bits);
 }
 
-// Generic macro for small type shuffle operations  
+// Generic macro for small type shuffle operations
 macro_rules! impl_shuffle_small_op {
     ($fn_name:ident) => {
         #[gpu_only]
-        unsafe fn $fn_name(mask: WarpMask, value: Self, param: u32, width: u32) -> ShuffleResult<Self> {
+        unsafe fn $fn_name(
+            mask: WarpMask,
+            value: Self,
+            param: u32,
+            width: u32,
+        ) -> ShuffleResult<Self> {
             let result = <u32 as ShuffleValue>::$fn_name(mask, value as u32, param, width);
             ShuffleResult::new(result.value as Self, result.valid)
         }

crates/cuda_std/src/warp/sync.rs

@@ -99,17 +99,54 @@ impl WarpMask {
         Self(!self.0)
     }
 
-    /// Check if this mask is empty.
+    /// Create a mask for even-numbered lanes (0, 2, 4, ...).
+    #[inline]
+    pub const fn even_lanes() -> Self {
+        Self(0x55555555)
+    }
+
+    /// Create a mask for odd-numbered lanes (1, 3, 5, ...).
+    #[inline]
+    pub const fn odd_lanes() -> Self {
+        Self(0xAAAAAAAA)
+    }
+
+    /// Create a mask for a specific quadrant (0-3).
+    #[inline]
+    pub const fn quadrant(quad: u32) -> Self {
+        debug_assert!(quad < 4);
+        Self(0xFF << (quad * 8))
+    }
+
+    /// Create a mask for a range of lanes.
+    #[inline]
+    pub const fn range(start: u32, end: u32) -> Self {
+        debug_assert!(start <= end);
+        debug_assert!(end <= super::WARP_SIZE);
+        if start == end {
+            return Self(0);
+        }
+        let count = end - start;
+        Self::lanes(start, count)
+    }
+
+    /// Check if the mask is empty (no lanes set).
     #[inline]
     pub const fn is_empty(self) -> bool {
         self.0 == 0
     }
 
-    /// Check if this mask includes all lanes.
+    /// Check if the mask is full (all lanes set).
     #[inline]
     pub const fn is_full(self) -> bool {
         self.0 == super::FULL_MASK
     }
+
+    /// Count the number of set lanes in the mask.
+    #[inline]
+    pub const fn count(self) -> u32 {
+        self.0.count_ones()
+    }
 }
 
 impl Default for WarpMask {

crates/cuda_std/src/warp/vote.rs

@@ -410,7 +410,10 @@ macro_rules! impl_vote_equality_float {
             #[gpu_only]
             unsafe fn vote_all_equal(mask: WarpMask, value: Self) -> EqualityResult {
                 let result = __nvvm_warp_match_all_32(mask.raw(), value.to_bits());
-                EqualityResult::with_mask(result.all_matched != 0, WarpMask::new(result.matched_mask))
+                EqualityResult::with_mask(
+                    result.all_matched != 0,
+                    WarpMask::new(result.matched_mask),
+                )
             }
         }
     };
@@ -419,7 +422,10 @@ macro_rules! impl_vote_equality_float {
             #[gpu_only]
             unsafe fn vote_all_equal(mask: WarpMask, value: Self) -> EqualityResult {
                 let result = __nvvm_warp_match_all_64(mask.raw(), value.to_bits());
-                EqualityResult::with_mask(result.all_matched != 0, WarpMask::new(result.matched_mask))
+                EqualityResult::with_mask(
+                    result.all_matched != 0,
+                    WarpMask::new(result.matched_mask),
+                )
             }
         }
     };

tests/compiletests/ui/warp/sync/sync_api.rs

@@ -0,0 +1,100 @@
+// Test warp sync API and mask operations compile
+// build-pass
+
+use cuda_std::kernel;
+use cuda_std::warp::{self, WarpMask};
+
+#[kernel]
+pub unsafe fn test_warp_mask_creation() {
+    // Test different ways to create WarpMask
+    let _all_mask = WarpMask::all();
+    let _none_mask = WarpMask::none();
+    let _custom_mask = WarpMask::new(0x12345678);
+
+    // Test single lane masks
+    let _lane_mask = WarpMask::lane(5);
+    let _lane_mask_2 = WarpMask::lane(31);
+
+    // Test range masks
+    let _lower_16 = WarpMask::range(0, 16);
+    let _middle_8 = WarpMask::range(12, 20);
+}
+
+#[kernel]
+pub unsafe fn test_warp_mask_operations() {
+    let mask1 = WarpMask::new(0x0F0F0F0F);
+    let mask2 = WarpMask::new(0xF0F0F0F0);
+
+    // Test mask predicates
+    let _empty_check = mask1.is_empty();
+    let _full_check = mask1.is_full();
+
+    // Test popcount
+    let _count1 = mask1.count();
+    let _count2 = mask2.count();
+
+    // Test contains_lane
+    let _contains = mask1.contains_lane(0);
+    let _contains2 = mask2.contains_lane(4);
+
+    // Test raw access
+    let _raw = mask1.raw();
+}
+
+#[kernel]
+pub unsafe fn test_active_mask() {
+    // Get current active mask
+    let active = warp::active_mask();
+
+    // Sync with active mask
+    warp::sync(active);
+
+    // Use active mask in operations
+    let _count = active.count();
+    let _contains = active.contains_lane(0);
+}
+
+#[kernel]
+pub unsafe fn test_lane_operations() {
+    // Get lane ID
+    let lane_id = warp::lane_id();
+
+    // Create mask for current lane
+    let my_mask = WarpMask::lane(lane_id);
+
+    // Use mask in sync
+    warp::sync(my_mask);
+}
+
+#[kernel]
+pub unsafe fn test_mask_builders() {
+    // Test even/odd lane masks
+    let even_lanes = WarpMask::even_lanes();
+    let odd_lanes = WarpMask::odd_lanes();
+
+    // Test quadrant masks
+    let _q1 = WarpMask::quadrant(0);
+    let _q2 = WarpMask::quadrant(1);
+    let _q3 = WarpMask::quadrant(2);
+    let _q4 = WarpMask::quadrant(3);
+
+    // Use masks in sync operations
+    warp::sync(even_lanes);
+    warp::sync(odd_lanes);
+}
+
+#[kernel]
+pub unsafe fn test_mask_combinations() {
+    let mask1 = WarpMask::new(0x0F0F0F0F);
+    let mask2 = WarpMask::new(0xF0F0F0F0);
+
+    // Combine masks using bitwise operations
+    let combined = WarpMask::new(mask1.raw() | mask2.raw());
+    let intersection = WarpMask::new(mask1.raw() & mask2.raw());
+    let xor = WarpMask::new(mask1.raw() ^ mask2.raw());
+
+    // Use combined masks
+    warp::sync(combined);
+    warp::sync(intersection);
+    warp::sync(xor);
+}

tests/compiletests/ui/warp/sync/sync_generics.rs

@@ -0,0 +1,84 @@
+// Test sync operations with generic functions
+// build-pass
+
+use cuda_std::kernel;
+use cuda_std::warp::{self, WarpMask};
+
+#[kernel]
+pub unsafe fn test_sync_with_generics() {
+    // Generic function that performs sync
+    fn generic_sync<T>() {
+        unsafe {
+            warp::sync(WarpMask::all());
+            let mask = WarpMask::new(0xFFFFFFFF);
+            warp::sync(mask);
+        }
+    }
+
+    generic_sync::<i32>();
+    generic_sync::<f32>();
+    generic_sync::<()>();
+}
+
+#[kernel]
+pub unsafe fn test_generic_mask_ops() {
+    let mask1 = WarpMask::all();
+    let mask2 = WarpMask::none();
+
+    // Generic function using masks
+    fn sync_with_mask<T>(_phantom: T, mask: WarpMask) {
+        unsafe {
+            warp::sync(mask);
+        }
+    }
+
+    sync_with_mask(42i32, mask1);
+    sync_with_mask(3.14f32, mask2);
+    sync_with_mask((), mask1);
+}
+
+#[kernel]
+pub unsafe fn test_generic_lane_ops() {
+    // Generic function that uses lane operations
+    fn get_lane_mask<T>() -> WarpMask {
+        let lane_id = unsafe { warp::lane_id() };
+        WarpMask::lane(lane_id)
+    }
+
+    let mask_i32 = get_lane_mask::<i32>();
+    warp::sync(mask_i32);
+
+    let mask_f64 = get_lane_mask::<f64>();
+    warp::sync(mask_f64);
+
+    let mask_unit = get_lane_mask::<()>();
+    warp::sync(mask_unit);
+}
+
+#[kernel]
+pub unsafe fn test_generic_active_mask() {
+    // Get active mask in generic context
+    let active = warp::active_mask();
+
+    // Use in generic sync
+    fn sync_active<T>() {
+        unsafe {
+            let mask = warp::active_mask();
+            warp::sync(mask);
+        }
+    }
+
+    sync_active::<i32>();
+    sync_active::<u64>();
+    sync_active::<()>();
+
+    // Generic function with multiple type params
+    fn sync_with_types<T, U>() {
+        unsafe {
+            warp::sync(WarpMask::all());
+        }
+    }
+
+    sync_with_types::<i32, f32>();
+    sync_with_types::<u8, u16>();
+}