vectorized activation vm

linalg/Cargo.toml

@@ -97,5 +97,10 @@ name = "x86_64"
 harness = false
 
 [[bench]]
+bench = false
 name = "intel"
 harness = false
+
+[[bench]]
+name = "activations"
+harness = false

linalg/activations/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "activations"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+members = []
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dev-dependencies]
+criterion = "0.4.0"
+proptest = "1.1.0"
+
+[dependencies]
+
+
+[[bench]]
+name = "vm"
+harness = false

linalg/activations/benches/vm.rs

@@ -0,0 +1,50 @@
+use activations::{definitions, reference, Program};
+use criterion::{black_box, criterion_group, criterion_main, BatchSize, BenchmarkId, Criterion};
+
+fn crit(c: &mut Criterion, name: &str, r: impl Fn(f32) -> f32, prog: &Program) {
+ let mut group = c.benchmark_group(name);
+ for size in [1i32, 32, 256, 1024, 8192].iter() {
+ group.throughput(criterion::Throughput::Elements(*size as u64));
+ group.bench_with_input(BenchmarkId::new("Reference", size), size, |b, size| {
+ b.iter_batched(
+ || vec![1.0f32; *size as usize],
+ |v| {
+ for x in v {
+ r(black_box(x));
+ }
+ },
+ BatchSize::LargeInput,
+ )
+ });
+ group.bench_with_input(BenchmarkId::new("VM", size), size, |b, size| {
+ b.iter_batched(
+ || vec![1.0f32; *size as usize],
+ |v| {
+ for x in v {
+ prog.compute(black_box(x));
+ }
+ },
+ BatchSize::LargeInput,
+ )
+ });
+ group.bench_with_input(BenchmarkId::new("VMVec", size), size, |b, size| {
+ b.iter_batched(
+ || vec![1.0f32; *size as usize],
+ |mut v| {
+ prog.compute_slice(black_box(&mut v));
+ },
+ BatchSize::LargeInput,
+ )
+ });
+ }
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+ crit(c, "relu", reference::relu, &definitions::relu());
+ crit(c, "hardswish", reference::hardswish, &definitions::hardswish());
+ crit(c, "exp2f", reference::exp2f, &definitions::exp2f());
+ crit(c, "sigmoid", reference::sigmoid, &definitions::sigmoid());
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

linalg/activations/src/definitions.rs

@@ -0,0 +1,164 @@
+
+use super::Op::*;
+use super::RegisterId::*;
+use super::*;
+
+pub fn relu() -> Program {
+ Program { ops: vec![MaxConst(0)], csts: vec![] }
+}
+
+pub fn affine(alpha: f32, beta: f32) -> Program {
+ Program {
+ #[rustfmt::skip]
+ ops: vec![
+ MulConst(2),
+ AddConst(3),
+ ],
+ csts: vec![alpha, beta],
+ }
+}
+
+pub fn leaky_relu(alpha: f32) -> Program {
+ Program {
+ #[rustfmt::skip]
+ ops: vec![
+ Move(B,A),
+ MulConst(2),
+ Move(C,A),
+ Move(A,B),
+ IfPosTE,
+ ],
+ csts: vec![alpha],
+ }
+}
+
+pub fn threshold_relu(alpha: f32) -> Program {
+ Program {
+ #[rustfmt::skip]
+ ops: vec![
+ Move(B,A),
+ SubConst(2),
+ Load(C,0),
+ IfPosTE,
+ ],
+ csts: vec![alpha],
+ }
+}
+
+pub fn softsign() -> Program {
+ Program {
+ #[rustfmt::skip]
+ ops: vec![
+ Move(B,A),
+ Abs,
+ AddConst(1),
+ Recip,
+ Mul,
+ ],
+ csts: vec![],
+ }
+}
+
+pub fn hardswish() -> Program {
+ Program {
+ #[rustfmt::skip]
+ ops: vec![
+ Move(B, A),
+ MulConst(2),
+ AddConst(3),
+ MinConst(1),
+ MaxConst(0),
+ Mul,
+ ],
+ csts: vec![1f32 / 6., 0.5],
+ }
+}
+
+pub fn sigmoid() -> Program {
+ Program {
+ #[rustfmt::skip]
+ ops: vec![
+ MinConst(3),
+ MaxConst(2),
+ Move(B, A), // b = x
+ Move(C, A), // c = x
+ Mul, // a = x2
+ Move(B, A), // b = x2
+ MulConst(4),
+ AddConst(5), // a = x2 * a13 + a11
+ FMA(6),
+ FMA(7),
+ FMA(8),
+ FMA(9),
+ FMA(10),
+ SwapBC, // c = x2, b = x
+ Mul, // a = p(x)
+ Move(B, C), // b = x2
+ Move(C, A), // c = p(x)
+ Move(A, B), // a = x2
+ MulConst(11),
+ AddConst(12),
+ FMA(13),
+ FMA(1), // a = q(x)
+ Recip,
+ Move(B,C), // b = p(x)
+ Mul,
+ AddConst(14)
+ ],
+ csts: vec![
+ -18.6, // const 2
+ 18.6, // const 3
+ -4.433153405e-18, // const 4, also alpha_13
+ 1.169974371e-14, // const 5, also a11
+ -1.875289645e-11,
+ 4.257889523e-8,
+ 0.00004811817576, // const 8
+ 0.008163842030,
+ 0.2499999971, // alpha_1
+ 3.922935744e-6, // beta_6
+ 0.001524872358, // const 12
+ 0.1159886749,
+ 0.5, //beta_0
+ ],
+ }
+}
+
+pub fn exp2f() -> Program {
+ Program {
+ #[rustfmt::skip]
+ ops: vec![
+ MinConst(2),
+ MaxConst(3),
+ Move(B, A), // b = x
+ AddConst(4), // a = x + 0.5
+ Floor, // a = ipart
+ Move(C, A), // c = ipart
+ Move(A, B), // a = x
+ Move(B, C), // b = ipart
+ Sub, // a = fpart
+ Move(B, A), // b = fpart
+ Load(A, 5), // a = exp2p[0]
+ FMA(6),
+ FMA(7),
+ FMA(8),
+ FMA(9),
+ FMA(10),
+ FMA(1), // a = y
+ Move(B, A),
+ Move(A, C),
+ TwoPowOfInt,
+ Mul
+ ],
+ csts: vec![
+ 127f32,
+ -127f32,
+ 0.5,
+ 1.535336188319500e-4,
+ 1.339887440266574e-3,
+ 9.618437357674640e-3,
+ 5.550332471162809e-2,
+ 2.402264791363012e-1,
+ 6.931472028550421e-1,
+ ],
+ }
+}