Memory relocation

src/cairo_runner.c

@@ -1,22 +1,35 @@
 #include "cairo_runner.h"
+#include "collectc/cc_common.h"
+#include "collectc/cc_hashtable.h"
 #include "memory.h"
 #include "program.h"
 #include "relocatable.h"
 #include "vm.h"
+#include <assert.h>
 #include <collectc/cc_array.h>
+#include <stdio.h>
+#include <stdlib.h>
 
 cairo_runner runner_new(struct program program) {
 	virtual_machine vm = vm_new();
-	cairo_runner runner = {program, vm, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}};
+	CC_Array *relocated_memory;
+	cc_array_new(&relocated_memory);
+	CC_Array *relocation_table;
+	cc_array_new(&relocation_table);
+	cairo_runner runner = {program, vm, relocated_memory, relocation_table, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}};
 	return runner;
 }
 
 void runner_free(cairo_runner *runner) {
 	memory_free(&runner->vm.memory);
 	program_free(&runner->program);
+	cc_array_remove_all_free(runner->relocated_memory);
+	cc_array_destroy(runner->relocated_memory);
+	cc_array_remove_all_free(runner->relocation_table);
+	cc_array_destroy(runner->relocation_table);
 }
 
-// Creates program, execution and builtin segments
+// Creates program, execution and builtin segments.
 void runner_initialize_segments(cairo_runner *runner) {
 	// Program Segment
 	runner->program_base = memory_add_segment(&runner->vm.memory);
@@ -77,10 +90,110 @@ void runner_initialize_vm(cairo_runner *runner) {
 	// Apply validation rules to memory
 }
 
+void runner_get_segment_sizes(cairo_runner *runner, CC_Array *segment_sizes) {
+	int num_segments = runner->vm.memory.num_segments;
+	unsigned int *zero;
+	for (int i = 0; i < num_segments; i++) {
+		zero = malloc(sizeof(unsigned int));
+		*zero = 0;
+		cc_array_add(segment_sizes, zero);
+	}
+
+	unsigned int *new_size;
+	CC_HashTableIter memory_iter;
+	cc_hashtable_iter_init(&memory_iter, runner->vm.memory.data);
+	TableEntry *entry;
+	while (cc_hashtable_iter_next(&memory_iter, &entry) != CC_ITER_END) {
+		relocatable *ptr = entry->key;
+		unsigned int *segment_size;
+		assert(cc_array_get_at(segment_sizes, ptr->segment_index, (void **)&segment_size) == CC_OK);
+
+		if (*segment_size < ptr->offset + 1) {
+			new_size = malloc(sizeof(unsigned int));
+			*new_size = ptr->offset + 1;
+			cc_array_replace_at(segment_sizes, new_size, ptr->segment_index, NULL);
+		}
+	}
+}
+
+// Fills relocation table with the first relocated address of each memory segment
+// Warning: Can fail if runner_initialize_main_entrypoint is not called before
+void runner_fill_relocation_table(cairo_runner *runner, CC_Array *segment_sizes) {
+	int *first_addr = malloc(sizeof(int));
+	*first_addr = 1;
+	cc_array_add(runner->relocation_table, first_addr);
+	int *last_segment_size_added;
+	assert(cc_array_get_at(runner->relocation_table, 0, (void **)&last_segment_size_added) == CC_OK);
+
+	int relocation_table_size = runner->vm.memory.num_segments + 1;
+	for (int i = 1; i < relocation_table_size; i++) {
+		int segment_idx = i - 1;
+		int *segment_size;
+		assert(cc_array_get_at(segment_sizes, segment_idx, (void **)&segment_size) == CC_OK);
+		int *address = malloc(sizeof(int));
+		*address = *last_segment_size_added + *segment_size;
+		cc_array_add(runner->relocation_table, address);
+		assert(cc_array_get_at(runner->relocation_table, i, (void **)&last_segment_size_added) == CC_OK);
+	}
+}
+
 relocatable runner_initialize(cairo_runner *runner) {
 	// runner_initialize_builtins
 	runner_initialize_segments(runner);
 	relocatable end = runner_initialize_main_entrypoint(runner);
 	runner_initialize_vm(runner);
 	return end;
 }
+
+int runner_get_relocated_address(cairo_runner *runner, relocatable *relocatable) {
+	int *address;
+	assert(cc_array_get_at(runner->relocation_table, relocatable->segment_index, (void **)&address) == CC_OK);
+	return *address + relocatable->offset;
+}
+
+void runner_get_relocated_value(cairo_runner *runner, maybe_relocatable *value, felt_t out) {
+	if (value->is_felt) {
+		zero(out);
+		add(out, value->value.felt, out);
+	} else {
+		int out_number = runner_get_relocated_address(runner, &value->value.relocatable);
+		from(out, out_number);
+	}
+}
+
+void runner_relocate_memory(cairo_runner *runner) {
+	assert(cc_array_size(runner->relocated_memory) == 0);
+	relocated_memory_cell *first_cell = malloc(sizeof(relocated_memory_cell));
+	first_cell->is_some = false;
+	first_cell->memory_value.none = 0;
+	cc_array_add(runner->relocated_memory, first_cell);
+
+	CC_Array *segment_sizes;
+	cc_array_new(&segment_sizes);
+	runner_get_segment_sizes(runner, segment_sizes);
+	runner_fill_relocation_table(runner, segment_sizes);
+
+	int num_segment_sizes = cc_array_size(segment_sizes);
+
+	for (int i = 0; i < num_segment_sizes; i++) {
+		int *segment_size;
+		assert(cc_array_get_at(segment_sizes, i, (void **)&segment_size) == CC_OK);
+
+		for (int j = 0; j < *segment_size; j++) {
+			relocatable ptr = {i, j};
+			maybe_relocatable *cell;
+			if (cc_hashtable_get(runner->vm.memory.data, &ptr, (void **)&cell) == CC_OK) {
+				int relocated_addr = runner_get_relocated_address(runner, &ptr);
+				relocated_memory_cell *relocated_value = malloc(sizeof(relocated_memory_cell));
+				relocated_value->is_some = true;
+				runner_get_relocated_value(runner, cell, relocated_value->memory_value.value);
+				cc_array_add_at(runner->relocated_memory, relocated_value, relocated_addr);
+			} else {
+				relocated_memory_cell *none = malloc(sizeof(relocated_memory_cell));
+				none->is_some = false;
+				none->memory_value.none = 0;
+				cc_array_add(runner->relocated_memory, none);
+			}
+		}
+	}
+}

src/cairo_runner.h

@@ -1,13 +1,26 @@
 #ifndef RUNNER_H
 #define RUNNER_H
 
+#include "collectc/cc_array.h"
 #include "program.h"
 #include "relocatable.h"
 #include "vm.h"
 
+typedef union relocated_memory_value {
+	felt_t value;
+	int none;
+} relocated_memory_value;
+
+typedef struct relocated_memory_cell {
+	relocated_memory_value memory_value;
+	bool is_some;
+} relocated_memory_cell;
+
 typedef struct cairo_runner {
 	struct program program;
 	virtual_machine vm;
+	CC_Array *relocated_memory;
+	CC_Array *relocation_table;
 	relocatable program_base;
 	relocatable execution_base;
 	relocatable initial_pc;
@@ -25,4 +38,6 @@ void runner_free(cairo_runner *runner);
 // Performs the intialization step, leaving the runner ready to run a loaded cairo program from a main entrypoint
 relocatable runner_initialize(cairo_runner *runner);
 
+void runner_relocate_memory(cairo_runner *runner);
+
 #endif

test/runner_tests.c

@@ -1,7 +1,10 @@
 #include "runner_tests.h"
-
+#include "cairo_runner.h"
+#include "collectc/cc_array.h"
+#include "collectc/cc_common.h"
 #include "memory.h"
 #include "program.h"
+#include "relocatable.h"
 #include "run_context.h"
 #include "utils.h"
 #include "vm.h"
@@ -101,11 +104,105 @@ void initialize_runner_no_builtins_no_proof_mode_empty_program(void) {
 	printf("OK!\n");
 }
 
+void relocate_runner_memory(void) {
+	CC_Array *program_data;
+	cc_array_new(&program_data);
+	struct program program = {0, program_data};
+	cairo_runner runner = runner_new(program);
+	runner_initialize(&runner);
+
+	relocatable ptr_0_0 = {0, 0};
+	relocatable ptr_0_1 = {0, 1};
+	relocatable ptr_0_2 = {0, 2};
+	relocatable ptr_1_0 = {1, 0};
+	relocatable ptr_1_1 = {1, 1};
+	relocatable ptr_1_5 = {1, 5};
+	felt_t value_0_0;
+	felt_t value_0_1;
+	felt_t value_0_2;
+	relocatable value_1_0 = {2, 0};
+	relocatable value_1_1 = {3, 0};
+	felt_t value_1_5;
+	from(value_0_0, 4613515612218425347);
+	from(value_0_1, 5);
+	from(value_0_2, 2345108766317314046);
+	from(value_1_5, 5);
+	maybe_relocatable elem_0_0 = maybe_relocatable_from_felt_limbs(value_0_0);
+	maybe_relocatable elem_0_1 = maybe_relocatable_from_felt_limbs(value_0_1);
+	maybe_relocatable elem_0_2 = maybe_relocatable_from_felt_limbs(value_0_2);
+	maybe_relocatable elem_1_0 = {.value = {.relocatable = value_1_0}, .is_felt = false};
+	maybe_relocatable elem_1_1 = {.value = {.relocatable = value_1_1}, .is_felt = false};
+	maybe_relocatable elem_1_5 = maybe_relocatable_from_felt_limbs(value_1_5);
+	memory_insert(&runner.vm.memory, ptr_0_0, elem_0_0);
+	memory_insert(&runner.vm.memory, ptr_0_1, elem_0_1);
+	memory_insert(&runner.vm.memory, ptr_0_2, elem_0_2);
+	memory_insert(&runner.vm.memory, ptr_1_0, elem_1_0);
+	memory_insert(&runner.vm.memory, ptr_1_1, elem_1_1);
+	memory_insert(&runner.vm.memory, ptr_1_5, elem_1_5);
+
+	runner_relocate_memory(&runner);
+
+	relocated_memory_cell *relocated_memory_0 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 0, (void **)&relocated_memory_0) == CC_OK);
+	assert(!relocated_memory_0->is_some);
+	relocated_memory_cell *relocated_memory_1 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 1, (void **)&relocated_memory_1) == CC_OK);
+	felt_t expected_1;
+	from(expected_1, 4613515612218425347);
+	assert(relocated_memory_1->is_some);
+	assert(felt_equal(relocated_memory_1->memory_value.value, expected_1));
+	relocated_memory_cell *relocated_memory_2 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 2, (void **)&relocated_memory_2) == CC_OK);
+	felt_t expected_2;
+	from(expected_2, 5);
+	assert(relocated_memory_2->is_some);
+	assert(felt_equal(relocated_memory_2->memory_value.value, expected_2));
+	relocated_memory_cell *relocated_memory_3 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 3, (void **)&relocated_memory_3) == CC_OK);
+	felt_t expected_3;
+	from(expected_3, 2345108766317314046);
+	assert(relocated_memory_3->is_some);
+	assert(felt_equal(relocated_memory_3->memory_value.value, expected_3));
+	relocated_memory_cell *relocated_memory_4 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 4, (void **)&relocated_memory_4) == CC_OK);
+	felt_t expected_4;
+	from(expected_4, 10);
+	assert(relocated_memory_4->is_some);
+	assert(felt_equal(relocated_memory_4->memory_value.value, expected_4));
+	relocated_memory_cell *relocated_memory_5 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 5, (void **)&relocated_memory_5) == CC_OK);
+	felt_t expected_5;
+	from(expected_5, 10);
+	assert(relocated_memory_5->is_some);
+	assert(felt_equal(relocated_memory_5->memory_value.value, expected_5));
+	relocated_memory_cell *relocated_memory_6 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 6, (void **)&relocated_memory_6) == CC_OK);
+	assert(!relocated_memory_6->is_some);
+	relocated_memory_cell *relocated_memory_7 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 7, (void **)&relocated_memory_7) == CC_OK);
+	assert(!relocated_memory_7->is_some);
+	relocated_memory_cell *relocated_memory_8 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 8, (void **)&relocated_memory_8) == CC_OK);
+	assert(!relocated_memory_8->is_some);
+	relocated_memory_cell *relocated_memory_9 = NULL;
+	assert(cc_array_get_at(runner.relocated_memory, 9, (void **)&relocated_memory_9) == CC_OK);
+	felt_t expected_9;
+	from(expected_9, 5);
+	assert(relocated_memory_9->is_some);
+	assert(felt_equal(relocated_memory_9->memory_value.value, expected_9));
+
+	runner_free(&runner);
+	printf("OK!\n");
+}
+
 void runner_tests(void) {
 	printf("--------------------------------- \n");
 	printf("Test: initialize_runner_no_builtins_no_proof_mode_empty_program \n");
 	initialize_runner_no_builtins_no_proof_mode_empty_program();
 	printf("--------------------------------- \n");
 	printf("Test: initialize_runner_no_builtins_no_proof_mode_non_empty_program \n");
 	initialize_runner_no_builtins_no_proof_mode_non_empty_program();
+	printf("--------------------------------- \n");
+	printf("Test: relocate_runner_memory \n");
+	relocate_runner_memory();
 }