Merge pull request #197 from lumen/runtime_on_alloc

Runtime on alloc

Author: KronicDeth

Cargo.lock

@@ -8,7 +8,8 @@ edition = "2018"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-default = ["console_error_panic_hook"]
+default = ["console_error_panic_hook", "time_web_sys"]
+time_web_sys = ["parking_lot_core/time_web_sys", "lumen_runtime/time_web_sys"]
 
 [dependencies]
 # The `console_error_panic_hook` crate provides better debugging of panics by
@@ -17,6 +18,7 @@ default = ["console_error_panic_hook"]
 # code size when deploying.
 console_error_panic_hook = { version = "0.1.1", optional = true }
 
+liblumen_alloc = { path = "../../liblumen_alloc" }
 lumen_runtime = { path = "../../lumen_runtime" }
 num-bigint = "0.2.2"
 wasm-bindgen = "0.2"
@@ -28,9 +30,14 @@ wasm-bindgen = "0.2"
 # Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
 wee_alloc = { version = "0.4.2", optional = true }
 
+[dependencies.parking_lot_core]
+git = "https://github.com/KronicDeth/parking_lot.git"
+branch = "wasm32-time_web_sys"
+features = ["nightly"]
+
 [target.'cfg(target_arch = "wasm32")'.dependencies.web-sys]
 version = "0.3.20"
-features = ['console', 'Performance', 'Window']
+features = ['console']
 
 [dev-dependencies]
 time-test = "0.2.1"

examples/spawn-chain/Cargo.toml

@@ -1,34 +1,48 @@
 use std::convert::TryInto;
 use std::sync::Arc;
 
-use lumen_runtime::process::stack::frame::Frame;
-use lumen_runtime::process::{ModuleFunctionArity, Process};
-use lumen_runtime::term::Term;
+use liblumen_alloc::erts::exception::runtime;
+use liblumen_alloc::erts::process::code::stack::frame::Frame;
+use liblumen_alloc::erts::process::code::Result;
+use liblumen_alloc::erts::process::ProcessControlBlock;
+use liblumen_alloc::erts::term::{Atom, Term, TypedTerm};
+use liblumen_alloc::erts::ModuleFunctionArity;
 
 use crate::elixir;
 
-pub fn apply(arc_process: &Arc<Process>) {
-    let frame_argument_vec = arc_process.pop_arguments(3);
-    let module = frame_argument_vec[0];
-    let function = frame_argument_vec[1];
+pub fn apply(arc_process: &Arc<ProcessControlBlock>) -> Result {
+    let module_term = arc_process.stack_pop().unwrap();
+    let function_term = arc_process.stack_pop().unwrap();
 
-    let argument_list = frame_argument_vec[2];
-    let argument_vec: Vec<Term> = match argument_list.try_into() {
-        Ok(argument_vec) => argument_vec,
-        Err(_) => {
-            #[cfg(debug_assertions)]
-            panic!(
-                "Arguments ({:?}) are neither empty list nor proper list",
-                argument_list
-            );
-            #[cfg(not(debug_assertions))]
-            panic!("Arguments are neither empty list nor proper list")
+    let argument_list = arc_process.stack_pop().unwrap();
+
+    let mut argument_vec: Vec<Term> = Vec::new();
+
+    match argument_list.to_typed_term().unwrap() {
+        TypedTerm::Nil => (),
+        TypedTerm::List(argument_cons) => {
+            for result in argument_cons.into_iter() {
+                let element = result.unwrap();
+
+                argument_vec.push(element);
+            }
         }
-    };
-    let arity = argument_vec.len();
+        _ => panic!(
+            "In {:?}, {:?} ({:#b}) is not an argument list.  Cannot call {:?}:{:?}",
+            arc_process.pid_term(),
+            argument_list,
+            argument_list.as_usize(),
+            module_term,
+            function_term
+        ),
+    }
+
+    let module: Atom = module_term.try_into().unwrap();
+    let function: Atom = function_term.try_into().unwrap();
+    let arity = argument_vec.len() as u8;
 
-    match unsafe { module.atom_to_string() }.as_ref().as_ref() {
-        "Elixir.Chain" => match unsafe { function.atom_to_string() }.as_ref().as_ref() {
+    match module.name() {
+        "Elixir.Chain" => match function.name() {
             "counter" => match arity {
                 1 => {
                     let module_function_arity = Arc::new(ModuleFunctionArity {
@@ -39,16 +53,16 @@ pub fn apply(arc_process: &Arc<Process>) {
 
                     // Elixir.Chain.counter is a user function and not a BIF, so it is a `Code` and
                     // run in a frame instead of directly
-                    let mut chain_counter_frame =
+                    let chain_counter_frame =
                         Frame::new(module_function_arity, elixir::chain::counter_0_code);
-                    chain_counter_frame.push(argument_vec[0]);
+                    arc_process.stack_push(argument_vec[0])?;
                     arc_process.replace_frame(chain_counter_frame);
 
                     // don't count finding the function as a reduction if it is found, only on
                     // exception in `undef`, so that each path is at least one reduction.
-                    Process::call_code(arc_process);
+                    ProcessControlBlock::call_code(arc_process)
                 }
-                _ => undef(arc_process, module, function, argument_list),
+                _ => undef(arc_process, module_term, function_term, argument_list),
             },
             "run" => match arity {
                 1 => {
@@ -59,42 +73,33 @@ pub fn apply(arc_process: &Arc<Process>) {
                     });
                     // Elixir.Chain.run is a user function and not a BIF, so it is a `Code` and
                     // run in a frame instead of directly
-                    let mut chain_run_frame =
+                    let chain_run_frame =
                         Frame::new(module_function_arity, elixir::chain::run_0_code);
-                    chain_run_frame.push(argument_vec[0]);
+                    arc_process.stack_push(argument_vec[0])?;
                     arc_process.replace_frame(chain_run_frame);
 
                     // don't count finding the function as a reduction if it is found, only on
                     // exception in `undef`, so that each path is at least one reduction.
-                    Process::call_code(arc_process);
+                    ProcessControlBlock::call_code(arc_process)
                 }
-                _ => undef(arc_process, module, function, argument_list),
+                _ => undef(arc_process, module_term, function_term, argument_list),
             },
-            _ => undef(arc_process, module, function, argument_list),
+            _ => undef(arc_process, module_term, function_term, argument_list),
         },
-        _ => undef(arc_process, module, function, argument_list),
-    }
-}
-
-#[cfg(debug_assertions)]
-pub fn print_stacktrace(process: &Process) {
-    let mut formatted_stacktrace_parts: Vec<String> = Vec::new();
-
-    for module_function_arity in process.stacktrace() {
-        formatted_stacktrace_parts.push(format!("{}", module_function_arity));
+        _ => undef(arc_process, module_term, function_term, argument_list),
     }
-
-    let formatted_stacktrace = formatted_stacktrace_parts.join("\n");
-
-    crate::start::log_1(formatted_stacktrace);
 }
 
-fn undef(arc_process: &Arc<Process>, module: Term, function: Term, arguments: Term) {
+fn undef(
+    arc_process: &Arc<ProcessControlBlock>,
+    module: Term,
+    function: Term,
+    arguments: Term,
+) -> Result {
     arc_process.reduce();
-    arc_process.exception(lumen_runtime::undef!(
-        module,
-        function,
-        arguments,
-        arc_process
-    ))
+    let exception = liblumen_alloc::undef!(arc_process, module, function, arguments);
+    let runtime_exception: runtime::Exception = exception.try_into().unwrap();
+    arc_process.exception(runtime_exception);
+
+    Ok(())
 }