added profiling time

Cargo.toml

@@ -100,3 +100,5 @@ path = "src/bin/dfg.rs"
 name = "compile-shaders"
 path = "src/bin/compile-shaders.rs"
 
+[profile.release]
+debug = 1

lisp/examples/mint2.lisp

@@ -306,10 +306,10 @@
   (            
     (def! param-u (scalar "6800f4fa0f001cfc7ff6826ad58004b4d1d8da41af03744e3bce3b7793664337"))
     (def! param-v (scalar "6d81d3a9cb45dedbe6fb2a6e1e22ab50ad46f1b0473b803b3caefab9380b6a8b"))
-    (def! param-a (scalar 110))
-    (rangeproof param-u)
-    ;; (def! param3 (rnd-scalar))
-    ;; (jj-mul param-u param-v param3)
+    ;; (def! param-a (scalar 110))
+    ;; (rangeproof param-a)
+    (def! param3 (rnd-scalar))
+    (jj-mul param-u param-v param3)
   )
 )
 

lisp/lisp.rs

@@ -147,6 +147,8 @@ fn eval_ast(ast: &MalVal, env: &Env) -> MalRet {
 fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
     let ret: MalRet;
 
+    let start = Instant::now();
+
     'tco: loop {
         ret = match ast.clone() {
             List(l, _) => {
@@ -573,6 +575,8 @@ fn eval(mut ast: MalVal, mut env: Env) -> MalRet {
         break;
     } // end 'tco loop
 
+    println!("eval end \t {:?} \t {:?}", ast, start.elapsed());
+
     ret
 }
 
@@ -648,7 +652,7 @@ pub fn setup(_ast: MalVal, env: Env) -> Result<VerifyKeyParams, MalErr> {
     })
 }
 
-pub fn prove(_ast: MalVal, env: Env) -> MalRet {
+pub fn prove(_ast: MalVal, env: Env) -> MalRet {    
     let start = Instant::now();
     let allocs_input = get_allocations(&env, "AllocationsInput");
     let allocs = get_allocations(&env, "Allocations");
@@ -664,6 +668,7 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
         };
         groth16::generate_random_parameters::<Bls12, _, _>(circuit, &mut OsRng)?
     });
+
     let verifying_key = Some(groth16::prepare_verifying_key(&params.as_ref().unwrap().vk));
     // prove
     let circuit = LispCircuit {
@@ -672,7 +677,6 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
         alloc_inputs: allocs_input.borrow().clone(),
         constraints: enforce_allocs.clone(),
     };
-
     let proof = groth16::create_random_proof(circuit, params.as_ref().unwrap(), &mut OsRng)?;
     let mut vec_input = vec![];
     for (k, val) in allocs_input.borrow_mut().iter() {
@@ -686,10 +690,13 @@ pub fn prove(_ast: MalVal, env: Env) -> MalRet {
             _ => {}
         };
     }
+    println!("groth16::create_random_proof: {:?}", start.elapsed());
+    // verification process 
+    let start = Instant::now();
     let result = groth16::verify_proof(verifying_key.as_ref().unwrap(), &proof, &vec_input);
+    println!("groth16::verify_proof: {:?}", start.elapsed());
     println!("vec public {:?}", vec_input);
-    println!("result {:?}", result);
-    println!("Elapsed time: {:?}", start.elapsed());
+    println!("result {:?}", result);    
     Ok(MalVal::Nil)
 }
 
@@ -746,6 +753,7 @@ fn main() -> Result<(), ()> {
 }
 
 fn repl_load(file: String) -> Result<(), ()> {
+    let start = Instant::now();
     let repl_env = env_new(None);
     for (k, v) in core::ns() {
         env_sets(&repl_env, k, v);
@@ -756,10 +764,21 @@ fn repl_load(file: String) -> Result<(), ()> {
         &repl_env,
     );
     match rep(&format!("(load-file \"{}\")", file), &repl_env) {
-        Ok(_) => std::process::exit(0),
+        Ok(_) => {
+            println!("lisp end \t {:?}", start.elapsed());
+            std::process::exit(0) 
+        },
         Err(e) => {
             println!("Error: {}", format_error(e));
             std::process::exit(1);
         }
+    }    
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
     }
 }

lisp/types.rs

@@ -1,6 +1,6 @@
 use bellman::{gadgets::Assignment, groth16, Circuit, ConstraintSystem, SynthesisError};
 use sapvi::bls_extensions::BlsStringConversion;
-use std::ops::{Add, AddAssign, MulAssign, SubAssign};
+use std::{ops::{Add, AddAssign, MulAssign, SubAssign}, time::Instant};
 use std::rc::Rc;
 use std::{cell::RefCell, collections::HashMap};
 // use fnv::FnvHashMap;
@@ -71,8 +71,10 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
         cs: &mut CS,
     ) -> Result<(), SynthesisError> {
         let mut variables: HashMap<String, Variable> = HashMap::default();
-        let mut params_const = self.params;
-
+        let params_const = self.params;
+        
+        let circuitTime = Instant::now();
+        let start = Instant::now();
         // println!("Allocations\n");
         for (k, v) in &self.allocs {
             match v {
@@ -96,7 +98,8 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 }
             }
         }
-
+        println!("circuit alloc \t {:?}", start.elapsed());
+        let start = Instant::now();        
         // println!("Allocations Input\n");
         for (k, v) in &self.alloc_inputs {
             match v {
@@ -116,8 +119,8 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 }
             }
         }
-
-        println!("Enforce Allocations\n");
+        println!("circuit alloc input \t {:?}", start.elapsed());        
+        let start = Instant::now();
         let mut enforce_sorted = self.constraints.clone();
         enforce_sorted.sort_by(|a, b| a.idx.cmp(&b.idx));
         for alloc_value in enforce_sorted.iter() {
@@ -130,7 +133,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                 let (a, b) = values;
                 let mut val_b = CS::one();
                 if b != "cs::one" {
-                    println!("{:?}", b);
+                    // println!("{:?}", b);
                     val_b = *variables.get(b).unwrap();
                 }
                 if a == "scalar::one" {
@@ -160,7 +163,7 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                         }
                     }
                 }
-                println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                // println!("left: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.right.iter() {
@@ -196,14 +199,14 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                         }
                     }
                 }
-                println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                // println!("right: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
             for values in alloc_value.output.iter() {
                 let (a, b) = values;
                 let mut val_b = CS::one();
                 if b != "cs::one" {
-                    println!("{:?}", b);
+                    // println!("{:?}", b);
                     val_b = *variables.get(b).unwrap();
                 }
                 if a == "scalar::one" {
@@ -233,18 +236,19 @@ impl Circuit<bls12_381::Scalar> for LispCircuit {
                         }
                     }
                 }
-                println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
+                // println!("output: a {:?} b {:?} val_b: {:?}", a, b, val_b);
             }
 
-            println!("Enforcing ...");
+            // println!("Enforcing ...");
             cs.enforce(
                 || "constraint",
                 |_| left.clone(),
                 |_| right.clone(),
                 |_| output.clone(),
             );
-        }
-
+        }     
+        println!("circuit enforce \t {:?}", start.elapsed());        
+        println!("end circuit \t {:?}", circuitTime.elapsed());        
         Ok(())
     }
 }