Merge pull request #20 from itzmeanjan/do-not-depend-on-unstable-toolchain

Do not depend on the `unstable` Rust Toolchain

Author: itzmeanjan

.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = ["-C", "target-cpu=native"]

.github/workflows/rust.yml

@@ -2,21 +2,34 @@ name: TurboSHAKE
 
 on:
   push:
-    branches: [ "master" ]
+    branches: ["master"]
   pull_request:
-    branches: [ "master" ]
+    branches: ["master"]
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
   build:
-
-    runs-on: ubuntu-latest
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        # See https://docs.github.com/en/actions/writing-workflows/choosing-where-your-workflow-runs/choosing-the-runner-for-a-job#standard-github-hosted-runners
+        # for available targets.
+        os: [
+            ubuntu-latest, # x86-64
+            ubuntu-24.04-arm, # aarch64
+            macos-latest, # aarch64
+            macos-13, # x86_64
+            windows-latest, # x86-64
+          ]
 
     steps:
-    - uses: actions/checkout@v3
-    - name: Run tests
-      run: RUSTFLAGS="-C opt-level=3 -C target-cpu=native" cargo test --lib --features simdx2,simdx4
-    - name: Run examples
-      run: cargo run --example turboshake128 && cargo run --example turboshake256
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Build and Test on ${{ matrix.os }}
+        run: cargo test
+
+      - name: Run Example on ${{ matrix.os }}
+        run: cargo run --example turboshake128 && cargo run --example turboshake256

.rustfmt.toml

@@ -0,0 +1 @@
+max_width = 160

Cargo.toml

@@ -1,35 +1,28 @@
 [package]
 name = "turboshake"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
+resolver = "2"
+rust-version = "1.84.0"
 authors = ["Anjan Roy <[email protected]>"]
 description = "A family of extendable output functions based on keccak-p[1600, 12] permutation"
-documentation = "https://github.com/itzmeanjan/turboshake"
 readme = "README.md"
 repository = "https://github.com/itzmeanjan/turboshake.git"
 license = "MIT"
 keywords = ["cryptography", "keccak", "xof", "hashing", "turboshake"]
-categories = ["cryptography"]
+categories = ["cryptography", "algorithms"]
 
 [features]
 dev = []
-simdx2 = []
-simdx4 = []
 
 [dependencies]
-crunchy = "=0.2.2"
 
 [dev-dependencies]
-rand = "=0.8.5"
+rand = "=0.9.0"
+rand_chacha = "=0.9.0"
 hex = "=0.4.3"
-criterion = "=0.5.1"
-test-case = "=3.2.1"
-
-[target.'cfg(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64", target_arch = "loongarch64"))'.dev-dependencies]
-criterion-cycles-per-byte = "=0.6.0"
-
-[lib]
-bench = false
+test-case = "=3.3.1"
+divan = "=0.1.17"
 
 [[bench]]
 name = "keccak"
@@ -40,10 +33,8 @@ required-features = ["dev"]
 name = "turboshake"
 harness = false
 
-[[example]]
-name = "keccak"
-required-features = ["dev"]
-
-[[example]]
-name = "simd_keccak"
-required-features = ["dev", "simdx4"]
+[profile.optimized]
+inherits = "release"
+codegen-units = 1
+lto = "thin"
+panic = "abort"

README.md

