wip, broken max const

linalg/arm64/arm64simd/arm64simd_act_f32_32n.tmpl

@@ -8,6 +8,10 @@
 .text
 .align 4
 
+// fn(ops: *const Op, constants: *const $ti, xs: *mut $ti, len: usize) -> usize
+
+// x0 <- ops, x1 <- constant, x2 <- xs, x3 <- len(xs)
+
 .cpu generic+fp+simd
 .global {{G}}arm64simd_act_f32_32n_{{suffix}}
 {{G}}arm64simd_act_f32_32n_{{suffix}}:
@@ -16,9 +20,61 @@
  stp d10, d11, [sp, #-16]!
  stp d12, d13, [sp, #-16]!
  stp d14, d15, [sp, #-16]!
+
+ cmp x3, 0
+ beq .ok
+
+.outer_loop:
+ mov x5, x0 // x5 is "pc"
+ ld1 {v0.4s, v1.4s, v2.4s, v3.4s}, [x2]
+ ld1 {v4.4s, v5.4s, v6.4s, v7.4s}, [x2], 64
+
+.inner_loop:
+ ldr x6, [x5] // x6 is fetched instruction at x5
+ and x7, x6, 0xffff
+
+ cmp x7, 0
+ beq .end_of_inner_loop
+ cmp x7, 10
+ beq .max_const
+
+ b .unsupported
+
+.inner_loop_payload_done:
+ add x5, x5, 4
+ b .inner_loop
+.end_of_inner_loop:
+ st1 {v0.4s, v1.4s, v2.4s, v3.4s}, [x2]
+ st1 {v4.4s, v5.4s, v6.4s, v7.4s}, [x2], 64
+
+ add x2, x2, 128
+ subs x3, x3, 32
+ bne .outer_loop
+
+.max_const:
+ lsr x7, x6, 16
+ and x7, x7, 0xff
+ lsl x7, x7, 2
+ add x7, x7, x1
+ ld1 { v24.s }[0], [x7]
+ dup v24.4s, v24.s[0]
+ fmax v0.4s, v0.4s, v24.4s
+ fmax v1.4s, v1.4s, v24.4s
+ fmax v2.4s, v2.4s, v24.4s
+ fmax v3.4s, v3.4s, v24.4s
+ fmax v4.4s, v4.4s, v24.4s
+ fmax v5.4s, v5.4s, v24.4s
+ fmax v6.4s, v6.4s, v24.4s
+ fmax v7.4s, v7.4s, v24.4s
+ b .inner_loop_payload_done
+
+
+.unsupported:
+ mov x0, 1
+ b .return
 
+.ok:
  mov x0, 0
-// b .return
 
 .return:
  ldp d14, d15, [sp], #16

linalg/src/frame/activations.rs

@@ -133,8 +133,12 @@ macro_rules! act_impl {
  }
  }
 
- #[cfg(test)]
- act_tests!($cond, $func, $ti);
+ mod [<test_ $func>] {
+ use super::*;
+
+ #[cfg(test)]
+ act_tests!($cond, $func, $ti);
+ }
  }
  };
 }

linalg/src/frame/activations/tests.rs

@@ -1,20 +1,24 @@
 use crate::LADatum;
 
-use super::{Program, Op};
+use super::{Op, Program};
 use Op::*;
 
 pub fn noop<T: LADatum>() -> Program<T> {
  Program { ops: vec![Done], csts: vec![] }
 }
 
+pub fn max_const<T: LADatum>(c: T) -> Program<T> {
+ Program { ops: vec![MaxConst(0)], csts: vec![c] }
+}
+
 macro_rules! prop_act_e2e {
  ($cond:expr, $ti: ty, $ker: ty, $name: ident ( $($param:ident),* )) => {
  proptest::proptest! {
  #[test]
  fn $name(
  x in proptest::prelude::any::<$ti>(),
  repeat in 1usize..4,
- $($param in proptest::prelude::any::<$ti>()),*) 
+ $($param in proptest::prelude::any::<$ti>()),*)
  {
  use crate::frame::activations::ActivationKer;
  if $cond {
@@ -39,14 +43,14 @@ macro_rules! prop_act_unit {
  fn $name(
  x in proptest::prelude::any::<$ti>(),
  repeat in 1usize..4,
- $($param in proptest::prelude::any::<$ti>()),*) 
+ $($param in proptest::prelude::any::<$ti>()),*)
  {
  use crate::frame::activations::ActivationKer;
  if $cond {
  let mut input = tract_data::prelude::Tensor::zero_aligned::<$ti>(&[<$ker>::nr() * repeat], <$ker>::alignment_bytes()).unwrap();
  input.fill_t::<$ti>(x).unwrap();
- let refer2: fn($ti) -> $ti = $refer;
- let expected:Vec<$ti> = input.as_slice::<$ti>().unwrap().iter().cloned().map(refer2).collect();
+// let refer2: fn($ti, $($param),*) -> $ti = $refer;
+ let expected:Vec<$ti> = input.as_slice::<$ti>().unwrap().iter().cloned().map(|x| $refer(x, $($param),*)).collect();
  let prog = crate::frame::activations::tests::$name($($param),*);
  <$ker>::run(&prog.ops, &prog.csts, &mut input.as_slice_mut::<$ti>().unwrap());
 
@@ -62,6 +66,7 @@ macro_rules! prop_act_unit {
 macro_rules! act_tests {
  ($cond:expr, $ker:ty, $ti:ty) => {
  prop_act_unit!($cond, $ti, $ker, noop(), |x| x);
+ prop_act_unit!($cond, $ti, $ker, max_const(alpha), |x: $ti, alpha| x.max(alpha));
 
  prop_act_e2e!($cond, $ti, $ker, relu());
  prop_act_e2e!($cond, $ti, $ker, affine(alpha, beta));
@@ -75,4 +80,3 @@ macro_rules! act_tests {
  */
  };
 }
-