Refine interpreter to improve performance, refine memory usage (#161)

Author: wenyongh

core/iwasm/aot/aot_loader.c

@@ -289,7 +289,8 @@ load_target_info_section(const uint8 *buf, const uint8 *buf_end,
     const uint8 *p = buf, *p_end = buf_end;
     bool is_target_little_endian, is_target_64_bit;
 
-    read_uint32(p, p_end, target_info.bin_type);
+    read_uint16(p, p_end, target_info.bin_type);
+    read_uint16(p, p_end, target_info.abi_type);
     read_uint16(p, p_end, target_info.e_type);
     read_uint16(p, p_end, target_info.e_machine);
     read_uint32(p, p_end, target_info.e_version);
@@ -424,6 +425,7 @@ load_memory_info(const uint8 **p_buf, const uint8 *buf_end,
 {
     const uint8 *buf = *p_buf;
 
+    read_uint32(buf, buf_end, module->num_bytes_per_page);
     read_uint32(buf, buf_end, module->mem_init_page_count);
     read_uint32(buf, buf_end, module->mem_max_page_count);
     read_uint32(buf, buf_end, module->mem_init_data_count);
@@ -1001,6 +1003,11 @@ load_init_data_section(const uint8 *buf, const uint8 *buf_end,
         return false;
     }
 
+    read_uint32(p, p_end, module->llvm_aux_data_end);
+    read_uint32(p, p_end, module->llvm_aux_stack_bottom);
+    read_uint32(p, p_end, module->llvm_aux_stack_size);
+    read_uint32(p, p_end, module->llvm_aux_stack_global_index);
+
     if (!load_object_data_sections_info(&p, p_end, module,
                                         error_buf, error_buf_size))
         return false;
@@ -2297,6 +2304,7 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
     memset(module, 0, sizeof(AOTModule));
 
     module->module_type = Wasm_Module_AoT;
+    module->num_bytes_per_page = comp_data->num_bytes_per_page;
     module->mem_init_page_count = comp_data->mem_init_page_count;
     module->mem_max_page_count = comp_data->mem_max_page_count;
 
@@ -2382,6 +2390,11 @@ aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
         module->start_function = NULL;
     }
 
+    module->llvm_aux_data_end = comp_data->llvm_aux_data_end;
+    module->llvm_aux_stack_bottom = comp_data->llvm_aux_stack_bottom;
+    module->llvm_aux_stack_size = comp_data->llvm_aux_stack_size;
+    module->llvm_aux_stack_global_index = comp_data->llvm_aux_stack_global_index;
+
     module->code = NULL;
     module->code_size = 0;
 

core/iwasm/aot/aot_runtime.c

@@ -111,7 +111,7 @@ memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
 {
     uint32 i, global_index, global_data_offset, base_offset, length;
     AOTMemInitData *data_seg;
-    uint64 total_size = (uint64)NumBytesPerPage * module->mem_init_page_count;
+    uint64 total_size = (uint64)module->num_bytes_per_page * module->mem_init_page_count;
 
     /* Allocate memory */
     if (total_size >= UINT32_MAX
@@ -802,11 +802,13 @@ bool
 aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
 {
     uint8 *mem_data_old = module_inst->memory_data.ptr, *mem_data_new;
+    uint32 num_bytes_per_page =
+        ((AOTModule*)module_inst->aot_module.ptr)->num_bytes_per_page;
     uint32 cur_page_count = module_inst->mem_cur_page_count;
     uint32 max_page_count = module_inst->mem_max_page_count;
     uint32 total_page_count = cur_page_count + inc_page_count;
-    uint32 old_size = NumBytesPerPage * cur_page_count;
-    uint64 total_size = (uint64)NumBytesPerPage * total_page_count;
+    uint32 old_size = num_bytes_per_page * cur_page_count;
+    uint64 total_size = (uint64)num_bytes_per_page * total_page_count;
 
     if (inc_page_count <= 0)
         /* No need to enlarge memory */

core/iwasm/aot/aot_runtime.h

@@ -75,6 +75,7 @@ typedef struct AOTModule {
     uint32 module_type;
 
     /* memory info */
+    uint32 num_bytes_per_page;
     uint32 mem_init_page_count;
     uint32 mem_max_page_count;
     uint32 mem_init_data_count;
@@ -132,6 +133,11 @@ typedef struct AOTModule {
     /* constant string set */
     HashMap *const_str_set;
 
+    uint32 llvm_aux_data_end;
+    uint32 llvm_aux_stack_bottom;
+    uint32 llvm_aux_stack_size;
+    uint32 llvm_aux_stack_global_index;
+
     /* is jit mode or not */
     bool is_jit_mode;
 
@@ -210,7 +216,9 @@ typedef AOTExportFunc AOTFunctionInstance;
 /* Target info, read from ELF header of object file */
 typedef struct AOTTargetInfo {
     /* Binary type, elf32l/elf32b/elf64l/elf64b */
-    uint32 bin_type;
+    uint16 bin_type;
+    /* ABI type */
+    uint16 abi_type;
     /* Object file type */
     uint16 e_type;
     /* Architecture */

core/iwasm/compilation/aot.c

@@ -384,12 +384,16 @@ aot_create_comp_data(WASMModule *module)
 
   /* Set memory page count */
   if (module->import_memory_count) {
+    comp_data->num_bytes_per_page =
+      module->import_memories[0].u.memory.num_bytes_per_page;
     comp_data->mem_init_page_count =
       module->import_memories[0].u.memory.init_page_count;
     comp_data->mem_max_page_count =
       module->import_memories[0].u.memory.max_page_count;
   }
   else if (module->memory_count) {
+    comp_data->num_bytes_per_page =
+      module->memories[0].num_bytes_per_page;
     comp_data->mem_init_page_count =
       module->memories[0].init_page_count;
     comp_data->mem_max_page_count =

core/iwasm/compilation/aot.h

@@ -110,6 +110,7 @@ typedef struct AOTExportFunc {
 
 typedef struct AOTCompData {
   /* Memory and memory init data info */
+  uint32 num_bytes_per_page;
   uint32 mem_init_page_count;
   uint32 mem_max_page_count;
   uint32 mem_init_data_count;
@@ -142,6 +143,11 @@ typedef struct AOTCompData {
   uint32 addr_data_size;
   uint32 global_data_size;
 
+  uint32 llvm_aux_data_end;
+  uint32 llvm_aux_stack_bottom;
+  uint32 llvm_aux_stack_size;
+  uint32 llvm_aux_stack_global_index;
+
   WASMModule *wasm_module;
 } AOTCompData;
 

core/iwasm/compilation/aot_emit_aot_file.c

@@ -141,8 +141,9 @@ get_mem_init_data_list_size(AOTMemInitData **mem_init_data_list,
 static uint32
 get_mem_info_size(AOTCompData *comp_data)
 {
-    /* init page count + max page count + init data count + init data list */
-    return (uint32)sizeof(uint32) * 3
+    /* num bytes per page + init page count + max page count
+       + init data count + init data list */
+    return (uint32)sizeof(uint32) * 4
            + get_mem_init_data_list_size(comp_data->mem_init_data_list,
                                          comp_data->mem_init_data_count);
 }
@@ -367,6 +368,10 @@ get_init_data_section_size(AOTCompData *comp_data, AOTObjectData *obj_data)
     size = align_uint(size, 4);
     size += (uint32)sizeof(uint32) * 2;
 
+    /* llvm aux data end + llvm aux stack bottom
+       + llvm aux stack size + llvm stack global index */
+    size += sizeof(uint32) * 4;
+
     size += get_object_data_section_info_size(obj_data);
     return size;
 }
@@ -837,7 +842,8 @@ aot_emit_target_info_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
     EMIT_U32(AOT_SECTION_TYPE_TARGET_INFO);
     EMIT_U32(section_size);
 
-    EMIT_U32(target_info->bin_type);
+    EMIT_U16(target_info->bin_type);
+    EMIT_U16(target_info->abi_type);
     EMIT_U16(target_info->e_type);
     EMIT_U16(target_info->e_machine);
     EMIT_U32(target_info->e_version);
@@ -864,6 +870,7 @@ aot_emit_mem_info(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
 
     *p_offset = offset = align_uint(offset, 4);
 
+    EMIT_U32(comp_data->num_bytes_per_page);
     EMIT_U32(comp_data->mem_init_page_count);
     EMIT_U32(comp_data->mem_max_page_count);
     EMIT_U32(comp_data->mem_init_data_count);
@@ -1087,6 +1094,11 @@ aot_emit_init_data_section(uint8 *buf, uint8 *buf_end, uint32 *p_offset,
     EMIT_U32(comp_data->func_count);
     EMIT_U32(comp_data->start_func_index);
 
+    EMIT_U32(comp_data->llvm_aux_data_end);
+    EMIT_U32(comp_data->llvm_aux_stack_bottom);
+    EMIT_U32(comp_data->llvm_aux_stack_size);
+    EMIT_U32(comp_data->llvm_aux_stack_global_index);
+
     if (!aot_emit_object_data_section_info(buf, buf_end, &offset, obj_data))
         return false;
 

core/iwasm/compilation/aot_emit_memory.c

@@ -71,7 +71,8 @@ check_memory_overflow(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
         uint32 memory_offset = (uint32)LLVMConstIntGetZExtValue(moffset);
         uint32 init_page_count = comp_ctx->comp_data->mem_init_page_count;
         if (init_page_count > 0
-            && memory_offset <= NumBytesPerPage * init_page_count - bytes) {
+            && memory_offset <= comp_ctx->comp_data->num_bytes_per_page
+                                * init_page_count - bytes) {
             /* inside memory space */
             if (!func_ctx->mem_space_unchanged) {
                 if (!(mem_base_addr = LLVMBuildLoad(comp_ctx->builder,

core/iwasm/interpreter/wasm.h

@@ -26,11 +26,7 @@ extern "C" {
 /* Table Element Type */
 #define TABLE_ELEM_TYPE_ANY_FUNC 0x70
 
-#define MaxMemoryPages 65536
-#define MaxTableElems UINT32_MAX
-#define NumBytesPerPage 65536
-#define NumBytesPerPageLog2 16
-#define MaxReturnValues 16
+#define DEFAULT_NUM_BYTES_PER_PAGE 65536
 
 #define INIT_EXPR_TYPE_I32_CONST 0x41
 #define INIT_EXPR_TYPE_I64_CONST 0x42
@@ -110,7 +106,7 @@ typedef struct WASMTable {
 
 typedef struct WASMMemory {
     uint32 flags;
-    /* 64 kbytes one page by default */
+    uint32 num_bytes_per_page;
     uint32 init_page_count;
     uint32 max_page_count;
 } WASMMemory;
@@ -129,7 +125,7 @@ typedef struct WASMMemoryImport {
     char *module_name;
     char *field_name;
     uint32 flags;
-    /* 64 kbytes one page by default */
+    uint32 num_bytes_per_page;
     uint32 init_page_count;
     uint32 max_page_count;
 } WASMMemoryImport;
@@ -269,6 +265,16 @@ typedef struct WASMModule {
     WASMDataSeg **data_segments;
     uint32 start_function;
 
+    /* __data_end global exported by llvm */
+    uint32 llvm_aux_data_end;
+    /* auxiliary stack bottom, or __heap_base global exported by llvm */
+    uint32 llvm_aux_stack_bottom;
+    /* auxiliary stack size */
+    uint32 llvm_aux_stack_size;
+    /* the index of a global exported by llvm, which is
+       auxiliary stack top pointer */
+    uint32 llvm_aux_stack_global_index;
+
     /* Whether there is possible memory grow, e.g.
        memory.grow opcode or call enlargeMemory */
     bool possible_memory_grow;