christoph/wamr
1
Fork 0
Code Releases Activity

Implement memory profiler, optimize memory usage, modify code indent (#35)

Browse Source
This commit is contained in:
wenyongh
2019-05-23 05:03:31 -05:00
committed by GitHub
parent 9136abfe31
commit ff7cbdd2fb
18 changed files with 462 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
core/iwasm/lib/native/base/timer_wrapper.c
View File

@ -55,8 +55,8 @@ void * thread_modulers_timer_check(void * arg)
while (1) {
ms_to_expiry = -1;
vm_mutex_lock(&g_timer_ctx_list_mutex);
timer_ctx_node_t* elem = (timer_ctx_node_t*) bh_list_first_elem(
&g_timer_ctx_list);
timer_ctx_node_t* elem = (timer_ctx_node_t*)
bh_list_first_elem(&g_timer_ctx_list);
while (elem) {
int next = check_app_timers(elem->timer_ctx);
if (next != -1) {
@ -72,7 +72,7 @@ void * thread_modulers_timer_check(void * arg)
ms_to_expiry = 60 * 1000;
vm_mutex_lock(&g_timer_ctx_list_mutex);
vm_cond_reltimedwait(&g_timer_ctx_list_cond, &g_timer_ctx_list_mutex,
ms_to_expiry);
ms_to_expiry);
vm_mutex_unlock(&g_timer_ctx_list_mutex);
}
}
@ -94,20 +94,21 @@ void init_wasm_timer()
vm_recursive_mutex_init(&g_timer_ctx_list_mutex);
vm_thread_create(&tm_tid, thread_modulers_timer_check,
NULL,
BH_APPLET_PRESERVED_STACK_SIZE);
NULL, BH_APPLET_PRESERVED_STACK_SIZE);
}
timer_ctx_t create_wasm_timer_ctx(unsigned int module_id, int prealloc_num)
{
timer_ctx_t ctx = create_timer_ctx(wasm_timer_callback,
wakeup_modules_timer_thread, prealloc_num, module_id);
wakeup_modules_timer_thread,
prealloc_num,
module_id);
if (ctx == NULL)
return NULL;
timer_ctx_node_t * node = (timer_ctx_node_t*) bh_malloc(
sizeof(timer_ctx_node_t));
timer_ctx_node_t * node = (timer_ctx_node_t*)
bh_malloc(sizeof(timer_ctx_node_t));
if (node == NULL) {
destroy_timer_ctx(ctx);
return NULL;
@ -125,8 +126,8 @@ timer_ctx_t create_wasm_timer_ctx(unsigned int module_id, int prealloc_num)
void destory_module_timer_ctx(unsigned int module_id)
{
vm_mutex_lock(&g_timer_ctx_list_mutex);
timer_ctx_node_t* elem = (timer_ctx_node_t*) bh_list_first_elem(
&g_timer_ctx_list);
timer_ctx_node_t* elem = (timer_ctx_node_t*)
bh_list_first_elem(&g_timer_ctx_list);
while (elem) {
if (timer_ctx_get_owner(elem->timer_ctx) == module_id) {
bh_list_remove(&g_timer_ctx_list, elem);
@ -151,7 +152,7 @@ timer_ctx_t get_wasm_timer_ctx()
timer_id_t wasm_create_timer(int interval, bool is_period, bool auto_start)
{
return sys_create_timer(get_wasm_timer_ctx(), interval, is_period,
auto_start);
auto_start);
}
void wasm_timer_destory(timer_id_t timer_id)

22
core/iwasm/lib/native/extension/sensor/sensor_mgr_ref.c
View File

@ -40,13 +40,13 @@ void app_mgr_sensor_event_callback(module_data *m_data, bh_message_t msg)
wasm_data *wasm_app_data = (wasm_data*) m_data->internal_data;
wasm_module_inst_t inst = wasm_app_data->wasm_module_inst;
sensor_event_data_t *payload = (sensor_event_data_t*) bh_message_payload(
msg);
sensor_event_data_t *payload = (sensor_event_data_t*)
bh_message_payload(msg);
if (payload == NULL)
return;
func_onSensorEvent = wasm_runtime_lookup_function(inst, "_on_sensor_event",
"(i32i32i32)");
"(i32i32i32)");
if (!func_onSensorEvent) {
printf("Cannot find function onRequest\n");
} else {
@ -54,18 +54,17 @@ void app_mgr_sensor_event_callback(module_data *m_data, bh_message_t msg)
uint32 sensor_data_len;
if (payload->data_fmt == FMT_ATTR_CONTAINER) {
sensor_data_len = attr_container_get_serialize_length(
payload->data);
sensor_data_len = attr_container_get_serialize_length(payload->data);
} else {
printf("Unsupported sensor data format: %d\n", payload->data_fmt);
return;
}
sensor_data_offset = wasm_runtime_module_dup_data(inst, payload->data,
sensor_data_len);
sensor_data_len);
if (sensor_data_offset == 0) {
printf("Got exception running wasm code: %s\n",
wasm_runtime_get_exception(inst));
wasm_runtime_get_exception(inst));
wasm_runtime_clear_exception(inst);
return;
}
@ -76,7 +75,7 @@ void app_mgr_sensor_event_callback(module_data *m_data, bh_message_t msg)
if (!wasm_runtime_call_wasm(inst, NULL, func_onSensorEvent, 3, argv)) {
printf(":Got exception running wasm code: %s\n",
wasm_runtime_get_exception(inst));
wasm_runtime_get_exception(inst));
wasm_runtime_clear_exception(inst);
wasm_runtime_module_free(inst, sensor_data_offset);
return;
@ -130,17 +129,16 @@ void init_sensor_framework()
// add the sys sensor objects
add_sys_sensor("sensor_test", "This is a sensor for test", 0, 1000,
read_test_sensor, config_test_sensor);
read_test_sensor, config_test_sensor);
set_sensor_reshceduler(cb_wakeup_thread);
wasm_register_msg_callback(SENSOR_EVENT_WASM,
app_mgr_sensor_event_callback);
app_mgr_sensor_event_callback);
wasm_register_cleanup_callback(sensor_cleanup_callback);
vm_thread_create(&tid, (void *)thread_sensor_check, NULL,
BH_APPLET_PRESERVED_STACK_SIZE);
BH_APPLET_PRESERVED_STACK_SIZE);
}

