Update app.py

app.py

@@ -1,5 +1,94 @@
+import time
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+import gradio as gr
+
+# Visualization style
+plt.style.use('seaborn-v0_8-darkgrid')
+
+# Random seed for reproducibility
+random.seed(42)
+np.random.seed(42)
+
+def simulate_batches(num_workers=4, 
+                     batch_time=500,     # ms
+                     network_latency=200, # ms
+                     mode='synchronous', 
+                     num_batches=10):
+    """
+    Simulates mini-batch scheduling under synchronous vs asynchronous update strategies.
+    Returns worker timelines and performance metrics.
+    """
+    timelines = []  # [(worker_id, start, end, active_flag)]
+    current_time = [0] * num_workers  # track each worker's time progress
+
+    for batch in range(num_batches):
+        for w in range(num_workers):
+            # Each worker takes a random batch processing time with jitter
+            proc_time = random.uniform(batch_time * 0.8, batch_time * 1.2)
+            start = current_time[w]
+            end = start + proc_time
+            timelines.append((w, start, end, 'active'))
+            current_time[w] = end
+
+        if mode == 'synchronous':
+            # Barrier: wait for all workers to finish
+            max_time = max(current_time)
+            for w in range(num_workers):
+                if current_time[w] < max_time:
+                    timelines.append((w, current_time[w], max_time, 'idle'))
+                    current_time[w] = max_time
+            # Add sync overhead (e.g., gradient aggregation)
+            current_time = [t + network_latency for t in current_time]
+        else:
+            # Asynchronous mode adds random network jitter
+            current_time = [t + random.uniform(0, network_latency * 0.3) for t in current_time]
+
+    total_time = max(current_time)
+    idle_time = sum(
+        end - start for (w, start, end, flag) in timelines if flag == 'idle'
+    )
+    total_blocks = sum(end - start for (_, start, end, _) in timelines)
+    idle_percent = (idle_time / total_blocks) * 100
+    throughput = (num_workers * num_batches * 1000) / total_time  # batches per second (approx)
+
+    metrics = {
+        "epoch_time_ms": total_time,
+        "idle_percent": round(idle_percent, 2),
+        "throughput": round(throughput, 2)
+    }
+
+    return timelines, metrics
+
+
+def plot_timeline(timelines, metrics, num_workers):
+    colors = {'active': '#4CAF50', 'idle': '#E74C3C'}
+    fig, ax = plt.subplots(figsize=(10, 5))
+
+    for (w, start, end, flag) in timelines:
+        ax.barh(y=w, width=end-start, left=start, color=colors[flag], edgecolor='black')
+
+    ax.set_xlabel("Time (ms)")
+    ax.set_ylabel("Worker ID")
+    ax.set_title("Batch Scheduler Simulation")
+    ax.set_yticks(range(num_workers))
+    ax.set_yticklabels([f"W{i}" for i in range(num_workers)])
+    ax.invert_yaxis()
+
+    text_summary = (
+        f"Epoch Duration: {metrics['epoch_time_ms']:.2f} ms\n"
+        f"Idle Time: {metrics['idle_percent']}%\n"
+        f"Throughput: {metrics['throughput']} batches/sec"
+    )
+
+    plt.figtext(0.72, 0.35, text_summary, fontsize=10, 
+                bbox=dict(facecolor='white', alpha=0.7, edgecolor='gray'))
+    plt.tight_layout()
+    return fig
+
+
 def run_simulation(num_workers, batch_time, network_latency, mode, num_batches):
-    """Wrapper for Gradio interface."""
     timelines, metrics = simulate_batches(
         num_workers=int(num_workers),
         batch_time=float(batch_time),
@@ -8,14 +97,15 @@ def run_simulation(num_workers, batch_time, network_latency, mode, num_batches):
         num_batches=int(num_batches)
     )
     fig = plot_timeline(timelines, metrics, num_workers)
-    return fig, (
+    summary = (
         f"Mode: {mode.capitalize()}\n"
         f"Epoch Time: {metrics['epoch_time_ms']:.2f} ms\n"
         f"Idle Time: {metrics['idle_percent']} %\n"
         f"Throughput: {metrics['throughput']} batches/sec"
     )
+    return fig, summary
+
 
-# Define Gradio UI
 interface = gr.Interface(
     fn=run_simulation,
     inputs=[
@@ -27,15 +117,15 @@ interface = gr.Interface(
     ],
     outputs=[
         gr.Plot(label="Timeline Visualization"),
-        gr.Textbox(label="Simulation Summary", lines=6, max_lines=8, show_copy_button=True)
+        gr.Textbox(label="Simulation Summary", lines=8, max_lines=12, show_copy_button=True)
     ],
     title="🧠 Batch Scheduler Simulator",
-    description="Visualize how synchronous vs. asynchronous batch scheduling affects throughput, idle time, and epoch duration.",
+    description="Visualize how synchronous vs asynchronous batch scheduling affects throughput, idle time, and epoch duration.",
     examples=[
         [4, 500, 200, "synchronous", 10],
         [8, 400, 150, "asynchronous", 15]
     ]
 )
 
-# Launch interface
-interface.launch(share=True)
+if __name__ == "__main__":
+    interface.launch()