#![allow(unsafe_code)]
#[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
mod decode_macros;
pub struct Wasm128;
#[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
mod imp {
use super::Wasm128;
use crate::scalar::{check_num_bits, packed_len_bytes};
use crate::traits::BitPacker;
use crate::Scalar;
#[cfg_attr(
docsrs,
doc(cfg(all(target_arch = "wasm32", target_feature = "simd128")))
)]
impl BitPacker for Wasm128 {
const BLOCK_LEN: usize = 128;
fn num_bits(decompressed: &[u32]) -> u8 {
Scalar::num_bits(decompressed)
}
fn compress(decompressed: &[u32], compressed: &mut [u8], num_bits: u8) -> usize {
Scalar::compress(decompressed, compressed, num_bits)
}
fn decompress(compressed: &[u8], decompressed: &mut [u32], num_bits: u8) -> usize {
assert_eq!(
decompressed.len(),
Self::BLOCK_LEN,
"decompressed.len() must be exactly BLOCK_LEN ({}), got {}",
Self::BLOCK_LEN,
decompressed.len()
);
check_num_bits(num_bits);
let needed = packed_len_bytes(Self::BLOCK_LEN, num_bits);
assert!(
compressed.len() >= needed,
"compressed buffer too small: need at least {needed} bytes, got {}",
compressed.len()
);
unsafe {
super::decode_macros::decode(num_bits, compressed, decompressed);
}
needed
}
}
#[cfg(test)]
mod tests {
use super::Wasm128;
use crate::testing::bench_gen;
use crate::testing::gen;
use crate::{BitPacker, Scalar};
use proptest::prelude::*;
fn patterns(num_bits: u8) -> [(&'static str, Vec<u32>); 5] {
let block_len = Scalar::BLOCK_LEN;
let max = gen::max_value_for_num_bits(num_bits);
let seed = bench_gen::BENCH_SEED ^ u32::from(num_bits).wrapping_mul(0x9E37_79B9);
[
("zeros", vec![0u32; block_len]),
("max_value", vec![max; block_len]),
(
"random",
bench_gen::random_values(seed, num_bits, block_len),
),
(
"sorted_ascending",
bench_gen::sorted_ascending_values(num_bits, block_len),
),
(
"alternating_min_max",
(0..block_len)
.map(|i| if i % 2 == 0 { 0 } else { max })
.collect(),
),
]
}
fn assert_wasm128_matches_scalar(num_bits: u8, values: &[u32], label: &str) {
let block_len = Scalar::BLOCK_LEN;
let mut compressed = vec![0u8; block_len * 4 + 8];
let written = Scalar::compress(values, &mut compressed, num_bits);
let compressed = &compressed[..written];
let mut scalar_out = vec![0u32; block_len];
Scalar::decompress(compressed, &mut scalar_out, num_bits);
let mut wasm_out = vec![0u32; block_len];
Wasm128::decompress(compressed, &mut wasm_out, num_bits);
assert_eq!(
wasm_out, scalar_out,
"Wasm128::decompress mismatched Scalar::decompress at num_bits={num_bits}, \
pattern={label}"
);
}
#[test]
#[allow(clippy::cast_possible_truncation)] fn equivalence_matrix_fixed_patterns() {
for num_bits in 1u8..=32 {
for (label, values) in patterns(num_bits) {
assert_wasm128_matches_scalar(num_bits, &values, label);
}
}
}
proptest! {
#![proptest_config(gen::proptest_config(200))]
#[test]
fn equivalence_matrix_random(
(num_bits, values) in gen::num_bits_and_block_values(Scalar::BLOCK_LEN)
) {
assert_wasm128_matches_scalar(num_bits, &values, "proptest_random");
}
}
}
}