13
core/iwasm/runtime/vmcore-wasm/wasm.h
View File

@ -219,6 +219,15 @@ typedef struct WASMDataSeg {
uint8 *data;
} WASMDataSeg;
typedef struct BlockAddr {
const uint8 *start_addr;
uint8 *else_addr;
uint8 *end_addr;
} BlockAddr;
#define BLOCK_ADDR_CACHE_SIZE 64
#define BLOCK_ADDR_CONFLICT_SIZE 4
typedef struct WASMModule {
uint32 type_count;
uint32 import_count;
@ -252,7 +261,11 @@ typedef struct WASMModule {
uint32 start_function;
HashMap *const_str_set;
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
HashMap *branch_set;
#else
BlockAddr block_addr_cache[BLOCK_ADDR_CACHE_SIZE][BLOCK_ADDR_CONFLICT_SIZE];
#endif
} WASMModule;
typedef struct WASMBranchBlock {

21
core/iwasm/runtime/vmcore-wasm/wasm_interp.c
View File

@ -760,11 +760,12 @@ wasm_interp_call_func_bytecode(WASMThread *self,
HANDLE_OP (WASM_OP_BLOCK):
read_leb_uint32(frame_ip, frame_ip_end, block_ret_type);
if (!wasm_loader_find_block_addr(module->branch_set, frame_ip,
frame_ip_end, BLOCK_TYPE_BLOCK,
if (!wasm_loader_find_block_addr(module->module,
frame_ip, frame_ip_end,
BLOCK_TYPE_BLOCK,
&else_addr, &end_addr,
NULL, 0)) {
wasm_runtime_set_exception(module, "wasm loader find block addr failed");
wasm_runtime_set_exception(module, "find block addr failed");
goto got_exception;
}
@ -774,11 +775,12 @@ wasm_interp_call_func_bytecode(WASMThread *self,
HANDLE_OP (WASM_OP_LOOP):
read_leb_uint32(frame_ip, frame_ip_end, block_ret_type);
if (!wasm_loader_find_block_addr(module->branch_set, frame_ip,
frame_ip_end, BLOCK_TYPE_LOOP,
if (!wasm_loader_find_block_addr(module->module,
frame_ip, frame_ip_end,
BLOCK_TYPE_LOOP,
&else_addr, &end_addr,
NULL, 0)) {
wasm_runtime_set_exception(module, "wasm loader find block addr failed");
wasm_runtime_set_exception(module, "find block addr failed");
goto got_exception;
}
@ -788,11 +790,12 @@ wasm_interp_call_func_bytecode(WASMThread *self,
HANDLE_OP (WASM_OP_IF):
read_leb_uint32(frame_ip, frame_ip_end, block_ret_type);
if (!wasm_loader_find_block_addr(module->branch_set, frame_ip,
frame_ip_end, BLOCK_TYPE_IF,
if (!wasm_loader_find_block_addr(module->module,
frame_ip, frame_ip_end,
BLOCK_TYPE_IF,
&else_addr, &end_addr,
NULL, 0)) {
wasm_runtime_set_exception(module, "wasm loader find block addr failed");
wasm_runtime_set_exception(module, "find block addr failed");
goto got_exception;
}

141
core/iwasm/runtime/vmcore-wasm/wasm_loader.c
View File

@ -1180,10 +1180,11 @@ load_from_sections(WASMModule *module, WASMSection *sections,
return true;
}
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
static uint32
branch_set_hash(const void *key)
{
return ((uintptr_t)key >> 4) ^ ((uintptr_t)key >> 14);
return ((uintptr_t)key) ^ ((uintptr_t)key >> 16);
}
static bool
@ -1197,6 +1198,16 @@ branch_set_value_destroy(void *value)
{
wasm_free(value);
}
#endif
#if BEIHAI_ENABLE_MEMORY_PROFILING != 0
static void wasm_loader_free(void *ptr)
{
wasm_free(ptr);
}
#else
#define wasm_loader_free wasm_free
#endif
static WASMModule*
create_module(char *error_buf, uint32 error_buf_size)
@ -1218,15 +1229,17 @@ create_module(char *error_buf, uint32 error_buf_size)
(HashFunc)wasm_string_hash,
(KeyEqualFunc)wasm_string_equal,
NULL,
wasm_free)))
wasm_loader_free)))
goto fail;
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
if (!(module->branch_set = wasm_hash_map_create(64, true,
branch_set_hash,
branch_set_key_equal,
NULL,
branch_set_value_destroy)))
goto fail;
#endif
return module;
@ -1361,15 +1374,17 @@ wasm_loader_load(const uint8 *buf, uint32 size, char *error_buf, uint32 error_bu
(HashFunc)wasm_string_hash,
(KeyEqualFunc)wasm_string_equal,
NULL,
wasm_free)))
wasm_loader_free)))
goto fail;
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
if (!(module->branch_set = wasm_hash_map_create(64, true,
branch_set_hash,
branch_set_key_equal,
NULL,
branch_set_value_destroy)))
goto fail;
#endif
if (!load(buf, size, module, error_buf, error_buf_size))
goto fail;
@ -1440,20 +1455,24 @@ wasm_loader_unload(WASMModule *module)
if (module->const_str_set)
wasm_hash_map_destroy(module->const_str_set);
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
if (module->branch_set)
wasm_hash_map_destroy(module->branch_set);
#endif
wasm_free(module);
}
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
typedef struct block_addr {
uint8 block_type;
uint8 *else_addr;
uint8 *end_addr;
uint8 *else_addr;
} block_addr;
#endif
bool
wasm_loader_find_block_addr(HashMap *branch_set,
wasm_loader_find_block_addr(WASMModule *module,
const uint8 *start_addr,
const uint8 *code_end_addr,
uint8 block_type,
@ -1466,8 +1485,10 @@ wasm_loader_find_block_addr(HashMap *branch_set,
uint8 *else_addr = NULL;
uint32 block_nested_depth = 1, count, i, u32, u64;
uint8 opcode, u8;
block_addr *block;
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
HashMap *branch_set = module->branch_set;
block_addr *block;
if ((block = wasm_hash_map_find(branch_set, (void*)start_addr))) {
if (block->block_type != block_type)
return false;
@ -1476,6 +1497,25 @@ wasm_loader_find_block_addr(HashMap *branch_set,
*p_end_addr = block->end_addr;
return true;
}
#else
BlockAddr block_stack[16] = { 0 }, *block;
uint32 j, t;
i = ((uintptr_t)start_addr) ^ ((uintptr_t)start_addr >> 16);
i = i % BLOCK_ADDR_CACHE_SIZE;
block = module->block_addr_cache[i];
for (j = 0; j < BLOCK_ADDR_CONFLICT_SIZE; j++) {
if (block[j].start_addr == start_addr) {
/* Cache hit */
*p_else_addr = block[j].else_addr;
*p_end_addr = block[j].end_addr;
return true;
}
}
/* Cache unhit */
block_stack[0].start_addr = start_addr;
#endif
while (p < code_end_addr) {
opcode = *p++;
@ -1489,12 +1529,22 @@ wasm_loader_find_block_addr(HashMap *branch_set,
case WASM_OP_LOOP:
case WASM_OP_IF:
read_leb_uint32(p, p_end, u32); /* blocktype */
#if WASM_ENABLE_HASH_BLOCK_ADDR == 0
if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr)) {
block_stack[block_nested_depth].start_addr = p;
block_stack[block_nested_depth].else_addr = NULL;
}
#endif
block_nested_depth++;
break;
case WASM_OP_ELSE:
if (block_type == BLOCK_TYPE_IF && block_nested_depth == 1)
else_addr = (uint8*)(p - 1);
#if WASM_ENABLE_HASH_BLOCK_ADDR == 0
if (block_nested_depth - 1 < sizeof(block_stack)/sizeof(BlockAddr))
block_stack[block_nested_depth - 1].else_addr = (uint8*)(p - 1);
#endif
break;
case WASM_OP_END:
@ -1503,7 +1553,13 @@ wasm_loader_find_block_addr(HashMap *branch_set,
*p_else_addr = else_addr;
*p_end_addr = (uint8*)(p - 1);
if ((block = wasm_malloc(sizeof(block_addr)))) {
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
if (block_type == BLOCK_TYPE_IF)
block = wasm_malloc(sizeof(block_addr));
else
block = wasm_malloc(offsetof(block_addr, else_addr));
if (block) {
block->block_type = block_type;
if (block_type == BLOCK_TYPE_IF)
block->else_addr = else_addr;
@ -1512,11 +1568,41 @@ wasm_loader_find_block_addr(HashMap *branch_set,
if (!wasm_hash_map_insert(branch_set, (void*)start_addr, block))
wasm_free(block);
}
#else
block_stack[0].end_addr = (uint8*)(p - 1);
for (t = 0; t < sizeof(block_stack)/sizeof(BlockAddr); t++) {
start_addr = block_stack[t].start_addr;
if (start_addr) {
i = ((uintptr_t)start_addr) ^ ((uintptr_t)start_addr >> 16);
i = i % BLOCK_ADDR_CACHE_SIZE;
block = module->block_addr_cache[i];
for (j = 0; j < BLOCK_ADDR_CONFLICT_SIZE; j++)
if (!block[j].start_addr)
break;
if (j == BLOCK_ADDR_CONFLICT_SIZE) {
memmove(block + 1, block, (BLOCK_ADDR_CONFLICT_SIZE - 1) *
sizeof(BlockAddr));
j = 0;
}
block[j].start_addr = block_stack[t].start_addr;
block[j].else_addr = block_stack[t].else_addr;
block[j].end_addr = block_stack[t].end_addr;
}
else
break;
}
#endif
return true;
}
else
else {
block_nested_depth--;
#if WASM_ENABLE_HASH_BLOCK_ADDR == 0
if (block_nested_depth < sizeof(block_stack)/sizeof(BlockAddr))
block_stack[block_nested_depth].end_addr = (uint8*)(p - 1);
#endif
}
break;
case WASM_OP_BR:
@ -2079,14 +2165,13 @@ static bool
wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
char *error_buf, uint32 error_buf_size)
{
HashMap *branch_set = module->branch_set;
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
block_addr *block;
#endif
uint8 *p = func->code, *p_end = func->code + func->code_size;
uint8 *frame_lp_ref_bottom = NULL;
uint8 *frame_ref_bottom = NULL, *frame_ref_boundary, *frame_ref;
BranchBlock *frame_csp_bottom = NULL, *frame_csp_boundary, *frame_csp;
uint32 param_count, local_count, global_count;
uint32 param_cell_num, local_cell_num;
uint32 max_stack_cell_num = 0, max_csp_num = 0;
uint32 stack_cell_num = 0, csp_num = 0;
uint32 frame_ref_size, frame_csp_size;
@ -2107,16 +2192,6 @@ wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
local_count = func->local_count;
local_types = func->local_types;
param_cell_num = wasm_get_cell_num(param_types, param_count);
local_cell_num = wasm_get_cell_num(local_types, local_count);
if (!(frame_lp_ref_bottom = wasm_malloc(param_cell_num + local_cell_num))) {
set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: alloc memory failed");
goto fail;
}
memset(frame_lp_ref_bottom, 0, param_cell_num + local_cell_num);
frame_ref_size = 32;
if (!(frame_ref_bottom = frame_ref = wasm_malloc(frame_ref_size))) {
set_error_buf(error_buf, error_buf_size,
@ -2167,7 +2242,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
(frame_csp - 1)->jumped_by_br = true;
else {
if (!i32_const) {
if(!wasm_loader_find_block_addr(branch_set,
if(!wasm_loader_find_block_addr(module,
(frame_csp - 1)->start_addr,
p_end,
(frame_csp - 1)->block_type,
@ -2210,10 +2285,16 @@ wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
if (csp_num > 0) {
frame_csp->end_addr = p - 1;
if (wasm_hash_map_find(branch_set, (void*)frame_csp->start_addr))
#if WASM_ENABLE_HASH_BLOCK_ADDR != 0
if (wasm_hash_map_find(module->branch_set, (void*)frame_csp->start_addr))
break;
if (!(block = wasm_malloc(sizeof(block_addr)))) {
if (frame_csp->block_type == BLOCK_TYPE_IF)
block = wasm_malloc(sizeof(block_addr));
else
block = wasm_malloc(offsetof(block_addr, else_addr));
if (!block) {
set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: "
"alloc memory failed");
@ -2221,10 +2302,11 @@ wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
}
block->block_type = frame_csp->block_type;
block->else_addr = (void*)frame_csp->else_addr;
if (frame_csp->block_type == BLOCK_TYPE_IF)
block->else_addr = (void*)frame_csp->else_addr;
block->end_addr = (void*)frame_csp->end_addr;
if (!wasm_hash_map_insert(branch_set, (void*)frame_csp->start_addr,
if (!wasm_hash_map_insert(module->branch_set, (void*)frame_csp->start_addr,
block)) {
set_error_buf(error_buf, error_buf_size,
"WASM loader prepare bytecode failed: "
@ -2232,6 +2314,7 @@ wasm_loader_prepare_bytecode(WASMModule *module, WASMFunction *func,
wasm_free(block);
goto fail;
}
#endif
}
break;
}
@ -2248,7 +2331,7 @@ handle_op_br:
block_return_type = (frame_csp - i)->return_type;
if(!wasm_loader_find_block_addr(branch_set,
if(!wasm_loader_find_block_addr(module,
(frame_csp - i)->start_addr,
p_end,
(frame_csp - i)->block_type,
@ -2304,7 +2387,7 @@ handle_op_br:
POP_TYPE(ret_type);
PUSH_TYPE(ret_type);
if(!wasm_loader_find_block_addr(branch_set,
if(!wasm_loader_find_block_addr(module,
(frame_csp - 1)->start_addr,
p_end,
(frame_csp - 1)->block_type,
@ -2862,8 +2945,6 @@ handle_op_br:
return_value = true;
fail:
if (frame_lp_ref_bottom)
wasm_free(frame_lp_ref_bottom);
if (frame_ref_bottom)
wasm_free(frame_ref_bottom);
if (frame_csp_bottom)

7
core/iwasm/runtime/vmcore-wasm/wasm_loader.h
View File

@ -61,10 +61,7 @@ wasm_loader_unload(WASMModule *module);
* Find address of related else opcode and end opcode of opcode block/loop/if
* according to the start address of opcode.
*
* @param branch_set the hashtable to store the else/end adress info of
* block/loop/if opcode. The function will lookup the hashtable firstly,
* if not found, it will then search the code from start_addr, and if success,
* stores the result to the hashtable.
* @param module the module to find
* @param start_addr the next address of opcode block/loop/if
* @param code_end_addr the end address of function code block
* @param block_type the type of block, 0/1/2 denotes block/loop/if
@ -76,7 +73,7 @@ wasm_loader_unload(WASMModule *module);
* @return true if success, false otherwise
*/
bool
wasm_loader_find_block_addr(HashMap *map,
wasm_loader_find_block_addr(WASMModule *module,
const uint8 *start_addr,
const uint8 *code_end_addr,
uint8 block_type,

11
core/iwasm/runtime/vmcore-wasm/wasm_runtime.c
View File

@ -706,7 +706,7 @@ execute_start_function(WASMModuleInstance *module_inst)
* Instantiate module
*/
WASMModuleInstance*
wasm_runtime_instantiate(const WASMModule *module,
wasm_runtime_instantiate(WASMModule *module,
uint32 stack_size, uint32 heap_size,
char *error_buf, uint32 error_buf_size)
{
@ -726,9 +726,11 @@ wasm_runtime_instantiate(const WASMModule *module,
/* Check heap size */
heap_size = align_uint(heap_size, 8);
if (heap_size == 0)
heap_size = DEFAULT_WASM_HEAP_SIZE;
if (heap_size < MIN_WASM_HEAP_SIZE)
heap_size = MIN_WASM_HEAP_SIZE;
heap_size = APP_HEAP_SIZE_DEFAULT;
if (heap_size < APP_HEAP_SIZE_MIN)
heap_size = APP_HEAP_SIZE_MIN;
if (heap_size > APP_HEAP_SIZE_MAX)
heap_size = APP_HEAP_SIZE_MAX;
/* Instantiate global firstly to get the mutable data size */
global_count = module->import_global_count + module->global_count;
@ -909,7 +911,6 @@ wasm_runtime_instantiate(const WASMModule *module,
&module_inst->functions[module->start_function];
}
module_inst->branch_set = module->branch_set;
module_inst->module = module;
/* module instance type */

8
core/iwasm/runtime/vmcore-wasm/wasm_runtime.h
View File

@ -25,11 +25,6 @@
extern "C" {
#endif
#define DEFAULT_WASM_STACK_SIZE (8 * 1024)
#define DEFAULT_WASM_HEAP_SIZE (8 * 1024)
#define MIN_WASM_HEAP_SIZE (1 * 1024)
typedef struct WASMMemoryInstance {
/* Current page count */
uint32 cur_page_count;
@ -153,8 +148,7 @@ typedef struct WASMModuleInstance {
WASMFunctionInstance *start_function;
HashMap *branch_set;
const WASMModule *module;
WASMModule *module;
uint32 DYNAMICTOP_PTR_offset;
uint32 temp_ret;