Update

Author: bedogni@unimore.it

None

@@ -0,0 +1,16 @@
+inference_id,timestamp,avg_device_time,min_device_time,max_device_time,avg_edge_time,min_edge_time,max_edge_time,num_device_layers,num_edge_layers
+1,2026-01-21T19:19:17.471255,0.010910704984503278,0.010067939758300781,0.012644767761230469,0,0,0,59,0
+2,2026-01-21T19:19:19.020886,0.011460065841674805,0.011460065841674805,0.011460065841674805,0.0006384972868294552,0.0005071163177490234,0.001268148422241211,1,58
+3,2026-01-21T19:19:20.546745,0.01173710823059082,0.01173710823059082,0.01173710823059082,0.0008302187097483668,0.0006759166717529297,0.0027070045471191406,1,58
+4,2026-01-21T19:19:22.091189,0.012285947799682617,0.012285947799682617,0.012285947799682617,0.0009110015014122272,0.0006470680236816406,0.0023860931396484375,1,58
+5,2026-01-21T19:19:23.617468,0.012113094329833984,0.012113094329833984,0.012113094329833984,0.0008099449091944201,0.0006158351898193359,0.0018260478973388672,1,58
+6,2026-01-21T19:19:25.256828,0.011109113693237305,0.011109113693237305,0.011109113693237305,0.0007914304733276367,0.0005650520324707031,0.0013270378112792969,1,58
+7,2026-01-21T19:19:26.818955,0.01017308235168457,0.01017308235168457,0.01017308235168457,0.0009169373018988248,0.0006320476531982422,0.002526998519897461,1,58
+8,2026-01-21T19:19:28.425736,0.01236104965209961,0.01236104965209961,0.01236104965209961,0.0010416096654431574,0.0007081031799316406,0.005360841751098633,1,58
+9,2026-01-21T19:19:29.947933,0.01035308837890625,0.01035308837890625,0.01035308837890625,0.0008198721655483903,0.0006811618804931641,0.0013899803161621094,1,58
+10,2026-01-21T19:19:31.451980,0.010391950607299805,0.010391950607299805,0.010391950607299805,0.0008155025284865807,0.0006880760192871094,0.0012340545654296875,1,58
+11,2026-01-21T19:19:33.099707,0.012675046920776367,0.012675046920776367,0.012675046920776367,0.0007025578926349508,0.000553131103515625,0.0010211467742919922,1,58
+12,2026-01-21T19:19:34.630296,0.010178089141845703,0.010178089141845703,0.010178089141845703,0.0007392168045043945,0.0005629062652587891,0.0016140937805175781,1,58
+13,2026-01-21T19:19:36.205286,0.010623931884765625,0.010623931884765625,0.010623931884765625,0.0007768129480296168,0.0005660057067871094,0.001711130142211914,1,58
+14,2026-01-21T19:19:37.731927,0.01018524169921875,0.01018524169921875,0.01018524169921875,0.0007240073434237776,0.0005450248718261719,0.0018589496612548828,1,58
+15,2026-01-21T19:19:39.266810,0.010265111923217773,0.010265111923217773,0.010265111923217773,0.0007337825051669417,0.0005698204040527344,0.0016589164733886719,1,58

server_client_light/client/http_config.yaml

@@ -4,13 +4,13 @@ client:
 delay_simulation:
   device_computation:
     enabled: true
-    mean: 0.01
-    std_dev: 0.0005
-    type: gaussian
+    std_dev: 0.5
+    type: static
+    value: 0.0001
   network:
     enabled: true
-    mean: 1
-    std_dev: 0.02
+    mean: 0.5
+    std_dev: 1
     type: gaussian
 http:
   endpoints:

simulation_runner.py

@@ -35,26 +35,28 @@
 SERVER_SETTINGS_FILE = SCRIPT_DIR / "src" / "server" / "settings.yaml"
 RESULTS_DIR = SCRIPT_DIR / "simulated_results"
 
+# Use the same python interpreter that's running this script
+PYTHON_EXECUTABLE = sys.executable
+
 # Ensure results directory exists
 RESULTS_DIR.mkdir(exist_ok=True)
 
 # Simulation parameters
 SIMULATION_SCENARIOS = [
 
-    # Scenario 8: Multiple clients (no delay)
+    # Scenario 8: Heavy device delay test (device slow, edge fast)
     {
         "name": "heavy_delay",
         "edge_computation_delay": {"enabled": False},
         "device_computation_delay": {
-            "enabled": False,
-            "type": "gaussian",
-            "mean": 0.01,
-            "std_dev": 0.0005
+            "enabled": True,
+            "type": "static",
+            "value": 0.01  # 10ms per layer = 590ms total for 59 layers
         },
-        "network_delay": {"enabled": True,
-                          "type": "gaussian",
-            "mean": 1,
-            "std_dev": 0.02
+        "network_delay": {
+            "enabled": True,
+            "type": "static",
+            "value": 0.02  # 20ms network delay
         },
         "duration_seconds": 300,
         "num_clients": 1
@@ -282,17 +284,21 @@ def start_server(self):
         server_script = SERVER_DIR / "run_edge.py"
 
         self.server_process = subprocess.Popen(
-            [sys.executable, str(server_script)],
+            [PYTHON_EXECUTABLE, str(server_script)],
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
             bufsize=1,
             cwd=str(SCRIPT_DIR)
         )
 
-        # Start thread to monitor server output
-        self.server_monitor_thread = threading.Thread(target=self._monitor_server_output, daemon=True)
-        self.server_monitor_thread.start()
+        # Start thread to print server output
+        def print_server_output():
+            for line in self.server_process.stdout:
+                print(f"[SERVER] {line.rstrip()}")
+        
+        server_output_thread = threading.Thread(target=print_server_output, daemon=True)
+        server_output_thread.start()
 
         # Wait for server to be ready
         max_wait = 15
@@ -319,96 +325,48 @@ def stop_server(self):
                 self.server_process.kill()
             self.server_process = None
 
-    def _monitor_server_output(self):
-        """Monitor server output for inference events"""
-        if not self.server_process:
-            return
-        
-        for line in self.server_process.stdout:
-            # Look for inference completion patterns
-            # Adjust these patterns based on actual server output
-            if "inference" in line.lower() or "layer" in line.lower():
-                # Try to extract inference data from logs
-                self._try_capture_inference_event(line)
-    
-    def _try_capture_inference_event(self, log_line):
-        """Try to capture inference event from log line"""
-        # This is called when we detect potential inference activity
-        # We'll also check files for more reliable data
-        pass
-    
-    def _check_and_record_new_inferences(self):
-        """Check server data files and record any new inferences"""
+    def setup_simulation_csv(self, csv_file_path):
+        """Setup CSV file in the request handler for direct recording"""
         try:
-            # Read the latest inference result directly from the server
-            latest_inference_file = SCRIPT_DIR / "src" / "server" / "latest_inference_result.json"
+            # Import here to avoid circular imports
+            import requests
 
-            if latest_inference_file.exists():
-                with open(latest_inference_file, 'r') as f:
-                    inference_data = json.load(f)
-                
-                # Check if this is a new inference (different timestamp)
-                current_timestamp = inference_data.get('timestamp')
-                if current_timestamp != self.last_inference_timestamp:
-                    self.last_inference_timestamp = current_timestamp
-                    
-                    # Get the actual measured times from this inference
-                    device_layer_times = inference_data.get('device_layers_inference_time', [])
-                    edge_layer_times = inference_data.get('edge_layers_inference_time', [])
-                    offloading_layer = inference_data.get('offloading_layer_index', -1)
-                    
-                    # Build device_times dict from the actual measurements
-                    device_times = {}
-                    for i, time_val in enumerate(device_layer_times):
-                        device_times[f'layer_{i}'] = time_val
-                    
-                    # Build edge_times dict from the actual measurements
-                    edge_times = {}
-                    if edge_layer_times:
-                        # Edge layers start from offloading_layer + 1
-                        start_edge_layer = offloading_layer + 1
-                        for i, time_val in enumerate(edge_layer_times):
-                            edge_times[f'layer_{start_edge_layer + i}'] = time_val
-                    
-                    # Record this inference
-                    self._record_inference(device_times, edge_times)
+            # Call the server endpoint to set up CSV recording
+            response = requests.post(
+                f"http://{self.server_host}:{self.server_port}/api/set_simulation_csv",
+                json={"csv_file_path": str(csv_file_path)},
+                timeout=5
+            )
+            if response.status_code == 200:
+                print(f"✓ Server CSV recording enabled: {csv_file_path}")
+                return True
+            else:
+                print(f"⚠ Failed to enable server CSV recording: {response.status_code}")
+                return False
         except Exception as e:
-            pass  # Silently ignore errors during monitoring
+            print(f"⚠ Could not setup server CSV recording: {e}")
+            return False
 
-    def _record_inference(self, device_times, edge_times):
-        """Record a single inference to CSV"""
-        if not self.csv_writer:
-            return
-        
-        self.inference_count += 1
-        
-        # Calculate statistics
-        device_values = [v for k, v in device_times.items() if k.startswith('layer_') and isinstance(v, (int, float))]
-        edge_values = [v for k, v in edge_times.items() if k.startswith('layer_') and isinstance(v, (int, float))]
-        
-        row = {
-            'inference_id': self.inference_count,
-            'timestamp': datetime.now().isoformat(),
-            'avg_device_time': sum(device_values) / len(device_values) if device_values else 0,
-            'min_device_time': min(device_values) if device_values else 0,
-            'max_device_time': max(device_values) if device_values else 0,
-            'avg_edge_time': sum(edge_values) / len(edge_values) if edge_values else 0,
-            'min_edge_time': min(edge_values) if edge_values else 0,
-            'max_edge_time': max(edge_values) if edge_values else 0,
-            'num_device_layers': len(device_values),
-            'num_edge_layers': len(edge_values),
-        }
-        
-        self.csv_writer.writerow(row)
-        self.csv_file.flush()  # Ensure data is written immediately
+    def close_simulation_csv(self):
+        """Close CSV file in the request handler"""
+        try:
+            import requests
+            response = requests.post(
+                f"http://{self.server_host}:{self.server_port}/api/close_simulation_csv",
+                timeout=5
+            )
+            return response.status_code == 200
+        except Exception as e:
+            print(f"⚠ Could not close server CSV: {e}")
+            return False
 
     def start_client(self, client_index=0):
         """Start a client and monitor its output"""
         print(f"  Starting client {client_index}...")
         client_script = CLIENT_DIR / "http_client.py"
 
         process = subprocess.Popen(
-            [sys.executable, str(client_script)],
+            [PYTHON_EXECUTABLE, str(client_script)],
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
@@ -428,11 +386,11 @@ def start_client(self, client_index=0):
         return process
 
     def _monitor_client_output(self, process, client_index):
-        """Monitor client output for inference completion"""
+        """Monitor client output (for logging purposes)"""
         for line in process.stdout:
-            if "Inference complete" in line or "✓" in line:
-                # Inference completed, check and record
-                self._check_and_record_new_inferences()
+            # Just consume the output to prevent buffer overflow
+            # Actual recording happens on the server side
+            pass
 
     def stop_clients(self):
         """Stop all client processes"""
@@ -526,7 +484,7 @@ def run_scenario(self, scenario):
 
         try:
             # Create folder for this scenario
-            self.create_scenario_folder(scenario)
+            csv_file_path = self.create_scenario_folder(scenario)
 
             # Update configurations
             self.update_server_config(scenario)
@@ -535,18 +493,18 @@ def run_scenario(self, scenario):
             self.start_server()
             time.sleep(3)  # Extra time for server initialization
 
+            # Setup CSV recording on the server side
+            self.setup_simulation_csv(csv_file_path)
+            
             # Start clients
             for i in range(scenario['num_clients']):
                 self.update_client_config(scenario, i)
                 time.sleep(0.5)  # Small delay between client starts
                 self.start_client(i)
 
-            # Monitor and record inferences during simulation
+            # Wait for simulation duration
             print(f"\n⏳ Running for {scenario['duration_seconds']} seconds...")
-            start_time = time.time()
-            while time.time() - start_time < scenario['duration_seconds']:
-                time.sleep(2)  # Check every 2 seconds
-                self._check_and_record_new_inferences()
+            time.sleep(scenario['duration_seconds'])
 
             # Stop clients
             self.stop_clients()

src/server/communication/http_server.py

@@ -99,6 +99,28 @@ async def offloading_layer():
             except Exception as e:
                 print(f"ERROR in offloading_layer endpoint: {type(e).__name__}: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
+        
+        @self.app.post('/api/set_simulation_csv')
+        async def set_simulation_csv(data: dict):
+            try:
+                csv_file_path = data.get('csv_file_path')
+                if not csv_file_path:
+                    raise HTTPException(status_code=400, detail="csv_file_path required")
+                RequestHandler.set_simulation_csv(csv_file_path)
+                return {'message': 'CSV recording enabled', 'path': csv_file_path}
+            except Exception as e:
+                logger.error(f"Failed to set simulation CSV: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+        
+        @self.app.post('/api/close_simulation_csv')
+        async def close_simulation_csv():
+            try:
+                RequestHandler.close_simulation_csv()
+                return {'message': 'CSV recording closed'}
+            except Exception as e:
+                logger.error(f"Failed to close simulation CSV: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+                raise HTTPException(status_code=500, detail=str(e))
 
     def run(self):
         import uvicorn