Struct rolling_dual_crc::Zeros

pub struct Zeros { /* fields omitted */ }

Efficient representation of a 0u8 sequence for DualCrc::update_with_zeros.

Examples

Compute checksum of "Hello, World!" padded to 4 kiB by 0u8:

use rolling_dual_crc::{DualCrc, Zeros};

let data = "Hello, world!";
let padding_size = 4096 - data.as_bytes().len();

let mut crc = DualCrc::new();
crc.update(data);
// This is equivalent to `crc.update(&vec![0u8; padding_size])`
// but more efficient with long sequences.
crc.update_with_zeros(&Zeros::new(padding_size));
assert_eq!(crc.get32(), 0xCED9AB00);

Benchmarks

• These benchmarks are from cargo bench zeros with 3.4 GHz i5-3570K (Ivy Bridge, 3rd gen.).
• See crate index for main benchmarks.

In these benchmarks update and update_with_zeros use sequence lengths 64/256/1024 while Zeros::new uses sequence lengths 63/64/255/256/1023/1024 because its speed depends on the number of 1-bits in the sequence length. Low end (best) timings are with 2^n while high end (worst) timings are with 2^n-1.

Method	ns / ~64 B	ns / ~256 B	ns / ~1024 B	complexity
DualCrc::update	65	260	1000	Θ(n)
DualCrc::update_with_zeros	90	90	90	Θ(1)
Zeros::new	3 - 430	3 - 600	3 - 770	Θ(one_bits n)

• For short sequences update is always faster than update_with_zeros.
• For long sequences update_with_zeros with Zeros::new is always faster.
• For intermediate sequences situation depends on exact sequence length and also whether new Zeros is created for each update_with_zeros call, or if same Zeros is used with multiple update_with_zeros calls, amortizing its creation time.

Implementations

impl Zeros

pub fn new(byte_count: usize) -> Self

Creates a new Zeros which represents a sequence of byte_count 0u8:s.

Complexity: Θ(one_bits n) time, Θ(1) space

See Zeros for example.

Trait Implementations

impl Clone for Zeros

fn clone(&self) -> Zeros

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Zeros

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Zeros

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Copy for Zeros