Better prints

Author: bedogni@unimore.it

server_client_light/client/http_client.py

@@ -199,11 +199,8 @@ def register_device():
     payload = {"device_id": DEVICE_ID}
     try:
         r = requests.post(url, json=payload, timeout=5)
-        print("Registration:", r.status_code, r.text)
         return True
     except requests.exceptions.RequestException as e:
-        print(f"WARNING: Registration failed (server unreachable): {e}")
-        print("  → Continuing with local-only inference")
         return False
 
 # ------------------------------------------------
@@ -228,10 +225,8 @@ def send_image():
 
     try:
         r = requests.post(url, data=buffer, headers={"Content-Type": "application/octet-stream"}, timeout=5)
-        print("Image sent:", r.status_code)
         return True
     except requests.exceptions.RequestException as e:
-        print(f"WARNING: Image send failed (server unreachable): {e}")
         return False
 
 # ----------------------------
@@ -243,10 +238,8 @@ def get_offloading_layer():
         r = requests.get(url, timeout=5)
         if r.status_code == 200:
             best_layer = r.json().get("offloading_layer_index", LAST_OFFLOADING_LAYER)
-            print("Best layer received:", best_layer)
             return best_layer
         else:
-            print("Error requesting layer:", r.status_code)
             return LAST_OFFLOADING_LAYER
     except requests.exceptions.RequestException as e:
         print(f"WARNING: Cannot reach server: {e}")
@@ -283,7 +276,6 @@ def run_split_inference(image, tflite_dir, stop_layer):
     # Handle -1 as "run all layers until the end"
     if stop_layer == -1:
         stop_layer = LAST_OFFLOADING_LAYER
-        print(f"Offloading layer -1: Running all {stop_layer + 1} layers locally")
 
     for i in range(stop_layer + 1):
         model_path = str(tflite_dir / f"{SUBMODEL_PREFIX}_{i}.tflite")
@@ -300,23 +292,18 @@ def run_split_inference(image, tflite_dir, stop_layer):
         # Apply artificial computation delay
         if computation_delay.enabled:
             delay = computation_delay.apply_delay()
-            print(f"  Layer {i} computation delay: {delay*1000:.2f}ms")
 
         interpreter.invoke()
         t1 = time.time()
         inference_times.append(t1 - t0)
-        # Increase inference time with random time -> simulate a slower client
-        #t = ((t1-t0) + random.uniform(0,0.02))
-        #inference_times.append(t)
         input_data = interpreter.get_tensor(output_details[0]['index'])
-        print(f"Layer {i} OK → output shape: {input_data.shape}")
     return input_data, inference_times
 
-def send_inference_result(output_data, inference_times, layer_index, message_id):
+def send_inference_result(output_data, inference_times, layer_index, message_id, acq_time_ms):
     # Apply network delay before sending
+    send_start = time.time()
     if network_delay.enabled:
         delay = network_delay.apply_delay()
-        print(f"  Applied network delay: {delay*1000:.2f}ms")
 
     url = f"{SERVER}{ENDPOINTS['device_inference_result']}"
     timestamp = time.time()
@@ -326,19 +313,21 @@ def send_inference_result(output_data, inference_times, layer_index, message_id)
     buffer += DEVICE_ID.encode("ascii").ljust(9, b'\x00')
     buffer += message_id.encode("ascii").ljust(4, b'\x00')
     buffer += struct.pack("i", layer_index)
+    buffer += struct.pack("f", acq_time_ms / 1000.0)  # Send acquisition time in seconds
     buffer += struct.pack("I", output_data.nbytes)
     buffer += output_data.tobytes()
     buffer += struct.pack("i", len(inference_times) * 4)
     buffer += np.array(inference_times, dtype=np.float32).tobytes()
 
     try:
         r = requests.post(url, data=buffer, headers={"Content-Type": "application/octet-stream"}, timeout=5)
-        print("Output sent:", r.status_code)
-        return True
+        send_end = time.time()
+        network_time = send_end - send_start
+        data_size = len(buffer)
+        network_speed = (data_size / network_time) / 1024 if network_time > 0 else 0  # KB/s
+        return True, network_time, network_speed, data_size
     except requests.exceptions.RequestException as e:
-        print(f"WARNING: Cannot send result to server: {e}")
-        print("  → Local inference completed, result not synchronized")
-        return False
+        return False, 0, 0, 0
 
 # -----
 # MAIN
@@ -353,8 +342,12 @@ def main():
     # Try to register, but continue even if it fails
     server_available = register_device()
     if not server_available:
-        print("\nWARNING: Server not available - Running in LOCAL-ONLY mode")
-        print("  Client will continue and retry server connection on each request\n")
+        print("WARNING: Server not available - Running in LOCAL-ONLY mode\n")
+    else:
+        print("Connected to server\n")
+    
+    print("Offload | Acq Time (ms) | Comp Time (ms) | Net Time (ms) | Net Speed (KB/s) | Data (bytes)")
+    print("-" * 90)
 
     while True:
         # Try to send image (optional, just for server tracking)
@@ -363,17 +356,26 @@ def main():
         # Get offloading decision (fallback to local if server unreachable)
         best_layer = get_offloading_layer()
 
-        time.sleep(1)  # Ensure server has processed the request
         message_id = generate_message_id()
+        
+        # Measure image acquisition time
+        acq_start = time.time()
         image = load_image_rgb(IMAGE_PATH)
+        acq_end = time.time()
+        acq_time = (acq_end - acq_start) * 1000  # Convert to ms
 
         # Always run inference (local or split based on best_layer)
         output_data, inference_times = run_split_inference(image, TFLITE_DIR, best_layer)
+        comp_time = sum(inference_times) * 1000  # Convert to ms
 
         # Try to send results (for variance tracking and algorithm updates)
-        send_inference_result(output_data, inference_times, best_layer, message_id)
+        success, net_time, net_speed, data_size = send_inference_result(output_data, inference_times, best_layer, message_id, acq_time)
 
-        print(f"Inference complete (layers 0-{best_layer})\n")
+        # Print single line summary
+        if success:
+            print(f"{best_layer:7d} | {acq_time:14.2f} | {comp_time:14.2f} | {net_time*1000:12.2f} | {net_speed:16.2f} | {data_size:12d}")
+        else:
+            print(f"{best_layer:7d} | {acq_time:14.2f} | {comp_time:14.2f} | {'N/A':>12} | {'N/A':>16} | {'N/A':>12}")
 
 main()
 

src/server/communication/http_server.py

@@ -6,6 +6,8 @@
 import time
 import traceback
 import sys
