tree: 82f205222e2fe6fcbd2b3a63a8df401dd0e49a62 [path history] [tgz]
  1. .cargo-checksum.json
  2. .travis.yml
  3. Cargo.toml
  4. LICENSE.Apache2
  7. appveyor.yml
  8. benches/
  9. src/
  10. tests/


Counting bytes really fast

Build Status Windows build status Current Version License: Apache 2.0/MIT

This uses the “hyperscreamingcount” algorithm by Joshua Landau to count bytes faster than anything else. The newlinebench repository has further benchmarks.

To use bytecount in your crate, if you have cargo-edit, just type cargo add bytecount in a terminal with the crate root as the current path. Otherwise you can manually edit your Cargo.toml to add bytecount = 0.3.2 to your [dependencies] section.

In your crate root ( or, depending on if you are writing a library or application), add extern crate bytecount;. Now you can simply use bytecount::count as follows:

extern crate bytecount;

fn main() {
    let mytext = "some potentially large text, perhaps read from disk?";
    let spaces = bytecount::count(mytext.as_bytes(), b' ');

bytecount supports two features to make use of modern CPU's features to speed up counting considerably. To allow your users to use them, add the following to your Cargo.toml:

avx-accel = ["bytecount/avx-accel"]
simd-accel = ["bytecount/simd-accel"]

Now your users can compile with SSE support (available on most modern x86_64 processors) using:

cargo build --release --features simd-accel

Or even with AVX support (which likely requires compiling for the native target CPU):

RUSTFLAGS="-C target-cpu=native" cargo build --release --features "simd-accel avx-accel"

The algorithm is explained in depth here.

Note that for very short slices, the data parallelism will likely not win much performance gains. In those cases, a naive count with a 32-bit counter may be a superior solution, unless counting really large byte slices.


Licensed under either of at your discretion: