1  // Copyright (c) 2019-2025 Alpha-Delta Network Inc.
  2  // This file is part of the deltavm library.
  3  
  4  // Licensed under the Apache License, Version 2.0 (the "License");
  5  // you may not use this file except in compliance with the License.
  6  // You may obtain a copy of the License at:
  7  
  8  // http://www.apache.org/licenses/LICENSE-2.0
  9  
 10  // Unless required by applicable law or agreed to in writing, software
 11  // distributed under the License is distributed on an "AS IS" BASIS,
 12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  // See the License for the specific language governing permissions and
 14  // limitations under the License.
 15  
 16  // Silences the false positives caused by black_box.
 17  #![allow(clippy::unit_arg)]
 18  
 19  use deltavm_fields::{Field, Fp256, Fp384, PrimeField};
 20  use deltavm_utilities::TestRng;
 21  
 22  use criterion::*;
 23  use rand::Rng;
 24  use std::{
 25      hint::black_box,
 26      ops::{AddAssign, MulAssign, SubAssign},
 27  };
 28  
 29  fn fp256(c: &mut Criterion) {
 30      let rng = &mut TestRng::default();
 31  
 32      const N: usize = 1_000;
 33  
 34      let mut values = Vec::with_capacity(N);
 35      let mut arr = [0u8; 32];
 36  
 37      while values.len() < N {
 38          rng.fill(&mut arr);
 39          if let Some(v) = Fp256::<deltavm_curves::bls12_377::FrParameters>::from_random_bytes(&arr) {
 40              values.push(v);
 41          }
 42      }
 43  
 44      c.bench_function("fp256_add_assign", |b| {
 45          b.iter(|| {
 46              for (mut v1, v2) in values.iter().cloned().zip(values.iter().skip(1)) {
 47                  black_box(v1.add_assign(v2));
 48              }
 49          })
 50      });
 51  
 52      c.bench_function("fp256_sub_assign", |b| {
 53          b.iter(|| {
 54              for (mut v1, v2) in values.iter().cloned().zip(values.iter().skip(1)) {
 55                  black_box(v1.sub_assign(v2));
 56              }
 57          })
 58      });
 59  
 60      c.bench_function("fp256_mul_assign", |b| {
 61          b.iter(|| {
 62              for (mut v1, v2) in values.iter().cloned().zip(values.iter().skip(1)) {
 63                  black_box(v1.mul_assign(v2));
 64              }
 65          })
 66      });
 67  
 68      c.bench_function("fp256_inverse", |b| {
 69          b.iter(|| {
 70              for v in values.iter() {
 71                  black_box(v.inverse());
 72              }
 73          })
 74      });
 75  
 76      c.bench_function("fp256_square_in_place", |b| {
 77          b.iter(|| {
 78              for mut v in values.iter().cloned() {
 79                  black_box(v.square_in_place());
 80              }
 81          })
 82      });
 83  
 84      c.bench_function("fp256_to_bigint", |b| {
 85          b.iter(|| {
 86              for v in values.iter() {
 87                  black_box(v.to_bigint());
 88              }
 89          })
 90      });
 91  }
 92  
 93  fn fp384(c: &mut Criterion) {
 94      let rng = &mut TestRng::default();
 95  
 96      const N: usize = 1_000;
 97  
 98      let mut values = Vec::with_capacity(N);
 99      let mut arr = [0u8; 48];
100  
101      while values.len() < N {
102          rng.fill(&mut arr[..32]);
103          rng.fill(&mut arr[32..]);
104          if let Some(v) = Fp384::<deltavm_curves::bls12_377::FqParameters>::from_random_bytes(&arr) {
105              values.push(v);
106          }
107      }
108  
109      c.bench_function("fp384_add_assign", |b| {
110          b.iter(|| {
111              for (mut v1, v2) in values.iter().cloned().zip(values.iter().skip(1)) {
112                  black_box(v1.add_assign(v2));
113              }
114          })
115      });
116  
117      c.bench_function("fp384_sub_assign", |b| {
118          b.iter(|| {
119              for (mut v1, v2) in values.iter().cloned().zip(values.iter().skip(1)) {
120                  black_box(v1.sub_assign(v2));
121              }
122          })
123      });
124  
125      c.bench_function("fp384_mul_assign", |b| {
126          b.iter(|| {
127              for (mut v1, v2) in values.iter().cloned().zip(values.iter().skip(1)) {
128                  black_box(v1.mul_assign(v2));
129              }
130          })
131      });
132  
133      c.bench_function("fp384_inverse", |b| {
134          b.iter(|| {
135              for v in values.iter() {
136                  black_box(v.inverse());
137              }
138          })
139      });
140  
141      c.bench_function("fp384_square_in_place", |b| {
142          b.iter(|| {
143              for mut v in values.iter().cloned() {
144                  black_box(v.square_in_place());
145              }
146          })
147      });
148  
149      c.bench_function("fp384_to_bigint", |b| {
150          b.iter(|| {
151              for v in values.iter() {
152                  black_box(v.to_bigint());
153              }
154          })
155      });
156  }
157  
158  criterion_group! {
159      name = fields;
160      config = Criterion::default();
161      targets = fp256, fp384
162  }
163  
164  criterion_main!(fields);