Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/benches/encoding.rs

3.7 KiB, 3 runs

created by r1870400018:15, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1use oxedyne_fe2o3_core::{
2 debug,
3 rand::Rand,
4};
5
6use criterion::{
7 criterion_group,
8 criterion_main,
9 Criterion,
10 BenchmarkId,
11 Throughput,
12};
13
14fn vu64_to_bytes_baseline(input: (Vec<u8>, Vec<u64>)) {
15 let (mut buf, seq) = input;
16 for num in seq {
17 let byts: [u8; 8] = num.to_be_bytes();
18 let mut count: u8 = 8;
19 for byt in &byts[..] {
20 if *byt == 0 {
21 count -= 1;
22 } else {
23 break;
24 }
25 }
26 buf.push(count);
27 while count > 0 {
28 buf.push(byts[(8-count) as usize]);
29 count -= 1;
30 }
31 }
32}
33
34fn vu64_to_bytes_alt_1(input: (Vec<u8>, Vec<u64>)) {
35 let (mut buf, seq) = input;
36 for num in seq {
37 let byts: [u8; 8] = num.to_be_bytes();
38 let mut count: usize = 8;
39 for byt in &byts[..] {
40 if *byt == 0 {
41 count -= 1;
42 } else {
43 break;
44 }
45 }
46 buf.push(count as u8);
47 while count > 0 {
48 buf.push(byts[8-count]);
49 count -= 1;
50 }
51 }
52}
53
54fn vu64_to_bytes_alt_2(input: (Vec<u8>, Vec<u64>)) {
55 let (mut buf, seq) = input;
56 for num in seq {
57 let byts: [u8; 8] = num.to_be_bytes();
58 let mut c_zeros: u8 = 0;
59 let mut mask: u64 = 0x_FF_FF_FF_FF_FF_FF_FF_FF;
60 // example
61 // c = 0
62 // MSB big endian LSB
63 // 0x_00_00_00_FF_FF_FF_FF_FF num
64 // 0x_FF_FF_FF_FF_FF_FF_FF_FF mask
65 // 0x_FF_FF_FF_00_00_00_00_00 xor
66 // c = 1
67 // 0x_00_00_00_FF_FF_FF_FF_FF num
68 // 0x_00_FF_FF_FF_FF_FF_FF_FF mask
69 // 0x_00_FF_FF_00_00_00_00_00 xor
70 // c = 2
71 // 0x_00_00_00_FF_FF_FF_FF_FF num
72 // 0x_00_00_FF_FF_FF_FF_FF_FF mask
73 // 0x_00_00_FF_00_00_00_00_00 xor
74 // c = 3
75 // 0x_00_00_00_FF_FF_FF_FF_FF num
76 // 0x_00_00_00_FF_FF_FF_FF_FF mask
77 // 0x_00_00_00_00_00_00_00_00 xor
78 //
79 // xor = 0 so exit with c = 3
80 //
81 while c_zeros > 0 && (num ^ mask) != 0 {
82 mask = mask >> 8;
83 c_zeros += 1;
84 }
85 buf.push(8-c_zeros);
86 //buf.extend_from_slice(&byts[(c_zeros as usize)..8]);
87 while c_zeros < 8 {
88 buf.push(byts[c_zeros as usize]);
89 c_zeros += 1;
90 }
91 }
92}
93
94fn bench_vu64_encoding(c: &mut Criterion) {
95 let mut group = c.benchmark_group("C64 encoding");
96
97 let mut seq = vec![0u64];
98 for _ in 0..10000 {
99 seq.push(Rand::rand_u64() & 0x_00_FF_FF_FF_FF_FF_FF_FF);
100 }
101 debug!("Length of input sequence: {}", seq.len());
102
103 group.throughput(Throughput::Elements(seq.len() as u64));
104
105 let seq0 = seq.clone();
106 let seq1 = seq.clone();
107 let seq2 = seq.clone();
108 let mut buf: Vec<u8> = Vec::new();
109 group.bench_with_input(
110 BenchmarkId::new("Baseline C64 encoding", seq0.len()),
111 &(buf, seq0),
112 |b, (buf, seq0)| {
113 b.iter(|| vu64_to_bytes_baseline((buf.to_vec(), seq0.to_vec())));
114 }
115 );
116 let mut buf: Vec<u8> = Vec::new();
117 group.bench_with_input(
118 BenchmarkId::new("Alternative #1 C64 encoding", seq1.len()),
119 &(buf, seq1),
120 |b, (buf, seq1)| {
121 b.iter(|| vu64_to_bytes_alt_1((buf.to_vec(), seq1.to_vec())));
122 }
123 );
124 let mut buf: Vec<u8> = Vec::new();
125 group.bench_with_input(
126 BenchmarkId::new("Alternative #2 C64 encoding", seq2.len()),
127 &(buf, seq2),
128 |b, (buf, seq2)| {
129 b.iter(|| vu64_to_bytes_alt_2((buf.to_vec(), seq2.to_vec())));
130 }
131 );
132
133 group.finish();
134}
135
136criterion_group!(benches, bench_vu64_encoding);
137criterion_main!(benches);