add more i16/u16 tests; fix cuda align for i16/u16

bitshifter · Nov 26, 2023 · 9aa4336 · 9aa4336
1 parent c432b1b
commit 9aa4336
Show file tree

Hide file tree

Showing 14 changed files with 881 additions and 91 deletions.
diff --git a/codegen/templates/vec.rs.tera b/codegen/templates/vec.rs.tera
@@ -91,10 +91,22 @@
     {% set try_from_types = ["I16Vec" ~ dim, "IVec" ~ dim, "I64Vec" ~ dim] %}
 {% endif %}
 
-{% if scalar_t == "f64" or scalar_t == "i64" or scalar_t == "u64" or dim == 4 %}
-    {% set cuda_align = 16 %}
-{% elif dim == 2 %}
-    {% set cuda_align = 8 %}
+{% if dim == 2 %}
+    {% if scalar_t == "i16" or scalar_t == "u16" %}
+        {% set cuda_align = 4 %}
+    {% elif scalar_t == "f32" or scalar_t == "i32" or scalar_t == "u32" %}
+        {% set cuda_align = 8 %}
+    {% elif scalar_t == "f64" or scalar_t == "i64" or scalar_t == "u64" %}
+        {% set cuda_align = 16 %}
+    {% endif %}
+{% elif dim == 4 %}
+    {% if scalar_t == "i16" or scalar_t == "u16" %}
+        {% set cuda_align = 8 %}
+    {% elif scalar_t == "f32" or scalar_t == "i32" or scalar_t == "u32" %}
+        {% set cuda_align = 16 %}
+    {% elif scalar_t == "f64" or scalar_t == "i64" or scalar_t == "u64" %}
+        {% set cuda_align = 16 %}
+    {% endif %}
 {% endif %}
 
 {% set components = ["x", "y", "z", "w"] | slice(end = dim) %}

diff --git a/src/i16.rs b/src/i16.rs
@@ -11,18 +11,15 @@ mod test {
     use super::*;
 
     mod const_test_i16vec2 {
+        const_assert_eq!(4, core::mem::size_of::<super::I16Vec2>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<i16>(),
             core::mem::align_of::<super::I16Vec2>()
         );
-        #[cfg(not(feature = "cuda"))]
-        const_assert_eq!(4, core::mem::size_of::<super::I16Vec2>());
-
-        #[cfg(feature = "cuda")]
-        const_assert_eq!(8, core::mem::align_of::<super::I16Vec2>());
         #[cfg(feature = "cuda")]
-        const_assert_eq!(8, core::mem::size_of::<super::I16Vec2>());
+        const_assert_eq!(4, core::mem::align_of::<super::I16Vec2>());
     }
 
     mod const_test_i16vec3 {
@@ -34,17 +31,14 @@ mod test {
     }
 
     mod const_test_i16vec4 {
+        const_assert_eq!(8, core::mem::size_of::<super::I16Vec4>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<i16>(),
             core::mem::align_of::<super::I16Vec4>()
         );
-        #[cfg(not(feature = "cuda"))]
-        const_assert_eq!(8, core::mem::size_of::<super::I16Vec4>());
-
-        #[cfg(feature = "cuda")]
-        const_assert_eq!(16, core::mem::align_of::<super::I16Vec4>());
         #[cfg(feature = "cuda")]
-        const_assert_eq!(16, core::mem::size_of::<super::I16Vec4>());
+        const_assert_eq!(8, core::mem::align_of::<super::I16Vec4>());
     }
 }
diff --git a/src/i16/i16vec2.rs b/src/i16/i16vec2.rs
@@ -16,7 +16,7 @@ pub const fn i16vec2(x: i16, y: i16) -> I16Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "cuda", repr(align(8)))]
+#[cfg_attr(feature = "cuda", repr(align(4)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct I16Vec2 {

