chore(avm)!: gas gt migrations optimized (#16989)

This PR re-introduces the reverted PR #16856 which caused a performance
regression in "Log derivative inverse commitments".

After the introduction of separate destination lookup selectors, this
original PR does not affect the performance.

We introduce a specific gt selectors for the gas accounting (gt.sel_gas)
while for the specific gt lookups involved by the CALL opcode, we used
the already existing gt.sel_others selector. The reason is that we
expect much less gt events produced by the latter one.

Benchmarks on mainframe with 16 cores did not lead to any significant
performance changes (ca. 2.5 seconds for the derivative inverse
commitments).

Author: jeanmon

barretenberg/cpp/pil/vm2/context.pil

@@ -485,8 +485,8 @@ namespace execution;
 
     // If any error happened during execution (i.e., sel_error=1), all gas should be consumed.
     pol SEL_CONSUMED_ALL_GAS = sel_error;
-    (l2_gas_limit - PREV_GAS_PLUS_USAGE_L2) * SEL_CONSUMED_ALL_GAS + PREV_GAS_PLUS_USAGE_L2 - l2_gas_used = 0;
-    (da_gas_limit - PREV_GAS_PLUS_USAGE_DA) * SEL_CONSUMED_ALL_GAS + PREV_GAS_PLUS_USAGE_DA - da_gas_used = 0;
+    (l2_gas_limit - total_gas_l2) * SEL_CONSUMED_ALL_GAS + total_gas_l2 - l2_gas_used = 0;
+    (da_gas_limit - total_gas_da) * SEL_CONSUMED_ALL_GAS + total_gas_da - da_gas_used = 0;
 
     // nested_exit_call = 1 <==> prev_gas_used' = parent_gas_used + gas_used
     // sel_enter_call   = 1 <==> prev_gas_used' = 0

barretenberg/cpp/pil/vm2/execution/gas.pil

@@ -1,5 +1,5 @@
 include "../precomputed.pil";
-include "../range_check.pil";
+include "../gt.pil";
 
 // This is a virtual gadget, which is part of the execution trace.
 // https://excalidraw.com/#json=-fkwtFjYVOq2Z69Q351AE,O3SbjwK5eHX7-Oz2OH8RqQ
@@ -49,8 +49,8 @@ namespace execution;
     // ==== COMPARISON AGAINST THE LIMITS ====
 
     // We will sum up all the gas used (base and dynamic) and compare just once.
-    pol TOTAL_L2_GAS_USED = BASE_L2_GAS + DYNAMIC_L2_GAS_USED;
-    pol TOTAL_DA_GAS_USED = base_da_gas + DYNAMIC_DA_GAS_USED;
+    pol L2_GAS_USED = BASE_L2_GAS + DYNAMIC_L2_GAS_USED;
+    pol DA_GAS_USED = base_da_gas + DYNAMIC_DA_GAS_USED;
 
     // We are going to do 64 bit comparisons. If we assume:
     // prev_l2_gas_used to be u32::MAX_VALUE
@@ -59,43 +59,24 @@ namespace execution;
     // dynamic_da_gas to be u32::MAX_VALUE
     // Then prev_l2_gas_used + BASE_L2_GAS + dynamic_l2_gas_factor*dynamic_da_gas is exactly u64::MAX_VALUE.
 
-    pol commit constant_64;
-    sel_should_check_gas * (64 - constant_64) = 0;
-
-    pol commit out_of_gas_l2;
-    out_of_gas_l2 * (1 - out_of_gas_l2) = 0;
-    pol commit out_of_gas_da;
-    out_of_gas_da * (1 - out_of_gas_da) = 0;
-
-    pol PREV_GAS_PLUS_USAGE_L2 = prev_l2_gas_used + TOTAL_L2_GAS_USED;
-    // Assumes l2_gas_limit is 32 bit and PREV_GAS_PLUS_USAGE_L2 is 64 bit
-    // So we perform a 64 bit comparison
-    pol LIMIT_GTE_USED_L2 = l2_gas_limit - PREV_GAS_PLUS_USAGE_L2;
-    pol LIMIT_LT_USED_L2 =  PREV_GAS_PLUS_USAGE_L2 - l2_gas_limit - 1;
-    pol commit limit_used_l2_cmp_diff;
-    // We multiply by sel_should_check_gas to force a 0 if we shouldn't check the gas.
-    #[L2_CMP_DIFF]
-    limit_used_l2_cmp_diff = sel_should_check_gas * ((LIMIT_LT_USED_L2 - LIMIT_GTE_USED_L2) * out_of_gas_l2 + LIMIT_GTE_USED_L2);
-
-    #[LIMIT_USED_L2_RANGE]
-    sel_should_check_gas { limit_used_l2_cmp_diff, constant_64 }
-    in
-    range_check.sel { range_check.value, range_check.rng_chk_bits };
-
-    pol PREV_GAS_PLUS_USAGE_DA = prev_da_gas_used + TOTAL_DA_GAS_USED;
-    // Assumes da_gas_limit is 32 bit and PREV_GAS_PLUS_USAGE_DA is 64 bit
-    // So we perform a 64 bit comparison
-    pol LIMIT_GTE_USED_DA = da_gas_limit - PREV_GAS_PLUS_USAGE_DA;
-    pol LIMIT_LT_USED_DA =  PREV_GAS_PLUS_USAGE_DA - da_gas_limit - 1;
-    pol commit limit_used_da_cmp_diff;
-    // We multiply by sel_should_check_gas to force a 0 if we shouldn't check the gas.
-    #[DA_CMP_DIFF]
-    limit_used_da_cmp_diff = sel_should_check_gas * ((LIMIT_LT_USED_DA - LIMIT_GTE_USED_DA) * out_of_gas_da + LIMIT_GTE_USED_DA);
-
-    #[LIMIT_USED_DA_RANGE]
-    sel_should_check_gas { limit_used_da_cmp_diff, constant_64 }
-    in
-    range_check.sel { range_check.value, range_check.rng_chk_bits };
+    pol commit out_of_gas_l2; // Boolean constraint enforced through lookup into gt.
+    pol commit out_of_gas_da; // Boolean constraint enforced through lookup into gt.
+
+    // TODO: Once we support expression in lookup, we can replace this column by an alias.
+    pol commit total_gas_l2;
+    total_gas_l2 = prev_l2_gas_used + L2_GAS_USED;
+    // Assumes l2_gas_limit is 32 bit and total_gas_l2 is 64 bit.
+
+    #[IS_OUT_OF_GAS_L2]
+    sel_should_check_gas { total_gas_l2, l2_gas_limit, out_of_gas_l2 } in gt.sel_gas { gt.input_a, gt.input_b, gt.res };
+
+    // TODO: Once we support expression in lookup, we can replace this column by an alias.
+    pol commit total_gas_da;
+    total_gas_da = prev_da_gas_used + DA_GAS_USED;
+    // Assumes da_gas_limit is 32 bit and total_gas_da is 64 bit.
+
+    #[IS_OUT_OF_GAS_DA]
+    sel_should_check_gas { total_gas_da, da_gas_limit, out_of_gas_da } in gt.sel_gas { gt.input_a, gt.input_b, gt.res };
 
     pol commit sel_out_of_gas;
     sel_out_of_gas = 1 - (1 - out_of_gas_l2) * (1 - out_of_gas_da);

barretenberg/cpp/pil/vm2/ff_gt.pil

@@ -46,7 +46,7 @@ namespace ff_gt;
     pol commit a;
     pol commit b;
     pol commit result;
-    (result * (1 - result)) = 0;
+    result * (1 - result) = 0;
 
     // Should be looked up based on this selector
     // This will be off when doing the shifts for the remaning range constraints.

barretenberg/cpp/pil/vm2/gt.pil

@@ -21,13 +21,15 @@ namespace gt;
     pol commit sel_sha256;
     pol commit sel_addressing;
     pol commit sel_alu;
+    pol commit sel_gas;
     pol commit sel_others;  // Any other lookup into this trace.
     sel_sha256 * (1 - sel_sha256) = 0;
     sel_addressing * (1 - sel_addressing) = 0;
     sel_alu * (1 - sel_alu) = 0;
+    sel_gas * (1 - sel_gas) = 0;
     sel_others * (1 - sel_others) = 0;
     // If any of the above selectors is 1, then sel must be 1.
-    (sel_sha256 + sel_addressing + sel_alu + sel_others) * (1 - sel) = 0;
+    (sel_sha256 + sel_addressing + sel_alu + sel_gas + sel_others) * (1 - sel) = 0;
 
     #[skippable_if]
     sel = 0;

barretenberg/cpp/pil/vm2/opcodes/external_call.pil

@@ -8,55 +8,39 @@ namespace execution;
 #[skippable_if]
 sel_enter_call = 0;
 
-// TODO: Remove this as a column when we can lookup with constants
-pol commit constant_32;
-sel_enter_call * (32 - constant_32) = 0;
-
 // ==== GAS CLAMPING ====
 // Guaranteed not to wrap since we never put a gas used > gas limit
-pol L2_GAS_LEFT = l2_gas_limit - l2_gas_used;
-pol DA_GAS_LEFT = da_gas_limit - da_gas_used;
+
+// TODO: Once we support expression in lookup, we can replace this column by an alias.
+pol commit l2_gas_left;
+l2_gas_left = sel_enter_call * (l2_gas_limit - l2_gas_used);
+
+// TODO: Once we support expression in lookup, we can replace this column by an alias.
+pol commit da_gas_left;
+da_gas_left = sel_enter_call * (da_gas_limit - da_gas_used);
+
 
 // L2 gas clamping
 
 // Compare the gas allocated to the call by the user, with the gas left.
 // Helper column containing whether the allocated gas is less than the left gas
-pol commit call_is_l2_gas_allocated_lt_left;
-call_is_l2_gas_allocated_lt_left * (1 - call_is_l2_gas_allocated_lt_left) = 0;
+pol commit call_is_l2_gas_allocated_lt_left; // Guaranteed to be boolean through the gt lookup. (provided that sel_enter_call == 1)
 
+#[CALL_IS_L2_GAS_ALLOCATED_LT_LEFT]
+sel_enter_call { l2_gas_left, register[0], call_is_l2_gas_allocated_lt_left } in gt.sel_others { gt.input_a, gt.input_b, gt.res };
 
-pol ALLOCATED_GTE_LEFT_L2 = register[0] - L2_GAS_LEFT;
-pol ALLOCATED_LT_LEFT_L2 = L2_GAS_LEFT - register[0] - 1;
-pol commit call_allocated_left_l2_cmp_diff;
-sel_enter_call * ((ALLOCATED_LT_LEFT_L2 - ALLOCATED_GTE_LEFT_L2) * call_is_l2_gas_allocated_lt_left + ALLOCATED_GTE_LEFT_L2 - call_allocated_left_l2_cmp_diff) = 0;
+// next row's l2_gas_limit = if call_is_l2_gas_allocated_lt_left { register[0] } else { l2_gas_left }
+sel_enter_call * ((register[0] - l2_gas_left) * call_is_l2_gas_allocated_lt_left + l2_gas_left - l2_gas_limit') = 0;
 
-#[CALL_ALLOCATED_LEFT_L2_RANGE]
-sel_enter_call { call_allocated_left_l2_cmp_diff, constant_32 }
-in
-range_check.sel
-    { range_check.value, range_check.rng_chk_bits };
-
-// next row's l2_gas_limit = if call_is_l2_gas_allocated_lt_left { register[0] } else { L2_GAS_LEFT }
-sel_enter_call * ((register[0] - L2_GAS_LEFT) * call_is_l2_gas_allocated_lt_left + L2_GAS_LEFT - l2_gas_limit') = 0;
 
 // DA gas clamping
 
 // Compare the gas allocated to the call by the user, with the gas left.
 // Helper column containing whether the allocated gas is less than the left gas
-pol commit call_is_da_gas_allocated_lt_left;
-call_is_da_gas_allocated_lt_left * (1 - call_is_da_gas_allocated_lt_left) = 0;
-
-pol ALLOCATED_GTE_LEFT_DA = register[1] - DA_GAS_LEFT;
-pol ALLOCATED_LT_LEFT_DA = DA_GAS_LEFT - register[1] - 1;
-pol commit call_allocated_left_da_cmp_diff;
-sel_enter_call * ((ALLOCATED_LT_LEFT_DA - ALLOCATED_GTE_LEFT_DA) * call_is_da_gas_allocated_lt_left + ALLOCATED_GTE_LEFT_DA - call_allocated_left_da_cmp_diff) = 0;
-
-#[CALL_ALLOCATED_LEFT_DA_RANGE]
-sel_enter_call { call_allocated_left_da_cmp_diff, constant_32 }
-in
-range_check.sel
-    { range_check.value, range_check.rng_chk_bits };
+pol commit call_is_da_gas_allocated_lt_left; // Guaranteed to be boolean through the gt lookup. (provided that sel_enter_call == 1)
 
-// next row's da_gas_limit = if call_is_da_gas_allocated_lt_left { reg2 } else { DA_GAS_LEFT }
-sel_enter_call * ((register[1] - DA_GAS_LEFT) * call_is_da_gas_allocated_lt_left + DA_GAS_LEFT - da_gas_limit') = 0;
+#[CALL_IS_DA_GAS_ALLOCATED_LT_LEFT]
+sel_enter_call { da_gas_left, register[1], call_is_da_gas_allocated_lt_left } in gt.sel_others { gt.input_a, gt.input_b, gt.res };
 
+// next row's da_gas_limit = if call_is_da_gas_allocated_lt_left { register[1] } else { da_gas_left }
+sel_enter_call * ((register[1] - da_gas_left) * call_is_da_gas_allocated_lt_left + da_gas_left - da_gas_limit') = 0;

barretenberg/cpp/src/barretenberg/vm2/constraining/relations/addressing.test.cpp

@@ -3,7 +3,6 @@
 
 #include <cstdint>
 
-#include "barretenberg/common/serialize.hpp"
 #include "barretenberg/vm2/common/memory_types.hpp"
 #include "barretenberg/vm2/constraining/flavor_settings.hpp"
 #include "barretenberg/vm2/constraining/testing/check_relation.hpp"