Merge #602

602: C api extract instance context from instance r=bjfish a=YaronWittenstein

Here is an example of usage:
c9a9d56bd0/crates/svm-wasmer-c-api/examples/counter.c (L132)



Co-authored-by: Yaron Wittenstein <yaron.wittenstein@gmail.com>

lib/runtime-c-api/src/instance.rs

@@ -108,6 +108,19 @@ pub unsafe extern "C" fn wasmer_instantiate(
     wasmer_result_t::WASMER_OK
 }
 
+/// Extracts the instance's context and returns it.
+#[allow(clippy::cast_ptr_alignment)]
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_instance_context_get(
+    instance: *mut wasmer_instance_t,
+) -> *const wasmer_instance_context_t {
+    let instance_ref = &*(instance as *const Instance);
+
+    let ctx: *const Ctx = instance_ref.context() as *const _;
+
+    ctx as *const wasmer_instance_context_t
+}
+
 /// Calls an instances exported function by `name` with the provided parameters.
 /// Results are set using the provided `results` pointer.
 ///

lib/runtime-c-api/tests/.gitignore

@@ -22,4 +22,5 @@ test-module-exports
 test-module-imports
 test-module-serialize
 test-tables
-test-validate
+test-validate
+test-context

lib/runtime-c-api/tests/CMakeLists.txt

@@ -14,6 +14,7 @@ add_executable(test-module-imports test-module-imports.c)
 add_executable(test-module-serialize test-module-serialize.c)
 add_executable(test-tables test-tables.c)
 add_executable(test-validate test-validate.c)
