Migrate to deepmem (#3)

Author: MMZK1526

include/deep_loader.h

@@ -25,6 +25,9 @@
 #define SECTION_TYPE_CODE 10
 #define SECTION_TYPE_DATA 11
 
+//内存模块实现
+#define PAGESIZE 65536
+
 //
 //type item
 typedef struct DEEPType

include/deep_mem.h

@@ -0,0 +1,96 @@
+#ifndef _DEEP_MEM_ALLOC_H
+#define _DEEP_MEM_ALLOC_H
+
+#include <stdbool.h>
+
+#define FAST_BIN_LENGTH (8) /* eight size options for fast bins */
+#define FAST_BIN_MAX_SIZE (64) /* 8 * 8 bytes */
+#define SORTED_BIN_MIN_SIZE (FAST_BIN_MAX_SIZE + 8) /* 64 + 8 bytes */
+
+#define A_FLAG_OFFSET (0) /* is allocated */
+#define A_FLAG_MASK (1 << A_FLAG_OFFSET)
+#define P_FLAG_OFFSET (1) /* is previous block allocated */
+#define P_FLAG_MASK (1 << P_FLAG_OFFSET)
+#define BLOCK_SIZE_MASK (0xFFFFFFFF - A_FLAG_MASK - P_FLAG_MASK)
+#define REMAINDER_SIZE_MASK ((0xffffffff << 32) & BLOCK_SIZE_MASK)
+
+#define SORTED_BLOCK_INDICES_LEVEL (13)
+
+/* Align the size up to a multiple of eight*/
+#define ALIGN_MEM_SIZE(size) (((size + 0x7) >> 3) << 3)
+/* Align the size down to a multiple of eight */
+#define ALIGN_MEM_SIZE_TRUNC(size) ((size >> 3) << 3)
+
+typedef void *mem_t;
+typedef uint64_t mem_size_t;
+typedef uint32_t block_head_t;
+typedef uint32_t block_size_t;
+
+/* For storing small blocks of memory */
+typedef struct fast_block
+{
+  block_head_t head;
+  union
+  {
+    struct fast_block *next;
+    void *payload;
+  } payload;
+} fast_block_t;
+
+typedef struct sorted_block
+{
+  block_head_t head;
+  union
+  {
+    struct
+    {
+      int32_t pred_offset;
+      int32_t succ_offset;
+      uint32_t level_of_indices;
+      // bigger array index corresponds to lower index in skip list,
+      // i.e., skipping less nodes in the skip list
+      // 0 means this node is the last one in this level of index.
+      // offsets[SORTED_BLOCK_INDICES_LEVEL - 1] is the level where each node
+      // is connected one by one consecutively.
+      // The skip list is in ascending order by block's size.
+      int32_t offsets[SORTED_BLOCK_INDICES_LEVEL];
+      // padding
+      // uint32_t footer;
+    } info;
+    void *payload;
+  } payload;
+} sorted_block_t;
+
+typedef struct mem_pool
+{
+  uint64_t free_memory;
+  union
+  {
+    uint64_t _padding;
+    sorted_block_t *addr;
+  } sorted_block;
+  union
+  {
+    uint64_t _remainder_block_head_padding;
+    block_head_t *remainder_block_head; /* The head of remainder */
+  };
+  union
+  {
+    uint64_t _remainder_block_end_padding;
+    void *remainder_block_end; /* The address of the last byte in remainder */
+  }; /* should not be dereferenced */
+  union
+  {
+    uint64_t _padding;
+    fast_block_t *addr;
+  } fast_bins[FAST_BIN_LENGTH];
+} mem_pool_t;
+
+bool deep_mem_init (void *mem, uint32_t size);
+void deep_mem_destroy (void);
+void *deep_malloc (uint32_t size);
+void *deep_realloc (void *ptr, uint32_t size);
+void deep_free (void *ptr);
+bool deep_mem_migrate (void *new_mem, uint32_t size);
+
+#endif /* _DEEP_MEM_ALLOC_H */

include/random.h

@@ -0,0 +1,19 @@
+#ifndef _VM_INCLUDE_RANDOM_H
+#define _VM_INCLUDE_RANDOM_H
+
+#include <stdint.h>
+
+uint64_t next (void);
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^64 calls to next(); it can be used to generate 2^64
+   non-overlapping subsequences for parallel computations. */
+void jump (void);
+
+/* This is the long-jump function for the generator. It is equivalent to
+   2^96 calls to next(); it can be used to generate 2^32 starting points,
+   from each of which jump() will generate 2^32 non-overlapping
+   subsequences for parallel distributed computations. */
+void long_jump (void);
+
+#endif /* _VM_INCLUDE_RANDOM_H */

src/deep_interp.c

@@ -8,6 +8,7 @@
 #include <string.h>
 #include "deep_interp.h"
 #include "deep_loader.h"
+#include "deep_mem.h"
 #include "deep_opcode.h"
 
 #define popS32() (int32_t)*(--sp)
@@ -26,13 +27,13 @@
 
 //创建操作数栈
 DEEPStack *stack_cons(void) {
-    DEEPStack *stack = (DEEPStack *) malloc(sizeof(DEEPStack));
+    DEEPStack *stack = (DEEPStack *) deep_malloc(sizeof(DEEPStack));
     if (stack == NULL) {
         printf("Operand stack creation failed!\r\n");
         return NULL;
     }
     stack->capacity = STACK_CAPACITY;
-    stack->sp = (uint32_t *) malloc(sizeof(uint32_t) * STACK_CAPACITY);
+    stack->sp = (uint32_t *) deep_malloc(sizeof(uint32_t) * STACK_CAPACITY);
     if (stack->sp == NULL) {
         printf("Malloc area for stack error!\r\n");
     }
@@ -42,8 +43,8 @@ DEEPStack *stack_cons(void) {
 
 //销毁操作数栈
 void stack_free(DEEPStack *stack) {
-    free(stack->sp);
-    free(stack);
+    deep_free(stack->sp);
+    deep_free(stack);
 }
 
 //执行代码块指令
@@ -289,7 +290,7 @@ void call_function(DEEPExecEnv *current_env, DEEPModule *module, int func_index)
     uint32_t ret_num = deepType->ret_count;
 
 //    current_env->sp-=param_num;//操作数栈指针下移
-    current_env->local_vars = (uint32_t *) malloc(sizeof(uint32_t) * param_num);
+    current_env->local_vars = (uint32_t *) deep_malloc(sizeof(uint32_t) * param_num);
     uint32_t vars_temp = param_num;
     while (vars_temp > 0) {
         uint32_t temp = *(--current_env->sp);
@@ -300,7 +301,7 @@ void call_function(DEEPExecEnv *current_env, DEEPModule *module, int func_index)
     LocalVars **locals = func->localvars;
 
     //为func函数创建帧
-    DEEPInterpFrame *frame = (DEEPInterpFrame *) malloc(sizeof(DEEPInterpFrame));
+    DEEPInterpFrame *frame = (DEEPInterpFrame *) deep_malloc(sizeof(DEEPInterpFrame));
     if (frame == NULL) {
         printf("Malloc area for normal_frame error!\r\n");
     }
@@ -319,8 +320,8 @@ void call_function(DEEPExecEnv *current_env, DEEPModule *module, int func_index)
     //执行完毕退栈
     current_env->cur_frame = frame->prev_frame;
     //释放掉局部变量
-    free(current_env->local_vars);
-    free(frame);
+    deep_free(current_env->local_vars);
+    deep_free(frame);
     return;
 }
 
@@ -345,7 +346,7 @@ int32_t call_main(DEEPExecEnv *current_env, DEEPModule *module) {
     DEEPFunction *main_func = module->func_section[main_index];//module.start_index记录了main函数索引
 
     //为main函数创建帧
-    DEEPInterpFrame *main_frame = (DEEPInterpFrame *) malloc(sizeof(struct DEEPInterpFrame));
+    DEEPInterpFrame *main_frame = (DEEPInterpFrame *) deep_malloc(sizeof(struct DEEPInterpFrame));
     if (main_frame == NULL) {
         printf("Malloc area for main_frame error!\r\n");
     }
@@ -359,8 +360,8 @@ int32_t call_main(DEEPExecEnv *current_env, DEEPModule *module) {
     //执行frame中函数
     //sp要下移，栈顶元素即为函数参数
     exec_instructions(current_env, module);
-    free(main_frame);
+    deep_free(main_frame);
 
     //返回栈顶元素
     return *(current_env->sp - 1);
-}
+}

src/deep_loader.c

@@ -11,6 +11,7 @@
 #include <stdint.h>
 #include "deep_loader.h"
 #include "deep_log.h"
+#include "deep_mem.h"
 
 //read a value of specified type
 #define READ_VALUE(Type, p) \
@@ -59,7 +60,7 @@ static bool check_magic_number_and_version(uint8_t** p) {
 }
 
 static char* str_gen(const char* p, int32_t len) {
-	char* str = (char*)malloc((len + 1) * sizeof(char));
+	char* str = (char*)deep_malloc((len + 1) * sizeof(char));
 	memcpy(str, p, len);
 	str[len] = '\0';
 	return str;
@@ -71,8 +72,7 @@ static section_listnode* create_section_list(const uint8_t** p, int32_t size) {
 	section_listnode* section_list = NULL;
 	section_listnode* current_section = NULL;
 	while (buf < buf_end) {
-		section_listnode* section = (section_listnode*)malloc(sizeof(section_listnode));
-		memset(section, 0, sizeof(section_listnode));
+		section_listnode* section = (section_listnode*)deep_malloc(sizeof(section_listnode));
 		if (section_list == NULL) {
 			section_list = section;
 			current_section = section;
@@ -96,7 +96,7 @@ static void decode_type_section(const uint8_t* p, DEEPModule* module) {
 	uint32_t         total_size = 0;
 	uint32_t         type_count = 0, param_count = 0, ret_count = 0;
 	module->type_count = type_count = read_leb_u32((uint8_t**)&p);
-	module->type_section            = (DEEPType**)malloc(type_count * sizeof(DEEPType*));
+	module->type_section            = (DEEPType**)deep_malloc(type_count * sizeof(DEEPType*));
 	for (int32_t i = 0; i < type_count; i++) {
 		if (READ_BYTE(p) == 0x60) {
 			param_count = read_leb_u32((uint8_t**)&p);
@@ -106,7 +106,7 @@ static void decode_type_section(const uint8_t* p, DEEPModule* module) {
 			p          = p_tmp;
 			total_size = 8 + param_count + ret_count;
 
-			module->type_section[i]             = (DEEPType*)malloc(total_size);
+			module->type_section[i]             = (DEEPType*)deep_malloc(total_size);
 			module->type_section[i]->param_count  = param_count;
 			module->type_section[i]->ret_count = ret_count;
 
@@ -131,11 +131,10 @@ static void decode_func_section(const uint8_t* p, DEEPModule* module,const uint8
 	const uint8_t*   p_code_temp;
 	if (func_count == code_func_count) {
 		module->function_count = func_count;
-		module->func_section   = (DEEPFunction**)malloc(func_count * sizeof(DEEPFunction*));
+		module->func_section   = (DEEPFunction**)deep_malloc(func_count * sizeof(DEEPFunction*));
 
 		for (uint32_t i = 0; i < func_count; i++) {
-			func = module->func_section[i] = (DEEPFunction*)malloc(sizeof(DEEPFunction));
-			memset(func, 0, sizeof(DEEPFunction));
+			func = module->func_section[i] = (DEEPFunction*)deep_malloc(sizeof(DEEPFunction));
 			type_index  = read_leb_u32((uint8_t**)&p);
 			code_size   = read_leb_u32((uint8_t**)&p_code);
 			p_code_temp = p_code;
@@ -145,9 +144,9 @@ static void decode_func_section(const uint8_t* p, DEEPModule* module,const uint8
 			if (local_set_count == 0) {
 				func->localvars = NULL;
 			} else {
-				func->localvars = (LocalVars**)malloc(local_set_count * sizeof(LocalVars*));
+				func->localvars = (LocalVars**)deep_malloc(local_set_count * sizeof(LocalVars*));
 				for (uint32_t j = 0; j < local_set_count; j++) {
-					local_set = func->localvars[j] = (LocalVars*)malloc(sizeof(LocalVars));
+					local_set = func->localvars[j] = (LocalVars*)deep_malloc(sizeof(LocalVars));
 					local_set->count                 = read_leb_u32((uint8_t**)&p_code);
 					local_set->local_type          = READ_BYTE(p_code);
 				}
@@ -164,10 +163,10 @@ static void decode_export_section(const uint8_t* p, DEEPModule* module) {
 	uint32_t name_len;
 	DEEPExport* Export;
 	module->export_count = export_count;
-	module->export_section = (DEEPExport**)malloc(export_count * sizeof(DEEPExport*));
+	module->export_section = (DEEPExport**)deep_malloc(export_count * sizeof(DEEPExport*));
 
 	for (uint32_t i = 0; i < export_count; i ++) {
-		Export = module->export_section[i] = (DEEPExport*)malloc(sizeof(DEEPExport));
+		Export = module->export_section[i] = (DEEPExport*)deep_malloc(sizeof(DEEPExport));
 		name_len = read_leb_u32((uint8_t**)&p);
 		Export->name = str_gen(p, name_len);
 		p += name_len;
@@ -181,10 +180,10 @@ static void decode_data_section(const uint8_t* p, DEEPModule* module) {
 	uint32_t data_count = read_leb_u32((uint8_t**)&p);
 	DEEPData* Data;
 	module->data_count = data_count;
-	module->data_section = (DEEPData**)malloc(data_count * sizeof(DEEPData*));
+	module->data_section = (DEEPData**)deep_malloc(data_count * sizeof(DEEPData*));
 
 	for (uint32_t i = 0; i < data_count; i ++) {
-		Data = module->data_section[i] = (DEEPData*)malloc(sizeof(DEEPData));
+		Data = module->data_section[i] = (DEEPData*)deep_malloc(sizeof(DEEPData));
 		READ_BYTE(p);
 		p ++;
 		Data->offset = read_leb_u32((uint8_t**)&p);
@@ -265,17 +264,16 @@ DEEPModule* deep_load(uint8_t** p, int size) {
 		return NULL;
 	}
 	size -= 8;
-	DEEPModule* module = (DEEPModule*)malloc(sizeof(DEEPModule));
+	DEEPModule* module = (DEEPModule*)deep_malloc(sizeof(DEEPModule));
 	if(module == NULL) {
 		error("module malloc fail");
 		return NULL;
 	}
-	memset(module, 0, sizeof(module));
 	decode_each_sections(module, section_list);
 	section_listnode* dummy = section_list, *q;
 	while(dummy != NULL) {
 		q = dummy->next;
-		free(dummy);
+		deep_free(dummy);
 		dummy = q;
 	}
 	section_list = NULL;
@@ -285,31 +283,28 @@ DEEPModule* deep_load(uint8_t** p, int size) {
 void module_free(DEEPModule *module) {
 	uint32_t i;
 	for (i = 0; i < module->data_count; i++) {
-		free(module->data_section[i]);
+		deep_free(module->data_section[i]);
 	}
-	free(module->data_section);
+	deep_free(module->data_section);
 	for (i = 0; i < module->type_count; i++) {
-		free(module->type_section[i]);
+		deep_free(module->type_section[i]);
 	}
-	free(module->type_section);
+	deep_free(module->type_section);
 	for (i = 0; i < module->function_count; i++) {
-		free(module->func_section[i]);
+		deep_free(module->func_section[i]->localvars);
+		deep_free(module->func_section[i]);
 	}
-	free(module->func_section);
+	deep_free(module->func_section);
 	for (i = 0; i < module->export_count; i++) {
-		free(module->export_section[i]->name);
-		free(module->export_section[i]);
+		deep_free(module->export_section[i]->name);
+		deep_free(module->export_section[i]);
 	}
-	free(module->export_section);
-	free(module);
+	deep_free(module->export_section);
+	deep_free(module);
 }
 
-//内存模块实现
-#define PAGESIZE 65536
-
 uint8_t* init_memory(uint32_t min_page) {
-    uint8_t* mem = (uint8_t*)malloc(min_page * PAGESIZE);
-    memset(mem, 0, min_page * PAGESIZE);
+    uint8_t* mem = (uint8_t*)deep_malloc(min_page * PAGESIZE);
     return mem;
 }