Merge branch 'merge-train/barretenberg' into ad/bbapi/vk-simplified-buffer

Author: ludamad

.test_patterns.yml

@@ -45,23 +45,19 @@ tests:
     error_regex: "field_t::range_constraint"
     owners:
       - *luke
-  - regex: "barretenberg/acir_tests/scripts/run_test_browser.sh"
+  - regex: "barretenberg/acir_tests/scripts/browser_prove.sh"
     error_regex: "Failed to fetch"
     owners:
       - *adam
-  - regex: "barretenberg/acir_tests/scripts/run_test_browser.sh"
-    error_regex: "Failed to fetch"
-    owners:
-      - *adam
-  - regex: "barretenberg/acir_tests/scripts/run_test_browser.sh"
+  - regex: "barretenberg/acir_tests/scripts/browser_prove.sh"
     error_regex: "RuntimeError: Out of bounds memory access"
     owners:
       - *adam
-  - regex: "barretenberg/acir_tests/scripts/run_test_browser.sh"
+  - regex: "barretenberg/acir_tests/scripts/browser_prove.sh"
     error_regex: "call_indirect to a null table entry"
     owners:
       - *adam
-  - regex: "barretenberg/acir_tests/scripts/run_test_browser.sh"
+  - regex: "barretenberg/acir_tests/scripts/browser_prove.sh"
     error_regex: "Input is not large enough"
     owners:
       - *adam

barretenberg/cpp/CMakePresets.json

