ark-curves-cherry-picked/curve-benches/src/macros/ec.rs
curve-benches/src/macros/ec.rsRaw
1macro_rules! ec_bench {
2 () => {
3 #[bench]
4 fn bench_g1_rand(b: &mut ::test::Bencher) {
5 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
6 b.iter(|| G1::rand(&mut rng));
7 }
8
9 #[bench]
10 fn bench_g1_mul_assign(b: &mut ::test::Bencher) {
11 const SAMPLES: usize = 1000;
12
13 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
14
15 let v: Vec<(G1, Fr)> = (0..SAMPLES)
16 .map(|_| (G1::rand(&mut rng), Fr::rand(&mut rng)))
17 .collect();
18
19 let mut count = 0;
20 b.iter(|| {
21 let mut tmp = v[count].0;
22 tmp *= v[count].1;
23 count = (count + 1) % SAMPLES;
24 tmp
25 });
26 }
27
28 #[bench]
29 fn bench_g1_add_assign(b: &mut ::test::Bencher) {
30 const SAMPLES: usize = 1000;
31
32 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
33
34 let v: Vec<(G1, G1)> = (0..SAMPLES)
35 .map(|_| (G1::rand(&mut rng), G1::rand(&mut rng)))
36 .collect();
37
38 let mut count = 0;
39 b.iter(|| {
40 let mut tmp = v[count].0;
41 n_fold!(tmp, v, add_assign, count);
42 count = (count + 1) % SAMPLES;
43 tmp
44 });
45 }
46
47 #[bench]
48 fn bench_g1_add_assign_mixed(b: &mut ::test::Bencher) {
49 const SAMPLES: usize = 1000;
50
51 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
52
53 let v: Vec<(G1, G1Affine)> = (0..SAMPLES)
54 .map(|_| (G1::rand(&mut rng), G1::rand(&mut rng).into()))
55 .collect();
56
57 let mut count = 0;
58 b.iter(|| {
59 let mut tmp = v[count].0;
60 n_fold!(tmp, v, add_assign_mixed, count);
61 count = (count + 1) % SAMPLES;
62 tmp
63 });
64 }
65
66 #[bench]
67 fn bench_g1_double(b: &mut ::test::Bencher) {
68 const SAMPLES: usize = 1000;
69
70 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
71
72 let v: Vec<(G1, G1)> = (0..SAMPLES)
73 .map(|_| (G1::rand(&mut rng), G1::rand(&mut rng)))
74 .collect();
75
76 let mut count = 0;
77 b.iter(|| {
78 let mut tmp = v[count].0;
79 n_fold!(tmp, double_in_place);
80 count = (count + 1) % SAMPLES;
81 tmp
82 });
83 }
84
85 #[bench]
86 fn bench_g1_deser(b: &mut ::test::Bencher) {
87 use ark_ec::ProjectiveCurve;
88 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
89 const SAMPLES: usize = 1000;
90
91 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
92
93 let mut num_bytes = 0;
94 let tmp = G1::rand(&mut rng).into_affine();
95 let v: Vec<_> = (0..SAMPLES)
96 .flat_map(|_| {
97 let mut bytes = Vec::with_capacity(1000);
98 tmp.serialize(&mut bytes).unwrap();
99 num_bytes = bytes.len();
100 bytes
101 })
102 .collect();
103
104 let mut count = 0;
105 b.iter(|| {
106 count = (count + 1) % SAMPLES;
107 let index = count * num_bytes;
108 G1Affine::deserialize(&v[index..(index + num_bytes)]).unwrap()
109 });
110 }
111
112 #[bench]
113 fn bench_g1_ser(b: &mut ::test::Bencher) {
114 use ark_ec::ProjectiveCurve;
115 use ark_serialize::CanonicalSerialize;
116 const SAMPLES: usize = 1000;
117
118 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
119
120 let mut v: Vec<_> = (0..SAMPLES).map(|_| G1::rand(&mut rng)).collect();
121 let v = G1::batch_normalization_into_affine(v.as_mut_slice());
122 let mut bytes = Vec::with_capacity(1000);
123
124 let mut count = 0;
125 b.iter(|| {
126 let tmp = v[count];
127 count = (count + 1) % SAMPLES;
128 bytes.clear();
129 tmp.serialize(&mut bytes)
130 });
131 }
132
133 #[bench]
134 fn bench_g1_deser_unchecked(b: &mut ::test::Bencher) {
135 use ark_ec::ProjectiveCurve;
136 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
137 const SAMPLES: usize = 1000;
138
139 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
140
141 let mut num_bytes = 0;
142 let tmp = G1::rand(&mut rng).into_affine();
143 let v: Vec<_> = (0..SAMPLES)
144 .flat_map(|_| {
145 let mut bytes = Vec::with_capacity(1000);
146 tmp.serialize_unchecked(&mut bytes).unwrap();
147 num_bytes = bytes.len();
148 bytes
149 })
150 .collect();
151
152 let mut count = 0;
153 b.iter(|| {
154 count = (count + 1) % SAMPLES;
155 let index = count * num_bytes;
156 G1Affine::deserialize_unchecked(&v[index..(index + num_bytes)]).unwrap()
157 });
158 }
159
160 #[bench]
161 fn bench_g1_ser_unchecked(b: &mut ::test::Bencher) {
162 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
163 const SAMPLES: usize = 1000;
164
165 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
166
167 let mut v: Vec<_> = (0..SAMPLES).map(|_| G1::rand(&mut rng)).collect();
168 let v = G1::batch_normalization_into_affine(v.as_mut_slice());
169 let mut bytes = Vec::with_capacity(1000);
170
171 let mut count = 0;
172 b.iter(|| {
173 let tmp = v[count];
174 count = (count + 1) % SAMPLES;
175 bytes.clear();
176 tmp.serialize_unchecked(&mut bytes)
177 });
178 }
179
180 #[bench]
181 fn bench_g2_rand(b: &mut ::test::Bencher) {
182 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
183 b.iter(|| G2::rand(&mut rng));
184 }
185
186 #[bench]
187 fn bench_g2_mul_assign(b: &mut ::test::Bencher) {
188 const SAMPLES: usize = 1000;
189
190 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
191
192 let v: Vec<(G2, Fr)> = (0..SAMPLES)
193 .map(|_| (G2::rand(&mut rng), Fr::rand(&mut rng)))
194 .collect();
195
196 let mut count = 0;
197 b.iter(|| {
198 let mut tmp = v[count].0;
199 tmp *= v[count].1;
200 count = (count + 1) % SAMPLES;
201 tmp
202 });
203 }
204
205 #[bench]
206 fn bench_g2_add_assign(b: &mut ::test::Bencher) {
207 const SAMPLES: usize = 1000;
208
209 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
210
211 let v: Vec<(G2, G2)> = (0..SAMPLES)
212 .map(|_| (G2::rand(&mut rng), G2::rand(&mut rng)))
213 .collect();
214
215 let mut count = 0;
216 b.iter(|| {
217 let mut tmp = v[count].0;
218 tmp.add_assign(&v[count].1);
219 count = (count + 1) % SAMPLES;
220 tmp
221 });
222 }
223
224 #[bench]
225 fn bench_g2_add_assign_mixed(b: &mut ::test::Bencher) {
226 const SAMPLES: usize = 1000;
227
228 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
229
230 let v: Vec<(G2, G2Affine)> = (0..SAMPLES)
231 .map(|_| (G2::rand(&mut rng), G2::rand(&mut rng).into()))
232 .collect();
233
234 let mut count = 0;
235 b.iter(|| {
236 let mut tmp = v[count].0;
237 tmp.add_assign_mixed(&v[count].1);
238 count = (count + 1) % SAMPLES;
239 tmp
240 });
241 }
242
243 #[bench]
244 fn bench_g2_double(b: &mut ::test::Bencher) {
245 const SAMPLES: usize = 1000;
246
247 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
248
249 let v: Vec<(G2, G2)> = (0..SAMPLES)
250 .map(|_| (G2::rand(&mut rng), G2::rand(&mut rng)))
251 .collect();
252
253 let mut count = 0;
254 b.iter(|| {
255 let mut tmp = v[count].0;
256 tmp.double_in_place();
257 count = (count + 1) % SAMPLES;
258 tmp
259 });
260 }
261
262 #[bench]
263 fn bench_g2_deser(b: &mut ::test::Bencher) {
264 use ark_ec::ProjectiveCurve;
265 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
266 const SAMPLES: usize = 1000;
267
268 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
269
270 let mut num_bytes = 0;
271 let tmp = G2::rand(&mut rng).into_affine();
272 let v: Vec<_> = (0..SAMPLES)
273 .flat_map(|_| {
274 let mut bytes = Vec::with_capacity(1000);
275 tmp.serialize(&mut bytes).unwrap();
276 num_bytes = bytes.len();
277 bytes
278 })
279 .collect();
280
281 let mut count = 0;
282 b.iter(|| {
283 count = (count + 1) % SAMPLES;
284 let index = count * num_bytes;
285 G2Affine::deserialize(&v[index..(index + num_bytes)]).unwrap()
286 });
287 }
288
289 #[bench]
290 fn bench_g2_ser(b: &mut ::test::Bencher) {
291 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
292 const SAMPLES: usize = 1000;
293
294 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
295
296 let mut v: Vec<_> = (0..SAMPLES).map(|_| G2::rand(&mut rng)).collect();
297 let v = G2::batch_normalization_into_affine(v.as_mut_slice());
298 let mut bytes = Vec::with_capacity(1000);
299
300 let mut count = 0;
301 b.iter(|| {
302 let tmp = v[count];
303 count = (count + 1) % SAMPLES;
304 bytes.clear();
305 tmp.serialize(&mut bytes)
306 });
307 }
308
309 #[bench]
310 fn bench_g2_deser_unchecked(b: &mut ::test::Bencher) {
311 use ark_ec::ProjectiveCurve;
312 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
313 const SAMPLES: usize = 1000;
314
315 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
316
317 let mut num_bytes = 0;
318 let tmp = G2::rand(&mut rng).into_affine();
319 let v: Vec<_> = (0..SAMPLES)
320 .flat_map(|_| {
321 let mut bytes = Vec::with_capacity(1000);
322 tmp.serialize_unchecked(&mut bytes).unwrap();
323 num_bytes = bytes.len();
324 bytes
325 })
326 .collect();
327
328 let mut count = 0;
329 b.iter(|| {
330 count = (count + 1) % SAMPLES;
331 let index = count * num_bytes;
332 G2Affine::deserialize_unchecked(&v[index..(index + num_bytes)]).unwrap()
333 });
334 }
335
336 #[bench]
337 fn bench_g2_ser_unchecked(b: &mut ::test::Bencher) {
338 use ark_ec::ProjectiveCurve;
339 use ark_serialize::CanonicalSerialize;
340 const SAMPLES: usize = 1000;
341
342 let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
343
344 let mut v: Vec<_> = (0..SAMPLES).map(|_| G2::rand(&mut rng)).collect();
345 let v = G2::batch_normalization_into_affine(v.as_mut_slice());
346 let mut bytes = Vec::with_capacity(1000);
347
348 let mut count = 0;
349 b.iter(|| {
350 let tmp = v[count];
351 count = (count + 1) % SAMPLES;
352 bytes.clear();
353 tmp.serialize_unchecked(&mut bytes)
354 });
355 }
356 };
357}