From 239751b7380d6d3a045181138559f1561d9daf5d Mon Sep 17 00:00:00 2001 From: cijiugechu Date: Wed, 18 Nov 2026 00:50:08 +0800 Subject: [PATCH] perf(base32): optimize bulk scalar quanta --- bases/src/backend/base32.rs | 72 ++++++++++++++++++++++++++-- bases/src/backend/base32/arch/mod.rs | 18 +++---- bases/src/backend/base32/arch/x86.rs | 22 ++++----- 3 files changed, 90 insertions(+), 22 deletions(-) diff --git a/bases/src/backend/base32.rs b/bases/src/backend/base32.rs index 0d77b69..6878811 100644 --- a/bases/src/backend/base32.rs +++ b/bases/src/backend/base32.rs @@ -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"; @@ -217,7 +219,13 @@ pub fn encode(input.len()).expect("encoded length overflow"); assert!(output.len() >= required, "output buffer too small"); - let (input_index, output_index) = arch::encode::(input, output); + let (input_index, output_index) = match arch::encode::(input, output) { + Some(progress) => progress, + None if input.len() >= SCALAR_BULK_QUANTA * 5 => { + return encode_scalar_bulk::(input, output); + } + None => (0, 0), + }; encode_scalar_from::(input, output, input_index, output_index) } @@ -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::(&input[..plan.complete_len], out); + let (input_index, output_index) = match arch::decode::( + &input[..plan.complete_len], + out, + ) { + Some(progress) => progress, + None if plan.complete_len >= SCALAR_BULK_QUANTA * 8 => { + return decode_scalar_bulk::(input, plan, out); + } + None => (0, 0), + }; decode_from::( input, out, @@ -382,6 +398,26 @@ fn encode_quantum_5(alphabet: &[u8; 32], b: &[u8; 5]) -> [u8; 8] { ] } +#[inline(never)] +fn encode_scalar_bulk( + input: &[u8], + output: &mut [MaybeUninit], +) -> usize { + let alphabet = select_alphabet::(); + 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::( + input, + output, + quanta.len() * 5, + complete_output_len, + ) +} + fn encode_scalar_from( input: &[u8], output: &mut [MaybeUninit], @@ -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( + input: &[u8], + plan: DecodePlan, + output: &mut [MaybeUninit], +) -> Result { + let lut = select_decode_lut::(); + 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::( + 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, diff --git a/bases/src/backend/base32/arch/mod.rs b/bases/src/backend/base32/arch/mod.rs index 8e25676..77c55a2 100644 --- a/bases/src/backend/base32/arch/mod.rs +++ b/bases/src/backend/base32/arch/mod.rs @@ -28,14 +28,14 @@ mod x86; pub fn encode( input: &[u8], output: &mut [MaybeUninit], -) -> (usize, usize) { +) -> Option<(usize, usize)> { if cfg!(miri) { - return (0, 0); + return None; } #[cfg(all(target_arch = "aarch64", target_feature = "neon"))] { - return aarch64::encode::(input, output); + return Some(aarch64::encode::(input, output)); } #[cfg(all( @@ -49,21 +49,23 @@ pub fn encode( #[allow(unreachable_code)] let _ = (input, output); #[allow(unreachable_code)] - (0, 0) + None } #[inline] pub fn decode( input: &[u8], output: &mut [MaybeUninit], -) -> (usize, usize) { +) -> Option<(usize, usize)> { if cfg!(miri) { - return (0, 0); + return None; } #[cfg(all(target_arch = "aarch64", target_feature = "neon"))] { - return aarch64::decode::(input, output); + return Some(aarch64::decode::( + input, output, + )); } #[cfg(all( @@ -77,7 +79,7 @@ pub fn decode() -> [i8 pub fn encode( input: &[u8], output: &mut [MaybeUninit], -) -> (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::(input, output) } + Some(unsafe { encode_avx2::(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::(input, output) } + Some(unsafe { encode_avx2::(input, output) }) } else if is_x86_feature_detected!("ssse3") { // SAFETY: Runtime feature detection confirmed SSSE3 support. - unsafe { encode_ssse3::(input, output) } + Some(unsafe { encode_ssse3::(input, output) }) } else { let _ = (input, output); - (0, 0) + None } } @@ -159,7 +159,7 @@ pub fn encode( ))] { // SAFETY: `target_feature = "ssse3"` is enabled at compile time. - unsafe { encode_ssse3::(input, output) } + Some(unsafe { encode_ssse3::(input, output) }) } } @@ -167,10 +167,10 @@ pub fn encode( pub fn decode( input: &[u8], output: &mut [MaybeUninit], -) -> (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(); @@ -208,7 +208,7 @@ pub fn decode