Merge branch 'v.next' of github.com:rusticstuff/simdutf8 into v.next

Author: hkratz

README.md

@@ -14,8 +14,8 @@ fuzzing and there are no known bugs.
 ## Features
 * `basic` API for the fastest validation, optimized for valid UTF-8
 * `compat` API as a fully compatible replacement for `std::str::from_utf8()`
-* Up to twenty times faster than the std library on non-ASCII, up to twice as fast on ASCII <-TBD!
-* Up to 28% faster on non-ASCII input compared to the original simdjson implementation on some CPUs
+* Up to 22 times faster than the std library on non-ASCII, up to three times faster on ASCII
+* As fast as or faster than the original simdjson implementation
 * Supports AVX 2 and SSE 4.2 implementations on x86 and x86-64. ARMv7 and ARMv8 neon support is planned
 * Selects the fastest implementation at runtime based on CPU support
 * Written in pure Rust
@@ -75,7 +75,7 @@ For no-std support (compiled with `--no-default-features`) the implementation is
 the targeted CPU. Use `RUSTFLAGS="-C target-feature=+avx2"` for the AVX 2 implementation or `RUSTFLAGS="-C target-feature=+sse4.2"`
 for the SSE 4.2 implementation.
 
-If you want to be able to call A SIMD implementation directly, use the `public_imp` feature flag. The validation
+If you want to be able to call a SIMD implementation directly, use the `public_imp` feature flag. The validation
 implementations are then accessible via `simdutf8::(basic|compat)::imp::x86::(avx2|sse42)::validate_utf8()`.
 
 ## When not to use
@@ -85,26 +85,34 @@ This library uses unsafe code which has not been battle-tested and should not (y
 This crate's minimum supported Rust version is 1.38.0.
 
 ## Benchmarks
-TBD!
 The benchmarks have been done with [criterion](https://bheisler.github.io/criterion.rs/book/index.html), the tables
 are created with [critcmp](https://github.com/BurntSushi/critcmp). Source code and data are in the
 [bench directory](https://github.com/rusticstuff/simdutf8/tree/main/bench).
 
 The name schema is id-charset/size. _0-empty_ is the empty byte slice, _x-error/66536_ is a 64KiB slice where the very
 first character is invalid UTF-8. All benchmarks were run on a laptop with an Intel Core i7-10750H CPU (Comet Lake) on
-Windows with Rust 1.51.0. Library versions are simdutf8 v0.1.0 and simdjson v0.9.2.
+Windows with Rust 1.51.0 if not otherwise stated. Library versions are simdutf8 v0.1.1 and simdjson v0.9.2. When comparing
+with simdjson simdutf8 is compiled with `#inline(never)`.
 
 ### simdutf8 basic vs std library UTF-8 validation
-![critcmp stimdutf8 basic vs std lib](https://raw.githubusercontent.com/rusticstuff/simdutf8/main/img/basic-vs-std.png)
-simdutf8 performs better except for inputs ≤ 64 bytes.
+![critcmp stimdutf8 v0.1.1 basic vs std lib](https://user-images.githubusercontent.com/3736990/116121179-a8271f80-a6c0-11eb-9b2b-6233c3c824f2.png)
+simdutf8 performs better or as well as the std library.
 
-### simdutf8 basic vs simdjson UTF-8 validation
-![critcmp st lib vs stimdutf8 basic](https://raw.githubusercontent.com/rusticstuff/simdutf8/main/img/basic-vs-simdjson.png)
-simdutf8 is faster than simdjson except for some crazy optimization by clang for the pure ASCII
-loop (to be investigated). simdjson is compiled using clang and gcc from MSYS.
+### simdutf8 basic vs simdjson UTF-8 validation on Intel Comet Lake
+![critcmp stimdutf8 v0.1.1 basic vs simdjson WSL](https://user-images.githubusercontent.com/3736990/116121748-38656480-a6c1-11eb-8cb4-385c7516a46a.png)
+simdutf8 beats simdjson on almost all inputs on this CPU. This benchmark is run on 
+[WSL](https://docs.microsoft.com/en-us/windows/wsl/install-win10) 
+since I could not get simdjson to reach maximum performance on Windows with any C++ toolchain (see also simdjson issues 
+[847](https://github.com/simdjson/simdjson/issues/847) and [848](https://github.com/simdjson/simdjson/issues/848)).
+
+### simdutf8 basic vs simdjson UTF-8 validation on AMD Zen 2
+![critcmp stimdutf8 v0.1.1 basic vs simdjson AMD Zen 2](https://user-images.githubusercontent.com/3736990/116122729-731bcc80-a6c2-11eb-82a5-6e297778a1c4.png)
+
+On AMD Zen 2 aligning reads apparently does not matter at all. The extra step for aligning even hurts performance a bit around
+an input size of 4096.
 
 ### simdutf8 basic vs simdutf8 compat UTF-8 validation
-![critcmp st lib vs stimdutf8 basic](https://raw.githubusercontent.com/rusticstuff/simdutf8/main/img/basic-vs-compat.png)
+![image](https://user-images.githubusercontent.com/3736990/116122427-0dc7db80-a6c2-11eb-8434-f9879742d90d.png)
 There is a small performance penalty to continuously checking the error status while processing data, but detecting
 errors early provides a huge benefit for the _x-error/66536_ benchmark.