Unit test and sample update for shared heap enhancement (#4070)

- preallocated shared heap and shared heap chain
- update preallocated shared heap and shared heap chain sample and document
- shared heap unit test and sample
- update document and build script

Co-authored-by: liang.he <liang.he@intel.com>

samples/shared-heap/CMakeLists.txt

@@ -83,17 +83,21 @@ target_link_libraries(vmlib ${LLVM_AVAILABLE_LIBS} ${UV_A_LIBS} -lm -ldl -lpthre
 include_directories(${CMAKE_CURRENT_LIST_DIR}/src)
 include (${SHARED_DIR}/utils/uncommon/shared_uncommon.cmake)
 
+add_executable (shared_heap_chain_test src/shared_heap_chain.c ${UNCOMMON_SHARED_SOURCE})
 add_executable (shared_heap_test src/main.c ${UNCOMMON_SHARED_SOURCE})
 
 check_pie_supported()
 set_target_properties (shared_heap_test PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
 if (APPLE)
-  target_link_libraries (shared_heap_test vmlib -lm -ldl -lpthread)
+  set (LIBS vmlib -lm -ldl -lpthread)
 else ()
-  target_link_libraries (shared_heap_test vmlib -lm -ldl -lpthread -lrt)
+  set (LIBS vmlib -lm -ldl -lpthread -lrt)
 endif ()
 
+target_link_libraries (shared_heap_chain_test ${LIBS})
+target_link_libraries (shared_heap_test ${LIBS})
+
 add_subdirectory(wasm-apps)
 
 if (WAMR_BUILD_AOT EQUAL 1)

samples/shared-heap/README.md

@@ -0,0 +1,50 @@
+# Shared heap Sample introduction
+
+This is a sample to show how to use the shared heap feature in WAMR. The shared heap feature allows multiple WASM instances to share the same memory space. This feature is useful when you want to run multiple WASM instances in the same process and share data between them. The sandbox nature of WASM is still maintained in the shared heap by WAMR. But the data management and correct data synchronization in shared heap is relied on the user's implementation.
+
+> Note: The shared heap feature is experimental feature, it should be used with caution. It's optional and only available when building WAMR with the CMake cache variable `WAMR_BUILD_SHARED_HEAP` set to 1.
+
+## Build and run the sample
+
+To build the shared heap used in multi thread sample and the shared heap chain sample with following commands:
+
+```bash
+cmake -S . -B build
+cmake --build build
+```
+
+For the shared heap sample, it demonstrates how to create a shared heap and use it shares data between two WASM instances, which would satisfy most of the use cases. Use the following commands to run the sample:
+
+```bash
+cd build
+./shared_heap_test
+```
+
+For the shared heap chain sample. It chains a pre-allocated heap and a normal shared heap to one chain(linked list) as a whole and attaches/detaches all together, and pass the WASM address directly between two WASM instances. Use the following commands to run the sample:
+
+```bash
+cd build
+./shared_heap_chain_test
+```
+
+## How to use shared heap
+
+The shared heap is an advanced feature in WAMR that gives the user flexibility to share data between multiple WASM instances(it will be the same address mapping for different WASM instance) or between WebAssembly and the host without incurring any copy overhead. The shared heap can be regarded as an extension of the WebAssembly linear memory. But it also heavily relies on the user's implementation to manage the shared data correctly. The following are some takeaway points to help the user use the shared heap correctly.
+
+### Create and manage shared heap
+
+You can create a shared heap by calling the `wasm_runtime_create_shared_heap(SharedHeapInitArgs *init_args)` API. And based on the `init_args`, you can create a shared heap in two ways:
+
+1. WAMR managed shared heap: when only `init_args.size` is given and `init_args.pre_allocated_addr` stays as NULL, WAMR will allocate a shared heap(not from the linear memory) with the given size. The shared heap will be managed by WAMR, the wasm app or host(WAMR users) can dynamically manage memory from it by calling `wasm_runtime_shared_heap_malloc()` and `wasm_runtime_shared_heap_free()` on demand. Only the memory allocated from the shared heap is valid and can be shared, not the unallocated part of shared heap memory. And it will be automatically freed when runtime is destroyed(when `wasm_runtime_destroy()` is called).
+
+2. Preallocated shared heap: the user can also use a pre-allocated memory(it can be allocated from the system heap, or is a static global buffer, the correctness of its accessibility and size needs to be ensured by the user) as a shared heap by giving `init_args.pre_allocated_addr` and `init_args.size`. This kind of shared heap serves as an area for data exchange, primarily between the host and WebAssembly. Any data within this area can be directly accessed by both sides (assuming the layout of the data structure is known). For instance, the host can store large structured variables in this space, allowing the WebAssembly application to operate on them without the need for copying. And the pre-allocated memory will relies on user to manage its life cycle.
+
+After creation, the shared heap can be attached to a WASM instance(an additional segment appended to the end of the linear memory) by calling `wasm_runtime_attach_shared_heap(wasm_module_inst_t module_inst, wasm_shared_heap_t shared_heap)`. And it can be detached by calling `wasm_runtime_detach_shared_heap(wasm_module_inst_t module_inst)`. So that the data sharing can only happen between the WASM instances that have the same shared heap attached, complete by user's choice.
+
+#### Shared heap chain
+
+Sometimes you may want to use multiple shared heaps to attach together as a chain(linked list) and to share data more flexibly. You can call `wasm_runtime_chain_shared_heaps(wasm_shared_heap_t head, wasm_shared_heap_t body)` to chain two shared heaps together. The shared heap list remains one continuous shared heap in wasm app's point of view. To create a shared heap chain, the shared heaps can't be currently attached to any WASM instance.
+
+> PS: At most one shared heap in shared heap list can be  WAMR managed shared heap, the rest have to be the pre-allocated shared heap.
+
+![shared-heap-chain](./images/shared_heap_chain.png)

samples/shared-heap/src/main.c

@@ -251,7 +251,7 @@ main(int argc, char **argv)
     heap_init_args.size = 65536;
     shared_heap = wasm_runtime_create_shared_heap(&heap_init_args);
     if (!shared_heap) {
-        printf("Create shared heap failed. error: %s\n", error_buf);
+        printf("Create shared heap failed.\n");
         goto fail;
     }
 

samples/shared-heap/src/shared_heap_chain.c

@@ -0,0 +1,321 @@
+/*
+ * Copyright (C) 2019 Intel Corporation.  All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#include "wasm_export.h"
+#include "bh_platform.h"
+#include "bh_read_file.h"
+
+#define BUF_SIZE 4096
+static char preallocated_buf[BUF_SIZE];
+
+static bool
+produce_data(wasm_module_inst_t module_inst, wasm_exec_env_t exec_env,
+             bh_queue *queue, wasm_function_inst_t func, uint32 *argv,
+             uint32 buf_size, bool free_on_fail)
+{
+    uint8 *buf;
+
+    wasm_runtime_call_wasm(exec_env, func, 2, argv);
+
+    if (wasm_runtime_get_exception(module_inst)) {
+        printf("Failed to call function: %s\n",
+               wasm_runtime_get_exception(module_inst));
+        return false;
+    }
+    if (free_on_fail && argv[0] == 0) {
+        printf("Failed to allocate memory from shared heap\n");
+        return false;
+    }
+
+    buf = wasm_runtime_addr_app_to_native(module_inst, argv[0]);
+    printf("wasm app1 send buf: %s\n\n", buf);
+
+    /* Passes wasm address directly between wasm apps since memory in shared
+     * heap chain is viewed as single address space in wasm's perspective */
+    buf = (uint8 *)(uint64)argv[0];
+    if (!bh_post_msg(queue, 1, buf, buf_size)) {
+        printf("Failed to post message to queue\n");
+        if (free_on_fail)
+            wasm_runtime_shared_heap_free(module_inst, argv[0]);
+        return false;
+    }
+
+    return true;
+}
+
+static void *
+wasm_producer(wasm_module_inst_t module_inst, bh_queue *queue)
+{
+    wasm_exec_env_t exec_env;
+    wasm_function_inst_t my_shared_heap_malloc_func, my_shared_heap_free_func,
+        produce_str_func;
+    uint32 i, argv[2];
+
+    /* lookup wasm functions */
+    if (!(my_shared_heap_malloc_func = wasm_runtime_lookup_function(
+              module_inst, "my_shared_heap_malloc"))
+        || !(my_shared_heap_free_func = wasm_runtime_lookup_function(
+                 module_inst, "my_shared_heap_free"))
+        || !(produce_str_func =
+                 wasm_runtime_lookup_function(module_inst, "produce_str"))) {
+        printf("Failed to lookup function.\n");
+    }
+
+    /* create exec env */
+    if (!(exec_env = wasm_runtime_create_exec_env(module_inst, 32768))) {
+        printf("Failed to create exec env.\n");
+        return NULL;
+    }
+
+    /* allocate memory by calling my_shared_heap_malloc function and send it
+       to wasm app2 */
+    for (i = 0; i < 8; i++) {
+        argv[0] = 1024 * (i + 1);
+        argv[1] = i + 1;
+        if (!produce_data(module_inst, exec_env, queue,
+                          my_shared_heap_malloc_func, argv, 1024 * (i + 1),
+                          true)) {
+            break;
+        }
+    }
+
+    /* use pre-allocated shared heap memory by calling produce_str function and
+       send it to wasm app2, the pre-allocated shared heap is the last one in
+       chain, so its end address is calculated from UIN32_MAX */
+    uint32 wasm_start_addr = UINT32_MAX - BUF_SIZE + 1;
+    for (i = 8; i < 16; i++) {
+        argv[0] = wasm_start_addr + 512 * (i - 8);
+        argv[1] = i + 1;
+        if (!produce_data(module_inst, exec_env, queue, produce_str_func, argv,
+                          512, false)) {
+            break;
+        }
+    }
+
+    wasm_runtime_destroy_exec_env(exec_env);
+
+    return NULL;
+}
+
+static void
+wasm_consumer(wasm_module_inst_t module_inst, bh_queue *queue)
+{
+    wasm_function_inst_t print_buf_func, consume_str_func;
+    wasm_exec_env_t exec_env;
+    uint32 argv[2], i;
+    bh_message_t msg;
+    char *buf;
+
+    /* lookup wasm function */
+    if (!(print_buf_func =
+              wasm_runtime_lookup_function(module_inst, "print_buf"))
+        || !(consume_str_func =
+                 wasm_runtime_lookup_function(module_inst, "consume_str"))) {
+        printf("Failed to lookup function.\n");
+        return;
+    }
+
+    /* create exec env */
+    if (!(exec_env = wasm_runtime_create_exec_env(module_inst, 32768))) {
+        printf("Failed to create exec env.\n");
+        return;
+    }
+
+    for (i = 0; i < 16; i++) {
+        msg = bh_get_msg(queue, BHT_WAIT_FOREVER);
+        if (!msg)
+            return;
+        buf = bh_message_payload(msg);
+
+        /* call wasm function */
+        argv[0] = (uint32)(uint64)buf;
+        if (i < 8)
+            wasm_runtime_call_wasm(exec_env, print_buf_func, 1, argv);
+        else
+            wasm_runtime_call_wasm(exec_env, consume_str_func, 1, argv);
+
+        if (wasm_runtime_get_exception(module_inst)) {
+            printf(
+                "Failed to call 'print_buf' or 'consumer_str' function: %s\n",
+                wasm_runtime_get_exception(module_inst));
+        }
+
+        bh_free_msg(msg);
+    }
+
+    wasm_runtime_destroy_exec_env(exec_env);
+}
+
+static char global_heap_buf[512 * 1024];
+
+int
+main(int argc, char **argv)
+{
+    char *wasm_file1 = NULL, *wasm_file2 = NULL;
+    uint8 *wasm_file1_buf = NULL, *wasm_file2_buf = NULL;
+    uint32 wasm_file1_size, wasm_file2_size;
+    wasm_module_t wasm_module1 = NULL, wasm_module2 = NULL;
+    wasm_module_inst_t module_inst1 = NULL;
+    wasm_module_inst_t module_inst2 = NULL;
+    wasm_shared_heap_t shared_heap = NULL, shared_heap2 = NULL,
+                       shared_heap_chain = NULL;
+    bh_queue *queue = NULL;
+    RuntimeInitArgs init_args;
+    SharedHeapInitArgs heap_init_args;
+    char error_buf[128] = { 0 };
+    bool aot_mode = false;
+    int ret = -1;
+
+    if (argc > 1 && !strcmp(argv[1], "--aot"))
+        aot_mode = true;
+
+    if (!aot_mode)
+        printf("Test shared heap in interpreter mode\n\n");
+    else
+        printf("Test shared heap in AOT mode\n\n");
+
+    memset(&init_args, 0, sizeof(RuntimeInitArgs));
+
+    init_args.mem_alloc_type = Alloc_With_Pool;
+    init_args.mem_alloc_option.pool.heap_buf = global_heap_buf;
+    init_args.mem_alloc_option.pool.heap_size = sizeof(global_heap_buf);
+
+    /* init wasm runtime */
+    if (!wasm_runtime_full_init(&init_args)) {
+        printf("Init runtime environment failed.\n");
+        return -1;
+    }
+
+    /* create queue */
+    if (!(queue = bh_queue_create())) {
+        printf("Create queue failed.\n");
+        goto fail;
+    }
+
+    /* read wasm file */
+    if (!aot_mode)
+        wasm_file1 = "./wasm-apps/test1.wasm";
+    else
+        wasm_file1 = "./wasm-apps/test1.aot";
+    if (!(wasm_file1_buf =
+              bh_read_file_to_buffer(wasm_file1, &wasm_file1_size))) {
+        printf("Open wasm file %s failed.\n", wasm_file1);
+        goto fail;
+    }
+
+    /* load wasm file */
+    wasm_module1 = wasm_runtime_load((uint8 *)wasm_file1_buf, wasm_file1_size,
+                                     error_buf, sizeof(error_buf));
+    if (!wasm_module1) {
+        printf("Load wasm module failed. error: %s\n", error_buf);
+        goto fail;
+    }
+
+    /* instantiate module */
+    module_inst1 = wasm_runtime_instantiate(wasm_module1, 65536, 0, error_buf,
+                                            sizeof(error_buf));
+    if (!module_inst1) {
+        printf("Instantiate wasm module failed. error: %s\n", error_buf);
+        goto fail;
+    }
+
+    /* read wasm file */
+    if (!aot_mode)
+        wasm_file2 = "./wasm-apps/test2.wasm";
+    else
+        wasm_file2 = "./wasm-apps/test2.aot";
+    if (!(wasm_file2_buf =
+              bh_read_file_to_buffer(wasm_file2, &wasm_file2_size))) {
+        printf("Open wasm file %s failed.\n", wasm_file1);
+        goto fail;
+    }
+
+    /* load wasm file */
+    wasm_module2 = wasm_runtime_load((uint8 *)wasm_file2_buf, wasm_file2_size,
+                                     error_buf, sizeof(error_buf));
+    if (!wasm_module2) {
+        printf("Load wasm module failed. error: %s\n", error_buf);
+        goto fail;
+    }
+
+    /* instantiate module */
+    module_inst2 = wasm_runtime_instantiate(wasm_module2, 65536, 0, error_buf,
+                                            sizeof(error_buf));
+    if (!module_inst2) {
+        printf("Instantiate wasm module failed. error: %s\n", error_buf);
+        goto fail;
+    }
+
+    /* create shared heap */
+    memset(&heap_init_args, 0, sizeof(heap_init_args));
+    heap_init_args.size = 65536;
+    shared_heap = wasm_runtime_create_shared_heap(&heap_init_args);
+    if (!shared_heap) {
+        printf("Create shared heap failed.\n");
+        goto fail;
+    }
+
+    /* create a preallocated shared heap */
+    memset(&heap_init_args, 0, sizeof(heap_init_args));
+    heap_init_args.pre_allocated_addr = preallocated_buf;
+    heap_init_args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&heap_init_args);
+    if (!shared_heap2) {
+        printf("Create preallocated shared heap failed\n");
+        goto fail;
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        printf("Create shared heap chain failed\n");
+        goto fail;
+    }
+
+    /* attach module instance 1 to the shared heap */
+    if (!wasm_runtime_attach_shared_heap(module_inst1, shared_heap_chain)) {
+        printf("Attach shared heap failed.\n");
+        goto fail;
+    }
+
+    /* attach module instance 2 to the shared heap */
+    if (!wasm_runtime_attach_shared_heap(module_inst2, shared_heap_chain)) {
+        printf("Attach shared heap failed.\n");
+        goto fail;
+    }
+
+    /* wasm 1 produce shared data */
+    wasm_producer(module_inst1, queue);
+
+    /* wasm 2 consume shared data */
+    wasm_consumer(module_inst2, queue);
+    ret = 0;
+
+fail:
+    if (module_inst2)
+        wasm_runtime_deinstantiate(module_inst2);
+
+    if (module_inst1)
+        wasm_runtime_deinstantiate(module_inst1);
+
+    if (wasm_module2)
+        wasm_runtime_unload(wasm_module2);
+
+    if (wasm_module1)
+        wasm_runtime_unload(wasm_module1);
+
+    if (wasm_file2_buf)
+        wasm_runtime_free(wasm_file2_buf);
+
+    if (wasm_file1_buf)
+        wasm_runtime_free(wasm_file1_buf);
+
+    if (queue)
+        bh_queue_destroy(queue);
+
+    wasm_runtime_destroy();
+
+    return ret;
+}

samples/shared-heap/wasm-apps/CMakeLists.txt

@@ -30,9 +30,7 @@ set (CMAKE_EXE_LINKER_FLAGS
       -Wl,--no-entry,--strip-all,                  \
       -Wl,--export=__heap_base,--export=__data_end \
       -Wl,--export=__wasm_call_ctors               \
-      -Wl,--export=my_shared_heap_malloc           \
-      -Wl,--export=my_shared_heap_free             \
-      -Wl,--export=print_buf                       \
+      -Wl,--export-all                             \
       -Wl,--allow-undefined"
 )
 

samples/shared-heap/wasm-apps/test1.c

@@ -58,3 +58,10 @@ my_shared_heap_free(void *ptr)
 {
     shared_heap_free(ptr);
 }
+
+void *
+produce_str(char *addr, uint32_t index)
+{
+    snprintf(addr, 512, "Data: %u stores to pre-allocated shared heap", index);
+    return addr;
+}

samples/shared-heap/wasm-apps/test2.c

@@ -4,8 +4,7 @@
  */
 
 #include <stdio.h>
-
-#include <stdio.h>
+#include <stdint.h>
 
 extern void
 shared_heap_free(void *ptr);
@@ -16,3 +15,11 @@ print_buf(char *buf)
     printf("wasm app2's wasm func received buf: %s\n\n", buf);
     shared_heap_free(buf);
 }
