[feat] mutex + fiber + thread + io || DRAFT

.github/.agp

@@ -0,0 +1,6 @@
+
+Auto Github Push (AGP)
+https://github.com/ms-jpq/auto-github-push
+
+---
+2023-08-22 05:28

src/block.rs

@@ -301,11 +301,7 @@ impl TryConvert for Proc {
 ///
 /// This effectivly makes the closure's lifetime managed by Ruby. It will be
 /// dropped when the returned `Value` is garbage collected.
-fn wrap_closure<F, R>(func: F) -> (*mut F, Value)
-where
-    F: FnMut(&[Value], Option<Proc>) -> R,
-    R: BlockReturn,
-{
+pub(crate) fn wrap_closure<F>(func: F) -> (*mut F, Value) {
     struct Closure();
     impl DataTypeFunctions for Closure {}
     let data_type = memoize!(DataType: {

src/error.rs

@@ -1,10 +1,12 @@
 //! Rust types for working with Ruby Exceptions and other interrupts.
 
-use std::{any::Any, borrow::Cow, ffi::CString, fmt, mem::transmute, ops::Deref, os::raw::c_int};
+use std::{
+    any::Any, borrow::Cow, ffi::CString, fmt, mem::transmute, ops::Deref, os::raw::c_int, ptr::null,
+};
 
 use crate::ruby_sys::{
     rb_bug, rb_ensure, rb_errinfo, rb_exc_raise, rb_iter_break, rb_iter_break_value, rb_jump_tag,
-    rb_protect, rb_raise, rb_set_errinfo, rb_warning, ruby_special_consts, VALUE,
+    rb_protect, rb_raise, rb_set_errinfo, rb_sys_fail, rb_warning, ruby_special_consts, VALUE,
 };
 
 use crate::{
@@ -92,6 +94,15 @@ impl Error {
         };
         Self::Error(exception::fatal(), msg)
     }
+
+    /// Akin to io::Error::last_os_error()
+    pub(crate) fn last_os_error() -> Self {
+        protect(|| {
+            unsafe { rb_sys_fail(null()) };
+            Value::default()
+        })
+        .unwrap_err()
+    }
 }
 
 impl fmt::Display for Error {

src/exception.rs

@@ -2,14 +2,18 @@
 
 use std::{fmt, ops::Deref};
 
-use crate::ruby_sys::{
-    rb_eArgError, rb_eEOFError, rb_eEncCompatError, rb_eEncodingError, rb_eException, rb_eFatal,
-    rb_eFloatDomainError, rb_eFrozenError, rb_eIOError, rb_eIndexError, rb_eInterrupt,
-    rb_eKeyError, rb_eLoadError, rb_eLocalJumpError, rb_eMathDomainError, rb_eNameError,
-    rb_eNoMemError, rb_eNoMethodError, rb_eNotImpError, rb_eRangeError, rb_eRegexpError,
-    rb_eRuntimeError, rb_eScriptError, rb_eSecurityError, rb_eSignal, rb_eStandardError,
-    rb_eStopIteration, rb_eSyntaxError, rb_eSysStackError, rb_eSystemCallError, rb_eSystemExit,
-    rb_eThreadError, rb_eTypeError, rb_eZeroDivError, VALUE,
+use crate::{
+    r_string::RString,
+    ruby_sys::{
+        rb_eArgError, rb_eEOFError, rb_eEncCompatError, rb_eEncodingError, rb_eException,
+        rb_eFatal, rb_eFloatDomainError, rb_eFrozenError, rb_eIOError, rb_eIndexError,
+        rb_eInterrupt, rb_eKeyError, rb_eLoadError, rb_eLocalJumpError, rb_eMathDomainError,
+        rb_eNameError, rb_eNoMemError, rb_eNoMethodError, rb_eNotImpError, rb_eRangeError,
+        rb_eRegexpError, rb_eRuntimeError, rb_eScriptError, rb_eSecurityError, rb_eSignal,
+        rb_eStandardError, rb_eStopIteration, rb_eSyntaxError, rb_eSysStackError,
+        rb_eSystemCallError, rb_eSystemExit, rb_eThreadError, rb_eTypeError, rb_eZeroDivError,
+        rb_syserr_new_str, VALUE,
+    },
 };
 
 #[cfg(ruby_gte_2_7)]
@@ -250,6 +254,18 @@ impl TryConvert for ExceptionClass {
     }
 }
 
+impl Exception {
+    /// Construct Exception from os Error, such as that of
+    /// `io::Error::last_os_error`
+    pub fn from_os_error<S>(errno: i32, msg: S) -> Self
+    where
+        S: Into<RString>,
+    {
+        let msg = msg.into();
+        unsafe { Self::from_rb_value_unchecked(rb_syserr_new_str(errno, msg.as_rb_value())) }
+    }
+}
+
 /// Return Ruby's `ArgumentError` class.
 #[inline]
 pub fn arg_error() -> ExceptionClass {

src/gvl.rs

@@ -0,0 +1,139 @@
+//!
+
+use {
+    crate::{
+        error::Error,
+        ruby_sys::{rb_thread_call_with_gvl, rb_thread_call_without_gvl},
+    },
+    std::{
+        any::Any,
+        marker::PhantomData,
+        os::raw::c_void,
+        panic::{catch_unwind, AssertUnwindSafe},
+        ptr::null_mut,
+    },
+};
+
+struct ExecutionContext<F, R> {
+    closure: *mut F,
+    rval: Option<R>,
+}
+
+/// Rust's panic type
+pub type Panic = Box<dyn 'static + Send + Any>;
+
+/// A `!Send` guard for invoking thread local GVL operations
+pub struct GVLContext(PhantomData<*const ()>);
+
+impl GVLContext {
+    fn new() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl GVLContext {
+    /// Reacquire GVL for the duration of funtion
+    pub fn with_gvl<F, R>(&mut self, f: F) -> Result<R, Error>
+    where
+        F: FnOnce() -> R,
+    {
+        unsafe extern "C" fn call<F, R>(context: *mut c_void) -> *mut c_void
+        where
+            F: FnOnce() -> R,
+        {
+            let ctx = context as *mut ExecutionContext<F, Result<R, Error>>;
+            let closure = Box::from_raw((*ctx).closure);
+            let r = catch_unwind(AssertUnwindSafe(closure)).map_err(Error::from_panic);
+            let prev = (*ctx).rval.replace(r);
+            debug_assert!(prev.is_none());
+            null_mut()
+        }
+
+        let handle = Box::into_raw(Box::new(ExecutionContext {
+            closure: Box::into_raw(Box::new(f)),
+            rval: None::<Result<R, Error>>,
+        }));
+        let call_func = call::<F, R> as unsafe extern "C" fn(*mut c_void) -> *mut c_void;
+
+        unsafe {
+            rb_thread_call_with_gvl(Some(call_func), handle as *mut _);
+            Box::from_raw(handle)
+                .rval
+                .expect("rb_thread_call_without_gvl should have finished execution")
+        }
+    }
+}
+
+/// Release GVL for the duration of the closure
+/// See `RThread::from_fn`'s example.
+///
+/// Optional `cancel` fn will execute on various thread interrupts.
+/// Including signals.
+///
+/// Pass in `None::<fn()>` if not required.
+pub fn without_gvl<F, C, FR, CR>(
+    f: F,
+    cancel: Option<C>,
+) -> (Result<FR, Error>, Option<Result<CR, Error>>)
+where
+    F: FnOnce(GVLContext) -> FR,
+    C: FnOnce() -> CR,
+{
+    unsafe extern "C" fn call<F, R>(context: *mut c_void) -> *mut c_void
+    where
+        F: FnOnce(GVLContext) -> R,
+    {
+        let ctx = context as *mut ExecutionContext<F, Result<R, Panic>>;
+        let closure = Box::from_raw((*ctx).closure);
+        let r = catch_unwind(AssertUnwindSafe(|| (closure)(GVLContext::new())));
+        let prev = (*ctx).rval.replace(r);
+        debug_assert!(prev.is_none());
+        null_mut()
+    }
+
+    unsafe extern "C" fn recall<F, R>(context: *mut c_void)
+    where
+        F: FnOnce() -> R,
+    {
+        let ctx = context as *mut ExecutionContext<F, Result<R, Panic>>;
+        let closure = Box::from_raw((*ctx).closure);
+        let r = catch_unwind(AssertUnwindSafe(closure));
+        let prev = (*ctx).rval.replace(r);
+        debug_assert!(prev.is_none());
+    }
+
+    let call_handle = Box::into_raw(Box::new(ExecutionContext {
+        closure: Box::into_raw(Box::new(f)),
+        rval: None::<Result<FR, Panic>>,
+    }));
+    let recall_handle = cancel.map(|c| {
+        Box::into_raw(Box::new(ExecutionContext {
+            closure: Box::into_raw(Box::new(c)),
+            rval: None::<Result<CR, Panic>>,
+        }))
+    });
+
+    let call_func = call::<F, FR> as unsafe extern "C" fn(*mut c_void) -> *mut c_void;
+    let recall_func = recall_handle.map(|_| recall::<C, CR> as unsafe extern "C" fn(*mut c_void));
+
+    unsafe {
+        rb_thread_call_without_gvl(
+            Some(call_func),
+            call_handle as *mut _,
+            recall_func,
+            match recall_handle {
+                Some(handle) => handle as *mut _,
+                None => null_mut(),
+            },
+        );
+
+        let lhs = Box::from_raw(call_handle)
+            .rval
+            .expect("rb_thread_call_without_gvl should have finished execution")
+            .map_err(Error::from_panic);
+        let rhs = recall_handle
+            .and_then(|handle| Box::from_raw(handle).rval)
+            .map(|rval| rval.map_err(Error::from_panic));
+        (lhs, rhs)
+    }
+}