simd_cesu8 1.2.0

An extremely fast, SIMD accelerated, encoding and decoding library for CESU-8 and Modified UTF-8.
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

#![allow(missing_docs)]

extern crate alloc;

use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion};
use dev_util::Bucket;

macro_rules! bench_function {
    ($group:ident, $function:expr, $data:ident $(,)?) => {
        let mut iter = $data.iter();
        $group.bench_function($data.name(), |b| {
            b.iter_batched(
                || iter.next().unwrap(),
                |i| {
                    let output = $function(i);
                    let _ = black_box(output);
                },
                BatchSize::SmallInput,
            );
        });
    };
}

fn bench(c: &mut Criterion) {
    let null_strings = Bucket::null();
    let ascii_non_null_strings = Bucket::ascii_non_null();
    let ascii_null_alternating_strings = Bucket::ascii_null_alternating();
    let utf8_clamped_2_strings = Bucket::utf8_clamped_width(2);
    let utf8_clamped_3_strings = Bucket::utf8_clamped_width(3);
    let utf8_clamped_4_strings = Bucket::utf8_clamped_width(4);
    let interspersed_strings = Bucket::interspersed();

    let null_bytes = null_strings.clone().into_bytes();
    let ascii_non_null_bytes = ascii_non_null_strings.clone().into_bytes();
    let ascii_null_alternating_bytes = ascii_null_alternating_strings.clone().into_bytes();
    let utf8_clamped_2_bytes = utf8_clamped_2_strings.clone().into_bytes();
    let utf8_clamped_3_bytes = utf8_clamped_3_strings.clone().into_bytes();
    let utf8_clamped_4_bytes = utf8_clamped_4_strings.clone().into_bytes();
    let interspersed_bytes = interspersed_strings.clone().into_bytes();

    let surrogate_pair_bytes = Bucket::surrogate_pairs();
    let mutf8_null_bytes = Bucket::mutf8_null_bytes();
    let interspersed_cesu8_bytes = Bucket::interspersed_cesu8();
    let interspersed_mutf8_bytes = Bucket::interspersed_mutf8();

    ////////////////////////////////////////////////////////////////////////////

    macro_rules! encode_group {
        ($group_name:literal, $function:expr $(,)?) => {
            let mut group = c.benchmark_group($group_name);
            group.throughput(Bucket::<String>::THROUGHPUT);

            bench_function!(group, $function, null_strings);
            bench_function!(group, $function, ascii_non_null_strings);
            bench_function!(group, $function, ascii_null_alternating_strings);
            bench_function!(group, $function, utf8_clamped_2_strings);
            bench_function!(group, $function, utf8_clamped_3_strings);
            bench_function!(group, $function, utf8_clamped_4_strings);
            bench_function!(group, $function, interspersed_strings);

            group.finish();
        };
    }

    encode_group!("encode_cesu8", simd_cesu8::encode);
    encode_group!("encode_mutf8", simd_cesu8::mutf8::encode);

    ////////////////////////////////////////////////////////////////////////////

    macro_rules! decode_group {
        ($group_name:literal, $function:expr $(,)?) => {
            let mut group = c.benchmark_group($group_name);
            group.throughput(Bucket::<Vec<u8>>::THROUGHPUT);

            bench_function!(group, $function, null_bytes);
            bench_function!(group, $function, ascii_non_null_bytes);
            bench_function!(group, $function, ascii_null_alternating_bytes);
            bench_function!(group, $function, utf8_clamped_2_bytes);
            bench_function!(group, $function, utf8_clamped_3_bytes);
            bench_function!(group, $function, utf8_clamped_4_bytes);
            bench_function!(group, $function, interspersed_bytes);

            bench_function!(group, $function, surrogate_pair_bytes);
            bench_function!(group, $function, interspersed_cesu8_bytes);

            if ($group_name).contains("mutf8") {
                bench_function!(group, $function, mutf8_null_bytes);
                bench_function!(group, $function, interspersed_mutf8_bytes);
            }

            group.finish();
        };
    }

    decode_group!("decode_cesu8", simd_cesu8::decode);
    decode_group!("decode_mutf8", simd_cesu8::mutf8::decode);
}

criterion_group!(benches, bench);
criterion_main!(benches);