Memory not shared between 2 modules

[IgorKhomenko]

Hello everyone,

I have 2 modules written in rust: one is with host functions (host_module) and another one is a user module (user_module) which calls functions from host module.

host_module

/// Allocate memory into the module's linear memory
/// and return the offset to the start of the block.
#[no_mangle]
pub fn alloc(len: usize) -> *mut u8 {
  // create a new mutable buffer with capacity `len`
  let mut buf = Vec::with_capacity(len);
  // take a mutable pointer to the buffer
  let ptr = buf.as_mut_ptr();
  // take ownership of the memory block and
  // ensure that its destructor is not
  // called when the object goes out of scope
  // at the end of the function

  println!("alloc: {:#?}", len);

  std::mem::forget(buf);
  // return the pointer so the runtime
  // can write data at this offset
  return ptr;
}

/// Given a pointer to the start of a byte array and
/// its length, return the sum of its elements.
#[no_mangle]
pub unsafe fn array_sum(ptr: *mut u8, len: usize) -> u8 {
    println!("array_sum: {:#?}", len);

    // create a Vec<u8> from the pointer to the
    // linear memory and the length
    let data = Vec::from_raw_parts(ptr, len, len);
    println!("array_sum data: {:#?}", data);

    // actually compute the sum and return it
    data.iter().sum()
}

#[no_mangle]
pub fn ping() {
  println!("pong");
}

user_module

#[no_mangle]
pub fn hello() {
  unsafe {
      // create a `Vec<u8>` as input
      let input = vec![1 as u8, 2, 3, 4, 5];

      // call the `alloc` function
      let ptr = host_module::alloc(input.len());
      let res: u8;

      // copy the contents of `input`into the buffer
      // returned by `alloc`
      std::ptr::copy(input.as_ptr(), ptr, input.len());
      // call the `array_sum` function with the pointer
      // and the length of the array
      res = host_module::array_sum(ptr, input.len());

      // print the result
      println!("Result: {:#?}", res);
  }
}

pub mod host_module {
  #[link(wasm_import_module = "host_module")]
  extern "C" {
    pub fn alloc(len: usize) -> *mut u8;
    pub fn array_sum(ptr: *mut u8, len: usize) -> u8;
  }
}

Both module are compiled using cargo build --release --target=wasm32-wasi

Also I have an app written in C and uses wasemde C SDK to run all this stuff inside wasmedge environment (main.cpp):

#include <iostream>
#include <wasmedge/wasmedge.h>
#include <stdio.h>
#include <string>
#include <sstream>

using namespace std;

int run(char *wasmFile, char *wasmFunction, int argc, char **argv, int preopenLen, const char *const *preopens) {
  /* Create the configure context and add the WASI support. */
  /* This step is not necessary unless you need WASI support. */
  WasmEdge_ConfigureContext *ConfCxt = WasmEdge_ConfigureCreate();
  WasmEdge_ConfigureAddHostRegistration(ConfCxt, WasmEdge_HostRegistration_Wasi);

  /* The configure and store context to the VM creation can be NULL. */
  WasmEdge_StoreContext *StoreCxt = WasmEdge_StoreCreate();
  WasmEdge_VMContext *VMCxt = WasmEdge_VMCreate(ConfCxt, StoreCxt);

  // add args/envs/preopens
  WasmEdge_ModuleInstanceContext *WasiCxt = WasmEdge_VMGetImportModuleContext(VMCxt, WasmEdge_HostRegistration_Wasi);
  WasmEdge_ModuleInstanceInitWASI(WasiCxt, argv, argc, NULL, 0, preopens, preopenLen);


  WasmEdge_Result Res;

  // connect host module
  //
  WasmEdge_String ModuleName = WasmEdge_StringCreateByCString("host_module");

  // // host functions written in rust
  Res = WasmEdge_VMRegisterModuleFromFile(VMCxt, ModuleName, "host_module/target/wasm32-wasi/release/host_module.wasm");

  if (!WasmEdge_ResultOK(Res)) {
    WasmEdge_VMDelete(VMCxt);
    printf("Register host functions error: %s\n", WasmEdge_ResultGetMessage(Res));
    return -1;
  }

  WasmEdge_StringDelete(ModuleName);
  //
  //

  // /* The parameters and returns arrays. */
  WasmEdge_Value Params[0];
  WasmEdge_Value Returns[0];
  // /* Function name. */
  WasmEdge_String FuncName = WasmEdge_StringCreateByCString(wasmFunction);


 /* Step 1: Load WASM file. */
  Res = WasmEdge_VMLoadWasmFromFile(VMCxt, wasmFile); 
 
  /*
   * Developers can load the WASM binary from buffer with the
   * `WasmEdge_VMLoadWasmFromBuffer()` API, or from
   * `WasmEdge_ASTModuleContext` object with the
   * `WasmEdge_VMLoadWasmFromASTModule()` API.
   */
  if (!WasmEdge_ResultOK(Res)) {
    printf("Loading phase failed: %s\n", WasmEdge_ResultGetMessage(Res));
    return 1;
  }
  /* Step 2: Validate the WASM module. */
  Res = WasmEdge_VMValidate(VMCxt);
  if (!WasmEdge_ResultOK(Res)) {
    printf("Validation phase failed: %s\n", WasmEdge_ResultGetMessage(Res));
    return 1;
  }
  /* Step 3: Instantiate the WASM module. */
  Res = WasmEdge_VMInstantiate(VMCxt);
  /*
   * Developers can load, validate, and instantiate another WASM module to
   * replace the instantiated one. In this case, the old module will be
   * cleared, but the registered modules are still kept.
   */
  if (!WasmEdge_ResultOK(Res)) {
    printf("Instantiation phase failed: %s\n",
           WasmEdge_ResultGetMessage(Res));
    return 1;
  }

   /*
   * Step 4: Execute WASM functions. You can execute functions repeatedly
   * after instantiation.
   */
  Res = WasmEdge_VMExecute(VMCxt, FuncName, Params, 0, Returns, 0);
  
  if (WasmEdge_ResultOK(Res)) {
    // printf("\nExecuted successfully\n");
  } else {
    printf("\nExecution phase failed: %s\n", WasmEdge_ResultGetMessage(Res));
  }

  
  /* Resources deallocations. */
  WasmEdge_VMDelete(VMCxt);
  WasmEdge_ConfigureDelete(ConfCxt);
  WasmEdge_StringDelete(FuncName);

  return 0;
}

int main(int argc, char **argv) {
  char *wasmFile = argv[1];
  char *wasmFunction = argv[2];

  run(wasmFile, wasmFunction, argc, argv, 0, NULL);

  return 0;
}

and a command to run it gcc main.cpp -lwasmedge && ./a.out user_module/target/wasm32-wasi/release/user_module.wasm hello

The idea of this is to be able to pass complex data from user module to host functions.
In my example, I'm trying to pass an array.

My current issue is that when I read an array at host module side, I read just zeroes.
So obviously the memory is not shared between 2 modules.

Is there anyone who could help me with this? Would be much appreciated

Repository link for better understanding and how to run https://github.com/IgorKhomenko/wasmedge-modules-complexdata-demo

[IgorKhomenko]

Solved an issue in another way.
Got rid of host_module and moved all the host functions implementation into main.cpp. Updated code is here https://github.com/IgorKhomenko/wasmedge-modules-complexdata-demo