Allow eir interpreter tests to run concurrently

Author: KronicDeth

liblumen_eir_interpreter/src/bin.rs

@@ -16,7 +16,7 @@ use liblumen_eir_interpreter::{call_erlang, VM};
 
 use liblumen_alloc::erts::term::Atom;
 
-use lumen_runtime::registry;
+use lumen_runtime::scheduler::Scheduler;
 
 fn parse_file<T, P>(path: P, config: ParseConfig) -> (T, Parser)
 where
@@ -70,8 +70,8 @@ fn main() {
 
     &*VM;
 
-    let init_atom = Atom::try_from_str("init").unwrap();
-    let init_arc_process = registry::atom_to_process(&init_atom).unwrap();
+    let arc_scheduler = Scheduler::current();
+    let init_arc_process = arc_scheduler.spawn_init(0).unwrap();
 
     let module = Atom::try_from_str(&ident.module.as_str()).unwrap();
     let function = Atom::try_from_str(&ident.name.as_str()).unwrap();

liblumen_eir_interpreter/src/lib.rs

@@ -135,19 +135,22 @@ pub fn call_erlang(
 
 #[cfg(test)]
 mod tests {
-
-    use liblumen_alloc::erts::term::Atom;
-    use lumen_runtime::registry;
+    use super::call_erlang;
+    use super::VM;
 
     use libeir_diagnostics::{ColorChoice, Emitter, StandardStreamEmitter};
+
     use libeir_ir::Module;
+
     use libeir_passes::PassManager;
+
     use libeir_syntax_erl::ast::Module as ErlAstModule;
     use libeir_syntax_erl::lower_module;
     use libeir_syntax_erl::{Parse, ParseConfig, Parser};
 
-    use super::call_erlang;
-    use super::VM;
+    use liblumen_alloc::erts::term::Atom;
+
+    use lumen_runtime::scheduler::Scheduler;
 
     fn parse<T>(input: &str, config: ParseConfig) -> (T, Parser)
     where
@@ -183,8 +186,8 @@ mod tests {
     fn nonexistent_function_call() {
         &*VM;
 
-        let init_atom = Atom::try_from_str("init").unwrap();
-        let init_arc_process = registry::atom_to_process(&init_atom).unwrap();
+        let arc_scheduler = Scheduler::current();
+        let init_arc_process = arc_scheduler.spawn_init(0).unwrap();
 
         let module = Atom::try_from_str("foo").unwrap();
         let function = Atom::try_from_str("bar").unwrap();
@@ -198,8 +201,8 @@ mod tests {
     fn simple_function() {
         &*VM;
 
-        let init_atom = Atom::try_from_str("init").unwrap();
-        let init_arc_process = registry::atom_to_process(&init_atom).unwrap();
+        let arc_scheduler = Scheduler::current();
+        let init_arc_process = arc_scheduler.spawn_init(0).unwrap();
 
         let module = Atom::try_from_str("simple_function_test").unwrap();
         let function = Atom::try_from_str("run").unwrap();
@@ -233,8 +236,8 @@ run() -> yay.
     fn fib() {
         &*VM;
 
-        let init_atom = Atom::try_from_str("init").unwrap();
-        let init_arc_process = registry::atom_to_process(&init_atom).unwrap();
+        let arc_scheduler = Scheduler::current();
+        let init_arc_process = arc_scheduler.spawn_init(0).unwrap();
 
         let module = Atom::try_from_str("fib").unwrap();
         let function = Atom::try_from_str("fib").unwrap();

liblumen_eir_interpreter/src/vm.rs

@@ -1,12 +1,11 @@
 use std::rc::Rc;
-use std::sync::{Arc, RwLock};
+use std::sync::RwLock;
 
 use libeir_ir::FunctionIdent;
 
 use liblumen_alloc::erts::exception;
 use liblumen_alloc::erts::process::{heap, next_heap_size, Status};
 use liblumen_alloc::erts::term::{atom_unchecked, Atom, Term};
-use lumen_runtime::registry;
 use lumen_runtime::scheduler::Scheduler;
 use lumen_runtime::system;
 
@@ -21,15 +20,6 @@ impl VMState {
     pub fn new() -> Self {
         lumen_runtime::otp::erlang::apply_3::set_code(crate::code::apply);
 
-        let arc_scheduler = Scheduler::current();
-        let init_arc_scheduler = Arc::clone(&arc_scheduler);
-        let init_arc_process = init_arc_scheduler.spawn_init(0).unwrap();
-        let init_atom = Atom::try_from_str("init").unwrap();
-
-        if !registry::put_atom_to_process(init_atom, init_arc_process) {
-            panic!("Could not register init process");
-        };
-
         let mut modules = ModuleRegistry::new();
         modules.register_native_module(crate::native::make_erlang());
 
@@ -44,8 +34,8 @@ impl VMState {
         fun: &FunctionIdent,
         args: &[Term],
     ) -> Result<Rc<Term>, (Rc<Term>, Rc<Term>, Rc<Term>)> {
-        let init_atom = Atom::try_from_str("init").unwrap();
-        let init_arc_process = registry::atom_to_process(&init_atom).unwrap();
+        let arc_scheduler = Scheduler::current();
+        let init_arc_process = arc_scheduler.spawn_init(0).unwrap();
 
         let module = Atom::try_from_str(&fun.module.as_str()).unwrap();
         let function = Atom::try_from_str(&fun.name.as_str()).unwrap();