Add a runtime API for reset shared heap(chain) (#4740)

* add new runtime api for reset shared heap(chain)
* add new unit test case

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);
     }

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);

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

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 @@ fail0:
 
 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;