Benchmark quire add in vs_external (results preliminary!)

Author: andrepd

benches/vs_external/cerlane_softposit.rs

@@ -12,6 +12,11 @@ pub struct posit32_t { v: u32 }
 #[derive(Clone, Copy)]
 pub struct posit64_t { v: u64 }
 
+#[repr(C)]
+#[derive(Clone, Copy)]
+#[derive(Default)]
+pub struct quire32_t { v: [u64; 8] }
+
 #[link(name = "softposit")]
 unsafe extern "C" {
   pub fn p32_add(x: posit32_t, y: posit32_t) -> posit32_t;
@@ -25,6 +30,14 @@ unsafe extern "C" {
 
   pub fn p32_sqrt(x: posit32_t) -> posit32_t;
   // pub fn p64_sqrt(x: posit64_t) -> posit64_t;
+
+  fn q32_fdp_add(q: quire32_t, x: posit32_t, y: posit32_t) -> quire32_t;
+}
+
+#[inline]
+pub unsafe fn q32_add(q: quire32_t, x: posit32_t) -> quire32_t {
+  let unit = posit32_t::from(p32::ONE);
+  unsafe { q32_fdp_add(q, x, unit) }
 }
 
 impl From<p32> for posit32_t { fn from(x: p32) -> Self { posit32_t { v: x.to_bits() as u32 } } }

benches/vs_external/main.rs

@@ -10,7 +10,7 @@
 //!   - https://github.com/stillwater-sc/universal/
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
-use fast_posit::{p32, p64};
+use fast_posit::{p32, p64, q32};
 
 //
 
@@ -74,6 +74,23 @@ fn bench_1ary<T: Copy, U: From<T>>(
   }));
 }
 
+/// Benchmark a 1-arg function that accumulates into another type.
+fn bench_1ary_accumulate<T: Copy, A: Clone, U: From<T>>(
+  g: &mut criterion::BenchmarkGroup<'_, criterion::measurement::WallTime>,
+  name: &str,
+  initial: A,
+  data: &[T],
+  mut f: impl FnMut(&mut A, U),
+) {
+  g.throughput(Throughput::Elements(data.len() as u64));
+  g.bench_function(name, |b| b.iter(|| {
+    let mut accum = black_box(initial.clone());
+    for &x in data {
+      let _ = black_box(f(&mut accum, black_box(U::from(x))));
+    }
+  }));
+}
+
 //
 
 /// Benchmark this number of operations
@@ -169,7 +186,7 @@ fn add_64(c: &mut Criterion) {
   bench_2ary(&mut g, "berkeley-softfloat", &data_float, |x, y| unsafe { berkeley_softfloat::f64_add(x, y) });
 
   /*#[cfg(feature = "cerlane-softposit")]
-  let _ = bench_2ary(&mut g, "cerlane-softposit", &data_posit, |x, y| unsafe { cerlane_softposit::p64_add(x, y) };*/
+  bench_2ary(&mut g, "cerlane-softposit", &data_posit, |x, y| unsafe { cerlane_softposit::p64_add(x, y) };*/
 
   #[cfg(feature = "stillwater-softposit")]
   bench_2ary(&mut g, "stillwater-softposit", &data_posit, |x, y| unsafe { stillwater_softposit::posit64_addp64(x, y) });
@@ -189,7 +206,7 @@ fn mul_64(c: &mut Criterion) {
   bench_2ary(&mut g, "berkeley-softfloat", &data_float, |x, y| unsafe { berkeley_softfloat::f64_mul(x, y) });
 
   /*#[cfg(feature = "cerlane-softposit")]
-  let _ = bench_2ary(&mut g, "cerlane-softposit", &data_posit, |x, y| unsafe { cerlane_softposit::p64_mul(x, y) };*/
+  bench_2ary(&mut g, "cerlane-softposit", &data_posit, |x, y| unsafe { cerlane_softposit::p64_mul(x, y) };*/
 
   #[cfg(feature = "stillwater-softposit")]
   bench_2ary(&mut g, "stillwater-softposit", &data_posit, |x, y| unsafe { stillwater_softposit::posit64_mulp64(x, y) });
@@ -209,7 +226,7 @@ fn div_64(c: &mut Criterion) {
   bench_2ary(&mut g, "berkeley-softfloat", &data_float, |x, y| unsafe { berkeley_softfloat::f64_div(x, y) });
 
   /*#[cfg(feature = "cerlane-softposit")]
-  let _ = bench_2ary(&mut g, "cerlane-softposit", &data_posit, |x, y| unsafe { cerlane_softposit::p64_div(x, y) };*/
+  bench_2ary(&mut g, "cerlane-softposit", &data_posit, |x, y| unsafe { cerlane_softposit::p64_div(x, y) };*/
 
   #[cfg(feature = "stillwater-softposit")]
   bench_2ary(&mut g, "stillwater-softposit", &data_posit, |x, y| unsafe { stillwater_softposit::posit64_divp64(x, y) });
@@ -229,7 +246,7 @@ fn sqrt_64(c: &mut Criterion) {
   bench_1ary(&mut g, "berkeley-softfloat", &data_float, |x| unsafe { berkeley_softfloat::f64_sqrt(x) });
 
   /*#[cfg(feature = "cerlane-softposit")]
-  let _ = bench_1ary(&mut g, "cerlane-softposit", &data_posit, |x| unsafe { cerlane_softposit::p64_sqrt(x) });*/
+  bench_1ary(&mut g, "cerlane-softposit", &data_posit, |x| unsafe { cerlane_softposit::p64_sqrt(x) });*/
 
   #[cfg(feature = "stillwater-softposit")]
   bench_1ary(&mut g, "stillwater-softposit", &data_posit, |x| unsafe { stillwater_softposit::posit64_sqrt(x) });
@@ -239,6 +256,32 @@ fn sqrt_64(c: &mut Criterion) {
   g.finish();
 }
 
+/// Generate arrays of random posits and benchmark our impl and external impls in summing them all
+/// into a quire.
+fn quire_add_32(c: &mut Criterion) {
+  let (data_posit, _) = make_data_32(LEN);
+  let mut g = c.benchmark_group("quire_add_32");
+
+  #[cfg(feature = "cerlane-softposit")]
+  bench_1ary_accumulate(
+    &mut g,
+    "cerlane-softposit",
+    cerlane_softposit::quire32_t::default(),
+    &data_posit,
+    |q, x| unsafe { *q = cerlane_softposit::q32_add(*q, x) },
+  );
+
+  bench_1ary_accumulate(
+    &mut g,
+    "posit",
+    q32::ZERO,
+    &data_posit,
+    |q: &mut q32, x: p32| *q += x,
+  );
+
+  g.finish();
+}
+
 criterion_group!(add,
   add_32,
   add_64,
@@ -259,4 +302,8 @@ criterion_group!(sqrt,
   sqrt_64,
 );
 
-criterion_main!(add, mul, div, sqrt);
+criterion_group!(quire,
+  quire_add_32,
+);
+
+criterion_main!(add, mul, div, sqrt, quire);