ark-curves-cherry-picked/curve-benches/src/macros/field.rs
curve-benches/src/macros/field.rsRaw
1#[macro_export]
2macro_rules! f_bench {
3 // Use this for base fields
4 ($f:ident, $f_type:ty, $f_repr:ident, $f_repr_type:ty, $modname:ident) => {
5 $crate::paste!{
6 pub mod [<_ $modname>] {
7 use super::*;
8 field_common!($f, $f_type);
9 sqrt!($f, $f_type);
10 prime_field!($f, $f_type, $f_repr, $f_repr_type);
11 $crate::benchmark_group!(
12 $modname,
13 // common stuff
14 add_assign,
15 sub_assign,
16 double,
17 negate,
18 mul_assign,
19 square,
20 inverse,
21 ser,
22 deser,
23 ser_unchecked,
24 deser_unchecked,
25 // sqrt field stuff
26 sqrt,
27 // prime field stuff
28 repr_add_nocarry,
29 repr_sub_noborrow,
30 repr_num_bits,
31 repr_mul2,
32 repr_div2,
33 into_repr,
34 from_repr,
35 );
36 }
37 use [<_ $modname>]::$modname;
38 }
39 };
40 // use this for intermediate fields
41 (extension, $f:ident, $f_type:ty, $modname:ident) => {
42 $crate::paste!{
43 mod [<_ $modname>] {
44 use super::*;
45 field_common!($f, $f_type);
46 sqrt!($f, $f_type);
47 $crate::benchmark_group!(
48 $modname,
49 // common stuff
50 add_assign,
51 sub_assign,
52 double,
53 negate,
54 mul_assign,
55 square,
56 inverse,
57 ser,
58 deser,
59 ser_unchecked,
60 deser_unchecked,
61 // sqrt field stuff
62 sqrt,
63 );
64 }
65 use [<_ $modname>]::$modname;
66 }
67 };
68 // Use this for the full extension field Fqk
69 (target, $f:ident, $f_type:ty, $modname:ident) => {
70 crate::paste! {
71 mod [<_ $modname>] {
72 use super::*;
73 field_common!($f, $f_type);
74 $crate::benchmark_group!(
75 $modname,
76 // common stuff
77 add_assign,
78 sub_assign,
79 double,
80 negate,
81 mul_assign,
82 square,
83 inverse,
84 ser,
85 deser,
86 ser_unchecked,
87 deser_unchecked,
88 );
89 }
90 use [<_ $modname>]::$modname;
91 }
92 };
93}
94
95#[macro_export]
96macro_rules! field_common {
97 ($f:ident, $f_type:ty) => {
98 fn add_assign(b: &mut $crate::bencher::Bencher) {
99 const SAMPLES: usize = 1000;
100
101 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
102
103 let v: Vec<_> = (0..SAMPLES)
104 .map(|_| ($f::rand(&mut rng), $f::rand(&mut rng)))
105 .collect();
106
107 let mut count = 0;
108 b.iter(|| {
109 let mut tmp = v[count].0;
110 n_fold!(tmp, v, add_assign, count);
111 count = (count + 1) % SAMPLES;
112 tmp
113 });
114 }
115
116
117 fn sub_assign(b: &mut $crate::bencher::Bencher) {
118 const SAMPLES: usize = 1000;
119
120 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
121
122 let v: Vec<_> = (0..SAMPLES)
123 .map(|_| ($f::rand(&mut rng), $f::rand(&mut rng)))
124 .collect();
125
126 let mut count = 0;
127 b.iter(|| {
128 let mut tmp = v[count].0;
129 n_fold!(tmp, v, sub_assign, count);
130 count = (count + 1) % SAMPLES;
131 tmp
132 });
133 }
134
135 fn double(b: &mut $crate::bencher::Bencher) {
136 const SAMPLES: usize = 1000;
137
138 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
139
140 let v: Vec<$f_type> = (0..SAMPLES).map(|_| $f::rand(&mut rng)).collect();
141
142 let mut count = 0;
143 b.iter(|| {
144 let mut tmp = v[count];
145 n_fold!(tmp, double_in_place);
146 count = (count + 1) % SAMPLES;
147 tmp
148 });
149 }
150
151
152 fn negate(b: &mut $crate::bencher::Bencher) {
153 const SAMPLES: usize = 1000;
154
155 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
156
157 let v: Vec<$f_type> = (0..SAMPLES).map(|_| $f::rand(&mut rng)).collect();
158
159 let mut count = 0;
160 b.iter(|| {
161 let mut tmp = v[count];
162 tmp = -tmp;
163 count = (count + 1) % SAMPLES;
164 tmp
165 });
166 }
167
168 fn mul_assign(b: &mut $crate::bencher::Bencher) {
169 const SAMPLES: usize = 1000;
170
171 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
172
173 let v: Vec<_> = (0..SAMPLES)
174 .map(|_| ($f::rand(&mut rng), $f::rand(&mut rng)))
175 .collect();
176
177 let mut count = 0;
178 b.iter(|| {
179 let mut tmp = v[count].0;
180 n_fold!(tmp, v, mul_assign, count);
181 count = (count + 1) % SAMPLES;
182 tmp
183 });
184 }
185
186 fn square(b: &mut $crate::bencher::Bencher) {
187 const SAMPLES: usize = 1000;
188
189 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
190
191 let v: Vec<$f_type> = (0..SAMPLES).map(|_| $f::rand(&mut rng)).collect();
192
193 let mut count = 0;
194 b.iter(|| {
195 let mut tmp = v[count];
196 n_fold!(tmp, square_in_place);
197 count = (count + 1) % SAMPLES;
198 tmp
199 });
200 }
201
202
203 fn inverse(b: &mut $crate::bencher::Bencher) {
204 const SAMPLES: usize = 1000;
205
206 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
207
208 let v: Vec<$f_type> = (0..SAMPLES).map(|_| $f::rand(&mut rng)).collect();
209
210 let mut count = 0;
211 b.iter(|| {
212 let tmp = v[count].inverse();
213 count = (count + 1) % SAMPLES;
214 tmp
215 });
216 }
217
218
219 fn deser(b: &mut $crate::bencher::Bencher) {
220 use ark_serialize::{CanonicalSerialize, CanonicalDeserialize};
221 const SAMPLES: usize = 1000;
222
223 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
224
225 let mut num_bytes = 0;
226 let v: Vec<_> = (0..SAMPLES).flat_map(|_| {
227 let mut bytes = Vec::with_capacity(1000);
228 let tmp = $f::rand(&mut rng);
229 tmp.serialize(&mut bytes).unwrap();
230 num_bytes = bytes.len();
231 bytes
232 }).collect();
233
234 let mut count = 0;
235 b.iter(|| {
236 count = (count + 1) % SAMPLES;
237 let index = count * num_bytes;
238 <$f_type>::deserialize(&v[index..(index + num_bytes)]).unwrap()
239 });
240 }
241
242
243 fn ser(b: &mut $crate::bencher::Bencher) {
244 use ark_serialize::CanonicalSerialize;
245 const SAMPLES: usize = 1000;
246
247 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
248
249 let v: Vec<$f_type> = (0..SAMPLES).map(|_| $f::rand(&mut rng)).collect();
250 let mut bytes = Vec::with_capacity(1000);
251
252 let mut count = 0;
253 b.iter(|| {
254 let tmp = v[count];
255 count = (count + 1) % SAMPLES;
256 bytes.clear();
257 tmp.serialize(&mut bytes)
258
259 });
260 }
261
262
263 fn deser_unchecked(b: &mut $crate::bencher::Bencher) {
264 use ark_serialize::{CanonicalSerialize, CanonicalDeserialize};
265 const SAMPLES: usize = 1000;
266
267 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
268
269 let mut num_bytes = 0;
270 let v: Vec<_> = (0..SAMPLES).flat_map(|_| {
271 let mut bytes = Vec::with_capacity(1000);
272 let tmp = $f::rand(&mut rng);
273 tmp.serialize_unchecked(&mut bytes).unwrap();
274 num_bytes = bytes.len();
275 bytes
276 }).collect();
277
278 let mut count = 0;
279 b.iter(|| {
280 count = (count + 1) % SAMPLES;
281 let index = count * num_bytes;
282 <$f_type>::deserialize_unchecked(&v[index..(index + num_bytes)]).unwrap()
283 });
284 }
285
286
287 fn ser_unchecked(b: &mut $crate::bencher::Bencher) {
288 use ark_serialize::CanonicalSerialize;
289 const SAMPLES: usize = 1000;
290
291 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
292
293 let v: Vec<$f_type> = (0..SAMPLES).map(|_| $f::rand(&mut rng)).collect();
294 let mut bytes = Vec::with_capacity(1000);
295
296 let mut count = 0;
297 b.iter(|| {
298 let tmp = v[count];
299 count = (count + 1) % SAMPLES;
300 bytes.clear();
301 tmp.serialize_unchecked(&mut bytes)
302
303 });
304 }
305 }
306}
307
308#[macro_export]
309macro_rules! sqrt {
310 ($f:ident, $f_type:ty) => {
311 pub fn sqrt(b: &mut $crate::bencher::Bencher) {
312 const SAMPLES: usize = 1000;
313
314 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
315
316 let v: Vec<$f_type> = (0..SAMPLES)
317 .map(|_| {
318 let mut tmp = $f::rand(&mut rng);
319 tmp.square_in_place();
320 tmp
321 })
322 .collect();
323
324 let mut count = 0;
325 b.iter(|| {
326 count = (count + 1) % SAMPLES;
327 v[count].sqrt()
328 });
329 }
330 }
331}
332
333#[macro_export]
334macro_rules! prime_field {
335 ($f:ident, $f_type:ty, $f_repr:ident, $f_repr_type:ty) => {
336 fn repr_add_nocarry(b: &mut $crate::bencher::Bencher) {
337 const SAMPLES: usize = 1000;
338
339 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
340
341 let v: Vec<_> = (0..SAMPLES)
342 .map(|_| {
343 let mut tmp1 = $f_repr::rand(&mut rng);
344 let mut tmp2 = $f_repr::rand(&mut rng);
345 // Shave a few bits off to avoid overflow.
346 for _ in 0..3 {
347 tmp1.div2();
348 tmp2.div2();
349 }
350 (tmp1, tmp2)
351 })
352 .collect();
353
354 let mut count = 0;
355 b.iter(|| {
356 let mut tmp = v[count].0;
357 n_fold!(tmp, v, add_nocarry, count);
358 count = (count + 1) % SAMPLES;
359 tmp
360 });
361 }
362
363 fn repr_sub_noborrow(b: &mut $crate::bencher::Bencher) {
364 const SAMPLES: usize = 1000;
365
366 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
367
368 let v: Vec<_> = (0..SAMPLES)
369 .map(|_| {
370 let tmp1 = $f_repr::rand(&mut rng);
371 let mut tmp2 = tmp1;
372 // Ensure tmp2 is smaller than tmp1.
373 for _ in 0..10 {
374 tmp2.div2();
375 }
376 (tmp1, tmp2)
377 })
378 .collect();
379
380 let mut count = 0;
381 b.iter(|| {
382 let mut tmp = v[count].0;
383 n_fold!(tmp, v, sub_noborrow, count);
384 count = (count + 1) % SAMPLES;
385 tmp;
386 });
387 }
388
389 fn repr_num_bits(b: &mut $crate::bencher::Bencher) {
390 const SAMPLES: usize = 1000;
391
392 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
393
394 let v: Vec<$f_repr_type> = (0..SAMPLES).map(|_| $f_repr::rand(&mut rng)).collect();
395
396 let mut count = 0;
397 b.iter(|| {
398 let tmp = v[count].num_bits();
399 count = (count + 1) % SAMPLES;
400 tmp;
401 });
402 }
403
404 fn repr_mul2(b: &mut $crate::bencher::Bencher) {
405 const SAMPLES: usize = 1000;
406
407 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
408
409 let v: Vec<$f_repr_type> = (0..SAMPLES).map(|_| $f_repr::rand(&mut rng)).collect();
410
411 let mut count = 0;
412 b.iter(|| {
413 let mut tmp = v[count];
414 n_fold!(tmp, mul2);
415 count = (count + 1) % SAMPLES;
416 tmp;
417 });
418 }
419
420 fn repr_div2(b: &mut $crate::bencher::Bencher) {
421 const SAMPLES: usize = 1000;
422
423 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
424
425 let v: Vec<$f_repr_type> = (0..SAMPLES).map(|_| $f_repr::rand(&mut rng)).collect();
426
427 let mut count = 0;
428 b.iter(|| {
429 let mut tmp = v[count];
430 n_fold!(tmp, div2);
431 count = (count + 1) % SAMPLES;
432 tmp;
433 });
434 }
435
436 fn into_repr(b: &mut $crate::bencher::Bencher) {
437 const SAMPLES: usize = 1000;
438
439 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
440
441 let v: Vec<$f_type> = (0..SAMPLES).map(|_| $f::rand(&mut rng)).collect();
442
443 let mut count = 0;
444 b.iter(|| {
445 count = (count + 1) % SAMPLES;
446 v[count].into_repr();
447 });
448 }
449
450 fn from_repr(b: &mut $crate::bencher::Bencher) {
451 const SAMPLES: usize = 1000;
452
453 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
454
455 let v: Vec<$f_repr_type> = (0..SAMPLES)
456 .map(|_| $f::rand(&mut rng).into_repr())
457 .collect();
458
459 let mut count = 0;
460 b.iter(|| {
461 count = (count + 1) % SAMPLES;
462 $f::from(v[count]);
463 });
464 }
465 }
466}