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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::{arch::x86_64::_mm512_setzero_si512, env, hint::black_box};

use bitsliced_op::{
    benchmark::benchmark,
    bitsliced_add, bitsliced_add_inline, bitsliced_add_single_inline_avx_512,
    bitsliced_modulo_power_of_two, bitsliced_modulo_power_of_two_inline,
    des_reduction_inline_avx_512,
    transpose::{transpose_gfni, transpose_scalar},
    transpose_64x64,
};
use wide::u64x8;

fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        println!("Usage: bitsliced-op <benchmark_name>");
    }
    let benchmark_name = &args[1];
    start_benchmark(benchmark_name.as_str());
}

fn start_benchmark(benchmark_name: &str) {
    match benchmark_name {
        "na" | "normal_addition" => {
            benchmark("normal_addition", 1_000_000, 10000, 1, || {
                let result = black_box(1) + black_box(1);
                black_box(result);
            });
        }
        "ba" | "bitsliced_addition" => {
            let all_ones = u64x8::splat(0xFFFFFFFFFFFFFFFF);
            let zero = u64x8::ZERO;
            let mut a = [zero; 64];
            a[63] = all_ones;
            let mut b = [zero; 64];
            b[63] = all_ones;

            benchmark("bitsliced_addition", 1_000_000, 10000, 64, || {
                let _ = bitsliced_add(&a, &b);
            });
        }
        "bai" | "bitsliced_addition_inline" => {
            let all_ones = u64x8::splat(0xFFFFFFFFFFFFFFFF);
            let zero = u64x8::ZERO;
            let mut a = [zero; 64];
            a[63] = all_ones;
            let mut b = [zero; 64];
            b[63] = all_ones;

            benchmark("bitsliced_addition_inline", 1_000_000, 10000, 64, || {
                bitsliced_add_inline(&mut a, &b);
            });
        }
        "baai" | "bitsliced_avx_addition_inline" => {
            let mut data = [unsafe { _mm512_setzero_si512() }; 64];

            benchmark(
                "bitsliced_addition_inline",
                1_000_000,
                10000,
                64,
                || unsafe {
                    bitsliced_add_single_inline_avx_512(&mut data, 111);
                },
            );
        }
        "ravx" | "reduction_avx" => {
            let mut data = [unsafe { _mm512_setzero_si512() }; 64];

            benchmark(
                "bitsliced_addition_inline",
                1_000_000,
                10000,
                64,
                || unsafe {
                    des_reduction_inline_avx_512(&mut data, 111);
                },
            );
        }
        "bm" | "bitsliced_modulo" => {
            let all_ones = u64x8::splat(0xFFFFFFFFFFFFFFFF);
            let a = [all_ones; 64];

            benchmark("bitsliced_modulo", 1_000_000, 10000, 64, || {
                let _ = bitsliced_modulo_power_of_two(&a, 56);
            });
        }
        "bmi" | "bitsliced_modulo_inline" => {
            let all_ones = u64x8::splat(0xFFFFFFFFFFFFFFFF);
            let mut a = [all_ones; 64];

            benchmark("bitsliced_modulo_inline", 1_000_000, 10000, 64, || {
                let _ = bitsliced_modulo_power_of_two_inline(&mut a, 56);
            });
        }
        "ts" | "transpose_scalar" => {
            let transpose_input = [0u64; 64];

            benchmark("transpose_scalar", 1_000_000, 10000, 1, || {
                let _ = transpose_scalar(&transpose_input);
            });
        }
        "tg" | "transpose_gfni" => {
            let transpose_input = [0u64; 64];

            benchmark("transpose_gfni", 1_000_000, 10000, 1, || unsafe {
                let _ = transpose_gfni(&transpose_input);
            });
        }
        "tr" | "transpose" => {
            let transpose_input = [0u64; 64];

            benchmark("transpose", 1_000_000, 10000, 1, || {
                let _ = transpose_64x64(&transpose_input);
            });
        }
        _ => {
            println!("Invalid benchmark name")
        }
    }
}