1#[macro_export]
  2macro_rules! ec_bench {
  3    ($projective:ty, $affine:ty) => {
  4        fn rand(b: &mut $crate::bencher::Bencher) {
  5            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
  6            b.iter(|| <$projective>::rand(&mut rng));
  7        }
  8
  9        fn mul_assign(b: &mut $crate::bencher::Bencher) {
 10            const SAMPLES: usize = 1000;
 11
 12            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 13
 14            let v: Vec<($projective, Fr)> = (0..SAMPLES)
 15                .map(|_| (<$projective>::rand(&mut rng), Fr::rand(&mut rng)))
 16                .collect();
 17
 18            let mut count = 0;
 19            b.iter(|| {
 20                let mut tmp = v[count].0;
 21                tmp *= v[count].1;
 22                count = (count + 1) % SAMPLES;
 23                tmp
 24            });
 25        }
 26
 27        fn add_assign(b: &mut $crate::bencher::Bencher) {
 28            const SAMPLES: usize = 1000;
 29
 30            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 31
 32            let v: Vec<($projective, $projective)> = (0..SAMPLES)
 33                .map(|_| (<$projective>::rand(&mut rng), <$projective>::rand(&mut rng)))
 34                .collect();
 35
 36            let mut count = 0;
 37            b.iter(|| {
 38                let mut tmp = v[count].0;
 39                n_fold!(tmp, v, add_assign, count);
 40                count = (count + 1) % SAMPLES;
 41                tmp
 42            });
 43        }
 44
 45        fn double(b: &mut $crate::bencher::Bencher) {
 46            const SAMPLES: usize = 1000;
 47
 48            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 49
 50            let v: Vec<$projective> = (0..SAMPLES)
 51                .map(|_| <$projective>::rand(&mut rng))
 52                .collect();
 53
 54            let mut count = 0;
 55            b.iter(|| {
 56                let mut tmp = v[count];
 57                n_fold!(tmp, double_in_place);
 58                count = (count + 1) % SAMPLES;
 59                tmp
 60            });
 61        }
 62
 63        fn add_assign_mixed(b: &mut $crate::bencher::Bencher) {
 64            const SAMPLES: usize = 1000;
 65
 66            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 67
 68            let v: Vec<($projective, $affine)> = (0..SAMPLES)
 69                .map(|_| {
 70                    (
 71                        <$projective>::rand(&mut rng),
 72                        <$projective>::rand(&mut rng).into(),
 73                    )
 74                })
 75                .collect();
 76
 77            let mut count = 0;
 78            b.iter(|| {
 79                let mut tmp = v[count].0;
 80                n_fold!(tmp, v, add_assign_mixed, count);
 81                count = (count + 1) % SAMPLES;
 82                tmp
 83            });
 84        }
 85
 86        fn deser(b: &mut $crate::bencher::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 = <$projective>::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                <$affine>::deserialize(&v[index..(index + num_bytes)]).unwrap()
109            });
110        }
111
112        fn ser(b: &mut $crate::bencher::Bencher) {
113            use ark_ec::ProjectiveCurve;
114            use ark_serialize::CanonicalSerialize;
115            const SAMPLES: usize = 1000;
116
117            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
118
119            let mut v: Vec<_> = (0..SAMPLES)
120                .map(|_| <$projective>::rand(&mut rng))
121                .collect();
122            let v = <$projective>::batch_normalization_into_affine(v.as_mut_slice());
123            let mut bytes = Vec::with_capacity(1000);
124
125            let mut count = 0;
126            b.iter(|| {
127                let tmp = v[count];
128                count = (count + 1) % SAMPLES;
129                bytes.clear();
130                tmp.serialize(&mut bytes)
131            });
132        }
133
134        fn deser_unchecked(b: &mut $crate::bencher::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 = <$projective>::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                <$affine>::deserialize_unchecked(&v[index..(index + num_bytes)]).unwrap()
157            });
158        }
159
160        fn ser_unchecked(b: &mut $crate::bencher::Bencher) {
161            use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
162            const SAMPLES: usize = 1000;
163
164            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
165
166            let mut v: Vec<_> = (0..SAMPLES)
167                .map(|_| <$projective>::rand(&mut rng))
168                .collect();
169            let v = <$projective>::batch_normalization_into_affine(v.as_mut_slice());
170            let mut bytes = Vec::with_capacity(1000);
171
172            let mut count = 0;
173            b.iter(|| {
174                let tmp = v[count];
175                count = (count + 1) % SAMPLES;
176                bytes.clear();
177                tmp.serialize_unchecked(&mut bytes)
178            });
179        }
180
181        fn msm_131072(b: &mut $crate::bencher::Bencher) {
182            use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
183            const SAMPLES: usize = 131072;
184
185            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
186
187            let g = <$projective>::rand(&mut rng).into_affine();
188            let v: Vec<_> = (0..SAMPLES).map(|_| g).collect();
189            let scalars: Vec<_> = (0..SAMPLES)
190                .map(|_| Fr::rand(&mut rng).into_repr())
191                .collect();
192            b.bench_n(1, |b| {
193                b.iter(|| ark_ec::msm::VariableBaseMSM::multi_scalar_mul(&v, &scalars));
194            })
195        }
196
197        $crate::benchmark_group!(
198            group_ops,
199            rand,
200            mul_assign,
201            add_assign,
202            add_assign_mixed,
203            double,
204            ser,
205            deser,
206            ser_unchecked,
207            deser_unchecked,
208            msm_131072,
209        );
210    };
211}