evmmax: Benchmark ate pairing

Co-authored-by: Paweł Bylica <[email protected]>

Author: rodiazet

test/precompiles_bench/precompiles_bench.cpp

@@ -32,7 +32,7 @@ constexpr auto analyze<PrecompileId::ecadd> = ecadd_analyze;
 template <>
 constexpr auto analyze<PrecompileId::ecmul> = ecmul_analyze;
 template <>
-[[maybe_unused]] constexpr auto analyze<PrecompileId::ecpairing> = ecpairing_analyze;
+constexpr auto analyze<PrecompileId::ecpairing> = ecpairing_analyze;
 
 template <PrecompileId>
 const inline std::array inputs{0};
@@ -185,6 +185,8 @@ BENCHMARK_TEMPLATE(precompile, PrecompileId::ecmul, libff);
 
 namespace bench_ecpairing
 {
+constexpr auto evmmax_cpp = ecpairing_execute;
+BENCHMARK_TEMPLATE(precompile, PrecompileId::ecpairing, evmmax_cpp);
 #ifdef EVMONE_PRECOMPILES_SILKPRE
 constexpr auto libff = silkpre_ecpairing_execute;
 BENCHMARK_TEMPLATE(precompile, PrecompileId::ecpairing, libff);

test/state/precompiles.cpp

@@ -240,6 +240,63 @@ ExecutionResult identity_execute(const uint8_t* input, size_t input_size, uint8_
     return {EVMC_SUCCESS, input_size};
 }
 
+ExecutionResult ecpairing_execute(const uint8_t* input, size_t input_size, uint8_t* output,
+    [[maybe_unused]] size_t output_size) noexcept
+{
+    assert(output_size >= 32);
+
+    const auto pair_size = 192;
+
+    if (input_size % pair_size != 0)
+        return {EVMC_PRECOMPILE_FAILURE, 0};
+
+    const auto pair_count = input_size / pair_size;
+
+    if (pair_count > 0)
+    {
+        auto input_idx = input;
+
+        std::vector<evmmax::bn254::Point> vG1(pair_count);
+        std::vector<evmmax::bn254::ExtPoint> vG2(pair_count);
+
+        for (size_t i = 0; i < pair_count; ++i)
+        {
+            const evmmax::bn254::Point p = {
+                intx::be::unsafe::load<intx::uint256>(input_idx),
+                intx::be::unsafe::load<intx::uint256>(input_idx + 32),
+            };
+
+            const evmmax::bn254::ExtPoint q = {
+                {intx::be::unsafe::load<intx::uint256>(input_idx + 96),
+                    intx::be::unsafe::load<intx::uint256>(input_idx + 64)},
+                {intx::be::unsafe::load<intx::uint256>(input_idx + 160),
+                    intx::be::unsafe::load<intx::uint256>(input_idx + 128)},
+            };
+
+            vG1[i] = p;
+            vG2[i] = q;
+
+            input_idx += pair_size;
+        }
+
+        const auto res = evmmax::bn254::pairing(vG2, vG1);
+
+        if (res.has_value())
+        {
+            intx::be::unsafe::store(output, res.value() ? intx::uint256{1} : intx::uint256{0});
+            return {EVMC_SUCCESS, 64};
+        }
+        else
+            return {EVMC_PRECOMPILE_FAILURE, 0};
+    }
+    else
+    {
+        intx::be::unsafe::store(output, intx::uint256{1});
+        return {EVMC_SUCCESS, 32};
+    }
+}
+
+
 namespace
 {
 struct PrecompileTraits

test/state/precompiles_internal.hpp

@@ -38,4 +38,6 @@ ExecutionResult ecadd_execute(
     const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
 ExecutionResult ecmul_execute(
     const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
+ExecutionResult ecpairing_execute(
+    const uint8_t* input, size_t input_size, uint8_t* output, size_t output_size) noexcept;
 }  // namespace evmone::state