hermes-simd-core 0.5.0

High-performance, zero-overhead SIMD abstraction 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
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

//! Zero-copy serialization support for Clone-on-Write SIMD containers using `rkyv`.

use super::SimdCow;
use crate::align::Alignment;
use crate::arch::SimdArch;
use crate::vec::AlignedVec;
use crate::view::SimdView;

#[repr(transparent)]
/// Archived representation of a `SimdCow` used by `rkyv` zero-copy serialization.
pub struct ArchivedSimdCow<T> {
    pub(crate) elements: rkyv::vec::ArchivedVec<T>,
}

/// Resolver type for `SimdCow` serialization.
pub struct SimdCowResolver {
    pub(crate) elements_resolver: rkyv::vec::VecResolver,
}

impl<'a, T, Arch, Align> rkyv::Archive for SimdCow<'a, T, Arch, Align>
where
    T: rkyv::Archive,
    Arch: SimdArch,
    Align: Alignment,
{
    type Archived = ArchivedSimdCow<T::Archived>;
    type Resolver = SimdCowResolver;

    #[inline]
    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
        let out_elements = core::ptr::addr_of_mut!((*out).elements);
        rkyv::vec::ArchivedVec::resolve_from_slice(
            &self[..],
            pos,
            resolver.elements_resolver,
            out_elements,
        );
    }
}

impl<'a, T, Arch, Align, S> rkyv::Serialize<S> for SimdCow<'a, T, Arch, Align>
where
    T: rkyv::Serialize<S> + rkyv::Archive,
    Arch: SimdArch,
    Align: Alignment,
    S: rkyv::Fallible + rkyv::ser::Serializer + ?Sized,
    [T]: rkyv::SerializeUnsized<S>,
{
    #[inline]
    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
        let elements_resolver =
            rkyv::vec::ArchivedVec::serialize_from_slice(&self[..], serializer)?;
        Ok(SimdCowResolver { elements_resolver })
    }
}

impl<T, Arch, Align, D> rkyv::Deserialize<SimdCow<'static, T, Arch, Align>, D>
    for ArchivedSimdCow<T>
where
    T: rkyv::Archive,
    T: rkyv::Deserialize<T, D>,
    Arch: SimdArch,
    Align: Alignment,
    D: rkyv::Fallible + ?Sized,
{
    #[inline]
    fn deserialize(
        &self,
        deserializer: &mut D,
    ) -> Result<SimdCow<'static, T, Arch, Align>, D::Error> {
        let slice = self.elements.as_slice();
        let mut v = AlignedVec::with_capacity(slice.len());
        for x in slice {
            v.push(x.deserialize(deserializer)?);
        }
        Ok(SimdCow::Owned(v))
    }
}

impl<T> ArchivedSimdCow<T> {
    /// Returns the length of the archived vector.
    #[inline]
    pub fn len(&self) -> usize {
        self.elements.len()
    }

    /// Returns `true` if the archived vector is empty.
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.elements.is_empty()
    }

    /// Access the archived elements as a slice.
    #[inline]
    pub fn as_slice(&self) -> &[T] {
        self.elements.as_slice()
    }

    /// Zero-copy conversion of the archived SimdCow to a borrowed SimdCow.
    ///
    /// # Safety
    /// The alignment of the underlying archived memory must satisfy `Align`.
    #[inline]
    pub unsafe fn as_borrowed<'a, Arch, Align>(&'a self) -> Option<SimdCow<'a, T, Arch, Align>>
    where
        Arch: SimdArch,
        Align: Alignment,
    {
        let slice = self.elements.as_slice();
        let view = SimdView::new(slice)?;
        Some(SimdCow::Borrowed(view))
    }
}

impl<T> core::ops::Deref for ArchivedSimdCow<T> {
    type Target = [T];

    #[inline]
    fn deref(&self) -> &Self::Target {
        self.elements.as_slice()
    }
}