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