+
+void
+consume_str(char *buf)
+{
+    printf("wasm app2's wasm func received buf in pre-allocated shared buf: "
+           "%s\n\n",
+           buf);
+}

tests/unit/CMakeLists.txt

@@ -22,10 +22,18 @@ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 
 # Fetch Google test
 include (FetchContent)
-FetchContent_Declare (
-    googletest
-    URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
-)
+if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24")
+  FetchContent_Declare (
+          googletest
+          URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+          DOWNLOAD_EXTRACT_TIMESTAMP ON
+  )
+else()
+  FetchContent_Declare (
+          googletest
+          URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+  )
+endif()
 FetchContent_MakeAvailable (googletest)
 
 SET(GOOGLETEST_INCLUDED 1)

tests/unit/shared-heap/shared_heap_test.cc

@@ -9,6 +9,8 @@
 #include "bh_read_file.h"
 #include "wasm_runtime_common.h"
 
+#include <gtest/gtest-spi.h>
+
 class shared_heap_test : public testing::Test
 {
   protected:
@@ -26,50 +28,50 @@ struct ret_env {
     char error_buf[128];
 };
 
-struct ret_env
-load_wasm(char *wasm_file_tested, unsigned int app_heap_size)
+static void
+destroy_module_env(struct ret_env module_env);
+
+static bool
+load_wasm(char *wasm_file_tested, unsigned int app_heap_size,
+          ret_env &ret_module_env)
 {
-    std::string wasm_mem_page = wasm_file_tested;
-    const char *wasm_file = strdup(wasm_mem_page.c_str());
-    wasm_module_inst_t wasm_module_inst = nullptr;
-    wasm_module_t wasm_module = nullptr;
-    wasm_exec_env_t exec_env = nullptr;
-    unsigned char *wasm_file_buf = nullptr;
+    const 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 };
-    struct ret_env ret_module_env;
 
-    memset(ret_module_env.error_buf, 0, 128);
-    wasm_file_buf =
+    ret_module_env.wasm_file_buf =
         (unsigned char *)bh_read_file_to_buffer(wasm_file, &wasm_file_size);
-    if (!wasm_file_buf) {
+    if (!ret_module_env.wasm_file_buf) {
         goto fail;
     }
 
-    wasm_module = wasm_runtime_load(wasm_file_buf, wasm_file_size, error_buf,
-                                    sizeof(error_buf));
-    if (!wasm_module) {
+    ret_module_env.wasm_module =
+        wasm_runtime_load(ret_module_env.wasm_file_buf, wasm_file_size,
+                          error_buf, sizeof(error_buf));
+    if (!ret_module_env.wasm_module) {
         memcpy(ret_module_env.error_buf, error_buf, 128);
         goto fail;
     }
 
-    wasm_module_inst = wasm_runtime_instantiate(
-        wasm_module, stack_size, heap_size, error_buf, sizeof(error_buf));
-    if (!wasm_module_inst) {
+    ret_module_env.wasm_module_inst =
+        wasm_runtime_instantiate(ret_module_env.wasm_module, stack_size,
+                                 heap_size, error_buf, sizeof(error_buf));
+    if (!ret_module_env.wasm_module_inst) {
         memcpy(ret_module_env.error_buf, error_buf, 128);
         goto fail;
     }
 
-    exec_env = wasm_runtime_create_exec_env(wasm_module_inst, stack_size);
+    ret_module_env.exec_env = wasm_runtime_create_exec_env(
+        ret_module_env.wasm_module_inst, stack_size);
+    if (!ret_module_env.exec_env) {
+        goto fail;
+    }
 
+    return true;
 fail:
-    ret_module_env.exec_env = exec_env;
-    ret_module_env.wasm_module = wasm_module;
-    ret_module_env.wasm_module_inst = wasm_module_inst;
-    ret_module_env.wasm_file_buf = wasm_file_buf;
-
-    return ret_module_env;
+    destroy_module_env(ret_module_env);
+    return false;
 }
 
 void
@@ -99,38 +101,40 @@ test_shared_heap(WASMSharedHeap *shared_heap, const char *file,
     struct ret_env tmp_module_env;
     WASMFunctionInstanceCommon *func_test = nullptr;
     bool ret = false;
-    const char *exception = nullptr;
 
-    tmp_module_env = load_wasm((char *)file, 0);
+    if (!load_wasm((char *)file, 0, tmp_module_env)) {
+        ADD_FAILURE() << "Failed to load wasm file\n";
+        goto fail0;
+    }
 
     if (!wasm_runtime_attach_shared_heap(tmp_module_env.wasm_module_inst,
                                          shared_heap)) {
-        printf("Failed to attach shared heap\n");
-        goto test_failed;
+        ADD_FAILURE() << "Failed to attach shared heap\n";
+        goto fail1;
     }
+
     func_test = wasm_runtime_lookup_function(tmp_module_env.wasm_module_inst,
                                              func_name);
     if (!func_test) {
-        printf("\nFailed to wasm_runtime_lookup_function!\n");
-        goto test_failed;
+        ADD_FAILURE() << "Failed to wasm_runtime_lookup_function!\n";
+        goto fail2;
     }
 
     ret =
         wasm_runtime_call_wasm(tmp_module_env.exec_env, func_test, argc, argv);
     if (!ret) {
-        printf("\nFailed to wasm_runtime_call_wasm!\n");
         const char *s =
             wasm_runtime_get_exception(tmp_module_env.wasm_module_inst);
-        printf("exception: %s\n", s);
-        goto test_failed;
+        ADD_FAILURE() << "Failed to wasm_runtime_call_wasm with "
+                      << "exception: " << s;
     }
 
+fail2:
     wasm_runtime_detach_shared_heap(tmp_module_env.wasm_module_inst);
+fail1:
     destroy_module_env(tmp_module_env);
+fail0:
     return;
-test_failed:
-    destroy_module_env(tmp_module_env);
-    EXPECT_EQ(1, 0);
 }
 
 TEST_F(shared_heap_test, test_shared_heap_basic)
@@ -143,16 +147,13 @@ TEST_F(shared_heap_test, test_shared_heap_basic)
     shared_heap = wasm_runtime_create_shared_heap(&args);
 
     if (!shared_heap) {
-        printf("Failed to create shared heap\n");
-        EXPECT_EQ(1, 0);
+        FAIL() << "Failed to create shared heap";
     }
 
-    // test wasm
-    test_shared_heap(shared_heap, "test.wasm", "test", 1, argv);
+    test_shared_heap(shared_heap, "test.wasm", "test", 0, argv);
     EXPECT_EQ(10, argv[0]);
 
-    // test aot
-    test_shared_heap(shared_heap, "test.aot", "test", 1, argv);
+    test_shared_heap(shared_heap, "test.aot", "test", 0, argv);
     EXPECT_EQ(10, argv[0]);
 }
 
@@ -166,23 +167,169 @@ TEST_F(shared_heap_test, test_shared_heap_malloc_fail)
     shared_heap = wasm_runtime_create_shared_heap(&args);
 
     if (!shared_heap) {
-        printf("Failed to create shared heap\n");
-        EXPECT_EQ(1, 0);
+        FAIL() << "Failed to create shared heap";
     }
 
-    // test wasm
-    test_shared_heap(shared_heap, "test.wasm", "test_malloc_fail", 1, argv);
+    test_shared_heap(shared_heap, "test.wasm", "test_malloc_fail", 0, argv);
     EXPECT_EQ(1, argv[0]);
 
-    // test aot
-    test_shared_heap(shared_heap, "test.aot", "test_malloc_fail", 1, argv);
+    test_shared_heap(shared_heap, "test.aot", "test_malloc_fail", 0, argv);
     EXPECT_EQ(1, argv[0]);
 }
 
+TEST_F(shared_heap_test, test_preallocated_shared_heap_malloc_fail)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE];
+
+    /* create a preallocated shared heap */
+    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";
+    }
+
+    /* test wasm can't malloc with preallocated shared heap */
+    argv[0] = 1024;
+    test_shared_heap(shared_heap, "test.wasm", "my_shared_heap_malloc", 1,
+                     argv);
+    EXPECT_EQ(0, argv[0]);
+
+    argv[0] = 1024;
+    test_shared_heap(shared_heap, "test.aot", "my_shared_heap_malloc", 1, argv);
+    EXPECT_EQ(0, argv[0]);
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain_rmw)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap_chain = nullptr;
+    uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE] = { 0 },
+          preallocated_buf2[BUF_SIZE] = { 0 };
+    uint32 start1, end1, start2, end2;
+
+    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(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf2;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        FAIL() << "Create shared heap chain failed.\n";
+    }
+
+    /* app addr for shared heap */
+    start1 = 0xFFFFFFFF - 2 * BUF_SIZE + 1;
+    end1 = 0xFFFFFFFF - BUF_SIZE;
+    start2 = 0xFFFFFFFF - BUF_SIZE + 1;
+    end2 = 0xFFFFFFFF;
+
+    /* shared heap 1 */
+    argv[0] = end1;
+    argv[1] = 101;
+    test_shared_heap(shared_heap_chain, "test.wasm", "read_modify_write_8", 2,
+                     argv);
+    EXPECT_EQ(0, argv[0]);
+    EXPECT_EQ(preallocated_buf[BUF_SIZE - 1], 101);
+
+    /* shared heap 2 */
+    argv[0] = start2;
+    argv[1] = 129;
+    test_shared_heap(shared_heap_chain, "test.wasm", "read_modify_write_8", 2,
+                     argv);
+    EXPECT_EQ(0, argv[0]);
+    EXPECT_EQ(preallocated_buf2[0], 129);
+
+    /* TODO: test aot when chain is supported in AOT */
+    /*
+    argv[0] = start1;
+    argv[1] = 98;
+    test_shared_heap(shared_heap_chain, "test.aot", "read_modify_write_8", 2,
+                     argv);
+    EXPECT_EQ(0, argv[0]);
+    EXPECT_EQ(preallocated_buf[0], 98);
+
+    argv[0] = end2;
+    argv[1] = 81;
+    test_shared_heap(shared_heap_chain, "test.aot", "read_modify_write_8", 2,
+                     argv);
+    EXPECT_EQ(0, argv[0]);
+    EXPECT_EQ(preallocated_buf2[BUF_SIZE - 1], 81);
+    */
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain_rmw_oob)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap_chain = nullptr;
+    uint32 argv[2] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE];
+    uint32 start1, end1, start2, end2;
+
+    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(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf2;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        FAIL() << "Create shared heap chain failed.\n";
+    }
+
+    /* app addr for shared heap */
+    start1 = 0xFFFFFFFF - 2 * BUF_SIZE + 1;
+    end1 = 0xFFFFFFFF - BUF_SIZE;
+    start2 = 0xFFFFFFFF - BUF_SIZE + 1;
+    end2 = 0xFFFFFFFF;
+
+    /* try to rmw an u16, first u8 is in the first shared heap and second u8 is
+     * in the second shared heap, will be seen as oob */
+    argv[0] = end1;
+    argv[1] = 12025;
+    EXPECT_NONFATAL_FAILURE(test_shared_heap(shared_heap_chain, "test.wasm",
+                                             "read_modify_write_16", 2, argv),
+                            "Exception: out of bounds memory access");
+
+    /* TODO: test aot when chain is supported in AOT */
+    /*argv[0] = end1;
+    argv[1] = 12025;
+    EXPECT_NONFATAL_FAILURE(test_shared_heap(shared_heap_chain, "test.wasm",
+                                             "read_modify_write_16", 2, argv),
+                            "Exception: out of bounds memory access");*/
+}
+
 #ifndef native_function
 /* clang-format off */
 #define native_function(func_name, signature) \
