Optimize remainder validation

.github/workflows/ci.yml

@@ -35,6 +35,23 @@ jobs:
         env:
           RUSTFLAGS: ${{ matrix.rustflags }}
 
+  test-arm64:
+    runs-on: ARM64
+    strategy:
+      matrix:
+        features: ["", "--features std", "--features aarch64_neon,std", "--features aarch64_neon,std,public_imp", "--features aarch64_neon,std,public_imp"]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+            toolchain: nightly
+            profile: minimal
+            override: true
+      - name: Run tests
+        run: cargo test --no-default-features ${{ matrix.features }} --all-targets --verbose
+        env:
+          RUSTFLAGS: ${{ matrix.rustflags }}
+
   test-inlining-x86:
     runs-on: ubuntu-latest
     strategy:
@@ -106,12 +123,12 @@ jobs:
         env:
           RUSTDOCFLAGS: --cfg docsrs
 
-  cross-build-arm:
+  cross-build-arm32:
     runs-on: ubuntu-latest
     strategy:
       matrix:
         toolchain: ["1.38.0", stable, beta, nightly ]
-        target: [arm-unknown-linux-gnueabi, aarch64-unknown-linux-gnu]
+        target: [arm-unknown-linux-gnueabi]
         features: ["--features std", ""]
         include:
           - toolchain: nightly
@@ -172,7 +189,10 @@ jobs:
         run: cargo fmt -- --check
 
   clippy_check:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      matrix:
+        runner: [ubuntu-latest, ARM64]
     steps:
       - uses: actions/checkout@v1
       - uses: actions-rs/toolchain@v1

bench/Cargo.toml

@@ -17,6 +17,7 @@ core_affinity = "0.5"
 criterion = "0.3"
 simdutf8 = { version = "*", path = "..", features = ["aarch64_neon"] }
 simdjson-utf8 = { version = "*", path = "simdjson-utf8", optional = true }
+rand = "0.8"
 
 [[bench]]
 name = "throughput_basic"
@@ -37,4 +38,16 @@ harness = false
 [[bench]]
 name = "throughput_simdjson"
 harness = false
-required-features = ["simdjson"]
+required-features = ["simdjson"]
+
+[[bench]]
+name = "small_basic"
+harness = false
+
+[[bench]]
+name = "small_compat"
+harness = false
+
+[[bench]]
+name = "small_std"
+harness = false

bench/benches/small_basic.rs

@@ -0,0 +1,3 @@
+use simdutf8_bench::define_small_benchmark;
+
+define_small_benchmark!(BenchFn::Basic);

bench/benches/small_compat.rs

@@ -0,0 +1,3 @@
+use simdutf8_bench::define_small_benchmark;
+
+define_small_benchmark!(BenchFn::Compat);

bench/benches/small_std.rs

@@ -0,0 +1,3 @@
+use simdutf8_bench::define_small_benchmark;
+
+define_small_benchmark!(BenchFn::Std);

bench/src/lib.rs

@@ -62,6 +62,37 @@ pub fn criterion_benchmark<M: Measurement>(c: &mut Criterion<M>, bench_fn: Bench
     bench_late_error(c, bench_fn);
 }
 
