Added tests

utxo/src/filter_expr/compiler/optimizations/move_load_top.rs

@@ -0,0 +1,105 @@
+use crate::filter_expr::opcode::OpCode;
+use std::collections::HashMap;
+
+/// Move the LOAD to the Top of the program
+///
+/// This optimization will allow the VM to execute all the LOAD operations at the beginning of the
+/// program, once, then clone the initial state of the registers and execute the rest of them.
+///
+/// This optimization works under the assumption that cloning the registers is faster than executing
+/// it
+pub fn move_load_top(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
+    let mut load_new_indexes = HashMap::new();
+    let mut new_index = opcodes.len();
+
+    if opcodes
+        .iter()
+        .fold((true, false), |(is_sorted, non_load_stage), opcode| {
+            let is_load_opcode = match opcode {
+                OpCode::LOAD(reg, _) => {
+                    load_new_indexes.insert(*reg, new_index.into());
+                    new_index += 1;
+                    true
+                }
+                _ => false,
+            };
+
+            if non_load_stage && is_load_opcode {
+                (false, true)
+            } else if !is_load_opcode {
+                (is_sorted, true)
+            } else {
+                (is_sorted, non_load_stage)
+            }
+        })
+        .0
+    {
+        // already sorted, all the LOAD opcodes are at the beginning of the program
+        return (opcodes, false);
+    }
+
+    /// assign new indexes to the static registers and rewrite the entire opcodes to use the new
+    /// addresses
+    opcodes.iter_mut().for_each(|opcode| match opcode {
+        OpCode::LOAD(reg, _) => {
+            *reg = load_new_indexes[reg];
+        }
+        OpCode::LABEL(_) | OpCode::JMP(_) => {}
+        OpCode::LOAD_EXTERNAL(dst, _)
+        | OpCode::HLT(dst)
+        | OpCode::JEQ(dst, _)
+        | OpCode::JNE(dst, _) => {
+            if let Some(new_dst) = load_new_indexes.get(dst) {
+                *dst = *new_dst;
+            }
+        }
+        OpCode::MOV(dst, reg1)
+        | OpCode::SHL(dst, reg1, _)
+        | OpCode::CPY(dst, reg1)
+        | OpCode::SHR(dst, reg1, _)
+        | OpCode::NEG(dst, reg1)
+        | OpCode::NOT(dst, reg1) => {
+            if let Some(value) = load_new_indexes.get(reg1) {
+                *reg1 = *value;
+            }
+            if let Some(new_dst) = load_new_indexes.get(dst) {
+                *dst = *new_dst;
+            }
+        }
+        OpCode::EQ(dst, reg1, reg2)
+        | OpCode::GE(dst, reg1, reg2)
+        | OpCode::GT(dst, reg1, reg2)
+        | OpCode::LE(dst, reg1, reg2)
+        | OpCode::LT(dst, reg1, reg2)
+        | OpCode::NE(dst, reg1, reg2)
+        | OpCode::AND(dst, reg1, reg2)
+        | OpCode::OR(dst, reg1, reg2)
+        | OpCode::XOR(dst, reg1, reg2)
+        | OpCode::ADD(dst, reg1, reg2)
+        | OpCode::SUB(dst, reg1, reg2)
+        | OpCode::MUL(dst, reg1, reg2)
+        | OpCode::DIV(dst, reg1, reg2)
+        | OpCode::MOD(dst, reg1, reg2) => {
+            if let Some(value) = load_new_indexes.get(reg1) {
+                *reg1 = *value;
+            }
+            if let Some(value) = load_new_indexes.get(reg2) {
+                *reg2 = *value;
+            }
+            if let Some(new_dst) = load_new_indexes.get(dst) {
+                *dst = *new_dst;
+            }
+        }
+    });
+
+    // split the opcodes into two parts, the LOAD opcodes and the rest
+    let mut parts: (Vec<_>, Vec<_>) = opcodes
+        .into_iter()
+        .partition(|opcode| matches!(opcode, OpCode::LOAD(_, _)));
+
+    // merge both parts
+    let mut new_opcodes = parts.0;
+    new_opcodes.extend(parts.1);
+
+    (new_opcodes, true)
+}

utxo/src/filter_expr/compiler/optimizations/remove_redundant_load_and_mov.rs

@@ -1,5 +1,10 @@
 use crate::filter_expr::opcode::OpCode;
 
