Update benchmarks to use different needle and haystack sizes

Author: zakcutner

benches/avx2_anysize.rs

@@ -1,276 +1,118 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 use memmem::{Searcher, TwoWaySearcher};
-use std::fs::File;
-use std::io::{self, BufRead, Read};
+use std::str;
 use strstr::avx2::*;
 
 fn criterion_benchmark(c: &mut Criterion) {
-    let mut f = File::open("./data/i386.txt").unwrap();
-    let mut buffer = Vec::new();
-    f.read_to_end(&mut buffer).unwrap();
-    let content = String::from_utf8_lossy(&buffer);
-
-    let file = File::open("./data/words").unwrap();
-    let mut words: Vec<String> = io::BufReader::new(file)
-        .lines()
-        .filter_map(|line| line.ok())
-        .filter(|word| word.len() > 1)
-        .collect();
-    // Sort all words by length then lexicographically
-    words.sort_by(|a, b| {
-        if a.len() != b.len() {
-            a.len().partial_cmp(&b.len()).unwrap()
-        } else {
-            a.partial_cmp(b).unwrap()
+    let haystack = include_bytes!("../data/haystack");
+    let needle = include_bytes!("../data/needle");
+
+    let sizes = [1, 5, 10, 20, 50, 100, 1000];
+
+    for (i, &size) in sizes.iter().enumerate() {
+        let mut group = c.benchmark_group(format!("{}-byte needle", size));
+        let needle = &needle[..size];
+
+        for &size in &sizes[i..] {
+            let parameter = &format!("{}-byte haystack", size);
+            let haystack = &haystack[..size];
+
+            group.bench_with_input(
+                BenchmarkId::new("String::find", parameter),
+                &size,
+                |b, _| {
+                    let haystack = str::from_utf8(haystack).unwrap();
+                    let needle = str::from_utf8(needle).unwrap();
+                    b.iter(|| haystack.find(needle));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("TwoWaySearcher::search_in", parameter),
+                &size,
+                |b, _| {
+                    let searcher = TwoWaySearcher::new(needle);
+                    b.iter(|| black_box(searcher.search_in(haystack)));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("twoway::find_bytes", parameter),
+                &size,
+                |b, _| {
+                    b.iter(|| black_box(twoway::find_bytes(haystack, needle)));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("strstr_avx2_original", parameter),
+                &size,
+                |b, _| {
+                    b.iter(|| black_box(unsafe { strstr_avx2_original(haystack, needle) }));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("strstr_avx2_rust_simple", parameter),
+                &size,
+                |b, _| {
+                    b.iter(|| black_box(unsafe { strstr_avx2_rust_simple(haystack, needle) }));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("strstr_avx2_rust_simple_2", parameter),
+                &size,
+                |b, _| {
+                    b.iter(|| black_box(unsafe { strstr_avx2_rust_simple_2(haystack, needle) }));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("strstr_avx2_rust_fast", parameter),
+                &size,
+                |b, _| {
+                    b.iter(|| black_box(unsafe { strstr_avx2_rust_fast(haystack, needle) }));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("strstr_avx2_rust_fast_2", parameter),
+                &size,
+                |b, _| {
+                    b.iter(|| black_box(strstr_avx2_rust_fast_2(haystack, needle)));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("strstr_avx2_rust_aligned", parameter),
+                &size,
+                |b, _| {
+                    b.iter(|| black_box(unsafe { strstr_avx2_rust_aligned(haystack, needle) }));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("StrStrAVX2Searcher::search_in", parameter),
+                &size,
+                |b, _| {
+                    let searcher = StrStrAVX2Searcher::new(needle);
+                    b.iter(|| black_box(searcher.search_in(haystack)));
+                },
+            );
+
+            group.bench_with_input(
+                BenchmarkId::new("DynamicAvx2Searcher::search_in", parameter),
+                &size,
+                |b, _| {
+                    let searcher = DynamicAvx2Searcher::new(needle.to_owned().into_boxed_slice());
+                    b.iter(|| black_box(searcher.search_in(haystack)));
+                },
+            );
         }
-    });
-    let words = words;
-
-    let twoway_words: Vec<TwoWaySearcher<'_>> = words
-        .iter()
-        .map(|word| TwoWaySearcher::new(word.as_bytes()))
-        .collect();
-
-    let avx2_words: Vec<StrStrAVX2Searcher> = words
-        .iter()
-        .map(|word| StrStrAVX2Searcher::new(word.as_bytes()))
-        .collect();
-
-    let dynamic_avx2_searchers: Vec<DynamicAvx2Searcher> = words
-        .iter()
-        .map(|word| DynamicAvx2Searcher::new(word.clone().into_boxed_str().into()))
-        .collect();
-
-    // Benchmarks against long haystacks
-
-    c.bench_function("String::find with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                content.find(word);
-            }
-        })
-    });
-
-    c.bench_function(
-        "memmem::TwoWaySearcher::search_in with long haystack",
-        |b| {
-            b.iter(|| {
-                for twoway_word in &twoway_words {
-                    twoway_word.search_in(content.as_bytes());
-                }
-            })
-        },
-    );
-
-    c.bench_function("twoway::find_bytes with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                twoway::find_bytes(content.as_bytes(), word.as_bytes());
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_original with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                unsafe {
-                    strstr_avx2_original(content.as_bytes(), word.as_bytes());
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_simple with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                unsafe {
-                    strstr_avx2_rust_simple(content.as_bytes(), word.as_bytes());
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_simple_2 with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                unsafe {
-                    strstr_avx2_rust_simple_2(content.as_bytes(), word.as_bytes());
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_fast with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                unsafe {
-                    strstr_avx2_rust_fast(content.as_bytes(), word.as_bytes());
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_fast_2 with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                strstr_avx2_rust_fast_2(content.as_bytes(), word.as_bytes());
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_aligned with long haystack", |b| {
-        b.iter(|| {
-            for word in &words {
-                unsafe {
-                    strstr_avx2_rust_aligned(content.as_bytes(), word.as_bytes());
-                }
-            }
-        })
-    });
-
-    c.bench_function("StrStrAVX2Searcher::search_in with long haystack", |b| {
-        b.iter(|| {
-            for avx2_word in &avx2_words {
-                avx2_word.search_in(content.as_bytes());
-            }
-        })
-    });
-
-    c.bench_function("DynamicAvx2Searcher::search_in with long haystack", |b| {
-        b.iter(|| {
-            for searcher in &dynamic_avx2_searchers {
-                searcher.search_in(content.as_bytes());
-            }
-        })
-    });
-
-    // Benchmarks against short haystacks
-    //
-    // Since words are ordered by length, pick a word as needle
-    // and use bigger words as haystacks.
-
-    c.bench_function("String::find with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    content.find(word);
-                }
-            }
-        })
-    });
-
-    c.bench_function(
-        "memmem::TwoWaySearcher::search_in with short haystack",
-        |b| {
-            b.iter(|| {
-                for (i, word) in twoway_words.iter().enumerate() {
-                    for content in &words[(i + 1)..] {
-                        word.search_in(content.as_bytes());
-                    }
-                }
-            })
-        },
-    );
-
-    c.bench_function("twoway::find_bytes with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    twoway::find_bytes(content.as_bytes(), word.as_bytes());
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_original with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    unsafe {
-                        strstr_avx2_original(content.as_bytes(), word.as_bytes());
-                    }
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_simple with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    unsafe {
-                        strstr_avx2_rust_simple(content.as_bytes(), word.as_bytes());
-                    }
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_simple_2 with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    unsafe {
-                        strstr_avx2_rust_simple_2(content.as_bytes(), word.as_bytes());
-                    }
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_fast with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    unsafe {
-                        strstr_avx2_rust_fast(content.as_bytes(), word.as_bytes());
-                    }
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_fast_2 with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    strstr_avx2_rust_fast_2(content.as_bytes(), word.as_bytes());
-                }
-            }
-        })
-    });
-
-    c.bench_function("strstr_avx2_rust_aligned with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    unsafe {
-                        strstr_avx2_rust_aligned(content.as_bytes(), word.as_bytes());
-                    }
-                }
-            }
-        })
-    });
-
-    c.bench_function("StrStrAVX2Searcher::search_in with short haystack", |b| {
-        b.iter(|| {
-            for (i, word) in avx2_words.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    word.search_in(content.as_bytes());
-                }
-            }
-        })
-    });
 