+pub fn criterion_benchmark_small<M: Measurement>(c: &mut Criterion<M>, bench_fn: BenchFn) {
+    let core_ids = core_affinity::get_core_ids().unwrap();
+    core_affinity::set_for_current(*core_ids.get(2).unwrap_or(&core_ids[0]));
+
+    bench_small(
+        c,
+        "1-latin",
+        &scale_to_one_mib(include_bytes!("../data/Latin-Lipsum.txt")),
+        bench_fn,
+    );
+
+    bench_small(
+        c,
+        "2-cyrillic",
+        &scale_to_one_mib(include_bytes!("../data/Russian-Lipsum.txt")),
+        bench_fn,
+    );
+    bench_small(
+        c,
+        "3-chinese",
+        &scale_to_one_mib(include_bytes!("../data/Chinese-Lipsum.txt")),
+        bench_fn,
+    );
+    bench_small(
+        c,
+        "4-emoji",
+        &scale_to_one_mib(include_bytes!("../data/Emoji-Lipsum.txt")),
+        bench_fn,
+    );
+}
+
 fn bench_empty<M: Measurement>(c: &mut Criterion<M>, bench_fn: BenchFn) {
     let mut group = c.benchmark_group("0-empty");
     bench_input(&mut group, b"", false, true, bench_fn);
@@ -129,6 +160,70 @@ fn bench<M: Measurement>(c: &mut Criterion<M>, name: &str, bytes: &[u8], bench_f
     group.finish();
 }
 
+fn bench_small<M: Measurement>(c: &mut Criterion<M>, name: &str, bytes: &[u8], bench_fn: BenchFn) {
+    let mut group = c.benchmark_group(name);
+    bench_range(&mut group, bytes, 0, 16, bench_fn);
+    bench_range(&mut group, bytes, 16, 32, bench_fn);
+    bench_range(&mut group, bytes, 32, 64, bench_fn);
+    bench_range(&mut group, bytes, 64, 128, bench_fn);
+    bench_range(&mut group, bytes, 128, 256, bench_fn);
+    group.finish();
+}
+
+fn gen_valid_in_range(bytes: &[u8], lower_limit: usize, upper_limit: usize) -> usize {
+    use rand::Rng;
+    let mut rng = rand::thread_rng();
+    loop {
+        let x = rng.gen_range(lower_limit..upper_limit);
+        if std_from_utf8(&bytes[0..x]).is_ok() {
+            return x;
+        }
+    }
+}
+
+fn bench_range<T: Measurement>(
+    group: &mut BenchmarkGroup<T>,
+    bytes: &[u8],
+    lower_limit: usize,
+    upper_limit: usize,
+    bench_fn: BenchFn,
+) {
+    let bench_id = format!("rand_{:03}-{:03}", lower_limit, upper_limit);
+    let gen_fn = || gen_valid_in_range(bytes, lower_limit, upper_limit);
+    match bench_fn {
+        BenchFn::Basic => {
+            group.bench_function(bench_id, |b| {
+                b.iter_batched(
+                    gen_fn,
+                    |x| assert!(basic_from_utf8(&bytes[0..x]).is_ok()),
+                    criterion::BatchSize::SmallInput,
+                )
+            });
+        }
+        BenchFn::Compat => {
+            group.bench_function(bench_id, |b| {
+                b.iter_batched(
+                    gen_fn,
+                    |x| assert!(compat_from_utf8(&bytes[0..x]).is_ok()),
+                    criterion::BatchSize::SmallInput,
+                )
+            });
+        }
+        BenchFn::Std => {
+            group.bench_function(bench_id, |b| {
+                b.iter_batched(
+                    gen_fn,
+                    |x| assert!(std_from_utf8(&bytes[0..x]).is_ok()),
+                    criterion::BatchSize::SmallInput,
+                )
+            });
+        }
+        _ => {
+            unimplemented!();
+        }
+    }
+}
+
 #[inline(never)]
 fn basic_from_utf8_no_inline(v: &[u8]) -> bool {
     basic_from_utf8(v).is_ok()

bench/src/macros.rs

@@ -8,14 +8,38 @@ macro_rules! define_throughput_benchmark {
 
         use simdutf8_bench::*;
 
-        fn benchmark_compat<M: Measurement>(c: &mut Criterion<M>) {
+        fn benchmark_throughput<M: Measurement>(c: &mut Criterion<M>) {
             criterion_benchmark(c, $bench_fn);
         }
 
         criterion_group!(
             name = benches;
             config = Criterion::default().measurement_time(Duration::from_secs(1)).warm_up_time(Duration::from_secs(1)).sample_size(300);
-            targets = benchmark_compat
+            targets = benchmark_throughput
+        );
+
+        criterion_main!(benches);
+    };
+}
+
+#[macro_export]
+macro_rules! define_small_benchmark {
+    ($bench_fn:expr) => {
+        use std::time::Duration;
+
+        use criterion::measurement::Measurement;
+        use criterion::{criterion_group, criterion_main, Criterion};
+
+        use simdutf8_bench::*;
+
+        fn benchmark_small<M: Measurement>(c: &mut Criterion<M>) {
+            criterion_benchmark_small(c, $bench_fn);
+        }
+
+        criterion_group!(
+            name = benches;
+            config = Criterion::default().measurement_time(Duration::from_secs(1)).warm_up_time(Duration::from_secs(1)).sample_size(300);
+            targets = benchmark_small
         );
 
         criterion_main!(benches);

examples/streaming.rs

@@ -1,11 +1,9 @@
-#[cfg(feature = "public_imp")]
-use simdutf8::basic::imp::Utf8Validator;
-
 #[allow(unused_imports)]
 use std::io::{stdin, Read, Result};
 
-#[cfg(feature = "public_imp")]
+#[cfg(all(feature = "public_imp", target_arch = "x86_64"))]
 fn main() -> Result<()> {
+    use simdutf8::basic::imp::Utf8Validator;
     unsafe {
         if !std::is_x86_feature_detected!("avx2") {
             panic!("This example only works with CPUs supporting AVX 2");
@@ -32,5 +30,5 @@ fn main() -> Result<()> {
 }
 
 /// Dummy main. This example requires the crate feature `public_imp`.
-#[cfg(not(feature = "public_imp"))]
+#[cfg(not(all(feature = "public_imp", target_arch = "x86_64")))]
 fn main() {}

src/basic.rs

@@ -77,6 +77,11 @@ pub mod imp {
     /// use simdutf8::basic::imp::Utf8Validator;
     /// use std::io::{stdin, Read, Result};
     ///
+    /// # #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
+    /// # fn main() {
+    /// # }
+    ///
+    /// # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
     /// fn main() -> Result<()> {
     ///     unsafe {
     ///         if !std::is_x86_feature_detected!("avx2") {

src/implementation/aarch64/mod.rs

@@ -5,10 +5,6 @@ pub(crate) mod neon;
 #[inline]
 #[cfg(all(feature = "aarch64_neon", target_feature = "neon"))]
 pub(crate) unsafe fn validate_utf8_basic(input: &[u8]) -> Result<(), crate::basic::Utf8Error> {
-    if input.len() < super::helpers::SIMD_CHUNK_SIZE {
-        return super::validate_utf8_basic_fallback(input);
-    }
-
     validate_utf8_basic_neon(input)
 }
 
@@ -24,10 +20,6 @@ pub(crate) use super::validate_utf8_basic_fallback as validate_utf8_basic;
 #[inline]
 #[cfg(all(feature = "aarch64_neon", target_feature = "neon"))]
 pub(crate) unsafe fn validate_utf8_compat(input: &[u8]) -> Result<(), crate::compat::Utf8Error> {
-    if input.len() < super::helpers::SIMD_CHUNK_SIZE {
-        return super::validate_utf8_compat_fallback(input);
-    }
-
     validate_utf8_compat_neon(input)
 }