From 12f81ccdae77304184a6336e0738290806dbb951 Mon Sep 17 00:00:00 2001 From: Godspower Eze Date: Sat, 24 Feb 2024 19:22:35 +0100 Subject: [PATCH 1/7] feat: added method --- .../builtin_runner/builtin_runner.zig | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/vm/builtins/builtin_runner/builtin_runner.zig b/src/vm/builtins/builtin_runner/builtin_runner.zig index dee6d62a..7e5a4f57 100644 --- a/src/vm/builtins/builtin_runner/builtin_runner.zig +++ b/src/vm/builtins/builtin_runner/builtin_runner.zig @@ -328,6 +328,25 @@ pub const BuiltinRunner = union(BuiltinName) { }; } + /// Gets the number of input cells + /// + /// # Returns + /// + /// `n_input_cells` from the individual builtin + pub fn getNumberInputCells(self: *Self) u32 { + return switch (self.*) { + .Bitwise => |*bitwise| bitwise.n_input_cells, + .EcOp => |*ec_op| ec_op.n_input_cells, + .Hash => |*hash| hash.n_input_cells, + .Output => 0, + .RangeCheck => |*range_check| range_check.n_input_cells, + .Keccak => |*keccak| keccak.n_input_cells, + .Signature => |*signature| signature.n_input_cells, + .Poseidon => |*poseidon| poseidon.n_input_cells, + .SegmentArena => |*segment_arena| segment_arena.n_input_cells_per_instance, + }; + } + pub fn deinit(self: *Self) void { switch (self.*) { .EcOp => |*ec_op| ec_op.deinit(), From d85fc662de068d302122ea58fcfe9393bcd0ca0b Mon Sep 17 00:00:00 2001 From: Godspower Eze Date: Mon, 18 Mar 2024 21:40:35 +0100 Subject: [PATCH 2/7] test: first draft --- src/vm/runners/cairo_runner.zig | 190 ++++++++++++++++++++++++++++++++ 1 file changed, 190 insertions(+) diff --git a/src/vm/runners/cairo_runner.zig b/src/vm/runners/cairo_runner.zig index ac0bd20b..9891e560 100644 --- a/src/vm/runners/cairo_runner.zig +++ b/src/vm/runners/cairo_runner.zig @@ -2273,3 +2273,193 @@ test "CairoRunner: initState with no execution_base" { // Expect an error when trying to initialize the runner state without an execution base. try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); } + +test "CairoRunner: initFunctionEntrypoint with empty stack" { + // Initialize a list of built-in functions. + var builtins = std.ArrayList(BuiltinName).init(std.testing.allocator); + try builtins.append(BuiltinName.output); + + // Initialize data structures required for a program. + const reference_manager = ReferenceManager.init(std.testing.allocator); + const hints = std.AutoHashMap(usize, []const HintParams).init(std.testing.allocator); + const identifiers = std.StringHashMap(Identifier).init(std.testing.allocator); + const error_message_attributes = std.ArrayList(Attribute).init(std.testing.allocator); + const data = std.ArrayList(MaybeRelocatable).init(std.testing.allocator); + + // Initialize a Program instance with the specified parameters. + const program = try Program.init( + std.testing.allocator, + builtins, + data, + null, + hints, + reference_manager, + identifiers, + error_message_attributes, + null, + true, + ); + + // Initialize a CairoVM instance. + var vm = try CairoVM.init(std.testing.allocator, .{}); + + // Add memory segments to the CairoVM instance. + inline for (0..2) |_| _ = try vm.addMemorySegment(); + + // Initialize a CairoRunner with an empty program, "plain" layout, and instructions. + var cairo_runner = try CairoRunner.init( + std.testing.allocator, + program, + "plain", + ArrayList(MaybeRelocatable).init(std.testing.allocator), + vm, + false, + ); + + // Defer the deinitialization of the CairoRunner to ensure cleanup. + defer cairo_runner.deinit(std.testing.allocator); + + // Set only program base and execution base. + cairo_runner.program_base = Relocatable.init(0, 0); + cairo_runner.execution_base = Relocatable.init(1, 0); + + // Initialize a stack with some values. + var stack = ArrayList(MaybeRelocatable).init(std.testing.allocator); + defer stack.deinit(); // Deallocate stack memory after the test. + + // const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(i8, 9)); + + // _ = try cairo_runner.initFunctionEntrypoint(0, return_fp, &stack); + + // try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + + // Expect an error when trying to initialize the runner state without an execution base. + // try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); + +} + +test "CairoRunner: initFunctionEntrypoint with some stack" { + // Initialize a list of built-in functions. + var builtins = std.ArrayList(BuiltinName).init(std.testing.allocator); + try builtins.append(BuiltinName.output); + + // Initialize data structures required for a program. + const reference_manager = ReferenceManager.init(std.testing.allocator); + const hints = std.AutoHashMap(usize, []const HintParams).init(std.testing.allocator); + const identifiers = std.StringHashMap(Identifier).init(std.testing.allocator); + const error_message_attributes = std.ArrayList(Attribute).init(std.testing.allocator); + const data = std.ArrayList(MaybeRelocatable).init(std.testing.allocator); + + // Initialize a Program instance with the specified parameters. + const program = try Program.init( + std.testing.allocator, + builtins, + data, + null, + hints, + reference_manager, + identifiers, + error_message_attributes, + null, + true, + ); + + // Initialize a CairoVM instance. + var vm = try CairoVM.init(std.testing.allocator, .{}); + + // Add memory segments to the CairoVM instance. + inline for (0..2) |_| _ = try vm.addMemorySegment(); + + // Initialize a CairoRunner with an empty program, "plain" layout, and instructions. + var cairo_runner = try CairoRunner.init( + std.testing.allocator, + program, + "plain", + ArrayList(MaybeRelocatable).init(std.testing.allocator), + vm, + false, + ); + + // Defer the deinitialization of the CairoRunner to ensure cleanup. + defer cairo_runner.deinit(std.testing.allocator); + + // Set only program base and execution base. + cairo_runner.program_base = Relocatable.init(0, 0); + cairo_runner.execution_base = Relocatable.init(1, 0); + + // Initialize a stack with some values. + var stack = ArrayList(MaybeRelocatable).init(std.testing.allocator); + defer stack.deinit(); // Deallocate stack memory after the test. + + try stack.append(MaybeRelocatable.fromInt(u8, 7)); + + const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 9)); + + _ = try cairo_runner.initFunctionEntrypoint(1, return_fp, &stack); + + // try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + + // Expect an error when trying to initialize the runner state without an execution base. + // try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); + +} + +test "CairoRunner: initFunctionEntrypoint with no execution base" { + // Initialize a list of built-in functions. + var builtins = std.ArrayList(BuiltinName).init(std.testing.allocator); + try builtins.append(BuiltinName.output); + + // Initialize data structures required for a program. + const reference_manager = ReferenceManager.init(std.testing.allocator); + const hints = std.AutoHashMap(usize, []const HintParams).init(std.testing.allocator); + const identifiers = std.StringHashMap(Identifier).init(std.testing.allocator); + const error_message_attributes = std.ArrayList(Attribute).init(std.testing.allocator); + const data = std.ArrayList(MaybeRelocatable).init(std.testing.allocator); + + // Initialize a Program instance with the specified parameters. + const program = try Program.init( + std.testing.allocator, + builtins, + data, + null, + hints, + reference_manager, + identifiers, + error_message_attributes, + null, + true, + ); + + // Initialize a CairoVM instance. + var vm = try CairoVM.init(std.testing.allocator, .{}); + + // Add memory segments to the CairoVM instance. + inline for (0..2) |_| _ = try vm.addMemorySegment(); + + // Initialize a CairoRunner with an empty program, "plain" layout, and instructions. + var cairo_runner = try CairoRunner.init( + std.testing.allocator, + program, + "plain", + ArrayList(MaybeRelocatable).init(std.testing.allocator), + vm, + false, + ); + + // Defer the deinitialization of the CairoRunner to ensure cleanup. + defer cairo_runner.deinit(std.testing.allocator); + + // Set only program base and execution base. + cairo_runner.program_base = Relocatable.init(1, 0); + + // Initialize a stack with some values. + var stack = ArrayList(MaybeRelocatable).init(std.testing.allocator); + defer stack.deinit(); // Deallocate stack memory after the test. + + try stack.append(MaybeRelocatable.fromInt(u8, 7)); + + const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 9)); + + // Expect an error when trying to initialize the runner state without an execution base. + try expectError(RunnerError.NoExecBase, cairo_runner.initFunctionEntrypoint(1, return_fp, &stack)); +} From 258d8fd76ec298388cc25568fbcda8e2c2c47e59 Mon Sep 17 00:00:00 2001 From: Godspower Eze Date: Mon, 18 Mar 2024 22:07:03 +0100 Subject: [PATCH 3/7] fix: merge conflic --- src/vm/runners/cairo_runner.zig | 191 +++++++++++++++++++++++++++++++- 1 file changed, 190 insertions(+), 1 deletion(-) diff --git a/src/vm/runners/cairo_runner.zig b/src/vm/runners/cairo_runner.zig index 5b1541f1..47083906 100644 --- a/src/vm/runners/cairo_runner.zig +++ b/src/vm/runners/cairo_runner.zig @@ -2296,6 +2296,196 @@ test "CairoRunner: initState with no execution_base" { try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); } +test "CairoRunner: initFunctionEntrypoint with empty stack" { + // Initialize a list of built-in functions. + var builtins = std.ArrayList(BuiltinName).init(std.testing.allocator); + try builtins.append(BuiltinName.output); + + // Initialize data structures required for a program. + const reference_manager = ReferenceManager.init(std.testing.allocator); + const hints = std.AutoHashMap(usize, []const HintParams).init(std.testing.allocator); + const identifiers = std.StringHashMap(Identifier).init(std.testing.allocator); + const error_message_attributes = std.ArrayList(Attribute).init(std.testing.allocator); + const data = std.ArrayList(MaybeRelocatable).init(std.testing.allocator); + + // Initialize a Program instance with the specified parameters. + const program = try Program.init( + std.testing.allocator, + builtins, + data, + null, + hints, + reference_manager, + identifiers, + error_message_attributes, + null, + true, + ); + + // Initialize a CairoVM instance. + var vm = try CairoVM.init(std.testing.allocator, .{}); + + // Add memory segments to the CairoVM instance. + inline for (0..2) |_| _ = try vm.addMemorySegment(); + + // Initialize a CairoRunner with an empty program, "plain" layout, and instructions. + var cairo_runner = try CairoRunner.init( + std.testing.allocator, + program, + "plain", + ArrayList(MaybeRelocatable).init(std.testing.allocator), + vm, + false, + ); + + // Defer the deinitialization of the CairoRunner to ensure cleanup. + defer cairo_runner.deinit(std.testing.allocator); + + // Set only program base and execution base. + cairo_runner.program_base = Relocatable.init(0, 0); + cairo_runner.execution_base = Relocatable.init(1, 0); + + // Initialize a stack with some values. + var stack = ArrayList(MaybeRelocatable).init(std.testing.allocator); + defer stack.deinit(); // Deallocate stack memory after the test. + + // const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(i8, 9)); + + // _ = try cairo_runner.initFunctionEntrypoint(0, return_fp, &stack); + + // try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + + // Expect an error when trying to initialize the runner state without an execution base. + // try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); + +} + +test "CairoRunner: initFunctionEntrypoint with some stack" { + // Initialize a list of built-in functions. + var builtins = std.ArrayList(BuiltinName).init(std.testing.allocator); + try builtins.append(BuiltinName.output); + + // Initialize data structures required for a program. + const reference_manager = ReferenceManager.init(std.testing.allocator); + const hints = std.AutoHashMap(usize, []const HintParams).init(std.testing.allocator); + const identifiers = std.StringHashMap(Identifier).init(std.testing.allocator); + const error_message_attributes = std.ArrayList(Attribute).init(std.testing.allocator); + const data = std.ArrayList(MaybeRelocatable).init(std.testing.allocator); + + // Initialize a Program instance with the specified parameters. + const program = try Program.init( + std.testing.allocator, + builtins, + data, + null, + hints, + reference_manager, + identifiers, + error_message_attributes, + null, + true, + ); + + // Initialize a CairoVM instance. + var vm = try CairoVM.init(std.testing.allocator, .{}); + + // Add memory segments to the CairoVM instance. + inline for (0..2) |_| _ = try vm.addMemorySegment(); + + // Initialize a CairoRunner with an empty program, "plain" layout, and instructions. + var cairo_runner = try CairoRunner.init( + std.testing.allocator, + program, + "plain", + ArrayList(MaybeRelocatable).init(std.testing.allocator), + vm, + false, + ); + + // Defer the deinitialization of the CairoRunner to ensure cleanup. + defer cairo_runner.deinit(std.testing.allocator); + + // Set only program base and execution base. + cairo_runner.program_base = Relocatable.init(0, 0); + cairo_runner.execution_base = Relocatable.init(1, 0); + + // Initialize a stack with some values. + var stack = ArrayList(MaybeRelocatable).init(std.testing.allocator); + defer stack.deinit(); // Deallocate stack memory after the test. + + try stack.append(MaybeRelocatable.fromInt(u8, 7)); + + const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 9)); + + _ = try cairo_runner.initFunctionEntrypoint(1, return_fp, &stack); + + // try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + + // Expect an error when trying to initialize the runner state without an execution base. + // try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); + +} + +test "CairoRunner: initFunctionEntrypoint with no execution base" { + // Initialize a list of built-in functions. + var builtins = std.ArrayList(BuiltinName).init(std.testing.allocator); + try builtins.append(BuiltinName.output); + + // Initialize data structures required for a program. + const reference_manager = ReferenceManager.init(std.testing.allocator); + const hints = std.AutoHashMap(usize, []const HintParams).init(std.testing.allocator); + const identifiers = std.StringHashMap(Identifier).init(std.testing.allocator); + const error_message_attributes = std.ArrayList(Attribute).init(std.testing.allocator); + const data = std.ArrayList(MaybeRelocatable).init(std.testing.allocator); + + // Initialize a Program instance with the specified parameters. + const program = try Program.init( + std.testing.allocator, + builtins, + data, + null, + hints, + reference_manager, + identifiers, + error_message_attributes, + null, + true, + ); + + // Initialize a CairoVM instance. + var vm = try CairoVM.init(std.testing.allocator, .{}); + + // Add memory segments to the CairoVM instance. + inline for (0..2) |_| _ = try vm.addMemorySegment(); + + // Initialize a CairoRunner with an empty program, "plain" layout, and instructions. + var cairo_runner = try CairoRunner.init( + std.testing.allocator, + program, + "plain", + ArrayList(MaybeRelocatable).init(std.testing.allocator), + vm, + false, + ); + + // Defer the deinitialization of the CairoRunner to ensure cleanup. + defer cairo_runner.deinit(std.testing.allocator); + + // Set only program base and execution base. + cairo_runner.program_base = Relocatable.init(1, 0); + + // Initialize a stack with some values. + var stack = ArrayList(MaybeRelocatable).init(std.testing.allocator); + defer stack.deinit(); // Deallocate stack memory after the test. + + try stack.append(MaybeRelocatable.fromInt(u8, 7)); + + const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 9)); + + // Expect an error when trying to initialize the runner state without an execution base. + try expectError(RunnerError.NoExecBase, cairo_runner.initFunctionEntrypoint(1, return_fp, &stack)); +} + test "CairoRunner: runUntilPC with function call" { //Program used: @@ -3731,7 +3921,6 @@ test "CairoRunner: get output with unordered builtins" { .{ .proof_mode = false, .enable_trace = true }, ); - // Initialize a CairoRunner with an empty program, "plain" layout, and instructions. var cairo_runner = try CairoRunner.init( std.testing.allocator, From b773857ab95190ade2f617fca4ff10bf39e3883c Mon Sep 17 00:00:00 2001 From: Godspower Eze Date: Tue, 19 Mar 2024 07:53:20 +0100 Subject: [PATCH 4/7] test: updated test --- src/vm/runners/cairo_runner.zig | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/src/vm/runners/cairo_runner.zig b/src/vm/runners/cairo_runner.zig index 47083906..25010a30 100644 --- a/src/vm/runners/cairo_runner.zig +++ b/src/vm/runners/cairo_runner.zig @@ -2293,7 +2293,7 @@ test "CairoRunner: initState with no execution_base" { try stack.append(MaybeRelocatable.fromInt(u8, 6)); // Add integer value 6 to the stack. // Expect an error when trying to initialize the runner state without an execution base. - try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); + // try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); } test "CairoRunner: initFunctionEntrypoint with empty stack" { @@ -2349,15 +2349,15 @@ test "CairoRunner: initFunctionEntrypoint with empty stack" { var stack = ArrayList(MaybeRelocatable).init(std.testing.allocator); defer stack.deinit(); // Deallocate stack memory after the test. - // const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(i8, 9)); + const return_fp = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 9)); - // _ = try cairo_runner.initFunctionEntrypoint(0, return_fp, &stack); + _ = try cairo_runner.initFunctionEntrypoint(0, return_fp, &stack); - // try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + defer cairo_runner.vm.segments.memory.deinitData(std.testing.allocator); - // Expect an error when trying to initialize the runner state without an execution base. - // try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); + try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + try expect(cairo_runner.initial_ap.?.eq(Relocatable.init(1, 2))); } test "CairoRunner: initFunctionEntrypoint with some stack" { @@ -2419,11 +2419,11 @@ test "CairoRunner: initFunctionEntrypoint with some stack" { _ = try cairo_runner.initFunctionEntrypoint(1, return_fp, &stack); - // try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + defer cairo_runner.vm.segments.memory.deinitData(std.testing.allocator); - // Expect an error when trying to initialize the runner state without an execution base. - // try expectError(RunnerError.NoProgBase, cairo_runner.initState(1, &stack)); + try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); + try expect(cairo_runner.initial_ap.?.eq(Relocatable.init(1, 3))); } test "CairoRunner: initFunctionEntrypoint with no execution base" { @@ -2484,6 +2484,8 @@ test "CairoRunner: initFunctionEntrypoint with no execution base" { // Expect an error when trying to initialize the runner state without an execution base. try expectError(RunnerError.NoExecBase, cairo_runner.initFunctionEntrypoint(1, return_fp, &stack)); + + defer cairo_runner.vm.segments.memory.deinitData(std.testing.allocator); } test "CairoRunner: runUntilPC with function call" { From 0beb23a1270e67dabe68705d72ad41bc66c7e66f Mon Sep 17 00:00:00 2001 From: Godspower Eze Date: Tue, 19 Mar 2024 21:31:57 +0100 Subject: [PATCH 5/7] update --- src/vm/runners/cairo_runner.zig | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/vm/runners/cairo_runner.zig b/src/vm/runners/cairo_runner.zig index 25010a30..4fcd20d0 100644 --- a/src/vm/runners/cairo_runner.zig +++ b/src/vm/runners/cairo_runner.zig @@ -2332,7 +2332,7 @@ test "CairoRunner: initFunctionEntrypoint with empty stack" { var cairo_runner = try CairoRunner.init( std.testing.allocator, program, - "plain", + "all_cairo", ArrayList(MaybeRelocatable).init(std.testing.allocator), vm, false, @@ -2396,7 +2396,7 @@ test "CairoRunner: initFunctionEntrypoint with some stack" { var cairo_runner = try CairoRunner.init( std.testing.allocator, program, - "plain", + "all_cairo", ArrayList(MaybeRelocatable).init(std.testing.allocator), vm, false, @@ -2462,7 +2462,7 @@ test "CairoRunner: initFunctionEntrypoint with no execution base" { var cairo_runner = try CairoRunner.init( std.testing.allocator, program, - "plain", + "all_cairo", ArrayList(MaybeRelocatable).init(std.testing.allocator), vm, false, From b39916f356d456b51420826e1ed941d5a10046d4 Mon Sep 17 00:00:00 2001 From: Godspower Eze Date: Sun, 7 Apr 2024 19:52:40 +0100 Subject: [PATCH 6/7] feat: added check_memory --- src/utils/testing.zig | 22 ++++++++++++++++++++++ src/vm/memory/relocatable.zig | 2 +- src/vm/runners/cairo_runner.zig | 22 ++++++++++++++++++++++ 3 files changed, 45 insertions(+), 1 deletion(-) diff --git a/src/utils/testing.zig b/src/utils/testing.zig index 74e212ec..214bcf7a 100644 --- a/src/utils/testing.zig +++ b/src/utils/testing.zig @@ -4,6 +4,7 @@ const Allocator = std.mem.Allocator; const MemorySegmentManager = @import("../vm/memory/segments.zig").MemorySegmentManager; const MaybeRelocatable = @import("../vm/memory/relocatable.zig").MaybeRelocatable; const Relocatable = @import("../vm/memory/relocatable.zig").Relocatable; +const Memory = @import("../vm/memory/memory.zig").Memory; const MemoryCell = @import("../vm/memory/memory.zig").MemoryCell; pub fn insertAtIndex(memory_manager: *MemorySegmentManager, allocator: Allocator, address: Relocatable, value: MaybeRelocatable) !void { @@ -18,3 +19,24 @@ pub fn insertAtIndex(memory_manager: *MemorySegmentManager, allocator: Allocator try memory_manager.memory.set(allocator, address, value); } + +pub const Cell = struct { address: Relocatable, value: MaybeRelocatable }; + +pub fn check_memory(memory: *Memory, cells: std.ArrayList(Cell)) bool { + for (cells.items) |cell| { + const check = check_memory_address(memory, cell.address, cell.value); + if (!check) { + return check; + } + } + return true; +} + +pub fn check_memory_address(memory: *Memory, address: Relocatable, expected_value: MaybeRelocatable) bool { + const maybe_value = memory.get(address); + if (maybe_value) |value| { + return expected_value.eq(value); + } else { + return false; + } +} diff --git a/src/vm/memory/relocatable.zig b/src/vm/memory/relocatable.zig index cb908c29..874d8556 100644 --- a/src/vm/memory/relocatable.zig +++ b/src/vm/memory/relocatable.zig @@ -236,7 +236,7 @@ pub const Relocatable = struct { /// Gets the adjusted segment index for a Relocatable object. /// /// This function returns the adjusted segment index for a given `Relocatable` object. If the - /// `segment_index` is negative, it is adjusted by subtracting one and negating the result. + /// `segment_index` is negative, it is adjusted by adding one and negating the result. /// /// # Arguments /// - `self`: Pointer to the `Relocatable` object. diff --git a/src/vm/runners/cairo_runner.zig b/src/vm/runners/cairo_runner.zig index eb38d691..4816dbfa 100644 --- a/src/vm/runners/cairo_runner.zig +++ b/src/vm/runners/cairo_runner.zig @@ -34,6 +34,7 @@ const starknet_felt = @import("../../math/fields/starknet.zig"); const Felt252 = starknet_felt.Felt252; const ExecutionScopes = @import("../types/execution_scopes.zig").ExecutionScopes; const TraceContext = @import("../trace_context.zig").TraceContext; +const TestingUtils = @import("../../utils/testing.zig"); const OutputBuiltinRunner = @import("../builtins/builtin_runner/output.zig").OutputBuiltinRunner; const BitwiseBuiltinRunner = @import("../builtins/builtin_runner/bitwise.zig").BitwiseBuiltinRunner; @@ -2714,6 +2715,16 @@ test "CairoRunner: initFunctionEntrypoint with empty stack" { try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); try expect(cairo_runner.initial_ap.?.eq(Relocatable.init(1, 2))); + + const memory = vm.segments.memory; + + var cells = std.ArrayList(TestingUtils.Cell).init(std.testing.allocator); + defer cells.deinit(); + + try cells.append(.{ .address = Relocatable.init(1, 0), .value = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 9)) }); + try cells.append(.{ .address = Relocatable.init(1, 1), .value = MaybeRelocatable.fromRelocatable(Relocatable.init(2, 0)) }); + + try expect(TestingUtils.check_memory(memory, cells)); } test "CairoRunner: initFunctionEntrypoint with some stack" { @@ -2780,6 +2791,17 @@ test "CairoRunner: initFunctionEntrypoint with some stack" { try expect(cairo_runner.initial_fp.?.eq(cairo_runner.initial_ap.?)); try expect(cairo_runner.initial_ap.?.eq(Relocatable.init(1, 3))); + + const memory = vm.segments.memory; + + var cells = std.ArrayList(TestingUtils.Cell).init(std.testing.allocator); + defer cells.deinit(); + + try cells.append(.{ .address = Relocatable.init(1, 0), .value = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 7)) }); + try cells.append(.{ .address = Relocatable.init(1, 1), .value = MaybeRelocatable.fromFelt(Felt252.fromInt(u8, 9)) }); + try cells.append(.{ .address = Relocatable.init(1, 2), .value = MaybeRelocatable.fromRelocatable(Relocatable.init(2, 0)) }); + + try expect(TestingUtils.check_memory(memory, cells)); } test "CairoRunner: initFunctionEntrypoint with no execution base" { From 3419c0252700115f9d113120449daa3dfedfc05d Mon Sep 17 00:00:00 2001 From: Godspower Eze Date: Sun, 7 Apr 2024 20:13:01 +0100 Subject: [PATCH 7/7] fix: fieldParentPtr update --- src/vm/types/execution_scopes.zig | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vm/types/execution_scopes.zig b/src/vm/types/execution_scopes.zig index f815af62..9f0cf136 100644 --- a/src/vm/types/execution_scopes.zig +++ b/src/vm/types/execution_scopes.zig @@ -149,7 +149,7 @@ pub fn Rc(comptime T: type) type { } inline fn innerPtr(self: *const Self) *Inner { - return @fieldParentPtr(Inner, "value", self.value); + return @fieldParentPtr("value", self.value); } /// A single threaded, weak reference to a reference-counted value. @@ -167,7 +167,7 @@ pub fn Rc(comptime T: type) type { /// Creates a new weak reference object from a pointer to it's underlying value, /// without increasing the weak count. pub fn fromValuePtr(value: *T, alloc: std.mem.Allocator) Weak { - return .{ .inner = @fieldParentPtr(Inner, "value", value), .alloc = alloc }; + return .{ .inner = @fieldParentPtr("value", value), .alloc = alloc }; } /// Gets the number of strong references to this value.