address Noa's review comments

Author: Centril

crates/core/src/host/wasmtime/mod.rs

@@ -62,7 +62,9 @@ impl WasmtimeRuntime {
             .async_support(true);
 
         #[cfg(unix)]
-        config.with_host_stack(self::pooling_stack_creator::PoolingStackCreator::new());
+        config
+            .async_stack_size(self::pooling_stack_creator::ASYNC_STACK_SIZE)
+            .with_host_stack(self::pooling_stack_creator::PoolingStackCreator::new());
 
         // Offer a compile-time flag for enabling perfmap generation,
         // so `perf` can display JITted symbol names.

crates/core/src/host/wasmtime/pooling_stack_creator.rs

@@ -1,16 +1,19 @@
-use core::mem::{ManuallyDrop, MaybeUninit};
+use core::mem::ManuallyDrop;
 use crossbeam_queue::ArrayQueue;
 use std::sync::{Arc, Weak};
 use wasmtime::{StackCreator, StackMemory};
 use wasmtime_internal_fiber::FiberStack;
 
+/// The stack size for async stacks.
+pub const ASYNC_STACK_SIZE: usize = 2 << 20;
+
 pub struct PoolingStackCreator {
     /// The actual pool of stacks.
     pool: ArrayQueue<FiberStack>,
     /// A weak reference to `self` that can be cloned
     /// and put into a `PooledFiberStack` which uses `weak` on drop.
     /// We do it self-referentially so that we can avoid another indirection.
-    weak: MaybeUninit<Weak<PoolingStackCreator>>,
+    weak: Weak<PoolingStackCreator>,
 }
 
 struct PooledFiberStack {
@@ -33,19 +36,21 @@ impl Drop for PooledFiberStack {
     }
 }
 
+const UNIX_SOME: &str = "FiberStack on unix always returns `Some(_)`";
+
 /// SAFETY: The implementation forwards to `FiberStack as StackMemory`,
 /// which wasmtime promises to be sound.
 unsafe impl StackMemory for PooledFiberStack {
     fn top(&self) -> *mut u8 {
-        self.stack.top().unwrap()
+        self.stack.top().expect(UNIX_SOME)
     }
 
     fn range(&self) -> std::ops::Range<usize> {
-        self.stack.range().unwrap()
+        self.stack.range().expect(UNIX_SOME)
     }
 
     fn guard_range(&self) -> std::ops::Range<*mut u8> {
-        self.stack.guard_range().unwrap()
+        self.stack.guard_range().expect(UNIX_SOME)
     }
 }
 
@@ -54,15 +59,17 @@ unsafe impl StackMemory for PooledFiberStack {
 // and are not modified elsewhere.
 unsafe impl StackCreator for PoolingStackCreator {
     fn new_stack(&self, size: usize, zeroed: bool) -> anyhow::Result<Box<dyn wasmtime::StackMemory>, anyhow::Error> {
+        debug_assert_eq!(size, ASYNC_STACK_SIZE);
+
         // SAFETY: `self.weak` is fully initialized whenever `new_stack` is called.
-        let weak = unsafe { self.weak.assume_init_ref() }.clone();
+        let weak = self.weak.clone();
 
         // Either take the stack from the pool
         // or fall back to creating a new one.
         let stack = weak
             .upgrade()
             .and_then(|pool| pool.pool.pop().map(Ok))
-            .unwrap_or_else(|| FiberStack::new(size, zeroed))?;
+            .unwrap_or_else(|| FiberStack::new(ASYNC_STACK_SIZE, zeroed))?;
 
         // Ship it.
         let stack = ManuallyDrop::new(stack);
@@ -74,7 +81,7 @@ impl PoolingStackCreator {
     pub fn new() -> Arc<Self> {
         Arc::new_cyclic(|weak| {
             let pool = ArrayQueue::new(100);
-            let weak = MaybeUninit::new(weak.clone());
+            let weak = weak.clone();
             Self { pool, weak }
         })
     }