Small Fields

.github/workflows/rust.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches: [ main ]
   pull_request:
-    branches: [ main ]
+    branches-ignore: []
 
 env:
   CARGO_TERM_COLOR: always

Cargo.toml

@@ -10,10 +10,16 @@ edition = "2021"
 [dependencies]
 ark-ff = "0.5.0"
 ark-poly = "0.5.0"
+ark-std = "0.5.0"
 ark-serialize = "0.5.0"
-ark-std ="0.5.0"
+num-bigint = "0.4"
+num-traits = "0.2"
+zeroize = "1.8.1"
+itertools = "0.10.5"
+educe = "0.6.0"
 memmap2 = "0.9.5"
 rayon = { version = "1.10", optional = true }
+fields_macro = { path = "fields_macro" }
 
 [dev-dependencies]
 criterion = "0.7"
@@ -31,3 +37,13 @@ parallel = [
 name = "provers"
 path = "benches/provers.rs"
 harness = false
+
+[[bench]]
+name = "arithmetic_backend"
+path = "benches/arithmetic_backend.rs"
+harness = false
+
+[[bench]]
+name = "cast_128"
+path = "benches/cast_128.rs"
+harness = false

benches/arithmetic_backend.rs

@@ -0,0 +1,33 @@
+use ark_ff::Field;
+use criterion::{criterion_group, criterion_main, Criterion};
+use space_efficient_sumcheck::tests::{SmallF32, SmallF32Mont};
+use std::hint::black_box;
+
+fn bench_mul_standard(c: &mut Criterion) {
+    c.bench_function("SmallField_mul", |b| {
+        b.iter(|| {
+            let mut v = SmallF32::ONE;
+            let v2 = SmallF32::new(20);
+            for _ in 0..1_000_000 {
+                v *= v2;
+            }
+            black_box(v);
+        })
+    });
+}
+
+fn bench_mul_montgomery(c: &mut Criterion) {
+    c.bench_function("SmallFieldMont_mul", |b| {
+        b.iter(|| {
+            let mut v = SmallF32Mont::ONE;
+            let v2 = SmallF32Mont::new(20);
+            for _ in 0..1_000_000 {
+                v *= v2;
+            }
+            black_box(v);
+        })
+    });
+}
+
+criterion_group!(benches, bench_mul_standard, bench_mul_montgomery);
+criterion_main!(benches);

benches/cast_128.rs

@@ -0,0 +1,49 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+fn mult_u128(c: &mut Criterion) {
+    c.bench_function("u128_mult", |b| {
+        b.iter(|| {
+            let a: u8 = 5;
+            let b: u8 = 254;
+            let c: u128 = (a as u128) * (b as u128);
+            black_box((c % 255) as u8);
+        })
+    });
+}
+
+fn mult_u16(c: &mut Criterion) {
+    c.bench_function("u16_mult", |b| {
+        b.iter(|| {
+            let a: u8 = 5;
+            let b: u8 = 254;
+            let c: u16 = (a as u16) * (b as u16);
+            black_box((c % 255) as u8);
+        })
+    });
+}
+
+fn add_u128(c: &mut Criterion) {
+    c.bench_function("u128_add", |b| {
+        b.iter(|| {
+            let a: u8 = 5;
+            let b: u8 = 254;
+            let c: u128 = (a as u128) + (b as u128);
+            black_box((c % 255) as u8);
+        })
+    });
+}
+
+fn add_u16(c: &mut Criterion) {
+    c.bench_function("u8_add", |b| {
+        b.iter(|| {
+            let a: u8 = 5;
+            let b: u8 = 25;
+            let c: u8 = a + b;
+            black_box((c % 255) as u8);
+        })
+    });
+}
+
+criterion_group!(benches, mult_u128, mult_u16, add_u128, add_u16);
+criterion_main!(benches);

benches/explanation.rs

@@ -1,5 +1,7 @@
 fn main() {
     eprintln!("Error: This project uses a custom benchmarking workflow.");
-    eprintln!("Please navigate to the appropriate bench directory and call the shell './run_bench.sh' directly.");
+    eprintln!("Please choose a bench:");
+    eprintln!("   Full Protocol Benches: 'cd ./benches/sumcheck-benches/ && cargo build --release && ./run_benches.sh'");
+    eprintln!("   Lagrange Polynomial Benches: 'cd ./benches/lag-poly-benches/ && cargo build --release && ./run_benches.sh'");
     std::process::exit(1);
 }

benches/sumcheck-benches/src/main.rs

@@ -8,13 +8,13 @@ use space_efficient_sumcheck::{
         TimeProverConfig,
     },
     multilinear_product::{
-        BlendyProductProver, BlendyProductProverConfig, TimeProductProver, TimeProductProverConfig, SpaceProductProver,
-        SpaceProductProverConfig,
+        BlendyProductProver, BlendyProductProverConfig, SpaceProductProver,
+        SpaceProductProverConfig, TimeProductProver, TimeProductProverConfig,
     },
     order_strategy::SignificantBitOrder,
     prover::{Prover, ProverConfig},
     streams::{multivariate_claim, multivariate_product_claim},
-    tests::{BenchStream, F128, F64},
+    tests::{BenchStream, SmallF128, SmallF32, SmallF64, F128, F64},
     ProductSumcheck, Sumcheck,
 };
 
