Add MD5 benchmark

Author: ictrobot

crates/utils/Cargo.toml

@@ -15,3 +15,7 @@ wasm-multithreading = ["unsafe"]
 
 [lints]
 workspace = true
+
+[[bench]]
+name = "md5"
+harness = false

crates/utils/benches/md5.rs

@@ -0,0 +1,69 @@
+use std::env::args;
+use std::hint::black_box;
+use std::io::Write;
+use std::time::{Duration, Instant};
+use utils::multiversion_test;
+
+#[expect(clippy::print_stdout)]
+fn main() {
+    let mut block_sizes = args()
+        .skip(1)
+        .filter(|x| x != "--bench")
+        .map(|x| x.parse())
+        .collect::<Result<Vec<usize>, _>>()
+        .expect("invalid block size(s)");
+    if block_sizes.is_empty() {
+        block_sizes.extend([16, 64, 256, 1024, 4096, 16384]);
+    }
+    block_sizes.sort_unstable();
+    let max_block_size = block_sizes.last().unwrap();
+
+    println!("               │ MD5 throughput (MiB/s) by block size (B)");
+    print!("              ");
+    for &length in &block_sizes {
+        print!(" │ {length:<6}");
+    }
+    println!();
+    print!("───────────────");
+    for _ in &block_sizes {
+        print!("┼────────");
+    }
+    println!();
+
+    multiversion_test! {
+        use {utils::simd::*, utils::md5::*};
+
+        {
+            print!("{SIMD_BACKEND:9}  {:3}", U32Vector::LANES);
+
+            #[expect(clippy::cast_possible_truncation)]
+            let input = (0..(max_block_size * U32Vector::LANES))
+                .map(|x| x as u8)
+                .collect::<Vec<_>>();
+
+            for &block_size in &block_sizes {
+                let input = &input[..block_size * U32Vector::LANES];
+
+                let start = Instant::now();
+                let mut iterations = 0;
+                let bytes_sec = loop {
+                    for _ in 0..1000 {
+                        let _ = black_box(hash(black_box(input)));
+                        iterations += 1;
+                    }
+
+                    let elapsed = start.elapsed();
+                    if elapsed > Duration::from_secs(1) {
+                        #[expect(clippy::cast_precision_loss)]
+                        break (iterations * input.len()) as f64 / elapsed.as_secs_f64();
+                    }
+                };
+
+                print!(" │ {:6.0}", (bytes_sec / 1024.0 / 1024.0).round());
+                let _ = std::io::stdout().flush();
+            }
+
+            println!()
+        }
+    }
+}

crates/utils/src/multiversion.rs

@@ -45,7 +45,8 @@ use std::sync::{LazyLock, OnceLock};
 /// attribute, which requires functions to be marked as unsafe. A safe fallback version will always
 /// be generated.
 ///
