如何通过UDP精准测量路由器本地数据传输速率？

Hey there! Let's dig into fixing your UDP-based router local transfer rate measurement issue. Your current 700-800Mbps result feels inaccurate, so let's break down the common pitfalls and actionable fixes tailored to your Android service implementation.

First, let's cover why your numbers might be skewed:

• Suboptimal packet size: Small packets mean high protocol overhead (IP/UDP headers), inflating your calculated rate. Oversized packets cause fragmentation and丢包, deflating results.
• Default socket buffer limits: Android's default UDP buffers are tiny, which bottlenecks throughput before you hit actual Wi-Fi limits.
• Single-threaded blocking I/O: A single thread can't sustain full bandwidth—either sending gets throttled or receiving can't keep up with incoming packets.
• Imprecise timing: Using System.currentTimeMillis() (millisecond precision) introduces errors in short-duration tests.
• Ignoring packet loss: UDP is connectionless; lost packets mean your calculated rate doesn't reflect actual delivered data.

Let's adjust your RouterTransferRateService with these improvements:

1. Optimize UDP Packet Size #

Wi-Fi typically uses a 1500-byte MTU. Subtract 28 bytes for IP (20) + UDP (8) headers to get a 1472-byte payload—this avoids fragmentation and minimizes overhead.

private static final int UDP_OPTIMAL_PAYLOAD = 1472; // 1500 MTU - 28 headers

2. Expand Socket Buffers #

Bump up send/receive buffers to avoid bottlenecks. Add this when initializing your DatagramSocket:

DatagramSocket socket = new DatagramSocket();
try {
    socket.setSendBufferSize(8 * 1024 * 1024); // 8MB buffer
    socket.setReceiveBufferSize(8 * 1024 * 1024);
} catch (SocketException e) {
    // Fallback if device doesn't support large buffers
    Log.w("RateTest", "Couldn't set large buffers: " + e.getMessage());
}

3. Use Multi-Threaded Asynchronous I/O #

Separate sender and receiver threads to maximize bandwidth utilization. Here's how to integrate this into your service:

private void startRateTest() {
    ExecutorService testExecutor = Executors.newFixedThreadPool(2);
    
    // Disable Wi-Fi sleep to prevent throttling
    wifiManager.setWifiSleepPolicy(WifiManager.WIFI_SLEEP_POLICY_NEVER);
    
    // Launch sender and receiver threads
    testExecutor.submit(this::runUdpSender);
    testExecutor.submit(this::runUdpReceiver);
}

private void runUdpSender() {
    try {
        DatagramSocket sendSocket = new DatagramSocket();
        sendSocket.setSendBufferSize(8 * 1024 * 1024);
        
        InetAddress routerIp = InetAddress.getByName(wirelessInfoProvider.getRouterIp());
        byte[] testPayload = new byte[UDP_OPTIMAL_PAYLOAD];
        Arrays.fill(testPayload, (byte) 0xAA); // Use non-compressible data
        DatagramPacket packet = new DatagramPacket(testPayload, testPayload.length, routerIp, 50000);
        
        long startTime = System.nanoTime();
        long totalBytesSent = 0;
        long testDurationNs = 10 * 1_000_000_000L; // 10-second test
        
        while (System.nanoTime() - startTime < testDurationNs) {
            sendSocket.send(packet);
            totalBytesSent += testPayload.length;
        }
        
        // Calculate accurate rate
        double elapsedSeconds = (System.nanoTime() - startTime) / 1_000_000_000.0;
        double mbps = (totalBytesSent * 8) / (elapsedSeconds * 1_000_000);
        Log.d("RateTest", String.format("Sender Rate: %.2f Mbps", mbps));
        
        sendSocket.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

private void runUdpReceiver() {
    try {
        DatagramSocket receiveSocket = new DatagramSocket(50000);
        receiveSocket.setReceiveBufferSize(8 * 1024 * 1024);
        
        byte[] buffer = new byte[UDP_OPTIMAL_PAYLOAD];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        
        long startTime = System.nanoTime();
        long totalBytesReceived = 0;
        long testDurationNs = 10 * 1_000_000_000L;
        
        while (System.nanoTime() - startTime < testDurationNs) {
            receiveSocket.receive(packet);
            totalBytesReceived += packet.getLength();
            packet.setLength(buffer.length); // Reset for next packet
        }
        
        double elapsedSeconds = (System.nanoTime() - startTime) / 1_000_000_000.0;
        double mbps = (totalBytesReceived * 8) / (elapsedSeconds * 1_000_000);
        Log.d("RateTest", String.format("Receiver Rate: %.2f Mbps", mbps));
        
        // Broadcast result to UI
        Intent resultIntent = new Intent(ACTION_NAME);
        resultIntent.putExtra("transfer_rate", mbps);
        sendBroadcast(resultIntent);
        
        receiveSocket.close();
        stopSelf(); // Stop service after test
    } catch (IOException e) {
        e.printStackTrace();
    }
}

4. Minimize System Overhead #

• Set thread priority: Give test threads maximum priority to avoid OS throttling:

  Thread senderThread = new Thread(this::runUdpSender);
  senderThread.setPriority(Thread.MAX_PRIORITY);
  senderThread.start();
  

• Disable Wi-Fi compression: Use non-compressible payload data (like repeated 0xAA bytes) to prevent device-side compression from skewing byte counts.
• Isolate the network: Turn off other devices on the same Wi-Fi network and switch to 5GHz (less interference than 2.4GHz) for consistent results.

5. Validate Against Wi-Fi SweetSpots' Methodology #

Align your test parameters with Wi-Fi SweetSpots:

• Use the same test duration (e.g., 10-30 seconds) to average out short-term fluctuations.
• Test bidirectional throughput (send and receive simultaneously) if SweetSpots does so.
• Confirm you're measuring local router throughput (not internet speed) by targeting the router's LAN IP.

Don't forget to:

• Declare required permissions in AndroidManifest.xml:

  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
  <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
  <uses-permission android:name="android.permission.INTERNET" />
  

• Clean up resources (close sockets, shut down executors) to avoid leaks.

内容的提问来源于stack exchange，提问作者NaviRamyle