crc-fast-rust: added fuzzing; fix the software memory leak; benched the software impl to validate the cache perf win

Author: loadingalias

.gitignore

@@ -5,3 +5,4 @@
 .DS_Store
 .git
 .vscode
+walkthrough.md

Cargo.toml

@@ -105,3 +105,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 name = "checksum_integration_tests"
 path = "tests/checksum_integration_tests.rs"
 required-features = ["cli"]
+
+[[bench]]
+name = "software_bench"
+harness = false

benches/software_bench.rs

@@ -0,0 +1,32 @@
+use crc_fast::{checksum_with_params, CrcAlgorithm, CrcKeysStorage, CrcParams};
+use criterion::{criterion_group, criterion_main, Criterion, Throughput};
+use std::hint::black_box;
+
+fn benchmark_custom_crc(c: &mut Criterion) {
+    let params = CrcParams {
+        algorithm: CrcAlgorithm::Crc32Custom,
+        name: "Custom",
+        width: 32,
+        poly: 0x04c11db7,
+        init: 0xffffffff,
+        refin: true,
+        refout: true,
+        xorout: 0xffffffff,
+        check: 0,
+        keys: CrcKeysStorage::KeysFold256([0; 23]),
+    };
+
+    let data = vec![0u8; 1024]; // 1KB
+
+    let mut group = c.benchmark_group("software_fallback");
+    group.throughput(Throughput::Bytes(data.len() as u64));
+
+    group.bench_function("custom_crc32_1kb", |b| {
+        b.iter(|| checksum_with_params(black_box(params), black_box(&data)))
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, benchmark_custom_crc);
+criterion_main!(benches);

fuzz/.gitignore

@@ -0,0 +1,4 @@
+target
+corpus
+artifacts
+coverage

fuzz/Cargo.lock

@@ -0,0 +1,22 @@
+[package]
+name = "crc-fast-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+crc = "3"
+
+[dependencies.crc-fast]
+path = ".."
+
+[[bin]]
+name = "compare_vs_crc"
+path = "fuzz_targets/compare_vs_crc.rs"
+test = false
+doc = false
+bench = false

fuzz/Cargo.toml

@@ -0,0 +1,118 @@
+#![no_main]
+use crc_fast::{CrcAlgorithm, Digest};
+use libfuzzer_sys::fuzz_target;
+
+fuzz_target!(|data: (u8, Vec<u8>)| {
+    let (algo_idx, bytes) = data;
+
+    // List of algorithms to test
+    let algorithms = [
+        CrcAlgorithm::Crc32Aixm,
+        CrcAlgorithm::Crc32Autosar,
+        CrcAlgorithm::Crc32Base91D,
+        CrcAlgorithm::Crc32Bzip2,
+        CrcAlgorithm::Crc32CdRomEdc,
+        CrcAlgorithm::Crc32Cksum,
+        CrcAlgorithm::Crc32Iscsi,
+        CrcAlgorithm::Crc32IsoHdlc,
+        CrcAlgorithm::Crc32Jamcrc,
+        CrcAlgorithm::Crc32Mef,
+        CrcAlgorithm::Crc32Mpeg2,
+        CrcAlgorithm::Crc32Xfer,
+        CrcAlgorithm::Crc64Ecma182,
+        CrcAlgorithm::Crc64GoIso,
+        CrcAlgorithm::Crc64Ms,
+        // CrcAlgorithm::Crc64Nvme, // Not in crc crate
+        CrcAlgorithm::Crc64Redis,
+        CrcAlgorithm::Crc64We,
+        CrcAlgorithm::Crc64Xz,
+    ];
+
+    if algorithms.is_empty() {
+        return;
+    }
+    let algo = algorithms[algo_idx as usize % algorithms.len()];
+
+    // Compute expected value using crc crate
+    let (expected, width) = match algo {
+        CrcAlgorithm::Crc32Aixm => (
+            crc::Crc::<u32>::new(&crc::CRC_32_AIXM).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Autosar => (
+            crc::Crc::<u32>::new(&crc::CRC_32_AUTOSAR).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Base91D => (
+            crc::Crc::<u32>::new(&crc::CRC_32_BASE91_D).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Bzip2 => (
+            crc::Crc::<u32>::new(&crc::CRC_32_BZIP2).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32CdRomEdc => (
+            crc::Crc::<u32>::new(&crc::CRC_32_CD_ROM_EDC).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Cksum => (
+            crc::Crc::<u32>::new(&crc::CRC_32_CKSUM).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Iscsi => (
+            crc::Crc::<u32>::new(&crc::CRC_32_ISCSI).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32IsoHdlc => (
+            crc::Crc::<u32>::new(&crc::CRC_32_ISO_HDLC).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Jamcrc => (
+            crc::Crc::<u32>::new(&crc::CRC_32_JAMCRC).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Mef => (
+            crc::Crc::<u32>::new(&crc::CRC_32_MEF).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Mpeg2 => (
+            crc::Crc::<u32>::new(&crc::CRC_32_MPEG_2).checksum(&bytes) as u64,
+            32,
+        ),
+        CrcAlgorithm::Crc32Xfer => (
+            crc::Crc::<u32>::new(&crc::CRC_32_XFER).checksum(&bytes) as u64,
+            32,
+        ),
+
+        CrcAlgorithm::Crc64Ecma182 => (
+            crc::Crc::<u64>::new(&crc::CRC_64_ECMA_182).checksum(&bytes),
+            64,
+        ),
+        CrcAlgorithm::Crc64GoIso => (
+            crc::Crc::<u64>::new(&crc::CRC_64_GO_ISO).checksum(&bytes),
+            64,
+        ),
+        CrcAlgorithm::Crc64Ms => (crc::Crc::<u64>::new(&crc::CRC_64_MS).checksum(&bytes), 64),
+        CrcAlgorithm::Crc64Redis => (
+            crc::Crc::<u64>::new(&crc::CRC_64_REDIS).checksum(&bytes),
+            64,
+        ),
+        CrcAlgorithm::Crc64We => (crc::Crc::<u64>::new(&crc::CRC_64_WE).checksum(&bytes), 64),
+        CrcAlgorithm::Crc64Xz => (crc::Crc::<u64>::new(&crc::CRC_64_XZ).checksum(&bytes), 64),
+
+        _ => return,
+    };
+
+    // Compute actual value using crc-fast
+    let mut digest = Digest::new(algo);
+    digest.update(&bytes);
+    let actual = digest.finalize();
+
+    assert_eq!(
+        actual,
+        expected,
+        "Mismatch for algorithm {:?} with input len {}",
+        algo,
+        bytes.len()
+    );
+});