feat(vm): reading kernel state opcodes

barretenberg/cpp/pil/avm/avm_kernel.pil

@@ -0,0 +1,40 @@
+include "avm_main.pil";
+include "constants.pil";
+
+namespace avm_kernel(256);
+    pol public kernel_inputs;
+    pol commit kernel_sel;
+
+    // The general pattern for environment lookups is as follows:
+    //  Each kernel opcode related to some fixed positions in the `public kernel_inputs` polynomial
+    //  We can lookup into a fixed index of this polynomial by including constraints that force the value
+    //  of kernel_sel to the value relevant to the given opcode that is active
+
+    #[SENDER_KERNEL]
+    avm_main.sel_op_sender * (kernel_sel - constants.SENDER_SELECTOR) = 0;
+
+    #[ADDRESS_KERNEL]
+    avm_main.sel_op_address * (kernel_sel - constants.ADDRESS_SELECTOR) = 0;
+
+    #[PORTAL_KERNEL]
+    avm_main.sel_op_portal * (kernel_sel - constants.PORTAL_SELECTOR) = 0;
+
+    #[FUNCTION_KERNEL]
+    avm_main.sel_op_function_selector * (kernel_sel - constants.FUNCTION_SELECTOR) = 0;
+
+    #[FEE_DA_GAS_KERNEL]
+    avm_main.sel_op_fee_per_da_gas  * (kernel_sel - constants.FEE_PER_DA_GAS_SELECTOR) = 0;
+
+    #[FEE_L1_GAS_KERNEL]
+    avm_main.sel_op_fee_per_l1_gas * (kernel_sel - constants.FEE_PER_L1_GAS_SELECTOR) = 0;
+
+    #[FEE_L2_GAS_KERNEL]
+    avm_main.sel_op_fee_per_l2_gas  * (kernel_sel - constants.FEE_PER_L2_GAS_SELECTOR) = 0;
+
+    // Note: in the future, with some codegen adjustments, this column will not be needed
+    // as we can just add every entry in the public kernel_inputs to the lookup table
+    pol commit q_public_input_kernel_add_to_table;
+
+    #[LOOKUP_INTO_KERNEL]
+    // TODO: FIX not having the trailing is_public breaking compilation :(
+    avm_main.q_kernel_lookup { avm_main.ia, kernel_sel } in q_public_input_kernel_add_to_table { kernel_inputs__is_public, avm_main.clk };

barretenberg/cpp/pil/avm/avm_main.pil

@@ -2,8 +2,30 @@
 include "avm_mem.pil";
 include "avm_alu.pil";
 include "avm_binary.pil";
+include "avm_kernel.pil";
 
 namespace avm_main(256);
+    // Kernel lookup selector opcodes
+    pol commit q_kernel_lookup;
+
+    // CALL CONTEXT
+    pol commit sel_op_sender;
+    pol commit sel_op_address;
+    pol commit sel_op_portal;
+    pol commit sel_op_function_selector;
+
+    // FEES
+    pol commit sel_op_fee_per_l1_gas;
+    pol commit sel_op_fee_per_l2_gas;
+    pol commit sel_op_fee_per_da_gas;
+
+    // GLOBALS
+    pol commit sel_op_chain_id;
+    pol commit sel_op_version;
+    pol commit sel_op_block_number;
+    pol commit sel_op_coinbase;
+    pol commit sel_op_timestamp;
+
 
     //===== CONSTANT POLYNOMIALS ==================================================
     pol constant clk(i) { i };
@@ -58,7 +80,7 @@ namespace avm_main(256);
     pol commit sel_op_lt;
     // LTE
     pol commit sel_op_lte;
-
+    
     // Helper selector to characterize an ALU chiplet selector
     pol commit alu_sel;
 
@@ -121,6 +143,18 @@ namespace avm_main(256);
     pol commit last;
 
     // Relations on type constraints
+    sel_op_sender * (1 - sel_op_sender) = 0;
+    sel_op_address * (1 - sel_op_address) = 0;
+    sel_op_portal * (1 - sel_op_portal) = 0;
+    sel_op_function_selector * (1 - sel_op_function_selector) = 0;
+    sel_op_chain_id * (1 - sel_op_chain_id) = 0;
+    sel_op_version * (1 - sel_op_version) = 0;
+    sel_op_block_number * (1 - sel_op_block_number) = 0;
+    sel_op_coinbase * (1 - sel_op_coinbase) = 0;
+    sel_op_timestamp * (1 - sel_op_timestamp) = 0;
+    sel_op_fee_per_l1_gas * (1 - sel_op_fee_per_l1_gas) = 0;
+    sel_op_fee_per_l2_gas * (1 - sel_op_fee_per_l2_gas) = 0;
+    sel_op_fee_per_da_gas * (1 - sel_op_fee_per_da_gas) = 0;
 
     sel_op_add * (1 - sel_op_add) = 0;
     sel_op_sub * (1 - sel_op_sub) = 0;
@@ -208,6 +242,15 @@ namespace avm_main(256);
     // (ib * inv - 1 + op_div_err) = 0 && op_err * (1 - inv) = 0 
     // This works in combination with op_div_err * (sel_op_div - 1) = 0;
     // Drawback is the need to paralllelize the latter.
