Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
72 changes: 69 additions & 3 deletions bases/src/backend/base32.rs
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,8 @@ use crate::codec;
#[allow(unsafe_code)]
mod arch;

const SCALAR_BULK_QUANTA: usize = 32;

const STANDARD_UPPER: &[u8; 32] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
const STANDARD_LOWER: &[u8; 32] = b"abcdefghijklmnopqrstuvwxyz234567";
const HEX_UPPER: &[u8; 32] = b"0123456789ABCDEFGHIJKLMNOPQRSTUV";
Expand Down Expand Up @@ -217,7 +219,13 @@ pub fn encode<const EXTENDED_HEX: bool, const PADDED: bool, const UPPERCASE: boo
let required = encoded_len::<PADDED>(input.len()).expect("encoded length overflow");
assert!(output.len() >= required, "output buffer too small");

let (input_index, output_index) = arch::encode::<EXTENDED_HEX, UPPERCASE>(input, output);
let (input_index, output_index) = match arch::encode::<EXTENDED_HEX, UPPERCASE>(input, output) {
Some(progress) => progress,
None if input.len() >= SCALAR_BULK_QUANTA * 5 => {
return encode_scalar_bulk::<EXTENDED_HEX, PADDED, UPPERCASE>(input, output);
}
None => (0, 0),
};
encode_scalar_from::<EXTENDED_HEX, PADDED, UPPERCASE>(input, output, input_index, output_index)
}

Expand Down Expand Up @@ -251,8 +259,16 @@ pub fn decode_with_plan<
assert!(output.len() >= plan.required, "output buffer too small");
let out = &mut output[..plan.required];

let (input_index, output_index) =
arch::decode::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>(&input[..plan.complete_len], out);
let (input_index, output_index) = match arch::decode::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>(
&input[..plan.complete_len],
out,
) {
Some(progress) => progress,
None if plan.complete_len >= SCALAR_BULK_QUANTA * 8 => {
return decode_scalar_bulk::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>(input, plan, out);
}
None => (0, 0),
};
decode_from::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>(
input,
out,
Expand Down Expand Up @@ -382,6 +398,26 @@ fn encode_quantum_5(alphabet: &[u8; 32], b: &[u8; 5]) -> [u8; 8] {
]
}

#[inline(never)]
fn encode_scalar_bulk<const EXTENDED_HEX: bool, const PADDED: bool, const UPPERCASE: bool>(
input: &[u8],
output: &mut [MaybeUninit<u8>],
) -> usize {
let alphabet = select_alphabet::<EXTENDED_HEX, UPPERCASE>();
let (quanta, _) = input.as_chunks::<5>();
let complete_output_len = quanta.len() * 8;
let complete_output = &mut output[..complete_output_len];
for (src, dst) in quanta.iter().zip(complete_output.as_chunks_mut::<8>().0) {
backend::write_bytes(dst, encode_quantum_5(alphabet, src));
}
encode_scalar_from::<EXTENDED_HEX, PADDED, UPPERCASE>(
input,
output,
quanta.len() * 5,
complete_output_len,
)
}

