simsimd 6.5.8

Portable mixed-precision BLAS-like vector math library for x86 and ARM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::collections::HashMap;
use std::env;

fn main() {
    build_simsimd();
}

/// Build SimSIMD with dynamic SIMD dispatching.
/// Returns a HashMap of enabled compilation flags for potential reuse.
fn build_simsimd() -> HashMap<String, bool> {
    let mut flags = HashMap::<String, bool>::new();
    let mut build = cc::Build::new();

    build
        // Prefer portable flags to support MSVC and older toolchains
        .std("c99") // Enforce C99 standard when supported
        .file("c/lib.c")
        .include("include")
        .define("SIMSIMD_NATIVE_F16", "0")
        .define("SIMSIMD_NATIVE_BF16", "0")
        .define("SIMSIMD_DYNAMIC_DISPATCH", "1")
        .opt_level(3)
        .flag_if_supported("-pedantic") // Strict compliance when supported
        .warnings(false);

    // Detect target architecture UPFRONT using Cargo's cross-compilation vars
    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
    let target_bits = env::var("CARGO_CFG_TARGET_POINTER_WIDTH").unwrap_or_default();

    // Set architecture-specific macros explicitly (like StringZilla)
    if target_arch == "x86_64" && target_bits == "64" {
        build.define("SIMSIMD_IS_64BIT_X86", "1");
        build.define("SIMSIMD_IS_64BIT_ARM", "0");
        flags.insert("SIMSIMD_IS_64BIT_X86".to_string(), true);
        flags.insert("SIMSIMD_IS_64BIT_ARM".to_string(), false);
    } else if target_arch == "aarch64" && target_bits == "64" {
        build.define("SIMSIMD_IS_64BIT_X86", "0");
        build.define("SIMSIMD_IS_64BIT_ARM", "1");
        flags.insert("SIMSIMD_IS_64BIT_X86".to_string(), false);
        flags.insert("SIMSIMD_IS_64BIT_ARM".to_string(), true);
    } else {
        build.define("SIMSIMD_IS_64BIT_X86", "0");
        build.define("SIMSIMD_IS_64BIT_ARM", "0");
        flags.insert("SIMSIMD_IS_64BIT_X86".to_string(), false);
        flags.insert("SIMSIMD_IS_64BIT_ARM".to_string(), false);
    }

    // Determine which backends to try based on target architecture.
    // The fallback mechanism will disable unsupported targets one by one.
    let flags_to_try = match target_arch.as_str() {
        "arm" | "aarch64" => vec![
            "SIMSIMD_TARGET_SVE2",
            "SIMSIMD_TARGET_SVE_BF16",
            "SIMSIMD_TARGET_SVE_F16",
            "SIMSIMD_TARGET_SVE_I8",
            "SIMSIMD_TARGET_SVE",
            "SIMSIMD_TARGET_NEON_BF16",
            "SIMSIMD_TARGET_NEON_F16",
            "SIMSIMD_TARGET_NEON_I8",
            "SIMSIMD_TARGET_NEON",
        ],
        "x86_64" => vec![
            "SIMSIMD_TARGET_SIERRA",
            "SIMSIMD_TARGET_TURIN",
            "SIMSIMD_TARGET_SAPPHIRE",
            "SIMSIMD_TARGET_GENOA",
            "SIMSIMD_TARGET_ICE",
            "SIMSIMD_TARGET_SKYLAKE",
            "SIMSIMD_TARGET_HASWELL",
        ],
        _ => vec![],
    };

    // Check environment variables to allow users to disable specific backends.
    // Usage: SIMSIMD_TARGET_NEON=0 SIMSIMD_TARGET_SVE=0 cargo build
    for flag in flags_to_try.iter() {
        let enabled = match env::var(flag) {
            Ok(val) => val != "0" && val.to_lowercase() != "false",
            Err(_) => true, // Default to enabled if not specified
        };

        if enabled {
            build.define(flag, "1");
            flags.insert(flag.to_string(), true);
        } else {
            build.define(flag, "0");
            flags.insert(flag.to_string(), false);
            println!("cargo:warning=Disabled {} via environment variable", flag);
        }
    }

    // Try compilation with all enabled backends
    if build.try_compile("simsimd").is_err() {
        println!("cargo:warning=Failed to compile SimSIMD with all SIMD backends...");

        // Fallback: disable backends one by one until compilation succeeds
        for flag in flags_to_try.iter() {
            build.define(flag, "0");
            flags.insert(flag.to_string(), false);

            if build.try_compile("simsimd").is_ok() {
                println!(
                    "cargo:warning=Successfully compiled after disabling {}",
                    flag
                );
                break;
            }

            println!(
                "cargo:warning=Failed to compile after disabling {}, trying next configuration...",
                flag
            );
        }
    }

    // Declare file dependencies
    println!("cargo:rerun-if-changed=c/lib.c");
    println!("cargo:rerun-if-changed=rust/lib.rs");
    println!("cargo:rerun-if-changed=include/simsimd/simsimd.h");
    println!("cargo:rerun-if-changed=include/simsimd/dot.h");
    println!("cargo:rerun-if-changed=include/simsimd/spatial.h");
    println!("cargo:rerun-if-changed=include/simsimd/probability.h");
    println!("cargo:rerun-if-changed=include/simsimd/binary.h");
    println!("cargo:rerun-if-changed=include/simsimd/types.h");

    // Rerun if environment variables change
    for flag in flags_to_try.iter() {
        println!("cargo:rerun-if-env-changed={}", flag);
    }

    flags
}