Skip to content

Initial support for futures/streams in wit-dylib #2324

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
wants to merge 1 commit into
base: main
Choose a base branch
from
Draft

Initial support for futures/streams in wit-dylib #2324

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
117 changes: 4 additions & 113 deletions Cargo.lock
View file
Open in desktop

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

77 changes: 27 additions & 50 deletions crates/wit-component/src/dummy.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
use wit_parser::abi::WasmType;
use wit_parser::{
Function, LiftLowerAbi, ManglingAndAbi, Resolve, ResourceIntrinsic, TypeDefKind, TypeId,
WasmExport, WasmExportKind, WasmImport, WorldId, WorldItem, WorldKey,
AsyncIntrinsic, Function, LiftLowerAbi, ManglingAndAbi, Resolve, ResourceIntrinsic,
TypeDefKind, TypeId, WasmExport, WasmExportKind, WasmImport, WorldId, WorldItem, WorldKey,
};

/// Generate a dummy implementation core Wasm module for a given WIT document
Expand Down Expand Up @@ -98,7 +98,7 @@ fn push_imported_func(
wat.push_str("))\n");

if mangling.is_async() {
push_imported_future_and_stream_intrinsics(wat, resolve, "", interface, func);
push_imported_future_and_stream_intrinsics(wat, resolve, interface, func, false, mangling);
}
}

Expand Down Expand Up @@ -156,67 +156,44 @@ fn push_exported_func_intrinsics(
push_tys(wat, "result", &sig.results);
wat.push_str("))\n");

push_imported_future_and_stream_intrinsics(wat, resolve, "[export]", interface, func);
push_imported_future_and_stream_intrinsics(wat, resolve, interface, func, true, mangling);
}

