fastserial 0.1.1

Ultra-fast, zero-copy serialization/deserialization library for Rust with SIMD acceleration
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

/// Scans the input for the first occurrence of a double quote (`"`) or a backslash (`\`)
/// using AVX2 SIMD instructions.
///
/// # Arguments
/// * `input` - The byte slice to scan.
///
/// # Returns
/// The index of the first quote or backslash, or the length of the input if none are found.
///
/// # Safety
/// This function is unsafe because:
/// 1. It uses AVX2 intrinsic instructions (`_mm256_*`).
/// 2. The caller must ensure that the CPU supports AVX2 before calling this function.
/// 3. It performs unaligned memory loads (`_mm256_loadu_si256`), which is safe for any valid slice.
#[target_feature(enable = "avx2")]
#[allow(unused_unsafe)]
pub unsafe fn scan_quote_or_backslash(input: &[u8]) -> usize {
    use core::arch::x86_64::*;
    let quote = unsafe { _mm256_set1_epi8(b'"' as i8) };
    let backslash = unsafe { _mm256_set1_epi8(b'\\' as i8) };

    let mut i = 0usize;
    while i + 32 <= input.len() {
        let chunk = unsafe { _mm256_loadu_si256(input.as_ptr().add(i) as *const __m256i) };
        let eq_q = unsafe { _mm256_cmpeq_epi8(chunk, quote) };
        let eq_bs = unsafe { _mm256_cmpeq_epi8(chunk, backslash) };
        let mask = unsafe { _mm256_movemask_epi8(_mm256_or_si256(eq_q, eq_bs)) as u32 };
        if mask != 0 {
            return i + mask.trailing_zeros() as usize;
        }
        i += 32;
    }
    i + super::scalar::scan_quote_or_backslash(&input[i..])
}

/// Skips all leading JSON whitespace characters (space, tab, newline, carriage return)
/// using AVX2 SIMD instructions.
///
/// # Arguments
/// * `input` - The byte slice to skip whitespace in.
///
/// # Returns
/// The number of leading whitespace bytes skipped.
///
/// # Safety
/// This function is unsafe because:
/// 1. It uses AVX2 intrinsic instructions (`_mm256_*`).
/// 2. The caller must ensure that the CPU supports AVX2 before calling this function.
#[target_feature(enable = "avx2")]
#[allow(unused_unsafe)]
pub unsafe fn skip_whitespace(input: &[u8]) -> usize {
    use core::arch::x86_64::*;
    let sp = unsafe { _mm256_set1_epi8(b' ' as i8) };
    let tab = unsafe { _mm256_set1_epi8(b'\t' as i8) };
    let lf = unsafe { _mm256_set1_epi8(b'\n' as i8) };
    let cr = unsafe { _mm256_set1_epi8(b'\r' as i8) };

    let mut i = 0usize;
    while i + 32 <= input.len() {
        let chunk = unsafe { _mm256_loadu_si256(input.as_ptr().add(i) as *const __m256i) };
        let is_sp = unsafe { _mm256_cmpeq_epi8(chunk, sp) };
        let is_tab = unsafe { _mm256_cmpeq_epi8(chunk, tab) };
        let is_lf = unsafe { _mm256_cmpeq_epi8(chunk, lf) };
        let is_cr = unsafe { _mm256_cmpeq_epi8(chunk, cr) };
        let is_ws = unsafe {
            _mm256_or_si256(
                _mm256_or_si256(is_sp, is_tab),
                _mm256_or_si256(is_lf, is_cr),
            )
        };
        let mask = unsafe { _mm256_movemask_epi8(is_ws) as u32 };
        if mask != 0xFFFF_FFFF {
            return i + (!mask).trailing_zeros() as usize;
        }
        i += 32;
    }
    i + super::scalar::skip_whitespace(&input[i..])
}

/// Checks if all bytes in the input slice are valid ASCII characters
/// using AVX2 SIMD instructions.
///
/// # Arguments
/// * `input` - The byte slice to check.
///
/// # Returns
/// `true` if all bytes are ASCII, `false` otherwise.
///
/// # Safety
/// This function is unsafe because:
/// 1. It uses AVX2 intrinsic instructions (`_mm256_*`).
/// 2. The caller must ensure that the CPU supports AVX2 before calling this function.
#[target_feature(enable = "avx2")]
#[allow(unused_unsafe)]
pub unsafe fn is_all_ascii(input: &[u8]) -> bool {
    use core::arch::x86_64::*;
    let mut i = 0usize;
    let mut acc = unsafe { _mm256_setzero_si256() };
    while i + 32 <= input.len() {
        let chunk = unsafe { _mm256_loadu_si256(input.as_ptr().add(i) as *const __m256i) };
        acc = unsafe { _mm256_or_si256(acc, chunk) };
        i += 32;
    }
    let mask = unsafe { _mm256_movemask_epi8(acc) };
    if mask != 0 {
        return false;
    }
    input[i..].iter().all(|b| b.is_ascii())
}