bitsliced-op 0.8.0

This crate exposes bitsliced operations that can be used in reduction functions for rainbow tables.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

use std::time::{Duration, Instant};

struct BenchmarkResult {
    runs: u64,
    duration: Duration,
}

pub fn benchmark<F>(name: &str, runs: u64, warmup: u64, parallel_count: u64, mut func: F)
where
    F: FnMut(),
{
    for _ in 0..warmup {
        func();
    }
    let start = Instant::now();
    for _ in 0..runs {
        func();
    }
    let duration = start.elapsed();
    let result = BenchmarkResult { runs, duration };
    let operations_per_second =
        (result.runs as f64 / result.duration.as_secs_f64()) * parallel_count as f64;
    print_report(name, operations_per_second);
}

fn print_report(name: &str, hashes_per_second: f64) {
    println!(
        "{} ran at {}",
        name,
        format_operations_per_second(hashes_per_second)
    );
}

fn format_operations_per_second(hashes_per_second: f64) -> String {
    let gh_delimiter = 1_000_000_000.0;
    let mh_delimiter = 1_000_000.0;
    let kh_delimiter = 1_000.0;
    if hashes_per_second > gh_delimiter {
        format!("{:.2}GH/s", hashes_per_second / gh_delimiter)
    } else if hashes_per_second > mh_delimiter {
        format!("{:.2}MH/s", hashes_per_second / mh_delimiter)
    } else if hashes_per_second > kh_delimiter {
        format!("{:.2}KH/s", hashes_per_second / kh_delimiter)
    } else {
        format!("{:.2}H/s", hashes_per_second)
    }
}