Update app.py

app.py

@@ -3,37 +3,56 @@ import plotly.graph_objects as go
 import pandas as pd
 import numpy as np
 
-def calculate_runpod_cost(
+def calculate_runpod_cost_revised(
     requests_per_hour,
     execution_time_per_request,
     active_cost_per_second,
     flex_cost_per_second,
-    cold_start_penalty=30,
-    active_request_percentage=0.5
+    cold_start_penalty,
+    num_active_workers,
+    concurrent_batch_size=1  # How many requests can be processed simultaneously by one worker
 ):
-    # Calculate monthly requests
-    monthly_requests = requests_per_hour * 24 * 30
+    # Monthly hours and requests
+    monthly_hours = 24 * 30
+    seconds_per_hour = 3600
+    monthly_requests = requests_per_hour * monthly_hours
     
-    # Split requests between active and flex workers
-    active_requests = monthly_requests * active_request_percentage
-    flex_requests = monthly_requests * (1 - active_request_percentage)
+    # Calculate active worker capacity (requests per hour)
+    # Each worker can process (concurrent_batch_size) requests at a time
+    active_capacity_per_hour = (seconds_per_hour / execution_time_per_request) * num_active_workers * concurrent_batch_size
     
-    # Calculate active worker cost
-    active_cost = active_requests * execution_time_per_request * active_cost_per_second
+    # Total requests handled by active workers over the month
+    active_requests_handled = min(monthly_requests, active_capacity_per_hour * monthly_hours)
     
-    # Calculate flex worker cost (including cold start penalty)
-    flex_cost = flex_requests * (execution_time_per_request + cold_start_penalty) * flex_cost_per_second
+    # Remaining requests go to flex workers
+    flex_requests = max(0, monthly_requests - active_requests_handled)
+    
+    # Active worker cost (constant regardless of actual usage)
+    active_cost = num_active_workers * active_cost_per_second * seconds_per_hour * monthly_hours
+    
+    # For flex workers, we calculate cold starts based on request arrival pattern
+    # This is simplified - in reality depends on actual traffic patterns
+    avg_requests_per_cold_start = concurrent_batch_size * 2  # Estimate that batches arrive close enough to reuse some workers
+    cold_starts = flex_requests / avg_requests_per_cold_start if flex_requests > 0 else 0
+    
+    # Flex worker cost (only pay for processing time + cold starts)
+    flex_processing_cost = flex_requests * execution_time_per_request * flex_cost_per_second
+    flex_cold_start_cost = cold_starts * cold_start_penalty * flex_cost_per_second
+    flex_cost = flex_processing_cost + flex_cold_start_cost
+    
+    # Active worker utilization
+    active_utilization = (active_requests_handled / (active_capacity_per_hour * monthly_hours) * 100) if num_active_workers > 0 else 0
     
-    # Total monthly cost
     total_monthly_cost = active_cost + flex_cost
     
     return {
         "monthly_requests": monthly_requests,
-        "active_requests": active_requests,
+        "active_requests": active_requests_handled,
         "flex_requests": flex_requests,
         "active_cost": active_cost,
         "flex_cost": flex_cost,
-        "total_monthly_cost": total_monthly_cost
+        "total_monthly_cost": total_monthly_cost,
+        "active_utilization": active_utilization
     }
 
 def generate_cost_projection(
@@ -42,28 +61,31 @@ def generate_cost_projection(
     execution_time,
     active_cost,
     flex_cost,
-    active_percentage,
-    cold_start
+    num_active_workers,
+    cold_start,
+    concurrent_batch_size
 ):
     # Generate data for different request volumes
     request_volumes = np.linspace(min_requests, max_requests, 20)
     results = []
 
     for req_vol in request_volumes:
-        result = calculate_runpod_cost(
+        result = calculate_runpod_cost_revised(
             req_vol, 
             execution_time, 
             active_cost, 
             flex_cost, 
             cold_start, 
-            active_percentage/100
+            num_active_workers,
+            concurrent_batch_size
         )
         results.append({
             'requests_per_hour': req_vol,
             'monthly_requests': result['monthly_requests'],
             'active_cost': result['active_cost'],
             'flex_cost': result['flex_cost'],
-            'total_cost': result['total_monthly_cost']
+            'total_cost': result['total_monthly_cost'],
+            'active_utilization': result['active_utilization']
         })
 
     df = pd.DataFrame(results)
@@ -103,16 +125,18 @@ def calculate_specific_cost(
     execution_time,
     active_cost,
     flex_cost,
-    active_percentage,
-    cold_start
+    num_active_workers,
+    cold_start,
+    concurrent_batch_size
 ):
-    result = calculate_runpod_cost(
+    result = calculate_runpod_cost_revised(
         requests, 
         execution_time, 
         active_cost, 
         flex_cost, 
         cold_start, 
-        active_percentage/100
+        num_active_workers,
+        concurrent_batch_size
     )
     
     # Format the output HTML for the table
@@ -126,6 +150,14 @@ def calculate_specific_cost(
         <td style="padding: 8px; border: 1px solid #ddd;">Monthly Requests</td>
         <td style="padding: 8px; text-align: right; border: 1px solid #ddd;">{result['monthly_requests']:,.0f}</td>
       </tr>
+      <tr>
+        <td style="padding: 8px; border: 1px solid #ddd;">Requests Handled by Active Workers</td>
+        <td style="padding: 8px; text-align: right; border: 1px solid #ddd;">{result['active_requests']:,.0f}</td>
+      </tr>
+      <tr>
+        <td style="padding: 8px; border: 1px solid #ddd;">Requests Handled by Flex Workers</td>
+        <td style="padding: 8px; text-align: right; border: 1px solid #ddd;">{result['flex_requests']:,.0f}</td>
+      </tr>
       <tr>
         <td style="padding: 8px; border: 1px solid #ddd;">Active Worker Cost</td>
         <td style="padding: 8px; text-align: right; border: 1px solid #ddd;">${result['active_cost']:,.2f}</td>
@@ -138,11 +170,16 @@ def calculate_specific_cost(
         <td style="padding: 8px; border: 1px solid #ddd;">Total Monthly Cost</td>
         <td style="padding: 8px; text-align: right; border: 1px solid #ddd;">${result['total_monthly_cost']:,.2f}</td>
       </tr>
+      <tr>
+        <td style="padding: 8px; border: 1px solid #ddd;">Active Worker Utilization</td>
+        <td style="padding: 8px; text-align: right; border: 1px solid #ddd;">{result['active_utilization']:.1f}%</td>
+      </tr>
     </table>
     """
     
     return html
 
+# Create theme
 theme = gr.themes.Default(
     primary_hue=gr.themes.colors.red,
     secondary_hue=gr.themes.colors.red,
@@ -161,8 +198,9 @@ with gr.Blocks(title="RunPod Serverless Cost Estimator", theme=theme) as demo:
             execution_time = gr.Slider(minimum=1, maximum=120, value=30, step=1, label="Execution Time per Request (seconds)")
             active_cost = gr.Number(value=0.00019, label="Active Worker Cost ($/second)", precision=5)
             flex_cost = gr.Number(value=0.00031, label="Flex Worker Cost ($/second)", precision=5)
-            active_percentage = gr.Slider(minimum=0, maximum=100, value=50, step=1, label="% Requests on Active Workers")
-            cold_start = gr.Slider(minimum=0, maximum=60, value=30, step=1, label="Cold Start Penalty (seconds)")
+            num_active_workers = gr.Slider(minimum=0, maximum=600, value=30, step=10, label="Number of Active Workers")
+            cold_start = gr.Slider(minimum=0, maximum=60, value=1, step=1, label="Cold Start Penalty (seconds)")
+            concurrent_batch_size = gr.Slider(minimum=1, maximum=10, value=2, step=1, label="Concurrent Requests per Worker")
             
             plot_button = gr.Button("Generate Cost Projection")
         
@@ -181,13 +219,13 @@ with gr.Blocks(title="RunPod Serverless Cost Estimator", theme=theme) as demo:
     
     plot_button.click(
         generate_cost_projection,
-        inputs=[min_requests, max_requests, execution_time, active_cost, flex_cost, active_percentage, cold_start],
+        inputs=[min_requests, max_requests, execution_time, active_cost, flex_cost, num_active_workers, cold_start, concurrent_batch_size],
         outputs=plot_output
     )
     
     calc_button.click(
         calculate_specific_cost,
-        inputs=[specific_requests, execution_time, active_cost, flex_cost, active_percentage, cold_start],
+        inputs=[specific_requests, execution_time, active_cost, flex_cost, num_active_workers, cold_start, concurrent_batch_size],
         outputs=cost_table
     )