-    c.bench_function("DynamicAvx2Searcher::search_in with short haystack", |b| {
-        b.iter(|| {
-            for (i, searcher) in dynamic_avx2_searchers.iter().enumerate() {
-                for content in &words[(i + 1)..] {
-                    searcher.search_in(content.as_bytes());
-                }
-            }
-        })
-    });
+        group.finish();
+    }
 }
 
 criterion_group!(benches, criterion_benchmark);

data/haystack

@@ -0,0 +1 @@
+I4BCeTWkpm1G1StV1WP8HKMX1IaRTslq88MOEg4nx7kWLaWYDRDYZrdTtsg26mz9S8DhYcd1ty35aPLyRZSeimOmPAroaqi861z44o35qP9GdrofuuHwdhSEeOg7E0L1KrTYgWZZrzyk7o0DVxw7vvmo6rVJ5T4lLMkesL1U6ObckS9oorPI5ZDm4Nk1ryh3AC8juZwJLcyWKveenfaVGaB42iYrOvrZGIMQG0OmA0k73ydw2mJawUzWE8O61MQpDm19JFaTgSJMkPs3yjY149knHg03uOBvb6d0hCmUbiHkRgFwH17cL7UJUlkggx55Gk1n07v7fGdkjvxmOmCHCvLrY9pCvewCAy1Lg1NTdE4N7AJfjPj1hiw9DqiDaJwTVc4JA229EubFHnMBlHkrSSnR1wh7RYOngmQUxjGOdctDkjVard24dO2mGkGCXAHrOjRGq9J54ml3HtCx3Ui3YN68Q8eywJnkS7CdiA2d2SmRako5VlGfRCDdoiNpZwq9FodDRcw4XsWLuH9XEAfXSGzx5X8PVUwnmTImOcc1az1x8dUWVdK5St7M5dVPsWZ5hrll7F0MjKdf2wBFYEp0gqZTswXUn2RwkDLCj4oikpBCE1fLSaiKL89rbo1RZ2phIVrXb7eQ8xJTBU1iSwWF97OJlIBcNjmE4TzrqgIl2m8ybVAURk3iC51cwO8wD5V1dcVzIuqAWJUwKh4PPyHhGdv4T439nRh3ukwAlHBtxj56izkIKWNm01Mfrc1boFApld1E597BDSrWEcXwn44KogPpJ058LGNB8IaAufcWEXfqbPwgNQUSqqarItOAFir3tr8nBGQar22nZifJzUiU35TzXUc46LYAxSEeDmbqMh3Zcmuw5YrFF5Ma0oaAuiiJb2IdpkPr5E6HuN5vDvvnjxDw0GbOX72xuSRFDxbOmt40hDLQLy3UrlaP92jS7DfBMUGefSo7mTfCpz5hvllPhbjYqJ31P9d8zJYPpQMW

