add runtime API for shared memory destroy and recycle, and some test cases

core/iwasm/common/wasm_memory.c

@@ -148,6 +148,25 @@ static void
 wasm_munmap_linear_memory(void *mapped_mem, uint64 commit_size,
                           uint64 map_size);
 
+static void
+destroy_shared_heap_node(WASMSharedHeap *heap)
+{
+    uint64 map_size;
+
+    if (heap->heap_handle) {
+        mem_allocator_destroy(heap->heap_handle);
+        wasm_runtime_free(heap->heap_handle);
+#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);
+    }
+
+    wasm_runtime_free(heap);
+}
+
 static void *
 runtime_malloc(uint64 size)
 {
@@ -339,6 +358,81 @@ wasm_runtime_unchain_shared_heaps(WASMSharedHeap *head, bool entire_chain)
     return cur;
 }
 
+/* Destroy and recycle a shared heap(or head of shared heap chain), return next
+ * node in the shared heap chain  */
+static WASMSharedHeap *
+wasm_runtime_destroy_shared_heap_head(WASMSharedHeap *head)
+{
+    WASMSharedHeap *cur = NULL, *prev = NULL, *new_head = NULL;
+    bool head_found = false, is_chain_head = true;
+
+    if (!head) {
+        LOG_WARNING("Invalid shared heap to destroy.");
+        return NULL;
+    }
+
+    os_mutex_lock(&shared_heap_list_lock);
+    if (head->attached_count != 0) {
+        LOG_WARNING("To destroy shared heap, it needs to be detached first.");
+        os_mutex_unlock(&shared_heap_list_lock);
+        return NULL;
+    }
+
+    for (cur = shared_heap_list; cur; cur = cur->next) {
+        if (cur == head)
+            head_found = true;
+        if (cur->chain_next == head)
+            is_chain_head = false;
+    }
+    if (!head_found) {
+        LOG_WARNING("Shared heap %p isn't tracked by runtime.", head);
+        os_mutex_unlock(&shared_heap_list_lock);
+        return NULL;
+    }
+    if (!is_chain_head) {
+        LOG_WARNING("Shared heap %p isn't the head of a shared heap chain.",
+                    head);
+        os_mutex_unlock(&shared_heap_list_lock);
+        return NULL;
+    }
+
+    new_head = head->chain_next;
+    if (head == shared_heap_list) {
+        shared_heap_list = head->next;
+        destroy_shared_heap_node(head);
+    }
+    else {
+        prev = shared_heap_list;
+        cur = shared_heap_list->next;
+        while (prev) {
+            if (head == cur) {
+                prev->next = head->next;
+                destroy_shared_heap_node(cur);
+                break;
+            }
+            prev = prev->next;
+            cur = cur->next;
+        }
+    }
+
+    os_mutex_unlock(&shared_heap_list_lock);
+
+    LOG_VERBOSE("Destroyed shared heap %p", head);
+
+    return new_head;
+}
+
+WASMSharedHeap *
+wasm_runtime_destroy_shared_heap(WASMSharedHeap *head, bool entire_chain)
+{
+    WASMSharedHeap *new_head = NULL;
+    do {
+        new_head = wasm_runtime_destroy_shared_heap_head(head);
+    } while (entire_chain && new_head);
+
+    return new_head;
+}
+
 static uint8 *
 get_last_used_shared_heap_base_addr_adj(WASMModuleInstanceCommon *module_inst)
 {
@@ -819,7 +913,6 @@ destroy_shared_heaps()
 {
     WASMSharedHeap *heap;
     WASMSharedHeap *cur;
-    uint64 map_size;
 
     os_mutex_lock(&shared_heap_list_lock);
     heap = shared_heap_list;
@@ -829,17 +922,7 @@ destroy_shared_heaps()
     while (heap) {
         cur = heap;
         heap = heap->next;
-        if (cur->heap_handle) {
+        destroy_shared_heap_node(cur);
-            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);
-        }
-        wasm_runtime_free(cur);
     }
     os_mutex_destroy(&shared_heap_list_lock);
 }

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);
 
+WASMSharedHeap *
+wasm_runtime_destroy_shared_heap(WASMSharedHeap *head, bool entire_chain);
+
 bool
 wasm_runtime_attach_shared_heap(WASMModuleInstanceCommon *module_inst,
                                 WASMSharedHeap *shared_heap);

core/iwasm/include/wasm_export.h

@@ -2405,6 +2405,21 @@ 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);
 
