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

//! rkyv zero-copy serialization support for AlignedVec.

//! Zero-copy serialization support for aligned vectors using `rkyv`.

use super::AlignedVec;
use crate::align::Alignment;

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

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

impl<T, Align> rkyv::Archive for AlignedVec<T, Align>
where
    T: rkyv::Archive,
    Align: Alignment,
{
    type Archived = ArchivedAlignedVec<T::Archived>;
    type Resolver = AlignedVecResolver;

    #[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.as_slice(),
            pos,
            resolver.elements_resolver,
            out_elements,
        );
    }
}

impl<T, Align, S> rkyv::Serialize<S> for AlignedVec<T, Align>
where
    T: rkyv::Serialize<S> + rkyv::Archive,
    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.as_slice(), serializer)?;
        Ok(AlignedVecResolver { elements_resolver })
    }
}

impl<T, Align, D> rkyv::Deserialize<AlignedVec<T, Align>, D> for ArchivedAlignedVec<T>
where
    T: rkyv::Archive,
    T: rkyv::Deserialize<T, D>,
    Align: Alignment,
    D: rkyv::Fallible + ?Sized,
{
    #[inline]
    fn deserialize(&self, deserializer: &mut D) -> Result<AlignedVec<T, 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(v)
    }
}