From b4203a014cda9ddbf879e6adca82b4d153a2decd Mon Sep 17 00:00:00 2001 From: jeanmon Date: Wed, 3 Jan 2024 16:58:13 +0000 Subject: [PATCH 1/7] 3738 - minor changes in import --- .../proof_system/circuit_builder/AvmMini_helper.cpp | 7 +------ .../proof_system/circuit_builder/AvmMini_trace.cpp | 3 +-- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp index 60d92a168cc..38c2a1cce73 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp @@ -1,9 +1,4 @@ -#include "barretenberg/ecc/curves/bn254/fr.hpp" -#include "barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp" - -#include "./AvmMini_helper.hpp" -#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" -#include "barretenberg/relations/generated/AvmMini/avm_mini.hpp" +#include "AvmMini_helper.hpp" namespace proof_system { diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index 308724f2e16..d4035f6ca60 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -8,8 +8,7 @@ #include #include -#include "./AvmMini_trace.hpp" -#include "./generated/AvmMini_circuit_builder.hpp" +#include "AvmMini_trace.hpp" namespace proof_system { From 6d485454c7889239dd8f43e11eeb9cb0cfa1d1ce Mon Sep 17 00:00:00 2001 From: jeanmon Date: Thu, 4 Jan 2024 10:05:19 +0000 Subject: [PATCH 2/7] 3738: create a common header files for AvmMini --- .../circuit_builder/AvmMini_common.hpp | 15 +++++++++++++++ .../circuit_builder/AvmMini_helper.hpp | 10 +--------- .../circuit_builder/AvmMini_trace.hpp | 13 +------------ .../src/barretenberg/vm/tests/helpers.test.cpp | 4 +--- 4 files changed, 18 insertions(+), 24 deletions(-) create mode 100644 barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp new file mode 100644 index 00000000000..fc5fcc579ab --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include "barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp" +#include "barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp" + +using Flavor = proof_system::honk::flavor::AvmMiniFlavor; +using FF = Flavor::FF; +using Row = proof_system::AvmMiniFullRow; + +namespace proof_system { + +enum class IntermRegister : uint32_t { ia = 0, ib = 1, ic = 2 }; +enum class AvmMemoryTag : uint32_t { u0 = 0, u8 = 1, u16 = 2, u32 = 3, u64 = 4, u128 = 5, ff = 6 }; + +} // namespace proof_system \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp index 491d597fa26..a2a8ba922a6 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp @@ -1,17 +1,9 @@ #pragma once -#include "barretenberg/ecc/curves/bn254/fr.hpp" -#include "barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp" - -#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" -#include "barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp" +#include "AvmMini_common.hpp" namespace proof_system { -using Flavor = proof_system::honk::flavor::AvmMiniFlavor; -using FF = Flavor::FF; -using Row = proof_system::AvmMiniFullRow; - void log_avmMini_trace(std::vector const& trace, size_t beg, size_t end); } // namespace proof_system \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp index 0185d76cf97..8329808b14f 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp @@ -2,24 +2,13 @@ #include +#include "AvmMini_common.hpp" #include "barretenberg/common/throw_or_abort.hpp" -#include "barretenberg/ecc/curves/bn254/fr.hpp" -#include "barretenberg/proof_system/circuit_builder/circuit_builder_base.hpp" -#include "barretenberg/proof_system/circuit_builder/generated/AvmMini_circuit_builder.hpp" - -#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" #include "barretenberg/relations/generated/AvmMini/avm_mini.hpp" -using Flavor = proof_system::honk::flavor::AvmMiniFlavor; -using FF = Flavor::FF; -using Row = proof_system::AvmMiniFullRow; - namespace proof_system { -enum class IntermRegister : uint32_t { ia = 0, ib = 1, ic = 2 }; -enum class AvmMemoryTag : uint32_t { u0 = 0, u8 = 1, u16 = 2, u32 = 3, u64 = 4, u128 = 5, ff = 6 }; - // This is the internal context that we keep along the lifecycle of bytecode execution // to iteratively build the whole trace. This is effectively performing witness generation. // At the end of circuit building, mainTrace can be moved to AvmMiniCircuitBuilder by calling diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 9cfb6fe7a17..90ec0d42bab 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,7 +1,5 @@ -#include "barretenberg/vm/tests/helpers.test.hpp" -#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" +#include "helpers.test.hpp" #include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" -#include "barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" From d52365c1cfb3c87e4714d80f10d23a3cd8d1fd27 Mon Sep 17 00:00:00 2001 From: jeanmon Date: Thu, 4 Jan 2024 15:36:45 +0000 Subject: [PATCH 3/7] Refactoring: move memory trace building and memory operations simluation in a dedicated class/file --- .../circuit_builder/AvmMini_common.hpp | 2 + .../circuit_builder/AvmMini_mem_trace.cpp | 235 ++++++++++++++ .../circuit_builder/AvmMini_mem_trace.hpp | 65 ++++ .../circuit_builder/AvmMini_trace.cpp | 295 +++++------------- .../circuit_builder/AvmMini_trace.hpp | 36 +-- .../vm/tests/AvmMini_memory.test.cpp | 14 +- 6 files changed, 385 insertions(+), 262 deletions(-) create mode 100644 barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp create mode 100644 barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp index fc5fcc579ab..50679598d05 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp @@ -9,6 +9,8 @@ using Row = proof_system::AvmMiniFullRow; namespace proof_system { +// Number of rows +static const size_t AVM_TRACE_SIZE = 256; enum class IntermRegister : uint32_t { ia = 0, ib = 1, ic = 2 }; enum class AvmMemoryTag : uint32_t { u0 = 0, u8 = 1, u16 = 2, u32 = 3, u64 = 4, u128 = 5, ff = 6 }; diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp new file mode 100644 index 00000000000..93d50e303b7 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp @@ -0,0 +1,235 @@ +#include "AvmMini_mem_trace.hpp" + +namespace proof_system { + +/** + * @brief Constructor of a memory trace builder of AVM. Only serves to set the capacity of the + * underlying traces. + */ +AvmMiniMemTraceBuilder::AvmMiniMemTraceBuilder() +{ + memTrace.reserve(AVM_TRACE_SIZE); +} + +/** + * @brief Resetting the internal state so that a new memory trace can be rebuilt using the same object. + * + */ +void AvmMiniMemTraceBuilder::reset() +{ + memTrace.clear(); + memory.fill(FF(0)); +} + +/** + * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. + * + */ +bool AvmMiniMemTraceBuilder::compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right) +{ + if (left.m_addr < right.m_addr) { + return true; + } + + if (left.m_addr > right.m_addr) { + return false; + } + + if (left.m_clk < right.m_clk) { + return true; + } + + if (left.m_clk > right.m_clk) { + return false; + } + + // No safeguard in case they are equal. The caller should ensure this property. + // Otherwise, relation will not be satisfied. + return left.m_sub_clk < right.m_sub_clk; +} + +/** + * @brief Prepare the memory trace to be incorporated into the main trace. + * + * @return The memory trace (which is moved). + */ +std::vector AvmMiniMemTraceBuilder::finalize() +{ + // Sort memTrace + std::sort(memTrace.begin(), memTrace.end(), compareMemEntries); + return std::move(memTrace); +} + +/** + * @brief A method to insert a row/entry in the memory trace. + * + * @param m_clk Main clock + * @param m_sub_clk Sub-clock used to order load/store sub operations + * @param m_addr Address pertaining to the memory operation + * @param m_val Value (FF) pertaining to the memory operation + * @param m_in_tag Memory tag pertaining to the instruction + * @param m_rw Boolean telling whether it is a load (false) or store operation (true). + */ +void AvmMiniMemTraceBuilder::insertInMemTrace(uint32_t const m_clk, + uint32_t const m_sub_clk, + uint32_t const m_addr, + FF const& m_val, + AvmMemoryTag const m_in_tag, + bool const m_rw) +{ + memTrace.emplace_back(MemoryTraceEntry{ + .m_clk = m_clk, + .m_sub_clk = m_sub_clk, + .m_addr = m_addr, + .m_val = m_val, + .m_tag = m_in_tag, + .m_in_tag = m_in_tag, + .m_rw = m_rw, + }); +} + +// Memory operations need to be performed before the addition of the corresponding row in +// MainTrace, otherwise the m_clk value will be wrong. This applies to loadInMemTrace and +// storeInMemTrace. + +/** + * @brief Add a memory trace entry for a load with a memory tag mismatching the instruction + * memory tag. + * + * @param m_clk Main clock + * @param m_sub_clk Sub-clock used to order load/store sub operations + * @param m_addr Address pertaining to the memory operation + * @param m_val Value (FF) pertaining to the memory operation + * @param m_in_tag Memory tag pertaining to the instruction + * @param m_tag Memory tag pertaining to the address + */ +void AvmMiniMemTraceBuilder::loadMismatchTagInMemTrace(uint32_t const m_clk, + uint32_t const m_sub_clk, + uint32_t const m_addr, + FF const& m_val, + AvmMemoryTag const m_in_tag, + AvmMemoryTag const m_tag) +{ + FF one_min_inv = FF(1) - (FF(static_cast(m_in_tag)) - FF(static_cast(m_tag))).invert(); + memTrace.emplace_back(MemoryTraceEntry{ .m_clk = m_clk, + .m_sub_clk = m_sub_clk, + .m_addr = m_addr, + .m_val = m_val, + .m_tag = m_tag, + .m_in_tag = m_in_tag, + .m_tag_err = true, + .m_one_min_inv = one_min_inv }); +} + +/** + * @brief Add a memory trace entry corresponding to a memory load into the intermediate + * passed register. + * + * @param clk The main clock + * @param intermReg The intermediate register + * @param addr The memory address + * @param val The value to be loaded + * @param m_in_tag The memory tag of the instruction + */ +bool AvmMiniMemTraceBuilder::loadInMemTrace( + uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) +{ + uint32_t sub_clk = 0; + switch (intermReg) { + case IntermRegister::ia: + sub_clk = SUB_CLK_LOAD_A; + break; + case IntermRegister::ib: + sub_clk = SUB_CLK_LOAD_B; + break; + case IntermRegister::ic: + sub_clk = SUB_CLK_LOAD_C; + break; + } + + auto m_tag = memoryTag.at(addr); + if (m_tag == AvmMemoryTag::u0 || m_tag == m_in_tag) { + insertInMemTrace(clk, sub_clk, addr, val, m_in_tag, false); + return true; + } + + // Handle memory tag inconsistency + loadMismatchTagInMemTrace(clk, sub_clk, addr, val, m_in_tag, m_tag); + return false; +} + +/** + * @brief Add a memory trace entry corresponding to a memory store from the intermediate + * register. + * + * @param clk The main clock + * @param intermReg The intermediate register + * @param addr The memory address + * @param val The value to be stored + * @param m_in_tag The memory tag of the instruction + */ +void AvmMiniMemTraceBuilder::storeInMemTrace( + uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) +{ + uint32_t sub_clk = 0; + switch (intermReg) { + case IntermRegister::ia: + sub_clk = SUB_CLK_STORE_A; + break; + case IntermRegister::ib: + sub_clk = SUB_CLK_STORE_B; + break; + case IntermRegister::ic: + sub_clk = SUB_CLK_STORE_C; + break; + } + + insertInMemTrace(clk, sub_clk, addr, val, m_in_tag, true); +} + +/** + * @brief Handle a read memory operation and load the corresponding value to the + * supplied intermediate register. A memory trace entry for the load operation + * is added. + * + * @param clk Main clock + * @param intermReg Intermediate register where we load the value + * @param addr Memory address to be read and loaded + * @param m_in_tag Memory instruction tag + * @return Result of the read operation containing the value and a boolean telling + * potential mismatch between instruction tag and memory tag of the address. + */ +AvmMiniMemTraceBuilder::MemRead AvmMiniMemTraceBuilder::readAndLoadFromMemory(uint32_t const clk, + IntermRegister const intermReg, + uint32_t const addr, + AvmMemoryTag const m_in_tag) +{ + FF val = memory.at(addr); + bool tagMatch = loadInMemTrace(clk, intermReg, addr, val, m_in_tag); + + return MemRead{ + .tagMatch = tagMatch, + .val = val, + }; +} + +/** + * @brief Handle a write memory operation and store the supplied value into memory + * at the supplied address. A memory trace entry for the write operation + * is added. + * + * @param clk Main clock + * @param intermReg Intermediate register where we write the value + * @param addr Memory address to be written to + * @param val Value to be written into memory + * @param m_in_tag Memory instruction tag + */ +void AvmMiniMemTraceBuilder::writeIntoMemory( + uint32_t const clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) +{ + memory.at(addr) = val; + memoryTag.at(addr) = m_in_tag; + storeInMemTrace(clk, intermReg, addr, val, m_in_tag); +} + +} // namespace proof_system \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp new file mode 100644 index 00000000000..6de192c9655 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp @@ -0,0 +1,65 @@ +#pragma once + +#include "AvmMini_common.hpp" + +namespace proof_system { + +class AvmMiniMemTraceBuilder { + + public: + static const size_t MEM_SIZE = 1024; + static const uint32_t SUB_CLK_LOAD_A = 0; + static const uint32_t SUB_CLK_LOAD_B = 1; + static const uint32_t SUB_CLK_LOAD_C = 2; + static const uint32_t SUB_CLK_STORE_A = 3; + static const uint32_t SUB_CLK_STORE_B = 4; + static const uint32_t SUB_CLK_STORE_C = 5; + + struct MemoryTraceEntry { + uint32_t m_clk; + uint32_t m_sub_clk; + uint32_t m_addr; + FF m_val{}; + AvmMemoryTag m_tag; + AvmMemoryTag m_in_tag; + bool m_rw = false; + bool m_tag_err = false; + FF m_one_min_inv{}; + }; + + // Structure to return value and tag matching boolean after a memory read. + struct MemRead { + bool tagMatch; + FF val; + }; + + AvmMiniMemTraceBuilder(); + + void reset(); + + std::vector finalize(); + + MemRead readAndLoadFromMemory(uint32_t clk, IntermRegister intermReg, uint32_t addr, AvmMemoryTag m_in_tag); + void writeIntoMemory(uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); + + private: + std::vector memTrace; // Entries will be sorted by m_clk, m_sub_clk after finalize(). + std::array memory{}; // Memory table (used for simulation) + std::array memoryTag{}; // The tag of the corresponding memory + // entry (aligned with the memory array). + + static bool compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right); + + void insertInMemTrace( + uint32_t m_clk, uint32_t m_sub_clk, uint32_t m_addr, FF const& m_val, AvmMemoryTag m_in_tag, bool m_rw); + void loadMismatchTagInMemTrace(uint32_t m_clk, + uint32_t m_sub_clk, + uint32_t m_addr, + FF const& m_val, + AvmMemoryTag m_in_tag, + AvmMemoryTag m_tag); + + bool loadInMemTrace(uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); + void storeInMemTrace(uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); +}; +} // namespace proof_system \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index d4035f6ca60..c177ad07db8 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -18,8 +18,7 @@ namespace proof_system { */ AvmMiniTraceBuilder::AvmMiniTraceBuilder() { - mainTrace.reserve(N); - memTrace.reserve(N); + mainTrace.reserve(AVM_TRACE_SIZE); } /** @@ -29,139 +28,7 @@ AvmMiniTraceBuilder::AvmMiniTraceBuilder() void AvmMiniTraceBuilder::reset() { mainTrace.clear(); - memTrace.clear(); - memory.fill(FF(0)); -} - -/** - * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. - * - */ -bool AvmMiniTraceBuilder::compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right) -{ - if (left.m_addr < right.m_addr) { - return true; - } - - if (left.m_addr > right.m_addr) { - return false; - } - - if (left.m_clk < right.m_clk) { - return true; - } - - if (left.m_clk > right.m_clk) { - return false; - } - - // No safeguard in case they are equal. The caller should ensure this property. - // Otherwise, relation will not be satisfied. - return left.m_sub_clk < right.m_sub_clk; -} - -/** - * @brief A method to insert a row/entry in the memory trace. - * - * @param m_clk Main clock - * @param m_sub_clk Sub-clock used to order load/store sub operations - * @param m_addr Address pertaining to the memory operation - * @param m_val Value (FF) pertaining to the memory operation - * @param m_in_tag Memory tag pertaining to the instruction - * @param m_rw Boolean telling whether it is a load (false) or store operation (true). - */ -void AvmMiniTraceBuilder::insertInMemTrace( - uint32_t m_clk, uint32_t m_sub_clk, uint32_t m_addr, FF m_val, AvmMemoryTag m_in_tag, bool m_rw) -{ - memTrace.emplace_back(MemoryTraceEntry{ - .m_clk = m_clk, - .m_sub_clk = m_sub_clk, - .m_addr = m_addr, - .m_val = m_val, - .m_tag = m_in_tag, - .m_in_tag = m_in_tag, - .m_rw = m_rw, - }); -} - -void AvmMiniTraceBuilder::loadMismatchTagInMemTrace( - uint32_t m_clk, uint32_t m_sub_clk, uint32_t m_addr, FF m_val, AvmMemoryTag m_in_tag, AvmMemoryTag m_tag) -{ - FF one_min_inv = FF(1) - (FF(static_cast(m_in_tag)) - FF(static_cast(m_tag))).invert(); - memTrace.emplace_back(MemoryTraceEntry{ .m_clk = m_clk, - .m_sub_clk = m_sub_clk, - .m_addr = m_addr, - .m_val = m_val, - .m_tag = m_tag, - .m_in_tag = m_in_tag, - .m_tag_err = true, - .m_one_min_inv = one_min_inv }); -} - -// Memory operations need to be performed before the addition of the corresponding row in -// MainTrace, otherwise the m_clk value will be wrong. This applies to loadInMemTrace and -// storeInMemTrace. - -/** - * @brief Add a memory trace entry corresponding to a memory load into the intermediate - * passed register. - * - * @param intermReg The intermediate register - * @param addr The memory address - * @param val The value to be loaded - * @param m_in_tag The memory tag of the instruction - */ -bool AvmMiniTraceBuilder::loadInMemTrace(IntermRegister intermReg, uint32_t addr, FF val, AvmMemoryTag m_in_tag) -{ - uint32_t sub_clk = 0; - switch (intermReg) { - case IntermRegister::ia: - sub_clk = SUB_CLK_LOAD_A; - break; - case IntermRegister::ib: - sub_clk = SUB_CLK_LOAD_B; - break; - case IntermRegister::ic: - sub_clk = SUB_CLK_LOAD_C; - break; - } - - auto m_tag = memoryTag.at(addr); - if (m_tag == AvmMemoryTag::u0 || m_tag == m_in_tag) { - insertInMemTrace(static_cast(mainTrace.size()), sub_clk, addr, val, m_in_tag, false); - return true; - } - - // Handle memory tag inconsistency - loadMismatchTagInMemTrace(static_cast(mainTrace.size()), sub_clk, addr, val, m_in_tag, m_tag); - return false; -} - -/** - * @brief Add a memory trace entry corresponding to a memory store from the intermediate - * register. - * - * @param intermReg The intermediate register - * @param addr The memory address - * @param val The value to be stored - * @param m_in_tag The memory tag of the instruction - */ -void AvmMiniTraceBuilder::storeInMemTrace(IntermRegister intermReg, uint32_t addr, FF val, AvmMemoryTag m_in_tag) -{ - uint32_t sub_clk = 0; - switch (intermReg) { - case IntermRegister::ia: - sub_clk = SUB_CLK_STORE_A; - break; - case IntermRegister::ib: - sub_clk = SUB_CLK_STORE_B; - break; - case IntermRegister::ic: - sub_clk = SUB_CLK_STORE_C; - break; - } - - insertInMemTrace(static_cast(mainTrace.size()), sub_clk, addr, val, m_in_tag, true); + memTraceBuilder.reset(); } /** TODO: Implement for non finite field types @@ -174,19 +41,20 @@ void AvmMiniTraceBuilder::storeInMemTrace(IntermRegister intermReg, uint32_t add */ void AvmMiniTraceBuilder::add(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) { + auto clk = static_cast(mainTrace.size()); + + // Reading from memory and loading into ia resp. ib. + auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); + auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); + bool tagMatch = readA.tagMatch && readB.tagMatch; + // a + b = c - FF a = memory.at(aOffset); - FF b = memory.at(bOffset); + FF a = readA.val; + FF b = readB.val; FF c = a + b; - memory.at(dstOffset) = c; - memoryTag.at(dstOffset) = inTag; - // Loading into Ia, Ib and storing into Ic - bool tagMatch = loadInMemTrace(IntermRegister::ia, aOffset, a, inTag); - tagMatch = loadInMemTrace(IntermRegister::ib, bOffset, b, inTag) && tagMatch; - storeInMemTrace(IntermRegister::ic, dstOffset, c, inTag); - - auto clk = mainTrace.size(); + // Write into memory value c from intermediate register ic. + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -218,19 +86,20 @@ void AvmMiniTraceBuilder::add(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf */ void AvmMiniTraceBuilder::sub(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) { + auto clk = static_cast(mainTrace.size()); + + // Reading from memory and loading into ia resp. ib. + auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); + auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); + bool tagMatch = readA.tagMatch && readB.tagMatch; + // a - b = c - FF a = memory.at(aOffset); - FF b = memory.at(bOffset); + FF a = readA.val; + FF b = readB.val; FF c = a - b; - memory.at(dstOffset) = c; - memoryTag.at(dstOffset) = inTag; - // Loading into Ia, Ib and storing into Ic - bool tagMatch = loadInMemTrace(IntermRegister::ia, aOffset, a, inTag); - tagMatch = loadInMemTrace(IntermRegister::ib, bOffset, b, inTag) && tagMatch; - storeInMemTrace(IntermRegister::ic, dstOffset, c, inTag); - - auto clk = mainTrace.size(); + // Write into memory value c from intermediate register ic. + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -262,19 +131,20 @@ void AvmMiniTraceBuilder::sub(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf */ void AvmMiniTraceBuilder::mul(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) { + auto clk = static_cast(mainTrace.size()); + + // Reading from memory and loading into ia resp. ib. + auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); + auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); + bool tagMatch = readA.tagMatch && readB.tagMatch; + // a * b = c - FF a = memory.at(aOffset); - FF b = memory.at(bOffset); + FF a = readA.val; + FF b = readB.val; FF c = a * b; - memory.at(dstOffset) = c; - memoryTag.at(dstOffset) = inTag; - // Loading into Ia, Ib and storing into Ic - bool tagMatch = loadInMemTrace(IntermRegister::ia, aOffset, a, inTag); - tagMatch = loadInMemTrace(IntermRegister::ib, bOffset, b, inTag) && tagMatch; - storeInMemTrace(IntermRegister::ic, dstOffset, c, inTag); - - auto clk = mainTrace.size(); + // Write into memory value c from intermediate register ic. + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -306,9 +176,16 @@ void AvmMiniTraceBuilder::mul(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf */ void AvmMiniTraceBuilder::div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) { + auto clk = static_cast(mainTrace.size()); + + // Reading from memory and loading into ia resp. ib. + auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); + auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); + bool tagMatch = readA.tagMatch && readB.tagMatch; + // a * b^(-1) = c - FF a = memory.at(aOffset); - FF b = memory.at(bOffset); + FF a = readA.val; + FF b = readB.val; FF c; FF inv; FF error; @@ -324,15 +201,8 @@ void AvmMiniTraceBuilder::div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf error = 1; } - memory.at(dstOffset) = c; - memoryTag.at(dstOffset) = inTag; - - // Loading into Ia, Ib and storing into Ic - bool tagMatch = loadInMemTrace(IntermRegister::ia, aOffset, a, inTag); - tagMatch = loadInMemTrace(IntermRegister::ib, bOffset, b, inTag) && tagMatch; - storeInMemTrace(IntermRegister::ic, dstOffset, c, inTag); - - auto clk = mainTrace.size(); + // Write into memory value c from intermediate register ic. + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -396,7 +266,7 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, uint32_t mem_idx_c(0); uint32_t rwb(0); uint32_t rwc(0); - auto clk = mainTrace.size(); + auto clk = static_cast(mainTrace.size()); FF ia = callDataMem.at(cdOffset + pos); uint32_t mem_op_a(1); @@ -404,9 +274,7 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, uint32_t rwa = 1; // Storing from Ia - memory.at(mem_idx_a) = ia; - memoryTag.at(mem_idx_a) = AvmMemoryTag::ff; - storeInMemTrace(IntermRegister::ia, mem_idx_a, ia, AvmMemoryTag::ff); + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ia, mem_idx_a, ia, AvmMemoryTag::ff); if (copySize - pos > 1) { ib = callDataMem.at(cdOffset + pos + 1); @@ -415,9 +283,7 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, rwb = 1; // Storing from Ib - memory.at(mem_idx_b) = ib; - memoryTag.at(mem_idx_b) = AvmMemoryTag::ff; - storeInMemTrace(IntermRegister::ib, mem_idx_b, ib, AvmMemoryTag::ff); + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ib, mem_idx_b, ib, AvmMemoryTag::ff); } if (copySize - pos > 2) { @@ -427,9 +293,7 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, rwc = 1; // Storing from Ic - memory.at(mem_idx_c) = ic; - memoryTag.at(mem_idx_c) = AvmMemoryTag::ff; - storeInMemTrace(IntermRegister::ic, mem_idx_c, ic, AvmMemoryTag::ff); + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, mem_idx_c, ic, AvmMemoryTag::ff); } mainTrace.push_back(Row{ @@ -491,34 +355,34 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi uint32_t mem_op_c(0); uint32_t mem_idx_b(0); uint32_t mem_idx_c(0); - auto clk = mainTrace.size(); + auto clk = static_cast(mainTrace.size()); uint32_t mem_op_a(1); uint32_t mem_idx_a = retOffset + pos; - FF ia = memory.at(mem_idx_a); - // Loading from Ia + // Reading and loading to Ia + auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, mem_idx_a, AvmMemoryTag::ff); + FF ia = readA.val; returnMem.push_back(ia); - loadInMemTrace(IntermRegister::ia, mem_idx_a, ia, AvmMemoryTag::ff); if (retSize - pos > 1) { mem_op_b = 1; mem_idx_b = retOffset + pos + 1; - ib = memory.at(mem_idx_b); - // Loading from Ib + // Reading and loading to Ib + auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, mem_idx_b, AvmMemoryTag::ff); + FF ib = readB.val; returnMem.push_back(ib); - loadInMemTrace(IntermRegister::ib, mem_idx_b, ib, AvmMemoryTag::ff); } if (retSize - pos > 2) { mem_op_c = 1; mem_idx_c = retOffset + pos + 2; - ic = memory.at(mem_idx_c); - // Loading from Ic + // Reading and loading to Ic + auto readC = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ic, mem_idx_c, AvmMemoryTag::ff); + FF ic = readC.val; returnMem.push_back(ic); - loadInMemTrace(IntermRegister::ic, mem_idx_c, ic, AvmMemoryTag::ff); } mainTrace.push_back(Row{ @@ -604,15 +468,14 @@ void AvmMiniTraceBuilder::jump(uint32_t jmpDest) */ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) { - auto clk = mainTrace.size(); + auto clk = static_cast(mainTrace.size()); // We store the next instruction as the return location uint32_t stored_pc = pc + 1; internal_call_stack.push(stored_pc); // Add the return location to the memory trace - storeInMemTrace(IntermRegister::ib, internal_return_ptr, FF(stored_pc), AvmMemoryTag::ff); - memory.at(internal_return_ptr) = stored_pc; + memTraceBuilder.writeIntoMemory(clk, IntermRegister::ib, internal_return_ptr, FF(stored_pc), AvmMemoryTag::ff); mainTrace.push_back(Row{ .avmMini_clk = clk, @@ -643,20 +506,19 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) */ void AvmMiniTraceBuilder::internal_return() { - auto clk = mainTrace.size(); + auto clk = static_cast(mainTrace.size()); // Internal return pointer is decremented - FF a = memory.at(internal_return_ptr - 1); - // We want to load the value pointed by the internal pointer - loadInMemTrace(IntermRegister::ia, internal_return_ptr - 1, FF(a), AvmMemoryTag::ff); + auto readA = + memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, internal_return_ptr - 1, AvmMemoryTag::ff); mainTrace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = pc, .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_internal_return = FF(1), - .avmMini_ia = a, + .avmMini_ia = readA.val, .avmMini_mem_op_a = FF(1), .avmMini_rwa = FF(0), .avmMini_mem_idx_a = FF(internal_return_ptr - 1), @@ -669,16 +531,6 @@ void AvmMiniTraceBuilder::internal_return() internal_return_ptr--; } -/** - * @brief Helper to initialize ffMemory. (Testing purpose mostly.) - * - */ -void AvmMiniTraceBuilder::setFFMem(size_t idx, FF el, AvmMemoryTag tag) -{ - memory.at(idx) = el; - memoryTag.at(idx) = tag; -}; - /** * @brief Finalisation of the memory trace and incorporating it to the main trace. * In particular, sorting the memory trace, setting .m_lastAccess and @@ -689,20 +541,18 @@ void AvmMiniTraceBuilder::setFFMem(size_t idx, FF el, AvmMemoryTag tag) */ std::vector AvmMiniTraceBuilder::finalize() { + auto memTrace = memTraceBuilder.finalize(); size_t memTraceSize = memTrace.size(); size_t mainTraceSize = mainTrace.size(); // TODO: We will have to handle this through error handling and not an assertion // Smaller than N because we have to add an extra initial row to support shifted // elements - assert(memTraceSize < N); - assert(mainTraceSize < N); - - // Sort memTrace - std::sort(memTrace.begin(), memTrace.end(), compareMemEntries); + assert(memTraceSize < AVM_TRACE_SIZE); + assert(mainTraceSize < AVM_TRACE_SIZE); // Fill the rest with zeros. - size_t zeroRowsNum = N - mainTraceSize - 1; + size_t zeroRowsNum = AVM_TRACE_SIZE - mainTraceSize - 1; while (zeroRowsNum-- > 0) { mainTrace.push_back(Row{}); } @@ -736,7 +586,10 @@ std::vector AvmMiniTraceBuilder::finalize() Row first_row = Row{ .avmMini_first = FF(1), .memTrace_m_lastAccess = FF(1) }; mainTrace.insert(mainTrace.begin(), first_row); - return std::move(mainTrace); + auto trace = std::move(mainTrace); + reset(); + + return trace; } } // namespace proof_system \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp index 8329808b14f..1e3b42c7b9a 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp @@ -3,6 +3,7 @@ #include #include "AvmMini_common.hpp" +#include "AvmMini_mem_trace.hpp" #include "barretenberg/common/throw_or_abort.hpp" #include "barretenberg/relations/generated/AvmMini/avm_mini.hpp" @@ -16,18 +17,8 @@ namespace proof_system { class AvmMiniTraceBuilder { public: - // Number of rows - static const size_t N = 256; - static const size_t MEM_SIZE = 1024; static const size_t CALLSTACK_OFFSET = 896; // TODO(md): Temporary reserved area 896 - 1024 - static const uint32_t SUB_CLK_LOAD_A = 0; - static const uint32_t SUB_CLK_LOAD_B = 1; - static const uint32_t SUB_CLK_LOAD_C = 2; - static const uint32_t SUB_CLK_STORE_A = 3; - static const uint32_t SUB_CLK_STORE_B = 4; - static const uint32_t SUB_CLK_STORE_C = 5; - AvmMiniTraceBuilder(); // Temporary helper to initialize memory. @@ -70,34 +61,11 @@ class AvmMiniTraceBuilder { std::vector returnOP(uint32_t retOffset, uint32_t retSize); private: - struct MemoryTraceEntry { - uint32_t m_clk; - uint32_t m_sub_clk; - uint32_t m_addr; - FF m_val{}; - AvmMemoryTag m_tag; - AvmMemoryTag m_in_tag; - bool m_rw = false; - bool m_tag_err = false; - FF m_one_min_inv{}; - }; - std::vector mainTrace; - std::vector memTrace; // Entries will be sorted by m_clk, m_sub_clk after finalize(). - std::array memory{}; // Memory table (used for simulation) - std::array memoryTag{}; // The tag of the corresponding memory - // entry (aligned with the memory array). + AvmMiniMemTraceBuilder memTraceBuilder; uint32_t pc = 0; uint32_t internal_return_ptr = CALLSTACK_OFFSET; std::stack internal_call_stack = {}; - - static bool compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right); - void insertInMemTrace( - uint32_t m_clk, uint32_t m_sub_clk, uint32_t m_addr, FF m_val, AvmMemoryTag m_in_tag, bool m_rw); - void loadMismatchTagInMemTrace( - uint32_t m_clk, uint32_t m_sub_clk, uint32_t m_addr, FF m_val, AvmMemoryTag m_in_tag, AvmMemoryTag m_tag); - bool loadInMemTrace(IntermRegister intermReg, uint32_t addr, FF val, AvmMemoryTag m_in_tag); - void storeInMemTrace(IntermRegister intermReg, uint32_t addr, FF val, AvmMemoryTag m_in_tag); }; } // namespace proof_system diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp index 893216fb71e..f1968f9f70f 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp @@ -69,7 +69,7 @@ TEST_F(AvmMiniMemoryTests, mismatchedTag) // Find the memory trace position corresponding to the add sub-operation of register ia. row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniTraceBuilder::SUB_CLK_LOAD_A; + return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniMemTraceBuilder::SUB_CLK_LOAD_A; }); EXPECT_TRUE(row != trace.end()); @@ -80,7 +80,7 @@ TEST_F(AvmMiniMemoryTests, mismatchedTag) // Find the memory trace position corresponding to the add sub-operation of register ib. row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniTraceBuilder::SUB_CLK_LOAD_B; + return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniMemTraceBuilder::SUB_CLK_LOAD_B; }); EXPECT_TRUE(row != trace.end()); @@ -112,7 +112,7 @@ TEST_F(AvmMiniMemoryTests, mLastAccessViolation) // Find the row for memory trace with last memory entry for address 1 (read for subtraction) row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { return r.memTrace_m_clk == clk && r.memTrace_m_addr == FF(1) && - r.memTrace_m_sub_clk == AvmMiniTraceBuilder::SUB_CLK_LOAD_A; + r.memTrace_m_sub_clk == AvmMiniMemTraceBuilder::SUB_CLK_LOAD_A; }); EXPECT_TRUE(row != trace.end()); @@ -142,7 +142,7 @@ TEST_F(AvmMiniMemoryTests, readWriteConsistencyValViolation) // Find the row for memory trace with last memory entry for address 2 (read for multiplication) row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { return r.memTrace_m_clk == clk && r.memTrace_m_addr == FF(2) && - r.memTrace_m_sub_clk == AvmMiniTraceBuilder::SUB_CLK_LOAD_A; + r.memTrace_m_sub_clk == AvmMiniMemTraceBuilder::SUB_CLK_LOAD_A; }); EXPECT_TRUE(row != trace.end()); @@ -172,7 +172,7 @@ TEST_F(AvmMiniMemoryTests, readWriteConsistencyTagViolation) // Find the row for memory trace with last memory entry for address 2 (read for multiplication) row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { return r.memTrace_m_clk == clk && r.memTrace_m_addr == FF(2) && - r.memTrace_m_sub_clk == AvmMiniTraceBuilder::SUB_CLK_LOAD_A; + r.memTrace_m_sub_clk == AvmMiniMemTraceBuilder::SUB_CLK_LOAD_A; }); EXPECT_TRUE(row != trace.end()); @@ -212,7 +212,7 @@ TEST_F(AvmMiniMemoryTests, mismatchedTagErrorViolation) // Find the memory trace position corresponding to the subtraction sub-operation of register ia. row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniTraceBuilder::SUB_CLK_LOAD_A; + return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniMemTraceBuilder::SUB_CLK_LOAD_A; }); row->memTrace_m_tag_err = FF(0); @@ -246,7 +246,7 @@ TEST_F(AvmMiniMemoryTests, consistentTagNoErrorViolation) // Find the memory trace position corresponding to the div sub-operation of register ia. row = std::ranges::find_if(trace.begin(), trace.end(), [clk](Row r) { - return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniTraceBuilder::SUB_CLK_LOAD_A; + return r.memTrace_m_clk == clk && r.memTrace_m_sub_clk == AvmMiniMemTraceBuilder::SUB_CLK_LOAD_A; }); row->memTrace_m_tag_err = FF(1); From 91e3a6593d65bcdbceaa13e3b944d85cfa57d416 Mon Sep 17 00:00:00 2001 From: jeanmon Date: Thu, 4 Jan 2024 16:22:37 +0000 Subject: [PATCH 4/7] Style - snake casing of camel case variables and function names --- .../circuit_builder/AvmMini_mem_trace.cpp | 100 ++--- .../circuit_builder/AvmMini_mem_trace.hpp | 37 +- .../circuit_builder/AvmMini_trace.cpp | 370 +++++++++--------- .../circuit_builder/AvmMini_trace.hpp | 30 +- .../vm/tests/AvmMini_arithmetic.test.cpp | 108 ++--- .../vm/tests/AvmMini_control_flow.test.cpp | 8 +- .../vm/tests/AvmMini_memory.test.cpp | 34 +- .../barretenberg/vm/tests/helpers.test.cpp | 10 +- .../barretenberg/vm/tests/helpers.test.hpp | 4 +- 9 files changed, 353 insertions(+), 348 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp index 93d50e303b7..735ab6ac272 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp @@ -8,7 +8,7 @@ namespace proof_system { */ AvmMiniMemTraceBuilder::AvmMiniMemTraceBuilder() { - memTrace.reserve(AVM_TRACE_SIZE); + mem_trace.reserve(AVM_TRACE_SIZE); } /** @@ -17,7 +17,7 @@ AvmMiniMemTraceBuilder::AvmMiniMemTraceBuilder() */ void AvmMiniMemTraceBuilder::reset() { - memTrace.clear(); + mem_trace.clear(); memory.fill(FF(0)); } @@ -25,7 +25,7 @@ void AvmMiniMemTraceBuilder::reset() * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. * */ -bool AvmMiniMemTraceBuilder::compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right) +bool AvmMiniMemTraceBuilder::compare_mem_entries(const MemoryTraceEntry& left, const MemoryTraceEntry& right) { if (left.m_addr < right.m_addr) { return true; @@ -56,8 +56,8 @@ bool AvmMiniMemTraceBuilder::compareMemEntries(const MemoryTraceEntry& left, con std::vector AvmMiniMemTraceBuilder::finalize() { // Sort memTrace - std::sort(memTrace.begin(), memTrace.end(), compareMemEntries); - return std::move(memTrace); + std::sort(mem_trace.begin(), mem_trace.end(), compare_mem_entries); + return std::move(mem_trace); } /** @@ -70,14 +70,14 @@ std::vector AvmMiniMemTraceBuilder::fi * @param m_in_tag Memory tag pertaining to the instruction * @param m_rw Boolean telling whether it is a load (false) or store operation (true). */ -void AvmMiniMemTraceBuilder::insertInMemTrace(uint32_t const m_clk, - uint32_t const m_sub_clk, - uint32_t const m_addr, - FF const& m_val, - AvmMemoryTag const m_in_tag, - bool const m_rw) +void AvmMiniMemTraceBuilder::insert_in_mem_trace(uint32_t const m_clk, + uint32_t const m_sub_clk, + uint32_t const m_addr, + FF const& m_val, + AvmMemoryTag const m_in_tag, + bool const m_rw) { - memTrace.emplace_back(MemoryTraceEntry{ + mem_trace.emplace_back(MemoryTraceEntry{ .m_clk = m_clk, .m_sub_clk = m_sub_clk, .m_addr = m_addr, @@ -103,22 +103,22 @@ void AvmMiniMemTraceBuilder::insertInMemTrace(uint32_t const m_clk, * @param m_in_tag Memory tag pertaining to the instruction * @param m_tag Memory tag pertaining to the address */ -void AvmMiniMemTraceBuilder::loadMismatchTagInMemTrace(uint32_t const m_clk, - uint32_t const m_sub_clk, - uint32_t const m_addr, - FF const& m_val, - AvmMemoryTag const m_in_tag, - AvmMemoryTag const m_tag) +void AvmMiniMemTraceBuilder::load_mismatch_tag_in_mem_trace(uint32_t const m_clk, + uint32_t const m_sub_clk, + uint32_t const m_addr, + FF const& m_val, + AvmMemoryTag const m_in_tag, + AvmMemoryTag const m_tag) { FF one_min_inv = FF(1) - (FF(static_cast(m_in_tag)) - FF(static_cast(m_tag))).invert(); - memTrace.emplace_back(MemoryTraceEntry{ .m_clk = m_clk, - .m_sub_clk = m_sub_clk, - .m_addr = m_addr, - .m_val = m_val, - .m_tag = m_tag, - .m_in_tag = m_in_tag, - .m_tag_err = true, - .m_one_min_inv = one_min_inv }); + mem_trace.emplace_back(MemoryTraceEntry{ .m_clk = m_clk, + .m_sub_clk = m_sub_clk, + .m_addr = m_addr, + .m_val = m_val, + .m_tag = m_tag, + .m_in_tag = m_in_tag, + .m_tag_err = true, + .m_one_min_inv = one_min_inv }); } /** @@ -126,16 +126,16 @@ void AvmMiniMemTraceBuilder::loadMismatchTagInMemTrace(uint32_t const m_clk, * passed register. * * @param clk The main clock - * @param intermReg The intermediate register + * @param interm_reg The intermediate register * @param addr The memory address * @param val The value to be loaded * @param m_in_tag The memory tag of the instruction */ -bool AvmMiniMemTraceBuilder::loadInMemTrace( - uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) +bool AvmMiniMemTraceBuilder::load_in_mem_trace( + uint32_t clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) { uint32_t sub_clk = 0; - switch (intermReg) { + switch (interm_reg) { case IntermRegister::ia: sub_clk = SUB_CLK_LOAD_A; break; @@ -147,14 +147,14 @@ bool AvmMiniMemTraceBuilder::loadInMemTrace( break; } - auto m_tag = memoryTag.at(addr); + auto m_tag = memory_tag.at(addr); if (m_tag == AvmMemoryTag::u0 || m_tag == m_in_tag) { - insertInMemTrace(clk, sub_clk, addr, val, m_in_tag, false); + insert_in_mem_trace(clk, sub_clk, addr, val, m_in_tag, false); return true; } // Handle memory tag inconsistency - loadMismatchTagInMemTrace(clk, sub_clk, addr, val, m_in_tag, m_tag); + load_mismatch_tag_in_mem_trace(clk, sub_clk, addr, val, m_in_tag, m_tag); return false; } @@ -163,16 +163,16 @@ bool AvmMiniMemTraceBuilder::loadInMemTrace( * register. * * @param clk The main clock - * @param intermReg The intermediate register + * @param interm_reg The intermediate register * @param addr The memory address * @param val The value to be stored * @param m_in_tag The memory tag of the instruction */ -void AvmMiniMemTraceBuilder::storeInMemTrace( - uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) +void AvmMiniMemTraceBuilder::store_in_mem_trace( + uint32_t clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) { uint32_t sub_clk = 0; - switch (intermReg) { + switch (interm_reg) { case IntermRegister::ia: sub_clk = SUB_CLK_STORE_A; break; @@ -184,7 +184,7 @@ void AvmMiniMemTraceBuilder::storeInMemTrace( break; } - insertInMemTrace(clk, sub_clk, addr, val, m_in_tag, true); + insert_in_mem_trace(clk, sub_clk, addr, val, m_in_tag, true); } /** @@ -193,22 +193,22 @@ void AvmMiniMemTraceBuilder::storeInMemTrace( * is added. * * @param clk Main clock - * @param intermReg Intermediate register where we load the value + * @param interm_reg Intermediate register where we load the value * @param addr Memory address to be read and loaded * @param m_in_tag Memory instruction tag * @return Result of the read operation containing the value and a boolean telling * potential mismatch between instruction tag and memory tag of the address. */ -AvmMiniMemTraceBuilder::MemRead AvmMiniMemTraceBuilder::readAndLoadFromMemory(uint32_t const clk, - IntermRegister const intermReg, - uint32_t const addr, - AvmMemoryTag const m_in_tag) +AvmMiniMemTraceBuilder::MemRead AvmMiniMemTraceBuilder::read_and_load_from_memory(uint32_t const clk, + IntermRegister const interm_reg, + uint32_t const addr, + AvmMemoryTag const m_in_tag) { FF val = memory.at(addr); - bool tagMatch = loadInMemTrace(clk, intermReg, addr, val, m_in_tag); + bool tagMatch = load_in_mem_trace(clk, interm_reg, addr, val, m_in_tag); return MemRead{ - .tagMatch = tagMatch, + .tag_match = tagMatch, .val = val, }; } @@ -219,17 +219,17 @@ AvmMiniMemTraceBuilder::MemRead AvmMiniMemTraceBuilder::readAndLoadFromMemory(ui * is added. * * @param clk Main clock - * @param intermReg Intermediate register where we write the value + * @param interm_reg Intermediate register where we write the value * @param addr Memory address to be written to * @param val Value to be written into memory * @param m_in_tag Memory instruction tag */ -void AvmMiniMemTraceBuilder::writeIntoMemory( - uint32_t const clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) +void AvmMiniMemTraceBuilder::write_into_memory( + uint32_t const clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) { memory.at(addr) = val; - memoryTag.at(addr) = m_in_tag; - storeInMemTrace(clk, intermReg, addr, val, m_in_tag); + memory_tag.at(addr) = m_in_tag; + store_in_mem_trace(clk, interm_reg, addr, val, m_in_tag); } } // namespace proof_system \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp index 6de192c9655..121d5ca9f6e 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp @@ -29,7 +29,7 @@ class AvmMiniMemTraceBuilder { // Structure to return value and tag matching boolean after a memory read. struct MemRead { - bool tagMatch; + bool tag_match; FF val; }; @@ -39,27 +39,30 @@ class AvmMiniMemTraceBuilder { std::vector finalize(); - MemRead readAndLoadFromMemory(uint32_t clk, IntermRegister intermReg, uint32_t addr, AvmMemoryTag m_in_tag); - void writeIntoMemory(uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); + MemRead read_and_load_from_memory(uint32_t clk, IntermRegister interm_reg, uint32_t addr, AvmMemoryTag m_in_tag); + void write_into_memory( + uint32_t clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); private: - std::vector memTrace; // Entries will be sorted by m_clk, m_sub_clk after finalize(). - std::array memory{}; // Memory table (used for simulation) - std::array memoryTag{}; // The tag of the corresponding memory - // entry (aligned with the memory array). + std::vector mem_trace; // Entries will be sorted by m_clk, m_sub_clk after finalize(). + std::array memory{}; // Memory table (used for simulation) + std::array memory_tag{}; // The tag of the corresponding memory + // entry (aligned with the memory array). - static bool compareMemEntries(const MemoryTraceEntry& left, const MemoryTraceEntry& right); + static bool compare_mem_entries(const MemoryTraceEntry& left, const MemoryTraceEntry& right); - void insertInMemTrace( + void insert_in_mem_trace( uint32_t m_clk, uint32_t m_sub_clk, uint32_t m_addr, FF const& m_val, AvmMemoryTag m_in_tag, bool m_rw); - void loadMismatchTagInMemTrace(uint32_t m_clk, - uint32_t m_sub_clk, - uint32_t m_addr, - FF const& m_val, - AvmMemoryTag m_in_tag, - AvmMemoryTag m_tag); + void load_mismatch_tag_in_mem_trace(uint32_t m_clk, + uint32_t m_sub_clk, + uint32_t m_addr, + FF const& m_val, + AvmMemoryTag m_in_tag, + AvmMemoryTag m_tag); - bool loadInMemTrace(uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); - void storeInMemTrace(uint32_t clk, IntermRegister intermReg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); + bool load_in_mem_trace( + uint32_t clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); + void store_in_mem_trace( + uint32_t clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); }; } // namespace proof_system \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp index c177ad07db8..de402554c34 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp @@ -18,7 +18,7 @@ namespace proof_system { */ AvmMiniTraceBuilder::AvmMiniTraceBuilder() { - mainTrace.reserve(AVM_TRACE_SIZE); + main_trace.reserve(AVM_TRACE_SIZE); } /** @@ -27,165 +27,165 @@ AvmMiniTraceBuilder::AvmMiniTraceBuilder() */ void AvmMiniTraceBuilder::reset() { - mainTrace.clear(); - memTraceBuilder.reset(); + main_trace.clear(); + mem_trace_builder.reset(); } /** TODO: Implement for non finite field types * @brief Addition with direct memory access. * - * @param aOffset An index in memory pointing to the first operand of the addition. - * @param bOffset An index in memory pointing to the second operand of the addition. - * @param dstOffset An index in memory pointing to the output of the addition. - * @param inTag The instruction memory tag of the operands. + * @param a_offset An index in memory pointing to the first operand of the addition. + * @param b_offset An index in memory pointing to the second operand of the addition. + * @param dst_offset An index in memory pointing to the output of the addition. + * @param in_tag The instruction memory tag of the operands. */ -void AvmMiniTraceBuilder::add(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) +void AvmMiniTraceBuilder::add(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag) { - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); // Reading from memory and loading into ia resp. ib. - auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); - auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); - bool tagMatch = readA.tagMatch && readB.tagMatch; + auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ia, a_offset, in_tag); + auto read_b = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ib, b_offset, in_tag); + bool tag_match = read_a.tag_match && read_b.tag_match; // a + b = c - FF a = readA.val; - FF b = readB.val; + FF a = read_a.val; + FF b = read_b.val; FF c = a + b; // Write into memory value c from intermediate register ic. - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); + mem_trace_builder.write_into_memory(clk, IntermRegister::ic, dst_offset, c, in_tag); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_add = FF(1), - .avmMini_in_tag = FF(static_cast(inTag)), - .avmMini_tag_err = FF(static_cast(!tagMatch)), - .avmMini_ia = tagMatch ? a : FF(0), - .avmMini_ib = tagMatch ? b : FF(0), - .avmMini_ic = tagMatch ? c : FF(0), + .avmMini_in_tag = FF(static_cast(in_tag)), + .avmMini_tag_err = FF(static_cast(!tag_match)), + .avmMini_ia = tag_match ? a : FF(0), + .avmMini_ib = tag_match ? b : FF(0), + .avmMini_ic = tag_match ? c : FF(0), .avmMini_mem_op_a = FF(1), .avmMini_mem_op_b = FF(1), .avmMini_mem_op_c = FF(1), .avmMini_rwc = FF(1), - .avmMini_mem_idx_a = FF(aOffset), - .avmMini_mem_idx_b = FF(bOffset), - .avmMini_mem_idx_c = FF(dstOffset), + .avmMini_mem_idx_a = FF(a_offset), + .avmMini_mem_idx_b = FF(b_offset), + .avmMini_mem_idx_c = FF(dst_offset), }); }; /** TODO: Implement for non finite field types * @brief Subtraction with direct memory access. * - * @param aOffset An index in memory pointing to the first operand of the subtraction. - * @param bOffset An index in memory pointing to the second operand of the subtraction. - * @param dstOffset An index in memory pointing to the output of the subtraction. - * @param inTag The instruction memory tag of the operands. + * @param a_offset An index in memory pointing to the first operand of the subtraction. + * @param b_offset An index in memory pointing to the second operand of the subtraction. + * @param dst_offset An index in memory pointing to the output of the subtraction. + * @param in_tag The instruction memory tag of the operands. */ -void AvmMiniTraceBuilder::sub(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) +void AvmMiniTraceBuilder::sub(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag) { - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); // Reading from memory and loading into ia resp. ib. - auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); - auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); - bool tagMatch = readA.tagMatch && readB.tagMatch; + auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ia, a_offset, in_tag); + auto read_b = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ib, b_offset, in_tag); + bool tag_match = read_a.tag_match && read_b.tag_match; // a - b = c - FF a = readA.val; - FF b = readB.val; + FF a = read_a.val; + FF b = read_b.val; FF c = a - b; // Write into memory value c from intermediate register ic. - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); + mem_trace_builder.write_into_memory(clk, IntermRegister::ic, dst_offset, c, in_tag); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_sub = FF(1), - .avmMini_in_tag = FF(static_cast(inTag)), - .avmMini_tag_err = FF(static_cast(!tagMatch)), - .avmMini_ia = tagMatch ? a : FF(0), - .avmMini_ib = tagMatch ? b : FF(0), - .avmMini_ic = tagMatch ? c : FF(0), + .avmMini_in_tag = FF(static_cast(in_tag)), + .avmMini_tag_err = FF(static_cast(!tag_match)), + .avmMini_ia = tag_match ? a : FF(0), + .avmMini_ib = tag_match ? b : FF(0), + .avmMini_ic = tag_match ? c : FF(0), .avmMini_mem_op_a = FF(1), .avmMini_mem_op_b = FF(1), .avmMini_mem_op_c = FF(1), .avmMini_rwc = FF(1), - .avmMini_mem_idx_a = FF(aOffset), - .avmMini_mem_idx_b = FF(bOffset), - .avmMini_mem_idx_c = FF(dstOffset), + .avmMini_mem_idx_a = FF(a_offset), + .avmMini_mem_idx_b = FF(b_offset), + .avmMini_mem_idx_c = FF(dst_offset), }); }; /** TODO: Implement for non finite field types * @brief Multiplication with direct memory access. * - * @param aOffset An index in memory pointing to the first operand of the multiplication. - * @param bOffset An index in memory pointing to the second operand of the multiplication. - * @param dstOffset An index in memory pointing to the output of the multiplication. - * @param inTag The instruction memory tag of the operands. + * @param a_offset An index in memory pointing to the first operand of the multiplication. + * @param b_offset An index in memory pointing to the second operand of the multiplication. + * @param dst_offset An index in memory pointing to the output of the multiplication. + * @param in_tag The instruction memory tag of the operands. */ -void AvmMiniTraceBuilder::mul(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) +void AvmMiniTraceBuilder::mul(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag) { - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); // Reading from memory and loading into ia resp. ib. - auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); - auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); - bool tagMatch = readA.tagMatch && readB.tagMatch; + auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ia, a_offset, in_tag); + auto read_b = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ib, b_offset, in_tag); + bool tag_match = read_a.tag_match && read_b.tag_match; // a * b = c - FF a = readA.val; - FF b = readB.val; + FF a = read_a.val; + FF b = read_b.val; FF c = a * b; // Write into memory value c from intermediate register ic. - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); + mem_trace_builder.write_into_memory(clk, IntermRegister::ic, dst_offset, c, in_tag); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_mul = FF(1), - .avmMini_in_tag = FF(static_cast(inTag)), - .avmMini_tag_err = FF(static_cast(!tagMatch)), - .avmMini_ia = tagMatch ? a : FF(0), - .avmMini_ib = tagMatch ? b : FF(0), - .avmMini_ic = tagMatch ? c : FF(0), + .avmMini_in_tag = FF(static_cast(in_tag)), + .avmMini_tag_err = FF(static_cast(!tag_match)), + .avmMini_ia = tag_match ? a : FF(0), + .avmMini_ib = tag_match ? b : FF(0), + .avmMini_ic = tag_match ? c : FF(0), .avmMini_mem_op_a = FF(1), .avmMini_mem_op_b = FF(1), .avmMini_mem_op_c = FF(1), .avmMini_rwc = FF(1), - .avmMini_mem_idx_a = FF(aOffset), - .avmMini_mem_idx_b = FF(bOffset), - .avmMini_mem_idx_c = FF(dstOffset), + .avmMini_mem_idx_a = FF(a_offset), + .avmMini_mem_idx_b = FF(b_offset), + .avmMini_mem_idx_c = FF(dst_offset), }); } /** TODO: Implement for non finite field types * @brief Division with direct memory access. * - * @param aOffset An index in memory pointing to the first operand of the division. - * @param bOffset An index in memory pointing to the second operand of the division. - * @param dstOffset An index in memory pointing to the output of the division. - * @param inTag The instruction memory tag of the operands. + * @param a_offset An index in memory pointing to the first operand of the division. + * @param b_offset An index in memory pointing to the second operand of the division. + * @param dst_offset An index in memory pointing to the output of the division. + * @param in_tag The instruction memory tag of the operands. */ -void AvmMiniTraceBuilder::div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag) +void AvmMiniTraceBuilder::div(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag) { - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); // Reading from memory and loading into ia resp. ib. - auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, aOffset, inTag); - auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, bOffset, inTag); - bool tagMatch = readA.tagMatch && readB.tagMatch; + auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ia, a_offset, in_tag); + auto read_b = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ib, b_offset, in_tag); + bool tag_match = read_a.tag_match && read_b.tag_match; // a * b^(-1) = c - FF a = readA.val; - FF b = readB.val; + FF a = read_a.val; + FF b = read_b.val; FF c; FF inv; FF error; @@ -202,62 +202,62 @@ void AvmMiniTraceBuilder::div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOf } // Write into memory value c from intermediate register ic. - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, dstOffset, c, inTag); + mem_trace_builder.write_into_memory(clk, IntermRegister::ic, dst_offset, c, in_tag); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_op_div = FF(1), - .avmMini_in_tag = FF(static_cast(inTag)), - .avmMini_op_err = tagMatch ? error : FF(1), - .avmMini_tag_err = FF(static_cast(!tagMatch)), - .avmMini_inv = tagMatch ? inv : FF(1), - .avmMini_ia = tagMatch ? a : FF(0), - .avmMini_ib = tagMatch ? b : FF(0), - .avmMini_ic = tagMatch ? c : FF(0), + .avmMini_in_tag = FF(static_cast(in_tag)), + .avmMini_op_err = tag_match ? error : FF(1), + .avmMini_tag_err = FF(static_cast(!tag_match)), + .avmMini_inv = tag_match ? inv : FF(1), + .avmMini_ia = tag_match ? a : FF(0), + .avmMini_ib = tag_match ? b : FF(0), + .avmMini_ic = tag_match ? c : FF(0), .avmMini_mem_op_a = FF(1), .avmMini_mem_op_b = FF(1), .avmMini_mem_op_c = FF(1), .avmMini_rwc = FF(1), - .avmMini_mem_idx_a = FF(aOffset), - .avmMini_mem_idx_b = FF(bOffset), - .avmMini_mem_idx_c = FF(dstOffset), + .avmMini_mem_idx_a = FF(a_offset), + .avmMini_mem_idx_b = FF(b_offset), + .avmMini_mem_idx_c = FF(dst_offset), }); } /** * @brief CALLDATACOPY opcode with direct memory access, i.e., - * M[dstOffset:dstOffset+copySize] = calldata[cdOffset:cdOffset+copySize] + * M[dst_offset:dst_offset+copy_size] = calldata[cd_offset:cd_offset+copy_size] * Simplified version with exclusively memory store operations and * values from M_calldata passed by an array and loaded into * intermediate registers. - * Assume that caller passes callDataMem which is large enough so that + * Assume that caller passes call_data_mem which is large enough so that * no out-of-bound memory issues occur. * TODO: Implement the indirect memory version (maybe not required) * TODO: taking care of intermediate register values consistency and propagating their * values to the next row when not overwritten. * - * @param cdOffset The starting index of the region in calldata to be copied. - * @param copySize The number of finite field elements to be copied into memory. - * @param dstOffset The starting index of memory where calldata will be copied to. - * @param callDataMem The vector containing calldata. + * @param cd_offset The starting index of the region in calldata to be copied. + * @param copy_size The number of finite field elements to be copied into memory. + * @param dst_offset The starting index of memory where calldata will be copied to. + * @param call_data_mem The vector containing calldata. */ -void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, - uint32_t copySize, - uint32_t dstOffset, - std::vector const& callDataMem) +void AvmMiniTraceBuilder::call_data_copy(uint32_t cd_offset, + uint32_t copy_size, + uint32_t dst_offset, + std::vector const& call_data_mem) { // We parallelize storing memory operations in chunk of 3, i.e., 1 per intermediate register. // The variable pos is an index pointing to the first storing operation (pertaining to intermediate - // register Ia) relative to cdOffset: - // cdOffset + pos: Ia memory store operation - // cdOffset + pos + 1: Ib memory store operation - // cdOffset + pos + 2: Ic memory store operation + // register Ia) relative to cd_offset: + // cd_offset + pos: Ia memory store operation + // cd_offset + pos + 1: Ib memory store operation + // cd_offset + pos + 2: Ic memory store operation uint32_t pos = 0; - while (pos < copySize) { + while (pos < copy_size) { FF ib(0); FF ic(0); uint32_t mem_op_b(0); @@ -266,37 +266,37 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, uint32_t mem_idx_c(0); uint32_t rwb(0); uint32_t rwc(0); - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); - FF ia = callDataMem.at(cdOffset + pos); + FF ia = call_data_mem.at(cd_offset + pos); uint32_t mem_op_a(1); - uint32_t mem_idx_a = dstOffset + pos; + uint32_t mem_idx_a = dst_offset + pos; uint32_t rwa = 1; // Storing from Ia - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ia, mem_idx_a, ia, AvmMemoryTag::ff); + mem_trace_builder.write_into_memory(clk, IntermRegister::ia, mem_idx_a, ia, AvmMemoryTag::ff); - if (copySize - pos > 1) { - ib = callDataMem.at(cdOffset + pos + 1); + if (copy_size - pos > 1) { + ib = call_data_mem.at(cd_offset + pos + 1); mem_op_b = 1; - mem_idx_b = dstOffset + pos + 1; + mem_idx_b = dst_offset + pos + 1; rwb = 1; // Storing from Ib - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ib, mem_idx_b, ib, AvmMemoryTag::ff); + mem_trace_builder.write_into_memory(clk, IntermRegister::ib, mem_idx_b, ib, AvmMemoryTag::ff); } - if (copySize - pos > 2) { - ic = callDataMem.at(cdOffset + pos + 2); + if (copy_size - pos > 2) { + ic = call_data_mem.at(cd_offset + pos + 2); mem_op_c = 1; - mem_idx_c = dstOffset + pos + 2; + mem_idx_c = dst_offset + pos + 2; rwc = 1; // Storing from Ic - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ic, mem_idx_c, ic, AvmMemoryTag::ff); + mem_trace_builder.write_into_memory(clk, IntermRegister::ic, mem_idx_c, ic, AvmMemoryTag::ff); } - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc++), .avmMini_internal_return_ptr = FF(internal_return_ptr), @@ -315,77 +315,79 @@ void AvmMiniTraceBuilder::callDataCopy(uint32_t cdOffset, .avmMini_mem_idx_c = FF(mem_idx_c), }); - if (copySize - pos > 2) { // Guard to prevent overflow if copySize is close to uint32_t maximum value. + if (copy_size - pos > 2) { // Guard to prevent overflow if copy_size is close to uint32_t maximum value. pos += 3; } else { - pos = copySize; + pos = copy_size; } } } /** * @brief RETURN opcode with direct memory access, i.e., - * return(M[retOffset:retOffset+retSize]) + * return(M[ret_offset:ret_offset+ret_size]) * Simplified version with exclusively memory load operations into * intermediate registers and then values are copied to the returned vector. * TODO: Implement the indirect memory version (maybe not required) * TODO: taking care of flagging this row as the last one? Special STOP flag? * - * @param retOffset The starting index of the memory region to be returned. - * @param retSize The number of elements to be returned. + * @param ret_offset The starting index of the memory region to be returned. + * @param ret_size The number of elements to be returned. * @return The returned memory region as a std::vector. */ -std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSize) +std::vector AvmMiniTraceBuilder::return_op(uint32_t ret_offset, uint32_t ret_size) { // We parallelize loading memory operations in chunk of 3, i.e., 1 per intermediate register. // The variable pos is an index pointing to the first storing operation (pertaining to intermediate - // register Ia) relative to retOffset: - // retOffset + pos: Ia memory load operation - // retOffset + pos + 1: Ib memory load operation - // retOffset + pos + 2: Ic memory load operation + // register Ia) relative to ret_offset: + // ret_offset + pos: Ia memory load operation + // ret_offset + pos + 1: Ib memory load operation + // ret_offset + pos + 2: Ic memory load operation uint32_t pos = 0; std::vector returnMem; - while (pos < retSize) { + while (pos < ret_size) { FF ib(0); FF ic(0); uint32_t mem_op_b(0); uint32_t mem_op_c(0); uint32_t mem_idx_b(0); uint32_t mem_idx_c(0); - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); uint32_t mem_op_a(1); - uint32_t mem_idx_a = retOffset + pos; + uint32_t mem_idx_a = ret_offset + pos; // Reading and loading to Ia - auto readA = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, mem_idx_a, AvmMemoryTag::ff); - FF ia = readA.val; + auto read_a = mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ia, mem_idx_a, AvmMemoryTag::ff); + FF ia = read_a.val; returnMem.push_back(ia); - if (retSize - pos > 1) { + if (ret_size - pos > 1) { mem_op_b = 1; - mem_idx_b = retOffset + pos + 1; + mem_idx_b = ret_offset + pos + 1; // Reading and loading to Ib - auto readB = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ib, mem_idx_b, AvmMemoryTag::ff); - FF ib = readB.val; + auto read_b = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ib, mem_idx_b, AvmMemoryTag::ff); + FF ib = read_b.val; returnMem.push_back(ib); } - if (retSize - pos > 2) { + if (ret_size - pos > 2) { mem_op_c = 1; - mem_idx_c = retOffset + pos + 2; + mem_idx_c = ret_offset + pos + 2; // Reading and loading to Ic - auto readC = memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ic, mem_idx_c, AvmMemoryTag::ff); - FF ic = readC.val; + auto read_c = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ic, mem_idx_c, AvmMemoryTag::ff); + FF ic = read_c.val; returnMem.push_back(ic); } - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), .avmMini_internal_return_ptr = FF(internal_return_ptr), @@ -402,10 +404,10 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi .avmMini_mem_idx_c = FF(mem_idx_c), }); - if (retSize - pos > 2) { // Guard to prevent overflow if retSize is close to uint32_t maximum value. + if (ret_size - pos > 2) { // Guard to prevent overflow if ret_size is close to uint32_t maximum value. pos += 3; } else { - pos = retSize; + pos = ret_size; } } return returnMem; @@ -419,9 +421,9 @@ std::vector AvmMiniTraceBuilder::returnOP(uint32_t retOffset, uint32_t retSi */ void AvmMiniTraceBuilder::halt() { - auto clk = mainTrace.size(); + auto clk = main_trace.size(); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), .avmMini_internal_return_ptr = FF(internal_return_ptr), @@ -431,58 +433,58 @@ void AvmMiniTraceBuilder::halt() /** * @brief JUMP OPCODE - * Jumps to a new `jmpDest` + * Jumps to a new `jmp_dest` * This function must: - * - Set the next program counter to the provided `jmpDest`. + * - Set the next program counter to the provided `jmp_dest`. * - * @param jmpDest - The destination to jump to + * @param jmp_dest - The destination to jump to */ -void AvmMiniTraceBuilder::jump(uint32_t jmpDest) +void AvmMiniTraceBuilder::jump(uint32_t jmp_dest) { - auto clk = mainTrace.size(); + auto clk = main_trace.size(); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_jump = FF(1), - .avmMini_ia = FF(jmpDest), + .avmMini_ia = FF(jmp_dest), }); // Adjust parameters for the next row - pc = jmpDest; + pc = jmp_dest; } /** * @brief INTERNAL_CALL OPCODE - * This opcode effectively jumps to a new `jmpDest` and stores the return program counter + * This opcode effectively jumps to a new `jmp_dest` and stores the return program counter * (current program counter + 1) onto a call stack. * This function must: - * - Set the next program counter to the provided `jmpDest`. + * - Set the next program counter to the provided `jmp_dest`. * - Store the current `pc` + 1 onto the call stack (emulated in memory) * - Increment the return stack pointer (a pointer to where the call stack is in memory) * * Note: We use intermediate register to perform memory storage operations. * - * @param jmpDest - The destination to jump to + * @param jmp_dest - The destination to jump to */ -void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) +void AvmMiniTraceBuilder::internal_call(uint32_t jmp_dest) { - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); // We store the next instruction as the return location uint32_t stored_pc = pc + 1; internal_call_stack.push(stored_pc); // Add the return location to the memory trace - memTraceBuilder.writeIntoMemory(clk, IntermRegister::ib, internal_return_ptr, FF(stored_pc), AvmMemoryTag::ff); + mem_trace_builder.write_into_memory(clk, IntermRegister::ib, internal_return_ptr, FF(stored_pc), AvmMemoryTag::ff); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = FF(pc), .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_internal_call = FF(1), - .avmMini_ia = FF(jmpDest), + .avmMini_ia = FF(jmp_dest), .avmMini_ib = stored_pc, .avmMini_mem_op_b = FF(1), .avmMini_rwb = FF(1), @@ -490,7 +492,7 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) }); // Adjust parameters for the next row - pc = jmpDest; + pc = jmp_dest; internal_return_ptr++; } @@ -506,25 +508,25 @@ void AvmMiniTraceBuilder::internal_call(uint32_t jmpDest) */ void AvmMiniTraceBuilder::internal_return() { - auto clk = static_cast(mainTrace.size()); + auto clk = static_cast(main_trace.size()); // Internal return pointer is decremented // We want to load the value pointed by the internal pointer - auto readA = - memTraceBuilder.readAndLoadFromMemory(clk, IntermRegister::ia, internal_return_ptr - 1, AvmMemoryTag::ff); + auto read_a = + mem_trace_builder.read_and_load_from_memory(clk, IntermRegister::ia, internal_return_ptr - 1, AvmMemoryTag::ff); - mainTrace.push_back(Row{ + main_trace.push_back(Row{ .avmMini_clk = clk, .avmMini_pc = pc, .avmMini_internal_return_ptr = FF(internal_return_ptr), .avmMini_sel_internal_return = FF(1), - .avmMini_ia = readA.val, + .avmMini_ia = read_a.val, .avmMini_mem_op_a = FF(1), .avmMini_rwa = FF(0), .avmMini_mem_idx_a = FF(internal_return_ptr - 1), }); - // We want the next row to be the one pointed by jmpDest + // We want the next row to be the one pointed by jmp_dest // The next pc should be from the top of the internal call stack + 1 pc = internal_call_stack.top(); internal_call_stack.pop(); @@ -541,27 +543,27 @@ void AvmMiniTraceBuilder::internal_return() */ std::vector AvmMiniTraceBuilder::finalize() { - auto memTrace = memTraceBuilder.finalize(); - size_t memTraceSize = memTrace.size(); - size_t mainTraceSize = mainTrace.size(); + auto mem_trace = mem_trace_builder.finalize(); + size_t mem_trace_size = mem_trace.size(); + size_t main_trace_size = main_trace.size(); // TODO: We will have to handle this through error handling and not an assertion // Smaller than N because we have to add an extra initial row to support shifted // elements - assert(memTraceSize < AVM_TRACE_SIZE); - assert(mainTraceSize < AVM_TRACE_SIZE); + assert(mem_trace_size < AVM_TRACE_SIZE); + assert(main_trace_size < AVM_TRACE_SIZE); // Fill the rest with zeros. - size_t zeroRowsNum = AVM_TRACE_SIZE - mainTraceSize - 1; - while (zeroRowsNum-- > 0) { - mainTrace.push_back(Row{}); + size_t zero_rows_num = AVM_TRACE_SIZE - main_trace_size - 1; + while (zero_rows_num-- > 0) { + main_trace.push_back(Row{}); } - mainTrace.at(mainTraceSize - 1).avmMini_last = FF(1); + main_trace.at(main_trace_size - 1).avmMini_last = FF(1); - for (size_t i = 0; i < memTraceSize; i++) { - auto const& src = memTrace.at(i); - auto& dest = mainTrace.at(i); + for (size_t i = 0; i < mem_trace_size; i++) { + auto const& src = mem_trace.at(i); + auto& dest = main_trace.at(i); dest.memTrace_m_clk = FF(src.m_clk); dest.memTrace_m_sub_clk = FF(src.m_sub_clk); @@ -573,8 +575,8 @@ std::vector AvmMiniTraceBuilder::finalize() dest.memTrace_m_tag_err = FF(static_cast(src.m_tag_err)); dest.memTrace_m_one_min_inv = src.m_one_min_inv; - if (i + 1 < memTraceSize) { - auto const& next = memTrace.at(i + 1); + if (i + 1 < mem_trace_size) { + auto const& next = mem_trace.at(i + 1); dest.memTrace_m_lastAccess = FF(static_cast(src.m_addr != next.m_addr)); } else { dest.memTrace_m_lastAccess = FF(1); @@ -584,9 +586,9 @@ std::vector AvmMiniTraceBuilder::finalize() // Adding extra row for the shifted values at the top of the execution trace. Row first_row = Row{ .avmMini_first = FF(1), .memTrace_m_lastAccess = FF(1) }; - mainTrace.insert(mainTrace.begin(), first_row); + main_trace.insert(main_trace.begin(), first_row); - auto trace = std::move(mainTrace); + auto trace = std::move(main_trace); reset(); return trace; diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp index 1e3b42c7b9a..555274d5595 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp @@ -21,30 +21,27 @@ class AvmMiniTraceBuilder { AvmMiniTraceBuilder(); - // Temporary helper to initialize memory. - void setFFMem(size_t idx, FF el, AvmMemoryTag tag); - std::vector finalize(); void reset(); // Addition with direct memory access. - void add(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag); + void add(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag); // Subtraction with direct memory access. - void sub(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag); + void sub(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag); // Multiplication with direct memory access. - void mul(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag); + void mul(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag); // Division with direct memory access. - void div(uint32_t aOffset, uint32_t bOffset, uint32_t dstOffset, AvmMemoryTag inTag); + void div(uint32_t a_offset, uint32_t b_offset, uint32_t dst_offset, AvmMemoryTag in_tag); // Jump to a given program counter. - void jump(uint32_t jmpDest); + void jump(uint32_t jmp_dest); // Jump to a given program counter; storing the return location on a call stack. // TODO(md): this program counter MUST be an operand to the OPCODE. - void internal_call(uint32_t jmpDest); + void internal_call(uint32_t jmp_dest); // Return from a jump. void internal_return(); @@ -53,16 +50,19 @@ class AvmMiniTraceBuilder { void halt(); // CALLDATACOPY opcode with direct memory access, i.e., - // M[dstOffset:dstOffset+copySize] = calldata[cdOffset:cdOffset+copySize] - void callDataCopy(uint32_t cdOffset, uint32_t copySize, uint32_t dstOffset, std::vector const& callDataMem); + // M[dst_offset:dst_offset+copy_size] = calldata[cd_offset:cd_offset+copy_size] + void call_data_copy(uint32_t cd_offset, + uint32_t copy_size, + uint32_t dst_offset, + std::vector const& call_data_mem); // RETURN opcode with direct memory access, i.e., - // return(M[retOffset:retOffset+retSize]) - std::vector returnOP(uint32_t retOffset, uint32_t retSize); + // return(M[ret_offset:ret_offset+ret_size]) + std::vector return_op(uint32_t ret_offset, uint32_t ret_size); private: - std::vector mainTrace; - AvmMiniMemTraceBuilder memTraceBuilder; + std::vector main_trace; + AvmMiniMemTraceBuilder mem_trace_builder; uint32_t pc = 0; uint32_t internal_return_ptr = CALLSTACK_OFFSET; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp index a75e798292c..0115edc4277 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp @@ -62,11 +62,11 @@ class AvmMiniArithmeticNegativeTests : public AvmMiniArithmeticTests {}; TEST_F(AvmMiniArithmeticTests, additionFF) { // trace_builder - trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 37, 4, 11 }); // Memory layout: [37,4,11,0,0,0,....] trace_builder.add(0, 1, 4, AvmMemoryTag::ff); // [37,4,11,0,41,0,....] - trace_builder.returnOP(0, 5); + trace_builder.return_op(0, 5); auto trace = trace_builder.finalize(); // Find the first row enabling the addition selector @@ -79,17 +79,17 @@ TEST_F(AvmMiniArithmeticTests, additionFF) EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); EXPECT_EQ(row->avmMini_rwc, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Test on basic subtraction over finite field type. TEST_F(AvmMiniArithmeticTests, subtractionFF) { - trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 8, 4, 17 }); // Memory layout: [8,4,17,0,0,0,....] trace_builder.sub(2, 0, 1, AvmMemoryTag::ff); // [8,9,17,0,0,0....] - trace_builder.returnOP(0, 3); + trace_builder.return_op(0, 3); auto trace = trace_builder.finalize(); // Find the first row enabling the subtraction selector @@ -102,17 +102,17 @@ TEST_F(AvmMiniArithmeticTests, subtractionFF) EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); EXPECT_EQ(row->avmMini_rwc, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Test on basic multiplication over finite field type. TEST_F(AvmMiniArithmeticTests, multiplicationFF) { - trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 5, 0, 20 }); // Memory layout: [5,0,20,0,0,0,....] trace_builder.mul(2, 0, 1, AvmMemoryTag::ff); // [5,100,20,0,0,0....] - trace_builder.returnOP(0, 3); + trace_builder.return_op(0, 3); auto trace = trace_builder.finalize(); // Find the first row enabling the multiplication selector @@ -125,17 +125,17 @@ TEST_F(AvmMiniArithmeticTests, multiplicationFF) EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); EXPECT_EQ(row->avmMini_rwc, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Test on multiplication by zero over finite field type. TEST_F(AvmMiniArithmeticTests, multiplicationByZeroFF) { - trace_builder.callDataCopy(0, 1, 0, std::vector{ 127 }); + trace_builder.call_data_copy(0, 1, 0, std::vector{ 127 }); // Memory layout: [127,0,0,0,0,0,....] trace_builder.mul(0, 1, 2, AvmMemoryTag::ff); // [127,0,0,0,0,0....] - trace_builder.returnOP(0, 3); + trace_builder.return_op(0, 3); auto trace = trace_builder.finalize(); // Find the first row enabling the multiplication selector @@ -148,17 +148,17 @@ TEST_F(AvmMiniArithmeticTests, multiplicationByZeroFF) EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); EXPECT_EQ(row->avmMini_rwc, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Test on basic division over finite field type. TEST_F(AvmMiniArithmeticTests, divisionFF) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 15, 315 }); // Memory layout: [15,315,0,0,0,0,....] trace_builder.div(1, 0, 2, AvmMemoryTag::ff); // [15,315,21,0,0,0....] - trace_builder.returnOP(0, 3); + trace_builder.return_op(0, 3); auto trace = trace_builder.finalize(); // Find the first row enabling the division selector @@ -171,17 +171,17 @@ TEST_F(AvmMiniArithmeticTests, divisionFF) EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); EXPECT_EQ(row->avmMini_rwc, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Test on division with zero numerator over finite field type. TEST_F(AvmMiniArithmeticTests, divisionNumeratorZeroFF) { - trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); + trace_builder.call_data_copy(0, 1, 0, std::vector{ 15 }); // Memory layout: [15,0,0,0,0,0,....] trace_builder.div(1, 0, 0, AvmMemoryTag::ff); // [0,0,0,0,0,0....] - trace_builder.returnOP(0, 3); + trace_builder.return_op(0, 3); auto trace = trace_builder.finalize(); // Find the first row enabling the division selector @@ -194,14 +194,14 @@ TEST_F(AvmMiniArithmeticTests, divisionNumeratorZeroFF) EXPECT_EQ(row->avmMini_mem_op_c, FF(1)); EXPECT_EQ(row->avmMini_rwc, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Test on division by zero over finite field type. // We check that the operator error flag is raised. TEST_F(AvmMiniArithmeticTests, divisionByZeroErrorFF) { - trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); + trace_builder.call_data_copy(0, 1, 0, std::vector{ 15 }); // Memory layout: [15,0,0,0,0,0,....] trace_builder.div(0, 1, 2, AvmMemoryTag::ff); // [15,0,0,0,0,0....] @@ -219,7 +219,7 @@ TEST_F(AvmMiniArithmeticTests, divisionByZeroErrorFF) EXPECT_EQ(row->avmMini_rwc, FF(1)); EXPECT_EQ(row->avmMini_op_err, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Test on division of zero by zero over finite field type. @@ -242,7 +242,7 @@ TEST_F(AvmMiniArithmeticTests, divisionZeroByZeroErrorFF) EXPECT_EQ(row->avmMini_rwc, FF(1)); EXPECT_EQ(row->avmMini_op_err, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Testing an execution of the different arithmetic opcodes over finite field @@ -251,7 +251,7 @@ TEST_F(AvmMiniArithmeticTests, divisionZeroByZeroErrorFF) // No check on the evaluation is performed here. TEST_F(AvmMiniArithmeticTests, arithmeticFFWithError) { - trace_builder.callDataCopy(0, 3, 2, std::vector{ 45, 23, 12 }); + trace_builder.call_data_copy(0, 3, 2, std::vector{ 45, 23, 12 }); // Memory layout: [0,0,45,23,12,0,0,0,....] trace_builder.add(2, 3, 4, AvmMemoryTag::ff); // [0,0,45,23,68,0,0,0,....] @@ -267,7 +267,7 @@ TEST_F(AvmMiniArithmeticTests, arithmeticFFWithError) trace_builder.halt(); auto trace = trace_builder.finalize(); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } /****************************************************************************** @@ -294,68 +294,68 @@ TEST_F(AvmMiniArithmeticTests, arithmeticFFWithError) // Test on basic incorrect addition over finite field type. TEST_F(AvmMiniArithmeticNegativeTests, additionFF) { - trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 37, 4, 11 }); // Memory layout: [37,4,11,0,0,0,....] trace_builder.add(0, 1, 4, AvmMemoryTag::ff); // [37,4,11,0,41,0,....] auto trace = trace_builder.finalize(); - auto selectRow = [](Row r) { return r.avmMini_sel_op_add == FF(1); }; - mutateIcInTrace(trace, std::move(selectRow), FF(40)); + auto select_row = [](Row r) { return r.avmMini_sel_op_add == FF(1); }; + mutate_ic_in_trace(trace, std::move(select_row), FF(40)); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_ADDITION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ADDITION_FF"); } // Test on basic incorrect subtraction over finite field type. TEST_F(AvmMiniArithmeticNegativeTests, subtractionFF) { - trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 8, 4, 17 }); // Memory layout: [8,4,17,0,0,0,....] trace_builder.sub(2, 0, 1, AvmMemoryTag::ff); // [8,9,17,0,0,0....] auto trace = trace_builder.finalize(); - auto selectRow = [](Row r) { return r.avmMini_sel_op_sub == FF(1); }; - mutateIcInTrace(trace, std::move(selectRow), FF(-9)); + auto select_row = [](Row r) { return r.avmMini_sel_op_sub == FF(1); }; + mutate_ic_in_trace(trace, std::move(select_row), FF(-9)); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_SUBTRACTION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_SUBTRACTION_FF"); } // Test on basic incorrect multiplication over finite field type. TEST_F(AvmMiniArithmeticNegativeTests, multiplicationFF) { - trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 5, 0, 20 }); // Memory layout: [5,0,20,0,0,0,....] trace_builder.mul(2, 0, 1, AvmMemoryTag::ff); // [5,100,20,0,0,0....] auto trace = trace_builder.finalize(); - auto selectRow = [](Row r) { return r.avmMini_sel_op_mul == FF(1); }; - mutateIcInTrace(trace, std::move(selectRow), FF(1000)); + auto select_row = [](Row r) { return r.avmMini_sel_op_mul == FF(1); }; + mutate_ic_in_trace(trace, std::move(select_row), FF(1000)); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_MULTIPLICATION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_MULTIPLICATION_FF"); } // Test on basic incorrect division over finite field type. TEST_F(AvmMiniArithmeticNegativeTests, divisionFF) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 15, 315 }); // Memory layout: [15,315,0,0,0,0,....] trace_builder.div(1, 0, 2, AvmMemoryTag::ff); // [15,315,21,0,0,0....] auto trace = trace_builder.finalize(); - auto selectRow = [](Row r) { return r.avmMini_sel_op_div == FF(1); }; - mutateIcInTrace(trace, std::move(selectRow), FF(0)); + auto select_row = [](Row r) { return r.avmMini_sel_op_div == FF(1); }; + mutate_ic_in_trace(trace, std::move(select_row), FF(0)); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_DIVISION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_FF"); } // Test where division is not by zero but an operation error is wrongly raised // in the trace. TEST_F(AvmMiniArithmeticNegativeTests, divisionNoZeroButErrorFF) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 15, 315 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 15, 315 }); // Memory layout: [15,315,0,0,0,0,....] trace_builder.div(1, 0, 2, AvmMemoryTag::ff); // [15,315,21,0,0,0....] @@ -370,17 +370,17 @@ TEST_F(AvmMiniArithmeticNegativeTests, divisionNoZeroButErrorFF) trace[index].avmMini_op_err = FF(1); auto trace2 = trace; - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); // Even more malicious, one makes the first relation passes by setting the inverse to zero. trace2[index].avmMini_inv = FF(0); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace2)), "SUBOP_DIVISION_ZERO_ERR2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace2)), "SUBOP_DIVISION_ZERO_ERR2"); } // Test with division by zero occurs and no error is raised (remove error flag) TEST_F(AvmMiniArithmeticNegativeTests, divisionByZeroNoErrorFF) { - trace_builder.callDataCopy(0, 1, 0, std::vector{ 15 }); + trace_builder.call_data_copy(0, 1, 0, std::vector{ 15 }); // Memory layout: [15,0,0,0,0,0,....] trace_builder.div(0, 1, 2, AvmMemoryTag::ff); // [15,0,0,0,0,0....] @@ -393,7 +393,7 @@ TEST_F(AvmMiniArithmeticNegativeTests, divisionByZeroNoErrorFF) // Remove the operator error flag row->avmMini_op_err = FF(0); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_DIVISION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_FF"); } // Test with division of zero by zero occurs and no error is raised (remove error flag) @@ -409,18 +409,18 @@ TEST_F(AvmMiniArithmeticNegativeTests, divisionZeroByZeroNoErrorFF) // Remove the operator error flag row->avmMini_op_err = FF(0); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); } // Test that error flag cannot be raised for a non-relevant operation such as // the addition, subtraction, multiplication. TEST_F(AvmMiniArithmeticNegativeTests, operationWithErrorFlagFF) { - trace_builder.callDataCopy(0, 3, 0, std::vector{ 37, 4, 11 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 37, 4, 11 }); // Memory layout: [37,4,11,0,0,0,....] trace_builder.add(0, 1, 4, AvmMemoryTag::ff); // [37,4,11,0,41,0,....] - trace_builder.returnOP(0, 5); + trace_builder.return_op(0, 5); auto trace = trace_builder.finalize(); // Find the first row enabling the addition selector @@ -429,15 +429,15 @@ TEST_F(AvmMiniArithmeticNegativeTests, operationWithErrorFlagFF) // Activate the operator error row->avmMini_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); trace_builder.reset(); - trace_builder.callDataCopy(0, 3, 0, std::vector{ 8, 4, 17 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 8, 4, 17 }); // Memory layout: [8,4,17,0,0,0,....] trace_builder.sub(2, 0, 1, AvmMemoryTag::ff); // [8,9,17,0,0,0....] - trace_builder.returnOP(0, 3); + trace_builder.return_op(0, 3); trace = trace_builder.finalize(); // Find the first row enabling the subtraction selector @@ -446,15 +446,15 @@ TEST_F(AvmMiniArithmeticNegativeTests, operationWithErrorFlagFF) // Activate the operator error row->avmMini_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); trace_builder.reset(); - trace_builder.callDataCopy(0, 3, 0, std::vector{ 5, 0, 20 }); + trace_builder.call_data_copy(0, 3, 0, std::vector{ 5, 0, 20 }); // Memory layout: [5,0,20,0,0,0,....] trace_builder.mul(2, 0, 1, AvmMemoryTag::ff); // [5,100,20,0,0,0....] - trace_builder.returnOP(0, 3); + trace_builder.return_op(0, 3); trace = trace_builder.finalize(); // Find the first row enabling the multiplication selector @@ -463,7 +463,7 @@ TEST_F(AvmMiniArithmeticNegativeTests, operationWithErrorFlagFF) // Activate the operator error row->avmMini_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp index c771ad6eaf6..3580a4621d4 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -73,7 +73,7 @@ TEST_F(AvmMiniControlFlowTests, simpleCall) EXPECT_EQ(halt_row->avmMini_pc, FF(CALL_ADDRESS)); EXPECT_EQ(halt_row->avmMini_internal_return_ptr, FF(AvmMiniTraceBuilder::CALLSTACK_OFFSET + 1)); } - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } TEST_F(AvmMiniControlFlowTests, simpleJump) @@ -106,7 +106,7 @@ TEST_F(AvmMiniControlFlowTests, simpleJump) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avmMini_pc, FF(JUMP_ADDRESS)); } - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } TEST_F(AvmMiniControlFlowTests, simpleCallAndReturn) @@ -156,7 +156,7 @@ TEST_F(AvmMiniControlFlowTests, simpleCallAndReturn) EXPECT_EQ(halt_row->avmMini_pc, FF(RETURN_ADDRESS)); } - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) @@ -298,6 +298,6 @@ TEST_F(AvmMiniControlFlowTests, multipleCallsAndReturns) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avmMini_pc, FF(1)); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp index f1968f9f70f..6233c509c4c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp @@ -49,7 +49,7 @@ class AvmMiniMemoryTests : public ::testing::Test { // The proof must pass and we check that the AVM error is raised. TEST_F(AvmMiniMemoryTests, mismatchedTag) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 98, 12 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 98, 12 }); trace_builder.add(0, 1, 4, AvmMemoryTag::u8); trace_builder.halt(); @@ -89,14 +89,14 @@ TEST_F(AvmMiniMemoryTests, mismatchedTag) EXPECT_EQ(row->memTrace_m_in_tag, FF(static_cast(AvmMemoryTag::u8))); EXPECT_EQ(row->memTrace_m_tag, FF(static_cast(AvmMemoryTag::ff))); - validateTraceProof(std::move(trace)); + validate_trace_proof(std::move(trace)); } // Testing violation that m_lastAccess is a delimiter for two different addresses // in the memory trace TEST_F(AvmMiniMemoryTests, mLastAccessViolation) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 4, 9 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 4, 9 }); // Memory layout: [4,9,0,0,0,0,....] trace_builder.sub(1, 0, 2, AvmMemoryTag::u8); // [4,9,5,0,0,0.....] @@ -119,18 +119,18 @@ TEST_F(AvmMiniMemoryTests, mLastAccessViolation) row->memTrace_m_lastAccess = FF(0); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "MEM_LAST_ACCESS_DELIMITER"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_LAST_ACCESS_DELIMITER"); } // Testing violation that a memory read operation must read the same value which was // written into memory TEST_F(AvmMiniMemoryTests, readWriteConsistencyValViolation) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 4, 9 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 4, 9 }); // Memory layout: [4,9,0,0,0,0,....] trace_builder.mul(1, 0, 2, AvmMemoryTag::u8); // [4,9,36,0,0,0.....] - trace_builder.returnOP(2, 1); // Return single memory word at position 2 (36) + trace_builder.return_op(2, 1); // Return single memory word at position 2 (36) auto trace = trace_builder.finalize(); // Find the row with multiplication operation @@ -149,18 +149,18 @@ TEST_F(AvmMiniMemoryTests, readWriteConsistencyValViolation) row->memTrace_m_val = FF(35); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "MEM_READ_WRITE_VAL_CONSISTENCY"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_READ_WRITE_VAL_CONSISTENCY"); } // Testing violation that memory read operation must read the same tag which was // written into memory TEST_F(AvmMiniMemoryTests, readWriteConsistencyTagViolation) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 4, 9 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 4, 9 }); // Memory layout: [4,9,0,0,0,0,....] trace_builder.mul(1, 0, 2, AvmMemoryTag::u8); // [4,9,36,0,0,0.....] - trace_builder.returnOP(2, 1); // Return single memory word at position 2 (36) + trace_builder.return_op(2, 1); // Return single memory word at position 2 (36) auto trace = trace_builder.finalize(); // Find the row with multiplication operation @@ -179,25 +179,25 @@ TEST_F(AvmMiniMemoryTests, readWriteConsistencyTagViolation) row->memTrace_m_tag = static_cast(AvmMemoryTag::u16); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "MEM_READ_WRITE_TAG_CONSISTENCY"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_READ_WRITE_TAG_CONSISTENCY"); } // Testing violation that a memory read at uninitialized location must have value 0. TEST_F(AvmMiniMemoryTests, readUninitializedMemoryViolation) { - trace_builder.returnOP(1, 1); // Return single memory word at position 1 + trace_builder.return_op(1, 1); // Return single memory word at position 1 auto trace = trace_builder.finalize(); trace[1].memTrace_m_val = 9; - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "MEM_ZERO_INIT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_ZERO_INIT"); } // Testing violation that an operation with a mismatched memory tag // must raise a VM error. TEST_F(AvmMiniMemoryTests, mismatchedTagErrorViolation) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 98, 12 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 98, 12 }); trace_builder.sub(0, 1, 4, AvmMemoryTag::u8); trace_builder.halt(); @@ -219,19 +219,19 @@ TEST_F(AvmMiniMemoryTests, mismatchedTagErrorViolation) auto index = static_cast(row - trace.begin()); auto trace2 = trace; - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); // More sophisticated attempt by adapting witness "on_min_inv" to make pass the above constraint trace2[index].memTrace_m_one_min_inv = FF(1); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace2)), "MEM_IN_TAG_CONSISTENCY_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace2)), "MEM_IN_TAG_CONSISTENCY_2"); } // Testing violation that an operation with a consistent memory tag // must not set a VM error. TEST_F(AvmMiniMemoryTests, consistentTagNoErrorViolation) { - trace_builder.callDataCopy(0, 2, 0, std::vector{ 84, 7 }); + trace_builder.call_data_copy(0, 2, 0, std::vector{ 84, 7 }); trace_builder.div(0, 1, 4, AvmMemoryTag::ff); trace_builder.halt(); @@ -251,6 +251,6 @@ TEST_F(AvmMiniMemoryTests, consistentTagNoErrorViolation) row->memTrace_m_tag_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validateTraceProof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 90ec0d42bab..caed9cee5dd 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -13,7 +13,7 @@ using namespace proof_system; * * @param trace The execution trace */ -void validateTraceProof(std::vector&& trace) +void validate_trace_proof(std::vector&& trace) { auto circuit_builder = AvmMiniCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); @@ -40,7 +40,7 @@ void validateTraceProof(std::vector&& trace) * @param selectRow Lambda serving to select the row in trace * @param newValue The value that will be written in intermediate register Ic at the selected row. */ -void mutateIcInTrace(std::vector& trace, std::function&& selectRow, FF const& newValue) +void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, FF const& newValue) { // Find the first row matching the criteria defined by selectRow auto row = std::ranges::find_if(trace.begin(), trace.end(), selectRow); @@ -56,12 +56,12 @@ void mutateIcInTrace(std::vector& trace, std::function&& selectR auto const addr = row->avmMini_mem_idx_c; // Find the relevant memory trace entry. - auto memRow = std::ranges::find_if(trace.begin(), trace.end(), [clk, addr](Row r) { + auto mem_row = std::ranges::find_if(trace.begin(), trace.end(), [clk, addr](Row r) { return r.memTrace_m_clk == clk && r.memTrace_m_addr == addr; }); - EXPECT_TRUE(memRow != trace.end()); - memRow->memTrace_m_val = newValue; + EXPECT_TRUE(mem_row != trace.end()); + mem_row->memTrace_m_val = newValue; }; } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index 36732908f89..f14d87c454e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -13,7 +13,7 @@ namespace tests_avm { -void validateTraceProof(std::vector&& trace); -void mutateIcInTrace(std::vector& trace, std::function&& selectRow, FF const& newValue); +void validate_trace_proof(std::vector&& trace); +void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, FF const& newValue); } // namespace tests_avm \ No newline at end of file From 052b240dc678b0a14cb0717550aa5dd18436b6ea Mon Sep 17 00:00:00 2001 From: jeanmon Date: Fri, 5 Jan 2024 09:15:54 +0000 Subject: [PATCH 5/7] 3834 - Address some review feedback on missing documentation --- .../circuit_builder/AvmMini_mem_trace.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp index 735ab6ac272..7fe984d5f41 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp @@ -22,8 +22,13 @@ void AvmMiniMemTraceBuilder::reset() } /** - * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. + * @brief A comparator on MemoryTraceEntry to be used by sorting algorithm. We sort first by + * ascending address (m_addr), then by clock (m_clk) and finally sub-clock (m_sub_clk). * + * @param left The left hand side memory trace entry + * @param right The right hand side memory trace entry + * + * @return A boolean indicating whether left member is smaller than right member. */ bool AvmMiniMemTraceBuilder::compare_mem_entries(const MemoryTraceEntry& left, const MemoryTraceEntry& right) { @@ -130,6 +135,9 @@ void AvmMiniMemTraceBuilder::load_mismatch_tag_in_mem_trace(uint32_t const m_clk * @param addr The memory address * @param val The value to be loaded * @param m_in_tag The memory tag of the instruction + * + * @return A boolean indicating that memory tag matches (resp. does not match) the + * instruction tag. Set to false in case of a mismatch. */ bool AvmMiniMemTraceBuilder::load_in_mem_trace( uint32_t clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag) @@ -196,6 +204,7 @@ void AvmMiniMemTraceBuilder::store_in_mem_trace( * @param interm_reg Intermediate register where we load the value * @param addr Memory address to be read and loaded * @param m_in_tag Memory instruction tag + * * @return Result of the read operation containing the value and a boolean telling * potential mismatch between instruction tag and memory tag of the address. */ From 6e03ab70223053332bdbeb0dd087daf14efd7416 Mon Sep 17 00:00:00 2001 From: jeanmon Date: Fri, 5 Jan 2024 09:41:54 +0000 Subject: [PATCH 6/7] Remove superfluous import of header files --- .../src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp | 8 +------- .../barretenberg/vm/tests/AvmMini_control_flow.test.cpp | 7 +------ .../cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp | 8 +------- 3 files changed, 3 insertions(+), 20 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp index 0115edc4277..2bd7b37f5f9 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp @@ -1,9 +1,4 @@ -#include "barretenberg/ecc/curves/bn254/fr.hpp" -#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" -#include "barretenberg/numeric/uint256/uint256.hpp" #include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" -#include "barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp" -#include "barretenberg/sumcheck/sumcheck_round.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" @@ -15,9 +10,8 @@ #include #include -using namespace proof_system; - namespace tests_avm { +using namespace proof_system; class AvmMiniArithmeticTests : public ::testing::Test { public: diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp index 3580a4621d4..b14d018a96c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -1,8 +1,4 @@ -#include "barretenberg/ecc/curves/bn254/fr.hpp" -#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" -#include "barretenberg/numeric/uint256/uint256.hpp" #include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" -#include "barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" @@ -14,9 +10,8 @@ #include #include -using namespace proof_system; - namespace tests_avm { +using namespace proof_system; class AvmMiniControlFlowTests : public ::testing::Test { public: diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp index 6233c509c4c..ce7cfdd7559 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp @@ -1,9 +1,4 @@ -#include "barretenberg/ecc/curves/bn254/fr.hpp" -#include "barretenberg/flavor/generated/AvmMini_flavor.hpp" -#include "barretenberg/numeric/uint256/uint256.hpp" #include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" -#include "barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp" -#include "barretenberg/sumcheck/sumcheck_round.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" @@ -15,9 +10,8 @@ #include #include -using namespace proof_system; - namespace tests_avm { +using namespace proof_system; class AvmMiniMemoryTests : public ::testing::Test { public: From a673e044888f6ff8a255e2373cf23f9cbd687bb4 Mon Sep 17 00:00:00 2001 From: jeanmon Date: Fri, 5 Jan 2024 10:01:09 +0000 Subject: [PATCH 7/7] 3834 - Moving trace building related files for avm into vm folder and introducing new namespace --- .../circuit_builder => vm/avm_trace}/AvmMini_common.hpp | 4 ++-- .../circuit_builder => vm/avm_trace}/AvmMini_helper.cpp | 4 ++-- .../circuit_builder => vm/avm_trace}/AvmMini_helper.hpp | 4 ++-- .../avm_trace}/AvmMini_mem_trace.cpp | 4 ++-- .../avm_trace}/AvmMini_mem_trace.hpp | 4 ++-- .../circuit_builder => vm/avm_trace}/AvmMini_trace.cpp | 4 ++-- .../circuit_builder => vm/avm_trace}/AvmMini_trace.hpp | 4 ++-- .../src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp | 4 ++-- .../barretenberg/vm/tests/AvmMini_control_flow.test.cpp | 4 ++-- .../cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp | 4 ++-- .../cpp/src/barretenberg/vm/tests/helpers.test.cpp | 8 ++++---- .../cpp/src/barretenberg/vm/tests/helpers.test.hpp | 2 +- 12 files changed, 25 insertions(+), 25 deletions(-) rename barretenberg/cpp/src/barretenberg/{proof_system/circuit_builder => vm/avm_trace}/AvmMini_common.hpp (91%) rename barretenberg/cpp/src/barretenberg/{proof_system/circuit_builder => vm/avm_trace}/AvmMini_helper.cpp (98%) rename barretenberg/cpp/src/barretenberg/{proof_system/circuit_builder => vm/avm_trace}/AvmMini_helper.hpp (70%) rename barretenberg/cpp/src/barretenberg/{proof_system/circuit_builder => vm/avm_trace}/AvmMini_mem_trace.cpp (99%) rename barretenberg/cpp/src/barretenberg/{proof_system/circuit_builder => vm/avm_trace}/AvmMini_mem_trace.hpp (97%) rename barretenberg/cpp/src/barretenberg/{proof_system/circuit_builder => vm/avm_trace}/AvmMini_trace.cpp (99%) rename barretenberg/cpp/src/barretenberg/{proof_system/circuit_builder => vm/avm_trace}/AvmMini_trace.hpp (97%) diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_common.hpp similarity index 91% rename from barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp rename to barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_common.hpp index 50679598d05..b925d5e01c2 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_common.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_common.hpp @@ -7,11 +7,11 @@ using Flavor = proof_system::honk::flavor::AvmMiniFlavor; using FF = Flavor::FF; using Row = proof_system::AvmMiniFullRow; -namespace proof_system { +namespace avm_trace { // Number of rows static const size_t AVM_TRACE_SIZE = 256; enum class IntermRegister : uint32_t { ia = 0, ib = 1, ic = 2 }; enum class AvmMemoryTag : uint32_t { u0 = 0, u8 = 1, u16 = 2, u32 = 3, u64 = 4, u128 = 5, ff = 6 }; -} // namespace proof_system \ No newline at end of file +} // namespace avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_helper.cpp similarity index 98% rename from barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp rename to barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_helper.cpp index 38c2a1cce73..207485ac63d 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_helper.cpp @@ -1,6 +1,6 @@ #include "AvmMini_helper.hpp" -namespace proof_system { +namespace avm_trace { /** * @brief Routine to log some slice of a trace of the AVM. Used to debug or in some unit tests. @@ -65,4 +65,4 @@ void log_avmMini_trace(std::vector const& trace, size_t beg, size_t end) } } -} // namespace proof_system \ No newline at end of file +} // namespace avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_helper.hpp similarity index 70% rename from barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp rename to barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_helper.hpp index a2a8ba922a6..eda2b5c89a6 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_helper.hpp @@ -2,8 +2,8 @@ #include "AvmMini_common.hpp" -namespace proof_system { +namespace avm_trace { void log_avmMini_trace(std::vector const& trace, size_t beg, size_t end); -} // namespace proof_system \ No newline at end of file +} // namespace avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_mem_trace.cpp similarity index 99% rename from barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp rename to barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_mem_trace.cpp index 7fe984d5f41..f55d7e9d8b6 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_mem_trace.cpp @@ -1,6 +1,6 @@ #include "AvmMini_mem_trace.hpp" -namespace proof_system { +namespace avm_trace { /** * @brief Constructor of a memory trace builder of AVM. Only serves to set the capacity of the @@ -241,4 +241,4 @@ void AvmMiniMemTraceBuilder::write_into_memory( store_in_mem_trace(clk, interm_reg, addr, val, m_in_tag); } -} // namespace proof_system \ No newline at end of file +} // namespace avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_mem_trace.hpp similarity index 97% rename from barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp rename to barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_mem_trace.hpp index 121d5ca9f6e..6a06dcee1fb 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_mem_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_mem_trace.hpp @@ -2,7 +2,7 @@ #include "AvmMini_common.hpp" -namespace proof_system { +namespace avm_trace { class AvmMiniMemTraceBuilder { @@ -65,4 +65,4 @@ class AvmMiniMemTraceBuilder { void store_in_mem_trace( uint32_t clk, IntermRegister interm_reg, uint32_t addr, FF const& val, AvmMemoryTag m_in_tag); }; -} // namespace proof_system \ No newline at end of file +} // namespace avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_trace.cpp similarity index 99% rename from barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp rename to barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_trace.cpp index de402554c34..c38a615560f 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_trace.cpp @@ -10,7 +10,7 @@ #include "AvmMini_trace.hpp" -namespace proof_system { +namespace avm_trace { /** * @brief Constructor of a trace builder of AVM. Only serves to set the capacity of the @@ -594,4 +594,4 @@ std::vector AvmMiniTraceBuilder::finalize() return trace; } -} // namespace proof_system \ No newline at end of file +} // namespace avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_trace.hpp similarity index 97% rename from barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp rename to barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_trace.hpp index 555274d5595..ef8e51b65bf 100644 --- a/barretenberg/cpp/src/barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/AvmMini_trace.hpp @@ -8,7 +8,7 @@ #include "barretenberg/relations/generated/AvmMini/avm_mini.hpp" -namespace proof_system { +namespace avm_trace { // This is the internal context that we keep along the lifecycle of bytecode execution // to iteratively build the whole trace. This is effectively performing witness generation. @@ -68,4 +68,4 @@ class AvmMiniTraceBuilder { uint32_t internal_return_ptr = CALLSTACK_OFFSET; std::stack internal_call_stack = {}; }; -} // namespace proof_system +} // namespace avm_trace diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp index 2bd7b37f5f9..c8f61b2dc59 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_arithmetic.test.cpp @@ -1,4 +1,4 @@ -#include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" +#include "barretenberg/vm/avm_trace/AvmMini_helper.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" @@ -11,7 +11,7 @@ #include namespace tests_avm { -using namespace proof_system; +using namespace avm_trace; class AvmMiniArithmeticTests : public ::testing::Test { public: diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp index b14d018a96c..36673853057 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_control_flow.test.cpp @@ -1,4 +1,4 @@ -#include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" +#include "barretenberg/vm/avm_trace/AvmMini_helper.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" @@ -11,7 +11,7 @@ #include namespace tests_avm { -using namespace proof_system; +using namespace avm_trace; class AvmMiniControlFlowTests : public ::testing::Test { public: diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp index ce7cfdd7559..e3798357e15 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/AvmMini_memory.test.cpp @@ -1,4 +1,4 @@ -#include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" +#include "barretenberg/vm/avm_trace/AvmMini_helper.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" @@ -11,7 +11,7 @@ #include namespace tests_avm { -using namespace proof_system; +using namespace avm_trace; class AvmMiniMemoryTests : public ::testing::Test { public: diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index caed9cee5dd..2a761b69a47 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,12 +1,12 @@ #include "helpers.test.hpp" -#include "barretenberg/proof_system/circuit_builder/AvmMini_helper.hpp" +#include "barretenberg/vm/avm_trace/AvmMini_helper.hpp" #include "barretenberg/vm/generated/AvmMini_composer.hpp" #include "barretenberg/vm/generated/AvmMini_prover.hpp" #include "barretenberg/vm/generated/AvmMini_verifier.hpp" #include namespace tests_avm { -using namespace proof_system; +using namespace avm_trace; /** * @brief Helper routine proving and verifying a proof based on the supplied trace @@ -15,12 +15,12 @@ using namespace proof_system; */ void validate_trace_proof(std::vector&& trace) { - auto circuit_builder = AvmMiniCircuitBuilder(); + auto circuit_builder = proof_system::AvmMiniCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); EXPECT_TRUE(circuit_builder.check_circuit()); - auto composer = honk::AvmMiniComposer(); + auto composer = proof_system::honk::AvmMiniComposer(); auto prover = composer.create_prover(circuit_builder); auto proof = prover.construct_proof(); diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index f14d87c454e..145eb171457 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -1,6 +1,6 @@ #pragma once -#include "barretenberg/proof_system/circuit_builder/AvmMini_trace.hpp" +#include "barretenberg/vm/avm_trace/AvmMini_trace.hpp" #define EXPECT_THROW_WITH_MESSAGE(code, expectedMessage) \ try { \