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        
 10        fn mul_assign(b: &mut $crate::bencher::Bencher) {
 11            const SAMPLES: usize = 1000;
 12
 13            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 14
 15            let v: Vec<($projective, Fr)> = (0..SAMPLES)
 16                .map(|_| (<$projective>::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        
 29        fn add_assign(b: &mut $crate::bencher::Bencher) {
 30            const SAMPLES: usize = 1000;
 31
 32            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 33
 34            let v: Vec<($projective, $projective)> = (0..SAMPLES)
 35                .map(|_| (<$projective>::rand(&mut rng), <$projective>::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        
 48        fn add_assign_mixed(b: &mut $crate::bencher::Bencher) {
 49            const SAMPLES: usize = 1000;
 50
 51            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 52
 53            let v: Vec<($projective, $affine)> = (0..SAMPLES)
 54                .map(|_| {
 55                    (
 56                        <$projective>::rand(&mut rng),
 57                        <$projective>::rand(&mut rng).into(),
 58                    )
 59                })
 60                .collect();
 61
 62            let mut count = 0;
 63            b.iter(|| {
 64                let mut tmp = v[count].0;
 65                n_fold!(tmp, v, add_assign_mixed, count);
 66                count = (count + 1) % SAMPLES;
 67                tmp
 68            });
 69        }
 70
 71        
 72        fn double(b: &mut $crate::bencher::Bencher) {
 73            const SAMPLES: usize = 1000;
 74
 75            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 76
 77            let v: Vec<($projective, $projective)> = (0..SAMPLES)
 78                .map(|_| (<$projective>::rand(&mut rng), <$projective>::rand(&mut rng)))
 79                .collect();
 80
 81            let mut count = 0;
 82            b.iter(|| {
 83                let mut tmp = v[count].0;
 84                n_fold!(tmp, double_in_place);
 85                count = (count + 1) % SAMPLES;
 86                tmp
 87            });
 88        }
 89
 90        
 91        fn deser(b: &mut $crate::bencher::Bencher) {
 92            use ark_ec::ProjectiveCurve;
 93            use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 94            const SAMPLES: usize = 1000;
 95
 96            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 97
 98            let mut num_bytes = 0;
 99            let tmp = <$projective>::rand(&mut rng).into_affine();
100            let v: Vec<_> = (0..SAMPLES)
101                .flat_map(|_| {
102                    let mut bytes = Vec::with_capacity(1000);
103                    tmp.serialize(&mut bytes).unwrap();
104                    num_bytes = bytes.len();
105                    bytes
106                })
107                .collect();
108
109            let mut count = 0;
110            b.iter(|| {
111                count = (count + 1) % SAMPLES;
112                let index = count * num_bytes;
113                <$affine>::deserialize(&v[index..(index + num_bytes)]).unwrap()
114            });
115        }
116
117        
118        fn ser(b: &mut $crate::bencher::Bencher) {
119            use ark_ec::ProjectiveCurve;
120            use ark_serialize::CanonicalSerialize;
121            const SAMPLES: usize = 1000;
122
123            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
124
125            let mut v: Vec<_> = (0..SAMPLES)
126                .map(|_| <$projective>::rand(&mut rng))
127                .collect();
128            let v = <$projective>::batch_normalization_into_affine(v.as_mut_slice());
129            let mut bytes = Vec::with_capacity(1000);
130
131            let mut count = 0;
132            b.iter(|| {
133                let tmp = v[count];
134                count = (count + 1) % SAMPLES;
135                bytes.clear();
136                tmp.serialize(&mut bytes)
137            });
138        }
139
140        
141        fn deser_unchecked(b: &mut $crate::bencher::Bencher) {
142            use ark_ec::ProjectiveCurve;
143            use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
144            const SAMPLES: usize = 1000;
145
146            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
147
148            let mut num_bytes = 0;
149            let tmp = <$projective>::rand(&mut rng).into_affine();
150            let v: Vec<_> = (0..SAMPLES)
151                .flat_map(|_| {
152                    let mut bytes = Vec::with_capacity(1000);
153                    tmp.serialize_unchecked(&mut bytes).unwrap();
154                    num_bytes = bytes.len();
155                    bytes
156                })
157                .collect();
158
159            let mut count = 0;
160            b.iter(|| {
161                count = (count + 1) % SAMPLES;
162                let index = count * num_bytes;
163                <$affine>::deserialize_unchecked(&v[index..(index + num_bytes)]).unwrap()
164            });
165        }
166
167        
168        fn ser_unchecked(b: &mut $crate::bencher::Bencher) {
169            use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
170            const SAMPLES: usize = 1000;
171
172            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
173
174            let mut v: Vec<_> = (0..SAMPLES)
175                .map(|_| <$projective>::rand(&mut rng))
176                .collect();
177            let v = <$projective>::batch_normalization_into_affine(v.as_mut_slice());
178            let mut bytes = Vec::with_capacity(1000);
179
180            let mut count = 0;
181            b.iter(|| {
182                let tmp = v[count];
183                count = (count + 1) % SAMPLES;
184                bytes.clear();
185                tmp.serialize_unchecked(&mut bytes)
186            });
187        }
188
189        $crate::bencher::benchmark_group!(
190            group_ops,
191            rand,
192            mul_assign,
193            add_assign,
194            add_assign_mixed,
195            ser,
196            deser,
197            ser_unchecked,
198            deser_unchecked,
199        );
200    };
201}