+/**
+ * Destroy a shared heap or shared heap chain starting from the given head.
+ * If `entire_chain` is true, destroy the whole chain; otherwise, destroy only
+ * the head and return the new head of the chain. The shared heap chain must be
+ * detached before destruction, and only the chain head registered with the
+ * runtime can be destroyed.
+ *
+ * @param head The head of the shared heap chain to be destroyed.
+ * @param entire_chain Whether to destroy the entire chain.
+ * @return The new head of the shared heap chain when `entire_chain` is false;
+ * NULL otherwise.
+ */
+WASM_RUNTIME_API_EXTERN wasm_shared_heap_t
+wasm_runtime_destroy_shared_heap(wasm_shared_heap_t head, bool entire_chain);
+
 /**
  * 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

@@ -7,7 +7,7 @@
 #include "gtest/gtest.h"
 
 #include "bh_read_file.h"
-#include "wasm_runtime_common.h"
+#include "wasm_runtime.h"
 
 #include <gtest/gtest-spi.h>
 
@@ -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,10 +188,10 @@ 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];
+    uint8 preallocated_buf[BUF_SIZE] = {};
 
     /* create a preallocated shared heap */
     args.pre_allocated_addr = preallocated_buf;
@@ -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;
@@ -321,11 +321,144 @@ create_test_shared_heap_chain(uint8 *preallocated_buf, size_t size,
     }
 }
 
