Migrate memory data structure in AVM circuit to unordered map

barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.cpp

@@ -21,7 +21,7 @@ AvmMemTraceBuilder::AvmMemTraceBuilder()
 void AvmMemTraceBuilder::reset()
 {
     mem_trace.clear();
-    memory.fill(FF(0));
+    memory.clear();
 }
 
 /**
@@ -133,7 +133,10 @@ void AvmMemTraceBuilder::load_mismatch_tag_in_mem_trace(uint32_t const m_clk,
 bool AvmMemTraceBuilder::load_from_mem_trace(
     uint32_t clk, uint32_t sub_clk, uint32_t addr, FF const& val, AvmMemoryTag r_in_tag, AvmMemoryTag w_in_tag)
 {
-    auto m_tag = memory_tag.at(addr);
+    AvmMemoryTag m_tag = AvmMemoryTag::U0;
+    if (memory.contains(addr)) {
+        m_tag = memory.at(addr).tag;
+    }
     if (m_tag == AvmMemoryTag::U0 || m_tag == r_in_tag) {
         insert_in_mem_trace(clk, sub_clk, addr, val, r_in_tag, r_in_tag, w_in_tag, false);
         return true;
@@ -187,23 +190,26 @@ void AvmMemTraceBuilder::store_in_mem_trace(
  * @return Result of the read operation containing the value and the tag of the memory cell
  *         at the supplied address.
  */
