Make threading optional

Author: coolreader18

Cargo.lock

@@ -15,18 +15,20 @@ name = "bench"
 path = "./benchmarks/bench.rs"
 
 [features]
+default = ["threading"]
 flame-it = ["rustpython-vm/flame-it", "flame", "flamescope"]
 freeze-stdlib = ["rustpython-vm/freeze-stdlib"]
+threading = ["rustpython-vm/threading"]
 
 ssl = ["rustpython-vm/ssl"]
 
 [dependencies]
 log = "0.4"
 env_logger = "0.7"
 clap = "2.33"
-rustpython-compiler = {path = "compiler", version = "0.1.1"}
-rustpython-parser = {path = "parser", version = "0.1.1"}
-rustpython-vm = {path = "vm", version = "0.1.1"}
+rustpython-compiler = { path = "compiler", version = "0.1.1" }
+rustpython-parser = { path = "parser", version = "0.1.1" }
+rustpython-vm = { path = "vm", version = "0.1.1", default-features = false, features = ["rustpython-parser", "rustpython-compiler"] }
 dirs = { package = "dirs-next", version = "1.0" }
 num-traits = "0.2.8"
 cfg-if = "0.1"

Cargo.toml

@@ -1587,7 +1587,10 @@ def _setup(_bootstrap_module):
     setattr(self_module, '_pathseps_with_colon', {f':{s}' for s in path_separators})
 
     # Directly load the _thread module (needed during bootstrap).
-    thread_module = _bootstrap._builtin_from_name('_thread')
+    try:
+        thread_module = _bootstrap._builtin_from_name('_thread')
+    except ImportError:
+        thread_module = None
     setattr(self_module, '_thread', thread_module)
 
     # Directly load the _weakref module (needed during bootstrap).

Lib/importlib/_bootstrap_external.py

@@ -4,12 +4,16 @@ version = "0.0.0"
 authors = ["RustPython Team"]
 edition = "2018"
 
+[features]
+threading = ["parking_lot"]
+
 [dependencies]
-parking_lot = "0.11.0"
+parking_lot = { version = "0.11.0", optional = true }
 num-traits = "0.2"
 num-bigint = "0.3"
 lexical = "4"
 hexf-parse = "0.1.0"
+cfg-if = "0.1"
 
 [dev-dependencies]
 rand = "0.7.3"

common/Cargo.toml

@@ -1,25 +1,50 @@
+#[cfg(feature = "threading")]
 use parking_lot::{Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
+#[cfg(not(feature = "threading"))]
+use std::cell::{Ref, RefCell, RefMut};
 use std::ops::{Deref, DerefMut};
 
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        type MutexInner<T> = Mutex<T>;
+        type MutexGuardInner<'a, T> = MutexGuard<'a, T>;
+        const fn new_mutex<T>(value: T) -> MutexInner<T> {
+            parking_lot::const_mutex(value)
+        }
+        fn lock_mutex<T: ?Sized>(m: &MutexInner<T>) -> MutexGuardInner<T> {
+            m.lock()
+        }
+    } else {
+        type MutexInner<T> = RefCell<T>;
+        type MutexGuardInner<'a, T> = RefMut<'a, T>;
+        const fn new_mutex<T>(value: T) -> MutexInner<T> {
+            RefCell::new(value)
+        }
+        fn lock_mutex<T: ?Sized>(m: &MutexInner<T>) -> MutexGuardInner<T> {
+            m.borrow_mut()
+        }
+    }
+}
+
 #[derive(Debug, Default)]
 #[repr(transparent)]
-pub struct PyMutex<T: ?Sized>(Mutex<T>);
+pub struct PyMutex<T: ?Sized>(MutexInner<T>);
 
 impl<T> PyMutex<T> {
     pub const fn new(value: T) -> Self {
-        Self(parking_lot::const_mutex(value))
+        Self(new_mutex(value))
     }
 }
 
 impl<T: ?Sized> PyMutex<T> {
     pub fn lock(&self) -> PyMutexGuard<T> {
-        PyMutexGuard(self.0.lock())
+        PyMutexGuard(lock_mutex(&self.0))
     }
 }
 
 #[derive(Debug)]
 #[repr(transparent)]
-pub struct PyMutexGuard<'a, T: ?Sized>(MutexGuard<'a, T>);
+pub struct PyMutexGuard<'a, T: ?Sized>(MutexGuardInner<'a, T>);
 impl<T: ?Sized> Deref for PyMutexGuard<'_, T> {
     type Target = T;
     fn deref(&self) -> &T {
@@ -32,28 +57,58 @@ impl<T: ?Sized> DerefMut for PyMutexGuard<'_, T> {
     }
 }
 
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        type RwLockInner<T> = RwLock<T>;
+        type RwLockReadInner<'a, T> = RwLockReadGuard<'a, T>;
+        type RwLockWriteInner<'a, T> = RwLockWriteGuard<'a, T>;
+        const fn new_rwlock<T>(value: T) -> RwLockInner<T> {
+            parking_lot::const_rwlock(value)
+        }
+        fn read_rwlock<T: ?Sized>(m: &RwLockInner<T>) -> RwLockReadInner<T> {
+            m.read()
+        }
+        fn write_rwlock<T: ?Sized>(m: &RwLockInner<T>) -> RwLockWriteInner<T> {
+            m.write()
+        }
+    } else {
+        type RwLockInner<T> = RefCell<T>;
+        type RwLockReadInner<'a, T> = Ref<'a, T>;
+        type RwLockWriteInner<'a, T> = RefMut<'a, T>;
+        const fn new_rwlock<T>(value: T) -> RwLockInner<T> {
+            RefCell::new(value)
+        }
+        fn read_rwlock<T: ?Sized>(m: &RwLockInner<T>) -> RwLockReadInner<T> {
+            m.borrow()
+        }
+        fn write_rwlock<T: ?Sized>(m: &RwLockInner<T>) -> RwLockWriteInner<T> {
+            m.borrow_mut()
+        }
+    }
+}
+
 #[derive(Debug, Default)]
 #[repr(transparent)]
