Always Run Extended Multiplication Benchmarks (#48)

Author: nlordell

bench/Cargo.toml

@@ -10,7 +10,6 @@ harness = false
 
 [features]
 llvm-intrinsics = ["ethnum/llvm-intrinsics"]
-extra-muls = []
 
 [dependencies]
 ethnum = { path = ".." }

bench/benches/num.rs

@@ -1,6 +1,6 @@
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 #[cfg(not(any(feature = "primitive-types", feature = "ruint")))]
-use ethnum::U256;
+use ethnum::{I256, U256};
 #[cfg(feature = "primitive-types")]
 use primitive_types::U256;
 #[cfg(feature = "ruint")]
@@ -40,17 +40,21 @@ fn arithmetic(c: &mut Criterion) {
             _ => "#",
         }
     };
-
-    #[allow(dead_code)]
-    fn name_fn(x: U256) -> String {
-        let n = x.leading_zeros() / 64;
-        match n {
-            0 => String::from("####"),
-            1 => String::from("###"),
-            2 => String::from("##"),
-            _ => String::from("#"),
+    #[cfg(not(any(feature = "primitive-types", feature = "ruint")))]
+    let iname = |x: I256| {
+        let neg = x.is_negative();
+        let n = x.abs().leading_zeros() / 64;
+        match (neg, n) {
+            (false, 0) => "####",
+            (false, 1) => "###",
+            (false, 2) => "##",
+            (false, _) => "#",
+            (true, 0) => "-####",
+            (true, 1) => "-###",
+            (true, 2) => "-##",
+            (true, _) => "-#",
         }
-    }
+    };
 
     c.bench_function("U256::add", |b| {
         b.iter(|| black_box(nums[0]) + black_box(nums[1]))
@@ -71,90 +75,53 @@ fn arithmetic(c: &mut Criterion) {
         );
     }
 
-    #[cfg(not(feature = "extra-muls"))]
     c.bench_function("U256::mul", |b| {
         b.iter(|| black_box(nums[3]) * black_box(nums[5]))
     });
 
-    #[cfg(not(any(feature = "primitive-types", feature = "extra-muls")))]
-    c.bench_function("U256::wrapping_mul", |b| {
-        b.iter(|| black_box(nums[0]).wrapping_mul(black_box(nums[1])))
-    });
+    for (x, y, tag) in [
+        (nums[0], nums[1], "overflow"),
+        (nums[3], nums[5], "no overflow"),
+        (nums[3], nums[4], "overflow"),
+        (nums[5], nums[3], "no overflow"),
+        (nums[4], nums[3], "overflow"),
+        (nums[6], nums[7], "no overflow"),
+    ] {
+        let name = format!("{}*{} ({})", name(x), name(y), tag);
 
-    #[cfg(feature = "extra-muls")]
-    {
-        fn get_name(
-            x1: U256,
-            y1: U256,
-            will_overflow1: bool,
-            x_sign: bool,
-            y_sign: bool,
-        ) -> String {
-            format!(
-                "{}{} * {}{} {}",
-                if x_sign { "-" } else { " " },
-                name_fn(x1),
-                if y_sign { "-" } else { " " },
-                name_fn(y1),
-                if will_overflow1 {
-                    "overflow"
-                } else {
-                    "no overflow"
-                }
-            )
-        }
-        for (x, y, will_overflow) in [
-            (nums[0], nums[1], true),
-            (nums[3], nums[5], false),
-            (nums[3], nums[4], true),
-            (nums[5], nums[3], false),
-            (nums[4], nums[3], true),
-            (nums[6], nums[7], false),
+        #[cfg(not(feature = "primitive-types"))]
+        c.bench_with_input(
+            BenchmarkId::new("U256::wrapping_mul", &name),
+            &(x, y),
+            |b, &(x, y)| b.iter(|| black_box(x).wrapping_mul(black_box(y))),
+        );
+
+        c.bench_with_input(
+            BenchmarkId::new("U256::overflowing_mul", &name),
+            &(x, y),
+            |b, &(x, y)| b.iter(|| black_box(x).overflowing_mul(black_box(y))),
+        );
+
+        #[cfg(not(any(feature = "primitive-types", feature = "ruint")))]
+        for (x, y) in [
+            (x.as_i256(), y.as_i256()),
+            (x.as_i256(), y.as_i256().wrapping_neg()),
+            (x.as_i256().wrapping_neg(), y.as_i256()),
+            (x.as_i256().wrapping_neg(), y.as_i256().wrapping_neg()),
         ] {
+            let name = format!("{}*{} ({})", iname(x), iname(y), tag);
+
             c.bench_with_input(
-                BenchmarkId::new(
-                    "U256::wrapping_mul",
-                    get_name(x, y, will_overflow, false, false),
-                ),
+                BenchmarkId::new("I256::wrapping_mul", &name),
                 &(x, y),
                 |b, &(x, y)| b.iter(|| black_box(x).wrapping_mul(black_box(y))),
             );
 
             c.bench_with_input(
-                BenchmarkId::new(
-                    "U256::overflowing_mul",
-                    get_name(x, y, will_overflow, false, false),
-                ),
+                BenchmarkId::new("I256::overflowing_mul", &name),
                 &(x, y),
                 |b, &(x, y)| b.iter(|| black_box(x).overflowing_mul(black_box(y))),
             );
-
-            for (x_sign, y_sign) in [(false, false), (false, true), (true, false), (true, true)] {
-                let signed_x = if x_sign { 0 - x.as_i256() } else { x.as_i256() };
-                let signed_y = if y_sign { 0 - y.as_i256() } else { y.as_i256() };
-
-                c.bench_with_input(
-                    BenchmarkId::new(
-                        "I256::wrapping_mul",
-                        get_name(x, y, will_overflow, x_sign, y_sign),
-                    ),
-                    &(signed_x, signed_y),
-                    |b, &(signed_x, signed_y)| {
-                        b.iter(|| black_box(signed_x).wrapping_mul(black_box(signed_y)))
-                    },
-                );
-
-                c.bench_with_input(
-                    BenchmarkId::new(
-                        "I256::overflowing_mul",
-                        get_name(x, y, will_overflow, x_sign, y_sign),
-                    ),
-                    &(signed_x, signed_y),
-                    |b, &(signed_x, signed_y)| {
-                        b.iter(|| black_box(signed_x).overflowing_mul(black_box(signed_y)))
-                    },
-                );
-            }
         }
     }