Merge pull request #141 from alexcrichton/fix-waitable-set-poll

Update ABI of `waitable-set.poll`

Author: alexcrichton

crates/test-programs/src/async_.rs

@@ -42,13 +42,10 @@ unsafe extern "C" {
     pub fn waitable_set_poll_raw(_: u32, _: *mut u32) -> u32;
 }
 
-pub fn waitable_set_poll(set: u32) -> Option<(u32, u32, u32)> {
-    let mut payload = [0u32; 3];
-    if unsafe { waitable_set_poll_raw(set, payload.as_mut_ptr()) } != 0 {
-        Some((payload[0], payload[1], payload[2]))
-    } else {
-        None
-    }
+pub fn waitable_set_poll(set: u32) -> (u32, u32, u32) {
+    let mut payload = [0u32; 2];
+    let ret0 = unsafe { waitable_set_poll_raw(set, payload.as_mut_ptr()) };
+    (ret0, payload[0], payload[1])
 }
 
 #[cfg(target_arch = "wasm32")]

crates/test-programs/src/bin/async_poll_synchronous.rs

@@ -13,7 +13,7 @@ use {
     bindings::{exports::local::local::run::Guest, local::local::ready},
     test_programs::async_::{
         subtask_drop, waitable_join, waitable_set_drop, waitable_set_new, waitable_set_poll,
-        EVENT_SUBTASK, STATUS_RETURNED,
+        EVENT_NONE, EVENT_SUBTASK, STATUS_RETURNED,
     },
 };
 
@@ -43,32 +43,30 @@ impl Guest for Component {
 
             let set = waitable_set_new();
 
-            assert!(waitable_set_poll(set).is_none());
+            assert_eq!(waitable_set_poll(set), (EVENT_NONE, 0, 0));
 
             let result = async_when_ready();
             let status = result & 0xf;
             let call = result >> 4;
             assert!(status != STATUS_RETURNED);
             waitable_join(call, set);
 
-            assert!(waitable_set_poll(set).is_none());
+            assert_eq!(waitable_set_poll(set), (EVENT_NONE, 0, 0));
 
             ready::set_ready(true);
 
-            let Some((event, task, code)) = waitable_set_poll(set) else {
-                panic!()
-            };
+            let (event, task, code) = waitable_set_poll(set);
             assert_eq!(event, EVENT_SUBTASK);
             assert_eq!(call, task);
             assert_eq!(code, STATUS_RETURNED);
 
             subtask_drop(task);
 
-            assert!(waitable_set_poll(set).is_none());
+            assert_eq!(waitable_set_poll(set), (EVENT_NONE, 0, 0));
 
             assert!(async_when_ready() == STATUS_RETURNED);
 
-            assert!(waitable_set_poll(set).is_none());
+            assert_eq!(waitable_set_poll(set), (EVENT_NONE, 0, 0));
 
             waitable_set_drop(set);
         }

crates/wasmtime/src/runtime/component/concurrent.rs

@@ -2335,50 +2335,34 @@ impl ComponentInstance {
                     (store, options)
                 };
 
-                if wait {
+                let (ordinal, handle, result) = if wait {
                     self.get_mut(params.set)?.waiting.remove(&guest_task);
-
                     let (event, handle) =
                         event_and_handle.ok_or_else(|| anyhow!("no waitables to wait for"))?;
-
                     let (ordinal, result) = event.parts();
-                    let (store, options) = store_and_options(self);
-                    let ptr = func::validate_inbounds::<(u32, u32)>(
-                        options.memory_mut(store),
-                        &ValRaw::u32(params.payload),
-                    )?;
-                    options.memory_mut(store)[ptr + 0..][..4]
-                        .copy_from_slice(&handle.to_le_bytes());
-                    options.memory_mut(store)[ptr + 4..][..4]
-                        .copy_from_slice(&result.to_le_bytes());
-
-                    Ok(ordinal)
+                    (ordinal, handle, result)
                 } else {
                     if let Some((event, handle)) = event_and_handle {
                         let (ordinal, result) = event.parts();
-                        let (store, options) = store_and_options(self);
-                        let ptr = func::validate_inbounds::<(u32, u32, u32)>(
-                            options.memory_mut(store),
-                            &ValRaw::u32(params.payload),
-                        )?;
-                        options.memory_mut(store)[ptr + 0..][..4]
-                            .copy_from_slice(&ordinal.to_le_bytes());
-                        options.memory_mut(store)[ptr + 4..][..4]
-                            .copy_from_slice(&handle.to_le_bytes());
-                        options.memory_mut(store)[ptr + 8..][..4]
-                            .copy_from_slice(&result.to_le_bytes());
-
-                        Ok(1)
+                        (ordinal, handle, result)
                     } else {
                         log::trace!(
                             "no events ready to deliver via waitable-set.poll to {}; set {}",
                             guest_task.rep(),
                             params.set.rep()
                         );
-
-                        Ok(0)
+                        let (ordinal, result) = Event::None.parts();
+                        (ordinal, 0, result)
                     }
-                }
+                };
+                let (store, options) = store_and_options(self);
+                let ptr = func::validate_inbounds::<(u32, u32)>(
+                    options.memory_mut(store),
+                    &ValRaw::u32(params.payload),
+                )?;
+                options.memory_mut(store)[ptr + 0..][..4].copy_from_slice(&handle.to_le_bytes());
+                options.memory_mut(store)[ptr + 4..][..4].copy_from_slice(&result.to_le_bytes());
+                Ok(ordinal)
             }
             WaitableCheck::Yield => Ok(0),
         };