fn push_imported_future_and_stream_intrinsics(
wat: &mut String,
resolve: &Resolve,
module_prefix: &str,
interface: Option<&WorldKey>,
func: &Function,
export: bool,
mangling: ManglingAndAbi,
) {
let module = match interface {
Some(key) => format!("{module_prefix}{}", resolve.name_world_key(key)),
None => format!("{module_prefix}$root"),
};
let name = &func.name;

for (i, id) in func
.find_futures_and_streams(resolve)
.into_iter()
.enumerate()
{
match &resolve.types[id].kind {
TypeDefKind::Future(_) => {
wat.push_str(&format!(
r#"
(import {module:?} "[future-new-{i}]{name}" (func (result i64)))
(import {module:?} "[future-read-{i}]{name}" (func (param i32 i32) (result i32)))
(import {module:?} "[future-write-{i}]{name}" (func (param i32 i32) (result i32)))
(import {module:?} "[future-cancel-read-{i}]{name}" (func (param i32) (result i32)))
(import {module:?} "[future-cancel-write-{i}]{name}" (func (param i32) (result i32)))
(import {module:?} "[future-drop-readable-{i}]{name}" (func (param i32)))
(import {module:?} "[future-drop-writable-{i}]{name}" (func (param i32)))
(import {module:?} "[async-lower][future-read-{i}]{name}" (func (param i32 i32) (result i32)))
(import {module:?} "[async-lower][future-write-{i}]{name}" (func (param i32 i32) (result i32)))

;; deferred behind 🚝
;;(import {module:?} "[async-lower][future-cancel-read-{i}]{name}" (func (param i32) (result i32)))
;;(import {module:?} "[async-lower][future-cancel-write-{i}]{name}" (func (param i32) (result i32)))
"#
));
}
TypeDefKind::Stream(_) => {
wat.push_str(&format!(
r#"
(import {module:?} "[stream-new-{i}]{name}" (func (result i64)))
(import {module:?} "[stream-read-{i}]{name}" (func (param i32 i32 i32) (result i32)))
(import {module:?} "[stream-write-{i}]{name}" (func (param i32 i32 i32) (result i32)))
(import {module:?} "[stream-cancel-read-{i}]{name}" (func (param i32) (result i32)))
(import {module:?} "[stream-cancel-write-{i}]{name}" (func (param i32) (result i32)))
(import {module:?} "[stream-drop-readable-{i}]{name}" (func (param i32)))
(import {module:?} "[stream-drop-writable-{i}]{name}" (func (param i32)))
(import {module:?} "[async-lower][stream-read-{i}]{name}" (func (param i32 i32 i32) (result i32)))
(import {module:?} "[async-lower][stream-write-{i}]{name}" (func (param i32 i32 i32) (result i32)))

;; deferred behind 🚝
;;(import {module:?} "[async-lower][stream-cancel-read-{i}]{name}" (func (param i32) (result i32)))
;;(import {module:?} "[async-lower][stream-cancel-write-{i}]{name}" (func (param i32) (result i32)))
"#
));
}
let is_future = match &resolve.types[id].kind {
TypeDefKind::Future(_) => true,
TypeDefKind::Stream(_) => false,
_ => unreachable!(),
};
for intrinsic in AsyncIntrinsic::ALL.iter().copied() {
let (module, name) = resolve.wasm_import_name(
mangling,
WasmImport::AsyncIntrinsic {
interface,
func,
intrinsic,
index: i,
is_future,
export,
},
);
let sig = intrinsic.signature(is_future);
wat.push_str(&format!("(import {module:?} {name:?} (func"));
push_tys(wat, "param", &sig.params);
push_tys(wat, "result", &sig.results);
wat.push_str("))\n");
}
}
}
Expand Down
50 changes: 50 additions & 0 deletions crates/wit-dylib/ffi/src/ffi.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -166,20 +166,70 @@ pub struct wit_fixed_size_list {
pub ty: wit_type_t,
}
pub type wit_fixed_size_list_t = wit_fixed_size_list;
pub type wit_async_type_lift_t = ::std::option::Option<
unsafe extern "C" fn(cx: *mut ::std::os::raw::c_void, ptr: *const ::std::os::raw::c_void),
>;
pub type wit_async_type_lower_t = ::std::option::Option<
unsafe extern "C" fn(cx: *mut ::std::os::raw::c_void, ptr: *mut ::std::os::raw::c_void),
>;
pub type wit_future_new_t = ::std::option::Option<unsafe extern "C" fn() -> u64>;
pub type wit_future_read_t = ::std::option::Option<
unsafe extern "C" fn(handle: u32, ptr: *mut ::std::os::raw::c_void) -> u32,
>;
pub type wit_future_write_t = ::std::option::Option<
unsafe extern "C" fn(handle: u32, ptr: *const ::std::os::raw::c_void) -> u32,
>;
pub type wit_future_cancel_t = ::std::option::Option<unsafe extern "C" fn(handle: u32) -> u32>;
pub type wit_future_drop_t = ::std::option::Option<unsafe extern "C" fn(handle: u32)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wit_future {
pub interface: *const ::std::os::raw::c_char,
pub name: *const ::std::os::raw::c_char,
pub ty: wit_type_t,
pub new: wit_future_new_t,
pub read_async: wit_future_read_t,
pub write_async: wit_future_write_t,
pub read_sync: wit_future_read_t,
pub write_sync: wit_future_write_t,
pub cancel_read: wit_future_cancel_t,
pub cancel_write: wit_future_cancel_t,
pub drop_read: wit_future_drop_t,
pub drop_write: wit_future_drop_t,
pub lift: wit_async_type_lift_t,
pub lower: wit_async_type_lower_t,
pub elem_size: usize,
pub elem_align: usize,
}
pub type wit_future_t = wit_future;
pub type wit_stream_new_t = ::std::option::Option<unsafe extern "C" fn() -> u64>;
pub type wit_stream_read_t = ::std::option::Option<
unsafe extern "C" fn(handle: u32, ptr: *mut ::std::os::raw::c_void, len: usize) -> u32,
>;
pub type wit_stream_write_t = ::std::option::Option<
unsafe extern "C" fn(handle: u32, ptr: *const ::std::os::raw::c_void, len: usize) -> u32,
>;
pub type wit_stream_cancel_t = ::std::option::Option<unsafe extern "C" fn(handle: u32) -> u32>;
pub type wit_stream_drop_t = ::std::option::Option<unsafe extern "C" fn(handle: u32)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct wit_stream {
pub interface: *const ::std::os::raw::c_char,
pub name: *const ::std::os::raw::c_char,
pub ty: wit_type_t,
pub new: wit_stream_new_t,
pub read_async: wit_stream_read_t,
pub write_async: wit_stream_write_t,
pub read_sync: wit_stream_read_t,
pub write_sync: wit_stream_write_t,
pub cancel_read: wit_stream_cancel_t,
pub cancel_write: wit_stream_cancel_t,
pub drop_read: wit_stream_drop_t,
pub drop_write: wit_stream_drop_t,
pub lift: wit_async_type_lift_t,
pub lower: wit_async_type_lower_t,
pub elem_size: usize,
pub elem_align: usize,
}
pub type wit_stream_t = wit_stream;
#[repr(C)]
Expand Down
Loading
Loading