From 93d9299500d50f31ed5b2c0bfa040a556b6c7b92 Mon Sep 17 00:00:00 2001 From: TL Date: Thu, 4 Dec 2025 18:39:12 +0800 Subject: [PATCH 1/2] add new runtime api for reset shared heap(chain) --- core/iwasm/common/wasm_memory.c | 137 ++++++++++++++++++++++--------- core/iwasm/common/wasm_memory.h | 3 + core/iwasm/include/wasm_export.h | 11 +++ 3 files changed, 114 insertions(+), 37 deletions(-) diff --git a/core/iwasm/common/wasm_memory.c b/core/iwasm/common/wasm_memory.c index 10c651bc94..02ab1b764d 100644 --- a/core/iwasm/common/wasm_memory.c +++ b/core/iwasm/common/wasm_memory.c @@ -162,10 +162,73 @@ runtime_malloc(uint64 size) return mem; } +static void +destroy_runtime_managed_shared_heap(WASMSharedHeap *heap) +{ + uint64 map_size; + + mem_allocator_destroy(heap->heap_handle); + wasm_runtime_free(heap->heap_handle); + heap->heap_handle = NULL; + +#ifndef OS_ENABLE_HW_BOUND_CHECK + map_size = heap->size; +#else + map_size = 8 * (uint64)BH_GB; +#endif + wasm_munmap_linear_memory(heap->base_addr, heap->size, map_size); + heap->base_addr = NULL; +} + +static bool +create_runtime_managed_shared_heap(WASMSharedHeap *heap, + uint64 heap_struct_size) +{ + uint64 map_size; + + heap->heap_handle = runtime_malloc(mem_allocator_get_heap_struct_size()); + if (!heap->heap_handle) { + heap->base_addr = NULL; + return false; + } + +#ifndef OS_ENABLE_HW_BOUND_CHECK + map_size = heap->size; +#else + /* Totally 8G is mapped, the opcode load/store address range is 0 to 8G: + * ea = i + memarg.offset + * both i and memarg.offset are u32 in range 0 to 4G + * so the range of ea is 0 to 8G + */ + map_size = 8 * (uint64)BH_GB; +#endif + + if (!(heap->base_addr = wasm_mmap_linear_memory(map_size, heap->size))) { + goto fail1; + } + if (!mem_allocator_create_with_struct_and_pool( + heap->heap_handle, heap_struct_size, heap->base_addr, heap->size)) { + LOG_WARNING("init share heap failed"); + goto fail2; + } + + LOG_VERBOSE("Create runtime managed shared heap %p with size %u", + heap->base_addr, (uint32)heap->size); + return true; + +fail2: + wasm_munmap_linear_memory(heap->base_addr, heap->size, map_size); +fail1: + wasm_runtime_free(heap->heap_handle); + heap->heap_handle = NULL; + heap->base_addr = NULL; + return false; +} + WASMSharedHeap * wasm_runtime_create_shared_heap(SharedHeapInitArgs *init_args) { - uint64 heap_struct_size = sizeof(WASMSharedHeap), map_size; + uint64 heap_struct_size = sizeof(WASMSharedHeap); uint32 size = init_args->size; WASMSharedHeap *heap; @@ -203,32 +266,9 @@ wasm_runtime_create_shared_heap(SharedHeapInitArgs *init_args) heap->base_addr, size); } else { - if (!(heap->heap_handle = - runtime_malloc(mem_allocator_get_heap_struct_size()))) { + if (!create_runtime_managed_shared_heap(heap, heap_struct_size)) { goto fail2; } - -#ifndef OS_ENABLE_HW_BOUND_CHECK - map_size = size; -#else - /* Totally 8G is mapped, the opcode load/store address range is 0 to 8G: - * ea = i + memarg.offset - * both i and memarg.offset are u32 in range 0 to 4G - * so the range of ea is 0 to 8G - */ - map_size = 8 * (uint64)BH_GB; -#endif - - if (!(heap->base_addr = wasm_mmap_linear_memory(map_size, size))) { - goto fail3; - } - if (!mem_allocator_create_with_struct_and_pool( - heap->heap_handle, heap_struct_size, heap->base_addr, size)) { - LOG_WARNING("init share heap failed"); - goto fail4; - } - LOG_VERBOSE("Create pool shared heap %p with size %u", heap->base_addr, - size); } os_mutex_lock(&shared_heap_list_lock); @@ -242,10 +282,6 @@ wasm_runtime_create_shared_heap(SharedHeapInitArgs *init_args) os_mutex_unlock(&shared_heap_list_lock); return heap; -fail4: - wasm_munmap_linear_memory(heap->base_addr, size, map_size); -fail3: - wasm_runtime_free(heap->heap_handle); fail2: wasm_runtime_free(heap); fail1: @@ -339,6 +375,40 @@ wasm_runtime_unchain_shared_heaps(WASMSharedHeap *head, bool entire_chain) return cur; } +bool +wasm_runtime_reset_shared_heap_chain(WASMSharedHeap *shared_heap) +{ + uint64 heap_struct_size = sizeof(WASMSharedHeap); + WASMSharedHeap *cur; + + if (!shared_heap) { + return false; + } + + os_mutex_lock(&shared_heap_list_lock); + if (shared_heap->attached_count != 0) { + os_mutex_unlock(&shared_heap_list_lock); + return false; + } + + for (cur = shared_heap; cur; cur = cur->chain_next) { + if (cur->heap_handle) { + destroy_runtime_managed_shared_heap(cur); + + if (!create_runtime_managed_shared_heap(cur, heap_struct_size)) { + os_mutex_unlock(&shared_heap_list_lock); + return false; + } + } + else { + memset(cur->base_addr, 0, (size_t)cur->size); + } + } + + os_mutex_unlock(&shared_heap_list_lock); + return true; +} + static uint8 * get_last_used_shared_heap_base_addr_adj(WASMModuleInstanceCommon *module_inst) { @@ -830,14 +900,7 @@ destroy_shared_heaps() cur = heap; heap = heap->next; if (cur->heap_handle) { - mem_allocator_destroy(cur->heap_handle); - wasm_runtime_free(cur->heap_handle); -#ifndef OS_ENABLE_HW_BOUND_CHECK - map_size = cur->size; -#else - map_size = 8 * (uint64)BH_GB; -#endif - wasm_munmap_linear_memory(cur->base_addr, cur->size, map_size); + destroy_runtime_managed_shared_heap(cur); } wasm_runtime_free(cur); } diff --git a/core/iwasm/common/wasm_memory.h b/core/iwasm/common/wasm_memory.h index b79ed4a6cb..a96e250400 100644 --- a/core/iwasm/common/wasm_memory.h +++ b/core/iwasm/common/wasm_memory.h @@ -95,6 +95,9 @@ wasm_runtime_chain_shared_heaps(WASMSharedHeap *head, WASMSharedHeap *body); WASMSharedHeap * wasm_runtime_unchain_shared_heaps(WASMSharedHeap *head, bool entire_chain); +bool +wasm_runtime_reset_shared_heap_chain(WASMSharedHeap *shared_heap); + bool wasm_runtime_attach_shared_heap(WASMModuleInstanceCommon *module_inst, WASMSharedHeap *shared_heap); diff --git a/core/iwasm/include/wasm_export.h b/core/iwasm/include/wasm_export.h index 44a45dedfc..86f7c22b17 100644 --- a/core/iwasm/include/wasm_export.h +++ b/core/iwasm/include/wasm_export.h @@ -2437,6 +2437,17 @@ wasm_runtime_chain_shared_heaps(wasm_shared_heap_t head, wasm_shared_heap_t wasm_runtime_unchain_shared_heaps(wasm_shared_heap_t head, bool entire_chain); +/** + * Reset shared heap chain. For each shared heap in the chain, if it is a + * pre-allocated shared heap, its memory region will be zeroed. For a + * WAMR-managed shared heap, it will be destroyed and reinitialized. + * + * @param shared_heap The head of the shared heap chain. + * @return true if success, false otherwise. + */ +WASM_RUNTIME_API_EXTERN bool +wasm_runtime_reset_shared_heap_chain(wasm_shared_heap_t shared_heap); + /** * Attach a shared heap, it can be the head of shared heap chain, in that case, * attach the shared heap chain, to a module instance From 7e8415d5535c9fa42e520c7a315667cfbea551c9 Mon Sep 17 00:00:00 2001 From: TL Date: Fri, 5 Dec 2025 10:47:56 +0800 Subject: [PATCH 2/2] add new unit test case and fix some warnings --- tests/unit/shared-heap/shared_heap_test.cc | 238 ++++++++++++++++----- 1 file changed, 188 insertions(+), 50 deletions(-) diff --git a/tests/unit/shared-heap/shared_heap_test.cc b/tests/unit/shared-heap/shared_heap_test.cc index 434b4c3899..5e2b1f7189 100644 --- a/tests/unit/shared-heap/shared_heap_test.cc +++ b/tests/unit/shared-heap/shared_heap_test.cc @@ -32,13 +32,13 @@ static void destroy_module_env(struct ret_env module_env); static bool -load_wasm(char *wasm_file_tested, unsigned int app_heap_size, +load_wasm(const char *wasm_file_tested, unsigned int app_heap_size, ret_env &ret_module_env) { char *wasm_file = strdup(wasm_file_tested); unsigned int wasm_file_size = 0; unsigned int stack_size = 16 * 1024, heap_size = app_heap_size; - char error_buf[128] = { 0 }; + char error_buf[128] = {}; ret_module_env.wasm_file_buf = (unsigned char *)bh_read_file_to_buffer(wasm_file, &wasm_file_size); @@ -141,9 +141,9 @@ test_shared_heap(WASMSharedHeap *shared_heap, const char *file, TEST_F(shared_heap_test, test_shared_heap_basic) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; args.size = 1024; shared_heap = wasm_runtime_create_shared_heap(&args); @@ -164,9 +164,9 @@ TEST_F(shared_heap_test, test_shared_heap_basic) TEST_F(shared_heap_test, test_shared_heap_malloc_fail) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; args.size = 1024; shared_heap = wasm_runtime_create_shared_heap(&args); @@ -188,9 +188,9 @@ TEST_F(shared_heap_test, test_shared_heap_malloc_fail) TEST_F(shared_heap_test, test_preallocated_shared_heap_malloc_fail) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; /* create a preallocated shared heap */ @@ -220,9 +220,9 @@ TEST_F(shared_heap_test, test_preallocated_shared_heap_malloc_fail) TEST_F(shared_heap_test, test_preallocated_shared_runtime_api) { struct ret_env tmp_module_env; - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; void *native_ptr; uint64 offset, size; bool ret; @@ -263,7 +263,7 @@ TEST_F(shared_heap_test, test_preallocated_shared_runtime_api) ASSERT_EQ(true, wasm_runtime_validate_app_addr( tmp_module_env.wasm_module_inst, offset, size)); - ASSERT_EQ(native_ptr + size, + ASSERT_EQ((char *)native_ptr + size, wasm_runtime_addr_app_to_native(tmp_module_env.wasm_module_inst, offset + size)); @@ -277,7 +277,7 @@ static void create_test_shared_heap(uint8 *preallocated_buf, size_t size, WASMSharedHeap **shared_heap_res) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; args.pre_allocated_addr = preallocated_buf; args.size = size; @@ -297,7 +297,7 @@ create_test_shared_heap_chain(uint8 *preallocated_buf, size_t size, uint8 *preallocated_buf2, size_t size2, WASMSharedHeap **shared_heap_chain) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr; args.pre_allocated_addr = preallocated_buf; args.size = size; @@ -324,8 +324,8 @@ create_test_shared_heap_chain(uint8 *preallocated_buf, size_t size, TEST_F(shared_heap_test, test_shared_heap_rmw) { WASMSharedHeap *shared_heap = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }; + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}; uint32 start1, end1; create_test_shared_heap(preallocated_buf, BUF_SIZE, &shared_heap); @@ -361,11 +361,10 @@ TEST_F(shared_heap_test, test_shared_heap_rmw) TEST_F(shared_heap_test, test_shared_heap_chain_rmw) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint32 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -410,11 +409,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw) TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint32 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -466,11 +464,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory) TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory_oob) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint32 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -551,7 +548,7 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw_bulk_memory_oob) TEST_F(shared_heap_test, test_shared_heap_rmw_oob) { WASMSharedHeap *shared_heap = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; uint32 start1, end1, start2, end2; @@ -585,7 +582,7 @@ TEST_F(shared_heap_test, test_shared_heap_rmw_oob) TEST_F(shared_heap_test, test_shared_heap_chain_rmw_oob) { WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[2] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; uint32 start1, end1, start2, end2; @@ -618,9 +615,8 @@ TEST_F(shared_heap_test, test_shared_heap_chain_rmw_oob) TEST_F(shared_heap_test, test_shared_heap_chain_memory64_rmw) { WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); - uint8 preallocated_buf[BUF_SIZE] = { 0 }, - preallocated_buf2[BUF_SIZE] = { 0 }; + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {}; uint64 start1, end1, start2, end2; create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2, @@ -666,7 +662,7 @@ TEST_F(shared_heap_test, test_shared_heap_chain_memory64_rmw) TEST_F(shared_heap_test, test_shared_heap_chain_memory64_rmw_oob) { WASMSharedHeap *shared_heap_chain = nullptr; - uint32 argv[3] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[3] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; uint64 start1, end1, start2, end2; @@ -726,9 +722,9 @@ static NativeSymbol g_test_native_symbols[] = { TEST_F(shared_heap_test, test_addr_conv) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }; + uint32 argv[1] = {}; bool ret = false; ret = wasm_native_register_natives("env", g_test_native_symbols, @@ -755,9 +751,9 @@ TEST_F(shared_heap_test, test_addr_conv) TEST_F(shared_heap_test, test_addr_conv_pre_allocated_oob) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(), + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(), app_addr = 0xFFFFFFFF - BUF_SIZE; uint8 preallocated_buf[BUF_SIZE]; bool ret = false; @@ -795,10 +791,10 @@ TEST_F(shared_heap_test, test_addr_conv_pre_allocated_oob) TEST_F(shared_heap_test, test_shared_heap_chain) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; bool ret = false; @@ -838,7 +834,7 @@ TEST_F(shared_heap_test, test_shared_heap_chain) TEST_F(shared_heap_test, test_shared_heap_chain_create_fail) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; @@ -861,10 +857,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_create_fail) TEST_F(shared_heap_test, test_shared_heap_chain_create_fail2) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; struct ret_env tmp_module_env; @@ -903,10 +899,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_create_fail2) TEST_F(shared_heap_test, test_shared_heap_chain_create_fail3) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap3 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; args.size = 1024; @@ -948,10 +944,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_create_fail3) TEST_F(shared_heap_test, test_shared_heap_chain_unchain) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap3 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE]; args.size = 1024; @@ -998,12 +994,154 @@ TEST_F(shared_heap_test, test_shared_heap_chain_unchain) wasm_runtime_unchain_shared_heaps(shared_heap_chain, true)); } +TEST_F(shared_heap_test, test_shared_heap_chain_reset_runtime_managed) +{ + SharedHeapInitArgs args = {}; + WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, + *shared_heap_chain = nullptr; + uint8 buf_size = 64; + uint64 offset = 0, offset_after_reset = 0; + void *native_ptr = nullptr, *native_ptr_after_reset = nullptr; + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE]; + struct ret_env tmp_module_env; + + args.size = 4096; + shared_heap = wasm_runtime_create_shared_heap(&args); + if (!shared_heap) { + FAIL() << "Failed to create shared heap"; + } + + args.size = BUF_SIZE; + args.pre_allocated_addr = preallocated_buf; + shared_heap2 = wasm_runtime_create_shared_heap(&args); + if (!shared_heap2) { + FAIL() << "Failed to create second shared heap"; + } + + shared_heap_chain = + wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2); + if (!shared_heap_chain) { + FAIL() << "Create shared heap chain failed.\n"; + } + + if (!load_wasm((char *)"test.wasm", 0, tmp_module_env)) { + FAIL() << "Failed to load wasm file\n"; + } + + if (!wasm_runtime_attach_shared_heap(tmp_module_env.wasm_module_inst, + shared_heap_chain)) { + destroy_module_env(tmp_module_env); + FAIL() << "Failed to attach shared heap chain"; + } + + offset = wasm_runtime_shared_heap_malloc(tmp_module_env.wasm_module_inst, + buf_size, &native_ptr); + ASSERT_NE(0u, offset); + ASSERT_NE(nullptr, native_ptr); + + memset(native_ptr, 0x5A, buf_size); + for (uint8 i = 0; i < buf_size; i++) { + EXPECT_EQ(0x5A, *((uint8 *)native_ptr + i)); + } + + wasm_runtime_detach_shared_heap(tmp_module_env.wasm_module_inst); + EXPECT_TRUE(wasm_runtime_reset_shared_heap_chain(shared_heap_chain)); + + if (!load_wasm((char *)"test.wasm", 0, tmp_module_env)) { + FAIL() << "Failed to load wasm file after reset\n"; + } + + if (!wasm_runtime_attach_shared_heap(tmp_module_env.wasm_module_inst, + shared_heap_chain)) { + destroy_module_env(tmp_module_env); + FAIL() << "Failed to attach shared heap chain after reset"; + } + + offset_after_reset = wasm_runtime_shared_heap_malloc( + tmp_module_env.wasm_module_inst, buf_size, &native_ptr_after_reset); + ASSERT_NE(0u, offset_after_reset); + ASSERT_NE(nullptr, native_ptr_after_reset); + + EXPECT_EQ(offset, offset_after_reset); + EXPECT_EQ(native_ptr, native_ptr_after_reset); + + /* Only on some platform, the os_mmap will memset the memory to 0 + for (uint8 i = 0; i < buf_size; i++) { + EXPECT_EQ(0, *((uint8 *)native_ptr_after_reset + i)); + } + */ + + wasm_runtime_detach_shared_heap(tmp_module_env.wasm_module_inst); + destroy_module_env(tmp_module_env); +} + +TEST_F(shared_heap_test, test_shared_heap_chain_reset_preallocated) +{ + SharedHeapInitArgs args = {}; + WASMSharedHeap *shared_heap = nullptr; + uint32 BUF_SIZE = os_getpagesize(); + uint8 preallocated_buf[BUF_SIZE]; + uint8 set_val = 0xA5; + + args.pre_allocated_addr = preallocated_buf; + args.size = BUF_SIZE; + shared_heap = wasm_runtime_create_shared_heap(&args); + if (!shared_heap) { + FAIL() << "Create preallocated shared heap failed.\n"; + } + + memset(preallocated_buf, set_val, BUF_SIZE); + for (uint32 i = 0; i < BUF_SIZE; i++) { + EXPECT_EQ(set_val, preallocated_buf[i]); + } + + EXPECT_TRUE(wasm_runtime_reset_shared_heap_chain(shared_heap)); + + for (uint32 i = 0; i < BUF_SIZE; i++) { + EXPECT_EQ(0, preallocated_buf[i]); + } +} + +TEST_F(shared_heap_test, test_shared_heap_chain_reset_attached_fail) +{ + SharedHeapInitArgs args = {}; + WASMSharedHeap *shared_heap = nullptr; + struct ret_env module_env = {}; + bool ret; + + args.size = 1024; + shared_heap = wasm_runtime_create_shared_heap(&args); + if (!shared_heap) { + FAIL() << "Failed to create shared heap"; + } + + ret = load_wasm((char *)"test.wasm", 0, module_env); + if (!ret) { + FAIL() << "Failed to load wasm"; + } + + ret = wasm_runtime_attach_shared_heap(module_env.wasm_module_inst, + shared_heap); + if (!ret) { + destroy_module_env(module_env); + FAIL() << "Failed to attach shared heap"; + } + + EXPECT_FALSE(wasm_runtime_reset_shared_heap_chain(shared_heap)); + + wasm_runtime_detach_shared_heap(module_env.wasm_module_inst); + destroy_module_env(module_env); + + EXPECT_TRUE(wasm_runtime_reset_shared_heap_chain(shared_heap)); +} + TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; bool ret = false; @@ -1057,10 +1195,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv) TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv_oob) { - SharedHeapInitArgs args = { 0 }; + SharedHeapInitArgs args = {}; WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr, *shared_heap_chain = nullptr; - uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(); + uint32 argv[1] = {}, BUF_SIZE = os_getpagesize(); uint8 preallocated_buf[BUF_SIZE]; bool ret = false;