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
use super::{BitPacker, UnsafeBitPacker};
const BLOCK_LEN: usize = 32;
mod scalar {
use std::ptr::read_unaligned as load_unaligned;
use std::ptr::write_unaligned as store_unaligned;
use Available;
use super::BLOCK_LEN;
type DataType = u32;
fn set1(el: i32) -> DataType {
el as u32
}
fn right_shift_32(el: DataType, shift: i32) -> DataType {
el >> shift
}
fn left_shift_32(el: DataType, shift: i32) -> DataType {
el << shift
}
fn op_or(left: DataType, right: DataType) -> DataType {
left | right
}
fn op_and(left: DataType, right: DataType) -> DataType {
left & right
}
fn or_collapse_to_u32(accumulator: DataType) -> u32 {
accumulator
}
fn compute_delta(curr: DataType, prev: DataType) -> DataType {
curr.wrapping_sub(prev)
}
fn integrate_delta(offset: DataType, delta: DataType) -> DataType {
offset.wrapping_add(delta)
}
declare_bitpacker!(cfg(any(debug, not(debug))));
impl Available for UnsafeBitPackerImpl {
fn available() -> bool {
true
}
}
}
pub struct BitPacker1x;
impl BitPacker for BitPacker1x {
const BLOCK_LEN: usize = BLOCK_LEN;
fn new() -> BitPacker1x {
BitPacker1x
}
fn compress(&self, decompressed: &[u32], compressed: &mut [u8], num_bits: u8) -> usize {
unsafe { scalar::UnsafeBitPackerImpl::compress(decompressed, compressed, num_bits) }
}
fn compress_sorted(
&self,
initial: u32,
decompressed: &[u32],
compressed: &mut [u8],
num_bits: u8,
) -> usize {
unsafe {
scalar::UnsafeBitPackerImpl::compress_sorted(
initial,
decompressed,
compressed,
num_bits,
)
}
}
fn decompress(&self, compressed: &[u8], decompressed: &mut [u32], num_bits: u8) -> usize {
unsafe { scalar::UnsafeBitPackerImpl::decompress(compressed, decompressed, num_bits) }
}
fn decompress_sorted(
&self,
initial: u32,
compressed: &[u8],
decompressed: &mut [u32],
num_bits: u8,
) -> usize {
unsafe {
scalar::UnsafeBitPackerImpl::decompress_sorted(
initial,
compressed,
decompressed,
num_bits,
)
}
}
fn num_bits(&self, decompressed: &[u32]) -> u8 {
unsafe { scalar::UnsafeBitPackerImpl::num_bits(decompressed) }
}
fn num_bits_sorted(&self, initial: u32, decompressed: &[u32]) -> u8 {
unsafe { scalar::UnsafeBitPackerImpl::num_bits_sorted(initial, decompressed) }
}
}