add info about flags to readme

trifectatechfoundation · Dec 16, 2024 · d0031d8 · d0031d8
1 parent 4dda12a
commit d0031d8
Show file tree

Hide file tree

Showing 2 changed files with 67 additions and 5 deletions.
diff --git a/README.md b/README.md
@@ -5,7 +5,7 @@
 
 # zlib-rs: a safer zlib
 
-This repository contains a Rust implementation of the zlib file format that is compatible with the zlib API. 
+This repository contains a Rust implementation of the zlib file format that is compatible with the zlib API.
 
 This repository contains two public crates:
 
@@ -23,14 +23,43 @@ zlib-rs can be used in both Rust and C projects.
 By far the easiest way to use zlib-rs is through the [flate2](https://crates.io/crates/flate2) crate, by simply enabling the `zlib-rs` feature gate. This will enable the `zlib-rs`
 backend.
 
-## C projects
+### C projects
 
 zlib-rs can be built as a shared object file for usage by C programs that dynamically link to zlib. Please see the example in [libz-rs-sys-cdylib](https://github.com/trifectatechfoundation/zlib-rs/tree/main/libz-rs-sys-cdylib).
 
-## Acknowledgment
+## Performance
 
-This project is heavily based on the [zlib](https://github.com/madler/zlib) and
-[zlib-ng](https://github.com/zlib-ng/zlib-ng) projects.
+Performance is generally on-par with [zlib-ng].
+
+### Compiler Flags
+
+Compiler flags that can be used to improve performance.
+
+#### `-Ctarget-cpu=...`
+
+Providing more information about the SIMD capabilities of the target machine can improve performance. E.g.
+
+```
+RUSTFLAGS="-Ctarget-cpu=native" cargo build --release ...
+```
+
+The resulting binary statically assumes the SIMD capabilities of the current machine.
+
+Note: binaries built with `-Ctarget-cpu` almost certainly crash on systems that don't have the specified CPU! Only use this flag if you control how the binary is deployed, and can guarantee that the CPU assumptions are never violated.
+
+#### `-Cllvm-args=-enable-dfa-jump-thread`
+
+For best performance with very small input sizes, compile with:
+
+```
+RUSTFLAGS="-Cllvm-args=-enable-dfa-jump-thread" cargo build --release ...
+```
+
+This flag gives around a 10% boost when the input arrives in chunks of 16 bytes, and a couple percent when input arrives in chunks of under 1024 bytes. Beyond that, the effect is not significant. Using this flag can lead to longer compile times, but otherwise has no adverse effects.
+
+## Acknowledgments
+
+This project is heavily based on the [zlib](https://github.com/madler/zlib) and [zlib-ng] projects.
 
 ## About
 
@@ -39,3 +68,5 @@ zlib-rs is part of Trifecta Tech Foundation's [Data compression initiative](http
 ## History
 
 The initial development of zlib-rs was started and funded by the [Internet Security Research Group](https://www.abetterinternet.org/) as part of the [Prossimo project](https://www.memorysafety.org/).
+
+[zlib-ng]: https://github.com/zlib-ng/zlib-ng
diff --git a/libz-rs-sys-cdylib/README.md b/libz-rs-sys-cdylib/README.md
@@ -112,3 +112,34 @@ target
         ├── libz_rs.so
         └── libz_rs-uninstalled.pc
 ```
+
+## Performance
+
+Performance is generally on-par with [zlib-ng].
+
+### Compiler Flags
+
+Compiler flags that can be used to improve performance.
+
+#### `-Ctarget-cpu=...`
+
+Providing more information about the SIMD capabilities of the target machine can improve performance. E.g.
+
+```
+RUSTFLAGS="-Ctarget-cpu=native" cargo build --release ...
+```
+
+The resulting binary statically assumes the SIMD capabilities of the current machine.
+
+Note: binaries built with `-Ctarget-cpu` almost certainly crash on systems that don't have the specified CPU! Only use this flag if you control how the binary is deployed, and can guarantee that the CPU assumptions are never violated.
+
+#### `-Cllvm-args=-enable-dfa-jump-thread`
+
+For best performance with very small input sizes, compile with:
+
+```
+RUSTFLAGS="-Cllvm-args=-enable-dfa-jump-thread" cargo build --release ...
+```
+
+This flag gives around a 10% boost when the input arrives in chunks of 16 bytes, and a couple percent when input arrives in chunks of under 1024 bytes. Beyond that, the effect is not significant. Using this flag can lead to longer compile times, but otherwise has no adverse effects.
+