1 #![feature(test)]
2
3 extern crate bit_field;
4
5 use bit_field::*;
6
7 pub trait BitOper {
8 const BIT_LEN: usize;
get_b(&self, idx: usize) -> bool9 fn get_b(&self, idx: usize) -> bool;
set_b(&mut self, idx: usize, val: bool)10 fn set_b(&mut self, idx: usize, val: bool);
toggle(&mut self, idx: usize)11 fn toggle(&mut self, idx: usize);
12 }
13
14 pub trait BitArrayOper<T: BitOper> {
get_blen(&self) -> usize15 fn get_blen(&self) -> usize;
get_b(&self, idx: usize) -> bool16 fn get_b(&self, idx: usize) -> bool;
set_b(&mut self, idx: usize, val: bool)17 fn set_b(&mut self, idx: usize, val: bool);
toggle(&mut self, idx: usize)18 fn toggle(&mut self, idx: usize);
19 }
20
21 impl BitOper for u8 {
22 const BIT_LEN: usize = std::mem::size_of::<Self>() as usize * 8;
23
set_b(&mut self, idx: usize, val: bool)24 fn set_b(&mut self, idx: usize, val: bool) {
25 assert!(idx < Self::BIT_LEN);
26 if val {
27 *self |= 1 << idx;
28 } else {
29 *self &= !(1 << idx);
30 }
31 }
32
get_b(&self, idx: usize) -> bool33 fn get_b(&self, idx: usize) -> bool {
34 assert!(idx < Self::BIT_LEN);
35 (self & 1 << idx) != 0
36 }
37
toggle(&mut self, idx: usize)38 fn toggle(&mut self, idx: usize) {
39 assert!(idx < Self::BIT_LEN);
40 *self ^= 1 << idx;
41 }
42 }
43
44 impl BitOper for u32 {
45 const BIT_LEN: usize = std::mem::size_of::<Self>() as usize * 8;
set_b(&mut self, idx: usize, val: bool)46 fn set_b(&mut self, idx: usize, val: bool) {
47 assert!(idx < Self::BIT_LEN);
48 if val {
49 *self |= 1 << idx;
50 } else {
51 *self &= !(1 << idx);
52 }
53 }
54
get_b(&self, idx: usize) -> bool55 fn get_b(&self, idx: usize) -> bool {
56 assert!(idx < Self::BIT_LEN);
57 (self & 1 << idx) != 0
58 }
59
toggle(&mut self, idx: usize)60 fn toggle(&mut self, idx: usize) {
61 assert!(idx < Self::BIT_LEN);
62 *self ^= 1 << idx;
63 }
64 }
65
66 impl BitOper for u64 {
67 const BIT_LEN: usize = std::mem::size_of::<Self>() as usize * 8;
set_b(&mut self, idx: usize, val: bool)68 fn set_b(&mut self, idx: usize, val: bool) {
69 assert!(idx < Self::BIT_LEN);
70 if val {
71 *self |= 1 << idx;
72 } else {
73 *self &= !(1 << idx);
74 }
75 }
76
get_b(&self, idx: usize) -> bool77 fn get_b(&self, idx: usize) -> bool {
78 assert!(idx < Self::BIT_LEN);
79 (self & 1 << idx) != 0
80 }
81
toggle(&mut self, idx: usize)82 fn toggle(&mut self, idx: usize) {
83 assert!(idx < Self::BIT_LEN);
84 *self ^= 1 << idx;
85 }
86 }
87
88 impl<T: BitOper> BitArrayOper<T> for [T] {
get_blen(&self) -> usize89 fn get_blen(&self) -> usize {
90 self.len() * T::BIT_LEN
91 }
92
get_b(&self, idx: usize) -> bool93 fn get_b(&self, idx: usize) -> bool {
94 self[idx / T::BIT_LEN].get_b(idx % T::BIT_LEN)
95 }
96
set_b(&mut self, idx: usize, val: bool)97 fn set_b(&mut self, idx: usize, val: bool) {
98 self[idx / T::BIT_LEN].set_b(idx % T::BIT_LEN, val);
99 }
100
toggle(&mut self, idx: usize)101 fn toggle(&mut self, idx: usize) {
102 self[idx / T::BIT_LEN].toggle(idx % T::BIT_LEN);
103 }
104 }
105
106 extern crate test;
107
108 use test::Bencher;
109
110 const LEN: usize = 256;
111
set_bitfield<T: BitField>(v: &mut Vec<T>)112 fn set_bitfield<T: BitField>(v: &mut Vec<T>) {
113 for i in 0..v.len() * T::BIT_LENGTH {
114 v.as_mut_slice().set_bit(i, true);;
115 }
116 }
117
get_bitfield<T: BitField>(v: &Vec<T>)118 fn get_bitfield<T: BitField>(v: &Vec<T>) {
119 for i in 0..v.len() * T::BIT_LENGTH {
120 let _b = v.as_slice().get_bit(i);
121 }
122 }
123
set_trivial<T: BitOper>(v: &mut Vec<T>)124 fn set_trivial<T: BitOper>(v: &mut Vec<T>) {
125 for i in 0..v.len() * T::BIT_LEN {
126 v.set_b(i, true);
127 }
128 }
129
get_trivial<T: BitOper>(v: &Vec<T>)130 fn get_trivial<T: BitOper>(v: &Vec<T>) {
131 for i in 0..v.len() * T::BIT_LEN {
132 let _b = v.get_b(i);
133 }
134 }
135
136 #[bench]
u8_set_bitfield(b: &mut Bencher)137 fn u8_set_bitfield(b: &mut Bencher) {
138 let mut v = vec![0u8; LEN];
139 b.iter(|| {
140 set_bitfield(&mut v);
141 });
142 }
143
144 #[bench]
u8_set_trivial(b: &mut Bencher)145 fn u8_set_trivial(b: &mut Bencher) {
146 let mut v = vec![0u8; LEN];
147
148 b.iter(|| {
149 set_trivial(&mut v);
150 });
151 }
152
153 #[bench]
u8_get_bitfield(b: &mut Bencher)154 fn u8_get_bitfield(b: &mut Bencher) {
155 let v = vec![1u8; LEN];
156 b.iter(|| {
157 get_bitfield(&v);
158 });
159 }
160
161 #[bench]
u8_get_trivial(b: &mut Bencher)162 fn u8_get_trivial(b: &mut Bencher) {
163 let v = vec![1u8; LEN];
164 b.iter(|| {
165 get_trivial(&v);
166 });
167 }
168
169 #[bench]
u32_set_bitfield(b: &mut Bencher)170 fn u32_set_bitfield(b: &mut Bencher) {
171 let mut v = vec![0u32; LEN];
172 b.iter(|| {
173 set_bitfield(&mut v);
174 });
175 }
176
177 #[bench]
u32_set_trivial(b: &mut Bencher)178 fn u32_set_trivial(b: &mut Bencher) {
179 let mut v = vec![0u32; LEN];
180
181 b.iter(|| {
182 set_trivial(&mut v);
183 });
184 }
185
186 #[bench]
u32_get_bitfield(b: &mut Bencher)187 fn u32_get_bitfield(b: &mut Bencher) {
188 let v = vec![1u32; LEN];
189 b.iter(|| {
190 get_bitfield(&v);
191 });
192 }
193
194 #[bench]
u32_get_trivial(b: &mut Bencher)195 fn u32_get_trivial(b: &mut Bencher) {
196 let v = vec![1u32; LEN];
197 b.iter(|| {
198 get_trivial(&v);
199 });
200 }
201
202 #[bench]
u64_set_bitfield(b: &mut Bencher)203 fn u64_set_bitfield(b: &mut Bencher) {
204 let mut v = vec![0u64; LEN];
205 b.iter(|| {
206 set_bitfield(&mut v);
207 });
208 }
209
210 #[bench]
u64_set_trivial(b: &mut Bencher)211 fn u64_set_trivial(b: &mut Bencher) {
212 let mut v = vec![0u64; LEN];
213
214 b.iter(|| {
215 set_trivial(&mut v);
216 });
217 }
218
219 #[bench]
u64_get_bitfield(b: &mut Bencher)220 fn u64_get_bitfield(b: &mut Bencher) {
221 let v = vec![1u64; LEN];
222 b.iter(|| {
223 get_bitfield(&v);
224 });
225 }
226
227 #[bench]
u64_get_trivial(b: &mut Bencher)228 fn u64_get_trivial(b: &mut Bencher) {
229 let v = vec![1u64; LEN];
230 b.iter(|| {
231 get_trivial(&v);
232 });
233 }
234