-/// See [`crate::md5`] as an example.
+/// See [`crate::md5`] as an example. [`multiversion_test!`](crate::multiversion_test!) can be used
+/// for testing multiversioned libraries.
 #[macro_export]
 macro_rules! multiversion {
     // One dynamic dispatch function, optionally with extra helper functions.
@@ -223,11 +224,17 @@ macro_rules! multiversion {
     (@helper $t:meta $(#[$m:meta])* $v:vis fn $n:ident $t0:tt $t1:tt $t2:tt $t3:tt $t4:tt $t5:tt $t6:tt $t7:tt $t8:tt $t9:tt $t10:tt $t11:tt $t12:tt $t13:tt $t14:tt $t15:tt $t16:tt $t17:tt $t18:tt $t19:tt $t20:tt $t21:tt $t22:tt $t23:tt $t24:tt $t25:tt $t26:tt $t27:tt $t28:tt $t29:tt $t30:tt $t31:tt $b:block $($tail:tt)*) => {$(#[$m])* #[$t] $v unsafe fn $n $t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $t8 $t9 $t10 $t11 $t12 $t13 $t14 $t15 $t16 $t17 $t18 $t19 $t20 $t21 $t22 $t23 $t24 $t25 $t26 $t27 $t28 $t29 $t30 $t31 { #[allow(clippy::allow_attributes, clippy::macro_metavars_in_unsafe, unused_unsafe)] unsafe { $b } } $crate::multiversion!{@helper $t $($tail)*}};
 }
 
-/// Helper for testing [`multiversion!`] library functions.
+/// Helper for testing and benchmarking [`multiversion!`] library functions.
 ///
-/// `#[target_feature(...)]` isn't applied to the test functions as the feature-specific code should
+/// The first rule is for testing and creates individual
+/// [`#[test]`](https://doc.rust-lang.org/reference/attributes/testing.html) functions for each
+/// implementation.
+///
+/// The second rule is more general, duplicating the same expression for each implementation and
+/// is useful for benchmarking.
+///
+/// `#[target_feature(...)]` isn't applied to the test code as the feature-specific code should
 /// be elsewhere, inside a [`multiversion!`] macro.
-#[cfg(test)]
 #[macro_export]
 macro_rules! multiversion_test {
     (
@@ -286,7 +293,7 @@ macro_rules! multiversion_test {
             #[allow(clippy::allow_attributes, unused_imports, clippy::wildcard_imports)]
             use {$($($path::)+avx2::*),*};
 
-            if !std::arch::is_x86_feature_detected!("avx2") {
+            if !$crate::multiversion::Version::AVX2.supported() {
                 use std::io::{stdout, Write};
                 let _ = writeln!(&mut stdout(), "warning: skipping test in {}::avx2 due to missing avx2 support", module_path!());
                 return;
@@ -295,6 +302,59 @@ macro_rules! multiversion_test {
             unsafe { $body }
         }
     };
+
+    (
+        use {$($($path:ident::)+*),*};
+
+        { $($tail:tt)+ }
+    ) => {
+        #[allow(
+            clippy::reversed_empty_ranges,
+            clippy::range_plus_one,
+            clippy::modulo_one,
+            clippy::trivially_copy_pass_by_ref
+        )]
+        {
+            #[allow(clippy::allow_attributes, unused_imports, clippy::wildcard_imports)]
+            use {$($($path::)+scalar::*),*};
+
+            $crate::multiversion_test!(@expr { $($tail)+ });
+        }
+
+        {
+            #[allow(clippy::allow_attributes, unused_imports, clippy::wildcard_imports)]
+            use {$($($path::)+array128::*),*};
+
+            $crate::multiversion_test!(@expr { $($tail)+ });
+        }
+
+        {
+            #[allow(clippy::allow_attributes, unused_imports, clippy::wildcard_imports)]
+            use {$($($path::)+array256::*),*};
+
+            $crate::multiversion_test!(@expr { $($tail)+ });
+        }
+
+        #[cfg(not(target_family = "wasm"))]
+        #[allow(clippy::large_types_passed_by_value)]
+        {
+            #[allow(clippy::allow_attributes, unused_imports, clippy::wildcard_imports)]
+            use {$($($path::)+array4096::*),*};
+
+            $crate::multiversion_test!(@expr { $($tail)+ });
+        }
+
+        #[cfg(all(feature="unsafe", any(target_arch = "x86", target_arch = "x86_64")))]
+        if $crate::multiversion::Version::AVX2.supported() {
+            unsafe {
+                #[allow(clippy::allow_attributes, unused_imports, clippy::wildcard_imports)]
+                use {$($($path::)+avx2::*),*};
+
+                $crate::multiversion_test!(@expr { $($tail)+ });
+            }
+        }
+    };
+    (@expr $e:expr) => { $e }
 }
 
 macro_rules! versions_impl {

crates/utils/src/simd/array.rs

@@ -96,18 +96,27 @@ impl<const N: usize> U32Vector<N> {
 
 /// 128-bit wide vector implementations using arrays.
 pub mod array128 {
+    /// The name of this backend.
+    pub const SIMD_BACKEND: &str = "array128";
+
     /// Array vector with four [u32] lanes.
     pub type U32Vector = super::U32Vector<4>;
 }
 
 /// 256-bit wide vector implementations using arrays.
 pub mod array256 {
+    /// The name of this backend.
+    pub const SIMD_BACKEND: &str = "array256";
+
     /// Array vector with eight [u32] lanes.
     pub type U32Vector = super::U32Vector<8>;
 }
 
 /// 4096-bit wide vector implementations using arrays.
 pub mod array4096 {
+    /// The name of this backend.
+    pub const SIMD_BACKEND: &str = "array4096";
+
     /// Array vector with 128 [u32] lanes.
     pub type U32Vector = super::U32Vector<128>;
 }

crates/utils/src/simd/avx2.rs

@@ -10,6 +10,9 @@ use std::arch::x86_64::*;
 #[allow(clippy::allow_attributes, clippy::wildcard_imports)]
 use std::arch::x86::*;
 
+/// The name of this backend.
+pub const SIMD_BACKEND: &str = "avx2";
+
 /// AVX2 vector with eight [u32] lanes.
 #[derive(Clone, Copy)]
 #[repr(transparent)]

crates/utils/src/simd/scalar.rs

@@ -5,6 +5,9 @@
 
 use std::ops::{Add, BitAnd, BitOr, BitXor, Not};
 
+/// The name of this backend.
+pub const SIMD_BACKEND: &str = "scalar";
+
 /// Scalar vector with a single [u32] lane.
 #[derive(Clone, Copy)]
 #[repr(transparent)]