+TEST_F(shared_heap_test, test_destroy_shared_heap_head_only)
+{
+    WASMSharedHeap *shared_heap_chain = nullptr;
+    WASMSharedHeap *second = nullptr;
+    uint32 argv[1] = {}, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE] = {};
+
+    create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, NULL, BUF_SIZE,
+                                  &shared_heap_chain);
+    second = shared_heap_chain->chain_next;
+
+    ASSERT_NE(nullptr, second);
+
+    WASMSharedHeap *new_head =
+        wasm_runtime_destroy_shared_heap(shared_heap_chain, false);
+
+    ASSERT_EQ(second, new_head);
+    ASSERT_EQ(nullptr, new_head->chain_next);
+
+    test_shared_heap(new_head, "test.wasm", "test", 0, argv);
+    EXPECT_EQ(10, argv[0]);
+}
+
+TEST_F(shared_heap_test, test_destroy_shared_heap_entire_chain)
+{
+    SharedHeapInitArgs args = {};
+    WASMSharedHeap *shared_heap_chain = nullptr;
+
+    args.size = 1024;
+    shared_heap_chain = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap_chain) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    EXPECT_EQ(nullptr,
+              wasm_runtime_destroy_shared_heap(shared_heap_chain, true));
+}
+
+TEST_F(shared_heap_test, test_destroy_shared_heap_not_chain_head)
+{
+    WASMSharedHeap *shared_heap_chain = nullptr;
+    WASMSharedHeap *body = nullptr;
+    uint32 argv[1] = {}, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {};
+
+    create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2,
+                                  BUF_SIZE, &shared_heap_chain);
+    body = shared_heap_chain->chain_next;
+
+    ASSERT_NE(nullptr, body);
+
+    EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(body, true));
+    EXPECT_EQ(body, shared_heap_chain->chain_next);
+
+    test_shared_heap(shared_heap_chain, "test.wasm", "test", 0, argv);
+    EXPECT_EQ(10, argv[0]);
+
+    EXPECT_EQ(nullptr,
+              wasm_runtime_destroy_shared_heap(shared_heap_chain, true));
+}
+
+TEST_F(shared_heap_test, test_destroy_shared_heap_when_attached)
+{
+    WASMSharedHeap *shared_heap = nullptr;
+    uint32 argv[1] = {}, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE] = {};
+    struct ret_env module_env = {};
+
+    create_test_shared_heap(preallocated_buf, BUF_SIZE, &shared_heap);
+
+    ASSERT_TRUE(load_wasm((char *)"test.wasm", 0, module_env));
+    ASSERT_TRUE(wasm_runtime_attach_shared_heap(module_env.wasm_module_inst,
+                                                shared_heap));
+
+    EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(shared_heap, true));
+
+    wasm_runtime_detach_shared_heap(module_env.wasm_module_inst);
+    destroy_module_env(module_env);
+
+    EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(shared_heap, true));
+}
+
+TEST_F(shared_heap_test, test_destroy_invalid_shared_heap)
+{
+    WASMSharedHeap fake_shared_heap = {};
+
+    EXPECT_EQ(nullptr,
+              wasm_runtime_destroy_shared_heap(&fake_shared_heap, true));
+}
+
+TEST_F(shared_heap_test, test_destroy_shared_heap_untracked_next_head_only)
+{
+    WASMSharedHeap *shared_heap_chain = nullptr;
+    WASMSharedHeap *body = nullptr;
+    WASMSharedHeap fake_shared_heap = {};
+    uint32 BUF_SIZE = os_getpagesize();
+
+    create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2,
+                                  BUF_SIZE, &shared_heap_chain);
+    body = shared_heap_chain->chain_next;
+
+    ASSERT_NE(nullptr, body);
+
+    shared_heap_chain->chain_next = &fake_shared_heap;
+    EXPECT_EQ(NULL, wasm_runtime_destroy_shared_heap(shared_heap_chain, false));
+    shared_heap_chain->chain_next = body;
+
+    EXPECT_EQ(body, wasm_runtime_destroy_shared_heap(shared_heap_chain, false));
+    EXPECT_EQ(nullptr, wasm_runtime_destroy_shared_heap(body, true));
+}
+
+TEST_F(shared_heap_test, test_destroy_shared_heap_untracked_next_entire_chain)
+{
+    WASMSharedHeap *shared_heap_chain = nullptr;
+    WASMSharedHeap *body = nullptr;
+    WASMSharedHeap fake_shared_heap = {};
+    uint32 BUF_SIZE = os_getpagesize();
+
+    create_test_shared_heap_chain(NULL, BUF_SIZE, NULL, BUF_SIZE,
+                                  &shared_heap_chain);
+    body = shared_heap_chain->chain_next;
+
+    ASSERT_NE(nullptr, body);
+
+    shared_heap_chain->chain_next = &fake_shared_heap;
+    EXPECT_EQ(nullptr,
+              wasm_runtime_destroy_shared_heap(shared_heap_chain, true));
+
+    shared_heap_chain->chain_next = body;
+    EXPECT_EQ(nullptr,
+              wasm_runtime_destroy_shared_heap(shared_heap_chain, true));
+}
+
 TEST_F(shared_heap_test, test_shared_heap_rmw)
 {
     WASMSharedHeap *shared_heap = nullptr;
-    uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint32 argv[2] = {}, BUF_SIZE = os_getpagesize();
-    uint8 preallocated_buf[BUF_SIZE] = { 0 };
+    uint8 preallocated_buf[BUF_SIZE] = {};
     uint32 start1, end1;
 
     create_test_shared_heap(preallocated_buf, BUF_SIZE, &shared_heap);
@@ -361,11 +494,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();
+    uint32 argv[2] = {}, BUF_SIZE = os_getpagesize();
-    uint8 preallocated_buf[BUF_SIZE] = { 0 },
+    uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {};
-          preallocated_buf2[BUF_SIZE] = { 0 };
     uint32 start1, end1, start2, end2;
 
     create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2,
@@ -410,11 +542,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();
+    uint32 argv[3] = {}, BUF_SIZE = os_getpagesize();
-    uint8 preallocated_buf[BUF_SIZE] = { 0 },
+    uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {};
-          preallocated_buf2[BUF_SIZE] = { 0 };
     uint32 start1, end1, start2, end2;
 
     create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2,
@@ -466,11 +597,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();
+    uint32 argv[3] = {}, BUF_SIZE = os_getpagesize();
-    uint8 preallocated_buf[BUF_SIZE] = { 0 },
+    uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {};
-          preallocated_buf2[BUF_SIZE] = { 0 };
     uint32 start1, end1, start2, end2;
 
     create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2,
@@ -551,7 +681,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,8 +715,8 @@ 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];
+    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,
@@ -618,9 +748,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();
+    uint32 argv[3] = {}, BUF_SIZE = os_getpagesize();
-    uint8 preallocated_buf[BUF_SIZE] = { 0 },
+    uint8 preallocated_buf[BUF_SIZE] = {}, preallocated_buf2[BUF_SIZE] = {};
-          preallocated_buf2[BUF_SIZE] = { 0 };
     uint64 start1, end1, start2, end2;
 
     create_test_shared_heap_chain(preallocated_buf, BUF_SIZE, preallocated_buf2,
@@ -666,7 +795,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 +855,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 +884,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 +924,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 +967,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 +990,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 +1032,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 +1077,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;
@@ -1000,10 +1129,10 @@ TEST_F(shared_heap_test, test_shared_heap_chain_unchain)
 
 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 +1186,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;