Move some vm fields to an Arc-wrapped struct

coolreader18 · coolreader18 · commit bf6060a6dff0 · 2020-05-17T00:43:22.000-05:00
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -736,7 +736,7 @@ fn builtin_sum(iterable: PyIterable, start: OptionalArg, vm: &VirtualMachine) ->
 
 // Should be renamed to builtin___import__?
 fn builtin_import(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {
-    vm.invoke(&vm.import_func.borrow(), args)
+    vm.invoke(&vm.import_func, args)
 }
 
 fn builtin_vars(obj: OptionalArg, vm: &VirtualMachine) -> PyResult {
diff --git a/vm/src/import.rs b/vm/src/import.rs
@@ -14,14 +14,13 @@ use crate::vm::{InitParameter, VirtualMachine};
 #[cfg(feature = "rustpython-compiler")]
 use rustpython_compiler::compile;
 
-pub fn init_importlib(vm: &VirtualMachine, initialize_parameter: InitParameter) -> PyResult {
+pub fn init_importlib(vm: &mut VirtualMachine, initialize_parameter: InitParameter) -> PyResult {
     flame_guard!("init importlib");
     let importlib = import_frozen(vm, "_frozen_importlib")?;
     let impmod = import_builtin(vm, "_imp")?;
     let install = vm.get_attribute(importlib.clone(), "_install")?;
     vm.invoke(&install, vec![vm.sys_module.clone(), impmod])?;
-    vm.import_func
-        .replace(vm.get_attribute(importlib.clone(), "__import__")?);
+    vm.import_func = vm.get_attribute(importlib.clone(), "__import__")?;
 
     match initialize_parameter {
         InitParameter::InitializeExternal if cfg!(feature = "rustpython-compiler") => {
@@ -58,16 +57,16 @@ pub fn init_importlib(vm: &VirtualMachine, initialize_parameter: InitParameter)
 }
 
 pub fn import_frozen(vm: &VirtualMachine, module_name: &str) -> PyResult {
-    vm.frozen
-        .borrow()
+    vm.state
+        .frozen
         .get(module_name)
         .ok_or_else(|| vm.new_import_error(format!("Cannot import frozen module {}", module_name)))
         .and_then(|frozen| import_codeobj(vm, module_name, frozen.code.clone(), false))
 }
 
 pub fn import_builtin(vm: &VirtualMachine, module_name: &str) -> PyResult {
-    vm.stdlib_inits
-        .borrow()
+    vm.state
+        .stdlib_inits
         .get(module_name)
         .ok_or_else(|| vm.new_import_error(format!("Cannot import bultin module {}", module_name)))
         .and_then(|make_module_func| {
diff --git a/vm/src/stdlib/imp.rs b/vm/src/stdlib/imp.rs
@@ -26,11 +26,11 @@ fn imp_lock_held(_vm: &VirtualMachine) -> PyResult<()> {
 }
 
 fn imp_is_builtin(name: PyStringRef, vm: &VirtualMachine) -> bool {
-    vm.stdlib_inits.borrow().contains_key(name.as_str())
+    vm.state.stdlib_inits.contains_key(name.as_str())
 }
 
 fn imp_is_frozen(name: PyStringRef, vm: &VirtualMachine) -> bool {
-    vm.frozen.borrow().contains_key(name.as_str())
+    vm.state.frozen.contains_key(name.as_str())
 }
 
 fn imp_create_builtin(spec: PyObjectRef, vm: &VirtualMachine) -> PyResult {
@@ -40,7 +40,7 @@ fn imp_create_builtin(spec: PyObjectRef, vm: &VirtualMachine) -> PyResult {
 
     if let Ok(module) = sys_modules.get_item(name, vm) {
         Ok(module)
-    } else if let Some(make_module_func) = vm.stdlib_inits.borrow().get(name) {
+    } else if let Some(make_module_func) = vm.state.stdlib_inits.get(name) {
         Ok(make_module_func(vm))
     } else {
         Ok(vm.get_none())
@@ -53,8 +53,8 @@ fn imp_exec_builtin(_mod: PyModuleRef) -> i32 {
 }
 
 fn imp_get_frozen_object(name: PyStringRef, vm: &VirtualMachine) -> PyResult<PyCode> {
-    vm.frozen
-        .borrow()
+    vm.state
+        .frozen
         .get(name.as_str())
         .map(|frozen| {
             let mut frozen = frozen.code.clone();
@@ -71,8 +71,8 @@ fn imp_init_frozen(name: PyStringRef, vm: &VirtualMachine) -> PyResult {
 }
 
 fn imp_is_frozen_package(name: PyStringRef, vm: &VirtualMachine) -> PyResult<bool> {
-    vm.frozen
-        .borrow()
+    vm.state
+        .frozen
         .get(name.as_str())
         .map(|frozen| frozen.package)
         .ok_or_else(|| {
diff --git a/vm/src/stdlib/signal.rs b/vm/src/stdlib/signal.rs
@@ -38,6 +38,10 @@ fn assert_in_range(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
 
 fn signal(signalnum: i32, handler: PyObjectRef, vm: &VirtualMachine) -> PyResult {
     assert_in_range(signalnum, vm)?;
+    let signal_handlers = vm
+        .signal_handlers
+        .as_ref()
+        .ok_or_else(|| vm.new_value_error("signal only works in main thread".to_owned()))?;
 
     let sig_handler = match usize::try_from_object(vm, handler.clone()).ok() {
         Some(SIG_DFL) => SIG_DFL,
@@ -68,15 +72,19 @@ fn signal(signalnum: i32, handler: PyObjectRef, vm: &VirtualMachine) -> PyResult
 
     let mut old_handler = handler;
     std::mem::swap(
-        &mut vm.signal_handlers.borrow_mut()[signalnum as usize],
+        &mut signal_handlers.borrow_mut()[signalnum as usize],
         &mut old_handler,
     );
     Ok(old_handler)
 }
 
 fn getsignal(signalnum: i32, vm: &VirtualMachine) -> PyResult {
     assert_in_range(signalnum, vm)?;
-    Ok(vm.signal_handlers.borrow()[signalnum as usize].clone())
+    let signal_handlers = vm
+        .signal_handlers
+        .as_ref()
+        .ok_or_else(|| vm.new_value_error("getsignal only works in main thread".to_owned()))?;
+    Ok(signal_handlers.borrow()[signalnum as usize].clone())
 }
 
 #[cfg(unix)]
@@ -91,13 +99,18 @@ fn alarm(time: u32) -> u32 {
 
 #[cfg_attr(feature = "flame-it", flame)]
 pub fn check_signals(vm: &VirtualMachine) -> PyResult<()> {
+    let signal_handlers = match vm.signal_handlers {
+        Some(ref h) => h.borrow(),
+        None => return Ok(()),
+    };
+
     if !ANY_TRIGGERED.swap(false, Ordering::Relaxed) {
         return Ok(());
     }
     for (signum, trigger) in TRIGGERS.iter().enumerate().skip(1) {
         let triggerd = trigger.swap(false, Ordering::Relaxed);
         if triggerd {
-            let handler = &vm.signal_handlers.borrow()[signum];
+            let handler = &signal_handlers[signum];
             if vm.is_callable(handler) {
                 vm.invoke(handler, vec![vm.new_int(signum), vm.get_none()])?;
             }
@@ -145,7 +158,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
         } else {
             vm.get_none()
         };
-        vm.signal_handlers.borrow_mut()[signum] = py_handler;
+        vm.signal_handlers.as_ref().unwrap().borrow_mut()[signum] = py_handler;
     }
 
     signal(libc::SIGINT, int_handler, vm).expect("Failed to set sigint handler");
diff --git a/vm/src/sysmodule.rs b/vm/src/sysmodule.rs
@@ -154,14 +154,14 @@ fn update_use_tracing(vm: &VirtualMachine) {
 }
 
 fn sys_getrecursionlimit(vm: &VirtualMachine) -> usize {
-    vm.recursion_limit.get()
+    vm.state.recursion_limit.load()
 }
 
 fn sys_setrecursionlimit(recursion_limit: usize, vm: &VirtualMachine) -> PyResult {
     let recursion_depth = vm.frames.borrow().len();
 
     if recursion_limit > recursion_depth + 1 {
-        vm.recursion_limit.set(recursion_limit);
+        vm.state.recursion_limit.store(recursion_limit);
         Ok(vm.ctx.none())
     } else {
         Err(vm.new_recursion_error(format!(
@@ -348,7 +348,7 @@ setprofile() -- set the global profiling function
 setrecursionlimit() -- set the max recursion depth for the interpreter
 settrace() -- set the global debug tracing function
 ";
-    let mut module_names: Vec<String> = vm.stdlib_inits.borrow().keys().cloned().collect();
+    let mut module_names: Vec<String> = vm.state.stdlib_inits.keys().cloned().collect();
     module_names.push("sys".to_owned());
     module_names.push("builtins".to_owned());
     module_names.sort();
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -4,7 +4,7 @@
 //!   https://github.com/ProgVal/pythonvm-rust/blob/master/src/processor/mod.rs
 //!
 
-use std::cell::{Cell, Ref, RefCell};
+use std::cell::{Ref, RefCell};
 use std::collections::hash_map::HashMap;
 use std::collections::hash_set::HashSet;
 use std::sync::{Arc, Mutex, MutexGuard};
@@ -46,6 +46,7 @@ use crate::pyobject::{
 use crate::scope::Scope;
 use crate::stdlib;
 use crate::sysmodule;
+use crossbeam_utils::atomic::AtomicCell;
 
 // use objects::objects;
 
@@ -56,23 +57,27 @@ use crate::sysmodule;
 pub struct VirtualMachine {
     pub builtins: PyObjectRef,
     pub sys_module: PyObjectRef,
-    pub stdlib_inits: RefCell<HashMap<String, stdlib::StdlibInitFunc>>,
     pub ctx: PyContext,
     pub frames: RefCell<Vec<FrameRef>>,
     pub wasm_id: Option<String>,
     pub exceptions: RefCell<Vec<PyBaseExceptionRef>>,
-    pub frozen: RefCell<HashMap<String, bytecode::FrozenModule>>,
-    pub import_func: RefCell<PyObjectRef>,
+    pub import_func: PyObjectRef,
     pub profile_func: RefCell<PyObjectRef>,
     pub trace_func: RefCell<PyObjectRef>,
     pub use_tracing: RefCell<bool>,
-    pub signal_handlers: RefCell<[PyObjectRef; NSIG]>,
+    pub signal_handlers: Option<RefCell<[PyObjectRef; NSIG]>>,
     pub settings: PySettings,
-    pub recursion_limit: Cell<usize>,
     pub codec_registry: RefCell<Vec<PyObjectRef>>,
+    pub state: Arc<PyGlobalState>,
     pub initialized: bool,
 }
 
+pub struct PyGlobalState {
+    pub recursion_limit: AtomicCell<usize>,
+    pub stdlib_inits: HashMap<String, stdlib::StdlibInitFunc>,
+    pub frozen: HashMap<String, bytecode::FrozenModule>,
+}
+
 pub const NSIG: usize = 64;
 
 #[derive(Copy, Clone)]
@@ -175,31 +180,34 @@ impl VirtualMachine {
         let sysmod_dict = ctx.new_dict();
         let sysmod = new_module(sysmod_dict.clone());
 
-        let stdlib_inits = RefCell::new(stdlib::get_module_inits());
-        let frozen = RefCell::new(frozen::get_module_inits());
-        let import_func = RefCell::new(ctx.none());
+        let import_func = ctx.none();
         let profile_func = RefCell::new(ctx.none());
         let trace_func = RefCell::new(ctx.none());
         let signal_handlers = RefCell::new(arr![ctx.none(); 64]);
         let initialize_parameter = settings.initialization_parameter;
 
+        let stdlib_inits = stdlib::get_module_inits();
+        let frozen = frozen::get_module_inits();
+
         let mut vm = VirtualMachine {
             builtins: builtins.clone(),
             sys_module: sysmod.clone(),
-            stdlib_inits,
             ctx,
             frames: RefCell::new(vec![]),
             wasm_id: None,
             exceptions: RefCell::new(vec![]),
-            frozen,
             import_func,
             profile_func,
             trace_func,
             use_tracing: RefCell::new(false),
-            signal_handlers,
+            signal_handlers: Some(signal_handlers),
             settings,
-            recursion_limit: Cell::new(if cfg!(debug_assertions) { 256 } else { 512 }),
             codec_registry: RefCell::default(),
+            state: Arc::new(PyGlobalState {
+                recursion_limit: AtomicCell::new(if cfg!(debug_assertions) { 256 } else { 512 }),
+                stdlib_inits,
+                frozen,
+            }),
             initialized: false,
         };
 
@@ -232,7 +240,7 @@ impl VirtualMachine {
                 builtins::make_module(self, self.builtins.clone());
                 sysmodule::make_module(self, self.sys_module.clone(), self.builtins.clone());
 
-                let inner_init = || -> PyResult<()> {
+                let mut inner_init = || -> PyResult<()> {
                     #[cfg(not(target_arch = "wasm32"))]
                     import::import_builtin(self, "signal")?;
 
@@ -266,7 +274,9 @@ impl VirtualMachine {
                     Ok(())
                 };
 
-                self.expect_pyresult(inner_init(), "initializiation failed");
+                let res = inner_init();
+
+                self.expect_pyresult(res, "initializiation failed");
 
                 self.initialized = true;
             }
@@ -302,7 +312,7 @@ impl VirtualMachine {
     }
 
     fn check_recursive_call(&self, _where: &str) -> PyResult<()> {
-        if self.frames.borrow().len() > self.recursion_limit.get() {
+        if self.frames.borrow().len() > self.state.recursion_limit.load() {
             Err(self.new_recursion_error(format!("maximum recursion depth exceeded {}", _where)))
         } else {
             Ok(())
diff --git a/wasm/lib/src/browser_module.rs b/wasm/lib/src/browser_module.rs
@@ -1,5 +1,6 @@
 use futures::Future;
 use js_sys::Promise;
+use std::sync::Arc;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_futures::{future_to_promise, JsFuture};
@@ -367,11 +368,12 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     })
 }
 
-pub fn setup_browser_module(vm: &VirtualMachine) {
-    vm.stdlib_inits
-        .borrow_mut()
+pub fn setup_browser_module(vm: &mut VirtualMachine) {
+    let state = Arc::get_mut(&mut vm.state).unwrap();
+    state
+        .stdlib_inits
         .insert("_browser".to_owned(), Box::new(make_module));
-    vm.frozen.borrow_mut().extend(py_compile_bytecode!(
+    state.frozen.extend(py_compile_bytecode!(
         file = "src/browser.py",
         module_name = "browser",
     ));
diff --git a/wasm/lib/src/js_module.rs b/wasm/lib/src/js_module.rs
@@ -5,6 +5,7 @@ use rustpython_vm::obj::{objfloat::PyFloatRef, objstr::PyStringRef, objtype::PyC
 use rustpython_vm::pyobject::{PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject};
 use rustpython_vm::types::create_type;
 use rustpython_vm::VirtualMachine;
+use std::sync::Arc;
 use wasm_bindgen::{prelude::*, JsCast};
 
 #[wasm_bindgen(inline_js = "
@@ -253,8 +254,9 @@ pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     })
 }
 
-pub fn setup_js_module(vm: &VirtualMachine) {
-    vm.stdlib_inits
-        .borrow_mut()
+pub fn setup_js_module(vm: &mut VirtualMachine) {
+    let state = Arc::get_mut(&mut vm.state).unwrap();
+    state
+        .stdlib_inits
         .insert("_js".to_owned(), Box::new(make_module));
 }
diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs

Original file line number	Diff line number	Diff line change
`@@ -736,7 +736,7 @@ fn builtin_sum(iterable: PyIterable, start: OptionalArg, vm: &VirtualMachine) ->`
`736`	`736`
`737`	`737`	`// Should be renamed to builtin___import__?`
`738`	`738`	`fn builtin_import(vm: &VirtualMachine, args: PyFuncArgs) -> PyResult {`
`739`		`- vm.invoke(&vm.import_func.borrow(), args)`
	`739`	`+ vm.invoke(&vm.import_func, args)`
`740`	`740`	`}`
`741`	`741`
`742`	`742`	`fn builtin_vars(obj: OptionalArg, vm: &VirtualMachine) -> PyResult {`