added ExecutionTimeTracker

Author: rdeioris

clarity/src/vm/clarity.rs

@@ -304,7 +304,11 @@ pub trait TransactionConnection: ClarityConnection {
 
         self.with_abort_callback(
             |vm_env| {
-                vm_env.context.set_max_execution_time(max_execution_time);
+                if let Some(max_execution_time_duration) = max_execution_time {
+                    vm_env
+                        .context
+                        .set_max_execution_time(max_execution_time_duration);
+                }
                 vm_env
                     .execute_transaction(
                         sender.clone(),

clarity/src/vm/contexts.rs

@@ -182,6 +182,17 @@ pub struct EventBatch {
     pub events: Vec<StacksTransactionEvent>,
 }
 
+/** ExecutionTimeTracker keeps track of how much time a contract call is taking.
+   It is checked at every eval call.
+*/
+pub enum ExecutionTimeTracker {
+    NoTracking,
+    MaxTime {
+        start_time: Instant,
+        max_duration: Duration,
+    },
+}
+
 /** GlobalContext represents the outermost context for a single transaction's
      execution. It tracks an asset changes that occurred during the
      processing of the transaction, whether or not the current context is read_only,
@@ -200,8 +211,7 @@ pub struct GlobalContext<'a, 'hooks> {
     /// This is the chain ID of the transaction
     pub chain_id: u32,
     pub eval_hooks: Option<Vec<&'hooks mut dyn EvalHook>>,
-    pub execution_time_tracker: Instant,
-    pub max_execution_time: Option<Duration>,
+    pub execution_time_tracker: ExecutionTimeTracker,
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -1556,17 +1566,19 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
             epoch_id,
             chain_id,
             eval_hooks: None,
-            execution_time_tracker: Instant::now(),
-            max_execution_time: None,
+            execution_time_tracker: ExecutionTimeTracker::NoTracking,
         }
     }
 
     pub fn is_top_level(&self) -> bool {
         self.asset_maps.is_empty()
     }
 
-    pub fn set_max_execution_time(&mut self, max_execution_time: Option<Duration>) {
-        self.max_execution_time = max_execution_time
+    pub fn set_max_execution_time(&mut self, max_execution_time: Duration) {
+        self.execution_time_tracker = ExecutionTimeTracker::MaxTime {
+            start_time: Instant::now(),
+            max_duration: max_execution_time,
+        }
     }
 
     fn get_asset_map(&mut self) -> Result<&mut AssetMap> {

clarity/src/vm/mod.rs

@@ -64,10 +64,10 @@ use self::ast::ContractAST;
 use self::costs::ExecutionCost;
 use self::diagnostic::Diagnostic;
 use crate::vm::callables::CallableType;
-use crate::vm::contexts::GlobalContext;
 pub use crate::vm::contexts::{
     CallStack, ContractContext, Environment, LocalContext, MAX_CONTEXT_DEPTH,
 };
+use crate::vm::contexts::{ExecutionTimeTracker, GlobalContext};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{
     runtime_cost, CostOverflowingMath, CostTracker, LimitedCostTracker, MemoryConsumer,
@@ -304,11 +304,20 @@ pub fn apply(
     }
 }
 
-fn check_max_execution_time_expired(global_context: &GlobalContext) -> bool {
-    if let Some(max_execution_time) = global_context.max_execution_time {
-        return global_context.execution_time_tracker.elapsed() >= max_execution_time;
+fn check_max_execution_time_expired(global_context: &GlobalContext) -> Result<()> {
+    match global_context.execution_time_tracker {
+        ExecutionTimeTracker::NoTracking => Ok(()),
+        ExecutionTimeTracker::MaxTime {
+            start_time,
+            max_duration,
+        } => {
+            if start_time.elapsed() >= max_duration {
+                Err(CostErrors::ExecutionTimeExpired.into())
+            } else {
+                Ok(())
+            }
+        }
     }
-    false
 }
 
 pub fn eval(
@@ -320,14 +329,7 @@ pub fn eval(
         Atom, AtomValue, Field, List, LiteralValue, TraitReference,
     };
 
-    if check_max_execution_time_expired(env.global_context) {
-        warn!(
-            "ExecutionTime expired while running {:?} ({:?} elapsed)",
-            exp,
-            env.global_context.execution_time_tracker.elapsed()
-        );
-        return Err(CostErrors::ExecutionTimeExpired.into());
-    }
+    check_max_execution_time_expired(env.global_context)?;
 
     if let Some(mut eval_hooks) = env.global_context.eval_hooks.take() {
         for hook in eval_hooks.iter_mut() {
@@ -616,7 +618,7 @@ pub fn execute_with_max_execution_time(
         ast::ASTRules::PrecheckSize,
         false,
         |g| {
-            g.set_max_execution_time(Some(max_execution_time));
+            g.set_max_execution_time(max_execution_time);
             Ok(())
         },
     )