-    { #func_name, (void *)glue_##func_name, signature, NULL }
+    { #func_name, (void *)glue_## func_name, signature, NULL }
 /* clang-format on */
 #endif
 #ifndef nitems
@@ -192,13 +339,13 @@ uintptr_t
 glue_test_addr_conv(wasm_exec_env_t env, uintptr_t addr)
 {
     wasm_module_inst_t module_inst = get_module_inst(env);
-    uintptr_t ret;
     void *native_addr = (void *)addr;
     uintptr_t app_addr = addr_native_to_app(native_addr);
 
     native_addr = addr_app_to_native(app_addr);
     if (native_addr != (void *)addr) {
-        EXPECT_EQ(1, 0);
+        ADD_FAILURE() << "address conversion incorrect";
+        return 0;
     }
     return app_addr;
 }
@@ -212,31 +359,370 @@ TEST_F(shared_heap_test, test_addr_conv)
     SharedHeapInitArgs args = { 0 };
     WASMSharedHeap *shared_heap = nullptr;
     uint32 argv[1] = { 0 };
-    struct ret_env tmp_module_env;
-    WASMFunctionInstanceCommon *func_test = nullptr;
     bool ret = false;
-    const char *exception = nullptr;
-    wasm_module_inst_t module_inst = tmp_module_env.wasm_module_inst;
 
     ret = wasm_native_register_natives("env", g_test_native_symbols,
                                        nitems(g_test_native_symbols));
     if (!ret) {
-        EXPECT_EQ(1, 0);
-        return;
+        FAIL() << "Failed to register natives";
+    }
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    test_shared_heap(shared_heap, "test_addr_conv.wasm", "test", 0, argv);
+    EXPECT_EQ(1, argv[0]);
+
+    test_shared_heap(shared_heap, "test_addr_conv.aot", "test", 0, argv);
+    EXPECT_EQ(1, argv[0]);
+}
+
+TEST_F(shared_heap_test, test_addr_conv_pre_allocated_oob)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize(),
+           app_addr = 0xFFFFFFFF - BUF_SIZE;
+    uint8 preallocated_buf[BUF_SIZE];
+    bool ret = false;
+
+    /* create a preallocated shared heap */
+    ret = wasm_native_register_natives("env", g_test_native_symbols,
+                                       nitems(g_test_native_symbols));
+    if (!ret) {
+        FAIL() << "Failed to register natives";
+    }
+
+    args.pre_allocated_addr = preallocated_buf;
+    args.size = BUF_SIZE;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    argv[0] = app_addr;
+    EXPECT_NONFATAL_FAILURE(test_shared_heap(shared_heap, "test_addr_conv.wasm",
+                                             "test_preallocated", 1, argv),
+                            "Exception: out of bounds memory access");
+
+    argv[0] = app_addr;
+    EXPECT_NONFATAL_FAILURE(test_shared_heap(shared_heap, "test_addr_conv.aot",
+                                             "test_preallocated", 1, argv),
+                            "Exception: out of bounds memory access");
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap_chain = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE];
+    bool ret = false;
+
+    ret = wasm_native_register_natives("env", g_test_native_symbols,
+                                       nitems(g_test_native_symbols));
+    if (!ret) {
+        FAIL() << "Failed to register natives";
+    }
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    /* create a preallocated shared heap */
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        FAIL() << "Create shared heap chain failed.\n";
+    }
+
+    test_shared_heap(shared_heap_chain, "test_addr_conv.wasm", "test", 0, argv);
+    EXPECT_EQ(1, argv[0]);
+
+    /* TODO: test aot when chain is supported in AOT */
+    /*test_shared_heap(shared_heap, "test_addr_conv.aot", "test", 1, argv);
+    EXPECT_EQ(1, argv[0]);*/
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain_create_fail)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap_chain = nullptr;
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    args.size = 4096;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
     }
 
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    EXPECT_EQ(shared_heap_chain, nullptr);
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain_create_fail2)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap_chain = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE];
+    struct ret_env tmp_module_env;
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap 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)) {
+        FAIL() << "Failed to attach shared heap\n";
+    }
+
+    /* can't create shared heap chain when shared heap is attached to a wasm
+     * app */
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    EXPECT_EQ(shared_heap_chain, nullptr);
+
+    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_create_fail3)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap3 = nullptr, *shared_heap_chain = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE];
+
+    args.size = 1024;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        FAIL() << "Create shared heap chain failed.\n";
+    }
+
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf2;
+    args.size = BUF_SIZE;
+    shared_heap3 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap3) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    /* The head and body can't be already in other shared heap chain as body */
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap3, shared_heap2);
+    EXPECT_EQ(shared_heap_chain, nullptr);
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap2, shared_heap);
+    EXPECT_EQ(shared_heap_chain, nullptr);
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain_unchain)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap3 = nullptr, *shared_heap_chain = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE], preallocated_buf2[BUF_SIZE];
+
     args.size = 1024;
     shared_heap = wasm_runtime_create_shared_heap(&args);
     if (!shared_heap) {
-        printf("Failed to create shared heap\n");
-        EXPECT_EQ(1, 0);
+        FAIL() << "Failed to create shared heap";
+    }
+
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        FAIL() << "Create shared heap chain failed.\n";
+    }
+
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf2;
+    args.size = BUF_SIZE;
+    shared_heap3 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap3) {
+        FAIL() << "Failed to create shared heap";
     }
 