+/// Convert:
+///     LOAD reg var
+///     MOV target reg
+/// To:
+///     LOAD target var
 pub fn remove_redundant_load_and_mov(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool) {
     let old_total_opcodes = opcodes.len();
     let new_opcodes = opcodes.into_iter().fold(Vec::new(), |mut acc, current| {

utxo/src/filter_expr/filter.rs

@@ -120,63 +120,3 @@ impl<'a> Filter<'a> {
         )
     }
 }
-
-#[cfg(test)]
-mod test {
-    use super::Filter;
-    use crate::filter_expr::{
-        opcode::OpCode,
-        value::{Value, ValueOrRef},
-    };
-
-    #[test]
-    fn parse() {
-        let mut x = Filter::new(
-            r#"
-            WHERE
-                $foo = 3 + 2 * 4 / 2 * 298210 + $bar
-                AND 25 = 5*$five
-        "#,
-        )
-        .unwrap();
-        println!("{}\n", x.dump());
-
-        let mut x = x.optimize();
-        println!("{}\n", x.dump());
-
-        let external_variables_1 = vec![
-            ("foo".into(), ValueOrRef::Value(0.into())),
-            ("bar".into(), ValueOrRef::Value(0.into())),
-            ("five".into(), ValueOrRef::Value(5.into())),
-        ]
-        .into_iter()
-        .collect();
-
-        let external_variables_2 = vec![
-            ("foo".into(), ValueOrRef::Value(1192844.into())),
-            ("bar".into(), ValueOrRef::Value(1.into())),
-            ("five".into(), ValueOrRef::Value(4.into())),
-        ]
-        .into_iter()
-        .collect();
-
-        let external_variables_3 = vec![
-            ("foo".into(), ValueOrRef::Value(1192844.into())),
-            ("bar".into(), ValueOrRef::Value(1.into())),
-            ("five".into(), ValueOrRef::Value(5.into())),
-        ]
-        .into_iter()
-        .collect();
-
-        for i in 0..100_000 {
-            let value = x.execute(&external_variables_1).expect("valid execution");
-            assert!(matches!(value, Value::Bool(false)));
-
-            let value = x.execute(&external_variables_2).expect("valid execution");
-            assert!(matches!(value, Value::Bool(false)));
-
-            let value = x.execute(&external_variables_3).expect("valid execution");
-            assert!(matches!(value, Value::Bool(true)));
-        }
-    }
-}

utxo/src/filter_expr/mod.rs

@@ -12,6 +12,9 @@ mod parser;
 mod runtime;
 mod value;
 
+#[cfg(test)]
+mod tests;
+
 pub use self::{filter::Filter, value::Value};
 
 #[derive(
@@ -54,7 +57,7 @@ impl Addr {
     }
 }
 
-#[derive(thiserror::Error, Debug)]
+#[derive(thiserror::Error, Debug, PartialEq)]
 pub enum Error {
     #[error("Variable not found: {0}")]
     VariableNotFound(String),

utxo/src/filter_expr/runtime.rs

@@ -6,10 +6,7 @@ use super::{
 };
 use crate::Transaction;
 use num::CheckedAdd;
-use std::{
-    collections::{HashMap, VecDeque},
-    ops::Deref,
-};
+use std::{collections::HashMap, ops::Deref};
 
 macro_rules! get {
     ($r:expr,$pos:expr) => {

utxo/src/filter_expr/tests/mod.rs

@@ -0,0 +1,50 @@
+use crate::filter_expr::value::ValueOrRef;
+
+use super::{expr::Variable, Error, Filter, Value};
+use std::collections::HashMap;
+
+fn testsuite<K: Into<Variable>, V: Into<Value>, R: Into<Value>>(
+    code: &str,
+    external_variables: Vec<(K, V)>,
+    ret: Result<R, Error>,
+) {
+    let filter = Filter::new(code).expect("valid filter");
+    let external_variables = external_variables
+        .into_iter()
+        .map(|(k, v)| (k.into(), ValueOrRef::Value(v.into())))
+        .collect();
+    assert_eq!(filter.execute(&external_variables), ret.map(|x| x.into()));
+}
+
+#[test]
+fn test_1() {
+    testsuite(
+        include_str!("program1.expr"),
+        vec![("external", 5)],
+        Ok(true),
+    );
+    testsuite(
+        include_str!("program1.expr"),
+        vec![("external", 4)],
+        Ok(false),
+    );
+}
+
+#[test]
+fn nested() {
+    testsuite(
+        include_str!("nested.expr"),
+        vec![("foo", 0), ("bar", 0), ("five", 5)],
+        Ok(false),
+    );
+    testsuite(
+        include_str!("nested.expr"),
+        vec![("foo", 1192844), ("bar", 1), ("five", 4)],
+        Ok(false),
+    );
+    testsuite(
+        include_str!("nested.expr"),
+        vec![("foo", 1192844), ("bar", 1), ("five", 5)],
+        Ok(true),
+    );
+}

utxo/src/filter_expr/tests/nested.expr

@@ -0,0 +1,3 @@
+   WHERE
+    $foo = 3 + 2 * 4 / 2 * 298210 + $bar
+    AND 25 = 5*$five

utxo/src/filter_expr/tests/program1.expr

@@ -0,0 +1,4 @@
+WHERE
+    5 + 1 = $external + 1
+    AND 5 = $external
+LIMIT 5