-std::pair<FF, AvmMemoryTag> AvmMemTraceBuilder::read_and_load_mov_opcode(uint32_t const clk, uint32_t const addr)
+AvmMemTraceBuilder::MemEntry AvmMemTraceBuilder::read_and_load_mov_opcode(uint32_t const clk, uint32_t const addr)
 {
-    FF const& val = memory.at(addr);
-    AvmMemoryTag m_tag = memory_tag.at(addr);
+    MemEntry memEntry;
+
+    if (memory.contains(addr)) {
+        memEntry = memory.at(addr);
+    }
 
     mem_trace.emplace_back(MemoryTraceEntry{
         .m_clk = clk,
         .m_sub_clk = SUB_CLK_LOAD_A,
         .m_addr = addr,
-        .m_val = val,
-        .m_tag = m_tag,
-        .r_in_tag = m_tag,
-        .w_in_tag = m_tag,
+        .m_val = memEntry.val,
+        .m_tag = memEntry.tag,
+        .r_in_tag = memEntry.tag,
+        .w_in_tag = memEntry.tag,
         .m_sel_mov = true,
     });
 
-    return std::make_pair(val, m_tag);
+    return memEntry;
 }
 
 /**
@@ -239,7 +245,12 @@ AvmMemTraceBuilder::MemRead AvmMemTraceBuilder::read_and_load_from_memory(uint32
         break;
     }
 
-    FF val = memory.at(addr);
+    FF val = 0;
+
+    if (memory.contains(addr)) {
+        val = memory.at(addr).val;
+    }
+
     bool tagMatch = load_from_mem_trace(clk, sub_clk, addr, val, r_in_tag, w_in_tag);
 
     return MemRead{
@@ -265,7 +276,10 @@ AvmMemTraceBuilder::MemRead AvmMemTraceBuilder::indirect_read_and_load_from_memo
         break;
     }
 
-    FF val = memory.at(addr);
+    FF val = 0;
+    if (memory.contains(addr)) {
+        val = memory.at(addr).val;
+    }
     bool tagMatch = load_from_mem_trace(clk, sub_clk, addr, val, AvmMemoryTag::U32, AvmMemoryTag::U0);
 
     return MemRead{
@@ -293,8 +307,13 @@ void AvmMemTraceBuilder::write_into_memory(uint32_t const clk,
                                            AvmMemoryTag r_in_tag,
                                            AvmMemoryTag w_in_tag)
 {
-    memory.at(addr) = val;
-    memory_tag.at(addr) = w_in_tag;
+    MemEntry memEntry{ val, w_in_tag };
+    auto it = memory.find(addr);
+    if (it != memory.end()) {
+        it->second = memEntry;
+    } else {
+        memory.emplace(addr, memEntry);
+    }
     store_in_mem_trace(clk, interm_reg, addr, val, r_in_tag, w_in_tag);
 }
 

barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_mem_trace.hpp

@@ -65,6 +65,12 @@ class AvmMemTraceBuilder {
         }
     };
 
+    // Structure representing an entry for the memory used in the simulation (not the trace).
+    struct MemEntry {
+        FF val{};
+        AvmMemoryTag tag = AvmMemoryTag::U0;
+    };
+
     // Structure to return value and tag matching boolean after a memory read.
     struct MemRead {
         bool tag_match = false;
@@ -77,7 +83,7 @@ class AvmMemTraceBuilder {
 
     std::vector<MemoryTraceEntry> finalize();
 
-    std::pair<FF, AvmMemoryTag> read_and_load_mov_opcode(uint32_t clk, uint32_t addr);
+    MemEntry read_and_load_mov_opcode(uint32_t clk, uint32_t addr);
     MemRead read_and_load_from_memory(
         uint32_t clk, IntermRegister interm_reg, uint32_t addr, AvmMemoryTag r_in_tag, AvmMemoryTag w_in_tag);
     MemRead indirect_read_and_load_from_memory(uint32_t clk, IndirectRegister ind_reg, uint32_t addr);
@@ -89,10 +95,8 @@ class AvmMemTraceBuilder {
                            AvmMemoryTag w_in_tag);
 
   private:
-    std::vector<MemoryTraceEntry> mem_trace;         // Entries will be sorted by m_clk, m_sub_clk after finalize().
-    std::array<FF, MEM_SIZE> memory{};               // Memory table (used for simulation)
-    std::array<AvmMemoryTag, MEM_SIZE> memory_tag{}; // The tag of the corresponding memory
-                                                     // entry (aligned with the memory array).
+    std::vector<MemoryTraceEntry> mem_trace;       // Entries will be sorted by m_clk, m_sub_clk after finalize().
+    std::unordered_map<uint32_t, MemEntry> memory; // Memory table (used for simulation)
 
     void insert_in_mem_trace(uint32_t m_clk,
                              uint32_t m_sub_clk,

barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp

@@ -353,6 +353,7 @@ TEST_F(AvmArithmeticTestsFF, subtraction)
     EXPECT_EQ(alu_row.avm_alu_cf, FF(0));
     EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0));
 
+    avm_trace::log_avm_trace(trace, 0, 10);
     validate_trace_proof(std::move(trace));
 }
 

barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp

@@ -171,6 +171,29 @@ TEST_F(AvmMemOpcodeTests, sameAddressMov)
     validate_trace(false, 11, 356, 356, AvmMemoryTag::U16);
 }
 
+TEST_F(AvmMemOpcodeTests, unitializedValueMov)
+{
+    auto trace_builder = AvmTraceBuilder();
+    trace_builder.set(4, 1, AvmMemoryTag::U32);
+    trace_builder.op_mov(0, 0, 1);
+    trace_builder.return_op(0, 0, 0);
+    trace = trace_builder.finalize();
+
+    validate_trace(false, 0, 0, 1, AvmMemoryTag::U0);
+}
+
+TEST_F(AvmMemOpcodeTests, indUnitializedValueMov)
+{
+    auto trace_builder = AvmTraceBuilder();
+    trace_builder.set(1, 3, AvmMemoryTag::U32);
+    trace_builder.set(4, 1, AvmMemoryTag::U32);
+    trace_builder.op_mov(3, 2, 3);
+    trace_builder.return_op(0, 0, 0);
+    trace = trace_builder.finalize();
+
+    validate_trace(true, 0, 2, 3, AvmMemoryTag::U0, 0, 1);
+}
+
 TEST_F(AvmMemOpcodeTests, indirectMov)
 {
     buildTrace(true, 23, 0, 1, AvmMemoryTag::U8, 2, 3);