cfavml 0.2.0

CF's Accelerated Vector Math Library providing SIMD optimzied routines for vector operations
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

#[macro_export]
/// Dispatches a set of functions based on the available CPU features.
///
/// If the crate is compiled for no-std, this will use compile time dispatch specified by the
/// `target_features` flags, otherwise runtime selection is used.
///
/// Priority is given in the following order:
///
/// #### x86
///
/// - AVX512
/// - AVX2 + FMA
/// - AVX2
/// - Fallback
///
/// #### ARM
///
/// - NEON
/// - Fallback
///
/// ### Usage
///
/// ```
/// use cfavml::dispatch;
///
/// let a = 123;
/// let b = 123;
///
/// dispatch!(
///     avx2fma = my_fma_function,
///     avx2 = my_avx2_function,
///     neon = my_neon_function,
///     fallback = my_fallback_function,  // Required!
///     args = (a, b)
/// );
///
/// fn my_avx2_function(a: usize, b: usize) {}
/// fn my_neon_function(a: usize, b: usize) {}
/// fn my_fma_function(a: usize, b: usize) {}
/// fn my_fallback_function(a: usize, b: usize) {}
/// ```
///
macro_rules! dispatch {
    (
        $(avx512 = $avx512_fn:expr,)?
        $(avx2fma = $avx2fma_fn:expr,)?
        $(avx2 = $avx2_fn:expr,)?
        $(neon = $neon_fn:expr,)?
        fallback = $fallback_fn:expr,
        args = $args:tt
    ) => {{
        $(
            #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "nightly"))]
            if $crate::dispatch::is_avx512_available() {
                return $avx512_fn $args;
            }
        )?

        $(
            #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
            if $crate::dispatch::is_avx2_available() && $crate::dispatch::is_fma_available() {
                return $avx2fma_fn $args;
            }
        )?

        $(
            #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
            if $crate::dispatch::is_avx2_available() {
                return $avx2_fn $args;
            }
        )?

        $(
            #[cfg(target_arch = "aarch64")]
            if $crate::dispatch::is_neon_available() {
                return $neon_fn $args;
            }
        )?

        $fallback_fn $args
    }};
}

#[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "nightly"))]
#[inline(always)]
/// Returns if AVX512 is available to the system.
///
/// If this is compiling for a no std target, this selection is done
/// at compile time only.
pub fn is_avx512_available() -> bool {
    if cfg!(target_feature = "avx512f") {
        return true;
    }

    #[cfg(feature = "std")]
    if std::arch::is_x86_feature_detected!("avx512f") {
        return true;
    }

    false
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[inline(always)]
/// Returns if AVX2 is available to the system.
///
/// If this is compiling for a no std target, this selection is done
/// at compile time only.
pub fn is_avx2_available() -> bool {
    if cfg!(target_feature = "avx2") {
        return true;
    }

    #[cfg(feature = "std")]
    if std::arch::is_x86_feature_detected!("avx2") {
        return true;
    }

    false
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[inline(always)]
/// Returns if FMA is available to the system.
///
/// If this is compiling for a no std target, this selection is done
/// at compile time only.
pub fn is_fma_available() -> bool {
    if cfg!(target_feature = "fma") {
        return true;
    }

    #[cfg(feature = "std")]
    if std::arch::is_x86_feature_detected!("fma") {
        return true;
    }

    false
}

#[cfg(target_arch = "aarch64")]
#[inline(always)]
/// Returns if NEON is available to the system.
///
/// If this is compiling for a no std target, this selection is done
/// at compile time only.
pub fn is_neon_available() -> bool {
    if cfg!(target_feature = "neon") {
        return true;
    }

    #[cfg(feature = "std")]
    if std::arch::is_aarch64_feature_detected!("neon") {
        return true;
    }

    false
}