feat: Refactored instruction execution for increased performance (#11)

Author: burdockcascade

benches/fib.rs

@@ -63,7 +63,7 @@ fn fibonacci(input: i64) -> i64 {
 
     let mut vm = Vm::default();
     vm.load_program(program.build());
-    vm.run(None).unwrap().result.unwrap().into()
+    vm.run(None, None).unwrap().result.unwrap().into()
 }
 
 fn bench_fibonacci(c: &mut Criterion) {

benches/functioncall.rs

@@ -37,7 +37,7 @@ fn test_function_call() {
 
     let mut vm = Vm::default();
     vm.load_program(program.build());
-    let _ = vm.run(None);
+    let _ = vm.run(None, None);
 }
 
 fn bench_fibonacci(c: &mut Criterion) {

benches/loop.rs

@@ -37,7 +37,7 @@ fn loopy(input: i64) -> i64 {
 
     let mut vm = Vm::default();
     vm.load_program(program.build());
-    vm.run(None).unwrap().result.unwrap().into()
+    vm.run(None, None).unwrap().result.unwrap().into()
 }
 
 fn bench_fibonacci(c: &mut Criterion) {

examples/fib.rs

@@ -1,7 +1,11 @@
+use log::LevelFilter;
+use simplelog::{ColorChoice, Config, TermLogger, TerminalMode};
 use bytevm::prelude::{BlockEncoder, FunctionBuilder, ProgramBuilder, Vm};
 
 fn main() {
 
+    TermLogger::init(LevelFilter::Info, Config::default(), TerminalMode::Mixed, ColorChoice::Auto).expect("Logger error");
+    
     let input = 35;
 
     let mut program  = ProgramBuilder::default();
@@ -61,9 +65,11 @@ fn main() {
         .build()
     );
 
+    program.optimize();
+
     let mut vm = Vm::default();
     vm.load_program(program.build());
-    let result = vm.run(None).unwrap();
+    let result = vm.run(None, None).unwrap();
 
     println!("Time taken: {:?}", result.run_time.as_secs_f64());
 

examples/math.rs

@@ -0,0 +1,53 @@
+use log::LevelFilter;
+use simplelog::{ColorChoice, Config, TermLogger, TerminalMode};
+use bytevm::prelude::{BlockEncoder, FunctionBuilder, ProgramBuilder, Vm};
+
+fn main() {
+
+    TermLogger::init(LevelFilter::Trace, Config::default(), TerminalMode::Mixed, ColorChoice::Auto).expect("Logger error");
+
+    
+    let mut program  = ProgramBuilder::default();
+
+    program.add_function(FunctionBuilder::default()
+        .name("main")
+        .arity(0)
+        .body(
+            BlockEncoder::default()
+                // Call the add function with 1 and 2
+                .push_integer(1)
+                .push_integer(2)
+                .call_function_by_name("add")
+                // Return the result
+                .return_value()
+        )
+        .build()
+    );
+
+    program.add_function(FunctionBuilder::default()
+        .name("add")
+        .arity(2)
+        .body(
+            BlockEncoder::default()
+                .declare_local("a")
+                .declare_local("b")
+                .declare_local("result")
+                .get_local("a")
+                .get_local("b")
+                .add()
+                .set_local("result")
+                .get_local("result")
+                .return_value()
+        )
+        .build()
+    );
+
+    program.optimize();
+
+    let mut vm = Vm::default();
+    vm.load_program(program.build());
+    let result = vm.run(None, None).unwrap();
+
+    println!("Time taken: {:?}", result.run_time.as_secs_f64());
+
+}

src/builder.rs

@@ -28,20 +28,25 @@ impl ProgramBuilder {
     pub fn add_symbol(&mut self, name: String, entry: SymbolEntry) {
         self.program.symbol_table.insert(name, entry);
     }
-
-    pub fn build(mut self) -> Program {
+    
+    pub fn optimize(&mut self) {
 
         // Resolve function references with function index
         for function in &mut self.program.functions {
             for instruction in &mut function.instructions {
                 if let Instruction::FunctionCall(CallTarget::Name(name)) = instruction {
                     if let Some(SymbolEntry::UserDefinedFunction { index }) = self.program.symbol_table.get(name) {
                         *instruction = Instruction::FunctionCall(CallTarget::Index(*index));
+                    } else {
+                        panic!("Function {} not found", name);
                     }
                 }
             }
         }
+        
+    }
 
+    pub fn build(self) -> Program {
         self.program
     }
 }
@@ -321,7 +326,7 @@ impl BlockEncoder {
     pub fn return_value(&mut self) -> &mut Self {
         self.push(Instruction::Return)
     }
-    
+
     /// End function execution.
     pub fn end_function(&mut self) -> &mut Self {
         self.push(Instruction::EndFunction)