Merge branch 'main' into update-stark-docs

lambdaclass · Oct 19, 2023 · b7ad074 · b7ad074
2 parents a20b4ad + 8f7b415
commit b7ad074
Show file tree

Hide file tree

Showing 42 changed files with 747 additions and 706 deletions.
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -30,6 +30,10 @@ jobs:
       - name: Run cargo check
         run: cargo check
 
+      - name: Run cargo check cli
+        run: |
+          cargo check --features cli
+          
       - name: Run cargo check for math with no-std
         run: cargo check --package lambdaworks-math --no-default-features
 

diff --git a/Cargo.toml b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = ["math", "crypto", "gpu", "benches", "provers/plonk", "provers/stark", "provers/cairo", "provers/cairo-prover-cli"]
+members = ["math", "crypto", "gpu", "benches", "provers/plonk", "provers/stark", "provers/cairo", "provers/cairo"]
 exclude = ["ensure-no_std"]
 resolver = "2"
 

diff --git a/README.md b/README.md
@@ -70,7 +70,6 @@ So, we decided to build our library, focusing on performance, with clear documen
 - [Crypto primitives](https://github.com/lambdaclass/lambdaworks/tree/main/crypto)
 - [Plonk Prover](https://github.com/lambdaclass/lambdaworks/tree/main/provers/plonk)
 - [Cairo Prover](https://github.com/lambdaclass/lambdaworks/tree/main/provers/cairo)
-- [Cairo Prover CLI](https://github.com/lambdaclass/lambdaworks/tree/main/provers/cairo-prover-cli)
 
 If you are interested in proving Cairo programs, use the Cairo Prover CLI. 
 

diff --git a/math/Cargo.toml b/math/Cargo.toml
@@ -27,10 +27,11 @@ lambdaworks-gpu = { workspace = true, optional = true }
 
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false }
-criterion = "0.4"
+criterion = "0.5.1"
 const-random = "0.1.15"
 iai-callgrind.workspace = true
 proptest = "1.1.0"
+pprof = { version = "0.13.0", features = ["criterion","flamegraph"] }
 
 [features]
 rayon = ["dep:rayon"]

diff --git a/math/benches/criterion_field.rs b/math/benches/criterion_field.rs
@@ -1,102 +1,12 @@
-use std::hint::black_box;
-
 use criterion::{criterion_group, criterion_main, Criterion};
-use lambdaworks_math::{
-    field::fields::{
-        fft_friendly::stark_252_prime_field::{
-            MontgomeryConfigStark252PrimeField, Stark252PrimeField,
-        },
-        montgomery_backed_prime_fields::IsModulus,
-    },
-    unsigned_integer::{element::U256, montgomery::MontgomeryAlgorithms},
-};
-
-mod utils;
-use utils::u64_utils;
-
-pub fn starkfield_ops_benchmarks(c: &mut Criterion) {
-    let mut group = c.benchmark_group("Stark FP operations");
-    let (x, y) = u64_utils::get_field_elements();
-
-    group.bench_with_input("add", &(x, y), |bench, (x, y)| {
-        bench.iter(|| x + y);
-    });
-
-    group.bench_with_input("mul", &(x, y), |bench, (x, y)| {
-        bench.iter(|| x * y);
-    });
-
-    group.bench_with_input("pow by 1", &x, |bench, x| {
-        bench.iter(|| x.pow(1_u64));
-    });
-
-    // The non-boxed constants are intentional as they are
-    // normally computed at compile time.
-    group.bench_with_input("sos_square", &x, |bench, x| {
-        bench.iter(|| {
-            MontgomeryAlgorithms::sos_square(
-                black_box(x.value()),
-                &<MontgomeryConfigStark252PrimeField as IsModulus<U256>>::MODULUS,
-                &Stark252PrimeField::MU,
-            )
-        });
-    });
-
-    group.bench_with_input("square", &x, |bench, x| {
-        bench.iter(|| x.square());
-    });
-
-    group.bench_with_input("square with pow", &x, |bench, x| {
-        bench.iter(|| x.pow(2_u64));
-    });
-
-    group.bench_with_input("square with mul", &x, |bench, x| {
-        bench.iter(|| x * x);
-    });
-
-    group.bench_with_input("pow", &(x, 5u64), |bench, (x, y)| {
-        bench.iter(|| x.pow(*y));
-    });
-
-    group.bench_with_input("sub", &(x, y), |bench, (x, y)| {
-        bench.iter(|| x - y);
-    });
-
-    group.bench_with_input("inv", &x, |bench, x| {
-        bench.iter(|| x.inv().unwrap());
-    });
-
-    group.bench_with_input("div", &(x, y), |bench, (x, y)| {
-        bench.iter(|| x / y);
-    });
-
-    group.bench_with_input("eq", &(x, y), |bench, (x, y)| {
-        bench.iter(|| x == y);
-    });
-
-    group.bench_with_input("sqrt", &x, |bench, x| {
-        bench.iter(|| x.sqrt());
-    });
-
-    group.bench_with_input("sqrt squared", &(x * x), |bench, x| {
-        bench.iter(|| x.sqrt());
-    });
-
-    // Unsigned integer bitwise operations
-    let (x, y) = (x.value(), y.value());
-
-    group.bench_with_input("bitand", &(x, y), |bench, (&x, &y)| {
-        bench.iter(|| x & y);
-    });
-
-    group.bench_with_input("bitor", &(x, y), |bench, (&x, &y)| {
-        bench.iter(|| x | y);
-    });
+use pprof::criterion::{Output, PProfProfiler};
 
-    group.bench_with_input("bitxor", &(x, y), |bench, (&x, &y)| {
-        bench.iter(|| x ^ y);
-    });
-}
+mod fields;
+use fields::stark252::starkfield_ops_benchmarks;
 
-criterion_group!(starkfp, starkfield_ops_benchmarks);
-criterion_main!(starkfp);
+criterion_group!(
+    name = field_benches;
+    config = Criterion::default().with_profiler(PProfProfiler::new(100, Output::Flamegraph(None)));
+    targets = starkfield_ops_benchmarks
+);
+criterion_main!(field_benches);
diff --git a/math/benches/fields/mod.rs b/math/benches/fields/mod.rs
@@ -0,0 +1 @@
+pub mod stark252;
diff --git a/math/benches/fields/stark252.rs b/math/benches/fields/stark252.rs
@@ -0,0 +1,230 @@
+use std::hint::black_box;
+
+use criterion::Criterion;
+use lambdaworks_math::{
+    field::{
+        element::FieldElement,
+        fields::{
+            fft_friendly::stark_252_prime_field::{
+                MontgomeryConfigStark252PrimeField, Stark252PrimeField,
+            },
+            montgomery_backed_prime_fields::IsModulus,
+        },
+    },
+    unsigned_integer::{
+        element::{UnsignedInteger, U256},
+        montgomery::MontgomeryAlgorithms,
+    },
+};
+use rand::random;
+
+pub type F = FieldElement<Stark252PrimeField>;
+
+#[inline(never)]
+#[no_mangle]
+#[export_name = "util::rand_field_elements"]
+pub fn rand_field_elements(num: usize) -> Vec<(F, F)> {
+    let mut result = Vec::with_capacity(num);
+    for _ in 0..result.capacity() {
+        let rand_a = UnsignedInteger { limbs: random() };
+        let rand_b = UnsignedInteger { limbs: random() };
+        result.push((F::new(rand_a), F::new(rand_b)));
+    }
+    result
+}
+
+pub fn starkfield_ops_benchmarks(c: &mut Criterion) {
+    let input: Vec<Vec<(F, F)>> = [1, 10, 100, 1000, 10000, 100000, 1000000]
+        .into_iter()
+        .map(rand_field_elements)
+        .collect::<Vec<_>>();
+    let mut group = c.benchmark_group("Stark FP operations");
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("add {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, y) in i {
+                    black_box(black_box(x) + black_box(y));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("mul {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, y) in i {
+                    black_box(black_box(x) * black_box(y));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("pow by 1 {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, _) in i {
+                    black_box(black_box(x).pow(1_u64));
+                }
+            });
+        });
+    }
+
+    // The non-boxed constants are intentional as they are
+    // normally computed at compile time.
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("sos_square {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, _) in i {
+                    MontgomeryAlgorithms::sos_square(
+                        black_box(black_box(x.value())),
+                        &<MontgomeryConfigStark252PrimeField as IsModulus<U256>>::MODULUS,
+                        &Stark252PrimeField::MU,
+                    );
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("square {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, _) in i {
+                    black_box(black_box(x).square());
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("square with pow {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, _) in i {
+                    black_box(black_box(x).pow(2_u64));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("square with mul {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, _) in i {
+                    black_box(black_box(x) * black_box(x));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(
+            format!("pow {:?}", &i.len()),
+            &(i, 5u64),
+            |bench, (i, a)| {
+                bench.iter(|| {
+                    for (x, _) in i {
+                        black_box(black_box(x).pow(*a));
+                    }
+                });
+            },
+        );
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("sub {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, y) in i {
+                    black_box(black_box(x) - black_box(y));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("inv {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, _) in i {
+                    black_box(black_box(x).inv().unwrap());
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("div {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, y) in i {
+                    black_box(black_box(x) / black_box(y));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("eq {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, y) in i {
+                    black_box(black_box(x) == black_box(y));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("sqrt {:?}", &i.len()), &i, |bench, i| {
+            bench.iter(|| {
+                for (x, _) in i {
+                    black_box(black_box(x).sqrt());
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("sqrt squared {:?}", &i.len()), &i, |bench, i| {
+            let i: Vec<F> = i.iter().map(|(x, _)| x * x).collect();
+            bench.iter(|| {
+                for x in &i {
+                    black_box(black_box(x).sqrt());
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("bitand {:?}", &i.len()), &i, |bench, i| {
+            // Note: we should strive to have the number of limbs be generic... ideally this benchmark group itself should have a generic type that we call into from the main runner.
+            let i: Vec<(UnsignedInteger<4>, UnsignedInteger<4>)> =
+                i.iter().map(|(x, y)| (*x.value(), *y.value())).collect();
+            bench.iter(|| {
+                for (x, y) in &i {
+                    black_box(black_box(*x) & black_box(*y));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("bitor {:?}", &i.len()), &i, |bench, i| {
+            let i: Vec<(UnsignedInteger<4>, UnsignedInteger<4>)> =
+                i.iter().map(|(x, y)| (*x.value(), *y.value())).collect();
+            bench.iter(|| {
+                for (x, y) in &i {
+                    black_box(black_box(*x) | black_box(*y));
+                }
+            });
+        });
+    }
+
+    for i in input.clone().into_iter() {
+        group.bench_with_input(format!("bitxor {:?}", &i.len()), &i, |bench, i| {
+            let i: Vec<(UnsignedInteger<4>, UnsignedInteger<4>)> =
+                i.iter().map(|(x, y)| (*x.value(), *y.value())).collect();
+            bench.iter(|| {
+                for (x, y) in &i {
+                    black_box(black_box(*x) ^ black_box(*y));
+                }
+            });
+        });
+    }
+}