+
+    //===== KERNEL LOOKUPS =======================================================
+    pol KERNEL_SELECTORS = (
+        sel_op_sender + sel_op_address + sel_op_portal + sel_op_function_selector + sel_op_chain_id + sel_op_version + 
+        sel_op_block_number + sel_op_coinbase + sel_op_timestamp + sel_op_fee_per_l1_gas + sel_op_fee_per_l2_gas + sel_op_fee_per_da_gas
+    );
+    // Ensure that only one kernel lookup is active when the kernel_sel is active
+    #[KERNEL_ACTIVE_CHECK]
+    KERNEL_SELECTORS * (1 - q_kernel_lookup) = 0;
 
     //===== CONTROL FLOW =======================================================
     //===== JUMP ===============================================================
@@ -243,7 +286,10 @@ namespace avm_main(256);
 
     //===== CONTROL_FLOW_CONSISTENCY ============================================
     pol INTERNAL_CALL_STACK_SELECTORS = (first + sel_internal_call + sel_internal_return + sel_halt);
-    pol OPCODE_SELECTORS = (sel_op_add + sel_op_sub + sel_op_div + sel_op_mul + sel_op_not + sel_op_eq + sel_op_and + sel_op_or + sel_op_xor);
+    pol OPCODE_SELECTORS = (
+        sel_op_add + sel_op_sub + sel_op_div + sel_op_mul + sel_op_not + sel_op_eq + sel_op_and + sel_op_or + 
+        sel_op_xor + KERNEL_SELECTORS
+    );
 
     // Program counter must increment if not jumping or returning
     #[PC_INCREMENT]

barretenberg/cpp/pil/avm/constants.pil

@@ -0,0 +1,11 @@
+
+// NOTE: the constants in this file line up to the indexes of values in the 
+// `PublicKernelInputs.nr` object
+namespace constants(256);
+    pol SENDER_SELECTOR = 0;
+    pol ADDRESS_SELECTOR = 1;
+    pol PORTAL_SELECTOR = 2;
+    pol FUNCTION_SELECTOR = 3;
+    pol FEE_PER_DA_GAS_SELECTOR = 9;
+    pol FEE_PER_L1_GAS_SELECTOR = 11;
+    pol FEE_PER_L2_GAS_SELECTOR = 13;

barretenberg/cpp/pil/spike/README.md

@@ -0,0 +1,3 @@
+## Spike machine
+
+A spike machine for testing new PIL functionality

barretenberg/cpp/pil/spike/spike.pil

@@ -0,0 +1,8 @@
+
+namespace Spike(16);
+
+pol constant first = [1] + [0]*;
+pol commit x;
+pol public kernel_inputs;
+
+x - first = 0;

barretenberg/cpp/scripts/compile_avm.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+use_zsh_alias() {
+    # Run Zsh command, source .zshrc, and then execute the alias
+    zsh -i -c "$1"
+}
+
+# Compile
+use_zsh_alias "bb_pil pil/avm/avm_main.pil --name Avm"
+
+# Format generated folders
+root_dir="src"
+
+# Find all directories named 'generate' under the specified root directory
+find "$root_dir" -type d -name 'generate' | while read dir_path; do
+    echo "Processing directory: $dir_path"
+
+    # Find all C/C++ source files in these directories and format them
+    find "$dir_path" -type f \( -iname '*.hpp' -o -iname '*.cpp' \) -exec clang-format -i {} +
+done
+
+
+# Build vm tests
+cmake --build --preset clang16 --target vm_tests

barretenberg/cpp/src/CMakeLists.txt

@@ -1,6 +1,9 @@
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
 
+# Temp, increase this flag to enable vm compilation
+set(CMAKE_CXX_FLAGS "-fbracket-depth=512")
+
 # Enable the following warnings project wide.
 # If any compilation issues arise in the future, they should not be silenced here but rather in the
 # module's own CMakeLists.txt by adding conditional compilation flags like the following

barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp

@@ -0,0 +1,67 @@
+
+#pragma once
+#include "../../relation_parameters.hpp"
+#include "../../relation_types.hpp"
+#include "./declare_views.hpp"
+
+namespace bb::Avm_vm {
+
+template <typename FF> struct Avm_environmentRow {
+    FF avm_environment_environment_selector{};
+    FF avm_environment_q_environment_lookup{};
+    FF avm_main_sel_op_address{};
+    FF avm_main_sel_op_sender{};
+};
+
+inline std::string get_relation_label_avm_environment(int index)
+{
+    switch (index) {
+    case 0:
+        return "SENDER_ENVIRONMENT";
+
+    case 1:
+        return "ADDRESS_ENVIRONMENT";
+    }
+    return std::to_string(index);
+}
+
+template <typename FF_> class avm_environmentImpl {
+  public:
+    using FF = FF_;
+
+    static constexpr std::array<size_t, 2> SUBRELATION_PARTIAL_LENGTHS{
+        4,
+        4,
+    };
+
+    template <typename ContainerOverSubrelations, typename AllEntities>
+    void static accumulate(ContainerOverSubrelations& evals,
+                           const AllEntities& new_term,
+                           [[maybe_unused]] const RelationParameters<FF>&,
+                           [[maybe_unused]] const FF& scaling_factor)
+    {
+
+        // Contribution 0
+        {
+            Avm_DECLARE_VIEWS(0);
+
+            auto tmp = ((avm_environment_q_environment_lookup * avm_main_sel_op_sender) *
+                        avm_environment_environment_selector);
+            tmp *= scaling_factor;
+            std::get<0>(evals) += tmp;
+        }
+        // Contribution 1
+        {
+            Avm_DECLARE_VIEWS(1);
+
+            auto tmp = ((avm_environment_q_environment_lookup * avm_main_sel_op_address) *
+                        (avm_environment_environment_selector - FF(1)));
+            tmp *= scaling_factor;
+            std::get<1>(evals) += tmp;
+        }
+    }
+};
+
+template <typename FF> using avm_environment = Relation<avm_environmentImpl<FF>>;
+
+} // namespace bb::Avm_vm

barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp

@@ -0,0 +1,123 @@
+
+#pragma once
+#include "../../relation_parameters.hpp"
+#include "../../relation_types.hpp"
+#include "./declare_views.hpp"
+
+namespace bb::Avm_vm {
+
+template <typename FF> struct Avm_kernelRow {
+    FF avm_kernel_kernel_sel{};
+    FF avm_main_sel_op_address{};
+    FF avm_main_sel_op_fee_per_da_gas{};
+    FF avm_main_sel_op_fee_per_l1_gas{};
+    FF avm_main_sel_op_fee_per_l2_gas{};
+    FF avm_main_sel_op_function_selector{};
+    FF avm_main_sel_op_portal{};
+    FF avm_main_sel_op_sender{};
+};
+
+inline std::string get_relation_label_avm_kernel(int index)
+{
+    switch (index) {
+    case 0:
+        return "SENDER_KERNEL";
+
+    case 1:
+        return "ADDRESS_KERNEL";
+
+    case 2:
+        return "PORTAL_KERNEL";
+
+    case 3:
+        return "FUNCTION_KERNEL";
+
+    case 4:
+        return "FEE_DA_GAS_KERNEL";
+
+    case 5:
+        return "FEE_L1_GAS_KERNEL";
+
+    case 6:
+        return "FEE_L2_GAS_KERNEL";
+    }
+    return std::to_string(index);
+}
+
+template <typename FF_> class avm_kernelImpl {
+  public:
+    using FF = FF_;
+
+    static constexpr std::array<size_t, 7> SUBRELATION_PARTIAL_LENGTHS{
+        3, 3, 3, 3, 3, 3, 3,
+    };
+
+    template <typename ContainerOverSubrelations, typename AllEntities>
+    void static accumulate(ContainerOverSubrelations& evals,
+                           const AllEntities& new_term,
+                           [[maybe_unused]] const RelationParameters<FF>&,
+                           [[maybe_unused]] const FF& scaling_factor)
+    {
+
+        // Contribution 0
+        {
+            Avm_DECLARE_VIEWS(0);
+
+            auto tmp = (avm_main_sel_op_sender * (avm_kernel_kernel_sel - FF(0)));
+            tmp *= scaling_factor;
+            std::get<0>(evals) += tmp;
+        }
+        // Contribution 1
+        {
+            Avm_DECLARE_VIEWS(1);
+
+            auto tmp = (avm_main_sel_op_address * (avm_kernel_kernel_sel - FF(1)));
+            tmp *= scaling_factor;
+            std::get<1>(evals) += tmp;
+        }
+        // Contribution 2
+        {
+            Avm_DECLARE_VIEWS(2);
+
+            auto tmp = (avm_main_sel_op_portal * (avm_kernel_kernel_sel - FF(2)));
+            tmp *= scaling_factor;
+            std::get<2>(evals) += tmp;
+        }
+        // Contribution 3
+        {
+            Avm_DECLARE_VIEWS(3);
+
+            auto tmp = (avm_main_sel_op_function_selector * (avm_kernel_kernel_sel - FF(3)));
+            tmp *= scaling_factor;
+            std::get<3>(evals) += tmp;
+        }
+        // Contribution 4
+        {
+            Avm_DECLARE_VIEWS(4);
+
+            auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(9)));
+            tmp *= scaling_factor;
+            std::get<4>(evals) += tmp;
+        }
+        // Contribution 5
+        {
+            Avm_DECLARE_VIEWS(5);
+
+            auto tmp = (avm_main_sel_op_fee_per_l1_gas * (avm_kernel_kernel_sel - FF(11)));
+            tmp *= scaling_factor;
+            std::get<5>(evals) += tmp;
+        }
+        // Contribution 6
+        {
+            Avm_DECLARE_VIEWS(6);
+
+            auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(13)));
+            tmp *= scaling_factor;
+            std::get<6>(evals) += tmp;
+        }
+    }
+};
+
+template <typename FF> using avm_kernel = Relation<avm_kernelImpl<FF>>;
+
+} // namespace bb::Avm_vm