vec3: difftest with member offset checking

Author: Firestar99

tests/difftests/tests/lang/abi/vector_layout/cpu/src/cpu_driver.rs

@@ -1,7 +1,11 @@
+use crate::layout::{LAYOUT_COUNT, LAYOUT_LEN, eval_layouts};
 use difftest::config::Config;
-use crate::layout::eval_layouts;
 
 pub fn run() {
     let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
-    config.write_result(bytemuck::bytes_of(&eval_layouts())).unwrap()
+    let mut out = vec![0; LAYOUT_LEN];
+    for gid in 0..LAYOUT_COUNT {
+        eval_layouts(gid as u32, &mut out);
+    }
+    config.write_result(&out).unwrap()
 }

tests/difftests/tests/lang/abi/vector_layout/cpu/src/layout.rs

@@ -1,37 +1,83 @@
-use bytemuck::{Pod, Zeroable};
+use core::mem::offset_of;
 use spirv_std::glam::*;
+use experiments::*;
 
-#[repr(C)]
-#[derive(Copy, Clone, Zeroable, Pod)]
-pub struct SizeAndAlign {
-	pub size: u32,
-	pub align: u32,
+pub struct BumpAlloc(usize);
+
+impl BumpAlloc {
+    pub fn inc(&mut self) -> usize {
+        let old = self.0;
+        self.0 += 1;
+        old
+    }
+}
+
+pub trait WriteLayout {
+    fn write_layout(offset: &mut BumpAlloc, out: &mut [u32]);
 }
 
-impl SizeAndAlign {
-	pub fn from<T>() -> Self {
-		Self {
-			size: size_of::<T>() as u32,
-			align: align_of::<T>() as u32,
+macro_rules! write_layout {
+    ($out:ident, $offset:ident, $name:ident($($member:ident),*)) => {
+		{
+			// offset 0: size
+			$out[$offset.inc()] = size_of::<$name>() as u32;
+			// offset 4: alignment
+			$out[$offset.inc()] = align_of::<$name>() as u32;
+			// offset 8 onwards: members
+			$($out[$offset.inc()] = offset_of!($name, $member) as u32;)*
 		}
-	}
+	};
+}
 
-	pub fn flatten(&self) -> [u32; 2] {
-		[self.size, self.align]
-	}
+/// gid is checked between `0..LAYOUT_COUNT`
+pub const LAYOUT_COUNT: usize = 0x40;
+/// at byte offset 0x100 * N starts layout N
+pub const LAYOUT_MAX_SIZE: usize = 0x100 / 0x4;
+pub const LAYOUT_LEN: usize = LAYOUT_COUNT * LAYOUT_MAX_SIZE;
+
+pub fn eval_layouts(gid: u32, out: &mut [u32]) {
+    let mut offset = BumpAlloc(gid as usize * LAYOUT_MAX_SIZE);
+    match gid {
+		// vec
+        0x0 => write_layout!(out, offset, u32()),
+		0x1 => write_layout!(out, offset, UVec2(x, y)),
+		0x2 => write_layout!(out, offset, UVec3(x, y, z)),
+		0x3 => write_layout!(out, offset, UVec4(x, y, z, w)),
+		0x4 => write_layout!(out, offset, i32()),
+		0x5 => write_layout!(out, offset, IVec2(x, y)),
+		0x6 => write_layout!(out, offset, IVec3(x, y, z)),
+		0x7 => write_layout!(out, offset, IVec4(x, y, z, w)),
+		0x8 => write_layout!(out, offset, f32()),
+		0x9 => write_layout!(out, offset, Vec2(x, y)),
+		0xA => write_layout!(out, offset, Vec3(x, y, z)),
+		0xB => write_layout!(out, offset, Vec4()), // private members
+		0xC => write_layout!(out, offset, Vec3A()), // private members
+
+		// experiments structs
+		0x10 => write_layout!(out, offset, Struct0x10(a, b)),
+		0x11 => write_layout!(out, offset, Struct0x11(a, b)),
+        _ => {}
+    }
 }
 
-pub type EvalResult = [SizeAndAlign; 8];
-
-pub fn eval_layouts() -> EvalResult {
-	[
-		SizeAndAlign::from::<u32>(),
-		SizeAndAlign::from::<UVec2>(),
-		SizeAndAlign::from::<UVec3>(),
-		SizeAndAlign::from::<UVec4>(),
-		SizeAndAlign::from::<f32>(),
-		SizeAndAlign::from::<Vec2>(),
-		SizeAndAlign::from::<Vec3>(),
-		SizeAndAlign::from::<Vec4>(),
-	]
+mod experiments {
+	use spirv_std::glam::*;
+
+	#[repr(C)]
+	pub struct Struct0x10 {
+		pub a: f32,
+		/// if UVec2 has an alignment of
+		/// * 4 (CPU): 12 size, 4 alignment, 4 b offset
+		/// * 8 (GPU): 16 size, 8 alignment, 8 b offset
+		pub b: UVec2,
+	}
+
+	#[repr(C)]
+	pub struct Struct0x11 {
+		pub a: Vec3,
+		/// if Vec3 has an alignment of
+		/// * 4 (CPU): 16 size, 4 alignment, 12 b offset
+		/// * 16 (GPU): 32 size, 16 alignment, 16 b offset
+		pub b: f32,
+	}
 }

tests/difftests/tests/lang/abi/vector_layout/cpu/src/shader.rs

@@ -1,7 +1,11 @@
-use crate::layout::{EvalResult, eval_layouts};
+use crate::layout::eval_layouts;
+use spirv_std::glam::UVec3;
 use spirv_std::spirv;
 
 #[spirv(compute(threads(1)))]
-pub fn main_cs(#[spirv(storage_buffer, descriptor_set = 0, binding = 0)] output: &mut EvalResult) {
-    *output = eval_layouts();
+pub fn main_cs(
+    #[spirv(workgroup_id)] gid: UVec3,
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] output: &mut [u32],
+) {
+    eval_layouts(gid.x, output);
 }

tests/difftests/tests/lang/abi/vector_layout/cpu/src/shader_driver.rs

@@ -1,13 +1,13 @@
-use crate::layout::EvalResult;
+use crate::layout::{LAYOUT_COUNT, LAYOUT_LEN};
 use difftest::config::Config;
 use difftest::scaffold::compute::{BufferConfig, RustComputeShader, WgpuComputeTestMultiBuffer};
 
 pub fn run() {
     let config = Config::from_path(std::env::args().nth(1).unwrap()).unwrap();
     let test = WgpuComputeTestMultiBuffer::new(
         RustComputeShader::default(),
-        [1, 1, 1],
-        Vec::from(&[BufferConfig::writeback(size_of::<EvalResult>())]),
+        [LAYOUT_COUNT as u32, 1, 1],
+        Vec::from(&[BufferConfig::writeback(LAYOUT_LEN * size_of::<u32>())]),
     );
     test.run_test(&config).unwrap();
 }