Benchmarking wide circuits and other optimizations

.envrc

@@ -1 +1,2 @@
+watch_file proof-producer.nix parallel-crypto3.nix crypto3.nix verify-proofs.nix debug-tools.nix
 use flake ${PLACEHOLDER_DEVELOP_DERIVATION:-.}

.gitignore

@@ -647,3 +647,5 @@ callgrind.*
 
 # direnv outputs
 .direnv
+
+crypto3/libs/blueprint/test/zkevm_bbf/data/alchemy/sp1_block/

CMakeLists.txt

@@ -21,6 +21,21 @@ if(${SANITIZE})
   add_link_options(-fsanitize=undefined,address,leak)
 endif()
 
+option(ARITHMETIC_COUNTERS "Build with arithmetic counters" FALSE)
+if (${ARITHMETIC_COUNTERS})
+  add_compile_definitions(NIL_CO3_MP_ENABLE_ARITHMETIC_COUNTERS NIL_CO3_PROFILE_COUNT_ARITHMETIC_OPS)
+endif()
+
+option(PROFILING_ENABLED "Build with profiling enabled" FALSE)
+if (${PROFILING_ENABLED})
+  add_compile_definitions(PROFILING_ENABLED)
+endif()
+
+option(USE_X86_64_V3 "Build with x86-64-v3 microarchitecture level" FALSE)
+if (${USE_X86_64_V3})
+  add_compile_options(-march=x86-64-v3)
+endif()
+
 # Add dummy target for the more efficient reusing of precompiled headers
 file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generated-dummy.cpp)
 add_library(crypto3_precompiled_headers STATIC ${CMAKE_CURRENT_BINARY_DIR}/generated-dummy.cpp)

crypto3/benchmarks/zk/lpc.cpp

@@ -150,7 +150,7 @@ void lpc_test_case(std::size_t steps)
 
             std::map<std::size_t, typename lpc_scheme_type::commitment_type> commitments;
             {
-                PROFILE_SCOPE("polynomial commitment");
+                PROFILE_SCOPE("Polynomial commitment");
                 lpc_scheme_prover.append_to_batch(0, poly);
                 commitments[0] = lpc_scheme_prover.commit(0);
             }
@@ -159,15 +159,15 @@ void lpc_test_case(std::size_t steps)
             typename lpc_scheme_type::proof_type proof;
             std::array<std::uint8_t, 96> x_data{};
             {
-                PROFILE_SCOPE("proof generation");
+                PROFILE_SCOPE("Proof generation");
                 lpc_scheme_prover.append_eval_point(0,
                         algebra::fields::arithmetic_params<FieldType>::multiplicative_generator);
                 zk::transcript::fiat_shamir_heuristic_sequential<transcript_hash_type> transcript(x_data);
                 proof = lpc_scheme_prover.proof_eval(transcript);
             }
 
             {
-                PROFILE_SCOPE("verification");
+                PROFILE_SCOPE("Verification");
                 zk::transcript::fiat_shamir_heuristic_sequential<transcript_hash_type> transcript_verifier(x_data);
                 lpc_scheme_verifier.set_batch_size(0, proof.z.get_batch_size(0));
 

crypto3/libs/algebra/include/nil/crypto3/algebra/fields/arithmetic_params/babybear.hpp

@@ -40,6 +40,12 @@ namespace nil::crypto3::algebra::fields {
         constexpr static integral_type multiplicative_generator = 31u;
         constexpr static integral_type root_of_unity = 0x1a427a41u;
     };
+
+    template<>
+    struct arithmetic_params<babybear_montgomery_big_mod> : public arithmetic_params<babybear> {};
+
+    template<>
+    struct arithmetic_params<babybear_simple_31_bit> : public arithmetic_params<babybear> {};
 }  // namespace nil::crypto3::algebra::fields
 
 #endif  // CRYPTO3_ALGEBRA_FIELDS_BABYBEAR_ARITHMETIC_PARAMS_HPP

crypto3/libs/algebra/include/nil/crypto3/algebra/fields/babybear.hpp

@@ -56,6 +56,18 @@ namespace nil::crypto3::algebra::fields {
         using modular_type = nil::crypto3::multiprecision::auto_big_mod<modulus>;
         using value_type = detail::element_fp<params<babybear>>;
     };
+
+    class babybear_montgomery_big_mod : public babybear {
+      public:
+        using modular_type = nil::crypto3::multiprecision::montgomery_big_mod<modulus>;
+        using value_type = detail::element_fp<params<babybear_montgomery_big_mod>>;
+    };
+
+    class babybear_simple_31_bit : public babybear {
+      public:
+        using modular_type = nil::crypto3::multiprecision::big_mod_impl<nil::crypto3::multiprecision::detail::modular_ops_storage_ct<multiprecision::babybear_modulus, nil::crypto3::multiprecision::detail::simple_31_bit_modular_ops>>;
+        using value_type = detail::element_fp<params<babybear_simple_31_bit>>;
+    };
 }  // namespace nil::crypto3::algebra::fields
 
 #endif  // CRYPTO3_ALGEBRA_FIELDS_BABYBEAR_HPP

crypto3/libs/algebra/include/nil/crypto3/algebra/fields/detail/element/fp.hpp

@@ -91,12 +91,12 @@ namespace nil {
                             return *this == one();
                         }
 
-                        constexpr bool operator==(const element_fp &B) const {
-                            return data == B.data;
+                        constexpr auto operator<=>(const element_fp &B) const {
+                            return data.base() <=> B.data.base();
                         }
 
-                        constexpr bool operator!=(const element_fp &B) const {
-                            return data != B.data;
+                        constexpr bool operator==(const element_fp &B) const {
+                            return data == B.data;
                         }
 
                         constexpr element_fp &operator=(const element_fp &B) {
@@ -153,22 +153,6 @@ namespace nil {
                             return element_fp(data * B.data);
                         }
 
-                        constexpr bool operator<(const element_fp &B) const {
-                            return data.base() < B.data.base();
-                        }
-
-                        constexpr bool operator>(const element_fp &B) const {
-                            return data.base() > B.data.base();
-                        }
-
-                        constexpr bool operator<=(const element_fp &B) const {
-                            return data.base() <= B.data.base();
-                        }
-
-                        constexpr bool operator>=(const element_fp &B) const {
-                            return data.base() >= B.data.base();
-                        }
-
                         constexpr element_fp &operator++() {
                             data += one().data;
                             return *this;