Quicksim

Quick-sim(d) provides several SIMD-accelerated, drop-in replacements for common algorithms. It's designed to make speeding up trivial parts of your code as easy as possible - no manual SIMD programming required. AVX features are automatically detected at runtime and enabled whenever possible. Quick-sim(d) is not intended as a replacement for Portable SIMD. Instead, it aims to completely hide vectorization logic from the API, keeping usage simple and ergonomic. The project is currently in alpha state, and does not yet provide vectorized implementations for all vectorizable functions in the Rust standard library. The implementations in this crate generally achieve significant speedups compared to naive versions. However, there are some trade-offs. For more information, see the Limitations section.

Note: Iterators are usually fast enough for most cases. Use this crate carefully, and make sure to identify critical hot-paths before replacing all of your implementations with the accelerated functions provided by this crate.

Add to your project

quicksim = "0.1"

Example

use quicksim::prelude::*;

fn main() {
    // Note: SIMD implementations only start to take effect with arrays of 32 elements or more.
    let array: Vec<u32> = vec![0, 1, 2, 3, 4];

    assert_eq!(array.max_simd(), array.iter().max().copied());
    assert_eq!(array.min_simd(), array.iter().min().copied());
    assert_eq!(array.find_simd(4), Some(4));
    assert!(array.contains_simd(4));
}

Limitations

The SIMD implementation becomes effective for arrays with more than 32 items. This means that if your array length is below 32 more than 50% of the time, using the *_simd() functions of this crate will generally be slower on average. Additionally, if no optimized implementation exists for a specific architecture, the SIMD version will always be slower than the regular implementation due to the overhead of checking for SIMD support and falling back to the default version.

Attribution

Many algorithms implemented here are based on those from Algorithmica, which helped me to get deeper into SIMD and implement some of the algorithms in this crate. Check this book out if you're interested in SIMD programming yourself, or if you want to learn more about computers, algorithms and low-level optimizations.

Benchmarks

The SIMD implementation becomes effective for arrays with more than 32 items. For smaller arrays (32 items or fewer), the SIMD versions are actually slower than the standard implementations. Please note that the benchmark results may contain some noise, so they shouldn't be treated as 100% accurate. All measurements were taken on a Ryzen 5 5600x CPU with 32 GB of RAM.

Some benchmarks include two cases: -avg and -worst. These represent the average-case and worst-case performance of the algorithm. For example, the find algorithm’s average case assumes the element is located at index size/2, while its worst case assumes the element is the last item in the collection.

&[u32]

🔍 Find - avg

🔍 Find - worst

Count

Min

Max

Contains - avg

Contains - worst

&[f32]

Min

Max