simdsieve 0.1.1

SIMD-accelerated byte pattern pre-filtering with AVX-512, AVX2, NEON, and scalar fallback
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#![allow(
    clippy::cast_possible_truncation,
    clippy::cast_sign_loss,
    clippy::unreadable_literal,
    clippy::panic,
    clippy::manual_let_else
)]
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use simdsieve::SimdSieve;

#[test]
fn test_simd_adversarial_fuzzing_million_iterations_multi() {
    let mut rng = StdRng::seed_from_u64(0xDEADBEEF);

    for _ in 0..10_000 {
        let len = rng.gen_range(1..10000);
        let mut haystack = vec![0u8; len];
        rng.fill(&mut haystack[..]);

        let p1_len = rng.gen_range(1..=4);
        let p2_len = rng.gen_range(1..=4);
        let mut p1 = vec![0u8; p1_len];
        let mut p2 = vec![0u8; p2_len];
        rng.fill(&mut p1[..]);
        rng.fill(&mut p2[..]);

        let hw_sieve = SimdSieve::new(&haystack, &[&p1, &p2]).unwrap();
        let hw_results: Vec<usize> = hw_sieve.collect();

        // Baseline comparison using string finding logic
        let mut baseline: Vec<usize> = Vec::new();
        for i in 0..haystack.len() {
            let remain = &haystack[i..];
            if (remain.len() >= p1_len && &remain[..p1_len] == p1.as_slice())
                || (remain.len() >= p2_len && &remain[..p2_len] == p2.as_slice())
            {
                baseline.push(i);
            }
        }

        assert_eq!(
            hw_results, baseline,
            "CRITICAL DIVERGENCE in multi-pattern fastpath router."
        );
    }
}