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 add_assign_mixed(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, $affine)> = (0..SAMPLES)
 51                .map(|_| {
 52                    (
 53                        <$projective>::rand(&mut rng),
 54                        <$projective>::rand(&mut rng).into(),
 55                    )
 56                })
 57                .collect();
 58
 59            let mut count = 0;
 60            b.iter(|| {
 61                let mut tmp = v[count].0;
 62                n_fold!(tmp, v, add_assign_mixed, count);
 63                count = (count + 1) % SAMPLES;
 64                tmp
 65            });
 66        }
 67
 68        fn double(b: &mut $crate::bencher::Bencher) {
 69            const SAMPLES: usize = 1000;
 70
 71            let mut rng = XorShiftRng::seed_from_u64(1231275789u64);
 72
 73            let v: Vec<($projective, $projective)> = (0..SAMPLES)
 74                .map(|_| (<$projective>::rand(&mut rng), <$projective>::rand(&mut rng)))
 75                .collect();
 76
 77            let mut count = 0;
 78            b.iter(|| {
 79                let mut tmp = v[count].0;
 80                n_fold!(tmp, double_in_place);
 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        $crate::benchmark_group!(
182            group_ops,
183            rand,
184            mul_assign,
185            add_assign,
186            add_assign_mixed,
187            ser,
188            deser,
189            ser_unchecked,
190            deser_unchecked,
191        );
192    };
193}