bitvec 0.19.5

A crate for manipulating memory, bit by bit
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

/*! Benchmarks for `BitSlice::copy_from_slice`.

The `copy_from_slice` implementation attempts to detect slice conditions that
allow element-wise `memcpy` behavior, rather than the conservative bit-by-bit
iteration, in the hopes that element load/stores are faster than reading and
writing each bit in an element individually.

At least on the author’s machine, this appears not to be the case. The author
has not inspected the object code emitted by `clone_from_bitslice` and has no
speculation on why this is the case.
!*/

use bitvec::prelude::*;

use criterion::{
	criterion_group,
	criterion_main,
	BenchmarkId,
	Criterion,
	Throughput,
};

const FACTOR: usize = 1024;

pub fn benchmarks(crit: &mut Criterion) {
	let mut group = crit.benchmark_group("accel");
	for (kibi, bits) in [1, 2, 4, 8, 16, 32, 64, 128]
		.iter()
		.copied()
		.map(|n| (n, n * FACTOR))
	{
		group.throughput(Throughput::Elements(bits as u64));
		group.bench_with_input(
			BenchmarkId::from_parameter(kibi),
			&bits,
			|b, bits| {
				let mut dst: BitVec = BitVec::repeat(false, *bits);
				let src: BitVec = BitVec::repeat(true, *bits);
				b.iter(|| {
					dst[10 .. *bits - 10]
						.copy_from_bitslice(&src[10 .. *bits - 10])
				});
			},
		);
	}
	group.finish();

	let mut group = crit.benchmark_group("bitwise");
	for (kibi, bits) in [1, 2, 4, 8, 16, 32, 64, 128]
		.iter()
		.copied()
		.map(|n| (n, n * FACTOR))
	{
		group.throughput(Throughput::Elements(bits as u64));
		group.bench_with_input(
			BenchmarkId::from_parameter(kibi),
			&bits,
			|b, bits| {
				let mut dst: BitVec = BitVec::repeat(false, *bits);
				let src: BitVec = BitVec::repeat(true, *bits);
				b.iter(|| dst.clone_from_bitslice(&src));
			},
		);
	}
	group.finish();

	let mut group = crit.benchmark_group("mismatch");
	for (kibi, bits) in [1, 2, 4, 8, 16, 32, 64, 128]
		.iter()
		.copied()
		.map(|n| (n, n * FACTOR))
	{
		group.throughput(Throughput::Elements(bits as u64));
		group.bench_with_input(
			BenchmarkId::from_parameter(kibi),
			&bits,
			|b, bits| {
				let mut dst: BitVec<Msb0, u16> = BitVec::repeat(false, *bits);
				let src: BitVec<Lsb0, u32> = BitVec::repeat(true, *bits);
				b.iter(|| dst.clone_from_bitslice(&src));
			},
		);
	}
	group.finish();
}

criterion_group!(benches, benchmarks);
criterion_main!(benches);