Merge pull request #7 from wiseaidev/fix-perf

feat: refactor, add benchmark && unit tests, improve perf, use safe operations

Author: wiseaidev

.bumpversion.toml

@@ -0,0 +1,10 @@
+[bumpversion]
+current_version = 0.0.4
+
+[bumpversion:file:Cargo.toml]
+search = version = "{current_version}"
+replace = version = "{new_version}"
+
+[bumpversion:file:README.md]
+search = crc32-v2 = "{current_version}"
+replace = crc32-v2 = "{new_version}"

Cargo.toml

@@ -12,3 +12,12 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+
+[dev-dependencies]
+bump2version = "0.1.4"
+crc32fast = "1.4.2"
+criterion = { version = "0.5.1", features = ["html_reports"] }
+
+[[bench]]
+name = "benchmark"
+harness = false

README.md

@@ -1,5 +1,7 @@
 # CRC32
 
+> Fastest CRC32 Rust Implementation
+
 Resurrecting the [`crc32`](https://crates.io/crates/crc32) crate from the ashes.
 
 ### Usage
@@ -46,4 +48,71 @@ fn main() {
 
 // CRC-32: ebe6c6e6
 // CRC-32 (Little Endian): a29eb9bf
-```
+```
+
+### Benchmark
+
+Running `cargo bench` provides the following performance insights:
+
+<details>
+<summary><code>cargo bench</code></summary>
+
+```sh
+cargo bench
+
+   Compiling crc32-v2 v0.0.4 (/home/mahmoud/Desktop/TODO/crc32-v2)
+    Finished `bench` profile [optimized] target(s) in 2.06s
+     Running unittests src/lib.rs (target/release/deps/crc32_v2-3c56bd9cac40bc4d)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running benches/benchmark.rs (target/release/deps/benchmark-f87f05a33c0b9723)
+Benchmarking `crc32-v2` crc32_while_loop(0, b"hello") performance:: Warming up fBenchmarking `crc32-v2` crc32_while_loop(0, b"hello") performance:: Collecting 1`crc32-v2` crc32_while_loop(0, b"hello") performance:
+                        time:   [6.6916 ns 6.7111 ns 6.7306 ns]
+                        change: [-6.2932% -5.1894% -3.8925%] (p = 0.00 < 0.05)
+                        Performance has improved.
+Found 14 outliers among 100 measurements (14.00%)
+  7 (7.00%) low mild
+  2 (2.00%) high mild
+  5 (5.00%) high severe
+
+Benchmarking `crc32-v2` crc32_for_loop(0, b"hello") performance:: Warming up forBenchmarking `crc32-v2` crc32_for_loop(0, b"hello") performance:: Collecting 100`crc32-v2` crc32_for_loop(0, b"hello") performance:
+                        time:   [6.7552 ns 6.7719 ns 6.7884 ns]
+                        change: [-16.025% -12.793% -9.5779%] (p = 0.00 < 0.05)
+                        Performance has improved.
+Found 4 outliers among 100 measurements (4.00%)
+  1 (1.00%) high mild
+  3 (3.00%) high severe
+
+Benchmarking `crc32fast` crc32fast::hash(b"hello") performance:: Warming up for Benchmarking `crc32fast` crc32fast::hash(b"hello") performance:: Collecting 100 `crc32fast` crc32fast::hash(b"hello") performance:
+                        time:   [8.4118 ns 8.4320 ns 8.4522 ns]
+                        change: [-9.0567% -7.0970% -5.3253%] (p = 0.00 < 0.05)
+                        Performance has improved.
+Found 4 outliers among 100 measurements (4.00%)
+  4 (4.00%) high severe
+
+Benchmarking `crc32fast` crc32fast::Hasher::new().update(b"hello").finalize() peBenchmarking `crc32fast` crc32fast::Hasher::new().update(b"hello").finalize() peBenchmarking `crc32fast` crc32fast::Hasher::new().update(b"hello").finalize() peBenchmarking `crc32fast` crc32fast::Hasher::new().update(b"hello").finalize() pe`crc32fast` crc32fast::Hasher::new().update(b"hello").finalize() performance:
+                        time:   [21.334 ns 21.379 ns 21.419 ns]
+                        change: [-6.8627% -5.2041% -3.7228%] (p = 0.00 < 0.05)
+                        Performance has improved.
+Found 5 outliers among 100 measurements (5.00%)
+  2 (2.00%) high mild
+  3 (3.00%) high severe
+```
+
+</details>
+
+Below is a summarized table of results, highlighting the execution times for each method:
+
+| **Method**                                     | **Mean Time (ns)** | **Outliers (%)** | **Description**                                |
+|-----------------------------------------------|---------------------|-------------------|------------------------------------------------|
+| `crc32_v2_while_loop(0, b"hello")`               | 6.71               |    14.00%           | CRC32-V2 built-in function using a while loop, optimized.   |
+| `crc32_v2_for_loop(0, b"hello")`                 | 6.77               |    4.00%            | Custom CRC32-V2 using a for loop, optimized.     |
+| `crc32fast::hash(b"hello")`                   | 8.43               |    4.00%            | crc32fast built-in hashing method.                |
+| `crc32fast::Hasher::new().update(b"hello").finalize()`   | 21.38              |    5.00%            | Hasher object approach, slower initialization.|
+
+1. **Fastest Method**: The built-in `crc32_v2_while_loop` implementation shows the best performance, slightly outperforming the `crc32_for_loop`.
+1. **crc32fast Performance**: The `crc32fast::hash` method is slightly slower than the `crc32-v2` implementation.
+1. **Hasher Object Method**: The `crc32fast::Hasher` object approach is significantly slower for some reason.

benches/benchmark.rs

@@ -0,0 +1,77 @@
+use crc32_v2::crc32tables::CRC_TABLE;
+use crc32fast::Hasher;
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+#[inline]
+pub fn crc32_while_loop(start_crc: u32, buf: &[u8]) -> u32 {
+    // Initialize variables
+    let len = buf.len();
+    let mut crc = start_crc;
+    let mut bufpos: usize = 0;
+    let mut remaining_bytes = len;
+
+    // XOR with 0xffffffff as specified in CRC32 algorithm
+    crc = crc ^ 0xffffffff;
+
+    // Reference to the first CRC table for faster access
+    let t0 = &CRC_TABLE[0];
+
+    // Process each byte in the buffer
+    while remaining_bytes > 0 {
+        let b = buf[bufpos];
+        let b32 = b as u32;
+        let b_index = (crc ^ b32) & 0xff;
+        let t = t0[b_index as usize];
+        crc = t ^ (crc >> 8);
+        bufpos += 1;
+        remaining_bytes -= 1;
+    }
+
+    // XOR again with 0xffffffff as specified in CRC32 algorithm
+    crc ^ 0xffffffff
+}
+
+#[inline]
+pub fn crc32_for_loop(start_crc: u32, buf: &[u8]) -> u32 {
+    // XOR with 0xffffffff as specified in the CRC32 algorithm
+    let mut crc = start_crc ^ 0xffffffff;
+
+    // Reference to the first CRC table for faster access
+    let t0 = &CRC_TABLE[0];
+
+    // Process each byte in the buffer
+    for &byte in buf {
+        let b_index = (crc ^ (byte as u32)) & 0xff;
+        crc = t0[b_index as usize] ^ (crc >> 8);
+    }
+
+    crc ^ 0xffffffff
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    c.bench_function(
+        "`crc32-v2` crc32_while_loop(0, b\"hello\") performance:",
+        |b| b.iter(|| crc32_while_loop(black_box(0), black_box(b"hello"))),
+    );
+    c.bench_function(
+        "`crc32-v2` crc32_for_loop(0, b\"hello\") performance:",
+        |b| b.iter(|| crc32_for_loop(black_box(0), black_box(b"hello"))),
+    );
+    c.bench_function(
+        "`crc32fast` crc32fast::hash(b\"hello\") performance:",
+        |b| b.iter(|| crc32fast::hash(black_box(b"hello"))),
+    );
+    c.bench_function(
+        "`crc32fast` crc32fast::Hasher::new().update(b\"hello\").finalize() performance:",
+        |b| {
+            b.iter(|| {
+                let mut hasher = black_box(Hasher::new());
+                hasher.update(black_box(b"foo bar baz"));
+                let _checksum = hasher.finalize();
+            })
+        },
+    );
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

build.rs

@@ -15,7 +15,7 @@ fn main() {
 
     let outpath = Path::new(outfile_name);
 
-    let outfile = File::create(&outpath);
+    let outfile = File::create(outpath);
 
     match outfile {
         Ok(file) => {

src/byfour.rs

@@ -46,14 +46,9 @@ pub fn dolit4(c: &mut u32, buf4: &[u32], buf4pos: &mut usize) {
 /// assert_eq!(crc, 0);
 /// ```
 pub fn dolit32(c: &mut u32, buf4: &[u32], buf4pos: &mut usize) {
-    dolit4(c, buf4, buf4pos);
-    dolit4(c, buf4, buf4pos);
-    dolit4(c, buf4, buf4pos);
-    dolit4(c, buf4, buf4pos);
-    dolit4(c, buf4, buf4pos);
-    dolit4(c, buf4, buf4pos);
-    dolit4(c, buf4, buf4pos);
-    dolit4(c, buf4, buf4pos);
+    for _ in 0..8 {
+        dolit4(c, buf4, buf4pos);
+    }
 }
 
 /// This function converts a slice of u8 into a slice of u32.
@@ -75,11 +70,13 @@ pub fn dolit32(c: &mut u32, buf4: &[u32], buf4pos: &mut usize) {
 /// let u32_slice = slice_u8_as_u32(&bytes);
 /// assert_eq!(u32_slice, &[50462976u32, 117835012u32]);
 /// ```
-pub fn slice_u8_as_u32(s8: &[u8]) -> &[u32] {
-    let len_u32 = s8.len() / 4;
-    let ptr: *const u32 = s8.as_ptr() as *const u32;
-
-    unsafe { std::slice::from_raw_parts(ptr, len_u32) }
+pub fn slice_u8_as_u32(s8: &[u8]) -> Vec<u32> {
+    s8.chunks_exact(4)
+        .map(|chunk| {
+            // Convert 4-bytes chunks into a u32 value
+            u32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]])
+        })
+        .collect()
 }
 
 /// This function calculates the CRC32 checksum of a byte buffer in little-endian format.
@@ -118,11 +115,11 @@ pub fn crc32_little(crc: u32, buf: &[u8]) -> u32 {
     let buf4 = slice_u8_as_u32(&buf[bufpos..]);
     let mut buf4pos: usize = 0;
     while len >= 32 {
-        dolit32(&mut c, buf4, &mut buf4pos);
+        dolit32(&mut c, &buf4, &mut buf4pos);
         len -= 32;
     }
     while len >= 4 {
-        dolit4(&mut c, buf4, &mut buf4pos);
+        dolit4(&mut c, &buf4, &mut buf4pos);
         len -= 4;
     }
 
@@ -142,6 +139,5 @@ pub fn crc32_little(crc: u32, buf: &[u8]) -> u32 {
             }
         }
     }
-    c = !c;
-    return c;
+    !c
 }

src/crc32gen.rs

@@ -91,9 +91,9 @@ pub fn write_tables(crc_table: &CrcTable) -> String {
     write_table(&mut s, &tt[0]);
     // #  ifdef BYFOUR
     s.push_str("// #ifdef BYFOUR\n");
-    for k in 1..8 {
+    for item in tt.iter().take(8).skip(1) {
         s.push_str("  ],\n [\n");
-        write_table(&mut s, &tt[k]);
+        write_table(&mut s, item);
     }
     s.push_str("// #endif\n");
     // #  endif /* BYFOUR */
@@ -103,11 +103,11 @@ pub fn write_tables(crc_table: &CrcTable) -> String {
 }
 
 fn write_table(s: &mut String, table: &[u32; 0x100]) {
-    for n in 0..0x100 {
+    for (n, item) in table.iter().enumerate().take(0x100) {
         let line = format!(
             "{}0x{:08x}{}",
             if n % 5 != 0 { "" } else { "    " },
-            table[n],
+            item,
             if n == 255 {
                 "\n"
             } else if n % 5 == 4 {