memx 0.2.0

memory functions like libc memcmp(), memchr(), memmem(), memcpy(), memset()
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

use super::{__m128i, __m256i};
use super::{_b16_eq, _b16_from_b32, _b16_value, _b32_eq, _b32_value};
use crate::utils::B1Qpl;

#[derive(Debug, Copy, Clone)]
pub(crate) struct MMB16Qpl {
    pub v1: __m128i,
    pub v2: __m128i,
    pub v3: __m128i,
    pub v4: __m128i,
}
impl MMB16Qpl {
    #[allow(dead_code)]
    #[inline(always)]
    pub fn new(b1: u8, b2: u8, b3: u8, b4: u8) -> Self {
        Self {
            v1: unsafe { _b16_value(b1) },
            v2: unsafe { _b16_value(b2) },
            v3: unsafe { _b16_value(b3) },
            v4: unsafe { _b16_value(b4) },
        }
    }
}
impl PartialEq for MMB16Qpl {
    fn eq(&self, other: &Self) -> bool {
        let a = unsafe { _b16_eq(self.v1, other.v1) };
        let b = unsafe { _b16_eq(self.v2, other.v2) };
        let c = unsafe { _b16_eq(self.v3, other.v3) };
        let d = unsafe { _b16_eq(self.v4, other.v4) };
        a && b && c && d
    }
}

impl From<B1Qpl> for MMB16Qpl {
    fn from(cc: B1Qpl) -> Self {
        Self::new(cc.v1, cc.v2, cc.v3, cc.v4)
    }
}

#[derive(Debug, Copy, Clone)]
pub(crate) struct MMB32Qpl {
    pub v1: __m256i,
    pub v2: __m256i,
    pub v3: __m256i,
    pub v4: __m256i,
}
impl MMB32Qpl {
    #[allow(dead_code)]
    #[inline(always)]
    pub fn new(b1: u8, b2: u8, b3: u8, b4: u8) -> Self {
        Self {
            v1: unsafe { _b32_value(b1) },
            v2: unsafe { _b32_value(b2) },
            v3: unsafe { _b32_value(b3) },
            v4: unsafe { _b32_value(b4) },
        }
    }
}
impl PartialEq for MMB32Qpl {
    fn eq(&self, other: &Self) -> bool {
        let a = unsafe { _b32_eq(self.v1, other.v1) };
        let b = unsafe { _b32_eq(self.v2, other.v2) };
        let c = unsafe { _b32_eq(self.v3, other.v3) };
        let d = unsafe { _b32_eq(self.v4, other.v4) };
        a && b && c && d
    }
}

impl From<B1Qpl> for MMB32Qpl {
    fn from(cc: B1Qpl) -> Self {
        Self::new(cc.v1, cc.v2, cc.v3, cc.v4)
    }
}

impl From<MMB32Qpl> for MMB16Qpl {
    fn from(cc: MMB32Qpl) -> Self {
        Self {
            v1: unsafe { _b16_from_b32(cc.v1) },
            v2: unsafe { _b16_from_b32(cc.v2) },
            v3: unsafe { _b16_from_b32(cc.v3) },
            v4: unsafe { _b16_from_b32(cc.v4) },
        }
    }
}

#[cfg(test)]
mod mini {
    #![allow(clippy::clone_on_copy)]
    use super::super::super::cpuid;
    use super::*;
    //
    #[test]
    fn t_b32() {
        if !cpuid::has_avx2() {
            return;
        }
        let a = MMB32Qpl::new(b'A', b'B', b'C', b'D');
        let b = a.clone();
        let c = a;
        assert_eq!(a, b);
        assert_eq!(a, c);
        assert_eq!(
            format!("{a:?}"),
            "MMB32Qpl { v1: __m256i(4702111234474983745, 4702111234474983745, 4702111234474983745, 4702111234474983745), v2: __m256i(4774451407313060418, 4774451407313060418, 4774451407313060418, 4774451407313060418), v3: __m256i(4846791580151137091, 4846791580151137091, 4846791580151137091, 4846791580151137091), v4: __m256i(4919131752989213764, 4919131752989213764, 4919131752989213764, 4919131752989213764) }"
        );
    }
    #[test]
    fn t_b16() {
        let a = MMB16Qpl::new(b'A', b'B', b'C', b'D');
        let b = a.clone();
        let c = a;
        assert_eq!(a, b);
        assert_eq!(a, c);
        assert_eq!(
            format!("{a:?}"),
            "MMB16Qpl { v1: __m128i(4702111234474983745, 4702111234474983745), v2: __m128i(4774451407313060418, 4774451407313060418), v3: __m128i(4846791580151137091, 4846791580151137091), v4: __m128i(4919131752989213764, 4919131752989213764) }"
        );
    }
    #[test]
    fn t_into() {
        if !cpuid::has_avx2() {
            return;
        }
        let a_b32 = MMB32Qpl::new(b'A', b'B', b'C', b'D');
        let a_b16: MMB16Qpl = a_b32.into();
        assert_eq!(a_b32, MMB32Qpl::new(b'A', b'B', b'C', b'D'));
        assert_eq!(a_b16, MMB16Qpl::new(b'A', b'B', b'C', b'D'));
    }
}