thermite 0.2.1

High-performance, generic, ISA-portable SIMD library with a policy-configurable transcendental math library
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

#![warn(missing_docs, clippy::missing_safety_doc)]

//! Non-temporal (streaming) vector loads and stores.

use core::ops::Deref;

use super::GenericVector;

/// Wrapper around an immutable vector reference for non-temporal (streaming) loads.
#[repr(transparent)]
pub struct StreamingVector<'a, V: GenericVector>(pub(crate) &'a V);

impl<V: GenericVector> Clone for StreamingVector<'_, V> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<V: GenericVector> Copy for StreamingVector<'_, V> {}

/// Wrapper around a mutable vector reference for non-temporal (streaming) loads and stores.
#[repr(transparent)]
pub struct StreamingVectorMut<'a, V: GenericVector>(pub(crate) &'a mut V);

impl<'a, V: GenericVector> Deref for StreamingVectorMut<'a, V> {
    type Target = StreamingVector<'a, V>;

    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        // SAFETY: StreamingVector and StreamingVectorMut have the same representation.
        unsafe { core::mem::transmute(self) }
    }
}

impl<V: GenericVector> StreamingVector<'_, V> {
    /// Load a vector using a non-temporal (streaming) load.
    ///
    /// This memory should not be accessed frequently by the CPU,
    /// as non-temporal loads are intended for data that will not be reused soon.
    #[inline(always)]
    pub fn load(&self) -> V {
        // SAFETY: Ensured valid alignment and size by reference type.
        unsafe { V::load_streaming(self.0 as *const _ as *const V::Element) }
    }

    /// Load a vector using a regular (cached) load.
    ///
    /// This is provided for cases where the user wants to load from a streaming source
    /// but still use a cached load. This will bring the data into the CPU cache.
    #[inline(always)]
    pub fn load_cached(&self) -> V {
        // SAFETY: Ensured valid alignment and size by reference type.
        unsafe { V::load(self.0 as *const _ as *const V::Element) }
    }
}

impl<V: GenericVector> StreamingVectorMut<'_, V> {
    /// Store a vector using a non-temporal (streaming) store.
    ///
    /// This memory should not be accessed frequently by the CPU,
    /// as non-temporal stores are intended for data that will not be reused soon.
    #[inline(always)]
    pub fn store(&mut self, vec: V) {
        // SAFETY: Ensured valid alignment and size by reference type.
        unsafe { vec.store_streaming(self.0 as *mut _ as *mut V::Element) }
    }

    /// Store a vector using a regular (cached) store.
    ///
    /// This is provided for cases where the user wants to store to a streaming destination
    /// but still use a cached store. This will bring the data into the CPU cache.
    #[inline(always)]
    pub fn store_cached(&mut self, vec: V) {
        // SAFETY: Ensured valid alignment and size by reference type.
        unsafe { vec.store(self.0 as *mut _ as *mut V::Element) }
    }
}