#[derive(Default)]
#[allow(clippy::struct_field_names)] struct Carries {
prev_in_string: u64,
prev_escaped: u64,
prev_scalar: u64,
}
struct BlockMasks {
backslash: u64,
quote: u64,
op: u64,
ws: u64,
}
impl Carries {
#[inline(always)]
fn find_escaped(&mut self, backslash: u64) -> u64 {
const EVEN: u64 = 0x5555_5555_5555_5555;
if backslash == 0 {
let escaped = self.prev_escaped;
self.prev_escaped = 0;
return escaped;
}
let backslash = backslash & !self.prev_escaped;
let follows_escape = backslash << 1 | self.prev_escaped;
let odd_starts = backslash & !EVEN & !follows_escape;
let (seq_start_on_even, carry) = odd_starts.overflowing_add(backslash);
self.prev_escaped = u64::from(carry);
let invert = seq_start_on_even << 1;
(EVEN ^ invert) & follows_escape
}
#[inline(always)]
fn block_structurals(&mut self, backslash: u64, quote_raw: u64, op: u64, ws: u64) -> u64 {
let escaped = self.find_escaped(backslash);
let quote = quote_raw & !escaped;
let mut string_mask = prefix_xor(quote);
string_mask ^= self.prev_in_string;
let string_tail = string_mask ^ quote;
self.prev_in_string = ((string_mask as i64) >> 63) as u64;
let scalar = !(op | ws);
let nonquote_scalar = scalar & !quote;
let follows_nonquote_scalar = nonquote_scalar << 1 | self.prev_scalar;
self.prev_scalar = nonquote_scalar >> 63;
(op | (scalar & !follows_nonquote_scalar)) & !string_tail
}
#[inline(always)]
fn block_ops(&mut self, backslash: u64, quote_raw: u64, op: u64) -> u64 {
let escaped = self.find_escaped(backslash);
let quote = quote_raw & !escaped;
let mut string_mask = prefix_xor(quote);
string_mask ^= self.prev_in_string;
let string_tail = string_mask ^ quote;
self.prev_in_string = ((string_mask as i64) >> 63) as u64;
op & !string_tail
}
}
#[inline(always)]
fn prefix_xor(x: u64) -> u64 {
#[cfg(all(target_arch = "aarch64", target_feature = "aes"))]
unsafe {
return std::arch::aarch64::vmull_p64(x, u64::MAX) as u64;
}
#[allow(unreachable_code)]
{
let mut x = x;
x ^= x << 1;
x ^= x << 2;
x ^= x << 4;
x ^= x << 8;
x ^= x << 16;
x ^= x << 32;
x
}
}
#[inline(always)]
fn flatten_bits<const PACK: bool>(out: &mut Vec<u32>, base: u32, mut bits: u64, bytes: *const u8) {
if bits == 0 {
return;
}
let cnt = bits.count_ones() as usize;
let start = out.len();
debug_assert!(out.capacity() >= start + cnt + 8);
unsafe {
let ptr = out.as_mut_ptr().add(start);
let mut written = 0usize;
while written < cnt {
for k in 0..8 {
let tz = bits.trailing_zeros() & 63;
let entry = if PACK {
((base + tz) << 8) | *bytes.add(tz as usize) as u32
} else {
base + tz
};
ptr.add(written + k).write(entry);
bits &= bits.wrapping_sub(1);
}
written += 8;
}
out.set_len(start + cnt);
}
}
pub(crate) const LO_NIBBLE: [u8; 16] = [16, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 1, 2, 9, 0, 0];
pub(crate) const HI_NIBBLE: [u8; 16] = [8, 0, 18, 4, 0, 1, 0, 1, 0, 0, 0, 3, 2, 1, 0, 0];
#[cfg(any(test, not(any(target_arch = "aarch64", target_arch = "x86_64"))))]
#[inline(always)]
fn classify_byte(b: u8) -> (bool, bool, bool, bool) {
let backslash = b == b'\\';
let quote = b == b'"';
let class = LO_NIBBLE[(b & 0x0F) as usize] & HI_NIBBLE[(b >> 4) as usize];
let op = class & 0x07 != 0;
let ws = class & 0x18 != 0;
(backslash, quote, op, ws)
}
#[cfg(any(test, not(any(target_arch = "aarch64", target_arch = "x86_64"))))]
pub fn index_scalar(input: &[u8], out: &mut Vec<u32>) {
index_scalar_impl::<false>(input, out);
}
#[cfg(any(test, not(any(target_arch = "aarch64", target_arch = "x86_64"))))]
fn index_scalar_impl<const PACK: bool>(input: &[u8], out: &mut Vec<u32>) {
out.clear();
out.reserve(input.len() + 8);
let mut carries = Carries::default();
let (chunks, rem) = input.as_chunks::<64>();
let mut base: u32 = 0;
for chunk in chunks {
let (mut bs, mut quote, mut op, mut ws) = (0u64, 0u64, 0u64, 0u64);
for (i, &b) in chunk.iter().enumerate() {
let (cb, cq, co, cw) = classify_byte(b);
bs |= (cb as u64) << i;
quote |= (cq as u64) << i;
op |= (co as u64) << i;
ws |= (cw as u64) << i;
}
let structurals = carries.block_structurals(bs, quote, op, ws);
flatten_bits::<PACK>(out, base, structurals, chunk.as_ptr());
base += 64;
}
if !rem.is_empty() {
let mut buf = [0u8; 64];
buf[..rem.len()].copy_from_slice(rem);
let (mut bs, mut quote, mut op, mut ws) = (0u64, 0u64, 0u64, 0u64);
for (i, &b) in buf[..rem.len()].iter().enumerate() {
let (cb, cq, co, cw) = classify_byte(b);
bs |= (cb as u64) << i;
quote |= (cq as u64) << i;
op |= (co as u64) << i;
ws |= (cw as u64) << i;
}
let structurals =
carries.block_structurals(bs, quote, op, ws) & (u64::MAX >> (64 - rem.len()));
flatten_bits::<PACK>(out, base, structurals, buf.as_ptr());
}
}
#[cfg(target_arch = "aarch64")]
mod neon {
use std::arch::aarch64::{
uint8x16_t, vandq_u8, vceqq_u8, vdupq_n_u8, vgetq_lane_u64, vld1q_u8, vpaddq_u8,
vqtbl1q_u8, vreinterpretq_u64_u8, vshrq_n_u8, vtstq_u8,
};
#[inline(always)]
unsafe fn movemask64(m0: uint8x16_t, m1: uint8x16_t, m2: uint8x16_t, m3: uint8x16_t) -> u64 {
unsafe {
let bit_mask: uint8x16_t = std::mem::transmute([
0x01u8, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x01, 0x02, 0x04, 0x08, 0x10,
0x20, 0x40, 0x80,
]);
let t0 = vandq_u8(m0, bit_mask);
let t1 = vandq_u8(m1, bit_mask);
let t2 = vandq_u8(m2, bit_mask);
let t3 = vandq_u8(m3, bit_mask);
let sum0 = vpaddq_u8(t0, t1);
let sum1 = vpaddq_u8(t2, t3);
let sum0 = vpaddq_u8(sum0, sum1);
let sum0 = vpaddq_u8(sum0, sum0);
vgetq_lane_u64::<0>(vreinterpretq_u64_u8(sum0))
}
}
use super::BlockMasks;
#[inline(always)]
pub(super) unsafe fn classify_block(ptr: *const u8) -> BlockMasks {
unsafe {
const LO: [u8; 16] = super::LO_NIBBLE;
const HI: [u8; 16] = super::HI_NIBBLE;
let v0 = vld1q_u8(ptr);
let v1 = vld1q_u8(ptr.add(16));
let v2 = vld1q_u8(ptr.add(32));
let v3 = vld1q_u8(ptr.add(48));
let lo_tbl = vld1q_u8(LO.as_ptr());
let hi_tbl = vld1q_u8(HI.as_ptr());
let nib = vdupq_n_u8(0x0F);
macro_rules! classify {
($v:expr) => {{
let lo = vqtbl1q_u8(lo_tbl, vandq_u8($v, nib));
let hi = vqtbl1q_u8(hi_tbl, vshrq_n_u8::<4>($v));
vandq_u8(lo, hi)
}};
}
let c0 = classify!(v0);
let c1 = classify!(v1);
let c2 = classify!(v2);
let c3 = classify!(v3);
let op_bits = vdupq_n_u8(0x07);
let ws_bits = vdupq_n_u8(0x18);
let op = movemask64(
vtstq_u8(c0, op_bits),
vtstq_u8(c1, op_bits),
vtstq_u8(c2, op_bits),
vtstq_u8(c3, op_bits),
);
let ws = movemask64(
vtstq_u8(c0, ws_bits),
vtstq_u8(c1, ws_bits),
vtstq_u8(c2, ws_bits),
vtstq_u8(c3, ws_bits),
);
macro_rules! eq_mask {
($byte:expr) => {{
let b = vdupq_n_u8($byte);
movemask64(
vceqq_u8(v0, b),
vceqq_u8(v1, b),
vceqq_u8(v2, b),
vceqq_u8(v3, b),
)
}};
}
let backslash = eq_mask!(b'\\');
let quote = eq_mask!(b'"');
BlockMasks {
backslash,
quote,
op,
ws,
}
}
}
}
#[cfg(target_arch = "x86_64")]
mod sse2 {
use std::arch::x86_64::*;
use super::BlockMasks;
#[inline(always)]
pub(super) unsafe fn classify_block(ptr: *const u8) -> BlockMasks {
unsafe {
let v0 = _mm_loadu_si128(ptr.cast());
let v1 = _mm_loadu_si128(ptr.add(16).cast());
let v2 = _mm_loadu_si128(ptr.add(32).cast());
let v3 = _mm_loadu_si128(ptr.add(48).cast());
macro_rules! eq_mask {
($byte:expr) => {{
let b = _mm_set1_epi8($byte as i8);
(_mm_movemask_epi8(_mm_cmpeq_epi8(v0, b)) as u64)
| (_mm_movemask_epi8(_mm_cmpeq_epi8(v1, b)) as u64) << 16
| (_mm_movemask_epi8(_mm_cmpeq_epi8(v2, b)) as u64) << 32
| (_mm_movemask_epi8(_mm_cmpeq_epi8(v3, b)) as u64) << 48
}};
}
let backslash = eq_mask!(b'\\');
let quote = eq_mask!(b'"');
let op = eq_mask!(b'{')
| eq_mask!(b'}')
| eq_mask!(b'[')
| eq_mask!(b']')
| eq_mask!(b':')
| eq_mask!(b',');
let ws = eq_mask!(b' ') | eq_mask!(b'\t') | eq_mask!(b'\n') | eq_mask!(b'\r');
BlockMasks {
backslash,
quote,
op,
ws,
}
}
}
}
#[cfg(target_arch = "x86_64")]
mod avx2 {
use super::{BlockMasks, Carries, flatten_bits};
use std::arch::x86_64::*;
#[inline]
#[target_feature(enable = "avx2")]
unsafe fn classify_block(ptr: *const u8) -> BlockMasks {
unsafe {
let lo128 = _mm_loadu_si128(super::LO_NIBBLE.as_ptr().cast());
let hi128 = _mm_loadu_si128(super::HI_NIBBLE.as_ptr().cast());
let lo_tbl = _mm256_broadcastsi128_si256(lo128);
let hi_tbl = _mm256_broadcastsi128_si256(hi128);
let nib = _mm256_set1_epi8(0x0F);
let op_bits = _mm256_set1_epi8(0x07);
let zero = _mm256_setzero_si256();
let quote_v = _mm256_set1_epi8(b'"' as i8);
let bs_v = _mm256_set1_epi8(b'\\' as i8);
let v0 = _mm256_loadu_si256(ptr.cast());
let v1 = _mm256_loadu_si256(ptr.add(32).cast());
macro_rules! classify {
($v:expr) => {{
let lo = _mm256_shuffle_epi8(lo_tbl, _mm256_and_si256($v, nib));
let hi = _mm256_shuffle_epi8(
hi_tbl,
_mm256_and_si256(_mm256_srli_epi16($v, 4), nib),
);
_mm256_and_si256(lo, hi)
}};
}
let c0 = classify!(v0);
let c1 = classify!(v1);
macro_rules! nonzero_mask {
($c:expr, $bits:expr) => {{
!(_mm256_movemask_epi8(_mm256_cmpeq_epi8(_mm256_and_si256($c, $bits), zero))
as u32)
}};
}
let op = nonzero_mask!(c0, op_bits) as u64 | (nonzero_mask!(c1, op_bits) as u64) << 32;
macro_rules! eq_mask {
($b:expr) => {{
(_mm256_movemask_epi8(_mm256_cmpeq_epi8(v0, $b)) as u32) as u64
| ((_mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, $b)) as u32) as u64) << 32
}};
}
let quote = eq_mask!(quote_v);
let backslash = eq_mask!(bs_v);
BlockMasks {
backslash,
quote,
op,
ws: 0,
}
}
}
#[target_feature(enable = "avx2")]
pub(super) unsafe fn container_end_avx2(input: &[u8], start: usize) -> Option<usize> {
super::container_end_driver(input, start, |ptr| {
unsafe { classify_block(ptr) }
})
}
#[target_feature(enable = "avx2")]
pub unsafe fn index_avx2<const PACK: bool>(input: &[u8], out: &mut Vec<u32>) {
unsafe {
out.clear();
out.reserve(input.len() + 8);
let mut carries = Carries::default();
let lo128 = _mm_loadu_si128(super::LO_NIBBLE.as_ptr().cast());
let hi128 = _mm_loadu_si128(super::HI_NIBBLE.as_ptr().cast());
let lo_tbl = _mm256_broadcastsi128_si256(lo128);
let hi_tbl = _mm256_broadcastsi128_si256(hi128);
let nib = _mm256_set1_epi8(0x0F);
let op_bits = _mm256_set1_epi8(0x07);
let ws_bits = _mm256_set1_epi8(0x18);
let zero = _mm256_setzero_si256();
let quote_v = _mm256_set1_epi8(b'"' as i8);
let bs_v = _mm256_set1_epi8(b'\\' as i8);
#[allow(clippy::too_many_arguments, clippy::items_after_statements)]
#[inline(always)]
unsafe fn block_masks(
ptr: *const u8,
lo_tbl: __m256i,
hi_tbl: __m256i,
nib: __m256i,
op_bits: __m256i,
ws_bits: __m256i,
zero: __m256i,
quote_v: __m256i,
bs_v: __m256i,
) -> (u64, u64, u64, u64) {
unsafe {
let v0 = _mm256_loadu_si256(ptr.cast());
let v1 = _mm256_loadu_si256(ptr.add(32).cast());
macro_rules! classify {
($v:expr) => {{
let lo = _mm256_shuffle_epi8(lo_tbl, _mm256_and_si256($v, nib));
let hi = _mm256_shuffle_epi8(
hi_tbl,
_mm256_and_si256(_mm256_srli_epi16($v, 4), nib),
);
_mm256_and_si256(lo, hi)
}};
}
let c0 = classify!(v0);
let c1 = classify!(v1);
macro_rules! nonzero_mask {
($c:expr, $bits:expr) => {{
!(_mm256_movemask_epi8(_mm256_cmpeq_epi8(
_mm256_and_si256($c, $bits),
zero,
)) as u32)
}};
}
let op = nonzero_mask!(c0, op_bits) as u64
| (nonzero_mask!(c1, op_bits) as u64) << 32;
let ws = nonzero_mask!(c0, ws_bits) as u64
| (nonzero_mask!(c1, ws_bits) as u64) << 32;
macro_rules! eq_mask {
($b:expr) => {{
(_mm256_movemask_epi8(_mm256_cmpeq_epi8(v0, $b)) as u32) as u64
| ((_mm256_movemask_epi8(_mm256_cmpeq_epi8(v1, $b)) as u32) as u64)
<< 32
}};
}
let quote = eq_mask!(quote_v);
let backslash = eq_mask!(bs_v);
(backslash, quote, op, ws)
}
}
let len = input.len();
let full_blocks = len / 64;
let ptr = input.as_ptr();
for block in 0..full_blocks {
let (bs, quote, op, ws) = block_masks(
ptr.add(block * 64),
lo_tbl,
hi_tbl,
nib,
op_bits,
ws_bits,
zero,
quote_v,
bs_v,
);
let structurals = carries.block_structurals(bs, quote, op, ws);
flatten_bits::<PACK>(out, (block * 64) as u32, structurals, ptr.add(block * 64));
}
let rem = len % 64;
if rem != 0 {
let mut buf = [0u8; 64];
buf[..rem].copy_from_slice(&input[len - rem..]);
let (bs, quote, op, ws) = block_masks(
buf.as_ptr(),
lo_tbl,
hi_tbl,
nib,
op_bits,
ws_bits,
zero,
quote_v,
bs_v,
);
let structurals =
carries.block_structurals(bs, quote, op, ws) & (u64::MAX >> (64 - rem));
flatten_bits::<PACK>(out, (len - rem) as u32, structurals, buf.as_ptr());
}
}
}
}
pub const PACKED_INDEX_MAX_LEN: usize = 1 << 24;
pub const INDEX_MAX_LEN: usize = u32::MAX as usize;
#[inline]
const fn index_len_ok(len: usize, packed: bool) -> bool {
if packed {
len < PACKED_INDEX_MAX_LEN
} else {
len <= INDEX_MAX_LEN
}
}
#[inline(always)]
fn index_dispatch<const PACK: bool>(input: &[u8], out: &mut Vec<u32>) {
#[cfg(target_arch = "aarch64")]
{
index_driver::<PACK>(input, out, |ptr| {
unsafe { neon::classify_block(ptr) }
});
}
#[cfg(target_arch = "x86_64")]
{
if std::is_x86_feature_detected!("avx2") {
unsafe { avx2::index_avx2::<PACK>(input, out) };
} else {
index_driver::<PACK>(input, out, |ptr| {
unsafe { sse2::classify_block(ptr) }
});
}
}
#[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
{
index_scalar_impl::<PACK>(input, out);
}
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
#[inline(always)]
fn index_driver<const PACK: bool>(
input: &[u8],
out: &mut Vec<u32>,
classify: impl Fn(*const u8) -> BlockMasks,
) {
out.clear();
out.reserve(input.len() + 8);
let mut carries = Carries::default();
let len = input.len();
let full_blocks = len / 64;
let ptr = input.as_ptr();
for block in 0..full_blocks {
let m = classify(input[block * 64..].as_ptr());
let structurals = carries.block_structurals(m.backslash, m.quote, m.op, m.ws);
flatten_bits::<PACK>(out, (block * 64) as u32, structurals, unsafe {
ptr.add(block * 64)
});
}
let rem = len % 64;
if rem != 0 {
let mut buf = [0u8; 64];
buf[..rem].copy_from_slice(&input[len - rem..]);
let m = classify(buf.as_ptr());
let structurals =
carries.block_structurals(m.backslash, m.quote, m.op, m.ws) & (u64::MAX >> (64 - rem));
flatten_bits::<PACK>(out, (len - rem) as u32, structurals, buf.as_ptr());
}
}
pub fn index(input: &[u8], out: &mut Vec<u32>) {
assert!(
index_len_ok(input.len(), false),
"input too large for u32 index offsets; use the fused cursor"
);
index_dispatch::<false>(input, out);
}
#[cfg(test)]
pub fn index_packed(input: &[u8], out: &mut Vec<u32>) {
assert!(
index_len_ok(input.len(), true),
"input too large for the packed index encoding (24-bit offsets)"
);
index_dispatch::<true>(input, out);
}
pub(crate) fn container_end(input: &[u8], start: usize) -> Option<usize> {
#[cfg(target_arch = "aarch64")]
{
container_end_driver(input, start, |ptr| {
unsafe { neon::classify_block(ptr) }
})
}
#[cfg(target_arch = "x86_64")]
{
if std::is_x86_feature_detected!("avx2") {
unsafe { avx2::container_end_avx2(input, start) }
} else {
container_end_driver(input, start, |ptr| {
unsafe { sse2::classify_block(ptr) }
})
}
}
#[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
{
container_end_scalar(input, start)
}
}
#[cfg(any(target_arch = "aarch64", target_arch = "x86_64"))]
fn container_end_driver(
input: &[u8],
start: usize,
classify: impl Fn(*const u8) -> BlockMasks,
) -> Option<usize> {
debug_assert!(matches!(input.get(start), Some(b'{' | b'[')));
let mut carries = Carries::default();
let mut depth = 0usize;
let mut block = start & !63;
let mut live = u64::MAX << (start - block);
while block < input.len() {
let masks = if block + 64 <= input.len() {
classify(input[block..].as_ptr())
} else {
let mut buf = [0u8; 64];
buf[..input.len() - block].copy_from_slice(&input[block..]);
classify(buf.as_ptr())
};
let mut ops =
carries.block_ops(masks.backslash & live, masks.quote & live, masks.op & live);
live = u64::MAX;
while ops != 0 {
let bit = ops.trailing_zeros() as usize;
ops &= ops - 1;
match input[block + bit] {
b'{' | b'[' => depth += 1,
b'}' | b']' => {
depth -= 1;
if depth == 0 {
return Some(block + bit + 1);
}
}
_ => {} }
}
block += 64;
}
None
}
#[cfg(not(any(target_arch = "aarch64", target_arch = "x86_64")))]
fn container_end_scalar(input: &[u8], start: usize) -> Option<usize> {
debug_assert!(matches!(input.get(start), Some(b'{' | b'[')));
let mut depth = 0usize;
let mut i = start;
while i < input.len() {
match input[i] {
b'"' => {
i += 1;
loop {
match input.get(i)? {
b'\\' => i += 2,
b'"' => break,
_ => i += 1,
}
}
}
b'{' | b'[' => depth += 1,
b'}' | b']' => {
depth -= 1;
if depth == 0 {
return Some(i + 1);
}
}
_ => {}
}
i += 1;
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn index_length_limits() {
assert!(index_len_ok(0, false));
assert!(index_len_ok(0, true));
assert!(index_len_ok(INDEX_MAX_LEN, false));
assert!(!index_len_ok(INDEX_MAX_LEN + 1, false));
assert!(index_len_ok(PACKED_INDEX_MAX_LEN - 1, true));
assert!(!index_len_ok(PACKED_INDEX_MAX_LEN, true));
}
fn both(input: &[u8]) -> (Vec<u32>, Vec<u32>) {
let mut s = Vec::new();
let mut v = Vec::new();
index_scalar(input, &mut s);
index(input, &mut v);
(s, v)
}
fn assert_match(input: &[u8]) {
let (s, v) = both(input);
assert_eq!(
s,
v,
"scalar vs simd mismatch for {:?}",
String::from_utf8_lossy(input)
);
}
fn offsets(input: &[u8]) -> Vec<u32> {
let (s, v) = both(input);
assert_eq!(s, v);
s
}
#[test]
fn simple_object() {
assert_eq!(offsets(br#"{"a":1}"#), vec![0, 1, 4, 5, 6]);
}
#[test]
fn strings_hide_structurals() {
assert_eq!(offsets(br#"["{a:1},[]"]"#), vec![0, 1, 11]);
}
#[test]
fn escaped_quote_stays_in_string() {
assert_eq!(offsets(br#"["a\"b"]"#), vec![0, 1, 7]);
}
#[test]
fn escaped_backslash_then_quote_ends_string() {
assert_eq!(offsets(br#"["a\\",1]"#), vec![0, 1, 6, 7, 8]);
}
#[test]
fn scalar_run_indexed_once() {
assert_eq!(offsets(b"[true,null,123.45]"), vec![0, 1, 5, 6, 10, 11, 17]);
}
#[test]
fn whitespace_between_tokens() {
assert_eq!(offsets(b" { \"k\" : 42 } "), vec![1, 3, 7, 9, 12]);
}
#[test]
fn cross_block_string() {
let mut doc = Vec::from(&br#"{"key":""#[..]);
doc.extend(std::iter::repeat_n(b'x', 100));
doc.extend(br#"","z":1}"#);
assert_match(&doc);
}
#[test]
fn cross_block_escapes() {
for pad in 55..70 {
let mut doc = Vec::from(&b"[\""[..]);
doc.extend(std::iter::repeat_n(b'a', pad));
doc.extend(br#"\\\""#);
doc.extend(br#"tail"]"#);
assert_match(&doc);
}
}
#[test]
fn benchmark_files_match() {
for name in ["twitter", "canada", "citm_catalog", "tolstoy", "numbers"] {
let path = format!(
"{}/../../benchmark/{}.json",
env!("CARGO_MANIFEST_DIR"),
name
);
if let Ok(data) = std::fs::read(&path) {
assert_match(&data);
}
}
}
#[test]
fn packed_matches_unpacked() {
let mut docs: Vec<Vec<u8>> = vec![
br#"{"a":[1,"b\\n",true],"c":null}"#.to_vec(),
b" [1,2,3] ".to_vec(),
];
for name in ["twitter", "canada", "tolstoy"] {
let path = format!(
"{}/../../benchmark/{}.json",
env!("CARGO_MANIFEST_DIR"),
name
);
if let Ok(data) = std::fs::read(&path) {
docs.push(data);
}
}
for doc in &docs {
let (mut plain, mut packed) = (Vec::new(), Vec::new());
index(doc, &mut plain);
index_packed(doc, &mut packed);
assert_eq!(plain.len(), packed.len());
for (&p, &q) in plain.iter().zip(packed.iter()) {
assert_eq!(q >> 8, p, "offset mismatch");
assert_eq!((q & 0xFF) as u8, doc[p as usize], "byte mismatch at {p}");
}
}
}
#[test]
fn block_boundary_sweep() {
for pos in 0..200 {
let mut doc = vec![b' '; pos];
doc.extend(br#"{"a":[1,"b\\n",true]}"#);
assert_match(&doc);
}
}
}