@@ -250,7 +250,8 @@
       "cacheVariables": {
         "ENABLE_ASAN": "ON",
         "DISABLE_AZTEC_VM": "ON",
-        "DISABLE_ASM": "ON"
+        "DISABLE_ASM": "ON",
+        "ENABLE_STACKTRACES": "OFF"
       }
     },
     {
@@ -261,7 +262,8 @@
       "binaryDir": "build-asan",
       "cacheVariables": {
         "ENABLE_ASAN": "ON",
-        "DISABLE_ASM": "ON"
+        "DISABLE_ASM": "ON",
+        "ENABLE_STACKTRACES": "OFF"
       }
     },
     {

barretenberg/cpp/pil/vm2/execution/addressing.pil

@@ -128,11 +128,9 @@ pol NUM_RELATIVE_E = 1 - sel_do_base_check;
 #[NUM_RELATIVE_INV_CHECK]
 NUM_RELATIVE_X * (NUM_RELATIVE_E * (1 - NUM_RELATIVE_Y) + NUM_RELATIVE_Y) - 1 + NUM_RELATIVE_E = 0;
 
-// FIXME: this should eventually be a permutation.
 #[BASE_ADDRESS_FROM_MEMORY]
 sel_do_base_check { precomputed.clk, context_id, /*address=*/precomputed.zero, /*value=*/base_address_val, /*tag=*/base_address_tag, /*rw=*/precomputed.zero/*(read)*/ }
-in
-memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_base { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 
 // This error will be true iff the base address is not valid AND we did actually check it.
 pol commit sel_base_address_failure;
@@ -259,30 +257,28 @@ sel_should_apply_indirection[6] = SEL_OP_IS_INDIRECT_EFFECTIVE_6_ * (1 - sel_rel
 pol commit rop_tag[7];
 
 // If indirection is applied, we need to lookup the value from memory.
-// If sel_should_apply_indirection is 1, then we know the address is valid therefore we can make the lookups.
-// TODO: complete these lookups once we get memory done. In particular, clk and space id.
-// FIXME: these should eventually be permutations.
+// If sel_should_apply_indirection is 1, then we know the address is valid therefore we can make the permutations.
 #[INDIRECT_FROM_MEMORY_0]
 sel_should_apply_indirection[0] { precomputed.clk, context_id, /*address=*/op_after_relative[0], /*value=*/rop[0], /*tag=*/rop_tag[0], /*rw=*/precomputed.zero/*(read)*/ }
-in memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_indirect[0] { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 #[INDIRECT_FROM_MEMORY_1]
 sel_should_apply_indirection[1] { precomputed.clk, context_id, /*address=*/op_after_relative[1], /*value=*/rop[1], /*tag=*/rop_tag[1], /*rw=*/precomputed.zero/*(read)*/ }
-in memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_indirect[1] { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 #[INDIRECT_FROM_MEMORY_2]
 sel_should_apply_indirection[2] { precomputed.clk, context_id, /*address=*/op_after_relative[2], /*value=*/rop[2], /*tag=*/rop_tag[2], /*rw=*/precomputed.zero/*(read)*/ }
-in memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_indirect[2] { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 #[INDIRECT_FROM_MEMORY_3]
 sel_should_apply_indirection[3] { precomputed.clk, context_id, /*address=*/op_after_relative[3], /*value=*/rop[3], /*tag=*/rop_tag[3], /*rw=*/precomputed.zero/*(read)*/ }
-in memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_indirect[3] { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 #[INDIRECT_FROM_MEMORY_4]
 sel_should_apply_indirection[4] { precomputed.clk, context_id, /*address=*/op_after_relative[4], /*value=*/rop[4], /*tag=*/rop_tag[4], /*rw=*/precomputed.zero/*(read)*/ }
-in memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_indirect[4] { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 #[INDIRECT_FROM_MEMORY_5]
 sel_should_apply_indirection[5] { precomputed.clk, context_id, /*address=*/op_after_relative[5], /*value=*/rop[5], /*tag=*/rop_tag[5], /*rw=*/precomputed.zero/*(read)*/ }
-in memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_indirect[5] { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 #[INDIRECT_FROM_MEMORY_6]
 sel_should_apply_indirection[6] { precomputed.clk, context_id, /*address=*/op_after_relative[6], /*value=*/rop[6], /*tag=*/rop_tag[6], /*rw=*/precomputed.zero/*(read)*/ }
-in memory.sel { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
+is memory.sel_addressing_indirect[6] { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 
 // Otherwise, if indirection is not applied , we propagate the operands from the previous step.
 #[INDIRECT_PROPAGATION_0]

barretenberg/cpp/pil/vm2/keccak_memory.pil

@@ -237,13 +237,9 @@ val43 = (1 - last) * val42';
 #[VAL44]
 val44 = (1 - last) * val43';
 
-// Memory permutation
-// TODO: Proper memory permutation (not a lookup), and introduce a specific
-// selector for keccak in memory sub-trace.
 #[SLICE_TO_MEM]
-sel {clk, addr, val00, tag, rw, space_id}
-in // TODO: replace with `is` (permutation)
-memory.sel { memory.clk, memory.address, memory.value, memory.tag, memory.rw, memory.space_id };
+sel { clk, space_id, addr, val00, tag, rw }
+is memory.sel_keccak { memory.clk, memory.space_id, memory.address, memory.value, memory.tag, memory.rw };
 
 // Used to constrain the number of rounds in keccakf1600.pil through the slice_write lookup.
 pol commit num_rounds;

barretenberg/cpp/pil/vm2/memory.pil

@@ -10,6 +10,49 @@ pol commit tag;
 pol commit rw;
 pol commit space_id;
 
+// Permutation selectors (addressing.pil).
+pol commit sel_addressing_base;
+pol commit sel_addressing_indirect[7];
+sel_addressing_base * (1 - sel_addressing_base) = 0;
+sel_addressing_indirect[0] * (1 - sel_addressing_indirect[0]) = 0;
+sel_addressing_indirect[1] * (1 - sel_addressing_indirect[1]) = 0;
+sel_addressing_indirect[2] * (1 - sel_addressing_indirect[2]) = 0;
+sel_addressing_indirect[3] * (1 - sel_addressing_indirect[3]) = 0;
+sel_addressing_indirect[4] * (1 - sel_addressing_indirect[4]) = 0;
+sel_addressing_indirect[5] * (1 - sel_addressing_indirect[5]) = 0;
+sel_addressing_indirect[6] * (1 - sel_addressing_indirect[6]) = 0;
+
+// Permutation selectors (keccak_memory.pil).
+pol commit sel_keccak;
+sel_keccak * (1 - sel_keccak) = 0;
+
+// Permutation selectors (sha256_mem.pil).
+pol commit sel_sha256_read;
+pol commit sel_sha256_op[8];
+sel_sha256_read * (1 - sel_sha256_read) = 0;
+sel_sha256_op[0] * (1 - sel_sha256_op[0]) = 0;
+sel_sha256_op[1] * (1 - sel_sha256_op[1]) = 0;
+sel_sha256_op[2] * (1 - sel_sha256_op[2]) = 0;
+sel_sha256_op[3] * (1 - sel_sha256_op[3]) = 0;
+sel_sha256_op[4] * (1 - sel_sha256_op[4]) = 0;
+sel_sha256_op[5] * (1 - sel_sha256_op[5]) = 0;
+sel_sha256_op[6] * (1 - sel_sha256_op[6]) = 0;
+sel_sha256_op[7] * (1 - sel_sha256_op[7]) = 0;
+
+// Permutation consistency.
+/*
+sel = // Addressing.
+      sel_addressing_base
+    + sel_addressing_indirect[0] + sel_addressing_indirect[1] + sel_addressing_indirect[2] + sel_addressing_indirect[3]
+    + sel_addressing_indirect[4] + sel_addressing_indirect[5] + sel_addressing_indirect[6]
+    // Keccak.
+    + sel_keccak
+    // Sha256.
+    + sel_sha256_read
+    + sel_sha256_op[0] + sel_sha256_op[1] + sel_sha256_op[2] + sel_sha256_op[3]
+    + sel_sha256_op[4] + sel_sha256_op[5] + sel_sha256_op[6] + sel_sha256_op[7];
+*/
+
 #[skippable_if]
 sel = 0;