+add_executable(test-context test-context.c)
 
 find_library(
         WASMER_LIB NAMES libwasmer_runtime_c_api.dylib libwasmer_runtime_c_api.so libwasmer_runtime_c_api.dll
@@ -87,3 +88,7 @@ add_test(test-tables test-tables)
 target_link_libraries(test-validate general ${WASMER_LIB})
 target_compile_options(test-validate PRIVATE ${COMPILER_OPTIONS})
 add_test(test-validate test-validate)
+
+target_link_libraries(test-context general ${WASMER_LIB})
+target_compile_options(test-context PRIVATE ${COMPILER_OPTIONS})
+add_test(test-context test-context)

lib/runtime-c-api/tests/assets/inc.wast

@@ -0,0 +1,7 @@
+(module
+  (func $inc (import "env" "inc"))
+  (func $get (import "env" "get") (result i32))
+
+  (func (export "inc_and_get") (result i32)
+      call $inc
+      call $get))

lib/runtime-c-api/tests/test-context.c

@@ -0,0 +1,126 @@
+#include <stdio.h>
+#include "../wasmer.h"
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+typedef struct {
+    int32_t amount;
+    int32_t value;
+} counter_data;
+
+typedef struct {
+    uint8_t* bytes;
+    long bytes_len;
+} wasm_file_t;
+
+wasm_file_t read_wasm_file(const char* file_name) {
+    wasm_file_t wasm_file;
+
+    FILE *file = fopen(file_name, "r");
+    fseek(file, 0, SEEK_END);
+    wasm_file.bytes_len = ftell(file);
+
+    wasm_file.bytes = malloc(wasm_file.bytes_len);
+    fseek(file, 0, SEEK_SET);
+    fread(wasm_file.bytes, 1, wasm_file.bytes_len, file);
+    fclose(file);
+
+    return wasm_file;
+}
+
+void inc_counter(wasmer_instance_context_t *ctx) {
+    counter_data* data = (counter_data*)wasmer_instance_context_data_get(ctx);
+    data->value = data->value + data->amount;
+}
+
+int32_t get_counter(wasmer_instance_context_t *ctx) {
+    counter_data* data = (counter_data*)wasmer_instance_context_data_get(ctx);
+    return data->value;
+}
+
+counter_data *init_counter(int32_t value, int32_t amount) {
+    counter_data* counter = malloc(sizeof(counter_data));
+    counter->value = value;
+    counter->amount = amount;
+    return counter;
+}
+
+void assert_counter(wasmer_instance_t *instance, int32_t expected) {
+    wasmer_value_t result_one;
+    wasmer_value_t params[] = {};
+    wasmer_value_t results[] = {result_one};
+
+    wasmer_result_t call1_result = wasmer_instance_call(instance, "inc_and_get", params, 0, results, 1);
+    printf("Call result:  %d\n", call1_result);
+    printf("Result: %d\n", results[0].value.I32);
+    assert(results[0].value.I32 == expected);
+    assert(call1_result == WASMER_OK);
+
+    const wasmer_instance_context_t *ctx = wasmer_instance_context_get(instance);
+    counter_data *cd = (counter_data*)wasmer_instance_context_data_get(ctx);
+    assert(cd->value == expected);
+}
+
+wasmer_import_t create_import(char* module_name, char* import_name, wasmer_import_func_t *func) {
+    wasmer_import_t import;
+    wasmer_byte_array module_name_bytes;
+    wasmer_byte_array import_name_bytes;
+
+    module_name_bytes.bytes = (const uint8_t *) module_name;
+    module_name_bytes.bytes_len = strlen(module_name);
+
+    import_name_bytes.bytes = (const uint8_t *) import_name;
+    import_name_bytes.bytes_len = strlen(import_name);
+
+    import.module_name = module_name_bytes;
+    import.import_name = import_name_bytes;
+
+    import.tag = WASM_FUNCTION;
+    import.value.func = func;
+
+    return import;
+}
+
+int main()
+{
+    // Prepare Imports
+    wasmer_value_tag inc_params_sig[] = {};
+    wasmer_value_tag inc_returns_sig[] = {};
+    wasmer_import_func_t *inc_func = wasmer_import_func_new((void (*)(void *)) inc_counter, inc_params_sig, 0, inc_returns_sig, 0);
+    wasmer_import_t inc_import = create_import("env", "inc", inc_func);
+
+    wasmer_value_tag get_params_sig[] = {};
+    wasmer_value_tag get_returns_sig[] = {WASM_I32};
+    wasmer_import_func_t *get_func = wasmer_import_func_new((void (*)(void *)) get_counter, get_params_sig, 0, get_returns_sig, 1);
+    wasmer_import_t get_import = create_import("env", "get", get_func);
+
+    wasmer_import_t imports[] = {inc_import, get_import};
+
+    // Read the wasm file
+    wasm_file_t wasm_file = read_wasm_file("assets/inc.wasm");
+
+    // Instantiate instance
+    printf("Instantiating\n");
+    wasmer_instance_t *instance = NULL;
+    wasmer_result_t compile_result = wasmer_instantiate(&instance, wasm_file.bytes, wasm_file.bytes_len, imports, 2);
+    printf("Compile result:  %d\n", compile_result);
+
+    // Init counter
+    counter_data *counter = init_counter(2, 5);
+    wasmer_instance_context_data_set(instance, counter);
+
+    // Run `instance.inc_and_get` and assert
+    assert_counter(instance, 7);
+    assert_counter(instance, 12);
+    assert_counter(instance, 17);
+
+    // Clear resources
+    wasmer_import_func_destroy(inc_func);
+    wasmer_import_func_destroy(get_func);
+    wasmer_instance_destroy(instance);
+    free(counter);
+    free(wasm_file.bytes);
+
+    return 0;
+}

lib/runtime-c-api/wasmer.h

@@ -417,6 +417,11 @@ void *wasmer_instance_context_data_get(const wasmer_instance_context_t *ctx);
  */
 void wasmer_instance_context_data_set(wasmer_instance_t *instance, void *data_ptr);
 
+/**
+ * Extracts the instance's context and returns it.
+ */
+const wasmer_instance_context_t *wasmer_instance_context_get(wasmer_instance_t *instance);
+
 /**
  * Gets the memory within the context at the index `memory_idx`.
  * The index is always 0 until multiple memories are supported.

lib/runtime-c-api/wasmer.hh

@@ -337,6 +337,9 @@ void *wasmer_instance_context_data_get(const wasmer_instance_context_t *ctx);
 /// passed to all imported function for instance.
 void wasmer_instance_context_data_set(wasmer_instance_t *instance, void *data_ptr);
 
+/// Extracts the instance's context and returns it.
+const wasmer_instance_context_t *wasmer_instance_context_get(wasmer_instance_t *instance);
+
 /// Gets the memory within the context at the index `memory_idx`.
 /// The index is always 0 until multiple memories are supported.
 const wasmer_memory_t *wasmer_instance_context_memory(const wasmer_instance_context_t *ctx,