feat(runtime-core) Support closures with a captured environment as host functions #925

Hywan · 2019-11-04T14:53:45Z

Reboot of #882 and #219.

For the moment, host functions (aka imported functions) can be regular function pointers, or (as a side-effect) closures without a captured environment. This PR extends the support of host functions to closures with a captured environment. This is required for many other features (incl. the Python integration, the Ruby integration, WebAssembly Interface Types [see #787], and so on).

This PR is the culmination of previous ones, notably #915, #916 and #917.

General idea

The user-defined host function is wrapped inside a wrap function. This wrapper function initially receives a vm::Ctx as its first argument, which is passed to the host function when necessary. The patch keeps this behavior but it comes from vm::FuncCtx, which is a new structure. A vm::FuncCtx is held by vm::ImportedFunc such as:

#[repr(C)]
pub struct ImportedFunc {
    pub(crate) func: *const Func,
    pub(crate) func_ctx: NonNull<FuncCtx>,
}

where vm::FuncCtx is:

#[repr(C)]
pub struct FuncCtx {
    pub(crate) vmctx: NonNull<Ctx>,
    pub(crate) func_env: Option<NonNull<FuncEnv>>,
}

where vm::FuncEnv is:

#[repr(transparent)]
pub struct FuncEnv(pub(self) *mut c_void);

i.e. a raw opaque pointer.

So the wrapper function of a host function receives a vm::Ctx, which is used to find out the associated FuncCtx (by using the import backing), which holds vm::FuncEnv. It holds a pointer to the closure captured environment.

Implementation details

How to get a pointer to a closure captured environment

A closure with a captured environment has a memory size greater than zero. This is how we detect it:

if mem::size_of::<Self>() != 0 { … }

To get a pointer to its captured environment, we use this statement:

NonNull::new(Box::into_raw(Box::new(self))).map(NonNull::cast)

(in typed_func.rs, in the wrap functions).

To reconstruct the closure based on the pointer, we use this statement:

let func: &FN = {
    let func: NonNull<FN> = func_env.cast();
    &*func.as_ptr()
};

That's basically how it works. And that's the core idea of this patch.

As a side effect, we have removed an undefined behavior (UB) in 2 places: The mem::transmute(&()) has been removed (it was used to get the function pointer of FN). The transmute is replaced by FuncEnv, which provides a unified API, erasing the difference between host functions as closures with a captured environment, and host functions as function pointer. For a reason I ignore, the UB wasn't showing himself until this PR and a modification in the Singlepass backend. But now it's fixed.

Impact on `Backing`

After the modification on the typed_func and the vm modules, this is the other core idea of this patch: Updating the backing module so that vm::ImportedFunc replaces vm::Ctx by vm::FuncCtx.

When creating vm::ImportedFunc, a new vm::FuncCtx is created and its pointer is used. We are purposely leaking vm::FuncCtx so that the pointer is always valid. Hence the specific Drop implementation on ImportBacking to dereference the pointer, and to drop it properly.

Impact on the backends

Since the structure of vm::ImportedFunc has changed, backends must be updated. We must deref FuncCtx to reach its vmctx field.

Impact on `Instance`

Because vm::ImportedFunc has changed, it has a minor impact on the instance module, nothing crazy though.

lib/runtime-core/src/backing.rs

lib/runtime-core-tests/tests/imports.rs

syrusakbary · 2019-11-04T18:33:48Z

Loving this PR ❤️

lachlansneff · 2019-11-05T05:43:29Z

Well done, Ivan 👍

`vm::FuncCtx` replaces `vm::Ctx` as first argument passed to host functions (aka imported functions).

…` pointers.

…ffset. `ImportedFunc::offset_vmctx` becomes `ImportedFunc::offset_func_ctx`.

…an host function.

In the `wrap` functions, we use `std::mem::transmute(&())` to get the pointer to the value “around” `wrap` (`Fn` has a method `to_raw` which declares a `wrap` function, which uses `transmute` to retrieve `Fn`). This is an undefined behavior. It was working until the `FuncCtx` is introduced. Since then, the undefined behavior was causing an error with the Singlepass backend. This patch stores the pointer to `Fn` in `func_env`, so that the pointer to the user-defined host function is always predictable.

Hywan · 2019-11-11T23:59:44Z

bors try

Hywan · 2019-11-12T00:06:44Z

Description updated!

Ready to review :-). cc @MarkMcCaskey @nlewycky

Hywan · 2019-11-12T00:11:02Z

bors try

bors · 2019-11-12T00:11:03Z

try

Already running a review

Hywan · 2019-11-12T00:11:50Z

bors try-

Hywan · 2019-11-12T00:12:54Z

bors try

bors · 2019-11-12T01:46:49Z

try

Build failed

wasmerio.wasmer

…ll` types. It fails only in release mode. That's a bug from the `field-offset` crate. This patch is a temporary fix.

Hywan · 2019-11-12T13:37:57Z

bors r+

925: feat(runtime-core) Support closures with a captured environment as host functions r=Hywan a=Hywan Reboot of #882 and #219. For the moment, host functions (aka imported functions) can be regular function pointers, or (as a side-effect) closures without a captured environment. This PR extends the support of host functions to closures with a captured environment. This is required for many other features (incl. the Python integration, the Ruby integration, WebAssembly Interface Types [see #787], and so on). This PR is the culmination of previous ones, notably #915, #916 and #917. ### General idea The user-defined host function is wrapped inside a `wrap` function. This wrapper function initially receives a `vm::Ctx` as its first argument, which is passed to the host function when necessary. The patch keeps this behavior but it comes from `vm::FuncCtx`, which is a new structure. A `vm::FuncCtx` is held by `vm::ImportedFunc` such as: ```rust #[repr(C)] pub struct ImportedFunc { pub(crate) func: *const Func, pub(crate) func_ctx: NonNull<FuncCtx>, } ``` where `vm::FuncCtx` is: ```rust #[repr(C)] pub struct FuncCtx { pub(crate) vmctx: NonNull<Ctx>, pub(crate) func_env: Option<NonNull<FuncEnv>>, } ``` where `vm::FuncEnv` is: ```rust #[repr(transparent)] pub struct FuncEnv(pub(self) *mut c_void); ``` i.e. a raw opaque pointer. So the wrapper function of a host function receives a `vm::Ctx`, which is used to find out the associated `FuncCtx` (by using the import backing), which holds `vm::FuncEnv`. It holds a pointer to the closure captured environment. ### Implementation details #### How to get a pointer to a closure captured environment A closure with a captured environment has a memory size greater than zero. This is how we detect it: ```rust if mem::size_of::<Self>() != 0 { … } ``` To get a pointer to its captured environment, we use this statement: ```rust NonNull::new(Box::into_raw(Box::new(self))).map(NonNull::cast) ``` (in `typed_func.rs`, in the `wrap` functions). To reconstruct the closure based on the pointer, we use this statement: ```rust let func: &FN = { let func: NonNull<FN> = func_env.cast(); &*func.as_ptr() }; ``` That's basically how it works. And that's the core idea of this patch. As a side effect, we have removed an undefined behavior (UB) in 2 places: The `mem::transmute(&())` has been removed (it was used to get the function pointer of `FN`). The transmute is replaced by `FuncEnv`, which provides a unified API, erasing the difference between host functions as closures with a captured environment, and host functions as function pointer. For a reason I ignore, the UB wasn't showing himself until this PR and a modification in the Singlepass backend. But now it's fixed. #### Impact on `Backing` After the modification on the `typed_func` and the `vm` modules, this is the other core idea of this patch: Updating the `backing` module so that `vm::ImportedFunc` replaces `vm::Ctx` by `vm::FuncCtx`. When creating `vm::ImportedFunc`, a new `vm::FuncCtx` is created and its pointer is used. We are purposely leaking `vm::FuncCtx` so that the pointer is always valid. Hence the specific `Drop` implementation on `ImportBacking` to dereference the pointer, and to drop it properly. #### Impact on the backends Since the structure of `vm::ImportedFunc` has changed, backends must be updated. We must deref `FuncCtx` to reach its `vmctx` field. #### Impact on `Instance` Because `vm::ImportedFunc` has changed, it has a minor impact on the `instance` module, nothing crazy though. Co-authored-by: Ivan Enderlin <[email protected]>

bors · 2019-11-12T14:13:35Z

Build failed

wasmerio.wasmer

It will be fixed in a following PR.

Hywan · 2019-11-12T14:18:30Z

I hope all bugs with field-offset are now fixed.

bors r+

925: feat(runtime-core) Support closures with a captured environment as host functions r=Hywan a=Hywan Reboot of #882 and #219. For the moment, host functions (aka imported functions) can be regular function pointers, or (as a side-effect) closures without a captured environment. This PR extends the support of host functions to closures with a captured environment. This is required for many other features (incl. the Python integration, the Ruby integration, WebAssembly Interface Types [see #787], and so on). This PR is the culmination of previous ones, notably #915, #916 and #917. ### General idea The user-defined host function is wrapped inside a `wrap` function. This wrapper function initially receives a `vm::Ctx` as its first argument, which is passed to the host function when necessary. The patch keeps this behavior but it comes from `vm::FuncCtx`, which is a new structure. A `vm::FuncCtx` is held by `vm::ImportedFunc` such as: ```rust #[repr(C)] pub struct ImportedFunc { pub(crate) func: *const Func, pub(crate) func_ctx: NonNull<FuncCtx>, } ``` where `vm::FuncCtx` is: ```rust #[repr(C)] pub struct FuncCtx { pub(crate) vmctx: NonNull<Ctx>, pub(crate) func_env: Option<NonNull<FuncEnv>>, } ``` where `vm::FuncEnv` is: ```rust #[repr(transparent)] pub struct FuncEnv(pub(self) *mut c_void); ``` i.e. a raw opaque pointer. So the wrapper function of a host function receives a `vm::Ctx`, which is used to find out the associated `FuncCtx` (by using the import backing), which holds `vm::FuncEnv`. It holds a pointer to the closure captured environment. ### Implementation details #### How to get a pointer to a closure captured environment A closure with a captured environment has a memory size greater than zero. This is how we detect it: ```rust if mem::size_of::<Self>() != 0 { … } ``` To get a pointer to its captured environment, we use this statement: ```rust NonNull::new(Box::into_raw(Box::new(self))).map(NonNull::cast) ``` (in `typed_func.rs`, in the `wrap` functions). To reconstruct the closure based on the pointer, we use this statement: ```rust let func: &FN = { let func: NonNull<FN> = func_env.cast(); &*func.as_ptr() }; ``` That's basically how it works. And that's the core idea of this patch. As a side effect, we have removed an undefined behavior (UB) in 2 places: The `mem::transmute(&())` has been removed (it was used to get the function pointer of `FN`). The transmute is replaced by `FuncEnv`, which provides a unified API, erasing the difference between host functions as closures with a captured environment, and host functions as function pointer. For a reason I ignore, the UB wasn't showing himself until this PR and a modification in the Singlepass backend. But now it's fixed. #### Impact on `Backing` After the modification on the `typed_func` and the `vm` modules, this is the other core idea of this patch: Updating the `backing` module so that `vm::ImportedFunc` replaces `vm::Ctx` by `vm::FuncCtx`. When creating `vm::ImportedFunc`, a new `vm::FuncCtx` is created and its pointer is used. We are purposely leaking `vm::FuncCtx` so that the pointer is always valid. Hence the specific `Drop` implementation on `ImportBacking` to dereference the pointer, and to drop it properly. #### Impact on the backends Since the structure of `vm::ImportedFunc` has changed, backends must be updated. We must deref `FuncCtx` to reach its `vmctx` field. #### Impact on `Instance` Because `vm::ImportedFunc` has changed, it has a minor impact on the `instance` module, nothing crazy though. Co-authored-by: Ivan Enderlin <[email protected]>

Hywan · 2019-11-12T14:18:53Z

bors r+

bors · 2019-11-12T14:18:54Z

Already running a review

bors · 2019-11-12T14:52:29Z

Build succeeded

wasmerio.wasmer

955: feat(runtime-core) Replace the `field-offset` crate by a custom `offset_of!` macro r=Hywan a=Hywan The `field-offset` crate is unmaintained. When using its `offset_of!` macro on a struct with a field of type `std::ptr::NonNull`, in release mode, it generates a sigill. This patch removes the `field-offset` crate, and implements a custom `offset_of!` macro. See #925 last commits to see an illustration of this bug. Co-authored-by: Ivan Enderlin <[email protected]>

Hywan added 📦 lib-compiler-cranelift About wasmer-compiler-cranelift 📦 lib-deprecated About the deprecated crates 📦 lib-spectests 📦 lib-compiler-llvm About wasmer-compiler-llvm labels Nov 4, 2019

syrusakbary reviewed Nov 4, 2019

View reviewed changes

lib/runtime-core/src/backing.rs Show resolved Hide resolved

syrusakbary reviewed Nov 4, 2019

View reviewed changes

lib/runtime-core-tests/tests/imports.rs Show resolved Hide resolved

Hywan added 🎉 enhancement New feature! 🧪 tests I love tests and removed 📦 lib-spectests labels Nov 4, 2019

Hywan added 18 commits November 6, 2019 14:48

feat(runtime-core) Introduce vm::FuncCtx.

177c507

`vm::FuncCtx` replaces `vm::Ctx` as first argument passed to host functions (aka imported functions).

feat(runtime-core) vm::ImportedFunc and vm::FuncCtx have `NonNull…

e002c37

…` pointers.

feat(runtime-core,clif-backend,llvm-backend) Rename an ImportFunc o…

6035bd2

…ffset. `ImportedFunc::offset_vmctx` becomes `ImportedFunc::offset_func_ctx`.

test(runtime-core) Test more host functions as closures.

0e27f2f

!temp

2a041f8

chore(runtime-core) Remove dbg!.

3b34a91

test(runtime-core) Test closures with a captured environment.

a52b4b2

test(runtime-core) Extract assert as tests.

3435ce4

doc(runtime-core) Write more documentation.

81326ce

doc(runtime-core) Write more documentation.

0f82cd3

doc(runtime-core) Write more documentation.

293b71a

test(runtime-core) Write more documentation.

a9e0e9b

Merge branch 'master' into feat-runtime-core-clos-host-function

215e445

feat(singlepass-backend) Inject FuncCtx to the function pointer of …

a4ba429

…an host function.

doc(runtime-core) Fix inline documentations.

5ccaf12

test(runtime-core) Remove a warning in tests.

6f84a6f

Merge branch 'master' into feat-runtime-core-clos-host-function

cf74b68

Hywan force-pushed the feat-runtime-core-clos-host-function branch from 8b185ae to cf74b68 Compare November 6, 2019 13:50

Hywan added 3 commits November 12, 2019 00:55

Merge branch 'master' into feat-runtime-core-clos-host-function

9570616

chore(changelog) Fix CS.

f002f03

Merge branch 'master' into feat-runtime-core-clos-host-function

cf33bf8

bors bot added a commit that referenced this pull request Nov 11, 2019

Try #925:

8ca06d1

doc(runtime-core) Add missing doc on vm::FuncCtx.

22abd8e

bors bot added a commit that referenced this pull request Nov 12, 2019

Try #925:

66a4614

bjfish approved these changes Nov 12, 2019

View reviewed changes

Hywan added 3 commits November 12, 2019 14:34

test(runtime-core) offset_of! fails with a struct containing `NonNu…

0de7f4f

…ll` types. It fails only in release mode. That's a bug from the `field-offset` crate. This patch is a temporary fix.

Merge branch 'master' into feat-runtime-core-clos-host-function

89859a9

doc(changelog) Fix last release number, and fix CS.

5d6c74b

fix(runtime-core) Same bug with field-offset as before.

a1e8a8f

It will be fixed in a following PR.

Hywan mentioned this pull request Nov 12, 2019

feat(runtime-core) Replace the field-offset crate by a custom offset_of! macro #955

Merged

bors bot merged commit a1e8a8f into wasmerio:master Nov 12, 2019

codefishd mentioned this pull request Nov 20, 2019

How to embed in C++? How to store secret state? bytecodealliance/wasmtime#610

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

feat(runtime-core) Support closures with a captured environment as host functions #925

feat(runtime-core) Support closures with a captured environment as host functions #925

Hywan commented Nov 4, 2019 •

edited

Loading

syrusakbary commented Nov 4, 2019

lachlansneff commented Nov 5, 2019

Hywan commented Nov 11, 2019

Hywan commented Nov 12, 2019

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

Hywan commented Nov 12, 2019

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

Hywan commented Nov 12, 2019

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

bors bot commented Nov 12, 2019

feat(runtime-core) Support closures with a captured environment as host functions #925

feat(runtime-core) Support closures with a captured environment as host functions #925

Conversation

Hywan commented Nov 4, 2019 • edited Loading

General idea

Implementation details

How to get a pointer to a closure captured environment

Impact on Backing

Impact on the backends

Impact on Instance

syrusakbary commented Nov 4, 2019

lachlansneff commented Nov 5, 2019

Hywan commented Nov 11, 2019

Hywan commented Nov 12, 2019

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

try

Hywan commented Nov 12, 2019

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

try

Build failed

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

Build failed

Hywan commented Nov 12, 2019

Hywan commented Nov 12, 2019

bors bot commented Nov 12, 2019

bors bot commented Nov 12, 2019

Build succeeded

Hywan commented Nov 4, 2019 •

edited

Loading

Impact on `Backing`

Impact on `Instance`