Possibility to change the stack size and code fix

Author: Lucas Paixão

src/buf/fixed/handle.rs

@@ -6,7 +6,7 @@ use std::cell::RefCell;
 use libc::iovec;
 use std::fmt::{self, Debug};
 use std::ops::{Deref, DerefMut};
-use std::rc::Rc;
+use std::sync::Arc;
 
 // Data to construct a `FixedBuf` handle from.
 pub(crate) struct CheckedOutBuf {
@@ -32,7 +32,7 @@ pub(crate) struct CheckedOutBuf {
 /// [`FixedBufPool`]:     super::FixedBufPool
 ///
 pub struct FixedBuf {
-  registry: Rc<RefCell<dyn FixedBuffers>>,
+  registry: Arc<RefCell<dyn FixedBuffers>>,
   buf: CheckedOutBuf,
 }
 
@@ -57,7 +57,7 @@ impl FixedBuf {
   // - the array will not be deallocated until the buffer is checked in;
   // - the data in the array must be initialized up to the number of bytes
   //   given in init_len.
-  pub(super) unsafe fn new(registry: Rc<RefCell<dyn FixedBuffers>>, buf: CheckedOutBuf) -> Self {
+  pub(super) unsafe fn new(registry: Arc<RefCell<dyn FixedBuffers>>, buf: CheckedOutBuf) -> Self {
     FixedBuf { registry, buf }
   }
 

src/buf/fixed/pool.rs

@@ -16,7 +16,6 @@ use crate::buf::fixed::handle::CheckedOutBuf;
 use crate::buf::fixed::plumbing::Pool;
 use crate::buf::fixed::shared::{process, register, unregister};
 use std::io;
-use std::rc::Rc;
 use std::sync::Arc;
 use tokio::pin;
 use tokio::sync::Notify;
@@ -95,7 +94,7 @@ use tokio::sync::Notify;
 /// ```
 #[derive(Clone)]
 pub struct FixedBufPool<T: IoBufMut> {
-  inner: RefCell<Rc<RefCell<plumbing::Pool<T>>>>,
+  inner: RefCell<Arc<RefCell<plumbing::Pool<T>>>>,
 }
 
 impl<T: IoBufMut> FixedBufPool<T> {
@@ -164,7 +163,7 @@ impl<T: IoBufMut> FixedBufPool<T> {
   /// ```
   pub fn new(bufs: impl IntoIterator<Item = T>) -> Self {
     FixedBufPool {
-      inner: RefCell::new(Rc::new(RefCell::new(Pool::new(bufs.into_iter())))),
+      inner: RefCell::new(Arc::new(RefCell::new(Pool::new(bufs.into_iter())))),
     }
   }
 
@@ -258,7 +257,7 @@ impl<T: IoBufMut> FixedBufPool<T> {
     self.next_when_notified(cap, notify).await
   }
 
-  fn get_fixed_buf(inner: Rc<RefCell<Pool<T>>>, data: CheckedOutBuf) -> FixedBuf {
+  fn get_fixed_buf(inner: Arc<RefCell<Pool<T>>>, data: CheckedOutBuf) -> FixedBuf {
     // Safety: the validity of buffer data is ensured by
     // plumbing::Pool::try_next
     unsafe { FixedBuf::new(inner, data) }

src/buf/fixed/registry.rs

@@ -5,7 +5,7 @@ use std::cell::RefCell;
 use crate::buf::fixed::shared::{process, register, unregister};
 use crate::buf::IoBufMut;
 use std::io;
-use std::rc::Rc;
+use std::sync::Arc;
 
 /// An indexed collection of I/O buffers pre-registered with the kernel.
 ///
@@ -31,7 +31,7 @@ use std::rc::Rc;
 /// [`Runtime`]: crate::Runtime
 #[derive(Clone)]
 pub struct FixedBufRegistry<T: IoBufMut> {
-  inner: RefCell<Rc<RefCell<plumbing::Registry<T>>>>,
+  inner: RefCell<Arc<RefCell<plumbing::Registry<T>>>>,
 }
 
 impl<T: IoBufMut> FixedBufRegistry<T> {
@@ -100,7 +100,7 @@ impl<T: IoBufMut> FixedBufRegistry<T> {
   /// ```
   pub fn new(bufs: impl IntoIterator<Item = T>) -> Self {
     FixedBufRegistry {
-      inner: RefCell::new(Rc::new(RefCell::new(plumbing::Registry::new(
+      inner: RefCell::new(Arc::new(RefCell::new(plumbing::Registry::new(
         bufs.into_iter(),
       )))),
     }

src/buf/fixed/shared.rs

@@ -3,10 +3,10 @@ use crate::buf::fixed::{FixedBuf, FixedBuffers};
 use crate::runtime::CONTEXT;
 use std::cell::RefCell;
 use std::io;
-use std::rc::Rc;
+use std::sync::Arc;
 
 pub(crate) fn process(
-  this: Rc<RefCell<dyn FixedBuffers>>,
+  this: Arc<RefCell<dyn FixedBuffers>>,
   cob: Option<CheckedOutBuf>,
 ) -> Option<FixedBuf> {
   cob.map(|data| {
@@ -16,7 +16,7 @@ pub(crate) fn process(
   })
 }
 
-pub(crate) fn register(this: Rc<RefCell<dyn FixedBuffers>>) -> io::Result<()> {
+pub(crate) fn register(this: Arc<RefCell<dyn FixedBuffers>>) -> io::Result<()> {
   CONTEXT.with(|x| x.handle().register_buffers(this))
 }
 

src/io/shared_fd.rs

@@ -1,15 +1,14 @@
 use std::future::poll_fn;
 
+use crate::runtime::driver::op::Op;
+use std::sync::Arc;
 use std::{
   cell::RefCell,
   io,
   os::unix::io::{FromRawFd, RawFd},
-  rc::Rc,
   task::Waker,
 };
 
-use crate::runtime::driver::op::Op;
-
 // Tracks in-flight operations on a file descriptor. Ensures all in-flight
 // operations complete before submitting the close.
 //
@@ -20,7 +19,7 @@ use crate::runtime::driver::op::Op;
 // Only the first close call returns the true result of closing the file descriptor.
 #[derive(Clone)]
 pub(crate) struct SharedFd {
-  inner: Rc<Inner>,
+  inner: Arc<Inner>,
 }
 
 unsafe impl Send for SharedFd {}
@@ -49,7 +48,7 @@ enum State {
 impl SharedFd {
   pub(crate) fn new(fd: RawFd) -> SharedFd {
     SharedFd {
-      inner: Rc::new(Inner {
+      inner: Arc::new(Inner {
         fd,
         state: RefCell::new(State::Init),
       }),
@@ -69,7 +68,7 @@ impl SharedFd {
     loop {
       // Get a mutable reference to Inner, indicating there are no
       // in-flight operations on the FD.
-      if let Some(inner) = Rc::get_mut(&mut self.inner) {
+      if let Some(inner) = Arc::get_mut(&mut self.inner) {
         // Wait for the close operation.
         return inner.async_close_op().await;
       }
@@ -84,7 +83,7 @@ impl SharedFd {
     use std::task::Poll;
 
     poll_fn(|cx| {
-      if Rc::<Inner>::strong_count(&self.inner) == 1 {
+      if Arc::<Inner>::strong_count(&self.inner) == 1 {
         return Poll::Ready(());
       }
 

src/runtime/context.rs

@@ -1,10 +1,8 @@
 use crate::runtime::driver::{Handle, WeakHandle};
-use std::cell::{Cell, OnceCell, RefCell, RefMut};
+use std::cell::{OnceCell, RefCell, RefMut};
 use std::ops::{Deref, DerefMut};
 use std::os::fd::{AsRawFd, RawFd};
 
-fn noop() {}
-
 pub(crate) struct RefOnceCell<T> {
   cell: OnceCell<T>,
 }
@@ -34,15 +32,13 @@ impl<T> DerefMut for RefOnceCell<T> {
 /// Owns the driver and resides in thread-local storage.
 pub(crate) struct RuntimeContext {
   driver: RefCell<RefOnceCell<Handle>>,
-  on_thread_park: Cell<fn()>,
 }
 
 impl RuntimeContext {
   /// Construct the context with an uninitialized driver.
   pub(crate) fn new() -> RuntimeContext {
     RuntimeContext {
       driver: RefCell::new(Default::default()),
-      on_thread_park: Cell::new(noop),
     }
   }
 
@@ -65,13 +61,10 @@ impl RuntimeContext {
     let _ = roc.flush();
   }
 
-  #[inline(always)]
-  pub(crate) fn call_on_thread_park(&self) {
-    self.on_thread_park.get()();
-  }
-
   pub(crate) fn set_on_thread_park(&self, callback: fn()) {
-    self.on_thread_park.set(callback)
+    let roc = unsafe { &*self.driver.as_ptr() };
+
+    roc.set_on_thread_park(callback)
   }
 
   /// Initialize the driver.

src/runtime/driver/handle.rs

@@ -20,12 +20,12 @@ use std::cell::RefCell;
 use std::io;
 use std::ops::Deref;
 use std::os::unix::io::{AsRawFd, RawFd};
-use std::rc::{Rc, Weak};
+use std::sync::{Arc, Weak};
 use std::task::{Context, Poll};
 
 #[derive(Clone)]
 pub(crate) struct Handle {
-  pub(super) inner: Rc<Driver>,
+  pub(super) inner: Arc<Driver>,
 }
 
 //SAFETY: Handle is only used in RuntimeContext,
@@ -45,7 +45,7 @@ unsafe impl Sync for WeakHandle {}
 impl Handle {
   pub(crate) fn new(b: &crate::Builder) -> io::Result<Self> {
     Ok(Self {
-      inner: Rc::new(Driver::new(b)?),
+      inner: Arc::new(Driver::new(b)?),
     })
   }
 
@@ -59,19 +59,27 @@ impl Handle {
   }
 
   pub(crate) fn flush(&self) -> io::Result<usize> {
-    self.inner.as_ref().uring.submit()
+    self.inner.as_ref().flush()
+  }
+
+  pub(crate) fn call_on_thread_park(&self) {
+    self.inner.as_ref().call_on_thread_park();
+  }
+
+  pub(crate) fn set_on_thread_park(&self, callback: fn()) {
+    self.inner.as_ref().set_on_thread_park(callback);
   }
 
   pub(crate) fn register_buffers(
     &mut self,
-    buffers: Rc<RefCell<dyn FixedBuffers>>,
+    buffers: Arc<RefCell<dyn FixedBuffers>>,
   ) -> io::Result<()> {
-    let inner = Rc::get_mut(&mut self.inner).unwrap();
+    let inner = Arc::get_mut(&mut self.inner).unwrap();
     inner.register_buffers(buffers)
   }
 
   pub(crate) fn unregister_buffers(&mut self) -> io::Result<()> {
-    let inner = Rc::get_mut(&mut self.inner).unwrap();
+    let inner = Arc::get_mut(&mut self.inner).unwrap();
     inner.unregister_buffers()
   }
 
@@ -152,7 +160,7 @@ impl AsRawFd for Handle {
 impl From<Driver> for Handle {
   fn from(driver: Driver) -> Self {
     Self {
-      inner: Rc::new(driver),
+      inner: Arc::new(driver),
     }
   }
 }
@@ -163,7 +171,7 @@ where
 {
   fn from(handle: T) -> Self {
     Self {
-      inner: Rc::downgrade(&handle.inner),
+      inner: Arc::downgrade(&handle.inner),
     }
   }
 }