-pub struct PyRwLock<T: ?Sized>(RwLock<T>);
+pub struct PyRwLock<T: ?Sized>(RwLockInner<T>);
 
 impl<T> PyRwLock<T> {
     pub const fn new(value: T) -> Self {
-        Self(parking_lot::const_rwlock(value))
+        Self(new_rwlock(value))
     }
 }
 
 impl<T: ?Sized> PyRwLock<T> {
     pub fn read(&self) -> PyRwLockReadGuard<T> {
-        PyRwLockReadGuard(self.0.read())
+        PyRwLockReadGuard(read_rwlock(&self.0))
     }
     pub fn write(&self) -> PyRwLockWriteGuard<T> {
-        PyRwLockWriteGuard(self.0.write())
+        PyRwLockWriteGuard(write_rwlock(&self.0))
     }
 }
 
 #[derive(Debug)]
 #[repr(transparent)]
-pub struct PyRwLockReadGuard<'a, T: ?Sized>(RwLockReadGuard<'a, T>);
+pub struct PyRwLockReadGuard<'a, T: ?Sized>(RwLockReadInner<'a, T>);
 impl<T: ?Sized> Deref for PyRwLockReadGuard<'_, T> {
     type Target = T;
     fn deref(&self) -> &T {
@@ -63,7 +118,7 @@ impl<T: ?Sized> Deref for PyRwLockReadGuard<'_, T> {
 
 #[derive(Debug)]
 #[repr(transparent)]
-pub struct PyRwLockWriteGuard<'a, T: ?Sized>(RwLockWriteGuard<'a, T>);
+pub struct PyRwLockWriteGuard<'a, T: ?Sized>(RwLockWriteInner<'a, T>);
 impl<T: ?Sized> Deref for PyRwLockWriteGuard<'_, T> {
     type Target = T;
     fn deref(&self) -> &T {

common/src/cell.rs

@@ -1,6 +1,14 @@
+#[cfg(not(feature = "threading"))]
+use std::rc::{Rc, Weak};
+#[cfg(feature = "threading")]
 use std::sync::{Arc, Weak};
 
 // type aliases instead of newtypes because you can't do `fn method(self: PyRc<Self>)` with a
 // newtype; requires the arbitrary_self_types unstable feature
+
+#[cfg(feature = "threading")]
 pub type PyRc<T> = Arc<T>;
+#[cfg(not(feature = "threading"))]
+pub type PyRc<T> = Rc<T>;
+
 pub type PyWeak<T> = Weak<T>;

common/src/rc.rs

@@ -9,10 +9,11 @@ edition = "2018"
 include = ["src/**/*.rs", "Cargo.toml", "build.rs", "Lib/**/*.py"]
 
 [features]
-default = ["rustpython-parser", "rustpython-compiler"]
+default = ["rustpython-parser", "rustpython-compiler", "threading"]
 vm-tracing-logging = []
 flame-it = ["flame", "flamer"]
 freeze-stdlib = ["rustpython-pylib"]
+threading = ["rustpython-common/threading"]
 
 ssl = ["openssl", "openssl-sys", "openssl-probe"]
 

vm/Cargo.toml

@@ -1276,7 +1276,17 @@ impl PyObject<dyn PyObjectPayload> {
     }
 }
 
-pub trait PyValue: fmt::Debug + Send + Sync + Sized + 'static {
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        pub trait PyThreadingConstraint: Send + Sync {}
+        impl<T: Send + Sync> PyThreadingConstraint for T {}
+    } else {
+        pub trait PyThreadingConstraint {}
+        impl<T> PyThreadingConstraint for T {}
+    }
+}
+
+pub trait PyValue: fmt::Debug + PyThreadingConstraint + Sized + 'static {
     const HAVE_DICT: bool = false;
 
     fn class(vm: &VirtualMachine) -> PyClassRef;
@@ -1306,7 +1316,7 @@ pub trait PyValue: fmt::Debug + Send + Sync + Sized + 'static {
     }
 }
 
-pub trait PyObjectPayload: Any + fmt::Debug + Send + Sync + 'static {
+pub trait PyObjectPayload: Any + fmt::Debug + PyThreadingConstraint + 'static {
     fn as_any(&self) -> &dyn Any;
 }
 

vm/src/pyobject.rs

@@ -32,6 +32,7 @@ mod string;
 mod symtable;
 mod sysconfigdata;
 #[cfg(not(target_arch = "wasm32"))]
+#[cfg(feature = "threading")]
 mod thread;
 mod time_module;
 #[cfg(feature = "rustpython-parser")]
@@ -131,6 +132,7 @@ pub fn get_module_inits() -> HashMap<String, StdlibInitFunc> {
         modules.insert("select".to_owned(), Box::new(select::make_module));
         #[cfg(feature = "ssl")]
         modules.insert("_ssl".to_owned(), Box::new(ssl::make_module));
+        #[cfg(feature = "threading")]
         modules.insert("_thread".to_owned(), Box::new(thread::make_module));
         #[cfg(not(target_os = "redox"))]
         modules.insert("zlib".to_owned(), Box::new(zlib::make_module));

vm/src/stdlib/mod.rs

@@ -287,6 +287,7 @@ impl VirtualMachine {
         }
     }
 
+    #[cfg(feature = "threading")]
     pub(crate) fn new_thread(&self) -> VirtualMachine {
         VirtualMachine {
             builtins: self.builtins.clone(),