feat(tip5): Add AVX-512 version of Tip5

On machines that support it, and using conditional compilation, Tip5 can
be vectorized using AVX-512, which results in significant performance
improvements. Credit goes to the team at https://kompilers.com/

== How To ==

To build the new goodies, use:

RUSTFLAGS="-C target-feature=+avx512ifma,+avx512f,+avx512bw,+avx512vbmi"
cargo build

If you are compiling on a machine that has all the necessary features,
you can use the following instead:

RUSTFLAGS="-C target-cpu=native" cargo build

== Performance ==

You can expect the following raw performance gains:

```
hash_10
              time:   [336.29 ns 336.92 ns 337.72 ns]
              change: [−31.354% −31.251% −31.139%] (p = 0.00 < 0.05)
              Performance has improved.

hash_varlen/len/16384
              time:   [526.63 µs 527.02 µs 527.51 µs]
              change: [−32.321% −32.151% −32.017%] (p = 0.00 < 0.05)
              Performance has improved.

hash_parallel/len/65536
              time:   [2.0350 ms 2.0502 ms 2.0656 ms]
              change: [−10.764% −8.6165% −5.8573%] (p = 0.00 < 0.05)
              Performance has improved.
```

In addition, there are now specialized functions for SIMD hashing. Since
those functions didn't exist before, they cannot be compared quite as
easily. For example, we have `hash_varlen_many`:

```
hash_varlen_many/(len, N)/(16384, 2)
              time:   [783.82 µs 787.46 µs 791.45 µs]
```

This is a ~25% speedup over the already sped-up `hash_varlen` (794 μs vs
1054 μs = 2·527 μs). Note that using these new functions requires
changes in the calling code, whereas no changes are needed to get the
performance benefits of the functions that existed already.

All benchmarks performed on the machine known as megingjord.

== Gotchas ==

Note that rust is somewhat conservative when it comes to enabling
CPU-architecture specific features. In particular, even if you compile
this code on a CPU that has all the necessary AVX features, rust opts
to not enable them in anticipation of the binary being distributed.
Thus, you must pass `RUSTFLAGS="-C target-cpu=native"` to get access to
the vectorized version of Tip5. In the future, we can use dynamic
dispatch
(https://doc.rust-lang.org/std/arch/#dynamic-cpu-feature-detection)
instead, but these current changes don't include that.

Author: jan-ferdinand

.github/workflows/avx512.yml

@@ -0,0 +1,31 @@
+name: Build AVX-512
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  rust:
+    name: Build with AVX-512 features
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@1.90.0
+
+      - name: Build
+        run: cargo build
+        env:
+          RUSTFLAGS: "-C target-feature=+avx512ifma,+avx512f,+avx512bw,+avx512vbmi"
+
+          # This is necessary to pass the `RUSTFLAGS` only to the compiler
+          # invocation for the final artifact, but _not_ to previous compiler
+          # invocations, such as build scripts. See also:
+          # https://doc.rust-lang.org/cargo/reference/config.html#buildrustflags
+          CARGO_BUILD_TARGET: "x86_64-unknown-linux-gnu"

twenty-first/benches/tip5.rs

@@ -15,9 +15,16 @@ criterion_group!(
     config = Criterion::default().measurement_time(Duration::from_secs(8));
     targets =
         hash_10,
+        hash_10_x2,
+        hash_10_many::<2>,
+        hash_10_many::<200>,
         hash_pair,
         hash_varlen::<10>,
         hash_varlen::<16_384>,
+        hash_varlen_many::<10, 2>,
+        hash_varlen_many::<10, 200>,
+        hash_varlen_many::<16_384, 2>,
+        hash_varlen_many::<16_384, 200>,
         hash_parallel::<65_536>,
 );
 
@@ -26,6 +33,19 @@ fn hash_10(c: &mut Criterion) {
     c.bench_function("hash_10", |b| b.iter(|| Tip5::hash_10(&input)));
 }
 
+fn hash_10_x2(c: &mut Criterion) {
+    let [left, right] = random();
+    c.bench_function("hash_10_x2", |b| b.iter(|| Tip5::hash_10_x2(&left, &right)));
+}
+
+fn hash_10_many<const N: usize>(c: &mut Criterion) {
+    let elements = random::<[_; N]>();
+    c.benchmark_group("hash_10_many")
+        .bench_function(BenchmarkId::new("N", N), |b| {
+            b.iter(|| Tip5::hash_10_many(&elements))
+        });
+}
+
 fn hash_pair(c: &mut Criterion) {
     let (left, right) = random();
     c.bench_function("hash_pair", |b| b.iter(|| Tip5::hash_pair(left, right)));
@@ -39,6 +59,15 @@ fn hash_varlen<const LEN: usize>(c: &mut Criterion) {
         });
 }
 
+fn hash_varlen_many<const LEN: usize, const N: usize>(c: &mut Criterion) {
+    let input = (0..N).map(|_| random_elements(LEN)).collect::<Vec<_>>();
+    let input = input.iter().map(|row| row.as_slice()).collect::<Vec<_>>();
+    c.benchmark_group("hash_varlen_many")
+        .bench_function(BenchmarkId::new("(len, N)", format!("({LEN}, {N})")), |b| {
+            b.iter(|| Tip5::hash_varlen_many(&input))
+        });
+}
+
 fn hash_parallel<const LEN: usize>(c: &mut Criterion) {
     let input = (0..LEN).map(|_| random()).collect::<Vec<_>>();
     c.benchmark_group("hash_parallel")