data/needle

@@ -0,0 +1 @@
+c7ll0y40P6Af6wq0GQ9ZZnCSTDOJMjY7DwJEnjR3LncoVS6Oz5oZoAX2ujWOwNzb5dbQ66jAPLxKcWK9skcfxdjVz9KZQwNYedrb32gSu5Uz42uiIy8JwcsQrzINauFahMgTxcDUfd6qiaNZrvsWxqWdl20lfd8HjFcXkaK60716cvM6Jry2wPvT9HdBVS3zWycALrb3gcEKhycPPVikCSc7TaOSfu99sga4qTxaI9syh5EYNKkCp7BLGTyPZZ8I1Z0V7x4PPhysOcXZu5FYsQXIInHg7muLLDdvpfSrIDAfp8cuchjXoAynbxLvjaAy5JjbLlCPrKBXsv52Clxf8BkHYhZuLfTB1rc41EseOexhedDjsRKfT6f9GlkbC3JKVRKtzxKua9vrxwYWmcGTKvUNAAHZeH1y9KDRY6Kyu8IVOdhQoPsVz4KUL055PJzN7wubglYt615GRnPnlhfwvi9pq54hUrMwWAwabvER6DmFgyh6mnx2KweqS9cH31gymB2XGocbXN4OCpa10kq6MMf7Ibvrm7y2rsjFBcdOeUZoOM5dqgrpvSKeQoOSnMpSrXeEiVTXrmXuLBZqHZMbbh7KPgKWlbg4MZwWVlDukNQKIsJdGy21m0q5DbDy0XSB1z1RbWu4B26g7fZJWK6TJr1ZUsUsQiRvKUrWbKz41A475MDxbaaWiAPJlqOFQl5UyoxuS1K51nMPlLG1DcRSeiQjLFsmDBNt6dcaIf8McnbDUhiA9MsHcNHlcroPCnrn26RatirFLkVhfMBFTORZ1EZz1IEMIRDrMotb9MzyqNpKkK2nItDA43MjaOddKhrms7ZxPUetfyKpcm9OXsbzmnvFqM9KFwtTiySICxAP6qNd24DM4wbGOU8WuVLZZyUnun3zqigNysKBwYwXdYKsaQAEZI6clSSmr4YcRzbgmf8qAIoYKz9crjXz47lMfPEpHIEEKN1ftW9Nml5Xg6Pivjw0mlUMRGTPLFKXedqC