Merge pull request #247 from nyannyacha/fix-cpu-limit-zero

fix: supervisor should also consider cases where the CPU time limit is zero

Author: laktek

crates/base/src/rt_worker/supervisor/mod.rs

@@ -60,6 +60,7 @@ pub struct IsolateMemoryStats {
     pub external_memory: usize,
 }
 
+#[derive(Clone, Copy)]
 pub struct CPUTimerParam {
     soft_limit_ms: u64,
     hard_limit_ms: u64,
@@ -79,7 +80,7 @@ impl CPUTimerParam {
     ) -> Option<(CPUTimer, UnboundedReceiver<()>)> {
         let (cpu_alarms_tx, cpu_alarms_rx) = mpsc::unbounded_channel::<()>();
 
-        if self.soft_limit_ms == 0 && self.hard_limit_ms == 0 {
+        if self.is_disabled() {
             return None;
         }
 
@@ -105,6 +106,10 @@ impl CPUTimerParam {
     pub fn limits(&self) -> (u64, u64) {
         (self.soft_limit_ms, self.hard_limit_ms)
     }
+
+    pub fn is_disabled(&self) -> bool {
+        self.soft_limit_ms == 0 && self.hard_limit_ms == 0
+    }
 }
 
 pub struct Arguments {

crates/base/src/rt_worker/supervisor/strategy_per_request.rs

@@ -85,8 +85,10 @@ pub async fn supervise(args: Arguments, oneshot: bool) -> (ShutdownReason, i64)
                         assert!(!is_worker_entered);
                         is_worker_entered = true;
 
-                        if let Some(Err(err)) = cpu_timer.as_ref().map(|it| it.reset()) {
-                            error!("can't reset cpu timer: {}", err);
+                        if !cpu_timer_param.is_disabled() {
+                            if let Some(Err(err)) = cpu_timer.as_ref().map(|it| it.reset()) {
+                                error!("can't reset cpu timer: {}", err);
+                            }
                         }
                     }
 
@@ -97,13 +99,15 @@ pub async fn supervise(args: Arguments, oneshot: bool) -> (ShutdownReason, i64)
                         cpu_usage_ms += diff / 1_000_000;
                         cpu_usage_accumulated_ms = accumulated / 1_000_000;
 
-                        if cpu_usage_ms >= hard_limit_ms as i64 {
-                            error!("CPU time limit reached. isolate: {:?}", key);
-                            complete_reason = Some(ShutdownReason::CPUTime);
-                        }
+                        if !cpu_timer_param.is_disabled() {
+                            if cpu_usage_ms >= hard_limit_ms as i64 {
+                                error!("CPU time limit reached. isolate: {:?}", key);
+                                complete_reason = Some(ShutdownReason::CPUTime);
+                            }
 
-                        if let Some(Err(err)) = cpu_timer.as_ref().map(|it| it.reset()) {
-                            error!("can't reset cpu timer: {}", err);
+                            if let Some(Err(err)) = cpu_timer.as_ref().map(|it| it.reset()) {
+                                error!("can't reset cpu timer: {}", err);
+                            }
                         }
                     }
                 }

crates/base/src/rt_worker/supervisor/strategy_per_worker.rs

@@ -102,8 +102,10 @@ pub async fn supervise(args: Arguments) -> (ShutdownReason, i64) {
                         assert!(!is_worker_entered);
                         is_worker_entered = true;
 
-                        if let Some(Err(err)) = cpu_timer.as_ref().map(|it| it.reset()) {
-                            error!("can't reset cpu timer: {}", err);
+                        if !cpu_timer_param.is_disabled() {
+                            if let Some(Err(err)) = cpu_timer.as_ref().map(|it| it.reset()) {
+                                error!("can't reset cpu timer: {}", err);
+                            }
                         }
                     }
 
@@ -113,22 +115,24 @@ pub async fn supervise(args: Arguments) -> (ShutdownReason, i64) {
                         is_worker_entered = false;
                         cpu_usage_ms = accumulated / 1_000_000;
 
-                        if cpu_usage_ms >= hard_limit_ms as i64 {
-                            // shutdown worker
-                            interrupt_fn(true);
-                            error!("CPU time hard limit reached. isolate: {:?}", key);
-                            return (ShutdownReason::CPUTime, cpu_usage_ms);
-                        } else if cpu_usage_ms >= soft_limit_ms as i64 && !cpu_time_soft_limit_reached {
-                                // retire worker
-                                is_retired.raise();
-                                error!("CPU time soft limit reached. isolate: {:?}", key);
-                                cpu_time_soft_limit_reached = true;
-
-                                if req_ack_count == demand.load(Ordering::Acquire) {
-                                    interrupt_fn(true);
-                                    error!("early termination due to the last request being completed. isolate: {:?}", key);
-                                    return (ShutdownReason::EarlyDrop, cpu_usage_ms);
-                                }
+                        if !cpu_timer_param.is_disabled() {
+                            if cpu_usage_ms >= hard_limit_ms as i64 {
+                                // shutdown worker
+                                interrupt_fn(true);
+                                error!("CPU time hard limit reached. isolate: {:?}", key);
+                                return (ShutdownReason::CPUTime, cpu_usage_ms);
+                            } else if cpu_usage_ms >= soft_limit_ms as i64 && !cpu_time_soft_limit_reached {
+                                    // retire worker
+                                    is_retired.raise();
+                                    error!("CPU time soft limit reached. isolate: {:?}", key);
+                                    cpu_time_soft_limit_reached = true;
+
+                                    if req_ack_count == demand.load(Ordering::Acquire) {
+                                        interrupt_fn(true);
+                                        error!("early termination due to the last request being completed. isolate: {:?}", key);
+                                        return (ShutdownReason::EarlyDrop, cpu_usage_ms);
+                                    }
+                            }
                         }
                     }
                 }