+import yaml
+from pathlib import Path
 
 class HttpServer:
     def __init__(
@@ -25,6 +27,9 @@ def __init__(
         self.endpoints = endpoints
 
         self.devices = set()
+        
+        # Load verbose setting
+        self.verbose = self._load_verbose_config()
 
         # Set up model
         self.input_height = input_height
@@ -122,10 +127,32 @@ async def close_simulation_csv():
                 raise HTTPException(status_code=500, detail=str(e))
                 raise HTTPException(status_code=500, detail=str(e))
 
+    def _load_verbose_config(self):
+        """Load verbose configuration from settings.yaml"""
+        try:
+            settings_path = Path(__file__).parent.parent / "settings.yaml"
+            with open(settings_path, 'r') as f:
+                settings = yaml.safe_load(f)
+                return settings.get('verbose', False)
+        except Exception:
+            return False
+    
     def run(self):
         import uvicorn
+        import logging
+        
+        # Configure uvicorn logging based on verbose setting
+        if not self.verbose:
+            # Suppress all uvicorn and FastAPI logging
+            logging.getLogger("uvicorn").setLevel(logging.CRITICAL)
+            logging.getLogger("uvicorn.access").setLevel(logging.CRITICAL)
+            logging.getLogger("uvicorn.error").setLevel(logging.CRITICAL)
+            logging.getLogger("fastapi").setLevel(logging.CRITICAL)
+        
         uvicorn.run(
             self.app,
             host=self.host,
-            port=self.port
+            port=self.port,
+            log_level="critical" if not self.verbose else "info",
+            access_log=self.verbose
         )

src/server/communication/request_handler.py

@@ -48,26 +48,47 @@ def load_local_inference_config():
         return {'enabled': False, 'probability': 0.0}
 
 
+def load_verbose_config():
+    """Load verbose configuration from settings.yaml"""
+    settings_path = Path(__file__).parent.parent / "settings.yaml"
+    try:
+        with open(settings_path, 'r') as f:
+            settings = yaml.safe_load(f)
+            return settings.get('verbose', False)
+    except Exception as e:
+        return False
+
+
 class RequestHandler():
     # Class-level variance detector (shared across all requests)
     variance_detector = VarianceDetector(window_size=10, variance_threshold=0.15)
     # Class-level CSV file tracking for simulation results
     csv_file = None
     csv_writer = None
     inference_counter = 0
+    header_printed = False
 
     def __init__(self):
+        # Load verbose configuration
+        self.verbose = load_verbose_config()
+        
+        # Print header once
+        if not RequestHandler.header_printed:
+            print("\nDevice    | Offload | Acq Time (ms) | Device Comp (ms) | Edge Comp (ms) | Net Time (ms) | Total (ms)")
+            print("-" * 100)
+            RequestHandler.header_printed = True
+        
         # Load network delay configuration
         network_delay_config = load_network_delay_config()
         self.network_delay = DelaySimulator(network_delay_config)
-        if self.network_delay.enabled:
+        if self.network_delay.enabled and self.verbose:
             logger.info(f"Network delay simulation enabled: {self.network_delay.get_delay_info()}")
 
         # Load local inference mode configuration
         local_config = load_local_inference_config()
         self.local_inference_enabled = local_config.get('enabled', False)
         self.local_inference_probability = local_config.get('probability', 0.0)
-        if self.local_inference_enabled:
+        if self.local_inference_enabled and self.verbose:
             logger.info(f"Local inference mode enabled with probability {self.local_inference_probability:.0%}")
 
         # Initialize network speed tracking
@@ -116,7 +137,7 @@ def should_force_local_inference(self) -> bool:
         # Randomly decide based on probability
         should_force = random.random() < self.local_inference_probability
 
-        if should_force:
+        if should_force and self.verbose:
             logger.info("Forcing local-only inference to refresh device times")
 
         return should_force
@@ -125,14 +146,16 @@ def handle_registration(self, device_id):
         # Apply network delay before responding
         if self.network_delay.enabled:
             delay = self.network_delay.apply_delay()
-            logger.debug(f"Applied network delay: {delay*1000:.2f}ms")
+            if self.verbose:
+                logger.debug(f"Applied network delay: {delay*1000:.2f}ms")
         return device_id
 
     def handle_device_input(self, rgb565_image, height, width):
         # Apply network delay after receiving input
         if self.network_delay.enabled:
             delay = self.network_delay.apply_delay()
-            logger.debug(f"Applied network delay: {delay*1000:.2f}ms")
+            if self.verbose:
+                logger.debug(f"Applied network delay: {delay*1000:.2f}ms")
 
         # Extract timestamp if present (first 8 bytes)
         import struct
@@ -147,7 +170,8 @@ def handle_device_input(self, rgb565_image, height, width):
                 if latency > 0:
                     # Store in class variable for use in offloading decision
                     self.last_avg_speed = payload_size / latency
-                    logger.info(f"Network speed calculated: {self.last_avg_speed:.2f} bytes/sec (latency: {latency*1000:.2f}ms)")
+                    if self.verbose:
+                        logger.info(f"Network speed calculated: {self.last_avg_speed:.2f} bytes/sec (latency: {latency*1000:.2f}ms)")
 
                 # Remove timestamp from image data
                 rgb565_image = rgb565_image[8:]
@@ -190,12 +214,14 @@ def handle_device_inference_result(self, body, received_timestamp):
         if message_data.offloading_layer_index == -1 or message_data.offloading_layer_index >= 58:
             # All layers completed on device, no edge inference needed
             prediction = np.array(message_data.layer_output, dtype=np.float32)
-            logger.debug(f"All layers completed on device (layer_index={message_data.offloading_layer_index})")
+            if self.verbose:
+                logger.debug(f"All layers completed on device (layer_index={message_data.offloading_layer_index})")
         else:
             # Continue inference on edge from where device stopped
             prediction, edge_layer_times = Edge.run_inference(message_data.offloading_layer_index, np.array(message_data.layer_output, dtype=np.float32))
             num_edge_layers = len(edge_layer_times)
-            logger.debug(f"Edge processed {num_edge_layers} layers with times: {edge_layer_times}")
+            if self.verbose:
+                logger.debug(f"Edge processed {num_edge_layers} layers with times: {edge_layer_times}")
 
             # Update edge inference times with EMA (same alpha as device for faster adaptation)
             with open(OffloadingDataFiles.data_file_path_edge, 'r') as f:
@@ -238,29 +264,44 @@ def handle_device_inference_result(self, body, received_timestamp):
 
             RequestHandler.csv_writer.writerow(row)
             RequestHandler.csv_file.flush()
-            logger.debug(f"Recorded inference {RequestHandler.inference_counter} to CSV")
+            if self.verbose:
+                logger.debug(f"Recorded inference {RequestHandler.inference_counter} to CSV")
 
-        logger.debug(f"Prediction: {prediction.tolist()}")
+        if self.verbose:
+            logger.debug(f"Prediction: {prediction.tolist()}")
         MessageData.save_to_file(EvaluationFiles.evaluation_file_path, message_data.to_dict())
 
+        # Print clean one-line summary
+        device_id = message_data.device_id
+        offload_layer = message_data.offloading_layer_index
+        acq_time = message_data.message_content.get("acquisition_time", 0) * 1000  # Convert to ms
+        device_comp_time = sum(message_data.device_layers_inference_time) * 1000  # Convert to ms
+        edge_comp_time = sum(edge_layer_times) * 1000 if edge_layer_times else 0  # Convert to ms
+        network_time = (received_timestamp - message_data.timestamp) * 1000  # Convert to ms
+        total_time = acq_time + device_comp_time + edge_comp_time + network_time
+        print(f"{device_id:9s} | {offload_layer:7d} | {acq_time:13.2f} | {device_comp_time:16.2f} | {edge_comp_time:14.2f} | {network_time:13.2f} | {total_time:10.2f}")
+        
         # Apply network delay before responding
         if self.network_delay.enabled:
             delay = self.network_delay.apply_delay()
-            logger.debug(f"Applied network delay before response: {delay*1000:.2f}ms")
+            if self.verbose:
+                logger.debug(f"Applied network delay before response: {delay*1000:.2f}ms")
 
         # run offloading algorithm
         device_inference_times, edge_inference_times, layers_sizes = RequestHandler._load_stats()
-        logger.debug(f"Loaded stats data")
+        if self.verbose:
+            logger.debug(f"Loaded stats data")
 
         # Check if variance detected - potentially need to re-test offloading
-        if RequestHandler.variance_detector.should_retest_offloading():
+        if RequestHandler.variance_detector.should_retest_offloading() and self.verbose:
             logger.warning("Offloading algorithm may need re-evaluation due to inference time variance")
 
         # Check if we should force local-only inference for refreshing times
         if self.should_force_local_inference():
             # Force all layers on device (offloading layer = -1 means no offloading)
             best_offloading_layer = -1
-            logger.info("Forcing all layers on device for time refresh (local inference mode)")
+            if self.verbose:
+                logger.info("Forcing all layers on device for time refresh (local inference mode)")
         else:
             offloading_algo = OffloadingAlgo(
                 avg_speed=self.last_avg_speed,
@@ -309,6 +350,8 @@ def _from_raw(topic: str, payload: bytes):
             offset += 4
             message_content["offloading_layer_index"] = struct.unpack('i', payload[offset:offset+4])[0]
             offset += 4
+            message_content["acquisition_time"] = struct.unpack('f', payload[offset:offset+4])[0]
+            offset += 4
             layer_output_size = struct.unpack('I', payload[offset:offset+4])[0]
             offset += 4
             message_content["layer_output"] = struct.unpack(f'<{int(layer_output_size/4)}f', payload[offset:offset+layer_output_size])

src/server/edge/run_edge.py

@@ -1,5 +1,5 @@
 from server.edge.edge_initialization import Edge
-from server.logger.log import logger
+from server.logger.log import logger, configure_logger_from_settings
 
 import yaml
 from server.communication.websocket_server import WebsocketServer
@@ -11,6 +11,9 @@
 from server.commons import ConfigurationFiles
 
 if __name__ == "__main__":
+    # Configure logger based on settings
+    configure_logger_from_settings()
+    
     logger.info("Starting the [EDGE] MQTT client")
 
     with open(ConfigurationFiles.server_configuration_file_path, "r") as f: