Fix some issues detected while testing system

Author: franvipa

edgeless_cloud_offloading/README.md

@@ -56,15 +56,15 @@ security_group_id = "sg-xxxxxxxxxxxxxxxxx"
 [scaling.thresholds]
 # --- Scale-Up Triggers ---
 # Sum of "credits" from overloaded nodes to trigger a scale-up
-credit_overload = 1.0
+credit_overload = 2.0
 # CPU percentage above which a node is considered saturated
-cpu_high_percent = 80.0
+cpu_high_percent = 75.0
 # Memory percentage above which a node is considered saturated
-mem_high_percent = 80.0
+mem_high_percent = 75.0
 
 # --- Scale-Down Triggers ---
 # CPU percentage below which a node is considered underutilized
-cpu_low_percent = 10.0
+cpu_low_percent = 20.0
 # Memory percentage below which a node is considered underutilized
 mem_low_percent = 20.0
 # Time in seconds a node must remain underutilized before being deleted

edgeless_cloud_offloading/src/config.rs

@@ -78,11 +78,11 @@ impl Default for AwsConfig {
 impl Default for ThresholdsConfig {
     fn default() -> Self {
         Self {
-            credit_overload: 1.0,
-            cpu_high_percent: 80.0,
-            mem_high_percent: 80.0,
-            cpu_low_percent: 30.0,
-            mem_low_percent: 40.0,
+            credit_overload: 2.0,
+            cpu_high_percent: 75.0,
+            mem_high_percent: 75.0,
+            cpu_low_percent: 20.0,
+            mem_low_percent: 20.0,
             delete_cooldown_seconds: 30,
         }
     }

edgeless_cloud_offloading/src/lib.rs

@@ -24,6 +24,7 @@ pub struct CloudNodeData {
     pub node_id: String,
     pub active: bool,
     pub creation_time: Instant,
+    pub activation_time: Option<Instant>,
 }
 
 fn generate_instance_name() -> String {
@@ -84,6 +85,7 @@ pub async fn create_cloud_node(input_data: CloudNodeInputData) -> Result<CloudNo
         node_id,
         active: false,
         creation_time: Instant::now(),
+        activation_time: None,
     };
 
     Ok(cloud_node)

edgeless_cloud_offloading/src/main.rs

@@ -12,6 +12,7 @@ use std::time::Duration;
 use tokio::time::sleep;
 
 const DEFAULT_CONFIG_FILENAME: &str = "cloud_offloading.toml";
+const NODE_STABILIZATION_TIME_SECS: u64 = 120;
 
 #[derive(Parser, Debug)]
 #[command(author, about, long_about = None)]
@@ -90,6 +91,7 @@ async fn run_cloud_offloading_delegated_orc(config: Config) -> anyhow::Result<()
         for node in cloud_nodes.iter_mut() {
             if !node.active && active_orc_nodes.contains(&node.node_id) {
                 node.active = true;
+                node.activation_time = Some(std::time::Instant::now());
                 log::info!("Cloud node {} is now active in the orchestrator!", node.node_id);
                 // After a node becomes active, we force a rebalance to ensure it receives load
                 rebalancer.rebalance_cluster();
@@ -138,7 +140,9 @@ async fn run_cloud_offloading_delegated_orc(config: Config) -> anyhow::Result<()
         // 2. DECIDE WHETHER TO CREATE A NEW NODE
         // Only create a new node if there isn't one already being created.
         // If the total number of active nodes is less than the minimum required, we also create a new node.
-        let is_creating_node = cloud_nodes.iter().any(|n| !n.active);
+        let is_creating_node = cloud_nodes.iter().any(|n| {
+            !n.active || n.creation_time.elapsed().as_secs() < NODE_STABILIZATION_TIME_SECS
+        });
         if !is_creating_node
             && (rebalancer.should_create_node(
                 config.scaling.thresholds.credit_overload,
@@ -182,9 +186,21 @@ async fn run_cloud_offloading_delegated_orc(config: Config) -> anyhow::Result<()
             // We only delete a node if there are more nodes available
             if active_orc_nodes.len() > 1 {
                 // If there's no node being created or emptied, check if we can find an underutilized node to delete
-                let managed_cloud_node_ids: HashSet<String> = cloud_nodes.iter().map(|n| n.node_id.clone()).collect();
+                // and consider only nodes that have been active for a certain stabilization time
+                let stable_managed_node_ids: HashSet<String> = cloud_nodes
+                    .iter()
+                    .filter(|n| {
+                        if let Some(activation_time) = n.activation_time {
+                            activation_time.elapsed().as_secs() >= NODE_STABILIZATION_TIME_SECS
+                        } else {
+                            true // If activation_time is None, consider it stable (it was never active)
+                        }
+                    })
+                    .map(|n| n.node_id.clone())
+                    .collect();
+
                 if let Some(victim_id) = rebalancer.find_node_to_delete(
-                    &managed_cloud_node_ids,
+                    &stable_managed_node_ids,
                     config.scaling.thresholds.cpu_low_percent,
                     config.scaling.thresholds.mem_low_percent,
                 ) {