New run function that doesn't import python code. (#246)

Only one `run` function, and it uses `ValueError` instead of `EvalError`.

Author: richardkiss

benchmark/run-benchmark.py

@@ -8,7 +8,7 @@
 import random
 from clvm import KEYWORD_FROM_ATOM, KEYWORD_TO_ATOM
 from clvm.operators import OP_REWRITE
-from clvm_rs import run_chia_program
+from clvm_rs import run_serialized_chia_program
 from colorama import init, Fore, Style
 
 init()
@@ -213,7 +213,7 @@ def need_update(file_path, mtime):
             env_data = bytes.fromhex(open(env_fn, 'r').read())
 
             time_start = time.perf_counter()
-            cost, result = run_chia_program(
+            cost, result = run_serialized_chia_program(
                 program_data,
                 env_data,
                 max_cost,

tests/run.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
-from clvm_rs import run_chia_program
+from clvm_rs import run_serialized_chia_program
+
 
 def run_clvm(fn, env=None):
 
@@ -15,13 +16,14 @@ def run_clvm(fn, env=None):
     cost_per_byte = 12000
 
     max_cost -= (len(program_data) + len(env_data)) * cost_per_byte
-    return run_chia_program(
+    return run_serialized_chia_program(
         program_data,
         env_data,
         max_cost,
         0,
     )
 
+
 def count_tree_size(tree) -> int:
     stack = [tree]
     ret = 0
@@ -48,7 +50,7 @@ def count_tree_size(tree) -> int:
         print(f"cost: {cost}")
         print(f"execution time: {duration:.2f}s")
     except Exception as e:
-        print("FAIL:", e)
+        print("FAIL:", e.args[0])
         sys.exit(1)
     start = time()
     ret_size = count_tree_size(result)

wheel/src/adapt_response.rs

@@ -1,39 +1,29 @@
+use std::rc::Rc;
+
 use crate::lazy_node::LazyNode;
 use clvmr::allocator::Allocator;
-use clvmr::reduction::{EvalErr, Response};
-
-use std::rc::Rc;
+use clvmr::reduction::Response;
 
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
-use pyo3::types::PyDict;
+use pyo3::types::PyTuple;
 
-pub fn eval_err_to_pyresult<T>(py: Python, eval_err: EvalErr, allocator: Allocator) -> PyResult<T> {
-    let node = LazyNode::new(Rc::new(allocator), eval_err.0);
-    let msg = eval_err.1;
-    let ctx: &PyDict = PyDict::new(py);
-    ctx.set_item("msg", msg)?;
-    ctx.set_item("node", node)?;
-    Err(py
-        .run(
-            "
-from clvm.EvalError import EvalError
-raise EvalError(msg, node)",
-            None,
-            Some(ctx),
-        )
-        .unwrap_err())
-}
-
-pub fn adapt_response_to_py(
+pub fn adapt_response(
     py: Python,
     allocator: Allocator,
-    r: Response,
+    response: Response,
 ) -> PyResult<(u64, LazyNode)> {
-    match r {
+    match response {
         Ok(reduction) => {
             let val = LazyNode::new(Rc::new(allocator), reduction.1);
             Ok((reduction.0, val))
         }
-        Err(eval_err) => eval_err_to_pyresult(py, eval_err, allocator),
+        Err(eval_err) => {
+            let sexp = LazyNode::new(Rc::new(allocator), eval_err.0).to_object(py);
+            let msg = eval_err.1.to_object(py);
+            let tuple = PyTuple::new(py, [msg, sexp]);
+            let value_error: PyErr = PyValueError::new_err(tuple.to_object(py));
+            Err(value_error)
+        }
     }
 }

wheel/src/api.rs

@@ -1,25 +1,55 @@
+use super::lazy_node::LazyNode;
+use crate::adapt_response::adapt_response;
+use clvmr::allocator::Allocator;
+use clvmr::chia_dialect::ChiaDialect;
+use clvmr::cost::Cost;
+use clvmr::reduction::Response;
+use clvmr::run_program::run_program;
+use clvmr::serde::{node_from_bytes, serialized_length_from_bytes};
+use clvmr::{LIMIT_HEAP, LIMIT_STACK, MEMPOOL_MODE, NO_NEG_DIV, NO_UNKNOWN_OPS};
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 
-use super::lazy_node::LazyNode;
-use super::run_program::{
-    __pyo3_get_function_deserialize_and_run_program2, __pyo3_get_function_run_chia_program,
-    __pyo3_get_function_serialized_length,
-};
-use clvmr::{LIMIT_HEAP, NO_NEG_DIV, NO_UNKNOWN_OPS, LIMIT_STACK, MEMPOOL_MODE};
+#[pyfunction]
+pub fn serialized_length(program: &[u8]) -> PyResult<u64> {
+    Ok(serialized_length_from_bytes(program)?)
+}
+
+#[pyfunction]
+pub fn run_serialized_chia_program(
+    py: Python,
+    program: &[u8],
+    args: &[u8],
+    max_cost: Cost,
+    flags: u32,
+) -> PyResult<(u64, LazyNode)> {
+    let mut allocator = if flags & LIMIT_HEAP != 0 {
+        Allocator::new_limited(500000000, 62500000, 62500000)
+    } else {
+        Allocator::new()
+    };
+
+    let r: Response = (|| -> PyResult<Response> {
+        let program = node_from_bytes(&mut allocator, program)?;
+        let args = node_from_bytes(&mut allocator, args)?;
+        let dialect = ChiaDialect::new(flags);
+
+        Ok(py.allow_threads(|| run_program(&mut allocator, &dialect, program, args, max_cost)))
+    })()?;
+    adapt_response(py, allocator, r)
+}
 
 #[pymodule]
 fn clvm_rs(_py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(deserialize_and_run_program2, m)?)?;
-    m.add_function(wrap_pyfunction!(run_chia_program, m)?)?;
+    m.add_function(wrap_pyfunction!(run_serialized_chia_program, m)?)?;
+    m.add_function(wrap_pyfunction!(serialized_length, m)?)?;
+
     m.add("NO_NEG_DIV", NO_NEG_DIV)?;
     m.add("NO_UNKNOWN_OPS", NO_UNKNOWN_OPS)?;
     m.add("LIMIT_HEAP", LIMIT_HEAP)?;
     m.add("LIMIT_STACK", LIMIT_STACK)?;
     m.add("MEMPOOL_MODE", MEMPOOL_MODE)?;
     m.add_class::<LazyNode>()?;
 
-    m.add_function(wrap_pyfunction!(serialized_length, m)?)?;
-
     Ok(())
 }

wheel/src/lib.rs

@@ -1,4 +1,3 @@
-pub mod adapt_response;
+mod adapt_response;
 pub mod api;
 pub mod lazy_node;
-mod run_program;