diff --git a/src/i16/i16vec4.rs b/src/i16/i16vec4.rs
@@ -16,7 +16,7 @@ pub const fn i16vec4(x: i16, y: i16, z: i16, w: i16) -> I16Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "cuda", repr(align(16)))]
+#[cfg_attr(feature = "cuda", repr(align(8)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct I16Vec4 {

diff --git a/src/i32.rs b/src/i32.rs
@@ -9,16 +9,17 @@ pub use ivec4::{ivec4, IVec4};
 #[cfg(not(target_arch = "spirv"))]
 mod test {
     use super::*;
-
+    
     mod const_test_ivec2 {
+        const_assert_eq!(8, core::mem::size_of::<super::IVec2>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<i32>(),
             core::mem::align_of::<super::IVec2>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(8, core::mem::align_of::<super::IVec2>());
-        const_assert_eq!(8, core::mem::size_of::<super::IVec2>());
     }
 
     mod const_test_ivec3 {
@@ -30,13 +31,14 @@ mod test {
     }
 
     mod const_test_ivec4 {
+        const_assert_eq!(16, core::mem::size_of::<super::IVec4>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<i32>(),
             core::mem::align_of::<super::IVec4>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(16, core::mem::align_of::<super::IVec4>());
-        const_assert_eq!(16, core::mem::size_of::<super::IVec4>());
     }
 }
diff --git a/src/i64.rs b/src/i64.rs
@@ -11,32 +11,35 @@ mod test {
     use super::*;
 
     mod const_test_i64vec2 {
+        const_assert_eq!(16, core::mem::size_of::<super::I64Vec2>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<i64>(),
             core::mem::align_of::<super::I64Vec2>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(16, core::mem::align_of::<super::I64Vec2>());
-        const_assert_eq!(16, core::mem::size_of::<super::I64Vec2>());
     }
 
     mod const_test_i64vec3 {
+        const_assert_eq!(24, core::mem::size_of::<super::I64Vec3>());
+
         const_assert_eq!(
             core::mem::align_of::<i64>(),
             core::mem::align_of::<super::I64Vec3>()
         );
-        const_assert_eq!(24, core::mem::size_of::<super::I64Vec3>());
     }
 
     mod const_test_i64vec4 {
+        const_assert_eq!(32, core::mem::size_of::<super::I64Vec4>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<i64>(),
             core::mem::align_of::<super::I64Vec4>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(16, core::mem::align_of::<super::I64Vec4>());
-        const_assert_eq!(32, core::mem::size_of::<super::I64Vec4>());
     }
 }
diff --git a/src/u16.rs b/src/u16.rs
@@ -11,18 +11,15 @@ mod test {
     use super::*;
 
     mod const_test_u16vec2 {
+        const_assert_eq!(4, core::mem::size_of::<super::U16Vec2>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<u16>(),
             core::mem::align_of::<super::U16Vec2>()
         );
-        #[cfg(not(feature = "cuda"))]
-        const_assert_eq!(4, core::mem::size_of::<super::U16Vec2>());
-        #[cfg(feature = "cuda")]
-
-        const_assert_eq!(8, core::mem::align_of::<super::U16Vec2>());
         #[cfg(feature = "cuda")]
-        const_assert_eq!(8, core::mem::size_of::<super::U16Vec2>());
+        const_assert_eq!(4, core::mem::align_of::<super::U16Vec2>());
     }
 
     mod const_test_u16vec3 {
@@ -34,17 +31,14 @@ mod test {
     }
 
     mod const_test_u16vec4 {
+        const_assert_eq!(8, core::mem::size_of::<super::U16Vec4>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<u16>(),
             core::mem::align_of::<super::U16Vec4>()
         );
-        #[cfg(not(feature = "cuda"))]
-        const_assert_eq!(8, core::mem::size_of::<super::U16Vec4>());
-
-        #[cfg(feature = "cuda")]
-        const_assert_eq!(16, core::mem::align_of::<super::U16Vec4>());
         #[cfg(feature = "cuda")]
-        const_assert_eq!(16, core::mem::size_of::<super::U16Vec4>());
+        const_assert_eq!(8, core::mem::align_of::<super::U16Vec4>());
     }
 }
diff --git a/src/u16/u16vec2.rs b/src/u16/u16vec2.rs
@@ -16,7 +16,7 @@ pub const fn u16vec2(x: u16, y: u16) -> U16Vec2 {
 /// A 2-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "cuda", repr(align(8)))]
+#[cfg_attr(feature = "cuda", repr(align(4)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct U16Vec2 {

diff --git a/src/u16/u16vec4.rs b/src/u16/u16vec4.rs
@@ -16,7 +16,7 @@ pub const fn u16vec4(x: u16, y: u16, z: u16, w: u16) -> U16Vec4 {
 /// A 4-dimensional vector.
 #[cfg_attr(not(target_arch = "spirv"), derive(Hash))]
 #[derive(Clone, Copy, PartialEq, Eq)]
-#[cfg_attr(feature = "cuda", repr(align(16)))]
+#[cfg_attr(feature = "cuda", repr(align(8)))]
 #[cfg_attr(not(target_arch = "spirv"), repr(C))]
 #[cfg_attr(target_arch = "spirv", repr(simd))]
 pub struct U16Vec4 {

diff --git a/src/u32.rs b/src/u32.rs
@@ -10,32 +10,35 @@ pub use uvec4::{uvec4, UVec4};
 mod test {
     use super::*;
     mod const_test_uvec2 {
+        const_assert_eq!(8, core::mem::size_of::<super::UVec2>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<u32>(),
             core::mem::align_of::<super::UVec2>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(8, core::mem::align_of::<super::UVec2>());
-        const_assert_eq!(8, core::mem::size_of::<super::UVec2>());
     }
 
     mod const_test_uvec3 {
+        const_assert_eq!(12, core::mem::size_of::<super::UVec3>());
+
         const_assert_eq!(
             core::mem::align_of::<u32>(),
             core::mem::align_of::<super::UVec3>()
         );
-        const_assert_eq!(12, core::mem::size_of::<super::UVec3>());
     }
 
     mod const_test_uvec4 {
+        const_assert_eq!(16, core::mem::size_of::<super::UVec4>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<u32>(),
             core::mem::align_of::<super::UVec4>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(16, core::mem::align_of::<super::UVec4>());
-        const_assert_eq!(16, core::mem::size_of::<super::UVec4>());
     }
 }
diff --git a/src/u64.rs b/src/u64.rs
@@ -10,32 +10,35 @@ pub use u64vec4::{u64vec4, U64Vec4};
 mod test {
     use super::*;
     mod const_test_u64vec2 {
+        const_assert_eq!(16, core::mem::size_of::<super::U64Vec2>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<u64>(),
             core::mem::align_of::<super::U64Vec2>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(16, core::mem::align_of::<super::U64Vec2>());
-        const_assert_eq!(16, core::mem::size_of::<super::U64Vec2>());
     }
 
     mod const_test_u64vec3 {
+        const_assert_eq!(24, core::mem::size_of::<super::U64Vec3>());
+
         const_assert_eq!(
             core::mem::align_of::<u64>(),
             core::mem::align_of::<super::U64Vec3>()
         );
-        const_assert_eq!(24, core::mem::size_of::<super::U64Vec3>());
     }
 
     mod const_test_u64vec4 {
+        const_assert_eq!(32, core::mem::size_of::<super::U64Vec4>());
+
         #[cfg(not(feature = "cuda"))]
         const_assert_eq!(
             core::mem::align_of::<u64>(),
             core::mem::align_of::<super::U64Vec4>()
         );
         #[cfg(feature = "cuda")]
         const_assert_eq!(16, core::mem::align_of::<super::U64Vec4>());
-        const_assert_eq!(32, core::mem::size_of::<super::U64Vec4>());
     }
 }