Improve and rename inbounds! macro.

It has two versions, one with an upper bound, and one with a lower and
upper bound. This commit removes the first one and changes the second
one to take a range, because that is more concise and flexible and
clearer.

Also, rename it as `in_range`, which makes sense given that the bounds
are specified via a Rust `Range`.

Note: some of the ranges are incorrect, and will be fixed in the next
commit.

Author: nnethercote

crates/cuda_std/src/thread.rs

@@ -89,26 +89,15 @@ extern "C" {
 }
 
 #[cfg(target_os = "cuda")]
-macro_rules! inbounds {
-    // the bounds were taken mostly from the cuda C++ programming guide, i also
-    // double-checked with what cuda clang does by checking its emitted llvm ir's scalar metadata
-    ($func_name:ident, $bound:expr) => {{
+macro_rules! in_range {
+    // The bounds were taken mostly from the cuda C++ programming guide. I also
+    // double-checked with what cuda clang does by checking its emitted llvm ir's scalar metadata.
+    ($func_name:ident, $range:expr) => {{
         let val = unsafe { $func_name() };
-        if val > $bound {
-            // SAFETY: this condition is declared unreachable by compute capability max bound
+        if !$range.contains(&val) {
+            // SAFETY: this condition is declared unreachable by compute capability max bound.
             // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capabilities
-            // we do this to potentially allow for better optimizations by LLVM
-            unsafe { core::hint::unreachable_unchecked() }
-        } else {
-            val
-        }
-    }};
-    ($func_name:ident, $lower_bound:expr, $upper_bound:expr) => {{
-        let val = unsafe { $func_name() };
-        if !($lower_bound..=$upper_bound).contains(&val) {
-            // SAFETY: this condition is declared unreachable by compute capability max bound
-            // https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#compute-capabilities
-            // we do this to potentially allow for better optimizations by LLVM
+            // We do this to potentially allow for better optimizations by LLVM.
             unsafe { core::hint::unreachable_unchecked() }
         } else {
             val
@@ -119,73 +108,73 @@ macro_rules! inbounds {
 #[gpu_only]
 #[inline(always)]
 pub fn thread_idx_x() -> u32 {
-    inbounds!(__nvvm_thread_idx_x, 1024)
+    in_range!(__nvvm_thread_idx_x, 0..=1024)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn thread_idx_y() -> u32 {
-    inbounds!(__nvvm_thread_idx_y, 1024)
+    in_range!(__nvvm_thread_idx_y, 0..=1024)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn thread_idx_z() -> u32 {
-    inbounds!(__nvvm_thread_idx_z, 64)
+    in_range!(__nvvm_thread_idx_z, 0..=64)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn block_idx_x() -> u32 {
-    inbounds!(__nvvm_block_idx_x, 2147483647)
+    in_range!(__nvvm_block_idx_x, 0..=2147483647)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn block_idx_y() -> u32 {
-    inbounds!(__nvvm_block_idx_y, 65535)
+    in_range!(__nvvm_block_idx_y, 0..=65535)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn block_idx_z() -> u32 {
-    inbounds!(__nvvm_block_idx_z, 65535)
+    in_range!(__nvvm_block_idx_z, 0..=65535)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn block_dim_x() -> u32 {
-    inbounds!(__nvvm_block_dim_x, 1, 1025)
+    in_range!(__nvvm_block_dim_x, 1..=1025)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn block_dim_y() -> u32 {
-    inbounds!(__nvvm_block_dim_y, 1, 1025)
+    in_range!(__nvvm_block_dim_y, 1..=1025)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn block_dim_z() -> u32 {
-    inbounds!(__nvvm_block_dim_z, 1, 65)
+    in_range!(__nvvm_block_dim_z, 1..=65)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn grid_dim_x() -> u32 {
-    inbounds!(__nvvm_grid_dim_x, 1, 2147483648)
+    in_range!(__nvvm_grid_dim_x, 1..=2147483648)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn grid_dim_y() -> u32 {
-    inbounds!(__nvvm_grid_dim_y, 1, 65536)
+    in_range!(__nvvm_grid_dim_y, 1..=65536)
 }
 
 #[gpu_only]
 #[inline(always)]
 pub fn grid_dim_z() -> u32 {
-    inbounds!(__nvvm_grid_dim_z, 1, 65536)
+    in_range!(__nvvm_grid_dim_z, 1..=65536)
 }
 
 /// Gets the 3d index of the thread currently executing the kernel.