-    // test wasm
-    test_shared_heap(shared_heap, "test_addr_conv.wasm", "test", 1, argv);
+    /* unchain shared heap so that the 'body' can be another chain 'body'
+     * again(1->2 to 1->3->2) */
+    EXPECT_EQ(shared_heap2,
+              wasm_runtime_unchain_shared_heaps(shared_heap_chain, false));
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap3, shared_heap2);
+    EXPECT_EQ(shared_heap_chain, shared_heap3);
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap3);
+    EXPECT_EQ(shared_heap, shared_heap_chain);
+
+    /* break down the entire shared heap chain */
+    EXPECT_EQ(shared_heap2,
+              wasm_runtime_unchain_shared_heaps(shared_heap_chain, true));
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap_chain = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE];
+    bool ret = false;
+
+    ret = wasm_native_register_natives("env", g_test_native_symbols,
+                                       nitems(g_test_native_symbols));
+    if (!ret) {
+        FAIL() << "Failed to register natives";
+    }
+
+    args.size = 4096;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    /* create a preallocated shared heap */
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        FAIL() << "Create shared heap chain failed.\n";
+    }
+
+    argv[0] = 0xFFFFFFFF;
+    test_shared_heap(shared_heap_chain, "test_addr_conv.wasm",
+                     "test_preallocated", 1, argv);
+    EXPECT_EQ(1, argv[0]);
+
+    argv[0] = 0xFFFFF000;
+    test_shared_heap(shared_heap_chain, "test_addr_conv.wasm",
+                     "test_preallocated", 1, argv);
     EXPECT_EQ(1, argv[0]);
 