@@ -34,11 +34,10 @@ fn run_on_field<F: Field>(bench_args: BenchArgs) {
                     bench_args.num_variables,
                     s,
                 );
-            let transcript =
-                Sumcheck::<F>::prove::<BenchStream<F>, BlendyProver<F, BenchStream<F>>>(
-                    &mut BlendyProver::<F, BenchStream<F>>::new(config),
-                    &mut rng,
-                );
+            let transcript = Sumcheck::<F>::prove::<BenchStream<F>, BlendyProver<F, BenchStream<F>>>(
+                &mut BlendyProver::<F, BenchStream<F>>::new(config),
+                &mut rng,
+            );
             assert!(transcript.is_accepted);
         }
         AlgorithmLabel::VSBW => {
@@ -133,5 +132,14 @@ fn main() {
         FieldLabel::FieldBn254 => {
             run_on_field::<BN254Field>(bench_args);
         }
+        FieldLabel::SmallF32 => {
+            run_on_field::<SmallF32>(bench_args);
+        }
+        FieldLabel::SmallF64 => {
+            run_on_field::<SmallF64>(bench_args);
+        }
+        FieldLabel::SmallF128 => {
+            run_on_field::<SmallF128>(bench_args);
+        }
     };
 }

benches/sumcheck-benches/src/validation/mod.rs

@@ -3,6 +3,9 @@ pub enum FieldLabel {
     Field64,
     Field128,
     FieldBn254,
+    SmallF32,
+    SmallF64,
+    SmallF128,
 }
 
 #[derive(Debug)]
@@ -62,17 +65,28 @@ pub fn validate_and_format_command_line_args(argsv: Vec<String>) -> BenchArgs {
         _ => AlgorithmLabel::ProductBlendy, // this is checked in previous line
     };
     // field_label
-    if !(argsv[2] == "Field64" || argsv[2] == "Field128" || argsv[2] == "FieldBn254") {
+    if !(argsv[2] == "Field64"
+        || argsv[2] == "Field128"
+        || argsv[2] == "FieldBn254"
+        || argsv[2] == "SmallF32"
+        || argsv[2] == "SmallF64"
+        || argsv[2] == "SmallF128")
+    {
         eprintln!(
             "Usage: {} field_label algorithm_label num_variables stage_size",
             argsv[0]
         );
-        eprintln!("Invalid input: field_label must be one of (Field64, Field128, FieldBn254)");
+        eprintln!(
+            "Invalid input: field_label must be one of (Field64, Field128, FieldBn254, SmallF32, SmallF64, SmallF128)"
+        );
         std::process::exit(1);
     }
     let field_label = match argsv[2].as_str() {
         "Field64" => FieldLabel::Field64,
         "Field128" => FieldLabel::Field128,
+        "SmallF32" => FieldLabel::SmallF32,
+        "SmallF64" => FieldLabel::SmallF64,
+        "SmallF128" => FieldLabel::SmallF128,
         _ => FieldLabel::FieldBn254, // this is checked in previous line
     };
     // num_variables