fn encode_scalar_from<const EXTENDED_HEX: bool, const PADDED: bool, const UPPERCASE: bool>(
input: &[u8],
output: &mut [MaybeUninit<u8>],
Expand Down Expand Up @@ -476,6 +512,36 @@ fn decode_chunk_8(lut: &[u8; 256], s: &[u8; 8]) -> Option<[u8; 5]> {
Some([b0, b1, b2, b3, packed as u8])
}

#[inline(never)]
fn decode_scalar_bulk<const EXTENDED_HEX: bool, const UPPERCASE: bool, const STRICT_CASE: bool>(
input: &[u8],
plan: DecodePlan,
output: &mut [MaybeUninit<u8>],
) -> Result<usize, DecodeError> {
let lut = select_decode_lut::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>();
let (quanta, _) = input[..plan.complete_len].as_chunks::<8>();
let complete_output_len = quanta.len() * 5;
let complete_output = &mut output[..complete_output_len];
for (chunk_index, (src, dst)) in quanta
.iter()
.zip(complete_output.as_chunks_mut::<5>().0)
.enumerate()
{
let Some(decoded) = decode_chunk_8(lut, src) else {
return Err(find_invalid_in_quantum(src, chunk_index * 8, lut));
};
backend::write_bytes(dst, decoded);
}
decode_from::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>(
input,
output,
plan.data_len,
plan.complete_len,
plan.complete_len,
complete_output_len,
)
}

fn decode_scalar_complete_from<
const EXTENDED_HEX: bool,
const UPPERCASE: bool,
Expand Down
18 changes: 10 additions & 8 deletions bases/src/backend/base32/arch/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -28,14 +28,14 @@ mod x86;
pub fn encode<const EXTENDED_HEX: bool, const UPPERCASE: bool>(
input: &[u8],
output: &mut [MaybeUninit<u8>],
) -> (usize, usize) {
) -> Option<(usize, usize)> {
if cfg!(miri) {
return (0, 0);
return None;
}

#[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
{
return aarch64::encode::<EXTENDED_HEX, UPPERCASE>(input, output);
return Some(aarch64::encode::<EXTENDED_HEX, UPPERCASE>(input, output));
}

#[cfg(all(
Expand All @@ -49,21 +49,23 @@ pub fn encode<const EXTENDED_HEX: bool, const UPPERCASE: bool>(
#[allow(unreachable_code)]
let _ = (input, output);
#[allow(unreachable_code)]
(0, 0)
None
}

#[inline]
pub fn decode<const EXTENDED_HEX: bool, const UPPERCASE: bool, const STRICT_CASE: bool>(
input: &[u8],
output: &mut [MaybeUninit<u8>],
) -> (usize, usize) {
) -> Option<(usize, usize)> {
if cfg!(miri) {
return (0, 0);
return None;
}

#[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
{
return aarch64::decode::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>(input, output);
return Some(aarch64::decode::<EXTENDED_HEX, UPPERCASE, STRICT_CASE>(
input, output,
));
}

#[cfg(all(
Expand All @@ -77,7 +79,7 @@ pub fn decode<const EXTENDED_HEX: bool, const UPPERCASE: bool, const STRICT_CASE
#[allow(unreachable_code)]
let _ = (input, output);
#[allow(unreachable_code)]
(0, 0)
None
}

#[inline]
Expand Down
22 changes: 11 additions & 11 deletions bases/src/backend/base32/arch/x86.rs
Original file line number Diff line number Diff line change
Expand Up @@ -127,28 +127,28 @@ const fn select_hi_mask<const UPPERCASE: bool, const STRICT_CASE: bool>() -> [i8
pub fn encode<const EXTENDED_HEX: bool, const UPPERCASE: bool>(
input: &[u8],
output: &mut [MaybeUninit<u8>],
) -> (usize, usize) {
) -> Option<(usize, usize)> {
if input.len() < 16 || output.len() < 16 {
return (0, 0);
return Some((0, 0));
}

#[cfg(target_feature = "avx2")]
{
// SAFETY: `target_feature = "avx2"` is enabled at compile time.
unsafe { encode_avx2::<EXTENDED_HEX, UPPERCASE>(input, output) }
Some(unsafe { encode_avx2::<EXTENDED_HEX, UPPERCASE>(input, output) })
}

#[cfg(all(not(target_feature = "avx2"), feature = "std"))]
{
if is_x86_feature_detected!("avx2") {
// SAFETY: Runtime feature detection confirmed AVX2 support.
unsafe { encode_avx2::<EXTENDED_HEX, UPPERCASE>(input, output) }
Some(unsafe { encode_avx2::<EXTENDED_HEX, UPPERCASE>(input, output) })
} else if is_x86_feature_detected!("ssse3") {
// SAFETY: Runtime feature detection confirmed SSSE3 support.
unsafe { encode_ssse3::<EXTENDED_HEX, UPPERCASE>(input, output) }
Some(unsafe { encode_ssse3::<EXTENDED_HEX, UPPERCASE>(input, output) })
} else {
let _ = (input, output);
(0, 0)
None
}
}

Expand All @@ -159,18 +159,18 @@ pub fn encode<const EXTENDED_HEX: bool, const UPPERCASE: bool>(
))]
{
// SAFETY: `target_feature = "ssse3"` is enabled at compile time.
unsafe { encode_ssse3::<EXTENDED_HEX, UPPERCASE>(input, output) }
Some(unsafe { encode_ssse3::<EXTENDED_HEX, UPPERCASE>(input, output) })
}
}

#[inline]
pub fn decode<const EXTENDED_HEX: bool, const UPPERCASE: bool, const STRICT_CASE: bool>(
input: &[u8],
output: &mut [MaybeUninit<u8>],
) -> (usize, usize) {
) -> Option<(usize, usize)> {
let chunks_16 = (input.len() / 16).min(output.len() / 10);
if chunks_16 == 0 {
return (0, 0);
return Some((0, 0));
}

let in_ptr = input.as_ptr();
Expand Down Expand Up @@ -208,7 +208,7 @@ pub fn decode<const EXTENDED_HEX: bool, const UPPERCASE: bool, const STRICT_CASE
}
} else {
let _ = (in_ptr, out_ptr, out_len);
0
return None;
}
}

Expand All @@ -228,7 +228,7 @@ pub fn decode<const EXTENDED_HEX: bool, const UPPERCASE: bool, const STRICT_CASE
}
};

(done_16 * 16, done_16 * 10)
Some((done_16 * 16, done_16 * 10))
}

#[inline]
Expand Down
Loading