-    // test aot
+    /* TODO: test aot when chain is supported in AOT */
+    /*argv[0] = 0xFFFFFFFF;
     test_shared_heap(shared_heap, "test_addr_conv.aot", "test", 1, argv);
     EXPECT_EQ(1, argv[0]);
+
+    argv[0] = 0xFFFFF000;
+    test_shared_heap(shared_heap, "test_addr_conv.aot", "test", 1, argv);
+    EXPECT_EQ(1, argv[0]); */
+}
+
+TEST_F(shared_heap_test, test_shared_heap_chain_addr_conv_oob)
+{
+    SharedHeapInitArgs args = { 0 };
+    WASMSharedHeap *shared_heap = nullptr, *shared_heap2 = nullptr,
+                   *shared_heap_chain = nullptr;
+    uint32 argv[1] = { 0 }, BUF_SIZE = os_getpagesize();
+    uint8 preallocated_buf[BUF_SIZE];
+    bool ret = false;
+
+    ret = wasm_native_register_natives("env", g_test_native_symbols,
+                                       nitems(g_test_native_symbols));
+    if (!ret) {
+        FAIL() << "Failed to register natives";
+    }
+
+    args.size = 4096;
+    shared_heap = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap) {
+        FAIL() << "Failed to create shared heap";
+    }
+
+    /* create a preallocated shared heap */
+    memset(&args, 0, sizeof(args));
+    args.pre_allocated_addr = preallocated_buf;
+    args.size = BUF_SIZE;
+    shared_heap2 = wasm_runtime_create_shared_heap(&args);
+    if (!shared_heap2) {
+        FAIL() << "Create preallocated shared heap failed.\n";
+    }
+
+    shared_heap_chain =
+        wasm_runtime_chain_shared_heaps(shared_heap, shared_heap2);
+    if (!shared_heap_chain) {
+        FAIL() << "Create shared heap chain failed.\n";
+    }
+
+    /* test wasm */
+    argv[0] = 0xFFFFFFFF - BUF_SIZE - 4096;
+    EXPECT_NONFATAL_FAILURE(test_shared_heap(shared_heap_chain,
+                                             "test_addr_conv.wasm",
+                                             "test_preallocated", 1, argv),
+                            "Exception: out of bounds memory access");
+
+    /* TODO: test aot when chain is supported in AOT */
+    /*argv[0] = 0xFFFFFFFF - BUF_SIZE - 4096;
+    EXPECT_NONFATAL_FAILURE(test_shared_heap(shared_heap_chain,
+                                             "test_addr_conv.aot",
+                                             "test_preallocated", 1, argv),
+                            "Exception: out of bounds memory access");*/
 }

tests/unit/shared-heap/wasm-apps/test.c

@@ -32,3 +32,31 @@ test_malloc_fail()
     shared_heap_free(ptr);
     return 0;
 }
+
+void *
+my_shared_heap_malloc(int size)
+{
+    return shared_heap_malloc(size);
+}
+
+void
+my_shared_heap_free(void *addr)
+{
+    shared_heap_free(addr);
+}
+
+char
+read_modify_write_8(char *addr, char value)
+{
+    char original_value = *addr;
+    *addr = value;
+    return original_value;
+}
+
+short
+read_modify_write_16(short *addr, short value)
+{
+    short original_value = *addr;
+    *addr = value;
+    return original_value;
+}

tests/unit/shared-heap/wasm-apps/test_addr_conv.c

@@ -30,3 +30,17 @@ test()
     shared_heap_free(ptr);
     return 1;
 }
+
+int
+test_preallocated(void *app_addr)
+{
+    int *ptr = (int *)app_addr;
+    int *ptr2 = NULL;
+
+    ptr2 = test_addr_conv(ptr);
+    if (ptr2 != ptr) {
+        return 0;
+    }
+
+    return 1;
+}