@@ -1,164 +1,24 @@
-use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion, Throughput};
-use rand::{thread_rng, Rng};
+use divan;
+use divan::counter::{BytesCount, BytesFormat, ItemsCount};
+use rand::prelude::*;
+use rand_chacha::ChaCha8Rng;
 use turboshake::keccak;
 
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "aarch64",
-    target_arch = "loongarch64"
-))]
-use criterion_cycles_per_byte::CyclesPerByte;
-
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "aarch64",
-    target_arch = "loongarch64"
-))]
-type CriterionHandler = Criterion<CyclesPerByte>;
-
-#[cfg(not(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "aarch64",
-    target_arch = "loongarch64"
-)))]
-type CriterionHandler = Criterion;
-
-#[cfg(not(any(feature = "simdx2", feature = "simdx4")))]
-fn keccak(c: &mut CriterionHandler) {
-    let mut rng = thread_rng();
-
-    let mut group = c.benchmark_group("keccak");
-    group.throughput(Throughput::Bytes(200u64)); // size of keccak-p[1600] permutation state
-
-    group.bench_function("keccak-p[1600, 12] (cached)", |bench| {
-        let mut state = [0u64; 25];
-        rng.fill(&mut state);
-
-        bench.iter(|| keccak::permute(black_box(&mut state)))
-    });
-    group.bench_function("keccak-p[1600, 12] (random)", |bench| {
-        let mut state = [0u64; 25];
-        rng.fill(&mut state);
-
-        bench.iter_batched(
-            || state.clone(),
-            |mut state| keccak::permute(black_box(&mut state)),
-            BatchSize::SmallInput,
-        )
-    });
-
-    group.finish();
+fn main() {
+    divan::Divan::default().bytes_format(BytesFormat::Binary).run_benches();
 }
 
-#[cfg(any(feature = "simdx2", feature = "simdx4"))]
-fn keccak(c: &mut CriterionHandler) {
-    let mut rng = thread_rng();
-
-    let mut group = c.benchmark_group("keccak");
-
-    #[cfg(feature = "simdx2")]
-    {
-        group.throughput(Throughput::Bytes(200u64 * 2));
+#[divan::bench]
+fn permute_12_rounds(bencher: divan::Bencher) {
+    let mut rng = ChaCha8Rng::from_os_rng();
 
-        group.bench_function("keccak-p[1600, 12] x2 (cached)", |bench| {
-            let mut state0 = [0u64; 25];
-            let mut state1 = [0u64; 25];
-            rng.fill(&mut state0);
-            rng.fill(&mut state1);
+    let mut state = [0u64; 25];
+    let state_byte_len = state.len() * 8;
+    rng.fill(&mut state);
 
-            bench.iter(|| keccak::permutex2(black_box(&mut state0), black_box(&mut state1)));
-        });
-        group.bench_function("keccak-p[1600, 12] x2 (random)", |bench| {
-            let mut state0 = [0u64; 25];
-            let mut state1 = [0u64; 25];
-            rng.fill(&mut state0);
-            rng.fill(&mut state1);
-
-            bench.iter_batched(
-                || (state0.clone(), state1.clone()),
-                |(mut state0, mut state1)| {
-                    keccak::permutex2(black_box(&mut state0), black_box(&mut state1))
-                },
-                BatchSize::SmallInput,
-            )
-        });
-    }
-
-    #[cfg(feature = "simdx4")]
-    {
-        group.throughput(Throughput::Bytes(200u64 * 4));
-
-        group.bench_function("keccak-p[1600, 12] x4 (cached)", |bench| {
-            let mut state0 = [0u64; 25];
-            let mut state1 = [0u64; 25];
-            let mut state2 = [0u64; 25];
-            let mut state3 = [0u64; 25];
-            rng.fill(&mut state0);
-            rng.fill(&mut state1);
-            rng.fill(&mut state2);
-            rng.fill(&mut state3);
-
-            bench.iter(|| {
-                keccak::permutex4(
-                    black_box(&mut state0),
-                    black_box(&mut state1),
-                    black_box(&mut state2),
-                    black_box(&mut state3),
-                )
-            });
-        });
-        group.bench_function("keccak-p[1600, 12] x4 (random)", |bench| {
-            let mut state0 = [0u64; 25];
-            let mut state1 = [0u64; 25];
-            let mut state2 = [0u64; 25];
-            let mut state3 = [0u64; 25];
-            rng.fill(&mut state0);
-            rng.fill(&mut state1);
-            rng.fill(&mut state2);
-            rng.fill(&mut state3);
-
-            bench.iter_batched(
-                || {
-                    (
-                        state0.clone(),
-                        state1.clone(),
-                        state2.clone(),
-                        state3.clone(),
-                    )
-                },
-                |(mut state0, mut state1, mut state2, mut state3)| {
-                    keccak::permutex4(
-                        black_box(&mut state0),
-                        black_box(&mut state1),
-                        black_box(&mut state2),
-                        black_box(&mut state3),
-                    )
-                },
-                BatchSize::SmallInput,
-            )
-        });
-    }
-
-    group.finish();
+    bencher
+        .counter(BytesCount::new(state_byte_len))
+        .counter(ItemsCount::new(1usize))
+        .with_inputs(|| (state.clone()))
+        .bench_values(|mut state| keccak::permute(divan::black_box(&mut state)));
 }
-
-#[cfg(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "aarch64",
-    target_arch = "loongarch64"
-))]
-criterion_group!(name = permutation; config = Criterion::default().with_measurement(CyclesPerByte); targets = keccak);
-
-#[cfg(not(any(
-    target_arch = "x86_64",
-    target_arch = "x86",
-    target_arch = "aarch64",
-    target_arch = "loongarch64"
-)))]
-criterion_group!(permutation, keccak);
-
-criterion_main!(permutation);