add dummy test cases

Author: ZuseZ4

tests/ui/vectorize/batch_sqnorm.rs

@@ -0,0 +1,20 @@
+// We want a batch size of 4, and hardcode the size of one element.
+// It would be somewhat nice if the final interface can deduce the 8, not sure.
+#[vectorize(dsqnorm, Batch, 4 * 8)]
+fn sqnorm(x: &[f64]) -> f64 {
+    x.iter().map(|&x| x * x).sum()
+}
+
+fn main() {
+    let x1 = vec![1.0; 4 * 8];
+    let x2 = vec![1.0; 4 * 8];
+    let mut res1 = 0.0;
+    for i in 0..4 * 8 {
+        res1 += sqnorm(&x1[i..i + 1]);
+    }
+    let res2 = dsqnorm(&x2);
+
+    for i in 0..4 * 8 {
+        assert_eq!(res1, res2[i]);
+    }
+}

tests/ui/vectorize/vector_char-ptr.rs

@@ -0,0 +1,49 @@
+
+#[repr(C, packed)]
+struct Foo {
+    arr: [i32; 3],
+    x: f64,
+    y: f32,
+    res: f64,
+}
+
+//#pragma pack(1)
+//struct Foo {
+//  int arr[3];
+//  double x;
+//  float y;
+//  double res;
+//};
+
+#[vectorize(df, Vector, 4)]
+unsafe fn f(foo: *mut i32) {
+    let xptr = foo.add(3) as *mut f64;
+    let yptr = foo.add(5) as *mut f32;
+    let resptr = foo.add(6) as *mut f64;
+    let x: f64 = *xptr;
+    let y: f32 = *yptr;
+    *resptr = x * y;
+}
+
+//void df(char *dfoo1, char *dfoo2, char *dfoo3, char *dfoo4) {
+//  __enzyme_batch((void *)f, enzyme_width, 4, dfoo1, dfoo2, dfoo3, dfoo4);
+//}
+
+fn main() {
+    let foo1: Foo = Foo { [0,0,0], 10.0, 9.0, 0.0 };
+    let foo2: Foo = Foo { [0,0,0], 99.0, 7.0, 0.0 };
+    let foo3: Foo = Foo { [0,0,0], 1.10, 9.0, 0.0 };
+    let foo4: Foo = Foo { [0,0,0], 3.14, 0.1, 0.0 };
+
+    let expected = [90.0, 693.0, 9.9, 0.314};
+
+    df(&foo1.as_ptr() as *mut i32,
+       &foo2.as_ptr() as *mut i32,
+       &foo3.as_ptr() as *mut i32,
+       &foo4.as_ptr() as *mut i32);
+
+    assert_eq!(foo1.res, expected[0]);
+    assert_eq!(foo2.res, expected[1]);
+    assert_eq!(foo3.res, expected[2]);
+    assert_eq!(foo4.res, expected[3]);
+}

tests/ui/vectorize/vector_square.rs

@@ -0,0 +1,32 @@
+struct Vector {
+    x1: f64,
+    x2: f64,
+    x3: f64,
+    x4: f64,
+}
+
+//extern Vector __enzyme_batch(...);
+
+//extern int enzyme_width;
+//extern int enzyme_vector;
+//extern int enzyme_scalar;
+
+#[vectorize(vecsquare, Vector, 4)]
+#[vectorize(vecsquare8, Vector, 8)]
+fn square(x: f64) -> f64 {
+    x * x
+}
+
+//Vector vecsquare(double x1, double x2, double x3, double x4) {
+//  return __enzyme_batch(square, enzyme_width, 4, enzyme_vector, x1, x2, x3, x4);
+//}
+
+fn main() {
+    let vals = [23.1, 10.0, 100.0, 3.14];
+    let expected = [square(vals[0]), square(vals[1]), square(vals[2]), square(vals[3])];
+    let result = vecsquare(vals[0], vals[1], vals[2], vals[3]);
+    assert_eq!(result.x1, expected[0]);
+    assert_eq!(result.x2, expected[1]);
+    assert_eq!(result.x3, expected[2]);
+    assert_eq!(result.x4, expected[3]);
+}