diff --git a/Cargo.lock b/Cargo.lock index 7638249d98abe..6e2017707fed1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5850,6 +5850,16 @@ version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" +[[package]] +name = "slice-search-bench" +version = "51.0.0" +dependencies = [ + "criterion", + "hashbrown 0.14.5", + "libc", + "seq-macro", +] + [[package]] name = "smallvec" version = "1.15.1" diff --git a/Cargo.toml b/Cargo.toml index 9632d3397d8a5..90f33ae69f24d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -63,6 +63,7 @@ members = [ "datafusion-examples/examples/ffi/ffi_module_loader", "test-utils", "benchmarks", + "benchmarks/slice-search", "datafusion/macros", "datafusion/doc", ] diff --git a/benchmarks/.gitignore b/benchmarks/.gitignore index c35b1a7c1944f..836a6c2d8af6b 100644 --- a/benchmarks/.gitignore +++ b/benchmarks/.gitignore @@ -1,3 +1,5 @@ data results +!slice-search/results/ +!slice-search/results/*.txt venv diff --git a/benchmarks/slice-search/Cargo.toml b/benchmarks/slice-search/Cargo.toml new file mode 100644 index 0000000000000..5bb6d173216ff --- /dev/null +++ b/benchmarks/slice-search/Cargo.toml @@ -0,0 +1,42 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +[package] +name = "slice-search-bench" +description = "Microbenchmarks comparing slice search strategies" +version = { workspace = true } +edition = { workspace = true } +authors = { workspace = true } +homepage = { workspace = true } +repository = { workspace = true } +license = { workspace = true } +rust-version = { workspace = true } + +[lints] +workspace = true + +[dependencies] +seq-macro = "0.3" + +[dev-dependencies] +criterion = { workspace = true } +hashbrown = { workspace = true } +libc = "0.2" + +[[bench]] +name = "slice_search" +harness = false diff --git a/benchmarks/slice-search/benches/slice_search.rs b/benchmarks/slice-search/benches/slice_search.rs new file mode 100644 index 0000000000000..82e5da815c53c --- /dev/null +++ b/benchmarks/slice-search/benches/slice_search.rs @@ -0,0 +1,243 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Batched slice search benchmarks. +//! +//! Each benchmark processes BATCH_SIZE lookups at once, representative of +//! production IN LIST processing where we check many values against a haystack. +//! Results are reported as total time for the batch; divide by BATCH_SIZE for +//! per-lookup cost. + +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; + +/// Set the current thread to highest QoS class on macOS (Apple Silicon). +/// This strongly encourages the scheduler to run on Performance cores. +#[cfg(target_os = "macos")] +fn prefer_performance_cores() { + unsafe { + // QOS_CLASS_USER_INTERACTIVE is the highest priority, strongly prefers P-cores + libc::pthread_set_qos_class_self_np( + libc::qos_class_t::QOS_CLASS_USER_INTERACTIVE, + 0, + ); + } +} + +#[cfg(not(target_os = "macos"))] +fn prefer_performance_cores() { + // No-op on non-macOS platforms +} +use hashbrown::HashSet; +use slice_search_bench::branchless::branchless_batch_lookup; +use slice_search_bench::{ + generate_even_strings, generate_numeric_even, LENGTHS_128, LENGTHS_16, LENGTHS_256, + LENGTHS_64, +}; +use std::hash::Hash; +use std::hint::black_box; +use std::sync::Arc; +use std::time::Duration; + +/// Number of lookups per benchmark iteration. +/// Matches typical Arrow array batch sizes. +const BATCH_SIZE: usize = 8192; + +/// Generate needles for batch lookup. +/// Mix of values that will hit (even) and miss (odd) in the haystack. +fn generate_numeric_needles(count: usize, max_value: usize, to_type: F) -> Vec +where + F: Fn(usize) -> T, +{ + (0..count) + .map(|i| { + // Alternate between hits (even values in haystack) and misses (odd values) + let v = (i * 7) % (max_value * 2); // spread across range, ~50% hit rate + to_type(v) + }) + .collect() +} + +fn generate_string_needles(count: usize, max_value: usize) -> Vec { + (0..count) + .map(|i| { + let v = (i * 7) % (max_value * 2); + // Match haystack format: "item_padding_________________{:08}" (32 chars) + format!("item_padding_________________{v:08}") + }) + .collect() +} + +fn bench_numeric(c: &mut Criterion, type_name: &str, lengths: &[usize], to_type: F) +where + T: Ord + Copy + Hash + Default + Send + Sync + 'static, + F: Fn(usize) -> T + Copy, +{ + let mut group = c.benchmark_group(format!("{type_name}_slice_search")); + // Minimal config for fast benchmarks with meaningful stats + group.sample_size(10); // Minimum for statistical significance + group.measurement_time(Duration::from_millis(100)); + group.warm_up_time(Duration::from_millis(50)); + + for &len in lengths { + let (haystack_vec, _) = generate_numeric_even(len, to_type); + let haystack = Arc::new(haystack_vec); + let hashset: Arc> = Arc::new(haystack.iter().cloned().collect()); + let needles: Arc> = + Arc::new(generate_numeric_needles(BATCH_SIZE, len * 2, to_type)); + + // Only run linear/binary_search for small sizes (not competitive above 64) + if len <= 64 { + group.bench_with_input( + BenchmarkId::new("contains", len), + &len, + |b, &_len| { + let haystack = Arc::clone(&haystack); + let needles = Arc::clone(&needles); + b.iter(|| { + let haystack = black_box(haystack.as_slice()); + black_box(&*needles) + .iter() + .filter(|needle| haystack.contains(needle)) + .count() + }); + }, + ); + + group.bench_with_input( + BenchmarkId::new("binary_search", len), + &len, + |b, &_len| { + let haystack = Arc::clone(&haystack); + let needles = Arc::clone(&needles); + b.iter(|| { + let haystack = black_box(haystack.as_slice()); + black_box(&*needles) + .iter() + .filter(|needle| haystack.binary_search(needle).is_ok()) + .count() + }); + }, + ); + } + + group.bench_with_input(BenchmarkId::new("hashset", len), &len, |b, &_len| { + let hashset = Arc::clone(&hashset); + let needles = Arc::clone(&needles); + b.iter(|| { + let hashset = black_box(&*hashset); + black_box(&*needles) + .iter() + .filter(|needle| hashset.contains(*needle)) + .count() + }); + }); + + group.bench_with_input(BenchmarkId::new("branchless", len), &len, |b, &_len| { + let haystack = Arc::clone(&haystack); + let needles = Arc::clone(&needles); + b.iter(|| { + branchless_batch_lookup( + black_box(haystack.as_slice()), + black_box(&needles), + ) + .expect("LENGTHS should only contain supported sizes") + }); + }); + } + + group.finish(); +} + +fn bench_strings(c: &mut Criterion) { + let mut group = c.benchmark_group("str_slice_search"); + // Minimal config for fast benchmarks with meaningful stats + group.sample_size(10); // Minimum for statistical significance + group.measurement_time(Duration::from_millis(100)); + group.warm_up_time(Duration::from_millis(50)); + + for &len in &LENGTHS_16 { + let (haystack_vec, _) = generate_even_strings(len); + let haystack = Arc::new(haystack_vec); + let hashset: Arc> = Arc::new(haystack.iter().cloned().collect()); + let needles: Arc> = + Arc::new(generate_string_needles(BATCH_SIZE, len * 2)); + + group.bench_with_input(BenchmarkId::new("contains", len), &len, |b, &_len| { + let haystack = Arc::clone(&haystack); + let needles = Arc::clone(&needles); + b.iter(|| { + let haystack = black_box(haystack.as_slice()); + black_box(&*needles) + .iter() + .filter(|needle| haystack.contains(needle)) + .count() + }); + }); + + group.bench_with_input( + BenchmarkId::new("binary_search", len), + &len, + |b, &_len| { + let haystack = Arc::clone(&haystack); + let needles = Arc::clone(&needles); + b.iter(|| { + let haystack = black_box(haystack.as_slice()); + black_box(&*needles) + .iter() + .filter(|needle| haystack.binary_search(needle).is_ok()) + .count() + }); + }, + ); + + group.bench_with_input(BenchmarkId::new("hashset", len), &len, |b, &_len| { + let hashset = Arc::clone(&hashset); + let needles = Arc::clone(&needles); + b.iter(|| { + let hashset = black_box(&*hashset); + black_box(&*needles) + .iter() + .filter(|needle| hashset.contains(needle.as_str())) + .count() + }); + }); + + // Note: branchless not implemented for strings (requires Copy trait) + } + + group.finish(); +} + +fn slice_search(c: &mut Criterion) { + // On Apple Silicon, prefer Performance cores for consistent results + prefer_performance_cores(); + + // i8: benchmark up to 256 (extended range for cutoff analysis) + bench_numeric::(c, "i8", &LENGTHS_256, |v| v as i8); + // i16: benchmark up to 128 + bench_numeric::(c, "i16", &LENGTHS_128, |v| v as i16); + // i32/i64: benchmark up to 64 + bench_numeric::(c, "i32", &LENGTHS_64, |v| v as i32); + bench_numeric::(c, "i64", &LENGTHS_64, |v| v as i64); + // i128: benchmark up to 16 + bench_numeric::(c, "i128", &LENGTHS_16, |v| v as i128); + // str: benchmark up to 16 (uses LENGTHS_16 internally) + bench_strings(c); +} + +criterion_group!(benches, slice_search); +criterion_main!(benches); diff --git a/benchmarks/slice-search/results/ANALYSIS.md b/benchmarks/slice-search/results/ANALYSIS.md new file mode 100644 index 0000000000000..3b272a211809a --- /dev/null +++ b/benchmarks/slice-search/results/ANALYSIS.md @@ -0,0 +1,215 @@ +# Slice Search Benchmark Analysis + +This document analyzes the performance of four search strategies for membership testing in sorted slices, typical of SQL `IN (list)` processing. + +## Benchmark Results + +Results are stored per-CPU in subfolders. See: +- [`Apple_M1_Max/slice_search.png`](Apple_M1_Max/slice_search.png) — Visual comparison +- [`Apple_M1_Max/CUTOFFS.md`](Apple_M1_Max/CUTOFFS.md) — Recommended algorithm cutoffs + +![Slice Search Benchmark Results](Apple_M1_Max/slice_search.png) + +## Benchmark Configuration + +| Parameter | Value | +|-----------|-------| +| **Batch size** | 8,192 lookups per measurement | +| **Metric** | Minimum time (noise only adds, never subtracts) | +| **Hit rate** | ~50% (mix of hits and misses) | +| **String length** | 32 characters (differentiating suffix) | +| **Platform** | Apple M1 Max (QoS set to prefer P-cores) | + +### Data Types Tested + +| Type | Sizes Benchmarked | Bytes | +|------|-------------------|-------| +| `i8` | 2–256 | 1 | +| `i16` | 2–128 | 2 | +| `i32` | 2–64 | 4 | +| `i64` | 2–64 | 8 | +| `i128` | 2–16 | 16 | +| `str` | 2–16 | 32 (chars) | + +### Search Methods + +1. **linear** (`slice.contains()`) — O(n) scan +2. **binary search** (`slice.binary_search()`) — O(log n) +3. **hashset** (`HashSet::contains()`) — O(1) amortized +4. **branchless** — Const-generic SIMD-friendly linear scan (numeric only) + +## Key Findings + +### 1. Branchless Dominates for Small Numeric Slices + +The const-generic branchless implementation wins decisively for small numeric types: + +| Type | Branchless Wins Up To | +|------|----------------------| +| i8 | 128 elements | +| i16 | 64 elements | +| i32 | 32 elements | +| i64 | 16 elements | +| i128 | 4 elements | + +**Why?** The compiler knows the exact array size at compile time, enabling: +- Full loop unrolling +- SIMD auto-vectorization (NEON on Apple Silicon) +- No branch misprediction (uses bitwise OR accumulation) + +### 2. HashSet Wins for Larger Slices + +Once slice size exceeds the branchless threshold, HashSet's O(1) lookup dominates: +- Near-constant time regardless of slice size +- Construction cost amortized over 8,192 lookups per batch + +### 3. Binary Search is Never Optimal + +**Surprising finding**: Binary search is never the best choice in batch scenarios. +- For small sizes: branchless beats it via SIMD +- For large sizes: HashSet beats it with O(1) vs O(log n) + +Binary search only makes sense for single lookups where HashSet construction isn't amortized. + +### 4. Strings Behave Differently + +Without branchless (requires `Copy` trait), strings show: +- **Linear scan wins for ≤2 elements** (no comparison overhead) +- **HashSet wins for ≥3 elements** (hashing amortizes string comparison cost) + +## Recommended Algorithm Selection + +```rust +match (element_type, slice_length) { + // Small numeric types: branchless has longest runway + (i8, ..=128) => branchless, + (i16, ..=64) => branchless, + (i32, ..=32) => branchless, + (i64, ..=16) => branchless, + (i128, ..=4) => branchless, + + // Strings: very short cutoff + (str, ..=2) => linear, + + // Everything else: HashSet + _ => hashset, +} +``` + +### Simplified Decision Tree + +```python +def select_algorithm(element_type, slice_length): + if element_type.is_numeric() and slice_length <= branchless_cutoff(element_type): + return "branchless" + elif element_type == "str" and slice_length <= 2: + return "linear" + else: + return "hashset" +``` + +## Why These Cutoffs? + +### SIMD Register Capacity + +The branchless cutoff correlates inversely with type size: + +| Type | Bytes | NEON Elements/Register | Optimal Branchless Cutoff | +|------|-------|------------------------|---------------------------| +| i8 | 1 | 16 | 128 | +| i16 | 2 | 8 | 64 | +| i32 | 4 | 4 | 32 | +| i64 | 8 | 2 | 16 | +| i128 | 16 | 1 | 4 | + +Smaller types pack more elements per SIMD register, extending the branchless advantage. + +### Empirical Formula + +The M1 Max data reveals a consistent relationship: + +``` +cutoff = 8 × (register_bits / type_bits) + = 8 × elements_per_register +``` + +For example, with NEON's 128-bit registers and `i32` (32 bits): +- Elements per register = 128 / 32 = 4 +- Predicted cutoff = 8 × 4 = 32 ✓ + +The multiplier of 8 represents approximately how many SIMD operations can execute before HashSet's O(1) lookup (with its hashing and memory indirection overhead) becomes faster. + +### Predicted Cutoffs by Platform + +Applying the formula to different SIMD widths: + +| Platform | Register Bits | i8 | i16 | i32 | i64 | +|----------|---------------|-----|-----|-----|-----| +| SSE / NEON | 128 | 128 | 64 | 32 | 16 | +| AVX2 | 256 | 256 | 128 | 64 | 32 | +| AVX-512 | 512 | 512 | 256 | 128 | 64 | + +**Note:** Intel/AMD CPUs with AVX2 or AVX-512 have not yet been benchmarked. Running this benchmark suite on x86 hardware would validate the empirical formula and confirm whether the 8× multiplier holds across architectures. To benchmark with wider SIMD enabled: + +```bash +RUSTFLAGS="-C target-cpu=native" cargo bench +python3 results/plot_results.py # saves to results// +``` + +### HashSet Overhead + +HashSet has fixed overhead: +- Hash computation per lookup +- Memory indirection +- Cache behavior + +This overhead is amortized at larger sizes but dominates at small sizes. + +## Implementation Notes + +### Branchless Check + +```rust +fn branchless_check( + haystack: &[T; N], + needle: T +) -> bool { + haystack.iter().fold(false, |acc, &v| acc | (v == needle)) +} +``` + +The `const N` parameter enables the compiler to fully unroll and vectorize. + +### Batch Processing + +All benchmarks process 8,192 lookups per iteration, matching typical Arrow array batch sizes. This amortizes: +- HashSet construction +- Function call overhead +- Match dispatch for branchless size selection + +## Reproducing Results + +```bash +cd benchmarks/slice-search + +# Clear previous results +rm -rf ../../target/criterion + +# Run benchmarks (results saved to target/criterion/) +cargo bench + +# Generate plots and cutoff recommendations +python3 results/plot_results.py +``` + +Results are automatically saved to a CPU-specific subfolder (e.g., `results/Apple_M1_Max/`). + +## Conclusion + +For DataFusion's IN LIST processing: + +1. **Use branchless** for small numeric IN lists (size varies by type) +2. **Use HashSet** for larger lists and strings (≥3 elements) +3. **Never use binary search** in batch scenarios + +The branchless approach provides **2–10× speedup** over alternatives for small numeric slices, making it the clear winner for the common case of IN lists with few elements. diff --git a/benchmarks/slice-search/results/Apple_M1_Max/CUTOFFS.md b/benchmarks/slice-search/results/Apple_M1_Max/CUTOFFS.md new file mode 100644 index 0000000000000..8e27da0f5976a --- /dev/null +++ b/benchmarks/slice-search/results/Apple_M1_Max/CUTOFFS.md @@ -0,0 +1,10 @@ +# Recommended Search Algorithm Cutoffs + +Based on minimum batch time (8192 lookups per batch). + +- **Int8**: use branchless up to 128, then hashset +- **Int16**: use branchless up to 64, then hashset +- **Int32**: use branchless up to 32, then hashset +- **Int64**: use branchless up to 16, then hashset +- **Int128**: use branchless up to 4, then hashset +- **String**: use linear up to 2, then hashset diff --git a/benchmarks/slice-search/results/Apple_M1_Max/benchmark_run_20251210_134603.txt b/benchmarks/slice-search/results/Apple_M1_Max/benchmark_run_20251210_134603.txt new file mode 100644 index 0000000000000..fbe40d57e7a4d --- /dev/null +++ b/benchmarks/slice-search/results/Apple_M1_Max/benchmark_run_20251210_134603.txt @@ -0,0 +1,6211 @@ + Compiling slice-search-bench v51.0.0 (/Users/geoffrey.claude/go/src/github.com/DataDog/datafusion/benchmarks/slice-search) + Finished `bench` profile [optimized] target(s) in 33.47s + Running unittests src/lib.rs (/Users/geoffrey.claude/go/src/github.com/DataDog/datafusion/target/release/deps/slice_search_bench-96eda5e9cb83700c) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running benches/slice_search.rs (/Users/geoffrey.claude/go/src/github.com/DataDog/datafusion/target/release/deps/slice_search-7d12850531d50077) +Benchmarking i8_slice_search/contains/2 +Benchmarking i8_slice_search/contains/2: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/2: Collecting 10 samples in estimated 100.14 ms (16k iterations) +Benchmarking i8_slice_search/contains/2: Analyzing +i8_slice_search/contains/2 + time: [6.1129 µs 6.1334 µs 6.1702 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/2 +Benchmarking i8_slice_search/binary_search/2: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/2: Collecting 10 samples in estimated 100.02 ms (15k iterations) +Benchmarking i8_slice_search/binary_search/2: Analyzing +i8_slice_search/binary_search/2 + time: [6.6648 µs 6.7142 µs 6.7595 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/2 +Benchmarking i8_slice_search/hashset/2: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/2: Collecting 10 samples in estimated 100.22 ms (8635 iterations) +Benchmarking i8_slice_search/hashset/2: Analyzing +i8_slice_search/hashset/2 + time: [11.544 µs 11.594 µs 11.662 µs] +Benchmarking i8_slice_search/branchless/2 +Benchmarking i8_slice_search/branchless/2: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/2: Collecting 10 samples in estimated 100.06 ms (54k iterations) +Benchmarking i8_slice_search/branchless/2: Analyzing +i8_slice_search/branchless/2 + time: [1.8472 µs 1.8555 µs 1.8730 µs] +Benchmarking i8_slice_search/contains/3 +Benchmarking i8_slice_search/contains/3: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/3: Collecting 10 samples in estimated 100.64 ms (7480 iterations) +Benchmarking i8_slice_search/contains/3: Analyzing +i8_slice_search/contains/3 + time: [13.104 µs 13.184 µs 13.244 µs] +Benchmarking i8_slice_search/binary_search/3 +Benchmarking i8_slice_search/binary_search/3: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/3: Collecting 10 samples in estimated 100.03 ms (9845 iterations) +Benchmarking i8_slice_search/binary_search/3: Analyzing +i8_slice_search/binary_search/3 + time: [9.9362 µs 9.9751 µs 10.023 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/3 +Benchmarking i8_slice_search/hashset/3: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/3: Collecting 10 samples in estimated 100.46 ms (8580 iterations) +Benchmarking i8_slice_search/hashset/3: Analyzing +i8_slice_search/hashset/3 + time: [11.470 µs 11.529 µs 11.624 µs] +Benchmarking i8_slice_search/branchless/3 +Benchmarking i8_slice_search/branchless/3: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/3: Collecting 10 samples in estimated 100.05 ms (51k iterations) +Benchmarking i8_slice_search/branchless/3: Analyzing +i8_slice_search/branchless/3 + time: [1.9328 µs 1.9429 µs 1.9545 µs] +Benchmarking i8_slice_search/contains/4 +Benchmarking i8_slice_search/contains/4: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/4: Collecting 10 samples in estimated 100.45 ms (6710 iterations) +Benchmarking i8_slice_search/contains/4: Analyzing +i8_slice_search/contains/4 + time: [14.509 µs 14.607 µs 14.748 µs] +Benchmarking i8_slice_search/binary_search/4 +Benchmarking i8_slice_search/binary_search/4: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/4: Collecting 10 samples in estimated 100.50 ms (9955 iterations) +Benchmarking i8_slice_search/binary_search/4: Analyzing +i8_slice_search/binary_search/4 + time: [9.9765 µs 10.008 µs 10.045 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i8_slice_search/hashset/4 +Benchmarking i8_slice_search/hashset/4: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/4: Collecting 10 samples in estimated 100.11 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/4: Analyzing +i8_slice_search/hashset/4 + time: [11.512 µs 11.556 µs 11.618 µs] +Benchmarking i8_slice_search/branchless/4 +Benchmarking i8_slice_search/branchless/4: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/4: Collecting 10 samples in estimated 100.10 ms (49k iterations) +Benchmarking i8_slice_search/branchless/4: Analyzing +i8_slice_search/branchless/4 + time: [2.0231 µs 2.0391 µs 2.0477 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/5 +Benchmarking i8_slice_search/contains/5: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/5: Collecting 10 samples in estimated 100.69 ms (5885 iterations) +Benchmarking i8_slice_search/contains/5: Analyzing +i8_slice_search/contains/5 + time: [16.764 µs 16.904 µs 17.055 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/5 +Benchmarking i8_slice_search/binary_search/5: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/5: Collecting 10 samples in estimated 100.51 ms (7425 iterations) +Benchmarking i8_slice_search/binary_search/5: Analyzing +i8_slice_search/binary_search/5 + time: [13.342 µs 13.449 µs 13.572 µs] +Benchmarking i8_slice_search/hashset/5 +Benchmarking i8_slice_search/hashset/5: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/5: Collecting 10 samples in estimated 100.15 ms (8580 iterations) +Benchmarking i8_slice_search/hashset/5: Analyzing +i8_slice_search/hashset/5 + time: [11.567 µs 11.629 µs 11.689 µs] +Benchmarking i8_slice_search/branchless/5 +Benchmarking i8_slice_search/branchless/5: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/5: Collecting 10 samples in estimated 100.04 ms (46k iterations) +Benchmarking i8_slice_search/branchless/5: Analyzing +i8_slice_search/branchless/5 + time: [2.1406 µs 2.1484 µs 2.1561 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/6 +Benchmarking i8_slice_search/contains/6: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/6: Collecting 10 samples in estimated 100.91 ms (5225 iterations) +Benchmarking i8_slice_search/contains/6: Analyzing +i8_slice_search/contains/6 + time: [19.014 µs 19.139 µs 19.280 µs] +Benchmarking i8_slice_search/binary_search/6 +Benchmarking i8_slice_search/binary_search/6: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/6: Collecting 10 samples in estimated 100.32 ms (7425 iterations) +Benchmarking i8_slice_search/binary_search/6: Analyzing +i8_slice_search/binary_search/6 + time: [13.388 µs 13.456 µs 13.514 µs] +Benchmarking i8_slice_search/hashset/6 +Benchmarking i8_slice_search/hashset/6: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/6: Collecting 10 samples in estimated 100.04 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/6: Analyzing +i8_slice_search/hashset/6 + time: [11.630 µs 11.684 µs 11.740 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/6 +Benchmarking i8_slice_search/branchless/6: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/6: Collecting 10 samples in estimated 100.04 ms (45k iterations) +Benchmarking i8_slice_search/branchless/6: Analyzing +i8_slice_search/branchless/6 + time: [2.1788 µs 2.1897 µs 2.2009 µs] +Benchmarking i8_slice_search/contains/7 +Benchmarking i8_slice_search/contains/7: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/7: Collecting 10 samples in estimated 100.23 ms (5115 iterations) +Benchmarking i8_slice_search/contains/7: Analyzing +i8_slice_search/contains/7 + time: [19.500 µs 19.610 µs 19.771 µs] +Benchmarking i8_slice_search/binary_search/7 +Benchmarking i8_slice_search/binary_search/7: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/7: Collecting 10 samples in estimated 100.45 ms (7370 iterations) +Benchmarking i8_slice_search/binary_search/7: Analyzing +i8_slice_search/binary_search/7 + time: [13.443 µs 13.496 µs 13.563 µs] +Benchmarking i8_slice_search/hashset/7 +Benchmarking i8_slice_search/hashset/7: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/7: Collecting 10 samples in estimated 100.33 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/7: Analyzing +i8_slice_search/hashset/7 + time: [11.697 µs 11.757 µs 11.799 µs] +Benchmarking i8_slice_search/branchless/7 +Benchmarking i8_slice_search/branchless/7: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/7: Collecting 10 samples in estimated 100.05 ms (43k iterations) +Benchmarking i8_slice_search/branchless/7: Analyzing +i8_slice_search/branchless/7 + time: [2.2718 µs 2.2844 µs 2.2991 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/8 +Benchmarking i8_slice_search/contains/8: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/8: Collecting 10 samples in estimated 101.28 ms (4235 iterations) +Benchmarking i8_slice_search/contains/8: Analyzing +i8_slice_search/contains/8 + time: [23.740 µs 23.807 µs 23.892 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/8 +Benchmarking i8_slice_search/binary_search/8: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/8: Collecting 10 samples in estimated 100.13 ms (7370 iterations) +Benchmarking i8_slice_search/binary_search/8: Analyzing +i8_slice_search/binary_search/8 + time: [13.430 µs 13.495 µs 13.593 µs] +Benchmarking i8_slice_search/hashset/8 +Benchmarking i8_slice_search/hashset/8: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/8: Collecting 10 samples in estimated 100.52 ms (8195 iterations) +Benchmarking i8_slice_search/hashset/8: Analyzing +i8_slice_search/hashset/8 + time: [12.061 µs 12.107 µs 12.166 µs] +Benchmarking i8_slice_search/branchless/8 +Benchmarking i8_slice_search/branchless/8: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/8: Collecting 10 samples in estimated 100.02 ms (42k iterations) +Benchmarking i8_slice_search/branchless/8: Analyzing +i8_slice_search/branchless/8 + time: [2.3507 µs 2.3637 µs 2.3777 µs] +Benchmarking i8_slice_search/contains/9 +Benchmarking i8_slice_search/contains/9: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/9: Collecting 10 samples in estimated 101.29 ms (3850 iterations) +Benchmarking i8_slice_search/contains/9: Analyzing +i8_slice_search/contains/9 + time: [25.953 µs 26.208 µs 26.626 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/9 +Benchmarking i8_slice_search/binary_search/9: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/9: Collecting 10 samples in estimated 100.33 ms (5885 iterations) +Benchmarking i8_slice_search/binary_search/9: Analyzing +i8_slice_search/binary_search/9 + time: [16.868 µs 16.932 µs 16.989 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/hashset/9 +Benchmarking i8_slice_search/hashset/9: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/9: Collecting 10 samples in estimated 100.06 ms (8250 iterations) +Benchmarking i8_slice_search/hashset/9: Analyzing +i8_slice_search/hashset/9 + time: [12.053 µs 12.079 µs 12.113 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/9 +Benchmarking i8_slice_search/branchless/9: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/9: Collecting 10 samples in estimated 100.02 ms (41k iterations) +Benchmarking i8_slice_search/branchless/9: Analyzing +i8_slice_search/branchless/9 + time: [2.4205 µs 2.4282 µs 2.4365 µs] +Benchmarking i8_slice_search/contains/10 +Benchmarking i8_slice_search/contains/10: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/10: Collecting 10 samples in estimated 100.74 ms (3520 iterations) +Benchmarking i8_slice_search/contains/10: Analyzing +i8_slice_search/contains/10 + time: [28.246 µs 28.370 µs 28.497 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/10 +Benchmarking i8_slice_search/binary_search/10: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/10: Collecting 10 samples in estimated 100.63 ms (5885 iterations) +Benchmarking i8_slice_search/binary_search/10: Analyzing +i8_slice_search/binary_search/10 + time: [16.888 µs 17.007 µs 17.104 µs] +Benchmarking i8_slice_search/hashset/10 +Benchmarking i8_slice_search/hashset/10: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/10: Collecting 10 samples in estimated 100.06 ms (8305 iterations) +Benchmarking i8_slice_search/hashset/10: Analyzing +i8_slice_search/hashset/10 + time: [12.008 µs 12.042 µs 12.091 µs] +Benchmarking i8_slice_search/branchless/10 +Benchmarking i8_slice_search/branchless/10: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/10: Collecting 10 samples in estimated 100.02 ms (40k iterations) +Benchmarking i8_slice_search/branchless/10: Analyzing +i8_slice_search/branchless/10 + time: [2.4844 µs 2.4947 µs 2.5072 µs] +Benchmarking i8_slice_search/contains/11 +Benchmarking i8_slice_search/contains/11: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/11: Collecting 10 samples in estimated 100.19 ms (3245 iterations) +Benchmarking i8_slice_search/contains/11: Analyzing +i8_slice_search/contains/11 + time: [30.512 µs 30.676 µs 30.864 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/11 +Benchmarking i8_slice_search/binary_search/11: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/11: Collecting 10 samples in estimated 100.18 ms (5830 iterations) +Benchmarking i8_slice_search/binary_search/11: Analyzing +i8_slice_search/binary_search/11 + time: [16.981 µs 17.040 µs 17.130 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/hashset/11 +Benchmarking i8_slice_search/hashset/11: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/11: Collecting 10 samples in estimated 100.29 ms (8195 iterations) +Benchmarking i8_slice_search/hashset/11: Analyzing +i8_slice_search/hashset/11 + time: [12.149 µs 12.214 µs 12.290 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/11 +Benchmarking i8_slice_search/branchless/11: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/11: Collecting 10 samples in estimated 100.12 ms (39k iterations) +Benchmarking i8_slice_search/branchless/11: Analyzing +i8_slice_search/branchless/11 + time: [2.5701 µs 2.5760 µs 2.5868 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/12 +Benchmarking i8_slice_search/contains/12: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/12: Collecting 10 samples in estimated 100.05 ms (3025 iterations) +Benchmarking i8_slice_search/contains/12: Analyzing +i8_slice_search/contains/12 + time: [32.613 µs 32.868 µs 33.179 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/12 +Benchmarking i8_slice_search/binary_search/12: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/12: Collecting 10 samples in estimated 100.78 ms (5885 iterations) +Benchmarking i8_slice_search/binary_search/12: Analyzing +i8_slice_search/binary_search/12 + time: [16.987 µs 17.080 µs 17.164 µs] +Benchmarking i8_slice_search/hashset/12 +Benchmarking i8_slice_search/hashset/12: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/12: Collecting 10 samples in estimated 100.48 ms (8030 iterations) +Benchmarking i8_slice_search/hashset/12: Analyzing +i8_slice_search/hashset/12 + time: [12.498 µs 12.625 µs 12.836 µs] +Benchmarking i8_slice_search/branchless/12 +Benchmarking i8_slice_search/branchless/12: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/12: Collecting 10 samples in estimated 100.08 ms (37k iterations) +Benchmarking i8_slice_search/branchless/12: Analyzing +i8_slice_search/branchless/12 + time: [2.6598 µs 2.6714 µs 2.6853 µs] +Benchmarking i8_slice_search/contains/13 +Benchmarking i8_slice_search/contains/13: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/13: Collecting 10 samples in estimated 100.10 ms (2805 iterations) +Benchmarking i8_slice_search/contains/13: Analyzing +i8_slice_search/contains/13 + time: [35.236 µs 35.633 µs 36.379 µs] +Benchmarking i8_slice_search/binary_search/13 +Benchmarking i8_slice_search/binary_search/13: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/13: Collecting 10 samples in estimated 100.56 ms (5885 iterations) +Benchmarking i8_slice_search/binary_search/13: Analyzing +i8_slice_search/binary_search/13 + time: [17.017 µs 17.066 µs 17.153 µs] +Benchmarking i8_slice_search/hashset/13 +Benchmarking i8_slice_search/hashset/13: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/13: Collecting 10 samples in estimated 100.19 ms (7205 iterations) +Benchmarking i8_slice_search/hashset/13: Analyzing +i8_slice_search/hashset/13 + time: [13.795 µs 13.840 µs 13.886 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high mild +Benchmarking i8_slice_search/branchless/13 +Benchmarking i8_slice_search/branchless/13: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/13: Collecting 10 samples in estimated 100.09 ms (36k iterations) +Benchmarking i8_slice_search/branchless/13: Analyzing +i8_slice_search/branchless/13 + time: [2.7446 µs 2.7513 µs 2.7657 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/14 +Benchmarking i8_slice_search/contains/14: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/14: Collecting 10 samples in estimated 101.37 ms (2805 iterations) +Benchmarking i8_slice_search/contains/14: Analyzing +i8_slice_search/contains/14 + time: [35.654 µs 35.706 µs 35.775 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/14 +Benchmarking i8_slice_search/binary_search/14: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/14: Collecting 10 samples in estimated 100.94 ms (5610 iterations) +Benchmarking i8_slice_search/binary_search/14: Analyzing +i8_slice_search/binary_search/14 + time: [17.726 µs 17.956 µs 18.277 µs] +Benchmarking i8_slice_search/hashset/14 +Benchmarking i8_slice_search/hashset/14: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/14: Collecting 10 samples in estimated 100.44 ms (6985 iterations) +Benchmarking i8_slice_search/hashset/14: Analyzing +i8_slice_search/hashset/14 + time: [14.355 µs 14.717 µs 15.060 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/14 +Benchmarking i8_slice_search/branchless/14: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/14: Collecting 10 samples in estimated 100.02 ms (35k iterations) +Benchmarking i8_slice_search/branchless/14: Analyzing +i8_slice_search/branchless/14 + time: [2.8093 µs 2.8160 µs 2.8275 µs] +Benchmarking i8_slice_search/contains/15 +Benchmarking i8_slice_search/contains/15: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/15: Collecting 10 samples in estimated 101.17 ms (2530 iterations) +Benchmarking i8_slice_search/contains/15: Analyzing +i8_slice_search/contains/15 + time: [40.723 µs 49.288 µs 55.677 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking i8_slice_search/binary_search/15 +Benchmarking i8_slice_search/binary_search/15: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/15: Collecting 10 samples in estimated 100.48 ms (5885 iterations) +Benchmarking i8_slice_search/binary_search/15: Analyzing +i8_slice_search/binary_search/15 + time: [16.993 µs 17.216 µs 17.840 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/15 +Benchmarking i8_slice_search/hashset/15: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/15: Collecting 10 samples in estimated 100.06 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/15: Analyzing +i8_slice_search/hashset/15 + time: [11.694 µs 11.719 µs 11.754 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/15 +Benchmarking i8_slice_search/branchless/15: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/15: Collecting 10 samples in estimated 100.04 ms (34k iterations) +Benchmarking i8_slice_search/branchless/15: Analyzing +i8_slice_search/branchless/15 + time: [2.8995 µs 2.9087 µs 2.9266 µs] +Benchmarking i8_slice_search/contains/16 +Benchmarking i8_slice_search/contains/16: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/16: Collecting 10 samples in estimated 100.88 ms (5830 iterations) +Benchmarking i8_slice_search/contains/16: Analyzing +i8_slice_search/contains/16 + time: [17.253 µs 17.333 µs 17.433 µs] +Benchmarking i8_slice_search/binary_search/16 +Benchmarking i8_slice_search/binary_search/16: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/16: Collecting 10 samples in estimated 100.54 ms (5885 iterations) +Benchmarking i8_slice_search/binary_search/16: Analyzing +i8_slice_search/binary_search/16 + time: [17.039 µs 17.096 µs 17.154 µs] +Benchmarking i8_slice_search/hashset/16 +Benchmarking i8_slice_search/hashset/16: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/16: Collecting 10 samples in estimated 100.11 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/16: Analyzing +i8_slice_search/hashset/16 + time: [11.684 µs 11.723 µs 11.769 µs] +Benchmarking i8_slice_search/branchless/16 +Benchmarking i8_slice_search/branchless/16: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/16: Collecting 10 samples in estimated 100.10 ms (33k iterations) +Benchmarking i8_slice_search/branchless/16: Analyzing +i8_slice_search/branchless/16 + time: [3.0363 µs 3.0805 µs 3.1444 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/17 +Benchmarking i8_slice_search/contains/17: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/17: Collecting 10 samples in estimated 100.21 ms (5830 iterations) +Benchmarking i8_slice_search/contains/17: Analyzing +i8_slice_search/contains/17 + time: [17.086 µs 17.128 µs 17.178 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/17 +Benchmarking i8_slice_search/binary_search/17: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/17: Collecting 10 samples in estimated 100.60 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/17: Analyzing +i8_slice_search/binary_search/17 + time: [20.672 µs 20.755 µs 20.854 µs] +Benchmarking i8_slice_search/hashset/17 +Benchmarking i8_slice_search/hashset/17: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/17: Collecting 10 samples in estimated 100.12 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/17: Analyzing +i8_slice_search/hashset/17 + time: [11.680 µs 11.719 µs 11.758 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/17 +Benchmarking i8_slice_search/branchless/17: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/17: Collecting 10 samples in estimated 100.10 ms (33k iterations) +Benchmarking i8_slice_search/branchless/17: Analyzing +i8_slice_search/branchless/17 + time: [3.0552 µs 3.0659 µs 3.0853 µs] +Benchmarking i8_slice_search/contains/18 +Benchmarking i8_slice_search/contains/18: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/18: Collecting 10 samples in estimated 101.15 ms (4730 iterations) +Benchmarking i8_slice_search/contains/18: Analyzing +i8_slice_search/contains/18 + time: [21.293 µs 21.340 µs 21.409 µs] +Benchmarking i8_slice_search/binary_search/18 +Benchmarking i8_slice_search/binary_search/18: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/18: Collecting 10 samples in estimated 100.23 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/18: Analyzing +i8_slice_search/binary_search/18 + time: [20.751 µs 20.813 µs 20.912 µs] +Benchmarking i8_slice_search/hashset/18 +Benchmarking i8_slice_search/hashset/18: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/18: Collecting 10 samples in estimated 100.26 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/18: Analyzing +i8_slice_search/hashset/18 + time: [11.701 µs 11.822 µs 12.018 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/18 +Benchmarking i8_slice_search/branchless/18: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/18: Collecting 10 samples in estimated 100.10 ms (32k iterations) +Benchmarking i8_slice_search/branchless/18: Analyzing +i8_slice_search/branchless/18 + time: [3.1237 µs 3.1329 µs 3.1394 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/19 +Benchmarking i8_slice_search/contains/19: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/19: Collecting 10 samples in estimated 100.36 ms (4345 iterations) +Benchmarking i8_slice_search/contains/19: Analyzing +i8_slice_search/contains/19 + time: [23.001 µs 23.091 µs 23.188 µs] +Benchmarking i8_slice_search/binary_search/19 +Benchmarking i8_slice_search/binary_search/19: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/19: Collecting 10 samples in estimated 100.31 ms (4565 iterations) +Benchmarking i8_slice_search/binary_search/19: Analyzing +i8_slice_search/binary_search/19 + time: [20.753 µs 20.864 µs 21.092 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/19 +Benchmarking i8_slice_search/hashset/19: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/19: Collecting 10 samples in estimated 100.40 ms (6655 iterations) +Benchmarking i8_slice_search/hashset/19: Analyzing +i8_slice_search/hashset/19 + time: [15.161 µs 16.886 µs 19.417 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/19 +Benchmarking i8_slice_search/branchless/19: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/19: Collecting 10 samples in estimated 100.05 ms (31k iterations) +Benchmarking i8_slice_search/branchless/19: Analyzing +i8_slice_search/branchless/19 + time: [3.2089 µs 3.2389 µs 3.2730 µs] +Benchmarking i8_slice_search/contains/20 +Benchmarking i8_slice_search/contains/20: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/20: Collecting 10 samples in estimated 100.25 ms (4015 iterations) +Benchmarking i8_slice_search/contains/20: Analyzing +i8_slice_search/contains/20 + time: [24.736 µs 24.825 µs 24.915 µs] +Benchmarking i8_slice_search/binary_search/20 +Benchmarking i8_slice_search/binary_search/20: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/20: Collecting 10 samples in estimated 100.87 ms (4785 iterations) +Benchmarking i8_slice_search/binary_search/20: Analyzing +i8_slice_search/binary_search/20 + time: [20.753 µs 20.857 µs 20.973 µs] +Benchmarking i8_slice_search/hashset/20 +Benchmarking i8_slice_search/hashset/20: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/20: Collecting 10 samples in estimated 100.43 ms (8415 iterations) +Benchmarking i8_slice_search/hashset/20: Analyzing +i8_slice_search/hashset/20 + time: [11.930 µs 11.970 µs 12.016 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i8_slice_search/branchless/20 +Benchmarking i8_slice_search/branchless/20: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/20: Collecting 10 samples in estimated 100.09 ms (30k iterations) +Benchmarking i8_slice_search/branchless/20: Analyzing +i8_slice_search/branchless/20 + time: [3.2914 µs 3.3097 µs 3.3271 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i8_slice_search/contains/21 +Benchmarking i8_slice_search/contains/21: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/21: Collecting 10 samples in estimated 100.21 ms (3630 iterations) +Benchmarking i8_slice_search/contains/21: Analyzing +i8_slice_search/contains/21 + time: [27.412 µs 27.531 µs 27.658 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/21 +Benchmarking i8_slice_search/binary_search/21: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/21: Collecting 10 samples in estimated 100.79 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/21: Analyzing +i8_slice_search/binary_search/21 + time: [37.053 µs 52.874 µs 59.996 µs] +Benchmarking i8_slice_search/hashset/21 +Benchmarking i8_slice_search/hashset/21: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/21: Collecting 10 samples in estimated 100.43 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/21: Analyzing +i8_slice_search/hashset/21 + time: [11.692 µs 11.722 µs 11.771 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/21 +Benchmarking i8_slice_search/branchless/21: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/21: Collecting 10 samples in estimated 100.17 ms (30k iterations) +Benchmarking i8_slice_search/branchless/21: Analyzing +i8_slice_search/branchless/21 + time: [3.3813 µs 3.3986 µs 3.4178 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/22 +Benchmarking i8_slice_search/contains/22: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/22: Collecting 10 samples in estimated 100.35 ms (3465 iterations) +Benchmarking i8_slice_search/contains/22: Analyzing +i8_slice_search/contains/22 + time: [28.466 µs 28.567 µs 28.643 µs] +Benchmarking i8_slice_search/binary_search/22 +Benchmarking i8_slice_search/binary_search/22: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/22: Collecting 10 samples in estimated 100.39 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/22: Analyzing +i8_slice_search/binary_search/22 + time: [20.716 µs 20.790 µs 20.858 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/22 +Benchmarking i8_slice_search/hashset/22: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/22: Collecting 10 samples in estimated 100.30 ms (8360 iterations) +Benchmarking i8_slice_search/hashset/22: Analyzing +i8_slice_search/hashset/22 + time: [11.925 µs 11.955 µs 12.004 µs] +Benchmarking i8_slice_search/branchless/22 +Benchmarking i8_slice_search/branchless/22: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/22: Collecting 10 samples in estimated 100.12 ms (29k iterations) +Benchmarking i8_slice_search/branchless/22: Analyzing +i8_slice_search/branchless/22 + time: [3.4614 µs 3.4722 µs 3.4805 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/23 +Benchmarking i8_slice_search/contains/23: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/23: Collecting 10 samples in estimated 100.61 ms (3300 iterations) +Benchmarking i8_slice_search/contains/23: Analyzing +i8_slice_search/contains/23 + time: [30.398 µs 30.504 µs 30.682 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/23 +Benchmarking i8_slice_search/binary_search/23: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/23: Collecting 10 samples in estimated 100.85 ms (4730 iterations) +Benchmarking i8_slice_search/binary_search/23: Analyzing +i8_slice_search/binary_search/23 + time: [20.715 µs 20.804 µs 20.887 µs] +Benchmarking i8_slice_search/hashset/23 +Benchmarking i8_slice_search/hashset/23: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/23: Collecting 10 samples in estimated 100.39 ms (7700 iterations) +Benchmarking i8_slice_search/hashset/23: Analyzing +i8_slice_search/hashset/23 + time: [13.032 µs 13.063 µs 13.087 µs] +Benchmarking i8_slice_search/branchless/23 +Benchmarking i8_slice_search/branchless/23: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/23: Collecting 10 samples in estimated 100.18 ms (28k iterations) +Benchmarking i8_slice_search/branchless/23: Analyzing +i8_slice_search/branchless/23 + time: [3.5546 µs 3.5778 µs 3.6066 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/24 +Benchmarking i8_slice_search/contains/24: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/24: Collecting 10 samples in estimated 100.51 ms (3025 iterations) +Benchmarking i8_slice_search/contains/24: Analyzing +i8_slice_search/contains/24 + time: [32.724 µs 33.008 µs 33.730 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/24 +Benchmarking i8_slice_search/binary_search/24: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/24: Collecting 10 samples in estimated 101.08 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/24: Analyzing +i8_slice_search/binary_search/24 + time: [20.706 µs 20.774 µs 20.876 µs] +Benchmarking i8_slice_search/hashset/24 +Benchmarking i8_slice_search/hashset/24: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/24: Collecting 10 samples in estimated 100.62 ms (6930 iterations) +Benchmarking i8_slice_search/hashset/24: Analyzing +i8_slice_search/hashset/24 + time: [14.459 µs 14.543 µs 14.622 µs] +Benchmarking i8_slice_search/branchless/24 +Benchmarking i8_slice_search/branchless/24: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/24: Collecting 10 samples in estimated 100.14 ms (27k iterations) +Benchmarking i8_slice_search/branchless/24: Analyzing +i8_slice_search/branchless/24 + time: [3.6323 µs 3.6456 µs 3.6635 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/25 +Benchmarking i8_slice_search/contains/25: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/25: Collecting 10 samples in estimated 101.25 ms (2750 iterations) +Benchmarking i8_slice_search/contains/25: Analyzing +i8_slice_search/contains/25 + time: [36.917 µs 37.135 µs 37.492 µs] +Benchmarking i8_slice_search/binary_search/25 +Benchmarking i8_slice_search/binary_search/25: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/25: Collecting 10 samples in estimated 100.49 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/25: Analyzing +i8_slice_search/binary_search/25 + time: [20.679 µs 20.738 µs 20.838 µs] +Benchmarking i8_slice_search/hashset/25 +Benchmarking i8_slice_search/hashset/25: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/25: Collecting 10 samples in estimated 100.17 ms (6765 iterations) +Benchmarking i8_slice_search/hashset/25: Analyzing +i8_slice_search/hashset/25 + time: [14.841 µs 14.961 µs 15.064 µs] +Benchmarking i8_slice_search/branchless/25 +Benchmarking i8_slice_search/branchless/25: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/25: Collecting 10 samples in estimated 100.08 ms (27k iterations) +Benchmarking i8_slice_search/branchless/25: Analyzing +i8_slice_search/branchless/25 + time: [3.7078 µs 3.7224 µs 3.7381 µs] +Benchmarking i8_slice_search/contains/26 +Benchmarking i8_slice_search/contains/26: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/26: Collecting 10 samples in estimated 100.12 ms (2585 iterations) +Benchmarking i8_slice_search/contains/26: Analyzing +i8_slice_search/contains/26 + time: [38.438 µs 38.587 µs 38.816 µs] +Benchmarking i8_slice_search/binary_search/26 +Benchmarking i8_slice_search/binary_search/26: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/26: Collecting 10 samples in estimated 100.46 ms (4730 iterations) +Benchmarking i8_slice_search/binary_search/26: Analyzing +i8_slice_search/binary_search/26 + time: [20.772 µs 20.868 µs 21.039 µs] +Benchmarking i8_slice_search/hashset/26 +Benchmarking i8_slice_search/hashset/26: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/26: Collecting 10 samples in estimated 100.73 ms (6380 iterations) +Benchmarking i8_slice_search/hashset/26: Analyzing +i8_slice_search/hashset/26 + time: [15.733 µs 15.764 µs 15.811 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/26 +Benchmarking i8_slice_search/branchless/26: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/26: Collecting 10 samples in estimated 100.00 ms (26k iterations) +Benchmarking i8_slice_search/branchless/26: Analyzing +i8_slice_search/branchless/26 + time: [3.7880 µs 3.7976 µs 3.8114 µs] +Benchmarking i8_slice_search/contains/27 +Benchmarking i8_slice_search/contains/27: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/27: Collecting 10 samples in estimated 101.66 ms (2475 iterations) +Benchmarking i8_slice_search/contains/27: Analyzing +i8_slice_search/contains/27 + time: [40.575 µs 40.722 µs 40.885 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/27 +Benchmarking i8_slice_search/binary_search/27: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/27: Collecting 10 samples in estimated 100.91 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/27: Analyzing +i8_slice_search/binary_search/27 + time: [20.688 µs 20.775 µs 20.871 µs] +Benchmarking i8_slice_search/hashset/27 +Benchmarking i8_slice_search/hashset/27: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/27: Collecting 10 samples in estimated 100.69 ms (5830 iterations) +Benchmarking i8_slice_search/hashset/27: Analyzing +i8_slice_search/hashset/27 + time: [17.234 µs 17.284 µs 17.387 µs] +Benchmarking i8_slice_search/branchless/27 +Benchmarking i8_slice_search/branchless/27: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/27: Collecting 10 samples in estimated 100.06 ms (26k iterations) +Benchmarking i8_slice_search/branchless/27: Analyzing +i8_slice_search/branchless/27 + time: [3.8722 µs 3.8830 µs 3.8951 µs] +Benchmarking i8_slice_search/contains/28 +Benchmarking i8_slice_search/contains/28: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/28: Collecting 10 samples in estimated 100.26 ms (2255 iterations) +Benchmarking i8_slice_search/contains/28: Analyzing +i8_slice_search/contains/28 + time: [44.177 µs 44.409 µs 44.658 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i8_slice_search/binary_search/28 +Benchmarking i8_slice_search/binary_search/28: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/28: Collecting 10 samples in estimated 101.13 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/28: Analyzing +i8_slice_search/binary_search/28 + time: [20.718 µs 20.766 µs 20.840 µs] +Benchmarking i8_slice_search/hashset/28 +Benchmarking i8_slice_search/hashset/28: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/28: Collecting 10 samples in estimated 100.67 ms (7040 iterations) +Benchmarking i8_slice_search/hashset/28: Analyzing +i8_slice_search/hashset/28 + time: [14.120 µs 14.286 µs 14.389 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/28 +Benchmarking i8_slice_search/branchless/28: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/28: Collecting 10 samples in estimated 100.09 ms (25k iterations) +Benchmarking i8_slice_search/branchless/28: Analyzing +i8_slice_search/branchless/28 + time: [3.9635 µs 3.9734 µs 3.9863 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i8_slice_search/contains/29 +Benchmarking i8_slice_search/contains/29: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/29: Collecting 10 samples in estimated 101.24 ms (2090 iterations) +Benchmarking i8_slice_search/contains/29: Analyzing +i8_slice_search/contains/29 + time: [48.432 µs 48.549 µs 48.721 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/29 +Benchmarking i8_slice_search/binary_search/29: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/29: Collecting 10 samples in estimated 100.99 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/29: Analyzing +i8_slice_search/binary_search/29 + time: [20.705 µs 20.785 µs 20.870 µs] +Benchmarking i8_slice_search/hashset/29 +Benchmarking i8_slice_search/hashset/29: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/29: Collecting 10 samples in estimated 100.18 ms (8415 iterations) +Benchmarking i8_slice_search/hashset/29: Analyzing +i8_slice_search/hashset/29 + time: [11.941 µs 12.007 µs 12.098 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/29 +Benchmarking i8_slice_search/branchless/29: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/29: Collecting 10 samples in estimated 100.09 ms (25k iterations) +Benchmarking i8_slice_search/branchless/29: Analyzing +i8_slice_search/branchless/29 + time: [4.0407 µs 4.0555 µs 4.0765 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/30 +Benchmarking i8_slice_search/contains/30: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/30: Collecting 10 samples in estimated 102.32 ms (2035 iterations) +Benchmarking i8_slice_search/contains/30: Analyzing +i8_slice_search/contains/30 + time: [50.179 µs 50.386 µs 50.589 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/30 +Benchmarking i8_slice_search/binary_search/30: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/30: Collecting 10 samples in estimated 100.93 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/30: Analyzing +i8_slice_search/binary_search/30 + time: [20.706 µs 20.786 µs 20.883 µs] +Benchmarking i8_slice_search/hashset/30 +Benchmarking i8_slice_search/hashset/30: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/30: Collecting 10 samples in estimated 100.18 ms (7535 iterations) +Benchmarking i8_slice_search/hashset/30: Analyzing +i8_slice_search/hashset/30 + time: [12.979 µs 13.085 µs 13.223 µs] +Benchmarking i8_slice_search/branchless/30 +Benchmarking i8_slice_search/branchless/30: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/30: Collecting 10 samples in estimated 100.09 ms (24k iterations) +Benchmarking i8_slice_search/branchless/30: Analyzing +i8_slice_search/branchless/30 + time: [4.1194 µs 4.1267 µs 4.1375 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/31 +Benchmarking i8_slice_search/contains/31: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/31: Collecting 10 samples in estimated 100.27 ms (1870 iterations) +Benchmarking i8_slice_search/contains/31: Analyzing +i8_slice_search/contains/31 + time: [52.911 µs 53.092 µs 53.253 µs] +Benchmarking i8_slice_search/binary_search/31 +Benchmarking i8_slice_search/binary_search/31: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/31: Collecting 10 samples in estimated 100.48 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/31: Analyzing +i8_slice_search/binary_search/31 + time: [20.770 µs 20.832 µs 20.926 µs] +Benchmarking i8_slice_search/hashset/31 +Benchmarking i8_slice_search/hashset/31: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/31: Collecting 10 samples in estimated 100.18 ms (8360 iterations) +Benchmarking i8_slice_search/hashset/31: Analyzing +i8_slice_search/hashset/31 + time: [11.927 µs 11.970 µs 12.009 µs] +Benchmarking i8_slice_search/branchless/31 +Benchmarking i8_slice_search/branchless/31: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/31: Collecting 10 samples in estimated 100.17 ms (24k iterations) +Benchmarking i8_slice_search/branchless/31: Analyzing +i8_slice_search/branchless/31 + time: [4.1927 µs 4.2098 µs 4.2320 µs] +Benchmarking i8_slice_search/contains/32 +Benchmarking i8_slice_search/contains/32: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/32: Collecting 10 samples in estimated 100.33 ms (4840 iterations) +Benchmarking i8_slice_search/contains/32: Analyzing +i8_slice_search/contains/32 + time: [20.632 µs 20.681 µs 20.739 µs] +Benchmarking i8_slice_search/binary_search/32 +Benchmarking i8_slice_search/binary_search/32: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/32: Collecting 10 samples in estimated 100.95 ms (4840 iterations) +Benchmarking i8_slice_search/binary_search/32: Analyzing +i8_slice_search/binary_search/32 + time: [20.692 µs 20.775 µs 20.850 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/hashset/32 +Benchmarking i8_slice_search/hashset/32: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/32: Collecting 10 samples in estimated 100.57 ms (7645 iterations) +Benchmarking i8_slice_search/hashset/32: Analyzing +i8_slice_search/hashset/32 + time: [12.931 µs 13.009 µs 13.088 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/32 +Benchmarking i8_slice_search/branchless/32: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/32: Collecting 10 samples in estimated 100.11 ms (22k iterations) +Benchmarking i8_slice_search/branchless/32: Analyzing +i8_slice_search/branchless/32 + time: [4.5556 µs 4.5694 µs 4.5914 µs] +Benchmarking i8_slice_search/contains/34 +Benchmarking i8_slice_search/contains/34: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/34: Collecting 10 samples in estimated 100.34 ms (4015 iterations) +Benchmarking i8_slice_search/contains/34: Analyzing +i8_slice_search/contains/34 + time: [24.554 µs 24.650 µs 24.770 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/34 +Benchmarking i8_slice_search/binary_search/34: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/34: Collecting 10 samples in estimated 100.85 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/34: Analyzing +i8_slice_search/binary_search/34 + time: [24.891 µs 24.985 µs 25.076 µs] +Benchmarking i8_slice_search/hashset/34 +Benchmarking i8_slice_search/hashset/34: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/34: Collecting 10 samples in estimated 100.72 ms (7205 iterations) +Benchmarking i8_slice_search/hashset/34: Analyzing +i8_slice_search/hashset/34 + time: [13.740 µs 13.778 µs 13.840 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i8_slice_search/branchless/34 +Benchmarking i8_slice_search/branchless/34: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/34: Collecting 10 samples in estimated 100.14 ms (20k iterations) +Benchmarking i8_slice_search/branchless/34: Analyzing +i8_slice_search/branchless/34 + time: [4.8961 µs 4.9127 µs 4.9411 µs] +Benchmarking i8_slice_search/contains/36 +Benchmarking i8_slice_search/contains/36: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/36: Collecting 10 samples in estimated 101.07 ms (3630 iterations) +Benchmarking i8_slice_search/contains/36: Analyzing +i8_slice_search/contains/36 + time: [27.668 µs 27.773 µs 27.968 µs] +Benchmarking i8_slice_search/binary_search/36 +Benchmarking i8_slice_search/binary_search/36: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/36: Collecting 10 samples in estimated 100.70 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/36: Analyzing +i8_slice_search/binary_search/36 + time: [24.936 µs 25.041 µs 25.120 µs] +Benchmarking i8_slice_search/hashset/36 +Benchmarking i8_slice_search/hashset/36: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/36: Collecting 10 samples in estimated 100.51 ms (7810 iterations) +Benchmarking i8_slice_search/hashset/36: Analyzing +i8_slice_search/hashset/36 + time: [12.754 µs 12.825 µs 12.882 µs] +Benchmarking i8_slice_search/branchless/36 +Benchmarking i8_slice_search/branchless/36: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/36: Collecting 10 samples in estimated 100.03 ms (20k iterations) +Benchmarking i8_slice_search/branchless/36: Analyzing +i8_slice_search/branchless/36 + time: [4.9728 µs 4.9830 µs 4.9993 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/38 +Benchmarking i8_slice_search/contains/38: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/38: Collecting 10 samples in estimated 100.95 ms (3135 iterations) +Benchmarking i8_slice_search/contains/38: Analyzing +i8_slice_search/contains/38 + time: [56.485 µs 68.097 µs 79.067 µs] +Benchmarking i8_slice_search/binary_search/38 +Benchmarking i8_slice_search/binary_search/38: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/38: Collecting 10 samples in estimated 100.90 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/38: Analyzing +i8_slice_search/binary_search/38 + time: [24.985 µs 25.070 µs 25.194 µs] +Benchmarking i8_slice_search/hashset/38 +Benchmarking i8_slice_search/hashset/38: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/38: Collecting 10 samples in estimated 100.66 ms (7865 iterations) +Benchmarking i8_slice_search/hashset/38: Analyzing +i8_slice_search/hashset/38 + time: [12.697 µs 12.754 µs 12.802 µs] +Benchmarking i8_slice_search/branchless/38 +Benchmarking i8_slice_search/branchless/38: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/38: Collecting 10 samples in estimated 100.23 ms (20k iterations) +Benchmarking i8_slice_search/branchless/38: Analyzing +i8_slice_search/branchless/38 + time: [5.1036 µs 5.1138 µs 5.1275 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/40 +Benchmarking i8_slice_search/contains/40: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/40: Collecting 10 samples in estimated 100.48 ms (2530 iterations) +Benchmarking i8_slice_search/contains/40: Analyzing +i8_slice_search/contains/40 + time: [39.281 µs 39.374 µs 39.565 µs] +Benchmarking i8_slice_search/binary_search/40 +Benchmarking i8_slice_search/binary_search/40: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/40: Collecting 10 samples in estimated 100.43 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/40: Analyzing +i8_slice_search/binary_search/40 + time: [24.910 µs 25.086 µs 25.233 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/40 +Benchmarking i8_slice_search/hashset/40: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/40: Collecting 10 samples in estimated 100.41 ms (7095 iterations) +Benchmarking i8_slice_search/hashset/40: Analyzing +i8_slice_search/hashset/40 + time: [13.790 µs 14.145 µs 14.563 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/40 +Benchmarking i8_slice_search/branchless/40: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/40: Collecting 10 samples in estimated 100.03 ms (19k iterations) +Benchmarking i8_slice_search/branchless/40: Analyzing +i8_slice_search/branchless/40 + time: [5.1591 µs 5.1803 µs 5.2111 µs] +Benchmarking i8_slice_search/contains/42 +Benchmarking i8_slice_search/contains/42: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/42: Collecting 10 samples in estimated 100.85 ms (2420 iterations) +Benchmarking i8_slice_search/contains/42: Analyzing +i8_slice_search/contains/42 + time: [41.421 µs 41.555 µs 41.731 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high severe +Benchmarking i8_slice_search/binary_search/42 +Benchmarking i8_slice_search/binary_search/42: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/42: Collecting 10 samples in estimated 101.24 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/42: Analyzing +i8_slice_search/binary_search/42 + time: [24.993 µs 25.182 µs 25.343 µs] +Benchmarking i8_slice_search/hashset/42 +Benchmarking i8_slice_search/hashset/42: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/42: Collecting 10 samples in estimated 100.33 ms (8525 iterations) +Benchmarking i8_slice_search/hashset/42: Analyzing +i8_slice_search/hashset/42 + time: [11.722 µs 11.764 µs 11.807 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/42 +Benchmarking i8_slice_search/branchless/42: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/42: Collecting 10 samples in estimated 100.04 ms (18k iterations) +Benchmarking i8_slice_search/branchless/42: Analyzing +i8_slice_search/branchless/42 + time: [5.3695 µs 5.3908 µs 5.4154 µs] +Benchmarking i8_slice_search/contains/44 +Benchmarking i8_slice_search/contains/44: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/44: Collecting 10 samples in estimated 100.65 ms (2145 iterations) +Benchmarking i8_slice_search/contains/44: Analyzing +i8_slice_search/contains/44 + time: [46.805 µs 46.942 µs 47.121 µs] +Benchmarking i8_slice_search/binary_search/44 +Benchmarking i8_slice_search/binary_search/44: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/44: Collecting 10 samples in estimated 100.63 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/44: Analyzing +i8_slice_search/binary_search/44 + time: [24.936 µs 25.010 µs 25.087 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/hashset/44 +Benchmarking i8_slice_search/hashset/44: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/44: Collecting 10 samples in estimated 100.09 ms (6655 iterations) +Benchmarking i8_slice_search/hashset/44: Analyzing +i8_slice_search/hashset/44 + time: [14.764 µs 15.046 µs 15.699 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/44 +Benchmarking i8_slice_search/branchless/44: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/44: Collecting 10 samples in estimated 100.01 ms (18k iterations) +Benchmarking i8_slice_search/branchless/44: Analyzing +i8_slice_search/branchless/44 + time: [5.5233 µs 5.5440 µs 5.5673 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/46 +Benchmarking i8_slice_search/contains/46: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/46: Collecting 10 samples in estimated 101.97 ms (1980 iterations) +Benchmarking i8_slice_search/contains/46: Analyzing +i8_slice_search/contains/46 + time: [51.158 µs 51.357 µs 51.626 µs] +Benchmarking i8_slice_search/binary_search/46 +Benchmarking i8_slice_search/binary_search/46: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/46: Collecting 10 samples in estimated 100.92 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/46: Analyzing +i8_slice_search/binary_search/46 + time: [24.889 µs 24.953 µs 25.055 µs] +Benchmarking i8_slice_search/hashset/46 +Benchmarking i8_slice_search/hashset/46: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/46: Collecting 10 samples in estimated 100.04 ms (8085 iterations) +Benchmarking i8_slice_search/hashset/46: Analyzing +i8_slice_search/hashset/46 + time: [12.230 µs 12.268 µs 12.315 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/46 +Benchmarking i8_slice_search/branchless/46: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/46: Collecting 10 samples in estimated 100.26 ms (18k iterations) +Benchmarking i8_slice_search/branchless/46: Analyzing +i8_slice_search/branchless/46 + time: [5.6292 µs 5.6470 µs 5.6770 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/48 +Benchmarking i8_slice_search/contains/48: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/48: Collecting 10 samples in estimated 101.44 ms (3795 iterations) +Benchmarking i8_slice_search/contains/48: Analyzing +i8_slice_search/contains/48 + time: [26.682 µs 26.823 µs 27.024 µs] +Benchmarking i8_slice_search/binary_search/48 +Benchmarking i8_slice_search/binary_search/48: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/48: Collecting 10 samples in estimated 100.10 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/48: Analyzing +i8_slice_search/binary_search/48 + time: [24.887 µs 24.970 µs 25.046 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/hashset/48 +Benchmarking i8_slice_search/hashset/48: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/48: Collecting 10 samples in estimated 100.45 ms (7865 iterations) +Benchmarking i8_slice_search/hashset/48: Analyzing +i8_slice_search/hashset/48 + time: [12.630 µs 12.678 µs 12.736 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/48 +Benchmarking i8_slice_search/branchless/48: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/48: Collecting 10 samples in estimated 100.10 ms (17k iterations) +Benchmarking i8_slice_search/branchless/48: Analyzing +i8_slice_search/branchless/48 + time: [5.7830 µs 5.8062 µs 5.8335 µs] +Benchmarking i8_slice_search/contains/50 +Benchmarking i8_slice_search/contains/50: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/50: Collecting 10 samples in estimated 100.36 ms (3245 iterations) +Benchmarking i8_slice_search/contains/50: Analyzing +i8_slice_search/contains/50 + time: [30.428 µs 30.559 µs 30.657 µs] +Benchmarking i8_slice_search/binary_search/50 +Benchmarking i8_slice_search/binary_search/50: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/50: Collecting 10 samples in estimated 101.24 ms (1815 iterations) +Benchmarking i8_slice_search/binary_search/50: Analyzing +i8_slice_search/binary_search/50 + time: [25.807 µs 27.734 µs 30.313 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/50 +Benchmarking i8_slice_search/hashset/50: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/50: Collecting 10 samples in estimated 100.20 ms (7535 iterations) +Benchmarking i8_slice_search/hashset/50: Analyzing +i8_slice_search/hashset/50 + time: [13.325 µs 13.366 µs 13.412 µs] +Benchmarking i8_slice_search/branchless/50 +Benchmarking i8_slice_search/branchless/50: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/50: Collecting 10 samples in estimated 100.05 ms (17k iterations) +Benchmarking i8_slice_search/branchless/50: Analyzing +i8_slice_search/branchless/50 + time: [5.9653 µs 5.9806 µs 6.0027 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i8_slice_search/contains/52 +Benchmarking i8_slice_search/contains/52: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/52: Collecting 10 samples in estimated 101.45 ms (2640 iterations) +Benchmarking i8_slice_search/contains/52: Analyzing +i8_slice_search/contains/52 + time: [38.283 µs 38.443 µs 38.637 µs] +Benchmarking i8_slice_search/binary_search/52 +Benchmarking i8_slice_search/binary_search/52: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/52: Collecting 10 samples in estimated 100.63 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/52: Analyzing +i8_slice_search/binary_search/52 + time: [24.919 µs 24.986 µs 25.123 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/52 +Benchmarking i8_slice_search/hashset/52: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/52: Collecting 10 samples in estimated 100.19 ms (7095 iterations) +Benchmarking i8_slice_search/hashset/52: Analyzing +i8_slice_search/hashset/52 + time: [14.018 µs 14.080 µs 14.167 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i8_slice_search/branchless/52 +Benchmarking i8_slice_search/branchless/52: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/52: Collecting 10 samples in estimated 100.05 ms (16k iterations) +Benchmarking i8_slice_search/branchless/52: Analyzing +i8_slice_search/branchless/52 + time: [6.1497 µs 6.1704 µs 6.1926 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/contains/54 +Benchmarking i8_slice_search/contains/54: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/54: Collecting 10 samples in estimated 100.99 ms (2420 iterations) +Benchmarking i8_slice_search/contains/54: Analyzing +i8_slice_search/contains/54 + time: [41.579 µs 41.786 µs 41.962 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/54 +Benchmarking i8_slice_search/binary_search/54: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/54: Collecting 10 samples in estimated 100.21 ms (3960 iterations) +Benchmarking i8_slice_search/binary_search/54: Analyzing +i8_slice_search/binary_search/54 + time: [24.957 µs 25.045 µs 25.144 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/hashset/54 +Benchmarking i8_slice_search/hashset/54: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/54: Collecting 10 samples in estimated 100.79 ms (6435 iterations) +Benchmarking i8_slice_search/hashset/54: Analyzing +i8_slice_search/hashset/54 + time: [15.349 µs 15.407 µs 15.462 µs] +Benchmarking i8_slice_search/branchless/54 +Benchmarking i8_slice_search/branchless/54: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/54: Collecting 10 samples in estimated 100.25 ms (15k iterations) +Benchmarking i8_slice_search/branchless/54: Analyzing +i8_slice_search/branchless/54 + time: [6.4548 µs 6.4665 µs 6.4833 µs] +Benchmarking i8_slice_search/contains/56 +Benchmarking i8_slice_search/contains/56: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/56: Collecting 10 samples in estimated 100.78 ms (2090 iterations) +Benchmarking i8_slice_search/contains/56: Analyzing +i8_slice_search/contains/56 + time: [43.931 µs 44.312 µs 44.939 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/binary_search/56 +Benchmarking i8_slice_search/binary_search/56: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/56: Collecting 10 samples in estimated 100.23 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/56: Analyzing +i8_slice_search/binary_search/56 + time: [24.768 µs 24.927 µs 25.079 µs] +Benchmarking i8_slice_search/hashset/56 +Benchmarking i8_slice_search/hashset/56: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/56: Collecting 10 samples in estimated 100.46 ms (6710 iterations) +Benchmarking i8_slice_search/hashset/56: Analyzing +i8_slice_search/hashset/56 + time: [14.963 µs 15.014 µs 15.053 µs] +Benchmarking i8_slice_search/branchless/56 +Benchmarking i8_slice_search/branchless/56: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/56: Collecting 10 samples in estimated 100.32 ms (15k iterations) +Benchmarking i8_slice_search/branchless/56: Analyzing +i8_slice_search/branchless/56 + time: [6.5992 µs 6.6301 µs 6.6540 µs] +Benchmarking i8_slice_search/contains/58 +Benchmarking i8_slice_search/contains/58: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/58: Collecting 10 samples in estimated 100.87 ms (2035 iterations) +Benchmarking i8_slice_search/contains/58: Analyzing +i8_slice_search/contains/58 + time: [49.120 µs 49.241 µs 49.381 µs] +Benchmarking i8_slice_search/binary_search/58 +Benchmarking i8_slice_search/binary_search/58: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/58: Collecting 10 samples in estimated 100.26 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/58: Analyzing +i8_slice_search/binary_search/58 + time: [24.904 µs 25.130 µs 25.354 µs] +Benchmarking i8_slice_search/hashset/58 +Benchmarking i8_slice_search/hashset/58: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/58: Collecting 10 samples in estimated 100.73 ms (6985 iterations) +Benchmarking i8_slice_search/hashset/58: Analyzing +i8_slice_search/hashset/58 + time: [14.046 µs 14.096 µs 14.147 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/58 +Benchmarking i8_slice_search/branchless/58: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/58: Collecting 10 samples in estimated 100.13 ms (15k iterations) +Benchmarking i8_slice_search/branchless/58: Analyzing +i8_slice_search/branchless/58 + time: [6.7195 µs 6.8049 µs 6.8910 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/contains/60 +Benchmarking i8_slice_search/contains/60: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/60: Collecting 10 samples in estimated 100.15 ms (1870 iterations) +Benchmarking i8_slice_search/contains/60: Analyzing +i8_slice_search/contains/60 + time: [53.312 µs 53.564 µs 53.769 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/binary_search/60 +Benchmarking i8_slice_search/binary_search/60: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/60: Collecting 10 samples in estimated 100.78 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/60: Analyzing +i8_slice_search/binary_search/60 + time: [24.942 µs 25.062 µs 25.160 µs] +Benchmarking i8_slice_search/hashset/60 +Benchmarking i8_slice_search/hashset/60: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/60: Collecting 10 samples in estimated 100.23 ms (7645 iterations) +Benchmarking i8_slice_search/hashset/60: Analyzing +i8_slice_search/hashset/60 + time: [13.024 µs 13.148 µs 13.255 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/60 +Benchmarking i8_slice_search/branchless/60: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/60: Collecting 10 samples in estimated 100.04 ms (14k iterations) +Benchmarking i8_slice_search/branchless/60: Analyzing +i8_slice_search/branchless/60 + time: [6.9854 µs 7.0144 µs 7.0490 µs] +Benchmarking i8_slice_search/contains/62 +Benchmarking i8_slice_search/contains/62: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/62: Collecting 10 samples in estimated 103.10 ms (1760 iterations) +Benchmarking i8_slice_search/contains/62: Analyzing +i8_slice_search/contains/62 + time: [57.950 µs 58.141 µs 58.361 µs] +Benchmarking i8_slice_search/binary_search/62 +Benchmarking i8_slice_search/binary_search/62: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/62: Collecting 10 samples in estimated 100.65 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/62: Analyzing +i8_slice_search/binary_search/62 + time: [24.822 µs 24.946 µs 25.056 µs] +Benchmarking i8_slice_search/hashset/62 +Benchmarking i8_slice_search/hashset/62: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/62: Collecting 10 samples in estimated 100.09 ms (7205 iterations) +Benchmarking i8_slice_search/hashset/62: Analyzing +i8_slice_search/hashset/62 + time: [13.855 µs 13.913 µs 13.974 µs] +Benchmarking i8_slice_search/branchless/62 +Benchmarking i8_slice_search/branchless/62: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/62: Collecting 10 samples in estimated 100.29 ms (14k iterations) +Benchmarking i8_slice_search/branchless/62: Analyzing +i8_slice_search/branchless/62 + time: [7.0237 µs 7.0510 µs 7.0731 µs] +Benchmarking i8_slice_search/contains/64 +Benchmarking i8_slice_search/contains/64: Warming up for 50.000 ms +Benchmarking i8_slice_search/contains/64: Collecting 10 samples in estimated 101.72 ms (3135 iterations) +Benchmarking i8_slice_search/contains/64: Analyzing +i8_slice_search/contains/64 + time: [32.226 µs 32.403 µs 32.535 µs] +Benchmarking i8_slice_search/binary_search/64 +Benchmarking i8_slice_search/binary_search/64: Warming up for 50.000 ms +Benchmarking i8_slice_search/binary_search/64: Collecting 10 samples in estimated 100.57 ms (4015 iterations) +Benchmarking i8_slice_search/binary_search/64: Analyzing +i8_slice_search/binary_search/64 + time: [24.886 µs 24.968 µs 25.079 µs] +Benchmarking i8_slice_search/hashset/64 +Benchmarking i8_slice_search/hashset/64: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/64: Collecting 10 samples in estimated 100.36 ms (7150 iterations) +Benchmarking i8_slice_search/hashset/64: Analyzing +i8_slice_search/hashset/64 + time: [13.897 µs 13.946 µs 13.992 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/64 +Benchmarking i8_slice_search/branchless/64: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/64: Collecting 10 samples in estimated 100.02 ms (12k iterations) +Benchmarking i8_slice_search/branchless/64: Analyzing +i8_slice_search/branchless/64 + time: [7.2870 µs 7.3505 µs 7.4153 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i8_slice_search/hashset/80 +Benchmarking i8_slice_search/hashset/80: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/80: Collecting 10 samples in estimated 100.32 ms (7810 iterations) +Benchmarking i8_slice_search/hashset/80: Analyzing +i8_slice_search/hashset/80 + time: [12.643 µs 12.716 µs 12.803 µs] +Benchmarking i8_slice_search/branchless/80 +Benchmarking i8_slice_search/branchless/80: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/80: Collecting 10 samples in estimated 100.11 ms (9295 iterations) +Benchmarking i8_slice_search/branchless/80: Analyzing +i8_slice_search/branchless/80 + time: [10.735 µs 10.777 µs 10.836 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i8_slice_search/hashset/96 +Benchmarking i8_slice_search/hashset/96: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/96: Collecting 10 samples in estimated 100.60 ms (7480 iterations) +Benchmarking i8_slice_search/hashset/96: Analyzing +i8_slice_search/hashset/96 + time: [13.354 µs 13.407 µs 13.456 µs] +Benchmarking i8_slice_search/branchless/96 +Benchmarking i8_slice_search/branchless/96: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/96: Collecting 10 samples in estimated 100.14 ms (11k iterations) +Benchmarking i8_slice_search/branchless/96: Analyzing +i8_slice_search/branchless/96 + time: [9.1285 µs 9.1513 µs 9.1951 µs] +Benchmarking i8_slice_search/hashset/112 +Benchmarking i8_slice_search/hashset/112: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/112: Collecting 10 samples in estimated 100.00 ms (5720 iterations) +Benchmarking i8_slice_search/hashset/112: Analyzing +i8_slice_search/hashset/112 + time: [32.708 µs 42.594 µs 49.752 µs] +Benchmarking i8_slice_search/branchless/112 +Benchmarking i8_slice_search/branchless/112: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/112: Collecting 10 samples in estimated 100.64 ms (7535 iterations) +Benchmarking i8_slice_search/branchless/112: Analyzing +i8_slice_search/branchless/112 + time: [13.300 µs 13.339 µs 13.379 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i8_slice_search/hashset/128 +Benchmarking i8_slice_search/hashset/128: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/128: Collecting 10 samples in estimated 100.34 ms (6820 iterations) +Benchmarking i8_slice_search/hashset/128: Analyzing +i8_slice_search/hashset/128 + time: [14.658 µs 14.704 µs 14.750 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i8_slice_search/branchless/128 +Benchmarking i8_slice_search/branchless/128: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/128: Collecting 10 samples in estimated 100.09 ms (8470 iterations) +Benchmarking i8_slice_search/branchless/128: Analyzing +i8_slice_search/branchless/128 + time: [11.786 µs 11.805 µs 11.840 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/hashset/160 +Benchmarking i8_slice_search/hashset/160: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/160: Collecting 10 samples in estimated 100.34 ms (6600 iterations) +Benchmarking i8_slice_search/hashset/160: Analyzing +i8_slice_search/hashset/160 + time: [15.123 µs 15.179 µs 15.239 µs] +Benchmarking i8_slice_search/branchless/160 +Benchmarking i8_slice_search/branchless/160: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/160: Collecting 10 samples in estimated 100.88 ms (5775 iterations) +Benchmarking i8_slice_search/branchless/160: Analyzing +i8_slice_search/branchless/160 + time: [17.376 µs 17.407 µs 17.451 µs] +Benchmarking i8_slice_search/hashset/192 +Benchmarking i8_slice_search/hashset/192: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/192: Collecting 10 samples in estimated 100.39 ms (6820 iterations) +Benchmarking i8_slice_search/hashset/192: Analyzing +i8_slice_search/hashset/192 + time: [14.701 µs 14.735 µs 14.780 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/192 +Benchmarking i8_slice_search/branchless/192: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/192: Collecting 10 samples in estimated 100.68 ms (5885 iterations) +Benchmarking i8_slice_search/branchless/192: Analyzing +i8_slice_search/branchless/192 + time: [16.977 µs 17.017 µs 17.073 µs] +Benchmarking i8_slice_search/hashset/224 +Benchmarking i8_slice_search/hashset/224: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/224: Collecting 10 samples in estimated 100.06 ms (7150 iterations) +Benchmarking i8_slice_search/hashset/224: Analyzing +i8_slice_search/hashset/224 + time: [13.863 µs 13.910 µs 13.966 µs] +Benchmarking i8_slice_search/branchless/224 +Benchmarking i8_slice_search/branchless/224: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/224: Collecting 10 samples in estimated 100.30 ms (4400 iterations) +Benchmarking i8_slice_search/branchless/224: Analyzing +i8_slice_search/branchless/224 + time: [22.601 µs 22.695 µs 22.801 µs] +Benchmarking i8_slice_search/hashset/256 +Benchmarking i8_slice_search/hashset/256: Warming up for 50.000 ms +Benchmarking i8_slice_search/hashset/256: Collecting 10 samples in estimated 100.00 ms (7810 iterations) +Benchmarking i8_slice_search/hashset/256: Analyzing +i8_slice_search/hashset/256 + time: [12.773 µs 12.807 µs 12.844 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i8_slice_search/branchless/256 +Benchmarking i8_slice_search/branchless/256: Warming up for 50.000 ms +Benchmarking i8_slice_search/branchless/256: Collecting 10 samples in estimated 100.33 ms (4235 iterations) +Benchmarking i8_slice_search/branchless/256: Analyzing +i8_slice_search/branchless/256 + time: [23.477 µs 23.611 µs 23.728 µs] + +Benchmarking i16_slice_search/contains/2 +Benchmarking i16_slice_search/contains/2: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/2: Collecting 10 samples in estimated 100.83 ms (6490 iterations) +Benchmarking i16_slice_search/contains/2: Analyzing +i16_slice_search/contains/2 + time: [15.426 µs 15.482 µs 15.506 µs] +Benchmarking i16_slice_search/binary_search/2 +Benchmarking i16_slice_search/binary_search/2: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/2: Collecting 10 samples in estimated 100.02 ms (15k iterations) +Benchmarking i16_slice_search/binary_search/2: Analyzing +i16_slice_search/binary_search/2 + time: [6.7618 µs 6.8077 µs 6.8721 µs] +Benchmarking i16_slice_search/hashset/2 +Benchmarking i16_slice_search/hashset/2: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/2: Collecting 10 samples in estimated 100.01 ms (8305 iterations) +Benchmarking i16_slice_search/hashset/2: Analyzing +i16_slice_search/hashset/2 + time: [11.837 µs 11.905 µs 12.022 µs] +Benchmarking i16_slice_search/branchless/2 +Benchmarking i16_slice_search/branchless/2: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/2: Collecting 10 samples in estimated 100.04 ms (50k iterations) +Benchmarking i16_slice_search/branchless/2: Analyzing +i16_slice_search/branchless/2 + time: [2.0116 µs 2.0185 µs 2.0264 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i16_slice_search/contains/3 +Benchmarking i16_slice_search/contains/3: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/3: Collecting 10 samples in estimated 100.50 ms (5885 iterations) +Benchmarking i16_slice_search/contains/3: Analyzing +i16_slice_search/contains/3 + time: [16.984 µs 17.019 µs 17.066 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/3 +Benchmarking i16_slice_search/binary_search/3: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/3: Collecting 10 samples in estimated 100.45 ms (9900 iterations) +Benchmarking i16_slice_search/binary_search/3: Analyzing +i16_slice_search/binary_search/3 + time: [10.138 µs 10.161 µs 10.197 µs] +Benchmarking i16_slice_search/hashset/3 +Benchmarking i16_slice_search/hashset/3: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/3: Collecting 10 samples in estimated 100.26 ms (8415 iterations) +Benchmarking i16_slice_search/hashset/3: Analyzing +i16_slice_search/hashset/3 + time: [11.849 µs 11.880 µs 11.928 µs] +Benchmarking i16_slice_search/branchless/3 +Benchmarking i16_slice_search/branchless/3: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/3: Collecting 10 samples in estimated 100.00 ms (46k iterations) +Benchmarking i16_slice_search/branchless/3: Analyzing +i16_slice_search/branchless/3 + time: [2.1533 µs 2.1599 µs 2.1678 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high mild +Benchmarking i16_slice_search/contains/4 +Benchmarking i16_slice_search/contains/4: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/4: Collecting 10 samples in estimated 100.33 ms (5170 iterations) +Benchmarking i16_slice_search/contains/4: Analyzing +i16_slice_search/contains/4 + time: [19.285 µs 19.346 µs 19.416 µs] +Benchmarking i16_slice_search/binary_search/4 +Benchmarking i16_slice_search/binary_search/4: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/4: Collecting 10 samples in estimated 100.01 ms (4895 iterations) +Benchmarking i16_slice_search/binary_search/4: Analyzing +i16_slice_search/binary_search/4 + time: [14.907 µs 29.205 µs 53.194 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/4 +Benchmarking i16_slice_search/hashset/4: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/4: Collecting 10 samples in estimated 100.39 ms (8415 iterations) +Benchmarking i16_slice_search/hashset/4: Analyzing +i16_slice_search/hashset/4 + time: [11.903 µs 11.958 µs 12.020 µs] +Benchmarking i16_slice_search/branchless/4 +Benchmarking i16_slice_search/branchless/4: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/4: Collecting 10 samples in estimated 100.09 ms (42k iterations) +Benchmarking i16_slice_search/branchless/4: Analyzing +i16_slice_search/branchless/4 + time: [2.3580 µs 2.3640 µs 2.3729 µs] +Benchmarking i16_slice_search/contains/5 +Benchmarking i16_slice_search/contains/5: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/5: Collecting 10 samples in estimated 100.35 ms (4620 iterations) +Benchmarking i16_slice_search/contains/5: Analyzing +i16_slice_search/contains/5 + time: [21.593 µs 21.644 µs 21.710 µs] +Benchmarking i16_slice_search/binary_search/5 +Benchmarking i16_slice_search/binary_search/5: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/5: Collecting 10 samples in estimated 100.60 ms (7260 iterations) +Benchmarking i16_slice_search/binary_search/5: Analyzing +i16_slice_search/binary_search/5 + time: [13.569 µs 13.632 µs 13.758 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high severe +Benchmarking i16_slice_search/hashset/5 +Benchmarking i16_slice_search/hashset/5: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/5: Collecting 10 samples in estimated 100.30 ms (8415 iterations) +Benchmarking i16_slice_search/hashset/5: Analyzing +i16_slice_search/hashset/5 + time: [11.827 µs 11.870 µs 11.934 µs] +Benchmarking i16_slice_search/branchless/5 +Benchmarking i16_slice_search/branchless/5: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/5: Collecting 10 samples in estimated 100.13 ms (40k iterations) +Benchmarking i16_slice_search/branchless/5: Analyzing +i16_slice_search/branchless/5 + time: [2.5139 µs 2.5259 µs 2.5450 µs] +Benchmarking i16_slice_search/contains/6 +Benchmarking i16_slice_search/contains/6: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/6: Collecting 10 samples in estimated 101.19 ms (4235 iterations) +Benchmarking i16_slice_search/contains/6: Analyzing +i16_slice_search/contains/6 + time: [23.814 µs 23.909 µs 24.032 µs] +Benchmarking i16_slice_search/binary_search/6 +Benchmarking i16_slice_search/binary_search/6: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/6: Collecting 10 samples in estimated 100.10 ms (7370 iterations) +Benchmarking i16_slice_search/binary_search/6: Analyzing +i16_slice_search/binary_search/6 + time: [13.495 µs 13.536 µs 13.586 µs] +Benchmarking i16_slice_search/hashset/6 +Benchmarking i16_slice_search/hashset/6: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/6: Collecting 10 samples in estimated 100.15 ms (8305 iterations) +Benchmarking i16_slice_search/hashset/6: Analyzing +i16_slice_search/hashset/6 + time: [11.944 µs 11.980 µs 12.059 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/branchless/6 +Benchmarking i16_slice_search/branchless/6: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/6: Collecting 10 samples in estimated 100.01 ms (37k iterations) +Benchmarking i16_slice_search/branchless/6: Analyzing +i16_slice_search/branchless/6 + time: [2.6655 µs 2.6769 µs 2.6870 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/7 +Benchmarking i16_slice_search/contains/7: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/7: Collecting 10 samples in estimated 100.31 ms (4070 iterations) +Benchmarking i16_slice_search/contains/7: Analyzing +i16_slice_search/contains/7 + time: [24.217 µs 24.326 µs 24.424 µs] +Benchmarking i16_slice_search/binary_search/7 +Benchmarking i16_slice_search/binary_search/7: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/7: Collecting 10 samples in estimated 100.28 ms (7370 iterations) +Benchmarking i16_slice_search/binary_search/7: Analyzing +i16_slice_search/binary_search/7 + time: [13.558 µs 13.626 µs 13.684 µs] +Benchmarking i16_slice_search/hashset/7 +Benchmarking i16_slice_search/hashset/7: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/7: Collecting 10 samples in estimated 100.53 ms (8415 iterations) +Benchmarking i16_slice_search/hashset/7: Analyzing +i16_slice_search/hashset/7 + time: [11.899 µs 11.963 µs 12.050 µs] +Benchmarking i16_slice_search/branchless/7 +Benchmarking i16_slice_search/branchless/7: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/7: Collecting 10 samples in estimated 100.06 ms (35k iterations) +Benchmarking i16_slice_search/branchless/7: Analyzing +i16_slice_search/branchless/7 + time: [2.8377 µs 2.8485 µs 2.8588 µs] +Benchmarking i16_slice_search/contains/8 +Benchmarking i16_slice_search/contains/8: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/8: Collecting 10 samples in estimated 100.93 ms (3520 iterations) +Benchmarking i16_slice_search/contains/8: Analyzing +i16_slice_search/contains/8 + time: [28.512 µs 28.639 µs 28.712 µs] +Benchmarking i16_slice_search/binary_search/8 +Benchmarking i16_slice_search/binary_search/8: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/8: Collecting 10 samples in estimated 100.68 ms (7315 iterations) +Benchmarking i16_slice_search/binary_search/8: Analyzing +i16_slice_search/binary_search/8 + time: [13.556 µs 13.620 µs 13.675 µs] +Benchmarking i16_slice_search/hashset/8 +Benchmarking i16_slice_search/hashset/8: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/8: Collecting 10 samples in estimated 100.11 ms (8030 iterations) +Benchmarking i16_slice_search/hashset/8: Analyzing +i16_slice_search/hashset/8 + time: [12.350 µs 12.389 µs 12.423 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/8 +Benchmarking i16_slice_search/branchless/8: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/8: Collecting 10 samples in estimated 100.05 ms (33k iterations) +Benchmarking i16_slice_search/branchless/8: Analyzing +i16_slice_search/branchless/8 + time: [2.9909 µs 2.9960 µs 3.0076 µs] +Benchmarking i16_slice_search/contains/9 +Benchmarking i16_slice_search/contains/9: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/9: Collecting 10 samples in estimated 100.56 ms (3245 iterations) +Benchmarking i16_slice_search/contains/9: Analyzing +i16_slice_search/contains/9 + time: [30.820 µs 30.915 µs 30.989 µs] +Benchmarking i16_slice_search/binary_search/9 +Benchmarking i16_slice_search/binary_search/9: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/9: Collecting 10 samples in estimated 100.68 ms (5885 iterations) +Benchmarking i16_slice_search/binary_search/9: Analyzing +i16_slice_search/binary_search/9 + time: [17.019 µs 17.067 µs 17.155 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/hashset/9 +Benchmarking i16_slice_search/hashset/9: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/9: Collecting 10 samples in estimated 100.54 ms (8140 iterations) +Benchmarking i16_slice_search/hashset/9: Analyzing +i16_slice_search/hashset/9 + time: [12.282 µs 12.333 µs 12.408 µs] +Benchmarking i16_slice_search/branchless/9 +Benchmarking i16_slice_search/branchless/9: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/9: Collecting 10 samples in estimated 100.11 ms (31k iterations) +Benchmarking i16_slice_search/branchless/9: Analyzing +i16_slice_search/branchless/9 + time: [3.1524 µs 3.1632 µs 3.1727 µs] +Benchmarking i16_slice_search/contains/10 +Benchmarking i16_slice_search/contains/10: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/10: Collecting 10 samples in estimated 100.31 ms (1430 iterations) +Benchmarking i16_slice_search/contains/10: Analyzing +i16_slice_search/contains/10 + time: [56.661 µs 69.728 µs 84.563 µs] +Benchmarking i16_slice_search/binary_search/10 +Benchmarking i16_slice_search/binary_search/10: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/10: Collecting 10 samples in estimated 100.45 ms (5885 iterations) +Benchmarking i16_slice_search/binary_search/10: Analyzing +i16_slice_search/binary_search/10 + time: [16.997 µs 17.051 µs 17.121 µs] +Benchmarking i16_slice_search/hashset/10 +Benchmarking i16_slice_search/hashset/10: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/10: Collecting 10 samples in estimated 100.44 ms (8140 iterations) +Benchmarking i16_slice_search/hashset/10: Analyzing +i16_slice_search/hashset/10 + time: [12.232 µs 12.327 µs 12.411 µs] +Benchmarking i16_slice_search/branchless/10 +Benchmarking i16_slice_search/branchless/10: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/10: Collecting 10 samples in estimated 100.18 ms (30k iterations) +Benchmarking i16_slice_search/branchless/10: Analyzing +i16_slice_search/branchless/10 + time: [3.3209 µs 3.3332 µs 3.3514 µs] +Benchmarking i16_slice_search/contains/11 +Benchmarking i16_slice_search/contains/11: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/11: Collecting 10 samples in estimated 101.65 ms (2860 iterations) +Benchmarking i16_slice_search/contains/11: Analyzing +i16_slice_search/contains/11 + time: [35.338 µs 35.456 µs 35.658 µs] +Benchmarking i16_slice_search/binary_search/11 +Benchmarking i16_slice_search/binary_search/11: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/11: Collecting 10 samples in estimated 100.67 ms (5885 iterations) +Benchmarking i16_slice_search/binary_search/11: Analyzing +i16_slice_search/binary_search/11 + time: [16.988 µs 17.046 µs 17.119 µs] +Benchmarking i16_slice_search/hashset/11 +Benchmarking i16_slice_search/hashset/11: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/11: Collecting 10 samples in estimated 100.37 ms (8030 iterations) +Benchmarking i16_slice_search/hashset/11: Analyzing +i16_slice_search/hashset/11 + time: [12.390 µs 12.430 µs 12.478 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/branchless/11 +Benchmarking i16_slice_search/branchless/11: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/11: Collecting 10 samples in estimated 100.08 ms (28k iterations) +Benchmarking i16_slice_search/branchless/11: Analyzing +i16_slice_search/branchless/11 + time: [3.5020 µs 3.5242 µs 3.5420 µs] +Benchmarking i16_slice_search/contains/12 +Benchmarking i16_slice_search/contains/12: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/12: Collecting 10 samples in estimated 101.91 ms (2695 iterations) +Benchmarking i16_slice_search/contains/12: Analyzing +i16_slice_search/contains/12 + time: [37.550 µs 37.658 µs 37.756 µs] +Benchmarking i16_slice_search/binary_search/12 +Benchmarking i16_slice_search/binary_search/12: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/12: Collecting 10 samples in estimated 100.05 ms (5830 iterations) +Benchmarking i16_slice_search/binary_search/12: Analyzing +i16_slice_search/binary_search/12 + time: [17.010 µs 17.075 µs 17.145 µs] +Benchmarking i16_slice_search/hashset/12 +Benchmarking i16_slice_search/hashset/12: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/12: Collecting 10 samples in estimated 100.15 ms (7865 iterations) +Benchmarking i16_slice_search/hashset/12: Analyzing +i16_slice_search/hashset/12 + time: [12.725 µs 12.754 µs 12.800 µs] +Benchmarking i16_slice_search/branchless/12 +Benchmarking i16_slice_search/branchless/12: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/12: Collecting 10 samples in estimated 100.15 ms (27k iterations) +Benchmarking i16_slice_search/branchless/12: Analyzing +i16_slice_search/branchless/12 + time: [3.6395 µs 3.6612 µs 3.6814 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/contains/13 +Benchmarking i16_slice_search/contains/13: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/13: Collecting 10 samples in estimated 101.52 ms (2530 iterations) +Benchmarking i16_slice_search/contains/13: Analyzing +i16_slice_search/contains/13 + time: [39.840 µs 40.058 µs 40.286 µs] +Benchmarking i16_slice_search/binary_search/13 +Benchmarking i16_slice_search/binary_search/13: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/13: Collecting 10 samples in estimated 100.79 ms (5885 iterations) +Benchmarking i16_slice_search/binary_search/13: Analyzing +i16_slice_search/binary_search/13 + time: [17.053 µs 17.104 µs 17.181 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high mild +Benchmarking i16_slice_search/hashset/13 +Benchmarking i16_slice_search/hashset/13: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/13: Collecting 10 samples in estimated 100.41 ms (7260 iterations) +Benchmarking i16_slice_search/hashset/13: Analyzing +i16_slice_search/hashset/13 + time: [13.784 µs 13.856 µs 13.941 µs] +Benchmarking i16_slice_search/branchless/13 +Benchmarking i16_slice_search/branchless/13: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/13: Collecting 10 samples in estimated 100.05 ms (26k iterations) +Benchmarking i16_slice_search/branchless/13: Analyzing +i16_slice_search/branchless/13 + time: [3.8159 µs 3.8496 µs 3.9324 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/14 +Benchmarking i16_slice_search/contains/14: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/14: Collecting 10 samples in estimated 100.06 ms (2475 iterations) +Benchmarking i16_slice_search/contains/14: Analyzing +i16_slice_search/contains/14 + time: [40.270 µs 40.409 µs 40.538 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i16_slice_search/binary_search/14 +Benchmarking i16_slice_search/binary_search/14: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/14: Collecting 10 samples in estimated 100.72 ms (5885 iterations) +Benchmarking i16_slice_search/binary_search/14: Analyzing +i16_slice_search/binary_search/14 + time: [17.020 µs 17.053 µs 17.082 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/14 +Benchmarking i16_slice_search/hashset/14: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/14: Collecting 10 samples in estimated 100.44 ms (6985 iterations) +Benchmarking i16_slice_search/hashset/14: Analyzing +i16_slice_search/hashset/14 + time: [14.328 µs 14.391 µs 14.438 µs] +Benchmarking i16_slice_search/branchless/14 +Benchmarking i16_slice_search/branchless/14: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/14: Collecting 10 samples in estimated 100.19 ms (25k iterations) +Benchmarking i16_slice_search/branchless/14: Analyzing +i16_slice_search/branchless/14 + time: [3.9769 µs 3.9952 µs 4.0294 µs] +Benchmarking i16_slice_search/contains/15 +Benchmarking i16_slice_search/contains/15: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/15: Collecting 10 samples in estimated 101.68 ms (2035 iterations) +Benchmarking i16_slice_search/contains/15: Analyzing +i16_slice_search/contains/15 + time: [49.444 µs 49.728 µs 50.013 µs] +Benchmarking i16_slice_search/binary_search/15 +Benchmarking i16_slice_search/binary_search/15: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/15: Collecting 10 samples in estimated 100.60 ms (5885 iterations) +Benchmarking i16_slice_search/binary_search/15: Analyzing +i16_slice_search/binary_search/15 + time: [17.014 µs 17.063 µs 17.148 µs] +Benchmarking i16_slice_search/hashset/15 +Benchmarking i16_slice_search/hashset/15: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/15: Collecting 10 samples in estimated 100.47 ms (8470 iterations) +Benchmarking i16_slice_search/hashset/15: Analyzing +i16_slice_search/hashset/15 + time: [11.853 µs 11.888 µs 11.949 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/15 +Benchmarking i16_slice_search/branchless/15: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/15: Collecting 10 samples in estimated 100.01 ms (24k iterations) +Benchmarking i16_slice_search/branchless/15: Analyzing +i16_slice_search/branchless/15 + time: [4.1274 µs 4.1456 µs 4.1720 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/16 +Benchmarking i16_slice_search/contains/16: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/16: Collecting 10 samples in estimated 100.68 ms (1925 iterations) +Benchmarking i16_slice_search/contains/16: Analyzing +i16_slice_search/contains/16 + time: [52.252 µs 52.464 µs 52.698 µs] +Benchmarking i16_slice_search/binary_search/16 +Benchmarking i16_slice_search/binary_search/16: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/16: Collecting 10 samples in estimated 100.66 ms (5885 iterations) +Benchmarking i16_slice_search/binary_search/16: Analyzing +i16_slice_search/binary_search/16 + time: [16.983 µs 17.027 µs 17.093 µs] +Benchmarking i16_slice_search/hashset/16 +Benchmarking i16_slice_search/hashset/16: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/16: Collecting 10 samples in estimated 100.26 ms (8360 iterations) +Benchmarking i16_slice_search/hashset/16: Analyzing +i16_slice_search/hashset/16 + time: [11.912 µs 12.078 µs 12.457 µs] +Benchmarking i16_slice_search/branchless/16 +Benchmarking i16_slice_search/branchless/16: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/16: Collecting 10 samples in estimated 100.07 ms (23k iterations) +Benchmarking i16_slice_search/branchless/16: Analyzing +i16_slice_search/branchless/16 + time: [4.3125 µs 4.3214 µs 4.3326 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i16_slice_search/contains/17 +Benchmarking i16_slice_search/contains/17: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/17: Collecting 10 samples in estimated 102.24 ms (1870 iterations) +Benchmarking i16_slice_search/contains/17: Analyzing +i16_slice_search/contains/17 + time: [54.124 µs 54.283 µs 54.437 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/binary_search/17 +Benchmarking i16_slice_search/binary_search/17: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/17: Collecting 10 samples in estimated 101.07 ms (4785 iterations) +Benchmarking i16_slice_search/binary_search/17: Analyzing +i16_slice_search/binary_search/17 + time: [20.904 µs 21.050 µs 21.163 µs] +Benchmarking i16_slice_search/hashset/17 +Benchmarking i16_slice_search/hashset/17: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/17: Collecting 10 samples in estimated 100.47 ms (8415 iterations) +Benchmarking i16_slice_search/hashset/17: Analyzing +i16_slice_search/hashset/17 + time: [11.886 µs 11.916 µs 11.946 µs] +Benchmarking i16_slice_search/branchless/17 +Benchmarking i16_slice_search/branchless/17: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/17: Collecting 10 samples in estimated 100.21 ms (22k iterations) +Benchmarking i16_slice_search/branchless/17: Analyzing +i16_slice_search/branchless/17 + time: [4.4601 µs 4.4743 µs 4.4898 µs] +Benchmarking i16_slice_search/contains/18 +Benchmarking i16_slice_search/contains/18: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/18: Collecting 10 samples in estimated 102.49 ms (1815 iterations) +Benchmarking i16_slice_search/contains/18: Analyzing +i16_slice_search/contains/18 + time: [56.154 µs 56.413 µs 56.657 µs] +Benchmarking i16_slice_search/binary_search/18 +Benchmarking i16_slice_search/binary_search/18: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/18: Collecting 10 samples in estimated 100.86 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/18: Analyzing +i16_slice_search/binary_search/18 + time: [20.724 µs 20.808 µs 20.938 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/18 +Benchmarking i16_slice_search/hashset/18: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/18: Collecting 10 samples in estimated 100.45 ms (8415 iterations) +Benchmarking i16_slice_search/hashset/18: Analyzing +i16_slice_search/hashset/18 + time: [11.843 µs 11.897 µs 11.976 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/18 +Benchmarking i16_slice_search/branchless/18: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/18: Collecting 10 samples in estimated 100.21 ms (21k iterations) +Benchmarking i16_slice_search/branchless/18: Analyzing +i16_slice_search/branchless/18 + time: [5.0548 µs 9.4688 µs 12.208 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/contains/19 +Benchmarking i16_slice_search/contains/19: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/19: Collecting 10 samples in estimated 101.09 ms (1650 iterations) +Benchmarking i16_slice_search/contains/19: Analyzing +i16_slice_search/contains/19 + time: [59.689 µs 60.115 µs 60.852 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/binary_search/19 +Benchmarking i16_slice_search/binary_search/19: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/19: Collecting 10 samples in estimated 100.89 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/19: Analyzing +i16_slice_search/binary_search/19 + time: [20.753 µs 20.842 µs 20.951 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/19 +Benchmarking i16_slice_search/hashset/19: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/19: Collecting 10 samples in estimated 100.15 ms (6490 iterations) +Benchmarking i16_slice_search/hashset/19: Analyzing +i16_slice_search/hashset/19 + time: [15.118 µs 15.187 µs 15.240 µs] +Benchmarking i16_slice_search/branchless/19 +Benchmarking i16_slice_search/branchless/19: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/19: Collecting 10 samples in estimated 100.15 ms (21k iterations) +Benchmarking i16_slice_search/branchless/19: Analyzing +i16_slice_search/branchless/19 + time: [4.8333 µs 4.8459 µs 4.8683 µs] +Benchmarking i16_slice_search/contains/20 +Benchmarking i16_slice_search/contains/20: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/20: Collecting 10 samples in estimated 100.30 ms (1650 iterations) +Benchmarking i16_slice_search/contains/20: Analyzing +i16_slice_search/contains/20 + time: [60.960 µs 61.424 µs 61.879 µs] +Benchmarking i16_slice_search/binary_search/20 +Benchmarking i16_slice_search/binary_search/20: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/20: Collecting 10 samples in estimated 100.68 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/20: Analyzing +i16_slice_search/binary_search/20 + time: [20.737 µs 20.895 µs 21.104 µs] +Benchmarking i16_slice_search/hashset/20 +Benchmarking i16_slice_search/hashset/20: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/20: Collecting 10 samples in estimated 100.04 ms (8250 iterations) +Benchmarking i16_slice_search/hashset/20: Analyzing +i16_slice_search/hashset/20 + time: [12.077 µs 12.114 µs 12.170 µs] +Benchmarking i16_slice_search/branchless/20 +Benchmarking i16_slice_search/branchless/20: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/20: Collecting 10 samples in estimated 100.24 ms (20k iterations) +Benchmarking i16_slice_search/branchless/20: Analyzing +i16_slice_search/branchless/20 + time: [4.9888 µs 5.0085 µs 5.0282 µs] +Benchmarking i16_slice_search/contains/21 +Benchmarking i16_slice_search/contains/21: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/21: Collecting 10 samples in estimated 102.97 ms (1705 iterations) +Benchmarking i16_slice_search/contains/21: Analyzing +i16_slice_search/contains/21 + time: [59.908 µs 60.092 µs 60.371 µs] +Benchmarking i16_slice_search/binary_search/21 +Benchmarking i16_slice_search/binary_search/21: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/21: Collecting 10 samples in estimated 100.60 ms (4785 iterations) +Benchmarking i16_slice_search/binary_search/21: Analyzing +i16_slice_search/binary_search/21 + time: [20.731 µs 20.810 µs 20.939 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/21 +Benchmarking i16_slice_search/hashset/21: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/21: Collecting 10 samples in estimated 100.26 ms (8030 iterations) +Benchmarking i16_slice_search/hashset/21: Analyzing +i16_slice_search/hashset/21 + time: [12.025 µs 12.385 µs 13.292 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking i16_slice_search/branchless/21 +Benchmarking i16_slice_search/branchless/21: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/21: Collecting 10 samples in estimated 100.13 ms (19k iterations) +Benchmarking i16_slice_search/branchless/21: Analyzing +i16_slice_search/branchless/21 + time: [5.1438 µs 5.1628 µs 5.1905 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/22 +Benchmarking i16_slice_search/contains/22: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/22: Collecting 10 samples in estimated 101.24 ms (1540 iterations) +Benchmarking i16_slice_search/contains/22: Analyzing +i16_slice_search/contains/22 + time: [64.614 µs 64.841 µs 65.218 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/22 +Benchmarking i16_slice_search/binary_search/22: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/22: Collecting 10 samples in estimated 100.08 ms (4785 iterations) +Benchmarking i16_slice_search/binary_search/22: Analyzing +i16_slice_search/binary_search/22 + time: [20.737 µs 20.799 µs 20.875 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/22 +Benchmarking i16_slice_search/hashset/22: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/22: Collecting 10 samples in estimated 100.44 ms (8140 iterations) +Benchmarking i16_slice_search/hashset/22: Analyzing +i16_slice_search/hashset/22 + time: [12.108 µs 12.164 µs 12.206 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/22 +Benchmarking i16_slice_search/branchless/22: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/22: Collecting 10 samples in estimated 100.28 ms (19k iterations) +Benchmarking i16_slice_search/branchless/22: Analyzing +i16_slice_search/branchless/22 + time: [5.3188 µs 5.3457 µs 5.3882 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/23 +Benchmarking i16_slice_search/contains/23: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/23: Collecting 10 samples in estimated 100.05 ms (1485 iterations) +Benchmarking i16_slice_search/contains/23: Analyzing +i16_slice_search/contains/23 + time: [67.193 µs 67.587 µs 67.984 µs] +Benchmarking i16_slice_search/binary_search/23 +Benchmarking i16_slice_search/binary_search/23: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/23: Collecting 10 samples in estimated 100.57 ms (4730 iterations) +Benchmarking i16_slice_search/binary_search/23: Analyzing +i16_slice_search/binary_search/23 + time: [20.803 µs 20.883 µs 20.997 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/23 +Benchmarking i16_slice_search/hashset/23: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/23: Collecting 10 samples in estimated 100.03 ms (7590 iterations) +Benchmarking i16_slice_search/hashset/23: Analyzing +i16_slice_search/hashset/23 + time: [13.121 µs 13.164 µs 13.220 µs] +Benchmarking i16_slice_search/branchless/23 +Benchmarking i16_slice_search/branchless/23: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/23: Collecting 10 samples in estimated 100.08 ms (18k iterations) +Benchmarking i16_slice_search/branchless/23: Analyzing +i16_slice_search/branchless/23 + time: [5.4780 µs 5.5837 µs 5.7801 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/24 +Benchmarking i16_slice_search/contains/24: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/24: Collecting 10 samples in estimated 102.97 ms (1485 iterations) +Benchmarking i16_slice_search/contains/24: Analyzing +i16_slice_search/contains/24 + time: [68.995 µs 69.143 µs 69.352 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/binary_search/24 +Benchmarking i16_slice_search/binary_search/24: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/24: Collecting 10 samples in estimated 100.96 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/24: Analyzing +i16_slice_search/binary_search/24 + time: [20.778 µs 20.881 µs 21.043 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/24 +Benchmarking i16_slice_search/hashset/24: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/24: Collecting 10 samples in estimated 100.71 ms (6875 iterations) +Benchmarking i16_slice_search/hashset/24: Analyzing +i16_slice_search/hashset/24 + time: [14.486 µs 14.518 µs 14.560 µs] +Benchmarking i16_slice_search/branchless/24 +Benchmarking i16_slice_search/branchless/24: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/24: Collecting 10 samples in estimated 100.02 ms (18k iterations) +Benchmarking i16_slice_search/branchless/24: Analyzing +i16_slice_search/branchless/24 + time: [5.6403 µs 5.6576 µs 5.6851 µs] +Benchmarking i16_slice_search/contains/25 +Benchmarking i16_slice_search/contains/25: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/25: Collecting 10 samples in estimated 101.41 ms (1430 iterations) +Benchmarking i16_slice_search/contains/25: Analyzing +i16_slice_search/contains/25 + time: [70.798 µs 71.107 µs 71.431 µs] +Benchmarking i16_slice_search/binary_search/25 +Benchmarking i16_slice_search/binary_search/25: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/25: Collecting 10 samples in estimated 100.96 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/25: Analyzing +i16_slice_search/binary_search/25 + time: [20.819 µs 20.862 µs 20.904 µs] +Benchmarking i16_slice_search/hashset/25 +Benchmarking i16_slice_search/hashset/25: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/25: Collecting 10 samples in estimated 100.03 ms (6600 iterations) +Benchmarking i16_slice_search/hashset/25: Analyzing +i16_slice_search/hashset/25 + time: [14.772 µs 14.842 µs 14.908 µs] +Benchmarking i16_slice_search/branchless/25 +Benchmarking i16_slice_search/branchless/25: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/25: Collecting 10 samples in estimated 100.18 ms (17k iterations) +Benchmarking i16_slice_search/branchless/25: Analyzing +i16_slice_search/branchless/25 + time: [5.8166 µs 5.8493 µs 5.9043 µs] +Benchmarking i16_slice_search/contains/26 +Benchmarking i16_slice_search/contains/26: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/26: Collecting 10 samples in estimated 101.41 ms (1375 iterations) +Benchmarking i16_slice_search/contains/26: Analyzing +i16_slice_search/contains/26 + time: [73.235 µs 73.396 µs 73.659 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/binary_search/26 +Benchmarking i16_slice_search/binary_search/26: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/26: Collecting 10 samples in estimated 100.88 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/26: Analyzing +i16_slice_search/binary_search/26 + time: [20.707 µs 20.753 µs 20.812 µs] +Benchmarking i16_slice_search/hashset/26 +Benchmarking i16_slice_search/hashset/26: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/26: Collecting 10 samples in estimated 100.35 ms (6215 iterations) +Benchmarking i16_slice_search/hashset/26: Analyzing +i16_slice_search/hashset/26 + time: [15.887 µs 15.988 µs 16.105 µs] +Benchmarking i16_slice_search/branchless/26 +Benchmarking i16_slice_search/branchless/26: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/26: Collecting 10 samples in estimated 100.04 ms (17k iterations) +Benchmarking i16_slice_search/branchless/26: Analyzing +i16_slice_search/branchless/26 + time: [5.9681 µs 5.9952 µs 6.0242 µs] +Benchmarking i16_slice_search/contains/27 +Benchmarking i16_slice_search/contains/27: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/27: Collecting 10 samples in estimated 100.67 ms (1320 iterations) +Benchmarking i16_slice_search/contains/27: Analyzing +i16_slice_search/contains/27 + time: [75.409 µs 75.593 µs 75.832 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking i16_slice_search/binary_search/27 +Benchmarking i16_slice_search/binary_search/27: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/27: Collecting 10 samples in estimated 100.83 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/27: Analyzing +i16_slice_search/binary_search/27 + time: [20.690 µs 20.755 µs 20.882 µs] +Benchmarking i16_slice_search/hashset/27 +Benchmarking i16_slice_search/hashset/27: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/27: Collecting 10 samples in estimated 100.52 ms (5830 iterations) +Benchmarking i16_slice_search/hashset/27: Analyzing +i16_slice_search/hashset/27 + time: [17.184 µs 17.228 µs 17.294 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/branchless/27 +Benchmarking i16_slice_search/branchless/27: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/27: Collecting 10 samples in estimated 100.11 ms (16k iterations) +Benchmarking i16_slice_search/branchless/27: Analyzing +i16_slice_search/branchless/27 + time: [6.1715 µs 6.2024 µs 6.2328 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/contains/28 +Benchmarking i16_slice_search/contains/28: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/28: Collecting 10 samples in estimated 100.10 ms (1320 iterations) +Benchmarking i16_slice_search/contains/28: Analyzing +i16_slice_search/contains/28 + time: [75.375 µs 75.743 µs 76.348 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/28 +Benchmarking i16_slice_search/binary_search/28: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/28: Collecting 10 samples in estimated 100.11 ms (4785 iterations) +Benchmarking i16_slice_search/binary_search/28: Analyzing +i16_slice_search/binary_search/28 + time: [20.706 µs 20.799 µs 20.896 µs] +Benchmarking i16_slice_search/hashset/28 +Benchmarking i16_slice_search/hashset/28: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/28: Collecting 10 samples in estimated 100.37 ms (7095 iterations) +Benchmarking i16_slice_search/hashset/28: Analyzing +i16_slice_search/hashset/28 + time: [14.091 µs 14.121 µs 14.167 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i16_slice_search/branchless/28 +Benchmarking i16_slice_search/branchless/28: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/28: Collecting 10 samples in estimated 100.30 ms (16k iterations) +Benchmarking i16_slice_search/branchless/28: Analyzing +i16_slice_search/branchless/28 + time: [6.2998 µs 6.3211 µs 6.3527 µs] +Benchmarking i16_slice_search/contains/29 +Benchmarking i16_slice_search/contains/29: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/29: Collecting 10 samples in estimated 102.40 ms (1265 iterations) +Benchmarking i16_slice_search/contains/29: Analyzing +i16_slice_search/contains/29 + time: [80.472 µs 80.920 µs 81.333 µs] +Benchmarking i16_slice_search/binary_search/29 +Benchmarking i16_slice_search/binary_search/29: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/29: Collecting 10 samples in estimated 100.87 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/29: Analyzing +i16_slice_search/binary_search/29 + time: [20.802 µs 20.831 µs 20.872 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low severe + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/hashset/29 +Benchmarking i16_slice_search/hashset/29: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/29: Collecting 10 samples in estimated 100.01 ms (8250 iterations) +Benchmarking i16_slice_search/hashset/29: Analyzing +i16_slice_search/hashset/29 + time: [12.033 µs 12.065 µs 12.121 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/29 +Benchmarking i16_slice_search/branchless/29: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/29: Collecting 10 samples in estimated 100.32 ms (16k iterations) +Benchmarking i16_slice_search/branchless/29: Analyzing +i16_slice_search/branchless/29 + time: [6.4416 µs 6.4627 µs 6.4871 µs] +Benchmarking i16_slice_search/contains/30 +Benchmarking i16_slice_search/contains/30: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/30: Collecting 10 samples in estimated 100.56 ms (1210 iterations) +Benchmarking i16_slice_search/contains/30: Analyzing +i16_slice_search/contains/30 + time: [82.772 µs 83.151 µs 83.728 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/binary_search/30 +Benchmarking i16_slice_search/binary_search/30: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/30: Collecting 10 samples in estimated 100.62 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/30: Analyzing +i16_slice_search/binary_search/30 + time: [20.711 µs 20.780 µs 20.898 µs] +Benchmarking i16_slice_search/hashset/30 +Benchmarking i16_slice_search/hashset/30: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/30: Collecting 10 samples in estimated 100.25 ms (7480 iterations) +Benchmarking i16_slice_search/hashset/30: Analyzing +i16_slice_search/hashset/30 + time: [13.292 µs 13.455 µs 13.676 µs] +Benchmarking i16_slice_search/branchless/30 +Benchmarking i16_slice_search/branchless/30: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/30: Collecting 10 samples in estimated 100.35 ms (14k iterations) +Benchmarking i16_slice_search/branchless/30: Analyzing +i16_slice_search/branchless/30 + time: [6.6402 µs 6.6852 µs 6.7959 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/31 +Benchmarking i16_slice_search/contains/31: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/31: Collecting 10 samples in estimated 103.93 ms (1210 iterations) +Benchmarking i16_slice_search/contains/31: Analyzing +i16_slice_search/contains/31 + time: [86.017 µs 86.204 µs 86.393 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/binary_search/31 +Benchmarking i16_slice_search/binary_search/31: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/31: Collecting 10 samples in estimated 100.93 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/31: Analyzing +i16_slice_search/binary_search/31 + time: [20.770 µs 20.833 µs 20.882 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/31 +Benchmarking i16_slice_search/hashset/31: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/31: Collecting 10 samples in estimated 100.37 ms (8195 iterations) +Benchmarking i16_slice_search/hashset/31: Analyzing +i16_slice_search/hashset/31 + time: [12.166 µs 12.313 µs 12.671 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/branchless/31 +Benchmarking i16_slice_search/branchless/31: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/31: Collecting 10 samples in estimated 100.03 ms (15k iterations) +Benchmarking i16_slice_search/branchless/31: Analyzing +i16_slice_search/branchless/31 + time: [6.7769 µs 6.8054 µs 6.8334 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i16_slice_search/contains/32 +Benchmarking i16_slice_search/contains/32: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/32: Collecting 10 samples in estimated 100.43 ms (6490 iterations) +Benchmarking i16_slice_search/contains/32: Analyzing +i16_slice_search/contains/32 + time: [15.515 µs 15.677 µs 15.818 µs] +Benchmarking i16_slice_search/binary_search/32 +Benchmarking i16_slice_search/binary_search/32: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/32: Collecting 10 samples in estimated 100.94 ms (4840 iterations) +Benchmarking i16_slice_search/binary_search/32: Analyzing +i16_slice_search/binary_search/32 + time: [20.753 µs 20.809 µs 20.912 µs] +Benchmarking i16_slice_search/hashset/32 +Benchmarking i16_slice_search/hashset/32: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/32: Collecting 10 samples in estimated 100.13 ms (7425 iterations) +Benchmarking i16_slice_search/hashset/32: Analyzing +i16_slice_search/hashset/32 + time: [13.166 µs 13.305 µs 13.441 µs] +Benchmarking i16_slice_search/branchless/32 +Benchmarking i16_slice_search/branchless/32: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/32: Collecting 10 samples in estimated 100.34 ms (14k iterations) +Benchmarking i16_slice_search/branchless/32: Analyzing +i16_slice_search/branchless/32 + time: [6.9102 µs 6.9610 µs 7.0448 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/34 +Benchmarking i16_slice_search/contains/34: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/34: Collecting 10 samples in estimated 100.84 ms (4290 iterations) +Benchmarking i16_slice_search/contains/34: Analyzing +i16_slice_search/contains/34 + time: [23.406 µs 23.497 µs 23.596 µs] +Benchmarking i16_slice_search/binary_search/34 +Benchmarking i16_slice_search/binary_search/34: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/34: Collecting 10 samples in estimated 100.84 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/34: Analyzing +i16_slice_search/binary_search/34 + time: [24.963 µs 25.027 µs 25.140 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/hashset/34 +Benchmarking i16_slice_search/hashset/34: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/34: Collecting 10 samples in estimated 100.37 ms (7095 iterations) +Benchmarking i16_slice_search/hashset/34: Analyzing +i16_slice_search/hashset/34 + time: [14.005 µs 14.220 µs 14.393 µs] +Benchmarking i16_slice_search/branchless/34 +Benchmarking i16_slice_search/branchless/34: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/34: Collecting 10 samples in estimated 100.21 ms (14k iterations) +Benchmarking i16_slice_search/branchless/34: Analyzing +i16_slice_search/branchless/34 + time: [7.2281 µs 7.2538 µs 7.2826 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/36 +Benchmarking i16_slice_search/contains/36: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/36: Collecting 10 samples in estimated 100.47 ms (3410 iterations) +Benchmarking i16_slice_search/contains/36: Analyzing +i16_slice_search/contains/36 + time: [29.240 µs 29.371 µs 29.586 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/36 +Benchmarking i16_slice_search/binary_search/36: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/36: Collecting 10 samples in estimated 101.19 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/36: Analyzing +i16_slice_search/binary_search/36 + time: [24.901 µs 24.992 µs 25.103 µs] +Benchmarking i16_slice_search/hashset/36 +Benchmarking i16_slice_search/hashset/36: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/36: Collecting 10 samples in estimated 100.52 ms (7700 iterations) +Benchmarking i16_slice_search/hashset/36: Analyzing +i16_slice_search/hashset/36 + time: [12.968 µs 13.084 µs 13.278 µs] +Benchmarking i16_slice_search/branchless/36 +Benchmarking i16_slice_search/branchless/36: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/36: Collecting 10 samples in estimated 100.35 ms (13k iterations) +Benchmarking i16_slice_search/branchless/36: Analyzing +i16_slice_search/branchless/36 + time: [7.5856 µs 7.6500 µs 7.7811 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/38 +Benchmarking i16_slice_search/contains/38: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/38: Collecting 10 samples in estimated 100.13 ms (2640 iterations) +Benchmarking i16_slice_search/contains/38: Analyzing +i16_slice_search/contains/38 + time: [37.520 µs 37.898 µs 38.407 µs] +Benchmarking i16_slice_search/binary_search/38 +Benchmarking i16_slice_search/binary_search/38: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/38: Collecting 10 samples in estimated 100.50 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/38: Analyzing +i16_slice_search/binary_search/38 + time: [24.970 µs 25.046 µs 25.097 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/38 +Benchmarking i16_slice_search/hashset/38: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/38: Collecting 10 samples in estimated 100.59 ms (7755 iterations) +Benchmarking i16_slice_search/hashset/38: Analyzing +i16_slice_search/hashset/38 + time: [12.910 µs 12.996 µs 13.088 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/38 +Benchmarking i16_slice_search/branchless/38: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/38: Collecting 10 samples in estimated 100.03 ms (13k iterations) +Benchmarking i16_slice_search/branchless/38: Analyzing +i16_slice_search/branchless/38 + time: [7.9318 µs 7.9584 µs 8.0036 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/40 +Benchmarking i16_slice_search/contains/40: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/40: Collecting 10 samples in estimated 102.05 ms (2420 iterations) +Benchmarking i16_slice_search/contains/40: Analyzing +i16_slice_search/contains/40 + time: [41.978 µs 42.084 µs 42.209 µs] +Benchmarking i16_slice_search/binary_search/40 +Benchmarking i16_slice_search/binary_search/40: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/40: Collecting 10 samples in estimated 100.94 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/40: Analyzing +i16_slice_search/binary_search/40 + time: [24.905 µs 25.011 µs 25.114 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/hashset/40 +Benchmarking i16_slice_search/hashset/40: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/40: Collecting 10 samples in estimated 100.30 ms (7150 iterations) +Benchmarking i16_slice_search/hashset/40: Analyzing +i16_slice_search/hashset/40 + time: [13.987 µs 14.041 µs 14.116 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low severe + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/40 +Benchmarking i16_slice_search/branchless/40: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/40: Collecting 10 samples in estimated 100.07 ms (12k iterations) +Benchmarking i16_slice_search/branchless/40: Analyzing +i16_slice_search/branchless/40 + time: [8.2019 µs 8.2301 µs 8.2811 µs] +Benchmarking i16_slice_search/contains/42 +Benchmarking i16_slice_search/contains/42: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/42: Collecting 10 samples in estimated 102.00 ms (2420 iterations) +Benchmarking i16_slice_search/contains/42: Analyzing +i16_slice_search/contains/42 + time: [41.631 µs 41.792 µs 42.071 µs] +Benchmarking i16_slice_search/binary_search/42 +Benchmarking i16_slice_search/binary_search/42: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/42: Collecting 10 samples in estimated 101.01 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/42: Analyzing +i16_slice_search/binary_search/42 + time: [24.951 µs 25.006 µs 25.104 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/42 +Benchmarking i16_slice_search/hashset/42: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/42: Collecting 10 samples in estimated 100.15 ms (8360 iterations) +Benchmarking i16_slice_search/hashset/42: Analyzing +i16_slice_search/hashset/42 + time: [11.900 µs 11.951 µs 12.027 µs] +Benchmarking i16_slice_search/branchless/42 +Benchmarking i16_slice_search/branchless/42: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/42: Collecting 10 samples in estimated 100.04 ms (12k iterations) +Benchmarking i16_slice_search/branchless/42: Analyzing +i16_slice_search/branchless/42 + time: [8.5432 µs 8.5709 µs 8.6074 µs] +Benchmarking i16_slice_search/contains/44 +Benchmarking i16_slice_search/contains/44: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/44: Collecting 10 samples in estimated 100.69 ms (1980 iterations) +Benchmarking i16_slice_search/contains/44: Analyzing +i16_slice_search/contains/44 + time: [50.035 µs 50.172 µs 50.294 µs] +Benchmarking i16_slice_search/binary_search/44 +Benchmarking i16_slice_search/binary_search/44: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/44: Collecting 10 samples in estimated 100.51 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/44: Analyzing +i16_slice_search/binary_search/44 + time: [24.961 µs 25.044 µs 25.163 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/44 +Benchmarking i16_slice_search/hashset/44: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/44: Collecting 10 samples in estimated 100.56 ms (6655 iterations) +Benchmarking i16_slice_search/hashset/44: Analyzing +i16_slice_search/hashset/44 + time: [14.995 µs 15.106 µs 15.264 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/branchless/44 +Benchmarking i16_slice_search/branchless/44: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/44: Collecting 10 samples in estimated 100.18 ms (11k iterations) +Benchmarking i16_slice_search/branchless/44: Analyzing +i16_slice_search/branchless/44 + time: [8.9014 µs 8.9402 µs 8.9957 µs] +Benchmarking i16_slice_search/contains/46 +Benchmarking i16_slice_search/contains/46: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/46: Collecting 10 samples in estimated 101.56 ms (1870 iterations) +Benchmarking i16_slice_search/contains/46: Analyzing +i16_slice_search/contains/46 + time: [54.320 µs 54.471 µs 54.663 µs] +Benchmarking i16_slice_search/binary_search/46 +Benchmarking i16_slice_search/binary_search/46: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/46: Collecting 10 samples in estimated 100.10 ms (3960 iterations) +Benchmarking i16_slice_search/binary_search/46: Analyzing +i16_slice_search/binary_search/46 + time: [25.075 µs 25.207 µs 25.356 µs] +Benchmarking i16_slice_search/hashset/46 +Benchmarking i16_slice_search/hashset/46: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/46: Collecting 10 samples in estimated 100.17 ms (7975 iterations) +Benchmarking i16_slice_search/hashset/46: Analyzing +i16_slice_search/hashset/46 + time: [12.517 µs 12.650 µs 12.732 µs] +Benchmarking i16_slice_search/branchless/46 +Benchmarking i16_slice_search/branchless/46: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/46: Collecting 10 samples in estimated 100.07 ms (11k iterations) +Benchmarking i16_slice_search/branchless/46: Analyzing +i16_slice_search/branchless/46 + time: [9.2162 µs 9.2488 µs 9.2801 µs] +Benchmarking i16_slice_search/contains/48 +Benchmarking i16_slice_search/contains/48: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/48: Collecting 10 samples in estimated 102.75 ms (1760 iterations) +Benchmarking i16_slice_search/contains/48: Analyzing +i16_slice_search/contains/48 + time: [57.911 µs 58.170 µs 58.343 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/48 +Benchmarking i16_slice_search/binary_search/48: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/48: Collecting 10 samples in estimated 100.63 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/48: Analyzing +i16_slice_search/binary_search/48 + time: [24.911 µs 25.030 µs 25.164 µs] +Benchmarking i16_slice_search/hashset/48 +Benchmarking i16_slice_search/hashset/48: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/48: Collecting 10 samples in estimated 100.12 ms (7755 iterations) +Benchmarking i16_slice_search/hashset/48: Analyzing +i16_slice_search/hashset/48 + time: [12.809 µs 12.879 µs 12.963 µs] +Benchmarking i16_slice_search/branchless/48 +Benchmarking i16_slice_search/branchless/48: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/48: Collecting 10 samples in estimated 100.31 ms (11k iterations) +Benchmarking i16_slice_search/branchless/48: Analyzing +i16_slice_search/branchless/48 + time: [9.5393 µs 9.5720 µs 9.6184 µs] +Benchmarking i16_slice_search/contains/50 +Benchmarking i16_slice_search/contains/50: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/50: Collecting 10 samples in estimated 102.68 ms (1650 iterations) +Benchmarking i16_slice_search/contains/50: Analyzing +i16_slice_search/contains/50 + time: [61.972 µs 62.313 µs 62.661 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/50 +Benchmarking i16_slice_search/binary_search/50: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/50: Collecting 10 samples in estimated 100.65 ms (3960 iterations) +Benchmarking i16_slice_search/binary_search/50: Analyzing +i16_slice_search/binary_search/50 + time: [25.172 µs 25.356 µs 25.516 µs] +Benchmarking i16_slice_search/hashset/50 +Benchmarking i16_slice_search/hashset/50: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/50: Collecting 10 samples in estimated 100.65 ms (7480 iterations) +Benchmarking i16_slice_search/hashset/50: Analyzing +i16_slice_search/hashset/50 + time: [13.375 µs 13.436 µs 13.538 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i16_slice_search/branchless/50 +Benchmarking i16_slice_search/branchless/50: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/50: Collecting 10 samples in estimated 100.47 ms (10k iterations) +Benchmarking i16_slice_search/branchless/50: Analyzing +i16_slice_search/branchless/50 + time: [9.8394 µs 9.8798 µs 9.9430 µs] +Benchmarking i16_slice_search/contains/52 +Benchmarking i16_slice_search/contains/52: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/52: Collecting 10 samples in estimated 102.22 ms (1540 iterations) +Benchmarking i16_slice_search/contains/52: Analyzing +i16_slice_search/contains/52 + time: [65.998 µs 66.308 µs 66.764 µs] +Benchmarking i16_slice_search/binary_search/52 +Benchmarking i16_slice_search/binary_search/52: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/52: Collecting 10 samples in estimated 100.54 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/52: Analyzing +i16_slice_search/binary_search/52 + time: [24.911 µs 25.018 µs 25.094 µs] +Benchmarking i16_slice_search/hashset/52 +Benchmarking i16_slice_search/hashset/52: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/52: Collecting 10 samples in estimated 100.59 ms (7095 iterations) +Benchmarking i16_slice_search/hashset/52: Analyzing +i16_slice_search/hashset/52 + time: [14.032 µs 14.086 µs 14.146 µs] +Benchmarking i16_slice_search/branchless/52 +Benchmarking i16_slice_search/branchless/52: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/52: Collecting 10 samples in estimated 100.37 ms (9845 iterations) +Benchmarking i16_slice_search/branchless/52: Analyzing +i16_slice_search/branchless/52 + time: [10.179 µs 10.210 µs 10.255 µs] +Benchmarking i16_slice_search/contains/54 +Benchmarking i16_slice_search/contains/54: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/54: Collecting 10 samples in estimated 100.07 ms (1375 iterations) +Benchmarking i16_slice_search/contains/54: Analyzing +i16_slice_search/contains/54 + time: [72.218 µs 72.412 µs 72.755 µs] +Found 4 outliers among 10 measurements (40.00%) + 2 (20.00%) low mild + 2 (20.00%) high mild +Benchmarking i16_slice_search/binary_search/54 +Benchmarking i16_slice_search/binary_search/54: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/54: Collecting 10 samples in estimated 100.16 ms (3960 iterations) +Benchmarking i16_slice_search/binary_search/54: Analyzing +i16_slice_search/binary_search/54 + time: [24.941 µs 25.022 µs 25.095 µs] +Benchmarking i16_slice_search/hashset/54 +Benchmarking i16_slice_search/hashset/54: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/54: Collecting 10 samples in estimated 100.62 ms (6490 iterations) +Benchmarking i16_slice_search/hashset/54: Analyzing +i16_slice_search/hashset/54 + time: [23.104 µs 37.639 µs 45.537 µs] +Benchmarking i16_slice_search/branchless/54 +Benchmarking i16_slice_search/branchless/54: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/54: Collecting 10 samples in estimated 100.30 ms (9515 iterations) +Benchmarking i16_slice_search/branchless/54: Analyzing +i16_slice_search/branchless/54 + time: [10.530 µs 10.549 µs 10.570 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low severe + 2 (20.00%) high severe +Benchmarking i16_slice_search/contains/56 +Benchmarking i16_slice_search/contains/56: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/56: Collecting 10 samples in estimated 102.74 ms (1375 iterations) +Benchmarking i16_slice_search/contains/56: Analyzing +i16_slice_search/contains/56 + time: [74.267 µs 74.423 µs 74.591 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/56 +Benchmarking i16_slice_search/binary_search/56: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/56: Collecting 10 samples in estimated 101.06 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/56: Analyzing +i16_slice_search/binary_search/56 + time: [24.948 µs 25.010 µs 25.087 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/56 +Benchmarking i16_slice_search/hashset/56: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/56: Collecting 10 samples in estimated 100.82 ms (6710 iterations) +Benchmarking i16_slice_search/hashset/56: Analyzing +i16_slice_search/hashset/56 + time: [14.996 µs 15.036 µs 15.087 µs] +Benchmarking i16_slice_search/branchless/56 +Benchmarking i16_slice_search/branchless/56: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/56: Collecting 10 samples in estimated 100.06 ms (9185 iterations) +Benchmarking i16_slice_search/branchless/56: Analyzing +i16_slice_search/branchless/56 + time: [10.855 µs 10.896 µs 10.955 µs] +Benchmarking i16_slice_search/contains/58 +Benchmarking i16_slice_search/contains/58: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/58: Collecting 10 samples in estimated 102.10 ms (1265 iterations) +Benchmarking i16_slice_search/contains/58: Analyzing +i16_slice_search/contains/58 + time: [80.342 µs 80.602 µs 80.980 µs] +Benchmarking i16_slice_search/binary_search/58 +Benchmarking i16_slice_search/binary_search/58: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/58: Collecting 10 samples in estimated 100.30 ms (3960 iterations) +Benchmarking i16_slice_search/binary_search/58: Analyzing +i16_slice_search/binary_search/58 + time: [25.205 µs 25.681 µs 26.549 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/58 +Benchmarking i16_slice_search/hashset/58: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/58: Collecting 10 samples in estimated 100.60 ms (6710 iterations) +Benchmarking i16_slice_search/hashset/58: Analyzing +i16_slice_search/hashset/58 + time: [14.763 µs 15.347 µs 16.755 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/58 +Benchmarking i16_slice_search/branchless/58: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/58: Collecting 10 samples in estimated 100.61 ms (8965 iterations) +Benchmarking i16_slice_search/branchless/58: Analyzing +i16_slice_search/branchless/58 + time: [11.125 µs 11.156 µs 11.192 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/contains/60 +Benchmarking i16_slice_search/contains/60: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/60: Collecting 10 samples in estimated 102.47 ms (1210 iterations) +Benchmarking i16_slice_search/contains/60: Analyzing +i16_slice_search/contains/60 + time: [84.452 µs 84.902 µs 85.653 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/binary_search/60 +Benchmarking i16_slice_search/binary_search/60: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/60: Collecting 10 samples in estimated 100.15 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/60: Analyzing +i16_slice_search/binary_search/60 + time: [24.907 µs 25.013 µs 25.137 µs] +Benchmarking i16_slice_search/hashset/60 +Benchmarking i16_slice_search/hashset/60: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/60: Collecting 10 samples in estimated 100.53 ms (7590 iterations) +Benchmarking i16_slice_search/hashset/60: Analyzing +i16_slice_search/hashset/60 + time: [13.162 µs 13.255 µs 13.356 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/60 +Benchmarking i16_slice_search/branchless/60: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/60: Collecting 10 samples in estimated 100.13 ms (8690 iterations) +Benchmarking i16_slice_search/branchless/60: Analyzing +i16_slice_search/branchless/60 + time: [11.458 µs 11.523 µs 11.571 µs] +Benchmarking i16_slice_search/contains/62 +Benchmarking i16_slice_search/contains/62: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/62: Collecting 10 samples in estimated 103.00 ms (1155 iterations) +Benchmarking i16_slice_search/contains/62: Analyzing +i16_slice_search/contains/62 + time: [88.574 µs 88.923 µs 89.425 µs] +Benchmarking i16_slice_search/binary_search/62 +Benchmarking i16_slice_search/binary_search/62: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/62: Collecting 10 samples in estimated 100.73 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/62: Analyzing +i16_slice_search/binary_search/62 + time: [24.919 µs 24.981 µs 25.034 µs] +Benchmarking i16_slice_search/hashset/62 +Benchmarking i16_slice_search/hashset/62: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/62: Collecting 10 samples in estimated 100.29 ms (7095 iterations) +Benchmarking i16_slice_search/hashset/62: Analyzing +i16_slice_search/hashset/62 + time: [14.083 µs 14.151 µs 14.225 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/62 +Benchmarking i16_slice_search/branchless/62: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/62: Collecting 10 samples in estimated 100.65 ms (8470 iterations) +Benchmarking i16_slice_search/branchless/62: Analyzing +i16_slice_search/branchless/62 + time: [11.928 µs 11.975 µs 12.035 µs] +Benchmarking i16_slice_search/contains/64 +Benchmarking i16_slice_search/contains/64: Warming up for 50.000 ms +Benchmarking i16_slice_search/contains/64: Collecting 10 samples in estimated 100.38 ms (3905 iterations) +Benchmarking i16_slice_search/contains/64: Analyzing +i16_slice_search/contains/64 + time: [25.600 µs 25.711 µs 25.830 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/binary_search/64 +Benchmarking i16_slice_search/binary_search/64: Warming up for 50.000 ms +Benchmarking i16_slice_search/binary_search/64: Collecting 10 samples in estimated 101.02 ms (4015 iterations) +Benchmarking i16_slice_search/binary_search/64: Analyzing +i16_slice_search/binary_search/64 + time: [24.918 µs 25.000 µs 25.111 µs] +Benchmarking i16_slice_search/hashset/64 +Benchmarking i16_slice_search/hashset/64: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/64: Collecting 10 samples in estimated 100.36 ms (7095 iterations) +Benchmarking i16_slice_search/hashset/64: Analyzing +i16_slice_search/hashset/64 + time: [14.065 µs 14.099 µs 14.138 µs] +Benchmarking i16_slice_search/branchless/64 +Benchmarking i16_slice_search/branchless/64: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/64: Collecting 10 samples in estimated 100.46 ms (8250 iterations) +Benchmarking i16_slice_search/branchless/64: Analyzing +i16_slice_search/branchless/64 + time: [12.214 µs 12.351 µs 12.528 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i16_slice_search/hashset/80 +Benchmarking i16_slice_search/hashset/80: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/80: Collecting 10 samples in estimated 100.16 ms (7645 iterations) +Benchmarking i16_slice_search/hashset/80: Analyzing +i16_slice_search/hashset/80 + time: [12.882 µs 12.971 µs 13.059 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/branchless/80 +Benchmarking i16_slice_search/branchless/80: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/80: Collecting 10 samples in estimated 100.66 ms (5830 iterations) +Benchmarking i16_slice_search/branchless/80: Analyzing +i16_slice_search/branchless/80 + time: [17.207 µs 17.300 µs 17.463 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i16_slice_search/hashset/96 +Benchmarking i16_slice_search/hashset/96: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/96: Collecting 10 samples in estimated 100.34 ms (7535 iterations) +Benchmarking i16_slice_search/hashset/96: Analyzing +i16_slice_search/hashset/96 + time: [13.078 µs 13.169 µs 13.257 µs] +Benchmarking i16_slice_search/branchless/96 +Benchmarking i16_slice_search/branchless/96: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/96: Collecting 10 samples in estimated 100.91 ms (5885 iterations) +Benchmarking i16_slice_search/branchless/96: Analyzing +i16_slice_search/branchless/96 + time: [16.957 µs 17.036 µs 17.109 µs] +Benchmarking i16_slice_search/hashset/112 +Benchmarking i16_slice_search/hashset/112: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/112: Collecting 10 samples in estimated 100.86 ms (5555 iterations) +Benchmarking i16_slice_search/hashset/112: Analyzing +i16_slice_search/hashset/112 + time: [18.113 µs 18.271 µs 18.369 µs] +Benchmarking i16_slice_search/branchless/112 +Benchmarking i16_slice_search/branchless/112: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/112: Collecting 10 samples in estimated 100.16 ms (4180 iterations) +Benchmarking i16_slice_search/branchless/112: Analyzing +i16_slice_search/branchless/112 + time: [22.769 µs 23.445 µs 24.389 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i16_slice_search/hashset/128 +Benchmarking i16_slice_search/hashset/128: Warming up for 50.000 ms +Benchmarking i16_slice_search/hashset/128: Collecting 10 samples in estimated 100.33 ms (7535 iterations) +Benchmarking i16_slice_search/hashset/128: Analyzing +i16_slice_search/hashset/128 + time: [13.148 µs 13.207 µs 13.278 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i16_slice_search/branchless/128 +Benchmarking i16_slice_search/branchless/128: Warming up for 50.000 ms +Benchmarking i16_slice_search/branchless/128: Collecting 10 samples in estimated 100.03 ms (4235 iterations) +Benchmarking i16_slice_search/branchless/128: Analyzing +i16_slice_search/branchless/128 + time: [23.601 µs 23.743 µs 23.971 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild + +Benchmarking i32_slice_search/contains/2 +Benchmarking i32_slice_search/contains/2: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/2: Collecting 10 samples in estimated 100.16 ms (6435 iterations) +Benchmarking i32_slice_search/contains/2: Analyzing +i32_slice_search/contains/2 + time: [15.320 µs 15.390 µs 15.451 µs] +Benchmarking i32_slice_search/binary_search/2 +Benchmarking i32_slice_search/binary_search/2: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/2: Collecting 10 samples in estimated 100.30 ms (16k iterations) +Benchmarking i32_slice_search/binary_search/2: Analyzing +i32_slice_search/binary_search/2 + time: [6.0279 µs 8.0580 µs 11.052 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/2 +Benchmarking i32_slice_search/hashset/2: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/2: Collecting 10 samples in estimated 100.54 ms (8360 iterations) +Benchmarking i32_slice_search/hashset/2: Analyzing +i32_slice_search/hashset/2 + time: [11.963 µs 12.047 µs 12.208 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/2 +Benchmarking i32_slice_search/branchless/2: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/2: Collecting 10 samples in estimated 100.07 ms (66k iterations) +Benchmarking i32_slice_search/branchless/2: Analyzing +i32_slice_search/branchless/2 + time: [1.5164 µs 1.5195 µs 1.5228 µs] +Benchmarking i32_slice_search/contains/3 +Benchmarking i32_slice_search/contains/3: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/3: Collecting 10 samples in estimated 100.92 ms (5940 iterations) +Benchmarking i32_slice_search/contains/3: Analyzing +i32_slice_search/contains/3 + time: [17.012 µs 17.083 µs 17.134 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/3 +Benchmarking i32_slice_search/binary_search/3: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/3: Collecting 10 samples in estimated 100.24 ms (11k iterations) +Benchmarking i32_slice_search/binary_search/3: Analyzing +i32_slice_search/binary_search/3 + time: [9.2130 µs 9.2833 µs 9.4031 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/3 +Benchmarking i32_slice_search/hashset/3: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/3: Collecting 10 samples in estimated 100.25 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/3: Analyzing +i32_slice_search/hashset/3 + time: [11.838 µs 11.876 µs 11.939 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/3 +Benchmarking i32_slice_search/branchless/3: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/3: Collecting 10 samples in estimated 100.08 ms (54k iterations) +Benchmarking i32_slice_search/branchless/3: Analyzing +i32_slice_search/branchless/3 + time: [1.8422 µs 1.8475 µs 1.8527 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i32_slice_search/contains/4 +Benchmarking i32_slice_search/contains/4: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/4: Collecting 10 samples in estimated 100.64 ms (5170 iterations) +Benchmarking i32_slice_search/contains/4: Analyzing +i32_slice_search/contains/4 + time: [19.345 µs 19.498 µs 19.593 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/4 +Benchmarking i32_slice_search/binary_search/4: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/4: Collecting 10 samples in estimated 100.14 ms (11k iterations) +Benchmarking i32_slice_search/binary_search/4: Analyzing +i32_slice_search/binary_search/4 + time: [9.2741 µs 9.3988 µs 9.5902 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/4 +Benchmarking i32_slice_search/hashset/4: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/4: Collecting 10 samples in estimated 100.14 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/4: Analyzing +i32_slice_search/hashset/4 + time: [11.849 µs 11.895 µs 11.960 µs] +Benchmarking i32_slice_search/branchless/4 +Benchmarking i32_slice_search/branchless/4: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/4: Collecting 10 samples in estimated 100.06 ms (31k iterations) +Benchmarking i32_slice_search/branchless/4: Analyzing +i32_slice_search/branchless/4 + time: [2.1731 µs 2.1847 µs 2.2016 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/5 +Benchmarking i32_slice_search/contains/5: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/5: Collecting 10 samples in estimated 100.27 ms (4620 iterations) +Benchmarking i32_slice_search/contains/5: Analyzing +i32_slice_search/contains/5 + time: [21.571 µs 21.638 µs 21.718 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i32_slice_search/binary_search/5 +Benchmarking i32_slice_search/binary_search/5: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/5: Collecting 10 samples in estimated 100.47 ms (7645 iterations) +Benchmarking i32_slice_search/binary_search/5: Analyzing +i32_slice_search/binary_search/5 + time: [13.132 µs 13.200 µs 13.267 µs] +Benchmarking i32_slice_search/hashset/5 +Benchmarking i32_slice_search/hashset/5: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/5: Collecting 10 samples in estimated 100.14 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/5: Analyzing +i32_slice_search/hashset/5 + time: [11.960 µs 12.131 µs 12.284 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/5 +Benchmarking i32_slice_search/branchless/5: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/5: Collecting 10 samples in estimated 100.11 ms (28k iterations) +Benchmarking i32_slice_search/branchless/5: Analyzing +i32_slice_search/branchless/5 + time: [2.5074 µs 2.5300 µs 2.5504 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/6 +Benchmarking i32_slice_search/contains/6: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/6: Collecting 10 samples in estimated 100.08 ms (4180 iterations) +Benchmarking i32_slice_search/contains/6: Analyzing +i32_slice_search/contains/6 + time: [23.868 µs 23.926 µs 24.039 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/6 +Benchmarking i32_slice_search/binary_search/6: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/6: Collecting 10 samples in estimated 100.58 ms (7590 iterations) +Benchmarking i32_slice_search/binary_search/6: Analyzing +i32_slice_search/binary_search/6 + time: [13.144 µs 13.215 µs 13.292 µs] +Benchmarking i32_slice_search/hashset/6 +Benchmarking i32_slice_search/hashset/6: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/6: Collecting 10 samples in estimated 100.18 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/6: Analyzing +i32_slice_search/hashset/6 + time: [11.854 µs 11.896 µs 11.955 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/6 +Benchmarking i32_slice_search/branchless/6: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/6: Collecting 10 samples in estimated 100.06 ms (35k iterations) +Benchmarking i32_slice_search/branchless/6: Analyzing +i32_slice_search/branchless/6 + time: [2.8202 µs 2.8284 µs 2.8397 µs] +Benchmarking i32_slice_search/contains/7 +Benchmarking i32_slice_search/contains/7: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/7: Collecting 10 samples in estimated 100.30 ms (4125 iterations) +Benchmarking i32_slice_search/contains/7: Analyzing +i32_slice_search/contains/7 + time: [24.128 µs 24.196 µs 24.292 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/7 +Benchmarking i32_slice_search/binary_search/7: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/7: Collecting 10 samples in estimated 100.31 ms (7645 iterations) +Benchmarking i32_slice_search/binary_search/7: Analyzing +i32_slice_search/binary_search/7 + time: [13.136 µs 13.186 µs 13.226 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/7 +Benchmarking i32_slice_search/hashset/7: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/7: Collecting 10 samples in estimated 100.53 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/7: Analyzing +i32_slice_search/hashset/7 + time: [11.862 µs 11.907 µs 11.958 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/7 +Benchmarking i32_slice_search/branchless/7: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/7: Collecting 10 samples in estimated 100.05 ms (32k iterations) +Benchmarking i32_slice_search/branchless/7: Analyzing +i32_slice_search/branchless/7 + time: [3.1503 µs 3.1597 µs 3.1704 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i32_slice_search/contains/8 +Benchmarking i32_slice_search/contains/8: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/8: Collecting 10 samples in estimated 101.05 ms (3520 iterations) +Benchmarking i32_slice_search/contains/8: Analyzing +i32_slice_search/contains/8 + time: [28.884 µs 29.181 µs 29.365 µs] +Benchmarking i32_slice_search/binary_search/8 +Benchmarking i32_slice_search/binary_search/8: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/8: Collecting 10 samples in estimated 100.49 ms (7645 iterations) +Benchmarking i32_slice_search/binary_search/8: Analyzing +i32_slice_search/binary_search/8 + time: [13.079 µs 13.116 µs 13.157 µs] +Benchmarking i32_slice_search/hashset/8 +Benchmarking i32_slice_search/hashset/8: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/8: Collecting 10 samples in estimated 100.00 ms (8085 iterations) +Benchmarking i32_slice_search/hashset/8: Analyzing +i32_slice_search/hashset/8 + time: [12.329 µs 12.371 µs 12.423 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/8 +Benchmarking i32_slice_search/branchless/8: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/8: Collecting 10 samples in estimated 100.09 ms (29k iterations) +Benchmarking i32_slice_search/branchless/8: Analyzing +i32_slice_search/branchless/8 + time: [3.4657 µs 3.4751 µs 3.4868 µs] +Benchmarking i32_slice_search/contains/9 +Benchmarking i32_slice_search/contains/9: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/9: Collecting 10 samples in estimated 100.49 ms (3245 iterations) +Benchmarking i32_slice_search/contains/9: Analyzing +i32_slice_search/contains/9 + time: [30.860 µs 31.196 µs 31.530 µs] +Benchmarking i32_slice_search/binary_search/9 +Benchmarking i32_slice_search/binary_search/9: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/9: Collecting 10 samples in estimated 100.70 ms (6215 iterations) +Benchmarking i32_slice_search/binary_search/9: Analyzing +i32_slice_search/binary_search/9 + time: [16.148 µs 16.218 µs 16.306 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i32_slice_search/hashset/9 +Benchmarking i32_slice_search/hashset/9: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/9: Collecting 10 samples in estimated 100.44 ms (8140 iterations) +Benchmarking i32_slice_search/hashset/9: Analyzing +i32_slice_search/hashset/9 + time: [12.248 µs 12.289 µs 12.346 µs] +Benchmarking i32_slice_search/branchless/9 +Benchmarking i32_slice_search/branchless/9: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/9: Collecting 10 samples in estimated 100.12 ms (26k iterations) +Benchmarking i32_slice_search/branchless/9: Analyzing +i32_slice_search/branchless/9 + time: [3.7964 µs 3.8090 µs 3.8295 µs] +Benchmarking i32_slice_search/contains/10 +Benchmarking i32_slice_search/contains/10: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/10: Collecting 10 samples in estimated 100.37 ms (3025 iterations) +Benchmarking i32_slice_search/contains/10: Analyzing +i32_slice_search/contains/10 + time: [32.961 µs 33.079 µs 33.196 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i32_slice_search/binary_search/10 +Benchmarking i32_slice_search/binary_search/10: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/10: Collecting 10 samples in estimated 100.03 ms (5940 iterations) +Benchmarking i32_slice_search/binary_search/10: Analyzing +i32_slice_search/binary_search/10 + time: [16.437 µs 16.526 µs 16.626 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking i32_slice_search/hashset/10 +Benchmarking i32_slice_search/hashset/10: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/10: Collecting 10 samples in estimated 100.55 ms (8140 iterations) +Benchmarking i32_slice_search/hashset/10: Analyzing +i32_slice_search/hashset/10 + time: [12.284 µs 12.315 µs 12.374 µs] +Benchmarking i32_slice_search/branchless/10 +Benchmarking i32_slice_search/branchless/10: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/10: Collecting 10 samples in estimated 100.14 ms (24k iterations) +Benchmarking i32_slice_search/branchless/10: Analyzing +i32_slice_search/branchless/10 + time: [4.1273 µs 4.1434 µs 4.1672 µs] +Benchmarking i32_slice_search/contains/11 +Benchmarking i32_slice_search/contains/11: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/11: Collecting 10 samples in estimated 101.90 ms (2860 iterations) +Benchmarking i32_slice_search/contains/11: Analyzing +i32_slice_search/contains/11 + time: [55.201 µs 80.623 µs 96.564 µs] +Benchmarking i32_slice_search/binary_search/11 +Benchmarking i32_slice_search/binary_search/11: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/11: Collecting 10 samples in estimated 100.54 ms (6160 iterations) +Benchmarking i32_slice_search/binary_search/11: Analyzing +i32_slice_search/binary_search/11 + time: [16.170 µs 16.264 µs 16.367 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/11 +Benchmarking i32_slice_search/hashset/11: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/11: Collecting 10 samples in estimated 100.21 ms (8030 iterations) +Benchmarking i32_slice_search/hashset/11: Analyzing +i32_slice_search/hashset/11 + time: [12.397 µs 12.456 µs 12.545 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/11 +Benchmarking i32_slice_search/branchless/11: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/11: Collecting 10 samples in estimated 100.19 ms (22k iterations) +Benchmarking i32_slice_search/branchless/11: Analyzing +i32_slice_search/branchless/11 + time: [4.4543 µs 4.4770 µs 4.4988 µs] +Benchmarking i32_slice_search/contains/12 +Benchmarking i32_slice_search/contains/12: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/12: Collecting 10 samples in estimated 101.85 ms (2695 iterations) +Benchmarking i32_slice_search/contains/12: Analyzing +i32_slice_search/contains/12 + time: [37.678 µs 37.826 µs 38.045 µs] +Benchmarking i32_slice_search/binary_search/12 +Benchmarking i32_slice_search/binary_search/12: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/12: Collecting 10 samples in estimated 100.53 ms (6160 iterations) +Benchmarking i32_slice_search/binary_search/12: Analyzing +i32_slice_search/binary_search/12 + time: [16.257 µs 16.330 µs 16.393 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/12 +Benchmarking i32_slice_search/hashset/12: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/12: Collecting 10 samples in estimated 100.41 ms (7865 iterations) +Benchmarking i32_slice_search/hashset/12: Analyzing +i32_slice_search/hashset/12 + time: [12.672 µs 12.712 µs 12.763 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/12 +Benchmarking i32_slice_search/branchless/12: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/12: Collecting 10 samples in estimated 100.06 ms (21k iterations) +Benchmarking i32_slice_search/branchless/12: Analyzing +i32_slice_search/branchless/12 + time: [4.7817 µs 4.7968 µs 4.8086 µs] +Benchmarking i32_slice_search/contains/13 +Benchmarking i32_slice_search/contains/13: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/13: Collecting 10 samples in estimated 101.38 ms (2530 iterations) +Benchmarking i32_slice_search/contains/13: Analyzing +i32_slice_search/contains/13 + time: [39.823 µs 39.955 µs 40.147 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/13 +Benchmarking i32_slice_search/binary_search/13: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/13: Collecting 10 samples in estimated 100.43 ms (6105 iterations) +Benchmarking i32_slice_search/binary_search/13: Analyzing +i32_slice_search/binary_search/13 + time: [16.241 µs 16.296 µs 16.349 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/13 +Benchmarking i32_slice_search/hashset/13: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/13: Collecting 10 samples in estimated 100.62 ms (7205 iterations) +Benchmarking i32_slice_search/hashset/13: Analyzing +i32_slice_search/hashset/13 + time: [13.806 µs 13.852 µs 13.905 µs] +Benchmarking i32_slice_search/branchless/13 +Benchmarking i32_slice_search/branchless/13: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/13: Collecting 10 samples in estimated 100.23 ms (19k iterations) +Benchmarking i32_slice_search/branchless/13: Analyzing +i32_slice_search/branchless/13 + time: [5.0988 µs 5.1103 µs 5.1291 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/contains/14 +Benchmarking i32_slice_search/contains/14: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/14: Collecting 10 samples in estimated 102.01 ms (2530 iterations) +Benchmarking i32_slice_search/contains/14: Analyzing +i32_slice_search/contains/14 + time: [42.405 µs 78.769 µs 96.828 µs] +Benchmarking i32_slice_search/binary_search/14 +Benchmarking i32_slice_search/binary_search/14: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/14: Collecting 10 samples in estimated 100.55 ms (6160 iterations) +Benchmarking i32_slice_search/binary_search/14: Analyzing +i32_slice_search/binary_search/14 + time: [16.221 µs 16.273 µs 16.345 µs] +Benchmarking i32_slice_search/hashset/14 +Benchmarking i32_slice_search/hashset/14: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/14: Collecting 10 samples in estimated 100.21 ms (6930 iterations) +Benchmarking i32_slice_search/hashset/14: Analyzing +i32_slice_search/hashset/14 + time: [14.395 µs 14.472 µs 14.591 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/14 +Benchmarking i32_slice_search/branchless/14: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/14: Collecting 10 samples in estimated 100.05 ms (18k iterations) +Benchmarking i32_slice_search/branchless/14: Analyzing +i32_slice_search/branchless/14 + time: [5.4557 µs 5.4708 µs 5.4890 µs] +Found 4 outliers among 10 measurements (40.00%) + 2 (20.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/15 +Benchmarking i32_slice_search/contains/15: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/15: Collecting 10 samples in estimated 102.06 ms (2090 iterations) +Benchmarking i32_slice_search/contains/15: Analyzing +i32_slice_search/contains/15 + time: [48.501 µs 48.730 µs 49.021 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/15 +Benchmarking i32_slice_search/binary_search/15: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/15: Collecting 10 samples in estimated 100.27 ms (6160 iterations) +Benchmarking i32_slice_search/binary_search/15: Analyzing +i32_slice_search/binary_search/15 + time: [16.160 µs 16.251 µs 16.355 µs] +Benchmarking i32_slice_search/hashset/15 +Benchmarking i32_slice_search/hashset/15: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/15: Collecting 10 samples in estimated 100.32 ms (8360 iterations) +Benchmarking i32_slice_search/hashset/15: Analyzing +i32_slice_search/hashset/15 + time: [11.834 µs 11.861 µs 11.895 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/15 +Benchmarking i32_slice_search/branchless/15: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/15: Collecting 10 samples in estimated 100.28 ms (17k iterations) +Benchmarking i32_slice_search/branchless/15: Analyzing +i32_slice_search/branchless/15 + time: [5.7513 µs 5.7721 µs 5.8115 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/16 +Benchmarking i32_slice_search/contains/16: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/16: Collecting 10 samples in estimated 100.23 ms (8965 iterations) +Benchmarking i32_slice_search/contains/16: Analyzing +i32_slice_search/contains/16 + time: [11.149 µs 11.190 µs 11.225 µs] +Benchmarking i32_slice_search/binary_search/16 +Benchmarking i32_slice_search/binary_search/16: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/16: Collecting 10 samples in estimated 100.43 ms (6160 iterations) +Benchmarking i32_slice_search/binary_search/16: Analyzing +i32_slice_search/binary_search/16 + time: [16.199 µs 16.270 µs 16.365 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/16 +Benchmarking i32_slice_search/hashset/16: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/16: Collecting 10 samples in estimated 100.02 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/16: Analyzing +i32_slice_search/hashset/16 + time: [11.857 µs 11.885 µs 11.925 µs] +Benchmarking i32_slice_search/branchless/16 +Benchmarking i32_slice_search/branchless/16: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/16: Collecting 10 samples in estimated 100.17 ms (16k iterations) +Benchmarking i32_slice_search/branchless/16: Analyzing +i32_slice_search/branchless/16 + time: [6.1286 µs 6.1486 µs 6.1662 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/contains/17 +Benchmarking i32_slice_search/contains/17: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/17: Collecting 10 samples in estimated 100.18 ms (6765 iterations) +Benchmarking i32_slice_search/contains/17: Analyzing +i32_slice_search/contains/17 + time: [14.829 µs 15.037 µs 15.171 µs] +Benchmarking i32_slice_search/binary_search/17 +Benchmarking i32_slice_search/binary_search/17: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/17: Collecting 10 samples in estimated 100.59 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/17: Analyzing +i32_slice_search/binary_search/17 + time: [20.013 µs 20.068 µs 20.151 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/17 +Benchmarking i32_slice_search/hashset/17: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/17: Collecting 10 samples in estimated 100.28 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/17: Analyzing +i32_slice_search/hashset/17 + time: [11.871 µs 11.909 µs 12.003 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/17 +Benchmarking i32_slice_search/branchless/17: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/17: Collecting 10 samples in estimated 100.24 ms (15k iterations) +Benchmarking i32_slice_search/branchless/17: Analyzing +i32_slice_search/branchless/17 + time: [6.4905 µs 6.5459 µs 6.6173 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/contains/18 +Benchmarking i32_slice_search/contains/18: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/18: Collecting 10 samples in estimated 100.98 ms (5115 iterations) +Benchmarking i32_slice_search/contains/18: Analyzing +i32_slice_search/contains/18 + time: [19.677 µs 19.721 µs 19.766 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i32_slice_search/binary_search/18 +Benchmarking i32_slice_search/binary_search/18: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/18: Collecting 10 samples in estimated 100.34 ms (4950 iterations) +Benchmarking i32_slice_search/binary_search/18: Analyzing +i32_slice_search/binary_search/18 + time: [20.019 µs 20.071 µs 20.149 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/18 +Benchmarking i32_slice_search/hashset/18: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/18: Collecting 10 samples in estimated 100.29 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/18: Analyzing +i32_slice_search/hashset/18 + time: [11.857 µs 11.905 µs 11.971 µs] +Benchmarking i32_slice_search/branchless/18 +Benchmarking i32_slice_search/branchless/18: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/18: Collecting 10 samples in estimated 100.20 ms (15k iterations) +Benchmarking i32_slice_search/branchless/18: Analyzing +i32_slice_search/branchless/18 + time: [6.7865 µs 6.8061 µs 6.8362 µs] +Benchmarking i32_slice_search/contains/19 +Benchmarking i32_slice_search/contains/19: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/19: Collecting 10 samples in estimated 100.51 ms (4510 iterations) +Benchmarking i32_slice_search/contains/19: Analyzing +i32_slice_search/contains/19 + time: [22.207 µs 22.292 µs 22.421 µs] +Benchmarking i32_slice_search/binary_search/19 +Benchmarking i32_slice_search/binary_search/19: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/19: Collecting 10 samples in estimated 100.64 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/19: Analyzing +i32_slice_search/binary_search/19 + time: [20.026 µs 20.093 µs 20.218 µs] +Benchmarking i32_slice_search/hashset/19 +Benchmarking i32_slice_search/hashset/19: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/19: Collecting 10 samples in estimated 100.59 ms (6600 iterations) +Benchmarking i32_slice_search/hashset/19: Analyzing +i32_slice_search/hashset/19 + time: [15.167 µs 15.211 µs 15.236 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i32_slice_search/branchless/19 +Benchmarking i32_slice_search/branchless/19: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/19: Collecting 10 samples in estimated 100.14 ms (14k iterations) +Benchmarking i32_slice_search/branchless/19: Analyzing +i32_slice_search/branchless/19 + time: [7.1594 µs 7.1843 µs 7.2145 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) low mild +Benchmarking i32_slice_search/contains/20 +Benchmarking i32_slice_search/contains/20: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/20: Collecting 10 samples in estimated 100.05 ms (4180 iterations) +Benchmarking i32_slice_search/contains/20: Analyzing +i32_slice_search/contains/20 + time: [23.825 µs 23.903 µs 24.007 µs] +Benchmarking i32_slice_search/binary_search/20 +Benchmarking i32_slice_search/binary_search/20: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/20: Collecting 10 samples in estimated 100.62 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/20: Analyzing +i32_slice_search/binary_search/20 + time: [20.064 µs 20.143 µs 20.252 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i32_slice_search/hashset/20 +Benchmarking i32_slice_search/hashset/20: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/20: Collecting 10 samples in estimated 100.36 ms (8305 iterations) +Benchmarking i32_slice_search/hashset/20: Analyzing +i32_slice_search/hashset/20 + time: [12.032 µs 12.072 µs 12.138 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/20 +Benchmarking i32_slice_search/branchless/20: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/20: Collecting 10 samples in estimated 100.20 ms (13k iterations) +Benchmarking i32_slice_search/branchless/20: Analyzing +i32_slice_search/branchless/20 + time: [7.4914 µs 7.5555 µs 7.6133 µs] +Benchmarking i32_slice_search/contains/21 +Benchmarking i32_slice_search/contains/21: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/21: Collecting 10 samples in estimated 101.19 ms (4015 iterations) +Benchmarking i32_slice_search/contains/21: Analyzing +i32_slice_search/contains/21 + time: [24.818 µs 24.964 µs 25.126 µs] +Benchmarking i32_slice_search/binary_search/21 +Benchmarking i32_slice_search/binary_search/21: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/21: Collecting 10 samples in estimated 100.70 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/21: Analyzing +i32_slice_search/binary_search/21 + time: [20.110 µs 20.183 µs 20.299 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/21 +Benchmarking i32_slice_search/hashset/21: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/21: Collecting 10 samples in estimated 100.15 ms (8360 iterations) +Benchmarking i32_slice_search/hashset/21: Analyzing +i32_slice_search/hashset/21 + time: [11.866 µs 11.897 µs 11.938 µs] +Benchmarking i32_slice_search/branchless/21 +Benchmarking i32_slice_search/branchless/21: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/21: Collecting 10 samples in estimated 100.00 ms (13k iterations) +Benchmarking i32_slice_search/branchless/21: Analyzing +i32_slice_search/branchless/21 + time: [7.7753 µs 7.8086 µs 7.8476 µs] +Benchmarking i32_slice_search/contains/22 +Benchmarking i32_slice_search/contains/22: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/22: Collecting 10 samples in estimated 100.74 ms (3575 iterations) +Benchmarking i32_slice_search/contains/22: Analyzing +i32_slice_search/contains/22 + time: [28.025 µs 28.134 µs 28.245 µs] +Benchmarking i32_slice_search/binary_search/22 +Benchmarking i32_slice_search/binary_search/22: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/22: Collecting 10 samples in estimated 100.47 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/22: Analyzing +i32_slice_search/binary_search/22 + time: [20.025 µs 20.092 µs 20.185 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i32_slice_search/hashset/22 +Benchmarking i32_slice_search/hashset/22: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/22: Collecting 10 samples in estimated 100.33 ms (8250 iterations) +Benchmarking i32_slice_search/hashset/22: Analyzing +i32_slice_search/hashset/22 + time: [12.148 µs 12.182 µs 12.208 µs] +Benchmarking i32_slice_search/branchless/22 +Benchmarking i32_slice_search/branchless/22: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/22: Collecting 10 samples in estimated 100.13 ms (12k iterations) +Benchmarking i32_slice_search/branchless/22: Analyzing +i32_slice_search/branchless/22 + time: [8.0987 µs 8.1155 µs 8.1395 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i32_slice_search/contains/23 +Benchmarking i32_slice_search/contains/23: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/23: Collecting 10 samples in estimated 100.55 ms (3080 iterations) +Benchmarking i32_slice_search/contains/23: Analyzing +i32_slice_search/contains/23 + time: [32.661 µs 32.869 µs 33.137 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i32_slice_search/binary_search/23 +Benchmarking i32_slice_search/binary_search/23: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/23: Collecting 10 samples in estimated 100.78 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/23: Analyzing +i32_slice_search/binary_search/23 + time: [20.026 µs 20.086 µs 20.136 µs] +Benchmarking i32_slice_search/hashset/23 +Benchmarking i32_slice_search/hashset/23: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/23: Collecting 10 samples in estimated 100.08 ms (7590 iterations) +Benchmarking i32_slice_search/hashset/23: Analyzing +i32_slice_search/hashset/23 + time: [13.068 µs 13.095 µs 13.117 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i32_slice_search/branchless/23 +Benchmarking i32_slice_search/branchless/23: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/23: Collecting 10 samples in estimated 100.06 ms (12k iterations) +Benchmarking i32_slice_search/branchless/23: Analyzing +i32_slice_search/branchless/23 + time: [8.4464 µs 8.4806 µs 8.5198 µs] +Benchmarking i32_slice_search/contains/24 +Benchmarking i32_slice_search/contains/24: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/24: Collecting 10 samples in estimated 101.77 ms (2805 iterations) +Benchmarking i32_slice_search/contains/24: Analyzing +i32_slice_search/contains/24 + time: [35.943 µs 36.132 µs 36.420 µs] +Benchmarking i32_slice_search/binary_search/24 +Benchmarking i32_slice_search/binary_search/24: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/24: Collecting 10 samples in estimated 100.78 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/24: Analyzing +i32_slice_search/binary_search/24 + time: [19.995 µs 20.102 µs 20.318 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/24 +Benchmarking i32_slice_search/hashset/24: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/24: Collecting 10 samples in estimated 100.04 ms (6875 iterations) +Benchmarking i32_slice_search/hashset/24: Analyzing +i32_slice_search/hashset/24 + time: [14.496 µs 42.585 µs 61.200 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i32_slice_search/branchless/24 +Benchmarking i32_slice_search/branchless/24: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/24: Collecting 10 samples in estimated 100.34 ms (11k iterations) +Benchmarking i32_slice_search/branchless/24: Analyzing +i32_slice_search/branchless/24 + time: [8.8395 µs 8.8711 µs 8.9234 µs] +Benchmarking i32_slice_search/contains/25 +Benchmarking i32_slice_search/contains/25: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/25: Collecting 10 samples in estimated 100.62 ms (2640 iterations) +Benchmarking i32_slice_search/contains/25: Analyzing +i32_slice_search/contains/25 + time: [38.018 µs 38.142 µs 38.296 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/25 +Benchmarking i32_slice_search/binary_search/25: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/25: Collecting 10 samples in estimated 100.55 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/25: Analyzing +i32_slice_search/binary_search/25 + time: [20.058 µs 20.166 µs 20.305 µs] +Benchmarking i32_slice_search/hashset/25 +Benchmarking i32_slice_search/hashset/25: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/25: Collecting 10 samples in estimated 100.54 ms (6655 iterations) +Benchmarking i32_slice_search/hashset/25: Analyzing +i32_slice_search/hashset/25 + time: [14.986 µs 15.055 µs 15.122 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/25 +Benchmarking i32_slice_search/branchless/25: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/25: Collecting 10 samples in estimated 100.05 ms (11k iterations) +Benchmarking i32_slice_search/branchless/25: Analyzing +i32_slice_search/branchless/25 + time: [9.1755 µs 9.2168 µs 9.2566 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/26 +Benchmarking i32_slice_search/contains/26: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/26: Collecting 10 samples in estimated 101.94 ms (2200 iterations) +Benchmarking i32_slice_search/contains/26: Analyzing +i32_slice_search/contains/26 + time: [46.233 µs 46.573 µs 46.857 µs] +Benchmarking i32_slice_search/binary_search/26 +Benchmarking i32_slice_search/binary_search/26: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/26: Collecting 10 samples in estimated 100.37 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/26: Analyzing +i32_slice_search/binary_search/26 + time: [20.016 µs 20.091 µs 20.182 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/26 +Benchmarking i32_slice_search/hashset/26: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/26: Collecting 10 samples in estimated 100.81 ms (6325 iterations) +Benchmarking i32_slice_search/hashset/26: Analyzing +i32_slice_search/hashset/26 + time: [15.766 µs 15.861 µs 16.098 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/26 +Benchmarking i32_slice_search/branchless/26: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/26: Collecting 10 samples in estimated 100.25 ms (11k iterations) +Benchmarking i32_slice_search/branchless/26: Analyzing +i32_slice_search/branchless/26 + time: [9.5351 µs 9.5869 µs 9.6422 µs] +Benchmarking i32_slice_search/contains/27 +Benchmarking i32_slice_search/contains/27: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/27: Collecting 10 samples in estimated 100.63 ms (2090 iterations) +Benchmarking i32_slice_search/contains/27: Analyzing +i32_slice_search/contains/27 + time: [48.101 µs 48.251 µs 48.428 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/27 +Benchmarking i32_slice_search/binary_search/27: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/27: Collecting 10 samples in estimated 100.93 ms (4290 iterations) +Benchmarking i32_slice_search/binary_search/27: Analyzing +i32_slice_search/binary_search/27 + time: [29.701 µs 41.547 µs 59.187 µs] +Benchmarking i32_slice_search/hashset/27 +Benchmarking i32_slice_search/hashset/27: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/27: Collecting 10 samples in estimated 100.84 ms (2585 iterations) +Benchmarking i32_slice_search/hashset/27: Analyzing +i32_slice_search/hashset/27 + time: [18.286 µs 21.467 µs 25.454 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking i32_slice_search/branchless/27 +Benchmarking i32_slice_search/branchless/27: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/27: Collecting 10 samples in estimated 100.16 ms (10k iterations) +Benchmarking i32_slice_search/branchless/27: Analyzing +i32_slice_search/branchless/27 + time: [9.8306 µs 9.8587 µs 9.8811 µs] +Benchmarking i32_slice_search/contains/28 +Benchmarking i32_slice_search/contains/28: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/28: Collecting 10 samples in estimated 101.99 ms (2255 iterations) +Benchmarking i32_slice_search/contains/28: Analyzing +i32_slice_search/contains/28 + time: [45.106 µs 45.315 µs 45.596 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/28 +Benchmarking i32_slice_search/binary_search/28: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/28: Collecting 10 samples in estimated 100.17 ms (4895 iterations) +Benchmarking i32_slice_search/binary_search/28: Analyzing +i32_slice_search/binary_search/28 + time: [20.084 µs 20.176 µs 20.280 µs] +Benchmarking i32_slice_search/hashset/28 +Benchmarking i32_slice_search/hashset/28: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/28: Collecting 10 samples in estimated 100.16 ms (6930 iterations) +Benchmarking i32_slice_search/hashset/28: Analyzing +i32_slice_search/hashset/28 + time: [14.238 µs 14.323 µs 14.453 µs] +Benchmarking i32_slice_search/branchless/28 +Benchmarking i32_slice_search/branchless/28: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/28: Collecting 10 samples in estimated 100.29 ms (9845 iterations) +Benchmarking i32_slice_search/branchless/28: Analyzing +i32_slice_search/branchless/28 + time: [10.138 µs 10.201 µs 10.275 µs] +Benchmarking i32_slice_search/contains/29 +Benchmarking i32_slice_search/contains/29: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/29: Collecting 10 samples in estimated 100.82 ms (1925 iterations) +Benchmarking i32_slice_search/contains/29: Analyzing +i32_slice_search/contains/29 + time: [51.737 µs 52.013 µs 52.378 µs] +Benchmarking i32_slice_search/binary_search/29 +Benchmarking i32_slice_search/binary_search/29: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/29: Collecting 10 samples in estimated 100.63 ms (4950 iterations) +Benchmarking i32_slice_search/binary_search/29: Analyzing +i32_slice_search/binary_search/29 + time: [20.337 µs 21.857 µs 24.357 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/29 +Benchmarking i32_slice_search/hashset/29: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/29: Collecting 10 samples in estimated 100.46 ms (8250 iterations) +Benchmarking i32_slice_search/hashset/29: Analyzing +i32_slice_search/hashset/29 + time: [12.055 µs 12.123 µs 12.198 µs] +Benchmarking i32_slice_search/branchless/29 +Benchmarking i32_slice_search/branchless/29: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/29: Collecting 10 samples in estimated 100.25 ms (9570 iterations) +Benchmarking i32_slice_search/branchless/29: Analyzing +i32_slice_search/branchless/29 + time: [10.450 µs 10.491 µs 10.572 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/contains/30 +Benchmarking i32_slice_search/contains/30: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/30: Collecting 10 samples in estimated 102.04 ms (1870 iterations) +Benchmarking i32_slice_search/contains/30: Analyzing +i32_slice_search/contains/30 + time: [53.939 µs 54.234 µs 54.651 µs] +Benchmarking i32_slice_search/binary_search/30 +Benchmarking i32_slice_search/binary_search/30: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/30: Collecting 10 samples in estimated 100.10 ms (4950 iterations) +Benchmarking i32_slice_search/binary_search/30: Analyzing +i32_slice_search/binary_search/30 + time: [20.042 µs 20.233 µs 20.464 µs] +Benchmarking i32_slice_search/hashset/30 +Benchmarking i32_slice_search/hashset/30: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/30: Collecting 10 samples in estimated 100.46 ms (7425 iterations) +Benchmarking i32_slice_search/hashset/30: Analyzing +i32_slice_search/hashset/30 + time: [13.519 µs 13.784 µs 14.105 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/30 +Benchmarking i32_slice_search/branchless/30: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/30: Collecting 10 samples in estimated 100.31 ms (9185 iterations) +Benchmarking i32_slice_search/branchless/30: Analyzing +i32_slice_search/branchless/30 + time: [18.842 µs 25.465 µs 29.955 µs] +Benchmarking i32_slice_search/contains/31 +Benchmarking i32_slice_search/contains/31: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/31: Collecting 10 samples in estimated 102.66 ms (1760 iterations) +Benchmarking i32_slice_search/contains/31: Analyzing +i32_slice_search/contains/31 + time: [55.905 µs 56.149 µs 56.486 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/31 +Benchmarking i32_slice_search/binary_search/31: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/31: Collecting 10 samples in estimated 100.60 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/31: Analyzing +i32_slice_search/binary_search/31 + time: [19.990 µs 20.076 µs 20.177 µs] +Benchmarking i32_slice_search/hashset/31 +Benchmarking i32_slice_search/hashset/31: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/31: Collecting 10 samples in estimated 100.16 ms (8250 iterations) +Benchmarking i32_slice_search/hashset/31: Analyzing +i32_slice_search/hashset/31 + time: [12.075 µs 12.104 µs 12.151 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/31 +Benchmarking i32_slice_search/branchless/31: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/31: Collecting 10 samples in estimated 100.48 ms (9020 iterations) +Benchmarking i32_slice_search/branchless/31: Analyzing +i32_slice_search/branchless/31 + time: [11.091 µs 11.160 µs 11.233 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/32 +Benchmarking i32_slice_search/contains/32: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/32: Collecting 10 samples in estimated 100.32 ms (4895 iterations) +Benchmarking i32_slice_search/contains/32: Analyzing +i32_slice_search/contains/32 + time: [20.319 µs 20.521 µs 20.774 µs] +Benchmarking i32_slice_search/binary_search/32 +Benchmarking i32_slice_search/binary_search/32: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/32: Collecting 10 samples in estimated 100.93 ms (5005 iterations) +Benchmarking i32_slice_search/binary_search/32: Analyzing +i32_slice_search/binary_search/32 + time: [20.025 µs 20.054 µs 20.115 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/32 +Benchmarking i32_slice_search/hashset/32: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/32: Collecting 10 samples in estimated 100.36 ms (7150 iterations) +Benchmarking i32_slice_search/hashset/32: Analyzing +i32_slice_search/hashset/32 + time: [13.372 µs 13.487 µs 13.709 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/32 +Benchmarking i32_slice_search/branchless/32: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/32: Collecting 10 samples in estimated 100.62 ms (8855 iterations) +Benchmarking i32_slice_search/branchless/32: Analyzing +i32_slice_search/branchless/32 + time: [11.327 µs 11.371 µs 11.430 µs] +Benchmarking i32_slice_search/contains/34 +Benchmarking i32_slice_search/contains/34: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/34: Collecting 10 samples in estimated 100.62 ms (3465 iterations) +Benchmarking i32_slice_search/contains/34: Analyzing +i32_slice_search/contains/34 + time: [28.882 µs 28.992 µs 29.106 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/34 +Benchmarking i32_slice_search/binary_search/34: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/34: Collecting 10 samples in estimated 101.35 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/34: Analyzing +i32_slice_search/binary_search/34 + time: [24.387 µs 24.477 µs 24.582 µs] +Benchmarking i32_slice_search/hashset/34 +Benchmarking i32_slice_search/hashset/34: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/34: Collecting 10 samples in estimated 100.48 ms (7040 iterations) +Benchmarking i32_slice_search/hashset/34: Analyzing +i32_slice_search/hashset/34 + time: [14.303 µs 14.492 µs 14.596 µs] +Benchmarking i32_slice_search/branchless/34 +Benchmarking i32_slice_search/branchless/34: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/34: Collecting 10 samples in estimated 100.66 ms (8360 iterations) +Benchmarking i32_slice_search/branchless/34: Analyzing +i32_slice_search/branchless/34 + time: [12.020 µs 12.073 µs 12.127 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/36 +Benchmarking i32_slice_search/contains/36: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/36: Collecting 10 samples in estimated 100.28 ms (2915 iterations) +Benchmarking i32_slice_search/contains/36: Analyzing +i32_slice_search/contains/36 + time: [34.228 µs 34.547 µs 34.772 µs] +Benchmarking i32_slice_search/binary_search/36 +Benchmarking i32_slice_search/binary_search/36: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/36: Collecting 10 samples in estimated 100.01 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/36: Analyzing +i32_slice_search/binary_search/36 + time: [24.342 µs 24.487 µs 24.592 µs] +Benchmarking i32_slice_search/hashset/36 +Benchmarking i32_slice_search/hashset/36: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/36: Collecting 10 samples in estimated 100.35 ms (7700 iterations) +Benchmarking i32_slice_search/hashset/36: Analyzing +i32_slice_search/hashset/36 + time: [12.954 µs 13.013 µs 13.090 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/36 +Benchmarking i32_slice_search/branchless/36: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/36: Collecting 10 samples in estimated 100.02 ms (7040 iterations) +Benchmarking i32_slice_search/branchless/36: Analyzing +i32_slice_search/branchless/36 + time: [12.738 µs 12.883 µs 13.025 µs] +Benchmarking i32_slice_search/contains/38 +Benchmarking i32_slice_search/contains/38: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/38: Collecting 10 samples in estimated 101.55 ms (2365 iterations) +Benchmarking i32_slice_search/contains/38: Analyzing +i32_slice_search/contains/38 + time: [43.022 µs 43.370 µs 43.564 µs] +Benchmarking i32_slice_search/binary_search/38 +Benchmarking i32_slice_search/binary_search/38: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/38: Collecting 10 samples in estimated 101.06 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/38: Analyzing +i32_slice_search/binary_search/38 + time: [24.576 µs 25.170 µs 25.732 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/38 +Benchmarking i32_slice_search/hashset/38: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/38: Collecting 10 samples in estimated 100.31 ms (7480 iterations) +Benchmarking i32_slice_search/hashset/38: Analyzing +i32_slice_search/hashset/38 + time: [13.068 µs 13.227 µs 13.340 µs] +Benchmarking i32_slice_search/branchless/38 +Benchmarking i32_slice_search/branchless/38: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/38: Collecting 10 samples in estimated 100.74 ms (6930 iterations) +Benchmarking i32_slice_search/branchless/38: Analyzing +i32_slice_search/branchless/38 + time: [13.478 µs 13.610 µs 13.721 µs] +Benchmarking i32_slice_search/contains/40 +Benchmarking i32_slice_search/contains/40: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/40: Collecting 10 samples in estimated 101.11 ms (2200 iterations) +Benchmarking i32_slice_search/contains/40: Analyzing +i32_slice_search/contains/40 + time: [46.013 µs 46.238 µs 46.539 µs] +Benchmarking i32_slice_search/binary_search/40 +Benchmarking i32_slice_search/binary_search/40: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/40: Collecting 10 samples in estimated 100.22 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/40: Analyzing +i32_slice_search/binary_search/40 + time: [24.275 µs 24.365 µs 24.472 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/40 +Benchmarking i32_slice_search/hashset/40: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/40: Collecting 10 samples in estimated 100.30 ms (7205 iterations) +Benchmarking i32_slice_search/hashset/40: Analyzing +i32_slice_search/hashset/40 + time: [13.800 µs 13.876 µs 13.980 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/40 +Benchmarking i32_slice_search/branchless/40: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/40: Collecting 10 samples in estimated 100.16 ms (7150 iterations) +Benchmarking i32_slice_search/branchless/40: Analyzing +i32_slice_search/branchless/40 + time: [13.970 µs 14.030 µs 14.087 µs] +Benchmarking i32_slice_search/contains/42 +Benchmarking i32_slice_search/contains/42: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/42: Collecting 10 samples in estimated 100.85 ms (2200 iterations) +Benchmarking i32_slice_search/contains/42: Analyzing +i32_slice_search/contains/42 + time: [45.572 µs 45.802 µs 46.165 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/binary_search/42 +Benchmarking i32_slice_search/binary_search/42: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/42: Collecting 10 samples in estimated 101.20 ms (4125 iterations) +Benchmarking i32_slice_search/binary_search/42: Analyzing +i32_slice_search/binary_search/42 + time: [24.453 µs 24.542 µs 24.653 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/42 +Benchmarking i32_slice_search/hashset/42: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/42: Collecting 10 samples in estimated 100.60 ms (8415 iterations) +Benchmarking i32_slice_search/hashset/42: Analyzing +i32_slice_search/hashset/42 + time: [11.855 µs 11.915 µs 11.982 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/42 +Benchmarking i32_slice_search/branchless/42: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/42: Collecting 10 samples in estimated 100.16 ms (6765 iterations) +Benchmarking i32_slice_search/branchless/42: Analyzing +i32_slice_search/branchless/42 + time: [14.603 µs 14.638 µs 14.684 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/contains/44 +Benchmarking i32_slice_search/contains/44: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/44: Collecting 10 samples in estimated 101.35 ms (1870 iterations) +Benchmarking i32_slice_search/contains/44: Analyzing +i32_slice_search/contains/44 + time: [53.970 µs 54.151 µs 54.378 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/44 +Benchmarking i32_slice_search/binary_search/44: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/44: Collecting 10 samples in estimated 100.13 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/44: Analyzing +i32_slice_search/binary_search/44 + time: [24.389 µs 24.492 µs 24.571 µs] +Benchmarking i32_slice_search/hashset/44 +Benchmarking i32_slice_search/hashset/44: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/44: Collecting 10 samples in estimated 100.75 ms (6655 iterations) +Benchmarking i32_slice_search/hashset/44: Analyzing +i32_slice_search/hashset/44 + time: [15.080 µs 15.140 µs 15.199 µs] +Benchmarking i32_slice_search/branchless/44 +Benchmarking i32_slice_search/branchless/44: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/44: Collecting 10 samples in estimated 100.47 ms (6545 iterations) +Benchmarking i32_slice_search/branchless/44: Analyzing +i32_slice_search/branchless/44 + time: [15.303 µs 15.340 µs 15.389 µs] +Benchmarking i32_slice_search/contains/46 +Benchmarking i32_slice_search/contains/46: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/46: Collecting 10 samples in estimated 102.51 ms (1760 iterations) +Benchmarking i32_slice_search/contains/46: Analyzing +i32_slice_search/contains/46 + time: [57.936 µs 58.141 µs 58.354 µs] +Benchmarking i32_slice_search/binary_search/46 +Benchmarking i32_slice_search/binary_search/46: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/46: Collecting 10 samples in estimated 100.82 ms (4125 iterations) +Benchmarking i32_slice_search/binary_search/46: Analyzing +i32_slice_search/binary_search/46 + time: [24.418 µs 24.436 µs 24.476 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low severe + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/46 +Benchmarking i32_slice_search/hashset/46: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/46: Collecting 10 samples in estimated 100.12 ms (7975 iterations) +Benchmarking i32_slice_search/hashset/46: Analyzing +i32_slice_search/hashset/46 + time: [12.474 µs 12.527 µs 12.575 µs] +Benchmarking i32_slice_search/branchless/46 +Benchmarking i32_slice_search/branchless/46: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/46: Collecting 10 samples in estimated 100.43 ms (6270 iterations) +Benchmarking i32_slice_search/branchless/46: Analyzing +i32_slice_search/branchless/46 + time: [15.909 µs 16.021 µs 16.156 µs] +Benchmarking i32_slice_search/contains/48 +Benchmarking i32_slice_search/contains/48: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/48: Collecting 10 samples in estimated 101.16 ms (4510 iterations) +Benchmarking i32_slice_search/contains/48: Analyzing +i32_slice_search/contains/48 + time: [22.324 µs 22.411 µs 22.543 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/48 +Benchmarking i32_slice_search/binary_search/48: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/48: Collecting 10 samples in estimated 100.52 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/48: Analyzing +i32_slice_search/binary_search/48 + time: [24.503 µs 24.546 µs 24.592 µs] +Benchmarking i32_slice_search/hashset/48 +Benchmarking i32_slice_search/hashset/48: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/48: Collecting 10 samples in estimated 100.24 ms (7755 iterations) +Benchmarking i32_slice_search/hashset/48: Analyzing +i32_slice_search/hashset/48 + time: [12.882 µs 13.069 µs 13.279 µs] +Benchmarking i32_slice_search/branchless/48 +Benchmarking i32_slice_search/branchless/48: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/48: Collecting 10 samples in estimated 100.80 ms (6050 iterations) +Benchmarking i32_slice_search/branchless/48: Analyzing +i32_slice_search/branchless/48 + time: [16.580 µs 16.656 µs 16.814 µs] +Benchmarking i32_slice_search/contains/50 +Benchmarking i32_slice_search/contains/50: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/50: Collecting 10 samples in estimated 101.26 ms (3245 iterations) +Benchmarking i32_slice_search/contains/50: Analyzing +i32_slice_search/contains/50 + time: [30.978 µs 31.084 µs 31.165 µs] +Benchmarking i32_slice_search/binary_search/50 +Benchmarking i32_slice_search/binary_search/50: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/50: Collecting 10 samples in estimated 101.05 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/50: Analyzing +i32_slice_search/binary_search/50 + time: [24.414 µs 24.502 µs 24.615 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/50 +Benchmarking i32_slice_search/hashset/50: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/50: Collecting 10 samples in estimated 100.40 ms (7480 iterations) +Benchmarking i32_slice_search/hashset/50: Analyzing +i32_slice_search/hashset/50 + time: [13.366 µs 13.413 µs 13.495 µs] +Benchmarking i32_slice_search/branchless/50 +Benchmarking i32_slice_search/branchless/50: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/50: Collecting 10 samples in estimated 100.18 ms (5775 iterations) +Benchmarking i32_slice_search/branchless/50: Analyzing +i32_slice_search/branchless/50 + time: [17.235 µs 17.291 µs 17.380 µs] +Benchmarking i32_slice_search/contains/52 +Benchmarking i32_slice_search/contains/52: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/52: Collecting 10 samples in estimated 100.82 ms (2695 iterations) +Benchmarking i32_slice_search/contains/52: Analyzing +i32_slice_search/contains/52 + time: [37.513 µs 37.594 µs 37.745 µs] +Benchmarking i32_slice_search/binary_search/52 +Benchmarking i32_slice_search/binary_search/52: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/52: Collecting 10 samples in estimated 100.24 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/52: Analyzing +i32_slice_search/binary_search/52 + time: [24.438 µs 24.493 µs 24.571 µs] +Benchmarking i32_slice_search/hashset/52 +Benchmarking i32_slice_search/hashset/52: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/52: Collecting 10 samples in estimated 100.34 ms (7095 iterations) +Benchmarking i32_slice_search/hashset/52: Analyzing +i32_slice_search/hashset/52 + time: [14.079 µs 14.196 µs 14.313 µs] +Benchmarking i32_slice_search/branchless/52 +Benchmarking i32_slice_search/branchless/52: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/52: Collecting 10 samples in estimated 100.22 ms (5555 iterations) +Benchmarking i32_slice_search/branchless/52: Analyzing +i32_slice_search/branchless/52 + time: [17.920 µs 17.989 µs 18.029 µs] +Benchmarking i32_slice_search/contains/54 +Benchmarking i32_slice_search/contains/54: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/54: Collecting 10 samples in estimated 101.40 ms (2420 iterations) +Benchmarking i32_slice_search/contains/54: Analyzing +i32_slice_search/contains/54 + time: [42.084 µs 42.351 µs 42.567 µs] +Benchmarking i32_slice_search/binary_search/54 +Benchmarking i32_slice_search/binary_search/54: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/54: Collecting 10 samples in estimated 100.78 ms (4125 iterations) +Benchmarking i32_slice_search/binary_search/54: Analyzing +i32_slice_search/binary_search/54 + time: [24.991 µs 25.171 µs 25.407 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/54 +Benchmarking i32_slice_search/hashset/54: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/54: Collecting 10 samples in estimated 100.07 ms (6490 iterations) +Benchmarking i32_slice_search/hashset/54: Analyzing +i32_slice_search/hashset/54 + time: [15.349 µs 15.385 µs 15.441 µs] +Benchmarking i32_slice_search/branchless/54 +Benchmarking i32_slice_search/branchless/54: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/54: Collecting 10 samples in estimated 100.60 ms (5390 iterations) +Benchmarking i32_slice_search/branchless/54: Analyzing +i32_slice_search/branchless/54 + time: [18.515 µs 18.586 µs 18.685 µs] +Benchmarking i32_slice_search/contains/56 +Benchmarking i32_slice_search/contains/56: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/56: Collecting 10 samples in estimated 100.31 ms (2200 iterations) +Benchmarking i32_slice_search/contains/56: Analyzing +i32_slice_search/contains/56 + time: [42.363 µs 42.529 µs 42.783 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/56 +Benchmarking i32_slice_search/binary_search/56: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/56: Collecting 10 samples in estimated 100.54 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/56: Analyzing +i32_slice_search/binary_search/56 + time: [24.519 µs 24.640 µs 24.780 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/hashset/56 +Benchmarking i32_slice_search/hashset/56: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/56: Collecting 10 samples in estimated 100.02 ms (6655 iterations) +Benchmarking i32_slice_search/hashset/56: Analyzing +i32_slice_search/hashset/56 + time: [14.922 µs 15.006 µs 15.078 µs] +Benchmarking i32_slice_search/branchless/56 +Benchmarking i32_slice_search/branchless/56: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/56: Collecting 10 samples in estimated 100.36 ms (5170 iterations) +Benchmarking i32_slice_search/branchless/56: Analyzing +i32_slice_search/branchless/56 + time: [19.190 µs 19.311 µs 19.521 µs] +Benchmarking i32_slice_search/contains/58 +Benchmarking i32_slice_search/contains/58: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/58: Collecting 10 samples in estimated 100.09 ms (1980 iterations) +Benchmarking i32_slice_search/contains/58: Analyzing +i32_slice_search/contains/58 + time: [50.065 µs 50.382 µs 50.683 µs] +Benchmarking i32_slice_search/binary_search/58 +Benchmarking i32_slice_search/binary_search/58: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/58: Collecting 10 samples in estimated 100.20 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/58: Analyzing +i32_slice_search/binary_search/58 + time: [24.405 µs 24.477 µs 24.536 µs] +Benchmarking i32_slice_search/hashset/58 +Benchmarking i32_slice_search/hashset/58: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/58: Collecting 10 samples in estimated 100.22 ms (6985 iterations) +Benchmarking i32_slice_search/hashset/58: Analyzing +i32_slice_search/hashset/58 + time: [14.254 µs 14.304 µs 14.343 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/58 +Benchmarking i32_slice_search/branchless/58: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/58: Collecting 10 samples in estimated 100.05 ms (5005 iterations) +Benchmarking i32_slice_search/branchless/58: Analyzing +i32_slice_search/branchless/58 + time: [19.955 µs 20.084 µs 20.335 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i32_slice_search/contains/60 +Benchmarking i32_slice_search/contains/60: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/60: Collecting 10 samples in estimated 102.48 ms (1870 iterations) +Benchmarking i32_slice_search/contains/60: Analyzing +i32_slice_search/contains/60 + time: [54.383 µs 54.594 µs 54.866 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i32_slice_search/binary_search/60 +Benchmarking i32_slice_search/binary_search/60: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/60: Collecting 10 samples in estimated 101.24 ms (4125 iterations) +Benchmarking i32_slice_search/binary_search/60: Analyzing +i32_slice_search/binary_search/60 + time: [24.340 µs 24.416 µs 24.496 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/hashset/60 +Benchmarking i32_slice_search/hashset/60: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/60: Collecting 10 samples in estimated 100.34 ms (7095 iterations) +Benchmarking i32_slice_search/hashset/60: Analyzing +i32_slice_search/hashset/60 + time: [13.880 µs 13.950 µs 14.014 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i32_slice_search/branchless/60 +Benchmarking i32_slice_search/branchless/60: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/60: Collecting 10 samples in estimated 100.16 ms (4840 iterations) +Benchmarking i32_slice_search/branchless/60: Analyzing +i32_slice_search/branchless/60 + time: [20.459 µs 20.581 µs 20.723 µs] +Benchmarking i32_slice_search/contains/62 +Benchmarking i32_slice_search/contains/62: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/62: Collecting 10 samples in estimated 100.70 ms (1705 iterations) +Benchmarking i32_slice_search/contains/62: Analyzing +i32_slice_search/contains/62 + time: [58.740 µs 58.919 µs 59.172 µs] +Found 4 outliers among 10 measurements (40.00%) + 2 (20.00%) low mild + 2 (20.00%) high mild +Benchmarking i32_slice_search/binary_search/62 +Benchmarking i32_slice_search/binary_search/62: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/62: Collecting 10 samples in estimated 100.63 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/62: Analyzing +i32_slice_search/binary_search/62 + time: [24.598 µs 24.831 µs 25.009 µs] +Benchmarking i32_slice_search/hashset/62 +Benchmarking i32_slice_search/hashset/62: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/62: Collecting 10 samples in estimated 100.61 ms (7095 iterations) +Benchmarking i32_slice_search/hashset/62: Analyzing +i32_slice_search/hashset/62 + time: [14.146 µs 14.223 µs 14.298 µs] +Benchmarking i32_slice_search/branchless/62 +Benchmarking i32_slice_search/branchless/62: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/62: Collecting 10 samples in estimated 100.72 ms (4730 iterations) +Benchmarking i32_slice_search/branchless/62: Analyzing +i32_slice_search/branchless/62 + time: [21.186 µs 21.267 µs 21.341 µs] +Benchmarking i32_slice_search/contains/64 +Benchmarking i32_slice_search/contains/64: Warming up for 50.000 ms +Benchmarking i32_slice_search/contains/64: Collecting 10 samples in estimated 101.50 ms (3355 iterations) +Benchmarking i32_slice_search/contains/64: Analyzing +i32_slice_search/contains/64 + time: [30.173 µs 30.327 µs 30.494 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i32_slice_search/binary_search/64 +Benchmarking i32_slice_search/binary_search/64: Warming up for 50.000 ms +Benchmarking i32_slice_search/binary_search/64: Collecting 10 samples in estimated 100.01 ms (4070 iterations) +Benchmarking i32_slice_search/binary_search/64: Analyzing +i32_slice_search/binary_search/64 + time: [24.458 µs 24.611 µs 24.864 µs] +Benchmarking i32_slice_search/hashset/64 +Benchmarking i32_slice_search/hashset/64: Warming up for 50.000 ms +Benchmarking i32_slice_search/hashset/64: Collecting 10 samples in estimated 100.63 ms (7095 iterations) +Benchmarking i32_slice_search/hashset/64: Analyzing +i32_slice_search/hashset/64 + time: [14.164 µs 14.629 µs 15.218 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i32_slice_search/branchless/64 +Benchmarking i32_slice_search/branchless/64: Warming up for 50.000 ms +Benchmarking i32_slice_search/branchless/64: Collecting 10 samples in estimated 100.25 ms (4510 iterations) +Benchmarking i32_slice_search/branchless/64: Analyzing +i32_slice_search/branchless/64 + time: [22.189 µs 22.860 µs 23.944 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe + +Benchmarking i64_slice_search/contains/2 +Benchmarking i64_slice_search/contains/2: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/2: Collecting 10 samples in estimated 100.28 ms (9955 iterations) +Benchmarking i64_slice_search/contains/2: Analyzing +i64_slice_search/contains/2 + time: [10.055 µs 10.227 µs 10.400 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/2 +Benchmarking i64_slice_search/binary_search/2: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/2: Collecting 10 samples in estimated 100.24 ms (16k iterations) +Benchmarking i64_slice_search/binary_search/2: Analyzing +i64_slice_search/binary_search/2 + time: [6.0345 µs 6.1148 µs 6.1873 µs] +Benchmarking i64_slice_search/hashset/2 +Benchmarking i64_slice_search/hashset/2: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/2: Collecting 10 samples in estimated 100.33 ms (8415 iterations) +Benchmarking i64_slice_search/hashset/2: Analyzing +i64_slice_search/hashset/2 + time: [11.825 µs 11.878 µs 11.967 µs] +Benchmarking i64_slice_search/branchless/2 +Benchmarking i64_slice_search/branchless/2: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/2: Collecting 10 samples in estimated 100.04 ms (75k iterations) +Benchmarking i64_slice_search/branchless/2: Analyzing +i64_slice_search/branchless/2 + time: [1.3179 µs 1.3251 µs 1.3348 µs] +Benchmarking i64_slice_search/contains/3 +Benchmarking i64_slice_search/contains/3: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/3: Collecting 10 samples in estimated 100.15 ms (7425 iterations) +Benchmarking i64_slice_search/contains/3: Analyzing +i64_slice_search/contains/3 + time: [13.580 µs 13.712 µs 13.933 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/3 +Benchmarking i64_slice_search/binary_search/3: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/3: Collecting 10 samples in estimated 100.52 ms (11k iterations) +Benchmarking i64_slice_search/binary_search/3: Analyzing +i64_slice_search/binary_search/3 + time: [9.2429 µs 9.2779 µs 9.3104 µs] +Benchmarking i64_slice_search/hashset/3 +Benchmarking i64_slice_search/hashset/3: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/3: Collecting 10 samples in estimated 100.12 ms (8140 iterations) +Benchmarking i64_slice_search/hashset/3: Analyzing +i64_slice_search/hashset/3 + time: [11.952 µs 11.988 µs 12.059 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/3 +Benchmarking i64_slice_search/branchless/3: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/3: Collecting 10 samples in estimated 100.06 ms (51k iterations) +Benchmarking i64_slice_search/branchless/3: Analyzing +i64_slice_search/branchless/3 + time: [1.9679 µs 1.9741 µs 1.9793 µs] +Benchmarking i64_slice_search/contains/4 +Benchmarking i64_slice_search/contains/4: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/4: Collecting 10 samples in estimated 100.63 ms (6050 iterations) +Benchmarking i64_slice_search/contains/4: Analyzing +i64_slice_search/contains/4 + time: [16.569 µs 16.614 µs 16.689 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i64_slice_search/binary_search/4 +Benchmarking i64_slice_search/binary_search/4: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/4: Collecting 10 samples in estimated 100.28 ms (11k iterations) +Benchmarking i64_slice_search/binary_search/4: Analyzing +i64_slice_search/binary_search/4 + time: [9.2786 µs 9.3269 µs 9.3768 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/4 +Benchmarking i64_slice_search/hashset/4: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/4: Collecting 10 samples in estimated 100.09 ms (7865 iterations) +Benchmarking i64_slice_search/hashset/4: Analyzing +i64_slice_search/hashset/4 + time: [11.941 µs 12.253 µs 12.779 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking i64_slice_search/branchless/4 +Benchmarking i64_slice_search/branchless/4: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/4: Collecting 10 samples in estimated 100.01 ms (38k iterations) +Benchmarking i64_slice_search/branchless/4: Analyzing +i64_slice_search/branchless/4 + time: [2.6339 µs 2.6409 µs 2.6526 µs] +Benchmarking i64_slice_search/contains/5 +Benchmarking i64_slice_search/contains/5: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/5: Collecting 10 samples in estimated 100.93 ms (5225 iterations) +Benchmarking i64_slice_search/contains/5: Analyzing +i64_slice_search/contains/5 + time: [19.232 µs 19.447 µs 19.621 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/5 +Benchmarking i64_slice_search/binary_search/5: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/5: Collecting 10 samples in estimated 100.51 ms (7645 iterations) +Benchmarking i64_slice_search/binary_search/5: Analyzing +i64_slice_search/binary_search/5 + time: [13.121 µs 13.156 µs 13.196 µs] +Benchmarking i64_slice_search/hashset/5 +Benchmarking i64_slice_search/hashset/5: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/5: Collecting 10 samples in estimated 100.55 ms (8415 iterations) +Benchmarking i64_slice_search/hashset/5: Analyzing +i64_slice_search/hashset/5 + time: [11.986 µs 12.051 µs 12.126 µs] +Benchmarking i64_slice_search/branchless/5 +Benchmarking i64_slice_search/branchless/5: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/5: Collecting 10 samples in estimated 100.14 ms (30k iterations) +Benchmarking i64_slice_search/branchless/5: Analyzing +i64_slice_search/branchless/5 + time: [3.3007 µs 3.3300 µs 3.3559 µs] +Benchmarking i64_slice_search/contains/6 +Benchmarking i64_slice_search/contains/6: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/6: Collecting 10 samples in estimated 100.05 ms (4400 iterations) +Benchmarking i64_slice_search/contains/6: Analyzing +i64_slice_search/contains/6 + time: [22.718 µs 22.801 µs 22.895 µs] +Benchmarking i64_slice_search/binary_search/6 +Benchmarking i64_slice_search/binary_search/6: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/6: Collecting 10 samples in estimated 100.06 ms (7535 iterations) +Benchmarking i64_slice_search/binary_search/6: Analyzing +i64_slice_search/binary_search/6 + time: [13.106 µs 13.152 µs 13.250 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/6 +Benchmarking i64_slice_search/hashset/6: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/6: Collecting 10 samples in estimated 100.33 ms (8415 iterations) +Benchmarking i64_slice_search/hashset/6: Analyzing +i64_slice_search/hashset/6 + time: [11.843 µs 11.879 µs 11.927 µs] +Benchmarking i64_slice_search/branchless/6 +Benchmarking i64_slice_search/branchless/6: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/6: Collecting 10 samples in estimated 100.02 ms (25k iterations) +Benchmarking i64_slice_search/branchless/6: Analyzing +i64_slice_search/branchless/6 + time: [3.9374 µs 3.9969 µs 4.0297 µs] +Benchmarking i64_slice_search/contains/7 +Benchmarking i64_slice_search/contains/7: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/7: Collecting 10 samples in estimated 100.79 ms (4565 iterations) +Benchmarking i64_slice_search/contains/7: Analyzing +i64_slice_search/contains/7 + time: [21.879 µs 21.960 µs 22.074 µs] +Benchmarking i64_slice_search/binary_search/7 +Benchmarking i64_slice_search/binary_search/7: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/7: Collecting 10 samples in estimated 100.13 ms (7535 iterations) +Benchmarking i64_slice_search/binary_search/7: Analyzing +i64_slice_search/binary_search/7 + time: [22.839 µs 34.565 µs 42.809 µs] +Benchmarking i64_slice_search/hashset/7 +Benchmarking i64_slice_search/hashset/7: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/7: Collecting 10 samples in estimated 100.13 ms (8360 iterations) +Benchmarking i64_slice_search/hashset/7: Analyzing +i64_slice_search/hashset/7 + time: [11.892 µs 11.968 µs 12.027 µs] +Benchmarking i64_slice_search/branchless/7 +Benchmarking i64_slice_search/branchless/7: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/7: Collecting 10 samples in estimated 100.09 ms (20k iterations) +Benchmarking i64_slice_search/branchless/7: Analyzing +i64_slice_search/branchless/7 + time: [4.9893 µs 5.0078 µs 5.0364 µs] +Benchmarking i64_slice_search/contains/8 +Benchmarking i64_slice_search/contains/8: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/8: Collecting 10 samples in estimated 100.03 ms (9515 iterations) +Benchmarking i64_slice_search/contains/8: Analyzing +i64_slice_search/contains/8 + time: [10.489 µs 10.524 µs 10.547 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/binary_search/8 +Benchmarking i64_slice_search/binary_search/8: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/8: Collecting 10 samples in estimated 100.19 ms (7645 iterations) +Benchmarking i64_slice_search/binary_search/8: Analyzing +i64_slice_search/binary_search/8 + time: [13.093 µs 13.138 µs 13.211 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/8 +Benchmarking i64_slice_search/hashset/8: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/8: Collecting 10 samples in estimated 100.56 ms (8085 iterations) +Benchmarking i64_slice_search/hashset/8: Analyzing +i64_slice_search/hashset/8 + time: [12.343 µs 12.380 µs 12.417 µs] +Benchmarking i64_slice_search/branchless/8 +Benchmarking i64_slice_search/branchless/8: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/8: Collecting 10 samples in estimated 100.27 ms (18k iterations) +Benchmarking i64_slice_search/branchless/8: Analyzing +i64_slice_search/branchless/8 + time: [5.6321 µs 5.6671 µs 5.7036 µs] +Benchmarking i64_slice_search/contains/9 +Benchmarking i64_slice_search/contains/9: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/9: Collecting 10 samples in estimated 100.05 ms (8910 iterations) +Benchmarking i64_slice_search/contains/9: Analyzing +i64_slice_search/contains/9 + time: [10.572 µs 10.643 µs 10.734 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/binary_search/9 +Benchmarking i64_slice_search/binary_search/9: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/9: Collecting 10 samples in estimated 100.01 ms (6160 iterations) +Benchmarking i64_slice_search/binary_search/9: Analyzing +i64_slice_search/binary_search/9 + time: [16.341 µs 16.759 µs 17.100 µs] +Benchmarking i64_slice_search/hashset/9 +Benchmarking i64_slice_search/hashset/9: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/9: Collecting 10 samples in estimated 100.53 ms (7150 iterations) +Benchmarking i64_slice_search/hashset/9: Analyzing +i64_slice_search/hashset/9 + time: [12.439 µs 12.570 µs 12.684 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/9 +Benchmarking i64_slice_search/branchless/9: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/9: Collecting 10 samples in estimated 100.35 ms (13k iterations) +Benchmarking i64_slice_search/branchless/9: Analyzing +i64_slice_search/branchless/9 + time: [6.6079 µs 6.8428 µs 7.0698 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/10 +Benchmarking i64_slice_search/contains/10: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/10: Collecting 10 samples in estimated 100.63 ms (8360 iterations) +Benchmarking i64_slice_search/contains/10: Analyzing +i64_slice_search/contains/10 + time: [12.059 µs 12.173 µs 12.293 µs] +Benchmarking i64_slice_search/binary_search/10 +Benchmarking i64_slice_search/binary_search/10: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/10: Collecting 10 samples in estimated 100.33 ms (5060 iterations) +Benchmarking i64_slice_search/binary_search/10: Analyzing +i64_slice_search/binary_search/10 + time: [17.682 µs 19.856 µs 22.850 µs] +Benchmarking i64_slice_search/hashset/10 +Benchmarking i64_slice_search/hashset/10: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/10: Collecting 10 samples in estimated 100.23 ms (7370 iterations) +Benchmarking i64_slice_search/hashset/10: Analyzing +i64_slice_search/hashset/10 + time: [12.510 µs 12.605 µs 12.745 µs] +Benchmarking i64_slice_search/branchless/10 +Benchmarking i64_slice_search/branchless/10: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/10: Collecting 10 samples in estimated 100.14 ms (8360 iterations) +Benchmarking i64_slice_search/branchless/10: Analyzing +i64_slice_search/branchless/10 + time: [7.1523 µs 7.1783 µs 7.2018 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/contains/11 +Benchmarking i64_slice_search/contains/11: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/11: Collecting 10 samples in estimated 100.45 ms (6270 iterations) +Benchmarking i64_slice_search/contains/11: Analyzing +i64_slice_search/contains/11 + time: [15.055 µs 15.161 µs 15.259 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/11 +Benchmarking i64_slice_search/binary_search/11: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/11: Collecting 10 samples in estimated 100.39 ms (6105 iterations) +Benchmarking i64_slice_search/binary_search/11: Analyzing +i64_slice_search/binary_search/11 + time: [16.450 µs 16.577 µs 16.736 µs] +Benchmarking i64_slice_search/hashset/11 +Benchmarking i64_slice_search/hashset/11: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/11: Collecting 10 samples in estimated 100.08 ms (7590 iterations) +Benchmarking i64_slice_search/hashset/11: Analyzing +i64_slice_search/hashset/11 + time: [12.968 µs 13.109 µs 13.170 µs] +Benchmarking i64_slice_search/branchless/11 +Benchmarking i64_slice_search/branchless/11: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/11: Collecting 10 samples in estimated 100.32 ms (13k iterations) +Benchmarking i64_slice_search/branchless/11: Analyzing +i64_slice_search/branchless/11 + time: [7.8560 µs 7.9368 µs 8.0488 µs] +Benchmarking i64_slice_search/contains/12 +Benchmarking i64_slice_search/contains/12: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/12: Collecting 10 samples in estimated 100.96 ms (5390 iterations) +Benchmarking i64_slice_search/contains/12: Analyzing +i64_slice_search/contains/12 + time: [18.514 µs 18.885 µs 19.525 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/12 +Benchmarking i64_slice_search/binary_search/12: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/12: Collecting 10 samples in estimated 100.69 ms (5060 iterations) +Benchmarking i64_slice_search/binary_search/12: Analyzing +i64_slice_search/binary_search/12 + time: [16.524 µs 16.640 µs 16.763 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/12 +Benchmarking i64_slice_search/hashset/12: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/12: Collecting 10 samples in estimated 100.38 ms (7755 iterations) +Benchmarking i64_slice_search/hashset/12: Analyzing +i64_slice_search/hashset/12 + time: [12.814 µs 12.907 µs 13.004 µs] +Benchmarking i64_slice_search/branchless/12 +Benchmarking i64_slice_search/branchless/12: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/12: Collecting 10 samples in estimated 100.05 ms (12k iterations) +Benchmarking i64_slice_search/branchless/12: Analyzing +i64_slice_search/branchless/12 + time: [8.3580 µs 8.4332 µs 8.5261 µs] +Benchmarking i64_slice_search/contains/13 +Benchmarking i64_slice_search/contains/13: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/13: Collecting 10 samples in estimated 100.21 ms (4840 iterations) +Benchmarking i64_slice_search/contains/13: Analyzing +i64_slice_search/contains/13 + time: [20.620 µs 20.809 µs 21.026 µs] +Benchmarking i64_slice_search/binary_search/13 +Benchmarking i64_slice_search/binary_search/13: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/13: Collecting 10 samples in estimated 100.51 ms (5390 iterations) +Benchmarking i64_slice_search/binary_search/13: Analyzing +i64_slice_search/binary_search/13 + time: [16.403 µs 16.497 µs 16.545 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/hashset/13 +Benchmarking i64_slice_search/hashset/13: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/13: Collecting 10 samples in estimated 100.41 ms (7095 iterations) +Benchmarking i64_slice_search/hashset/13: Analyzing +i64_slice_search/hashset/13 + time: [14.054 µs 14.143 µs 14.252 µs] +Benchmarking i64_slice_search/branchless/13 +Benchmarking i64_slice_search/branchless/13: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/13: Collecting 10 samples in estimated 100.14 ms (11k iterations) +Benchmarking i64_slice_search/branchless/13: Analyzing +i64_slice_search/branchless/13 + time: [8.9544 µs 9.0236 µs 9.1126 µs] +Benchmarking i64_slice_search/contains/14 +Benchmarking i64_slice_search/contains/14: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/14: Collecting 10 samples in estimated 101.11 ms (3905 iterations) +Benchmarking i64_slice_search/contains/14: Analyzing +i64_slice_search/contains/14 + time: [23.263 µs 24.343 µs 25.910 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/14 +Benchmarking i64_slice_search/binary_search/14: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/14: Collecting 10 samples in estimated 100.64 ms (6160 iterations) +Benchmarking i64_slice_search/binary_search/14: Analyzing +i64_slice_search/binary_search/14 + time: [16.232 µs 16.317 µs 16.434 µs] +Benchmarking i64_slice_search/hashset/14 +Benchmarking i64_slice_search/hashset/14: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/14: Collecting 10 samples in estimated 100.67 ms (6875 iterations) +Benchmarking i64_slice_search/hashset/14: Analyzing +i64_slice_search/hashset/14 + time: [14.414 µs 14.496 µs 14.642 µs] +Benchmarking i64_slice_search/branchless/14 +Benchmarking i64_slice_search/branchless/14: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/14: Collecting 10 samples in estimated 100.03 ms (10k iterations) +Benchmarking i64_slice_search/branchless/14: Analyzing +i64_slice_search/branchless/14 + time: [9.5535 µs 9.5935 µs 9.6237 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/contains/15 +Benchmarking i64_slice_search/contains/15: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/15: Collecting 10 samples in estimated 100.02 ms (3850 iterations) +Benchmarking i64_slice_search/contains/15: Analyzing +i64_slice_search/contains/15 + time: [25.400 µs 25.548 µs 25.681 µs] +Benchmarking i64_slice_search/binary_search/15 +Benchmarking i64_slice_search/binary_search/15: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/15: Collecting 10 samples in estimated 100.30 ms (5830 iterations) +Benchmarking i64_slice_search/binary_search/15: Analyzing +i64_slice_search/binary_search/15 + time: [16.412 µs 16.577 µs 16.783 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/15 +Benchmarking i64_slice_search/hashset/15: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/15: Collecting 10 samples in estimated 100.23 ms (8360 iterations) +Benchmarking i64_slice_search/hashset/15: Analyzing +i64_slice_search/hashset/15 + time: [11.945 µs 11.991 µs 12.089 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/15 +Benchmarking i64_slice_search/branchless/15: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/15: Collecting 10 samples in estimated 100.37 ms (9735 iterations) +Benchmarking i64_slice_search/branchless/15: Analyzing +i64_slice_search/branchless/15 + time: [10.236 µs 10.326 µs 10.431 µs] +Benchmarking i64_slice_search/contains/16 +Benchmarking i64_slice_search/contains/16: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/16: Collecting 10 samples in estimated 100.01 ms (5170 iterations) +Benchmarking i64_slice_search/contains/16: Analyzing +i64_slice_search/contains/16 + time: [18.946 µs 19.170 µs 19.446 µs] +Benchmarking i64_slice_search/binary_search/16 +Benchmarking i64_slice_search/binary_search/16: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/16: Collecting 10 samples in estimated 100.61 ms (6160 iterations) +Benchmarking i64_slice_search/binary_search/16: Analyzing +i64_slice_search/binary_search/16 + time: [16.333 µs 16.418 µs 16.471 µs] +Benchmarking i64_slice_search/hashset/16 +Benchmarking i64_slice_search/hashset/16: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/16: Collecting 10 samples in estimated 100.61 ms (8305 iterations) +Benchmarking i64_slice_search/hashset/16: Analyzing +i64_slice_search/hashset/16 + time: [11.832 µs 11.887 µs 11.958 µs] +Benchmarking i64_slice_search/branchless/16 +Benchmarking i64_slice_search/branchless/16: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/16: Collecting 10 samples in estimated 100.08 ms (9020 iterations) +Benchmarking i64_slice_search/branchless/16: Analyzing +i64_slice_search/branchless/16 + time: [10.846 µs 10.882 µs 10.935 µs] +Benchmarking i64_slice_search/contains/17 +Benchmarking i64_slice_search/contains/17: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/17: Collecting 10 samples in estimated 100.65 ms (5280 iterations) +Benchmarking i64_slice_search/contains/17: Analyzing +i64_slice_search/contains/17 + time: [18.692 µs 18.756 µs 18.860 µs] +Benchmarking i64_slice_search/binary_search/17 +Benchmarking i64_slice_search/binary_search/17: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/17: Collecting 10 samples in estimated 100.52 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/17: Analyzing +i64_slice_search/binary_search/17 + time: [19.984 µs 20.065 µs 20.144 µs] +Benchmarking i64_slice_search/hashset/17 +Benchmarking i64_slice_search/hashset/17: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/17: Collecting 10 samples in estimated 100.18 ms (8415 iterations) +Benchmarking i64_slice_search/hashset/17: Analyzing +i64_slice_search/hashset/17 + time: [11.867 µs 11.902 µs 11.945 µs] +Benchmarking i64_slice_search/branchless/17 +Benchmarking i64_slice_search/branchless/17: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/17: Collecting 10 samples in estimated 100.00 ms (8635 iterations) +Benchmarking i64_slice_search/branchless/17: Analyzing +i64_slice_search/branchless/17 + time: [11.542 µs 11.570 µs 11.605 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/18 +Benchmarking i64_slice_search/contains/18: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/18: Collecting 10 samples in estimated 100.44 ms (5115 iterations) +Benchmarking i64_slice_search/contains/18: Analyzing +i64_slice_search/contains/18 + time: [19.577 µs 20.032 µs 21.330 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high severe +Benchmarking i64_slice_search/binary_search/18 +Benchmarking i64_slice_search/binary_search/18: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/18: Collecting 10 samples in estimated 100.76 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/18: Analyzing +i64_slice_search/binary_search/18 + time: [20.066 µs 20.190 µs 20.387 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/18 +Benchmarking i64_slice_search/hashset/18: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/18: Collecting 10 samples in estimated 100.51 ms (8415 iterations) +Benchmarking i64_slice_search/hashset/18: Analyzing +i64_slice_search/hashset/18 + time: [11.896 µs 11.934 µs 11.994 µs] +Benchmarking i64_slice_search/branchless/18 +Benchmarking i64_slice_search/branchless/18: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/18: Collecting 10 samples in estimated 100.33 ms (8195 iterations) +Benchmarking i64_slice_search/branchless/18: Analyzing +i64_slice_search/branchless/18 + time: [12.186 µs 12.237 µs 12.295 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/19 +Benchmarking i64_slice_search/contains/19: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/19: Collecting 10 samples in estimated 100.97 ms (5005 iterations) +Benchmarking i64_slice_search/contains/19: Analyzing +i64_slice_search/contains/19 + time: [20.038 µs 20.082 µs 20.162 µs] +Benchmarking i64_slice_search/binary_search/19 +Benchmarking i64_slice_search/binary_search/19: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/19: Collecting 10 samples in estimated 100.78 ms (4950 iterations) +Benchmarking i64_slice_search/binary_search/19: Analyzing +i64_slice_search/binary_search/19 + time: [20.076 µs 20.231 µs 20.491 µs] +Benchmarking i64_slice_search/hashset/19 +Benchmarking i64_slice_search/hashset/19: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/19: Collecting 10 samples in estimated 100.17 ms (6435 iterations) +Benchmarking i64_slice_search/hashset/19: Analyzing +i64_slice_search/hashset/19 + time: [15.652 µs 16.102 µs 17.169 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/19 +Benchmarking i64_slice_search/branchless/19: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/19: Collecting 10 samples in estimated 100.37 ms (7700 iterations) +Benchmarking i64_slice_search/branchless/19: Analyzing +i64_slice_search/branchless/19 + time: [12.867 µs 12.907 µs 12.964 µs] +Benchmarking i64_slice_search/contains/20 +Benchmarking i64_slice_search/contains/20: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/20: Collecting 10 samples in estimated 101.42 ms (3465 iterations) +Benchmarking i64_slice_search/contains/20: Analyzing +i64_slice_search/contains/20 + time: [21.406 µs 21.539 µs 21.807 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/binary_search/20 +Benchmarking i64_slice_search/binary_search/20: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/20: Collecting 10 samples in estimated 100.60 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/20: Analyzing +i64_slice_search/binary_search/20 + time: [19.991 µs 20.018 µs 20.068 µs] +Benchmarking i64_slice_search/hashset/20 +Benchmarking i64_slice_search/hashset/20: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/20: Collecting 10 samples in estimated 100.65 ms (8305 iterations) +Benchmarking i64_slice_search/hashset/20: Analyzing +i64_slice_search/hashset/20 + time: [12.103 µs 12.142 µs 12.210 µs] +Benchmarking i64_slice_search/branchless/20 +Benchmarking i64_slice_search/branchless/20: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/20: Collecting 10 samples in estimated 100.68 ms (7370 iterations) +Benchmarking i64_slice_search/branchless/20: Analyzing +i64_slice_search/branchless/20 + time: [13.581 µs 13.621 µs 13.674 µs] +Benchmarking i64_slice_search/contains/21 +Benchmarking i64_slice_search/contains/21: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/21: Collecting 10 samples in estimated 100.48 ms (4455 iterations) +Benchmarking i64_slice_search/contains/21: Analyzing +i64_slice_search/contains/21 + time: [22.524 µs 22.560 µs 22.616 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i64_slice_search/binary_search/21 +Benchmarking i64_slice_search/binary_search/21: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/21: Collecting 10 samples in estimated 100.95 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/21: Analyzing +i64_slice_search/binary_search/21 + time: [20.023 µs 20.070 µs 20.139 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/21 +Benchmarking i64_slice_search/hashset/21: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/21: Collecting 10 samples in estimated 100.30 ms (8415 iterations) +Benchmarking i64_slice_search/hashset/21: Analyzing +i64_slice_search/hashset/21 + time: [11.853 µs 11.895 µs 11.953 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/21 +Benchmarking i64_slice_search/branchless/21: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/21: Collecting 10 samples in estimated 100.71 ms (7040 iterations) +Benchmarking i64_slice_search/branchless/21: Analyzing +i64_slice_search/branchless/21 + time: [14.285 µs 14.536 µs 14.801 µs] +Benchmarking i64_slice_search/contains/22 +Benchmarking i64_slice_search/contains/22: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/22: Collecting 10 samples in estimated 101.00 ms (3300 iterations) +Benchmarking i64_slice_search/contains/22: Analyzing +i64_slice_search/contains/22 + time: [30.262 µs 30.505 µs 30.753 µs] +Benchmarking i64_slice_search/binary_search/22 +Benchmarking i64_slice_search/binary_search/22: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/22: Collecting 10 samples in estimated 100.97 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/22: Analyzing +i64_slice_search/binary_search/22 + time: [20.056 µs 20.085 µs 20.135 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/22 +Benchmarking i64_slice_search/hashset/22: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/22: Collecting 10 samples in estimated 100.59 ms (8195 iterations) +Benchmarking i64_slice_search/hashset/22: Analyzing +i64_slice_search/hashset/22 + time: [12.169 µs 12.216 µs 12.260 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/branchless/22 +Benchmarking i64_slice_search/branchless/22: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/22: Collecting 10 samples in estimated 100.53 ms (6710 iterations) +Benchmarking i64_slice_search/branchless/22: Analyzing +i64_slice_search/branchless/22 + time: [14.869 µs 14.917 µs 14.976 µs] +Benchmarking i64_slice_search/contains/23 +Benchmarking i64_slice_search/contains/23: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/23: Collecting 10 samples in estimated 101.30 ms (3245 iterations) +Benchmarking i64_slice_search/contains/23: Analyzing +i64_slice_search/contains/23 + time: [30.810 µs 31.100 µs 31.715 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/23 +Benchmarking i64_slice_search/binary_search/23: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/23: Collecting 10 samples in estimated 100.48 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/23: Analyzing +i64_slice_search/binary_search/23 + time: [20.077 µs 20.126 µs 20.178 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/23 +Benchmarking i64_slice_search/hashset/23: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/23: Collecting 10 samples in estimated 100.17 ms (7645 iterations) +Benchmarking i64_slice_search/hashset/23: Analyzing +i64_slice_search/hashset/23 + time: [13.091 µs 13.132 µs 13.190 µs] +Benchmarking i64_slice_search/branchless/23 +Benchmarking i64_slice_search/branchless/23: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/23: Collecting 10 samples in estimated 100.28 ms (6435 iterations) +Benchmarking i64_slice_search/branchless/23: Analyzing +i64_slice_search/branchless/23 + time: [15.533 µs 15.579 µs 15.641 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/contains/24 +Benchmarking i64_slice_search/contains/24: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/24: Collecting 10 samples in estimated 100.61 ms (4895 iterations) +Benchmarking i64_slice_search/contains/24: Analyzing +i64_slice_search/contains/24 + time: [20.248 µs 20.363 µs 20.504 µs] +Benchmarking i64_slice_search/binary_search/24 +Benchmarking i64_slice_search/binary_search/24: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/24: Collecting 10 samples in estimated 100.71 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/24: Analyzing +i64_slice_search/binary_search/24 + time: [20.052 µs 20.126 µs 20.245 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/24 +Benchmarking i64_slice_search/hashset/24: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/24: Collecting 10 samples in estimated 100.31 ms (6875 iterations) +Benchmarking i64_slice_search/hashset/24: Analyzing +i64_slice_search/hashset/24 + time: [14.416 µs 14.467 µs 14.540 µs] +Benchmarking i64_slice_search/branchless/24 +Benchmarking i64_slice_search/branchless/24: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/24: Collecting 10 samples in estimated 100.74 ms (6160 iterations) +Benchmarking i64_slice_search/branchless/24: Analyzing +i64_slice_search/branchless/24 + time: [16.203 µs 16.265 µs 16.336 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/25 +Benchmarking i64_slice_search/contains/25: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/25: Collecting 10 samples in estimated 100.37 ms (4840 iterations) +Benchmarking i64_slice_search/contains/25: Analyzing +i64_slice_search/contains/25 + time: [20.624 µs 20.678 µs 20.755 µs] +Benchmarking i64_slice_search/binary_search/25 +Benchmarking i64_slice_search/binary_search/25: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/25: Collecting 10 samples in estimated 100.57 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/25: Analyzing +i64_slice_search/binary_search/25 + time: [20.062 µs 20.137 µs 20.234 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/25 +Benchmarking i64_slice_search/hashset/25: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/25: Collecting 10 samples in estimated 100.55 ms (6765 iterations) +Benchmarking i64_slice_search/hashset/25: Analyzing +i64_slice_search/hashset/25 + time: [14.761 µs 14.833 µs 14.904 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/25 +Benchmarking i64_slice_search/branchless/25: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/25: Collecting 10 samples in estimated 101.17 ms (4345 iterations) +Benchmarking i64_slice_search/branchless/25: Analyzing +i64_slice_search/branchless/25 + time: [24.983 µs 34.003 µs 44.295 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/contains/26 +Benchmarking i64_slice_search/contains/26: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/26: Collecting 10 samples in estimated 100.16 ms (4180 iterations) +Benchmarking i64_slice_search/contains/26: Analyzing +i64_slice_search/contains/26 + time: [23.942 µs 24.050 µs 24.164 µs] +Benchmarking i64_slice_search/binary_search/26 +Benchmarking i64_slice_search/binary_search/26: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/26: Collecting 10 samples in estimated 101.02 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/26: Analyzing +i64_slice_search/binary_search/26 + time: [20.059 µs 20.144 µs 20.253 µs] +Benchmarking i64_slice_search/hashset/26 +Benchmarking i64_slice_search/hashset/26: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/26: Collecting 10 samples in estimated 100.23 ms (6270 iterations) +Benchmarking i64_slice_search/hashset/26: Analyzing +i64_slice_search/hashset/26 + time: [15.834 µs 15.952 µs 16.111 µs] +Benchmarking i64_slice_search/branchless/26 +Benchmarking i64_slice_search/branchless/26: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/26: Collecting 10 samples in estimated 100.64 ms (5665 iterations) +Benchmarking i64_slice_search/branchless/26: Analyzing +i64_slice_search/branchless/26 + time: [17.647 µs 17.726 µs 17.788 µs] +Benchmarking i64_slice_search/contains/27 +Benchmarking i64_slice_search/contains/27: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/27: Collecting 10 samples in estimated 100.88 ms (3850 iterations) +Benchmarking i64_slice_search/contains/27: Analyzing +i64_slice_search/contains/27 + time: [25.774 µs 26.014 µs 26.273 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/27 +Benchmarking i64_slice_search/binary_search/27: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/27: Collecting 10 samples in estimated 100.53 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/27: Analyzing +i64_slice_search/binary_search/27 + time: [20.060 µs 20.163 µs 20.275 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/27 +Benchmarking i64_slice_search/hashset/27: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/27: Collecting 10 samples in estimated 100.84 ms (5830 iterations) +Benchmarking i64_slice_search/hashset/27: Analyzing +i64_slice_search/hashset/27 + time: [17.175 µs 17.230 µs 17.325 µs] +Benchmarking i64_slice_search/branchless/27 +Benchmarking i64_slice_search/branchless/27: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/27: Collecting 10 samples in estimated 100.05 ms (5445 iterations) +Benchmarking i64_slice_search/branchless/27: Analyzing +i64_slice_search/branchless/27 + time: [18.271 µs 18.354 µs 18.455 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/contains/28 +Benchmarking i64_slice_search/contains/28: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/28: Collecting 10 samples in estimated 100.71 ms (4290 iterations) +Benchmarking i64_slice_search/contains/28: Analyzing +i64_slice_search/contains/28 + time: [23.359 µs 23.453 µs 23.547 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/28 +Benchmarking i64_slice_search/binary_search/28: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/28: Collecting 10 samples in estimated 100.17 ms (4950 iterations) +Benchmarking i64_slice_search/binary_search/28: Analyzing +i64_slice_search/binary_search/28 + time: [20.087 µs 20.126 µs 20.195 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/28 +Benchmarking i64_slice_search/hashset/28: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/28: Collecting 10 samples in estimated 100.13 ms (7095 iterations) +Benchmarking i64_slice_search/hashset/28: Analyzing +i64_slice_search/hashset/28 + time: [14.066 µs 14.109 µs 14.152 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/28 +Benchmarking i64_slice_search/branchless/28: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/28: Collecting 10 samples in estimated 100.75 ms (5280 iterations) +Benchmarking i64_slice_search/branchless/28: Analyzing +i64_slice_search/branchless/28 + time: [19.007 µs 19.253 µs 19.564 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/29 +Benchmarking i64_slice_search/contains/29: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/29: Collecting 10 samples in estimated 100.04 ms (3300 iterations) +Benchmarking i64_slice_search/contains/29: Analyzing +i64_slice_search/contains/29 + time: [30.123 µs 30.227 µs 30.312 µs] +Benchmarking i64_slice_search/binary_search/29 +Benchmarking i64_slice_search/binary_search/29: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/29: Collecting 10 samples in estimated 100.03 ms (4895 iterations) +Benchmarking i64_slice_search/binary_search/29: Analyzing +i64_slice_search/binary_search/29 + time: [20.038 µs 20.083 µs 20.159 µs] +Benchmarking i64_slice_search/hashset/29 +Benchmarking i64_slice_search/hashset/29: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/29: Collecting 10 samples in estimated 100.18 ms (8250 iterations) +Benchmarking i64_slice_search/hashset/29: Analyzing +i64_slice_search/hashset/29 + time: [12.053 µs 12.081 µs 12.116 µs] +Benchmarking i64_slice_search/branchless/29 +Benchmarking i64_slice_search/branchless/29: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/29: Collecting 10 samples in estimated 100.63 ms (4895 iterations) +Benchmarking i64_slice_search/branchless/29: Analyzing +i64_slice_search/branchless/29 + time: [19.783 µs 20.022 µs 20.466 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/contains/30 +Benchmarking i64_slice_search/contains/30: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/30: Collecting 10 samples in estimated 100.53 ms (2970 iterations) +Benchmarking i64_slice_search/contains/30: Analyzing +i64_slice_search/contains/30 + time: [33.593 µs 33.744 µs 34.009 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high severe +Benchmarking i64_slice_search/binary_search/30 +Benchmarking i64_slice_search/binary_search/30: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/30: Collecting 10 samples in estimated 100.83 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/30: Analyzing +i64_slice_search/binary_search/30 + time: [20.055 µs 20.097 µs 20.169 µs] +Benchmarking i64_slice_search/hashset/30 +Benchmarking i64_slice_search/hashset/30: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/30: Collecting 10 samples in estimated 100.50 ms (7480 iterations) +Benchmarking i64_slice_search/hashset/30: Analyzing +i64_slice_search/hashset/30 + time: [13.217 µs 13.303 µs 13.438 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/branchless/30 +Benchmarking i64_slice_search/branchless/30: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/30: Collecting 10 samples in estimated 100.61 ms (4950 iterations) +Benchmarking i64_slice_search/branchless/30: Analyzing +i64_slice_search/branchless/30 + time: [20.352 µs 20.387 µs 20.410 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/contains/31 +Benchmarking i64_slice_search/contains/31: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/31: Collecting 10 samples in estimated 100.59 ms (2860 iterations) +Benchmarking i64_slice_search/contains/31: Analyzing +i64_slice_search/contains/31 + time: [34.577 µs 34.937 µs 35.450 µs] +Benchmarking i64_slice_search/binary_search/31 +Benchmarking i64_slice_search/binary_search/31: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/31: Collecting 10 samples in estimated 101.03 ms (5005 iterations) +Benchmarking i64_slice_search/binary_search/31: Analyzing +i64_slice_search/binary_search/31 + time: [20.145 µs 20.211 µs 20.293 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/hashset/31 +Benchmarking i64_slice_search/hashset/31: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/31: Collecting 10 samples in estimated 100.06 ms (8140 iterations) +Benchmarking i64_slice_search/hashset/31: Analyzing +i64_slice_search/hashset/31 + time: [21.479 µs 28.076 µs 32.819 µs] +Benchmarking i64_slice_search/branchless/31 +Benchmarking i64_slice_search/branchless/31: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/31: Collecting 10 samples in estimated 100.46 ms (4785 iterations) +Benchmarking i64_slice_search/branchless/31: Analyzing +i64_slice_search/branchless/31 + time: [20.944 µs 21.010 µs 21.101 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/32 +Benchmarking i64_slice_search/contains/32: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/32: Collecting 10 samples in estimated 100.52 ms (4070 iterations) +Benchmarking i64_slice_search/contains/32: Analyzing +i64_slice_search/contains/32 + time: [24.567 µs 24.626 µs 24.713 µs] +Benchmarking i64_slice_search/binary_search/32 +Benchmarking i64_slice_search/binary_search/32: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/32: Collecting 10 samples in estimated 100.52 ms (4950 iterations) +Benchmarking i64_slice_search/binary_search/32: Analyzing +i64_slice_search/binary_search/32 + time: [20.107 µs 20.159 µs 20.215 µs] +Benchmarking i64_slice_search/hashset/32 +Benchmarking i64_slice_search/hashset/32: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/32: Collecting 10 samples in estimated 100.66 ms (7535 iterations) +Benchmarking i64_slice_search/hashset/32: Analyzing +i64_slice_search/hashset/32 + time: [13.208 µs 13.308 µs 13.437 µs] +Benchmarking i64_slice_search/branchless/32 +Benchmarking i64_slice_search/branchless/32: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/32: Collecting 10 samples in estimated 101.15 ms (4730 iterations) +Benchmarking i64_slice_search/branchless/32: Analyzing +i64_slice_search/branchless/32 + time: [21.308 µs 21.371 µs 21.463 µs] +Benchmarking i64_slice_search/contains/34 +Benchmarking i64_slice_search/contains/34: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/34: Collecting 10 samples in estimated 100.74 ms (3355 iterations) +Benchmarking i64_slice_search/contains/34: Analyzing +i64_slice_search/contains/34 + time: [29.824 µs 29.943 µs 30.062 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/34 +Benchmarking i64_slice_search/binary_search/34: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/34: Collecting 10 samples in estimated 101.00 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/34: Analyzing +i64_slice_search/binary_search/34 + time: [24.356 µs 24.475 µs 24.578 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/34 +Benchmarking i64_slice_search/hashset/34: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/34: Collecting 10 samples in estimated 100.31 ms (7040 iterations) +Benchmarking i64_slice_search/hashset/34: Analyzing +i64_slice_search/hashset/34 + time: [13.966 µs 14.120 µs 14.311 µs] +Benchmarking i64_slice_search/branchless/34 +Benchmarking i64_slice_search/branchless/34: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/34: Collecting 10 samples in estimated 101.19 ms (4455 iterations) +Benchmarking i64_slice_search/branchless/34: Analyzing +i64_slice_search/branchless/34 + time: [22.650 µs 22.751 µs 22.905 µs] +Benchmarking i64_slice_search/contains/36 +Benchmarking i64_slice_search/contains/36: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/36: Collecting 10 samples in estimated 100.55 ms (3245 iterations) +Benchmarking i64_slice_search/contains/36: Analyzing +i64_slice_search/contains/36 + time: [30.992 µs 31.075 µs 31.138 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low severe + 1 (10.00%) low mild +Benchmarking i64_slice_search/binary_search/36 +Benchmarking i64_slice_search/binary_search/36: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/36: Collecting 10 samples in estimated 100.92 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/36: Analyzing +i64_slice_search/binary_search/36 + time: [24.398 µs 24.483 µs 24.581 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/36 +Benchmarking i64_slice_search/hashset/36: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/36: Collecting 10 samples in estimated 100.75 ms (5885 iterations) +Benchmarking i64_slice_search/hashset/36: Analyzing +i64_slice_search/hashset/36 + time: [19.133 µs 30.588 µs 46.703 µs] +Benchmarking i64_slice_search/branchless/36 +Benchmarking i64_slice_search/branchless/36: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/36: Collecting 10 samples in estimated 100.67 ms (4180 iterations) +Benchmarking i64_slice_search/branchless/36: Analyzing +i64_slice_search/branchless/36 + time: [24.012 µs 24.155 µs 24.377 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/contains/38 +Benchmarking i64_slice_search/contains/38: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/38: Collecting 10 samples in estimated 100.31 ms (2530 iterations) +Benchmarking i64_slice_search/contains/38: Analyzing +i64_slice_search/contains/38 + time: [39.422 µs 39.610 µs 39.841 µs] +Benchmarking i64_slice_search/binary_search/38 +Benchmarking i64_slice_search/binary_search/38: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/38: Collecting 10 samples in estimated 100.40 ms (4070 iterations) +Benchmarking i64_slice_search/binary_search/38: Analyzing +i64_slice_search/binary_search/38 + time: [24.449 µs 24.556 µs 24.660 µs] +Benchmarking i64_slice_search/hashset/38 +Benchmarking i64_slice_search/hashset/38: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/38: Collecting 10 samples in estimated 100.56 ms (7755 iterations) +Benchmarking i64_slice_search/hashset/38: Analyzing +i64_slice_search/hashset/38 + time: [12.968 µs 13.075 µs 13.282 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high severe +Benchmarking i64_slice_search/branchless/38 +Benchmarking i64_slice_search/branchless/38: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/38: Collecting 10 samples in estimated 100.83 ms (3960 iterations) +Benchmarking i64_slice_search/branchless/38: Analyzing +i64_slice_search/branchless/38 + time: [25.299 µs 25.354 µs 25.397 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/contains/40 +Benchmarking i64_slice_search/contains/40: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/40: Collecting 10 samples in estimated 101.29 ms (3135 iterations) +Benchmarking i64_slice_search/contains/40: Analyzing +i64_slice_search/contains/40 + time: [32.184 µs 32.325 µs 32.443 µs] +Benchmarking i64_slice_search/binary_search/40 +Benchmarking i64_slice_search/binary_search/40: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/40: Collecting 10 samples in estimated 101.28 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/40: Analyzing +i64_slice_search/binary_search/40 + time: [24.464 µs 24.559 µs 24.658 µs] +Benchmarking i64_slice_search/hashset/40 +Benchmarking i64_slice_search/hashset/40: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/40: Collecting 10 samples in estimated 100.47 ms (7040 iterations) +Benchmarking i64_slice_search/hashset/40: Analyzing +i64_slice_search/hashset/40 + time: [13.929 µs 14.062 µs 14.285 µs] +Benchmarking i64_slice_search/branchless/40 +Benchmarking i64_slice_search/branchless/40: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/40: Collecting 10 samples in estimated 100.17 ms (3740 iterations) +Benchmarking i64_slice_search/branchless/40: Analyzing +i64_slice_search/branchless/40 + time: [26.570 µs 26.652 µs 26.747 µs] +Benchmarking i64_slice_search/contains/42 +Benchmarking i64_slice_search/contains/42: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/42: Collecting 10 samples in estimated 101.30 ms (3410 iterations) +Benchmarking i64_slice_search/contains/42: Analyzing +i64_slice_search/contains/42 + time: [29.382 µs 29.506 µs 29.621 µs] +Benchmarking i64_slice_search/binary_search/42 +Benchmarking i64_slice_search/binary_search/42: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/42: Collecting 10 samples in estimated 101.37 ms (3905 iterations) +Benchmarking i64_slice_search/binary_search/42: Analyzing +i64_slice_search/binary_search/42 + time: [24.728 µs 25.908 µs 27.359 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/42 +Benchmarking i64_slice_search/hashset/42: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/42: Collecting 10 samples in estimated 100.60 ms (8360 iterations) +Benchmarking i64_slice_search/hashset/42: Analyzing +i64_slice_search/hashset/42 + time: [11.877 µs 11.908 µs 11.948 µs] +Benchmarking i64_slice_search/branchless/42 +Benchmarking i64_slice_search/branchless/42: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/42: Collecting 10 samples in estimated 101.44 ms (3630 iterations) +Benchmarking i64_slice_search/branchless/42: Analyzing +i64_slice_search/branchless/42 + time: [27.883 µs 27.950 µs 28.004 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/contains/44 +Benchmarking i64_slice_search/contains/44: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/44: Collecting 10 samples in estimated 101.57 ms (2475 iterations) +Benchmarking i64_slice_search/contains/44: Analyzing +i64_slice_search/contains/44 + time: [40.898 µs 41.041 µs 41.209 µs] +Benchmarking i64_slice_search/binary_search/44 +Benchmarking i64_slice_search/binary_search/44: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/44: Collecting 10 samples in estimated 100.37 ms (4070 iterations) +Benchmarking i64_slice_search/binary_search/44: Analyzing +i64_slice_search/binary_search/44 + time: [24.422 µs 24.523 µs 24.624 µs] +Benchmarking i64_slice_search/hashset/44 +Benchmarking i64_slice_search/hashset/44: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/44: Collecting 10 samples in estimated 100.19 ms (6655 iterations) +Benchmarking i64_slice_search/hashset/44: Analyzing +i64_slice_search/hashset/44 + time: [14.995 µs 15.142 µs 15.274 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/branchless/44 +Benchmarking i64_slice_search/branchless/44: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/44: Collecting 10 samples in estimated 100.29 ms (3410 iterations) +Benchmarking i64_slice_search/branchless/44: Analyzing +i64_slice_search/branchless/44 + time: [29.392 µs 29.736 µs 30.210 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/contains/46 +Benchmarking i64_slice_search/contains/46: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/46: Collecting 10 samples in estimated 102.39 ms (2145 iterations) +Benchmarking i64_slice_search/contains/46: Analyzing +i64_slice_search/contains/46 + time: [46.990 µs 47.252 µs 47.671 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/46 +Benchmarking i64_slice_search/binary_search/46: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/46: Collecting 10 samples in estimated 101.26 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/46: Analyzing +i64_slice_search/binary_search/46 + time: [24.418 µs 24.526 µs 24.615 µs] +Benchmarking i64_slice_search/hashset/46 +Benchmarking i64_slice_search/hashset/46: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/46: Collecting 10 samples in estimated 100.68 ms (8030 iterations) +Benchmarking i64_slice_search/hashset/46: Analyzing +i64_slice_search/hashset/46 + time: [12.483 µs 12.540 µs 12.591 µs] +Benchmarking i64_slice_search/branchless/46 +Benchmarking i64_slice_search/branchless/46: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/46: Collecting 10 samples in estimated 101.26 ms (3300 iterations) +Benchmarking i64_slice_search/branchless/46: Analyzing +i64_slice_search/branchless/46 + time: [30.496 µs 30.575 µs 30.674 µs] +Benchmarking i64_slice_search/contains/48 +Benchmarking i64_slice_search/contains/48: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/48: Collecting 10 samples in estimated 101.81 ms (2420 iterations) +Benchmarking i64_slice_search/contains/48: Analyzing +i64_slice_search/contains/48 + time: [41.951 µs 42.085 µs 42.231 µs] +Benchmarking i64_slice_search/binary_search/48 +Benchmarking i64_slice_search/binary_search/48: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/48: Collecting 10 samples in estimated 101.04 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/48: Analyzing +i64_slice_search/binary_search/48 + time: [24.384 µs 24.505 µs 24.611 µs] +Benchmarking i64_slice_search/hashset/48 +Benchmarking i64_slice_search/hashset/48: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/48: Collecting 10 samples in estimated 100.42 ms (7755 iterations) +Benchmarking i64_slice_search/hashset/48: Analyzing +i64_slice_search/hashset/48 + time: [12.873 µs 12.922 µs 12.957 µs] +Benchmarking i64_slice_search/branchless/48 +Benchmarking i64_slice_search/branchless/48: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/48: Collecting 10 samples in estimated 100.22 ms (3135 iterations) +Benchmarking i64_slice_search/branchless/48: Analyzing +i64_slice_search/branchless/48 + time: [31.835 µs 31.940 µs 32.020 µs] +Benchmarking i64_slice_search/contains/50 +Benchmarking i64_slice_search/contains/50: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/50: Collecting 10 samples in estimated 102.13 ms (2365 iterations) +Benchmarking i64_slice_search/contains/50: Analyzing +i64_slice_search/contains/50 + time: [42.634 µs 42.883 µs 43.358 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/50 +Benchmarking i64_slice_search/binary_search/50: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/50: Collecting 10 samples in estimated 101.09 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/50: Analyzing +i64_slice_search/binary_search/50 + time: [24.335 µs 24.464 µs 24.569 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/50 +Benchmarking i64_slice_search/hashset/50: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/50: Collecting 10 samples in estimated 100.53 ms (7480 iterations) +Benchmarking i64_slice_search/hashset/50: Analyzing +i64_slice_search/hashset/50 + time: [13.377 µs 13.427 µs 13.481 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/branchless/50 +Benchmarking i64_slice_search/branchless/50: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/50: Collecting 10 samples in estimated 102.02 ms (2695 iterations) +Benchmarking i64_slice_search/branchless/50: Analyzing +i64_slice_search/branchless/50 + time: [33.177 µs 33.269 µs 33.369 µs] +Benchmarking i64_slice_search/contains/52 +Benchmarking i64_slice_search/contains/52: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/52: Collecting 10 samples in estimated 102.32 ms (2255 iterations) +Benchmarking i64_slice_search/contains/52: Analyzing +i64_slice_search/contains/52 + time: [45.301 µs 45.386 µs 45.512 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/binary_search/52 +Benchmarking i64_slice_search/binary_search/52: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/52: Collecting 10 samples in estimated 100.04 ms (4070 iterations) +Benchmarking i64_slice_search/binary_search/52: Analyzing +i64_slice_search/binary_search/52 + time: [24.420 µs 24.533 µs 24.617 µs] +Benchmarking i64_slice_search/hashset/52 +Benchmarking i64_slice_search/hashset/52: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/52: Collecting 10 samples in estimated 100.56 ms (7095 iterations) +Benchmarking i64_slice_search/hashset/52: Analyzing +i64_slice_search/hashset/52 + time: [14.066 µs 14.091 µs 14.137 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/branchless/52 +Benchmarking i64_slice_search/branchless/52: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/52: Collecting 10 samples in estimated 100.62 ms (2915 iterations) +Benchmarking i64_slice_search/branchless/52: Analyzing +i64_slice_search/branchless/52 + time: [34.501 µs 34.573 µs 34.645 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/contains/54 +Benchmarking i64_slice_search/contains/54: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/54: Collecting 10 samples in estimated 102.40 ms (1980 iterations) +Benchmarking i64_slice_search/contains/54: Analyzing +i64_slice_search/contains/54 + time: [51.079 µs 51.256 µs 51.435 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i64_slice_search/binary_search/54 +Benchmarking i64_slice_search/binary_search/54: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/54: Collecting 10 samples in estimated 100.80 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/54: Analyzing +i64_slice_search/binary_search/54 + time: [24.433 µs 24.503 µs 24.583 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/54 +Benchmarking i64_slice_search/hashset/54: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/54: Collecting 10 samples in estimated 100.03 ms (6490 iterations) +Benchmarking i64_slice_search/hashset/54: Analyzing +i64_slice_search/hashset/54 + time: [15.339 µs 15.418 µs 15.506 µs] +Benchmarking i64_slice_search/branchless/54 +Benchmarking i64_slice_search/branchless/54: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/54: Collecting 10 samples in estimated 100.29 ms (2805 iterations) +Benchmarking i64_slice_search/branchless/54: Analyzing +i64_slice_search/branchless/54 + time: [36.085 µs 72.146 µs 89.780 µs] +Benchmarking i64_slice_search/contains/56 +Benchmarking i64_slice_search/contains/56: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/56: Collecting 10 samples in estimated 100.21 ms (2365 iterations) +Benchmarking i64_slice_search/contains/56: Analyzing +i64_slice_search/contains/56 + time: [42.252 µs 42.404 µs 42.589 µs] +Benchmarking i64_slice_search/binary_search/56 +Benchmarking i64_slice_search/binary_search/56: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/56: Collecting 10 samples in estimated 101.24 ms (3960 iterations) +Benchmarking i64_slice_search/binary_search/56: Analyzing +i64_slice_search/binary_search/56 + time: [24.553 µs 24.781 µs 25.300 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/56 +Benchmarking i64_slice_search/hashset/56: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/56: Collecting 10 samples in estimated 100.14 ms (6600 iterations) +Benchmarking i64_slice_search/hashset/56: Analyzing +i64_slice_search/hashset/56 + time: [14.972 µs 15.026 µs 15.065 µs] +Benchmarking i64_slice_search/branchless/56 +Benchmarking i64_slice_search/branchless/56: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/56: Collecting 10 samples in estimated 100.67 ms (2695 iterations) +Benchmarking i64_slice_search/branchless/56: Analyzing +i64_slice_search/branchless/56 + time: [37.094 µs 37.214 µs 37.339 µs] +Benchmarking i64_slice_search/contains/58 +Benchmarking i64_slice_search/contains/58: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/58: Collecting 10 samples in estimated 101.98 ms (2145 iterations) +Benchmarking i64_slice_search/contains/58: Analyzing +i64_slice_search/contains/58 + time: [47.430 µs 47.617 µs 47.890 µs] +Benchmarking i64_slice_search/binary_search/58 +Benchmarking i64_slice_search/binary_search/58: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/58: Collecting 10 samples in estimated 101.20 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/58: Analyzing +i64_slice_search/binary_search/58 + time: [24.428 µs 24.501 µs 24.609 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i64_slice_search/hashset/58 +Benchmarking i64_slice_search/hashset/58: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/58: Collecting 10 samples in estimated 100.51 ms (7040 iterations) +Benchmarking i64_slice_search/hashset/58: Analyzing +i64_slice_search/hashset/58 + time: [14.224 µs 14.255 µs 14.280 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i64_slice_search/branchless/58 +Benchmarking i64_slice_search/branchless/58: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/58: Collecting 10 samples in estimated 101.62 ms (2640 iterations) +Benchmarking i64_slice_search/branchless/58: Analyzing +i64_slice_search/branchless/58 + time: [38.343 µs 38.565 µs 38.951 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/60 +Benchmarking i64_slice_search/contains/60: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/60: Collecting 10 samples in estimated 100.80 ms (1980 iterations) +Benchmarking i64_slice_search/contains/60: Analyzing +i64_slice_search/contains/60 + time: [50.163 µs 50.425 µs 50.722 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/60 +Benchmarking i64_slice_search/binary_search/60: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/60: Collecting 10 samples in estimated 101.09 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/60: Analyzing +i64_slice_search/binary_search/60 + time: [24.421 µs 24.519 µs 24.632 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/hashset/60 +Benchmarking i64_slice_search/hashset/60: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/60: Collecting 10 samples in estimated 100.35 ms (7535 iterations) +Benchmarking i64_slice_search/hashset/60: Analyzing +i64_slice_search/hashset/60 + time: [13.177 µs 13.233 µs 13.294 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i64_slice_search/branchless/60 +Benchmarking i64_slice_search/branchless/60: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/60: Collecting 10 samples in estimated 100.45 ms (2530 iterations) +Benchmarking i64_slice_search/branchless/60: Analyzing +i64_slice_search/branchless/60 + time: [39.699 µs 39.833 µs 39.997 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i64_slice_search/contains/62 +Benchmarking i64_slice_search/contains/62: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/62: Collecting 10 samples in estimated 101.78 ms (1815 iterations) +Benchmarking i64_slice_search/contains/62: Analyzing +i64_slice_search/contains/62 + time: [56.079 µs 56.235 µs 56.417 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking i64_slice_search/binary_search/62 +Benchmarking i64_slice_search/binary_search/62: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/62: Collecting 10 samples in estimated 101.23 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/62: Analyzing +i64_slice_search/binary_search/62 + time: [24.352 µs 24.423 µs 24.508 µs] +Benchmarking i64_slice_search/hashset/62 +Benchmarking i64_slice_search/hashset/62: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/62: Collecting 10 samples in estimated 100.61 ms (7095 iterations) +Benchmarking i64_slice_search/hashset/62: Analyzing +i64_slice_search/hashset/62 + time: [14.051 µs 14.107 µs 14.198 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 2 (20.00%) high severe +Benchmarking i64_slice_search/branchless/62 +Benchmarking i64_slice_search/branchless/62: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/62: Collecting 10 samples in estimated 100.39 ms (2420 iterations) +Benchmarking i64_slice_search/branchless/62: Analyzing +i64_slice_search/branchless/62 + time: [41.007 µs 41.120 µs 41.265 µs] +Benchmarking i64_slice_search/contains/64 +Benchmarking i64_slice_search/contains/64: Warming up for 50.000 ms +Benchmarking i64_slice_search/contains/64: Collecting 10 samples in estimated 101.85 ms (1980 iterations) +Benchmarking i64_slice_search/contains/64: Analyzing +i64_slice_search/contains/64 + time: [51.069 µs 51.269 µs 51.466 µs] +Benchmarking i64_slice_search/binary_search/64 +Benchmarking i64_slice_search/binary_search/64: Warming up for 50.000 ms +Benchmarking i64_slice_search/binary_search/64: Collecting 10 samples in estimated 101.14 ms (4125 iterations) +Benchmarking i64_slice_search/binary_search/64: Analyzing +i64_slice_search/binary_search/64 + time: [24.411 µs 24.463 µs 24.510 µs] +Benchmarking i64_slice_search/hashset/64 +Benchmarking i64_slice_search/hashset/64: Warming up for 50.000 ms +Benchmarking i64_slice_search/hashset/64: Collecting 10 samples in estimated 100.13 ms (7095 iterations) +Benchmarking i64_slice_search/hashset/64: Analyzing +i64_slice_search/hashset/64 + time: [14.088 µs 14.125 µs 14.161 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i64_slice_search/branchless/64 +Benchmarking i64_slice_search/branchless/64: Warming up for 50.000 ms +Benchmarking i64_slice_search/branchless/64: Collecting 10 samples in estimated 100.70 ms (2365 iterations) +Benchmarking i64_slice_search/branchless/64: Analyzing +i64_slice_search/branchless/64 + time: [42.184 µs 42.377 µs 42.634 µs] + +Benchmarking i128_slice_search/contains/2 +Benchmarking i128_slice_search/contains/2: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/2: Collecting 10 samples in estimated 100.11 ms (6435 iterations) +Benchmarking i128_slice_search/contains/2: Analyzing +i128_slice_search/contains/2 + time: [15.352 µs 15.467 µs 15.557 µs] +Benchmarking i128_slice_search/binary_search/2 +Benchmarking i128_slice_search/binary_search/2: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/2: Collecting 10 samples in estimated 100.37 ms (11k iterations) +Benchmarking i128_slice_search/binary_search/2: Analyzing +i128_slice_search/binary_search/2 + time: [8.9460 µs 9.0547 µs 9.1270 µs] +Benchmarking i128_slice_search/hashset/2 +Benchmarking i128_slice_search/hashset/2: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/2: Collecting 10 samples in estimated 100.42 ms (6325 iterations) +Benchmarking i128_slice_search/hashset/2: Analyzing +i128_slice_search/hashset/2 + time: [15.897 µs 16.132 µs 16.283 µs] +Benchmarking i128_slice_search/branchless/2 +Benchmarking i128_slice_search/branchless/2: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/2: Collecting 10 samples in estimated 100.30 ms (16k iterations) +Benchmarking i128_slice_search/branchless/2: Analyzing +i128_slice_search/branchless/2 + time: [6.2439 µs 6.2720 µs 6.3227 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/contains/3 +Benchmarking i128_slice_search/contains/3: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/3: Collecting 10 samples in estimated 100.60 ms (5885 iterations) +Benchmarking i128_slice_search/contains/3: Analyzing +i128_slice_search/contains/3 + time: [16.930 µs 16.983 µs 17.081 µs] +Benchmarking i128_slice_search/binary_search/3 +Benchmarking i128_slice_search/binary_search/3: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/3: Collecting 10 samples in estimated 100.64 ms (7480 iterations) +Benchmarking i128_slice_search/binary_search/3: Analyzing +i128_slice_search/binary_search/3 + time: [13.358 µs 13.399 µs 13.480 µs] +Benchmarking i128_slice_search/hashset/3 +Benchmarking i128_slice_search/hashset/3: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/3: Collecting 10 samples in estimated 100.33 ms (6270 iterations) +Benchmarking i128_slice_search/hashset/3: Analyzing +i128_slice_search/hashset/3 + time: [15.929 µs 16.042 µs 16.152 µs] +Benchmarking i128_slice_search/branchless/3 +Benchmarking i128_slice_search/branchless/3: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/3: Collecting 10 samples in estimated 100.41 ms (11k iterations) +Benchmarking i128_slice_search/branchless/3: Analyzing +i128_slice_search/branchless/3 + time: [9.0716 µs 9.1364 µs 9.2414 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i128_slice_search/contains/4 +Benchmarking i128_slice_search/contains/4: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/4: Collecting 10 samples in estimated 100.19 ms (5170 iterations) +Benchmarking i128_slice_search/contains/4: Analyzing +i128_slice_search/contains/4 + time: [19.311 µs 19.401 µs 19.484 µs] +Benchmarking i128_slice_search/binary_search/4 +Benchmarking i128_slice_search/binary_search/4: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/4: Collecting 10 samples in estimated 100.74 ms (7425 iterations) +Benchmarking i128_slice_search/binary_search/4: Analyzing +i128_slice_search/binary_search/4 + time: [13.332 µs 13.374 µs 13.447 µs] +Benchmarking i128_slice_search/hashset/4 +Benchmarking i128_slice_search/hashset/4: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/4: Collecting 10 samples in estimated 100.67 ms (6325 iterations) +Benchmarking i128_slice_search/hashset/4: Analyzing +i128_slice_search/hashset/4 + time: [15.868 µs 15.958 µs 16.081 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/branchless/4 +Benchmarking i128_slice_search/branchless/4: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/4: Collecting 10 samples in estimated 100.07 ms (8140 iterations) +Benchmarking i128_slice_search/branchless/4: Analyzing +i128_slice_search/branchless/4 + time: [12.071 µs 12.166 µs 12.260 µs] +Benchmarking i128_slice_search/contains/5 +Benchmarking i128_slice_search/contains/5: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/5: Collecting 10 samples in estimated 101.07 ms (4675 iterations) +Benchmarking i128_slice_search/contains/5: Analyzing +i128_slice_search/contains/5 + time: [21.512 µs 21.613 µs 21.754 µs] +Benchmarking i128_slice_search/binary_search/5 +Benchmarking i128_slice_search/binary_search/5: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/5: Collecting 10 samples in estimated 100.67 ms (5335 iterations) +Benchmarking i128_slice_search/binary_search/5: Analyzing +i128_slice_search/binary_search/5 + time: [18.811 µs 18.863 µs 18.924 µs] +Found 4 outliers among 10 measurements (40.00%) + 1 (10.00%) low severe + 1 (10.00%) low mild + 2 (20.00%) high severe +Benchmarking i128_slice_search/hashset/5 +Benchmarking i128_slice_search/hashset/5: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/5: Collecting 10 samples in estimated 100.08 ms (6270 iterations) +Benchmarking i128_slice_search/hashset/5: Analyzing +i128_slice_search/hashset/5 + time: [15.833 µs 15.928 µs 16.018 µs] +Benchmarking i128_slice_search/branchless/5 +Benchmarking i128_slice_search/branchless/5: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/5: Collecting 10 samples in estimated 100.66 ms (6655 iterations) +Benchmarking i128_slice_search/branchless/5: Analyzing +i128_slice_search/branchless/5 + time: [15.047 µs 15.091 µs 15.147 µs] +Benchmarking i128_slice_search/contains/6 +Benchmarking i128_slice_search/contains/6: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/6: Collecting 10 samples in estimated 100.04 ms (4180 iterations) +Benchmarking i128_slice_search/contains/6: Analyzing +i128_slice_search/contains/6 + time: [23.799 µs 23.926 µs 24.091 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/binary_search/6 +Benchmarking i128_slice_search/binary_search/6: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/6: Collecting 10 samples in estimated 100.92 ms (5335 iterations) +Benchmarking i128_slice_search/binary_search/6: Analyzing +i128_slice_search/binary_search/6 + time: [18.727 µs 18.793 µs 18.884 µs] +Benchmarking i128_slice_search/hashset/6 +Benchmarking i128_slice_search/hashset/6: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/6: Collecting 10 samples in estimated 100.65 ms (6270 iterations) +Benchmarking i128_slice_search/hashset/6: Analyzing +i128_slice_search/hashset/6 + time: [15.833 µs 15.869 µs 15.923 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/branchless/6 +Benchmarking i128_slice_search/branchless/6: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/6: Collecting 10 samples in estimated 100.92 ms (5555 iterations) +Benchmarking i128_slice_search/branchless/6: Analyzing +i128_slice_search/branchless/6 + time: [18.108 µs 18.162 µs 18.203 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high severe +Benchmarking i128_slice_search/contains/7 +Benchmarking i128_slice_search/contains/7: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/7: Collecting 10 samples in estimated 100.24 ms (4125 iterations) +Benchmarking i128_slice_search/contains/7: Analyzing +i128_slice_search/contains/7 + time: [24.148 µs 24.227 µs 24.325 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i128_slice_search/binary_search/7 +Benchmarking i128_slice_search/binary_search/7: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/7: Collecting 10 samples in estimated 100.70 ms (5335 iterations) +Benchmarking i128_slice_search/binary_search/7: Analyzing +i128_slice_search/binary_search/7 + time: [18.825 µs 18.869 µs 18.919 µs] +Found 3 outliers among 10 measurements (30.00%) + 2 (20.00%) low mild + 1 (10.00%) high mild +Benchmarking i128_slice_search/hashset/7 +Benchmarking i128_slice_search/hashset/7: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/7: Collecting 10 samples in estimated 100.59 ms (6270 iterations) +Benchmarking i128_slice_search/hashset/7: Analyzing +i128_slice_search/hashset/7 + time: [15.912 µs 15.984 µs 16.039 µs] +Benchmarking i128_slice_search/branchless/7 +Benchmarking i128_slice_search/branchless/7: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/7: Collecting 10 samples in estimated 100.11 ms (4730 iterations) +Benchmarking i128_slice_search/branchless/7: Analyzing +i128_slice_search/branchless/7 + time: [21.148 µs 21.245 µs 21.350 µs] +Benchmarking i128_slice_search/contains/8 +Benchmarking i128_slice_search/contains/8: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/8: Collecting 10 samples in estimated 100.83 ms (3520 iterations) +Benchmarking i128_slice_search/contains/8: Analyzing +i128_slice_search/contains/8 + time: [28.444 µs 28.544 µs 28.672 µs] +Found 3 outliers among 10 measurements (30.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking i128_slice_search/binary_search/8 +Benchmarking i128_slice_search/binary_search/8: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/8: Collecting 10 samples in estimated 100.66 ms (5335 iterations) +Benchmarking i128_slice_search/binary_search/8: Analyzing +i128_slice_search/binary_search/8 + time: [18.744 µs 18.807 µs 18.887 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/hashset/8 +Benchmarking i128_slice_search/hashset/8: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/8: Collecting 10 samples in estimated 100.01 ms (6270 iterations) +Benchmarking i128_slice_search/hashset/8: Analyzing +i128_slice_search/hashset/8 + time: [15.871 µs 15.932 µs 15.975 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i128_slice_search/branchless/8 +Benchmarking i128_slice_search/branchless/8: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/8: Collecting 10 samples in estimated 101.19 ms (4125 iterations) +Benchmarking i128_slice_search/branchless/8: Analyzing +i128_slice_search/branchless/8 + time: [24.417 µs 24.548 µs 24.649 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i128_slice_search/contains/9 +Benchmarking i128_slice_search/contains/9: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/9: Collecting 10 samples in estimated 100.44 ms (3190 iterations) +Benchmarking i128_slice_search/contains/9: Analyzing +i128_slice_search/contains/9 + time: [31.390 µs 31.498 µs 31.625 µs] +Benchmarking i128_slice_search/binary_search/9 +Benchmarking i128_slice_search/binary_search/9: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/9: Collecting 10 samples in estimated 100.75 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/9: Analyzing +i128_slice_search/binary_search/9 + time: [25.262 µs 25.396 µs 25.538 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/hashset/9 +Benchmarking i128_slice_search/hashset/9: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/9: Collecting 10 samples in estimated 100.78 ms (6215 iterations) +Benchmarking i128_slice_search/hashset/9: Analyzing +i128_slice_search/hashset/9 + time: [16.099 µs 16.161 µs 16.238 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i128_slice_search/branchless/9 +Benchmarking i128_slice_search/branchless/9: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/9: Collecting 10 samples in estimated 100.09 ms (3685 iterations) +Benchmarking i128_slice_search/branchless/9: Analyzing +i128_slice_search/branchless/9 + time: [26.943 µs 27.014 µs 27.113 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/contains/10 +Benchmarking i128_slice_search/contains/10: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/10: Collecting 10 samples in estimated 100.45 ms (2915 iterations) +Benchmarking i128_slice_search/contains/10: Analyzing +i128_slice_search/contains/10 + time: [34.487 µs 34.616 µs 34.735 µs] +Benchmarking i128_slice_search/binary_search/10 +Benchmarking i128_slice_search/binary_search/10: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/10: Collecting 10 samples in estimated 100.30 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/10: Analyzing +i128_slice_search/binary_search/10 + time: [25.263 µs 25.353 µs 25.427 µs] +Benchmarking i128_slice_search/hashset/10 +Benchmarking i128_slice_search/hashset/10: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/10: Collecting 10 samples in estimated 100.17 ms (6215 iterations) +Benchmarking i128_slice_search/hashset/10: Analyzing +i128_slice_search/hashset/10 + time: [16.126 µs 16.215 µs 16.321 µs] +Benchmarking i128_slice_search/branchless/10 +Benchmarking i128_slice_search/branchless/10: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/10: Collecting 10 samples in estimated 100.17 ms (3245 iterations) +Benchmarking i128_slice_search/branchless/10: Analyzing +i128_slice_search/branchless/10 + time: [30.533 µs 30.721 µs 31.009 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/contains/11 +Benchmarking i128_slice_search/contains/11: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/11: Collecting 10 samples in estimated 101.25 ms (2695 iterations) +Benchmarking i128_slice_search/contains/11: Analyzing +i128_slice_search/contains/11 + time: [37.441 µs 37.572 µs 37.762 µs] +Benchmarking i128_slice_search/binary_search/11 +Benchmarking i128_slice_search/binary_search/11: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/11: Collecting 10 samples in estimated 100.61 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/11: Analyzing +i128_slice_search/binary_search/11 + time: [25.231 µs 25.334 µs 25.466 µs] +Benchmarking i128_slice_search/hashset/11 +Benchmarking i128_slice_search/hashset/11: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/11: Collecting 10 samples in estimated 100.86 ms (6215 iterations) +Benchmarking i128_slice_search/hashset/11: Analyzing +i128_slice_search/hashset/11 + time: [16.204 µs 16.476 µs 17.077 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i128_slice_search/branchless/11 +Benchmarking i128_slice_search/branchless/11: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/11: Collecting 10 samples in estimated 100.08 ms (3025 iterations) +Benchmarking i128_slice_search/branchless/11: Analyzing +i128_slice_search/branchless/11 + time: [32.902 µs 32.995 µs 33.101 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/contains/12 +Benchmarking i128_slice_search/contains/12: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/12: Collecting 10 samples in estimated 100.83 ms (2475 iterations) +Benchmarking i128_slice_search/contains/12: Analyzing +i128_slice_search/contains/12 + time: [40.488 µs 40.559 µs 40.651 µs] +Benchmarking i128_slice_search/binary_search/12 +Benchmarking i128_slice_search/binary_search/12: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/12: Collecting 10 samples in estimated 100.91 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/12: Analyzing +i128_slice_search/binary_search/12 + time: [25.257 µs 25.366 µs 25.466 µs] +Benchmarking i128_slice_search/hashset/12 +Benchmarking i128_slice_search/hashset/12: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/12: Collecting 10 samples in estimated 100.21 ms (6215 iterations) +Benchmarking i128_slice_search/hashset/12: Analyzing +i128_slice_search/hashset/12 + time: [16.101 µs 16.163 µs 16.248 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/branchless/12 +Benchmarking i128_slice_search/branchless/12: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/12: Collecting 10 samples in estimated 100.09 ms (2750 iterations) +Benchmarking i128_slice_search/branchless/12: Analyzing +i128_slice_search/branchless/12 + time: [36.172 µs 36.269 µs 36.436 µs] +Benchmarking i128_slice_search/contains/13 +Benchmarking i128_slice_search/contains/13: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/13: Collecting 10 samples in estimated 101.15 ms (2090 iterations) +Benchmarking i128_slice_search/contains/13: Analyzing +i128_slice_search/contains/13 + time: [43.520 µs 43.732 µs 44.044 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/binary_search/13 +Benchmarking i128_slice_search/binary_search/13: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/13: Collecting 10 samples in estimated 100.48 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/13: Analyzing +i128_slice_search/binary_search/13 + time: [25.202 µs 25.347 µs 25.506 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/hashset/13 +Benchmarking i128_slice_search/hashset/13: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/13: Collecting 10 samples in estimated 100.78 ms (5830 iterations) +Benchmarking i128_slice_search/hashset/13: Analyzing +i128_slice_search/hashset/13 + time: [17.234 µs 37.426 µs 47.974 µs] +Benchmarking i128_slice_search/branchless/13 +Benchmarking i128_slice_search/branchless/13: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/13: Collecting 10 samples in estimated 100.38 ms (2585 iterations) +Benchmarking i128_slice_search/branchless/13: Analyzing +i128_slice_search/branchless/13 + time: [38.814 µs 38.925 µs 39.027 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i128_slice_search/contains/14 +Benchmarking i128_slice_search/contains/14: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/14: Collecting 10 samples in estimated 102.20 ms (2310 iterations) +Benchmarking i128_slice_search/contains/14: Analyzing +i128_slice_search/contains/14 + time: [44.016 µs 44.124 µs 44.259 µs] +Benchmarking i128_slice_search/binary_search/14 +Benchmarking i128_slice_search/binary_search/14: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/14: Collecting 10 samples in estimated 101.22 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/14: Analyzing +i128_slice_search/binary_search/14 + time: [25.411 µs 25.441 µs 25.482 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i128_slice_search/hashset/14 +Benchmarking i128_slice_search/hashset/14: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/14: Collecting 10 samples in estimated 100.49 ms (6105 iterations) +Benchmarking i128_slice_search/hashset/14: Analyzing +i128_slice_search/hashset/14 + time: [16.380 µs 16.453 µs 16.546 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i128_slice_search/branchless/14 +Benchmarking i128_slice_search/branchless/14: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/14: Collecting 10 samples in estimated 101.44 ms (2420 iterations) +Benchmarking i128_slice_search/branchless/14: Analyzing +i128_slice_search/branchless/14 + time: [41.846 µs 41.929 µs 42.055 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/contains/15 +Benchmarking i128_slice_search/contains/15: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/15: Collecting 10 samples in estimated 101.89 ms (1925 iterations) +Benchmarking i128_slice_search/contains/15: Analyzing +i128_slice_search/contains/15 + time: [52.265 µs 52.688 µs 53.224 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking i128_slice_search/binary_search/15 +Benchmarking i128_slice_search/binary_search/15: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/15: Collecting 10 samples in estimated 100.70 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/15: Analyzing +i128_slice_search/binary_search/15 + time: [25.266 µs 25.357 µs 25.471 µs] +Benchmarking i128_slice_search/hashset/15 +Benchmarking i128_slice_search/hashset/15: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/15: Collecting 10 samples in estimated 100.11 ms (6160 iterations) +Benchmarking i128_slice_search/hashset/15: Analyzing +i128_slice_search/hashset/15 + time: [16.203 µs 16.249 µs 16.303 µs] +Benchmarking i128_slice_search/branchless/15 +Benchmarking i128_slice_search/branchless/15: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/15: Collecting 10 samples in estimated 101.51 ms (2255 iterations) +Benchmarking i128_slice_search/branchless/15: Analyzing +i128_slice_search/branchless/15 + time: [44.828 µs 44.900 µs 45.007 µs] +Benchmarking i128_slice_search/contains/16 +Benchmarking i128_slice_search/contains/16: Warming up for 50.000 ms +Benchmarking i128_slice_search/contains/16: Collecting 10 samples in estimated 101.74 ms (1760 iterations) +Benchmarking i128_slice_search/contains/16: Analyzing +i128_slice_search/contains/16 + time: [57.495 µs 57.683 µs 57.903 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking i128_slice_search/binary_search/16 +Benchmarking i128_slice_search/binary_search/16: Warming up for 50.000 ms +Benchmarking i128_slice_search/binary_search/16: Collecting 10 samples in estimated 100.41 ms (3960 iterations) +Benchmarking i128_slice_search/binary_search/16: Analyzing +i128_slice_search/binary_search/16 + time: [25.331 µs 25.442 µs 25.563 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking i128_slice_search/hashset/16 +Benchmarking i128_slice_search/hashset/16: Warming up for 50.000 ms +Benchmarking i128_slice_search/hashset/16: Collecting 10 samples in estimated 100.10 ms (5995 iterations) +Benchmarking i128_slice_search/hashset/16: Analyzing +i128_slice_search/hashset/16 + time: [16.544 µs 16.565 µs 16.591 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking i128_slice_search/branchless/16 +Benchmarking i128_slice_search/branchless/16: Warming up for 50.000 ms +Benchmarking i128_slice_search/branchless/16: Collecting 10 samples in estimated 102.58 ms (2145 iterations) +Benchmarking i128_slice_search/branchless/16: Analyzing +i128_slice_search/branchless/16 + time: [47.610 µs 47.708 µs 47.863 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe + +Benchmarking str_slice_search/contains/2 +Benchmarking str_slice_search/contains/2: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/2: Collecting 10 samples in estimated 100.27 ms (2420 iterations) +Benchmarking str_slice_search/contains/2: Analyzing +str_slice_search/contains/2 + time: [40.840 µs 40.940 µs 41.048 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking str_slice_search/binary_search/2 +Benchmarking str_slice_search/binary_search/2: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/2: Collecting 10 samples in estimated 101.21 ms (1760 iterations) +Benchmarking str_slice_search/binary_search/2: Analyzing +str_slice_search/binary_search/2 + time: [56.572 µs 56.773 µs 56.969 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking str_slice_search/hashset/2 +Benchmarking str_slice_search/hashset/2: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/2: Collecting 10 samples in estimated 101.12 ms (1980 iterations) +Benchmarking str_slice_search/hashset/2: Analyzing +str_slice_search/hashset/2 + time: [50.748 µs 50.944 µs 51.223 µs] +Benchmarking str_slice_search/contains/3 +Benchmarking str_slice_search/contains/3: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/3: Collecting 10 samples in estimated 100.65 ms (1595 iterations) +Benchmarking str_slice_search/contains/3: Analyzing +str_slice_search/contains/3 + time: [62.715 µs 62.938 µs 63.208 µs] +Benchmarking str_slice_search/binary_search/3 +Benchmarking str_slice_search/binary_search/3: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/3: Collecting 10 samples in estimated 102.04 ms (825 iterations) +Benchmarking str_slice_search/binary_search/3: Analyzing +str_slice_search/binary_search/3 + time: [123.11 µs 123.39 µs 123.84 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking str_slice_search/hashset/3 +Benchmarking str_slice_search/hashset/3: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/3: Collecting 10 samples in estimated 100.60 ms (2035 iterations) +Benchmarking str_slice_search/hashset/3: Analyzing +str_slice_search/hashset/3 + time: [49.321 µs 54.800 µs 62.606 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking str_slice_search/contains/4 +Benchmarking str_slice_search/contains/4: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/4: Collecting 10 samples in estimated 101.38 ms (1320 iterations) +Benchmarking str_slice_search/contains/4: Analyzing +str_slice_search/contains/4 + time: [76.505 µs 76.681 µs 76.930 µs] +Benchmarking str_slice_search/binary_search/4 +Benchmarking str_slice_search/binary_search/4: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/4: Collecting 10 samples in estimated 105.19 ms (935 iterations) +Benchmarking str_slice_search/binary_search/4: Analyzing +str_slice_search/binary_search/4 + time: [111.70 µs 112.07 µs 112.49 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking str_slice_search/hashset/4 +Benchmarking str_slice_search/hashset/4: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/4: Collecting 10 samples in estimated 101.06 ms (1980 iterations) +Benchmarking str_slice_search/hashset/4: Analyzing +str_slice_search/hashset/4 + time: [50.833 µs 50.994 µs 51.179 µs] +Benchmarking str_slice_search/contains/5 +Benchmarking str_slice_search/contains/5: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/5: Collecting 10 samples in estimated 100.54 ms (990 iterations) +Benchmarking str_slice_search/contains/5: Analyzing +str_slice_search/contains/5 + time: [101.12 µs 101.51 µs 101.96 µs] +Benchmarking str_slice_search/binary_search/5 +Benchmarking str_slice_search/binary_search/5: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/5: Collecting 10 samples in estimated 105.00 ms (605 iterations) +Benchmarking str_slice_search/binary_search/5: Analyzing +str_slice_search/binary_search/5 + time: [173.25 µs 173.89 µs 175.24 µs] +Benchmarking str_slice_search/hashset/5 +Benchmarking str_slice_search/hashset/5: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/5: Collecting 10 samples in estimated 102.74 ms (1980 iterations) +Benchmarking str_slice_search/hashset/5: Analyzing +str_slice_search/hashset/5 + time: [51.365 µs 51.664 µs 51.842 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) high mild +Benchmarking str_slice_search/contains/6 +Benchmarking str_slice_search/contains/6: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/6: Collecting 10 samples in estimated 101.83 ms (825 iterations) +Benchmarking str_slice_search/contains/6: Analyzing +str_slice_search/contains/6 + time: [123.55 µs 124.58 µs 126.76 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking str_slice_search/binary_search/6 +Benchmarking str_slice_search/binary_search/6: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/6: Collecting 10 samples in estimated 108.12 ms (605 iterations) +Benchmarking str_slice_search/binary_search/6: Analyzing +str_slice_search/binary_search/6 + time: [175.51 µs 178.17 µs 181.20 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking str_slice_search/hashset/6 +Benchmarking str_slice_search/hashset/6: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/6: Collecting 10 samples in estimated 100.93 ms (1980 iterations) +Benchmarking str_slice_search/hashset/6: Analyzing +str_slice_search/hashset/6 + time: [50.555 µs 50.738 µs 51.003 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking str_slice_search/contains/7 +Benchmarking str_slice_search/contains/7: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/7: Collecting 10 samples in estimated 105.12 ms (990 iterations) +Benchmarking str_slice_search/contains/7: Analyzing +str_slice_search/contains/7 + time: [106.37 µs 106.91 µs 107.60 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking str_slice_search/binary_search/7 +Benchmarking str_slice_search/binary_search/7: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/7: Collecting 10 samples in estimated 103.87 ms (660 iterations) +Benchmarking str_slice_search/binary_search/7: Analyzing +str_slice_search/binary_search/7 + time: [156.93 µs 157.47 µs 158.25 µs] +Benchmarking str_slice_search/hashset/7 +Benchmarking str_slice_search/hashset/7: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/7: Collecting 10 samples in estimated 100.61 ms (1980 iterations) +Benchmarking str_slice_search/hashset/7: Analyzing +str_slice_search/hashset/7 + time: [50.330 µs 50.553 µs 50.730 µs] +Found 2 outliers among 10 measurements (20.00%) + 2 (20.00%) low mild +Benchmarking str_slice_search/contains/8 +Benchmarking str_slice_search/contains/8: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/8: Collecting 10 samples in estimated 105.59 ms (660 iterations) +Benchmarking str_slice_search/contains/8: Analyzing +str_slice_search/contains/8 + time: [158.17 µs 158.63 µs 159.33 µs] +Benchmarking str_slice_search/binary_search/8 +Benchmarking str_slice_search/binary_search/8: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/8: Collecting 10 samples in estimated 102.51 ms (605 iterations) +Benchmarking str_slice_search/binary_search/8: Analyzing +str_slice_search/binary_search/8 + time: [167.87 µs 169.08 µs 169.89 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking str_slice_search/hashset/8 +Benchmarking str_slice_search/hashset/8: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/8: Collecting 10 samples in estimated 101.73 ms (1980 iterations) +Benchmarking str_slice_search/hashset/8: Analyzing +str_slice_search/hashset/8 + time: [50.474 µs 50.662 µs 50.896 µs] +Benchmarking str_slice_search/contains/9 +Benchmarking str_slice_search/contains/9: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/9: Collecting 10 samples in estimated 107.19 ms (605 iterations) +Benchmarking str_slice_search/contains/9: Analyzing +str_slice_search/contains/9 + time: [175.41 µs 175.85 µs 176.53 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking str_slice_search/binary_search/9 +Benchmarking str_slice_search/binary_search/9: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/9: Collecting 10 samples in estimated 112.05 ms (440 iterations) +Benchmarking str_slice_search/binary_search/9: Analyzing +str_slice_search/binary_search/9 + time: [252.74 µs 253.93 µs 255.71 µs] +Benchmarking str_slice_search/hashset/9 +Benchmarking str_slice_search/hashset/9: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/9: Collecting 10 samples in estimated 101.54 ms (1980 iterations) +Benchmarking str_slice_search/hashset/9: Analyzing +str_slice_search/hashset/9 + time: [50.782 µs 50.979 µs 51.123 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking str_slice_search/contains/10 +Benchmarking str_slice_search/contains/10: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/10: Collecting 10 samples in estimated 106.42 ms (550 iterations) +Benchmarking str_slice_search/contains/10: Analyzing +str_slice_search/contains/10 + time: [191.39 µs 192.47 µs 194.22 µs] +Benchmarking str_slice_search/binary_search/10 +Benchmarking str_slice_search/binary_search/10: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/10: Collecting 10 samples in estimated 101.85 ms (385 iterations) +Benchmarking str_slice_search/binary_search/10: Analyzing +str_slice_search/binary_search/10 + time: [261.40 µs 263.17 µs 265.21 µs] +Benchmarking str_slice_search/hashset/10 +Benchmarking str_slice_search/hashset/10: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/10: Collecting 10 samples in estimated 102.58 ms (1980 iterations) +Benchmarking str_slice_search/hashset/10: Analyzing +str_slice_search/hashset/10 + time: [51.230 µs 51.514 µs 51.961 µs] +Benchmarking str_slice_search/contains/11 +Benchmarking str_slice_search/contains/11: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/11: Collecting 10 samples in estimated 103.63 ms (495 iterations) +Benchmarking str_slice_search/contains/11: Analyzing +str_slice_search/contains/11 + time: [208.82 µs 209.55 µs 210.65 µs] +Benchmarking str_slice_search/binary_search/11 +Benchmarking str_slice_search/binary_search/11: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/11: Collecting 10 samples in estimated 112.99 ms (440 iterations) +Benchmarking str_slice_search/binary_search/11: Analyzing +str_slice_search/binary_search/11 + time: [255.23 µs 256.07 µs 257.66 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high severe +Benchmarking str_slice_search/hashset/11 +Benchmarking str_slice_search/hashset/11: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/11: Collecting 10 samples in estimated 102.29 ms (1980 iterations) +Benchmarking str_slice_search/hashset/11: Analyzing +str_slice_search/hashset/11 + time: [51.624 µs 51.768 µs 51.992 µs] +Benchmarking str_slice_search/contains/12 +Benchmarking str_slice_search/contains/12: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/12: Collecting 10 samples in estimated 112.09 ms (495 iterations) +Benchmarking str_slice_search/contains/12: Analyzing +str_slice_search/contains/12 + time: [225.33 µs 226.24 µs 227.39 µs] +Benchmarking str_slice_search/binary_search/12 +Benchmarking str_slice_search/binary_search/12: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/12: Collecting 10 samples in estimated 101.85 ms (385 iterations) +Benchmarking str_slice_search/binary_search/12: Analyzing +str_slice_search/binary_search/12 + time: [264.60 µs 265.79 µs 267.21 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking str_slice_search/hashset/12 +Benchmarking str_slice_search/hashset/12: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/12: Collecting 10 samples in estimated 100.59 ms (1925 iterations) +Benchmarking str_slice_search/hashset/12: Analyzing +str_slice_search/hashset/12 + time: [51.818 µs 52.023 µs 52.214 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking str_slice_search/contains/13 +Benchmarking str_slice_search/contains/13: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/13: Collecting 10 samples in estimated 107.24 ms (440 iterations) +Benchmarking str_slice_search/contains/13: Analyzing +str_slice_search/contains/13 + time: [240.59 µs 242.15 µs 243.29 µs] +Benchmarking str_slice_search/binary_search/13 +Benchmarking str_slice_search/binary_search/13: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/13: Collecting 10 samples in estimated 113.19 ms (275 iterations) +Benchmarking str_slice_search/binary_search/13: Analyzing +str_slice_search/binary_search/13 + time: [395.07 µs 569.50 µs 774.48 µs] +Benchmarking str_slice_search/hashset/13 +Benchmarking str_slice_search/hashset/13: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/13: Collecting 10 samples in estimated 102.82 ms (1925 iterations) +Benchmarking str_slice_search/hashset/13: Analyzing +str_slice_search/hashset/13 + time: [52.541 µs 53.148 µs 54.546 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) high mild + 1 (10.00%) high severe +Benchmarking str_slice_search/contains/14 +Benchmarking str_slice_search/contains/14: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/14: Collecting 10 samples in estimated 107.51 ms (440 iterations) +Benchmarking str_slice_search/contains/14: Analyzing +str_slice_search/contains/14 + time: [242.39 µs 242.79 µs 243.32 µs] +Benchmarking str_slice_search/binary_search/14 +Benchmarking str_slice_search/binary_search/14: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/14: Collecting 10 samples in estimated 102.62 ms (385 iterations) +Benchmarking str_slice_search/binary_search/14: Analyzing +str_slice_search/binary_search/14 + time: [262.71 µs 263.93 µs 265.08 µs] +Benchmarking str_slice_search/hashset/14 +Benchmarking str_slice_search/hashset/14: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/14: Collecting 10 samples in estimated 100.96 ms (1925 iterations) +Benchmarking str_slice_search/hashset/14: Analyzing +str_slice_search/hashset/14 + time: [52.191 µs 52.374 µs 52.598 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) high mild +Benchmarking str_slice_search/contains/15 +Benchmarking str_slice_search/contains/15: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/15: Collecting 10 samples in estimated 106.91 ms (385 iterations) +Benchmarking str_slice_search/contains/15: Analyzing +str_slice_search/contains/15 + time: [274.81 µs 277.32 µs 279.12 µs] +Benchmarking str_slice_search/binary_search/15 +Benchmarking str_slice_search/binary_search/15: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/15: Collecting 10 samples in estimated 101.90 ms (385 iterations) +Benchmarking str_slice_search/binary_search/15: Analyzing +str_slice_search/binary_search/15 + time: [260.60 µs 261.84 µs 262.65 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low severe + 1 (10.00%) low mild +Benchmarking str_slice_search/hashset/15 +Benchmarking str_slice_search/hashset/15: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/15: Collecting 10 samples in estimated 102.11 ms (1925 iterations) +Benchmarking str_slice_search/hashset/15: Analyzing +str_slice_search/hashset/15 + time: [52.828 µs 53.037 µs 53.308 µs] +Benchmarking str_slice_search/contains/16 +Benchmarking str_slice_search/contains/16: Warming up for 50.000 ms +Benchmarking str_slice_search/contains/16: Collecting 10 samples in estimated 111.08 ms (385 iterations) +Benchmarking str_slice_search/contains/16: Analyzing +str_slice_search/contains/16 + time: [289.03 µs 289.47 µs 290.38 µs] +Found 2 outliers among 10 measurements (20.00%) + 1 (10.00%) low mild + 1 (10.00%) high mild +Benchmarking str_slice_search/binary_search/16 +Benchmarking str_slice_search/binary_search/16: Warming up for 50.000 ms +Benchmarking str_slice_search/binary_search/16: Collecting 10 samples in estimated 101.84 ms (385 iterations) +Benchmarking str_slice_search/binary_search/16: Analyzing +str_slice_search/binary_search/16 + time: [263.17 µs 264.62 µs 265.80 µs] +Found 1 outliers among 10 measurements (10.00%) + 1 (10.00%) low mild +Benchmarking str_slice_search/hashset/16 +Benchmarking str_slice_search/hashset/16: Warming up for 50.000 ms +Benchmarking str_slice_search/hashset/16: Collecting 10 samples in estimated 101.52 ms (1870 iterations) +Benchmarking str_slice_search/hashset/16: Analyzing +str_slice_search/hashset/16 + time: [53.492 µs 53.772 µs 54.075 µs] + diff --git a/benchmarks/slice-search/results/Apple_M1_Max/slice_search.png b/benchmarks/slice-search/results/Apple_M1_Max/slice_search.png new file mode 100644 index 0000000000000..c2c902022aea8 Binary files /dev/null and b/benchmarks/slice-search/results/Apple_M1_Max/slice_search.png differ diff --git a/benchmarks/slice-search/results/plot_results.py b/benchmarks/slice-search/results/plot_results.py new file mode 100644 index 0000000000000..89415875c3dac --- /dev/null +++ b/benchmarks/slice-search/results/plot_results.py @@ -0,0 +1,480 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +"""Build plots from the Criterion sample data under target/criterion. + +This script reads the per-benchmark `sample.json` files emitted by Criterion +and produces PNGs showing **minimum** time to process a batch of 8192 lookups +for `contains` vs `binary_search` vs `hashset` vs `branchless` across the +measured slice lengths and data types. + +We use min (not mean) because noise can only add time, never subtract. +The minimum represents the code's intrinsic cost when the system isn't +doing other things. + +Results are saved to a CPU-specific subfolder (e.g., results/Apple_M1_Pro/). + +Style: SciencePlots (https://github.com/garrettj403/SciencePlots) +""" +from pathlib import Path +import json +import platform +import re +import subprocess +import pandas as pd +import matplotlib.pyplot as plt +import matplotlib.patches as mpatches +import scienceplots # noqa: F401 - required for plt.style.use('science') + +# Use SciencePlots science style (no LaTeX required) with sans-serif fonts +plt.style.use(['science', 'no-latex', 'grid']) +plt.rcParams['font.family'] = 'sans-serif' +plt.rcParams['font.sans-serif'] = ['Arial', 'Helvetica', 'DejaVu Sans'] + + +def get_cpu_model() -> str: + """Get the CPU model name, formatted for use as a folder name.""" + system = platform.system() + + try: + if system == "Darwin": # macOS + result = subprocess.run( + ["sysctl", "-n", "machdep.cpu.brand_string"], + capture_output=True, text=True, check=True + ) + cpu_name = result.stdout.strip() + elif system == "Linux": + with open("/proc/cpuinfo") as f: + for line in f: + if line.startswith("model name"): + cpu_name = line.split(":")[1].strip() + break + else: + cpu_name = "Unknown_CPU" + else: + cpu_name = platform.processor() or "Unknown_CPU" + except Exception: + cpu_name = "Unknown_CPU" + + # Sanitize for folder name: replace spaces/special chars with underscores + cpu_name = re.sub(r'[^\w\-]', '_', cpu_name) + cpu_name = re.sub(r'_+', '_', cpu_name) # Collapse multiple underscores + cpu_name = cpu_name.strip('_') + + return cpu_name + + +REPO_ROOT = Path(__file__).resolve().parents[3] +CRITERION_DIR = REPO_ROOT / "target" / "criterion" +RESULTS_BASE_DIR = Path(__file__).parent +CPU_MODEL = get_cpu_model() +RESULTS_DIR = RESULTS_BASE_DIR / CPU_MODEL +RESULTS_DIR.mkdir(parents=True, exist_ok=True) + +# Display names for data types +TYPE_DISPLAY_NAMES = { + "i8": "Int8", + "i16": "Int16", + "i32": "Int32", + "i64": "Int64", + "i128": "Int128", + "str": "String", +} + +# Bins for cutoff visualization (slice size ranges) +CUTOFF_BINS = ["2", "3-4", "5-8", "9-16", "17-32", "33-64", "65-128", "129-256"] +CUTOFF_BIN_RANGES = [(2, 2), (3, 4), (5, 8), (9, 16), (17, 32), (33, 64), (65, 128), (129, 256)] + + +def load_results(): + records = [] + for sample_path in CRITERION_DIR.glob("*_slice_search/*/*/new/sample.json"): + try: + length = int(sample_path.parent.parent.name) + except ValueError: + continue + method = sample_path.parent.parent.parent.name + type_group = sample_path.parent.parent.parent.parent.name + type_name = type_group.split("_")[0] + + with sample_path.open() as f: + sample = json.load(f) + # Compute per-iteration time and take the minimum (convert ns to µs) + iters = sample["iters"] + times = sample["times"] + per_iter_ns = [t / i for t, i in zip(times, iters)] + min_us = min(per_iter_ns) / 1e3 # ns to µs + records.append( + { + "type": type_name, + "method": method, + "length": length, + "min_us": min_us, + } + ) + + return pd.DataFrame(records) + + +def plot_consolidated(df: pd.DataFrame, output_path: Path): + """Generate a single consolidated plot organized by max slice length sections. + + Uses subplot_mosaic for declarative layout definition. + """ + # Define layout using subplot_mosaic + # Each unique string becomes a subplot; '.' creates empty space + # Using 6-column grid for flexible spanning + mosaic = [ + ['i8_256', 'i8_256', 'i8_256', 'i16_128', 'i16_128', 'i16_128'], # Section 1 + ['.', '.', '.', '.', '.', '.'], # Gap between sections + ['i32_64', 'i32_64', 'i32_64', 'i64_64', 'i64_64', 'i64_64'], # Section 2 + ['.', '.', '.', '.', '.', '.'], # Gap between sections + ['i8_16', 'i8_16', 'i16_16', 'i16_16', 'i32_16', 'i32_16'], # Section 3 top + ['.', '.', '.', '.', '.', '.'], # Gap within section 3 + ['i64_16', 'i64_16', 'i128_16', 'i128_16', 'str_16', 'str_16'], # Section 3 bottom + ['.', '.', '.', '.', '.', '.'], # Gap between sections + ['cutoffs', 'cutoffs', 'cutoffs', 'cutoffs', 'cutoffs', 'cutoffs'], # Section 4 + ] + + # Create figure with mosaic layout + fig, axd = plt.subplot_mosaic( + mosaic, + figsize=(12, 17), + height_ratios=[1, 0.2, 1, 0.2, 1, 0.12, 1, 0.2, 0.6], + gridspec_kw={'hspace': 0.25, 'wspace': 0.3}, + ) + + # Define what each subplot shows: (type, max_length) + subplot_config = { + 'i8_256': ('i8', 256), 'i16_128': ('i16', 128), + 'i32_64': ('i32', 64), 'i64_64': ('i64', 64), + 'i8_16': ('i8', 16), 'i16_16': ('i16', 16), 'i32_16': ('i32', 16), + 'i64_16': ('i64', 16), 'i128_16': ('i128', 16), 'str_16': ('str', 16), + } + + # Define sections for borders and titles + sections = [ + ("Max Slice Length of 256/128", ['i8_256', 'i16_128']), + ("Max Slice Length of 64", ['i32_64', 'i64_64']), + ("Max Slice Length of 16", ['i8_16', 'i16_16', 'i32_16', 'i64_16', 'i128_16', 'str_16']), + ("Recommended Algorithm Cutoffs", ['cutoffs']), + ] + + methods = ["contains", "binary_search", "hashset", "branchless"] + markers = ["o", "s", "^", "d"] + + # Plot data on all benchmark axes using default color cycle + handles, labels = [], [] + algo_colors = {} # Will capture colors from first subplot for cutoffs + for idx, (subplot_name, (t, max_len)) in enumerate(subplot_config.items()): + ax = axd[subplot_name] + subset = df[(df["type"] == t) & (df["length"] <= max_len)] + + for method, marker in zip(methods, markers): + data = subset[subset["method"] == method].sort_values("length") + if data.empty: + continue + label = "linear" if method == "contains" else method.replace("_", " ") + line, = ax.plot( + data["length"], + data["min_us"], + label=label, + marker=marker, + markersize=2.5, + ) + + # Capture handles/labels/colors from first subplot + if idx == 0: + handles.append(line) + labels.append(label) + algo_colors[method] = line.get_color() + + ax.set_title(TYPE_DISPLAY_NAMES.get(t, t)) + + # Get cutoffs axes + cutoffs_ax = axd['cutoffs'] + + # Plot cutoffs on the dedicated axes + cutoffs_data = find_best_cutoffs(df) + type_order = ["i8", "i16", "i32", "i64", "i128", "str"] + types = [t for t in type_order if t in cutoffs_data] + + def get_algo_for_size(ranges, size): + for algo, start, end in ranges: + if start <= size <= end: + return algo + return ranges[-1][0] + + # Short labels for algorithms (to fit in bars) + algo_labels = { + "branchless": "branchless", + "hashset": "hashset", + "contains": "linear", + "binary_search": "binary", + } + + bar_width = 0.8 + for y, dtype in enumerate(types): + ranges = cutoffs_data[dtype] + + # Group consecutive bins by algorithm to place centered labels + current_algo = None + algo_start_x = 0 + + for x, (bin_label, (bin_start, bin_end)) in enumerate(zip(CUTOFF_BINS, CUTOFF_BIN_RANGES)): + algo = get_algo_for_size(ranges, bin_start) + color = algo_colors.get(algo, "#95a5a6") + cutoffs_ax.barh(y, 1, left=x, height=bar_width, color=color, edgecolor='white', linewidth=0.5) + + # Track algorithm spans for labeling + if algo != current_algo: + # Label the previous span (left-aligned with small padding) + if current_algo is not None: + cutoffs_ax.text(algo_start_x + 0.1, y, algo_labels.get(current_algo, current_algo), + ha='left', va='center', color='white', fontsize=8, fontweight='bold') + current_algo = algo + algo_start_x = x + + # Label the final span (left-aligned with small padding) + if current_algo is not None: + cutoffs_ax.text(algo_start_x + 0.1, y, algo_labels.get(current_algo, current_algo), + ha='left', va='center', color='white', fontsize=8, fontweight='bold') + + cutoffs_ax.set_yticks(range(len(types))) + cutoffs_ax.set_yticklabels([TYPE_DISPLAY_NAMES.get(t, t) for t in types]) + cutoffs_ax.set_xticks([i + 0.5 for i in range(len(CUTOFF_BINS))], minor=True) + cutoffs_ax.set_xticklabels(CUTOFF_BINS, fontsize=9, minor=True) + cutoffs_ax.set_xticks(range(len(CUTOFF_BINS) + 1), minor=False) + cutoffs_ax.set_xticklabels([], minor=False) + cutoffs_ax.tick_params(axis='x', which='minor', length=0) + cutoffs_ax.tick_params(axis='x', which='major', length=4, color='#888888') + cutoffs_ax.tick_params(axis='y', length=0, which='both') + cutoffs_ax.set_xlim(0, len(CUTOFF_BINS)) + cutoffs_ax.grid(False) + cutoffs_ax.invert_yaxis() + + # Add section titles and borders + fig.canvas.draw() # Need to draw first to get accurate positions + + # Padding for borders + pad_left = 0.045 # Sized for widest labels (Int8, String, etc.) + pad_right = 0.012 + pad_bottom = 0.012 + pad_top = 0.035 + + # Compute consistent left boundary across all sections + left_boundary = None + for _, subplot_names in sections: + positions = [axd[name].get_position() for name in subplot_names] + x0 = min(p.x0 for p in positions) - pad_left + if left_boundary is None or x0 < left_boundary: + left_boundary = x0 + + # Draw section titles and borders + for title, subplot_names in sections: + axes_list = [axd[name] for name in subplot_names] + positions = [ax.get_position() for ax in axes_list] + + # Section title above first axis + axes_list[0].annotate( + title, + xy=(0, 1.18), xycoords='axes fraction', + fontsize=11, fontweight='bold', + ha='left', va='bottom' + ) + + # Section border + y0 = min(p.y0 for p in positions) - pad_bottom + x1 = max(p.x1 for p in positions) + pad_right + y1 = max(p.y1 for p in positions) + pad_top + + rect = mpatches.FancyBboxPatch( + (left_boundary, y0), x1 - left_boundary, y1 - y0, + boxstyle="square,pad=0", + linewidth=1, edgecolor='#cccccc', facecolor='none', + transform=fig.transFigure, clip_on=False + ) + fig.add_artist(rect) + + # Title and legend at top, left-aligned to section boundaries + fig.suptitle("Slice search benchmark — time in µs for 8192 lookups vs slice length", + fontsize=14, fontweight='bold', x=left_boundary, ha='left', y=0.98) + fig.legend(handles, labels, loc='upper left', ncol=4, frameon=True, + bbox_to_anchor=(left_boundary, 0.96), bbox_transform=fig.transFigure) + + fig.savefig(output_path, dpi=300, bbox_inches='tight') + plt.close(fig) + print(f"Saved plot to {output_path}") + + +def find_best_cutoffs(df: pd.DataFrame) -> dict: + """Find the best algorithm cutoffs for each data type. + + Uses dynamic programming to find optimal power-of-2 cutoffs that minimize + total cost while keeping algorithm ranges contiguous. + + Returns a dict mapping type -> list of (algorithm, start, end) tuples. + """ + # Powers of 2 we use as cutoff boundaries + powers_of_2 = [2, 4, 8, 16, 32, 64, 128, 256] + + results = {} + + for dtype in df["type"].unique(): + type_df = df[df["type"] == dtype] + lengths = sorted(type_df["length"].unique()) + max_len = max(lengths) + + # Get available algorithms for this type + algorithms = list(type_df["method"].unique()) + + # Build cost matrix: cost[algo][length] = time for that algo at that length + algo_costs = {} + for algo in algorithms: + algo_df = type_df[type_df["method"] == algo] + algo_costs[algo] = dict(zip(algo_df["length"], algo_df["min_us"])) + + # Find best power-of-2 aligned cutoffs + # Try all possible 1, 2, or 3 algorithm configurations + best_config = find_best_power2_config(lengths, algorithms, algo_costs, powers_of_2, max_len) + results[dtype] = best_config + + return results + + +def find_best_power2_config(lengths: list, algorithms: list, algo_costs: dict, + powers_of_2: list, max_len: int) -> list: + """Find the best algorithm configuration using power-of-2 boundaries.""" + + def range_cost(algo: str, start: int, end: int) -> float: + """Total cost of using algo for lengths in [start, end].""" + cost = 0 + for length in lengths: + if start <= length <= end: + if length in algo_costs.get(algo, {}): + cost += algo_costs[algo][length] + else: + cost += float('inf') # Algorithm not available at this length + return cost + + # Valid cutoffs (powers of 2 within our range) + cutoffs = [p for p in powers_of_2 if p <= max_len] + + best_cost = float('inf') + best_config = [(algorithms[0], 1, max_len)] + + # Try single algorithm (no cutoffs) + for algo in algorithms: + cost = range_cost(algo, 1, max_len) + if cost < best_cost: + best_cost = cost + best_config = [(algo, 1, max_len)] + + # Try two algorithms with one cutoff + for cutoff in cutoffs: + if cutoff >= max_len: + continue + for algo1 in algorithms: + for algo2 in algorithms: + if algo1 == algo2: + continue + cost = range_cost(algo1, 1, cutoff) + range_cost(algo2, cutoff + 1, max_len) + if cost < best_cost: + best_cost = cost + best_config = [(algo1, 1, cutoff), (algo2, cutoff + 1, max_len)] + + # Try three algorithms with two cutoffs + for i, cutoff1 in enumerate(cutoffs): + for cutoff2 in cutoffs[i+1:]: + if cutoff2 >= max_len: + continue + for algo1 in algorithms: + for algo2 in algorithms: + for algo3 in algorithms: + if algo1 == algo2 or algo2 == algo3: + continue + cost = (range_cost(algo1, 1, cutoff1) + + range_cost(algo2, cutoff1 + 1, cutoff2) + + range_cost(algo3, cutoff2 + 1, max_len)) + if cost < best_cost: + best_cost = cost + best_config = [ + (algo1, 1, cutoff1), + (algo2, cutoff1 + 1, cutoff2), + (algo3, cutoff2 + 1, max_len) + ] + + return best_config + + +def generate_cutoff_table(df: pd.DataFrame) -> str: + """Generate a Markdown summary of algorithm cutoffs per type.""" + cutoffs = find_best_cutoffs(df) + + # Order types by byte size + type_order = ["i8", "i16", "i32", "i64", "i128", "str"] + types = [t for t in type_order if t in cutoffs] + + lines = [ + "# Recommended Search Algorithm Cutoffs", + "", + "Based on minimum batch time (8192 lookups per batch).", + "", + ] + + # Generate readable decision logic + for dtype in types: + ranges = cutoffs[dtype] + display_name = TYPE_DISPLAY_NAMES.get(dtype, dtype) + + if len(ranges) == 1: + algo = "linear" if ranges[0][0] == "contains" else ranges[0][0] + lines.append(f"- **{display_name}**: always use {algo}") + elif len(ranges) == 2: + algo1 = "linear" if ranges[0][0] == "contains" else ranges[0][0] + algo2 = "linear" if ranges[1][0] == "contains" else ranges[1][0] + cutoff = ranges[0][2] + lines.append(f"- **{display_name}**: use {algo1} up to {cutoff}, then {algo2}") + else: + parts = [] + for algo, start, end in ranges: + algo_name = "linear" if algo == "contains" else algo + parts.append(f"{algo_name} ({start}-{end})") + lines.append(f"- **{display_name}**: {', '.join(parts)}") + + return "\n".join(lines) + + +def main(): + df = load_results() + if df.empty: + raise SystemExit("No criterion results found; run cargo bench first.") + + # Single consolidated plot with benchmark results and cutoffs + plot_consolidated(df, output_path=RESULTS_DIR / "slice_search.png") + + # Generate and save cutoff recommendations + table = generate_cutoff_table(df) + print("\n" + table) + + cutoff_path = RESULTS_DIR / "CUTOFFS.md" + cutoff_path.write_text(table + "\n") + print(f"\nSaved cutoff recommendations to {cutoff_path}") + + +if __name__ == "__main__": + main() diff --git a/benchmarks/slice-search/src/branchless.rs b/benchmarks/slice-search/src/branchless.rs new file mode 100644 index 0000000000000..496ca42ad9c34 --- /dev/null +++ b/benchmarks/slice-search/src/branchless.rs @@ -0,0 +1,85 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +//! Const-generic branchless filter for membership testing. +//! +//! The key optimization is using const generics so the compiler knows the exact +//! array size at compile time, enabling full loop unrolling and SIMD codegen. +//! +//! The API is batch-oriented: dispatch once on haystack size (match overhead), +//! then process thousands of needles with the fully-optimized monomorphic code. +//! This mirrors production IN LIST processing where dispatch cost is amortized. + +use seq_macro::seq; + +/// Branchless membership check using bitwise OR fold. +/// With const N, the compiler fully unrolls this loop. +#[inline(always)] +fn branchless_check( + haystack: &[T; N], + needle: T, +) -> bool { + haystack.iter().fold(false, |acc, &v| acc | (v == needle)) +} + +/// Batch branchless membership check. +/// Checks each needle against the haystack and counts matches. +/// This is representative of production IN LIST processing. +#[inline(always)] +fn branchless_batch( + haystack: &[T; N], + needles: &[T], +) -> usize { + needles + .iter() + .filter(|&&needle| branchless_check(haystack, needle)) + .count() +} + +/// Batch branchless lookup: checks all needles against a haystack. +/// Returns the count of matches (to prevent dead code elimination). +/// +/// This avoids vtable dispatch by selecting the const-generic instantiation +/// via match, then processing the entire batch with the monomorphic function. +pub fn branchless_batch_lookup( + haystack: &[T], + needles: &[T], +) -> Option { + macro_rules! dispatch { + ($n:literal) => {{ + let mut arr = [T::default(); $n]; + arr.copy_from_slice(haystack); + Some(branchless_batch(&arr, needles)) + }}; + } + + seq!(N in 2..=64 { + match haystack.len() { + #( N => dispatch!(N), )* + // Intermediate sizes up to 256 + 80 => dispatch!(80), + 96 => dispatch!(96), + 112 => dispatch!(112), + 128 => dispatch!(128), + 160 => dispatch!(160), + 192 => dispatch!(192), + 224 => dispatch!(224), + 256 => dispatch!(256), + _ => None, + } + }) +} diff --git a/benchmarks/slice-search/src/lib.rs b/benchmarks/slice-search/src/lib.rs new file mode 100644 index 0000000000000..f0cfe811ccfa1 --- /dev/null +++ b/benchmarks/slice-search/src/lib.rs @@ -0,0 +1,81 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +pub mod branchless; + +/// Slice lengths up to 256 for i8 benchmarks (extended range for cutoff analysis). +pub const LENGTHS_256: [usize; 55] = [ + // Every value 2-31 for fine-grained crossover analysis (skip 1, useless) + 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, // Even values 32-64 + 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, + // Intermediate sizes up to 256 + 80, 96, 112, 128, 160, 192, 224, 256, +]; + +/// Slice lengths up to 128 for i16 benchmarks. +pub const LENGTHS_128: [usize; 51] = [ + // Every value 2-31 for fine-grained crossover analysis (skip 1, useless) + 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, // Even values 32-64 + 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, + // Intermediate sizes up to 128 + 80, 96, 112, 128, +]; + +/// Slice lengths up to 64 for i32/i64 benchmarks. +pub const LENGTHS_64: [usize; 47] = [ + 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, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, + 60, 62, 64, +]; + +/// Slice lengths up to 16 for i128/str benchmarks. +pub const LENGTHS_16: [usize; 15] = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]; + +/// Builds an even-numbered sequence with a missing midpoint value to place the +/// target between two central elements for a worst-case binary search path. +/// +/// The returned vector contains the values `[0, 2, 4, ...]`, and the target is +/// the midpoint value plus one, so the lookup explores the deepest part of the +/// search tree while guaranteed to miss. +pub fn generate_numeric_even(len: usize, to_type: F) -> (Vec, T) +where + T: Ord + Clone, + F: Fn(usize) -> T, +{ + let data: Vec = (0..len).map(|i| to_type(i * 2)).collect(); + let midpoint = len / 2; + let target = to_type(midpoint * 2 + 1); + + (data, target) +} + +/// Builds an even-numbered string sequence with a missing midpoint value to +/// force the binary search down its longest path. +/// Strings are 32+ characters to be representative of real-world data. +/// The unique number is at the end to force full string comparison. +pub fn generate_even_strings(len: usize) -> (Vec, String) { + // Format: "item_padding_________________{:08}" (32 chars total) + let data: Vec = (0..len) + .map(|i| format!("item_padding_________________{:08}", i * 2)) + .collect(); + let midpoint = len / 2; + let target = format!("item_padding_________________{:08}", midpoint * 2 + 1); + + (data, target) +}