Debugging

Power2All · Power2All · commit bd7947935e39 · 2025-08-31T11:37:22.000+02:00
diff --git a/src/udp/impls/response_batch_manager.rs b/src/udp/impls/response_batch_manager.rs
@@ -16,9 +16,9 @@ impl ResponseBatchManager {
         let (sender, mut receiver) = mpsc::unbounded_channel::<QueuedResponse>();
 
         tokio::spawn(async move {
-            let mut buffer = VecDeque::with_capacity(1000); // Larger buffer for higher throughput
-            let mut timer = interval(Duration::from_millis(5)); // 5ms flush interval for better responsiveness
-            let mut stats_timer = interval(Duration::from_secs(10)); // Stats every 10 seconds
+            let mut buffer = VecDeque::with_capacity(1000);
+            let mut timer = interval(Duration::from_millis(1)); // 1ms flush - much more aggressive
+            let mut stats_timer = interval(Duration::from_secs(10));
             let mut total_queued = 0u64;
 
             loop {
@@ -28,17 +28,15 @@ impl ResponseBatchManager {
                         total_queued += 1;
                         buffer.push_back(response);
 
-                        // If buffer reaches 500 responses, send immediately
-                        if buffer.len() >= 500 {
-                            debug!("Buffer full ({} items) - flushing immediately", buffer.len());
+                        // Much smaller batch size for lower latency
+                        if buffer.len() >= 50 {
                             Self::flush_buffer(&socket, &mut buffer).await;
                         }
                     }
 
-                    // Timer tick - flush any remaining responses
+                    // Very frequent timer tick - prioritize low latency over efficiency
                     _ = timer.tick() => {
                         if !buffer.is_empty() {
-                            debug!("Timer flush - {} items in buffer", buffer.len());
                             Self::flush_buffer(&socket, &mut buffer).await;
                         }
                     }
diff --git a/src/udp/impls/udp_server.rs b/src/udp/impls/udp_server.rs
@@ -53,24 +53,6 @@ impl UdpServer {
         socket.set_send_buffer_size(actual_send_buffer).map_err(tokio::io::Error::other)?;
         socket.set_reuse_address(reuse_address).map_err(tokio::io::Error::other)?;
 
-        // Enable SO_REUSEPORT for better load distribution across threads
-        #[cfg(target_os = "linux")]
-        {
-            let reuse_port = 1i32;
-            unsafe {
-                let optval = &reuse_port as *const i32 as *const libc::c_void;
-                if libc::setsockopt(
-                    socket.as_raw_fd(),
-                    libc::SOL_SOCKET,
-                    libc::SO_REUSEPORT,
-                    optval,
-                    std::mem::size_of::<i32>() as libc::socklen_t,
-                ) != 0 {
-                    log::warn!("Failed to set SO_REUSEPORT - continuing without it");
-                }
-            }
-        }
-
         socket.bind(&bind_address.into()).map_err(tokio::io::Error::other)?;
         socket.set_nonblocking(true).map_err(tokio::io::Error::other)?;
 
@@ -174,9 +156,18 @@ impl UdpServer {
                 let position = cursor.position() as usize;
                 debug!("Response bytes: {:?}", &buffer[..position]);
 
-                // Get batch manager for this socket and queue the response
-                let batch_manager = ResponseBatchManager::get_for_socket(socket).await;
-                batch_manager.queue_response(remote_addr, buffer[..position].to_vec());
+                // For immediate response (bypassing batching for better latency)
+                match socket.send_to(&buffer[..position], &remote_addr).await {
+                    Ok(bytes_sent) => {
+                        debug!("Direct send successful: {} bytes to {}", bytes_sent, remote_addr);
+                    }
+                    Err(e) => {
+                        // If direct send fails, fall back to batched approach
+                        log::warn!("Direct send failed ({}), using batch queue", e);
+                        let batch_manager = ResponseBatchManager::get_for_socket(socket).await;
+                        batch_manager.queue_response(remote_addr, buffer[..position].to_vec());
+                    }
+                }
             }
             Err(error) => {
                 sentry::capture_error(&error);
