Golang 与 Python 中糟糕的 UDP 性能

Question

I want to send as many UDP packets as fast as possible. I tried different methods of sending UDP data in the net package, but ended up with the following;

func main() {
    for i := 0; i < THREADS; i++ {
        go loopSendHello()
    }

    // Sleep forever
    <-make(chan bool, 1)
}

func loopSendHello() {
    for {
        sendHello()
    }
}

func sendHello() {
    // Setup conn
    addr := net.UDPAddr{
        IP:   net.IP{192, 168, 1, xxx},
        Port: 1337,
    }
    conn, err := net.ListenPacket("udp", "")
    if err != nil {
        log.Fatal("Listen:", err)
    }

    n, err := conn.WriteTo([]byte("hello"), &addr)
    if err != nil {
        log.Fatal("Error while writing to conn! :", err)
    }

    conn.Close()
}

THREADS is defined by runtime.NumCPU() btw. Benchmarking this using Wireshark gives these results: About 90ms delay (if I'm reading this right).

While this is the situation in Python (this function is running in 4 threads):

def sendHello():
    while True:
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            addr = ("192.168.1.xxx", 1337)
            s.sendto(data, addr)
        except:
            print("error")

Benchmark using Wireshark: . This is from 1ms to about 10ms delay! Insane differences.

How can I match python's speed in Go?

Answer 1

So I decided to very quickly create a simple benchmark of sending 200 000 UDP packets without any threads or bad programming techniques. The benchmark is between Go and Python. In addition I wanted a benchmark test to be concidered close to as fast as possible. I concidered using C, but as I'm on Windows it seemed easiest to use Rust.

Rust code:

use std::time::{SystemTime};
use std::net::UdpSocket;

const DATA: &[u8] = &[0; 1024];

fn main() {
    let time_start = SystemTime::now();

    let socket = UdpSocket::bind("192.168.1.155:1339").unwrap();
    for _ in 0..200000 {
        socket.send_to(DATA, "192.168.1.122:80").unwrap();
    }
    let elapsed = time_start.elapsed().unwrap();
    println!("Time {} ms to send 200 000 packets", elapsed.as_millis());
}

Avg.result (built in --release mode): Time 1863 ms to send 200 000 packets

For the Go benchmark, this is essentially the code:

var buff = []byte("")

func main() {
    buff = []byte(RandomString(1024))

    conn, err := net.ListenUDP("udp", &net.UDPAddr{})
    if err != nil {
        log.Fatal("Listen:", err)
    }

    loopSendHello(*conn)
    conn.Close()
}

func loopSendHello(conn net.UDPConn) {
    timeStart := time.Now()
    for i:=0; i < 200000; i++ {
        sendHelloEdited(&conn)
    }
    timeStop := time.Now()
    timeDelta := timeStop.Sub(timeStart)
    fmt.Println("Took", timeDelta.Milliseconds(), "ms to send 200 000 packets.")
}

// targetAddr is target address in form of net.UDPAddr
func sendHelloEdited(conn *net.UDPConn) {
    _, err := conn.WriteToUDP(buff, &targetAddr)
    if err != nil {
        log.Fatal("Error while writing to conn! :", err)
    }
}

Go avg. result: Took 1959 MS to send 200 000 packets.

Now for the Python test, this is the code:

def main():
    x = 0
    data = random._urandom(1024)
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    addr = (str(ip), int(port))
    startTime = datetime.datetime.now()
    while x < 200000:
        s.sendto(data, addr)
        x += 1
    s.close()
    endTime = datetime.datetime.now()
    deltaTime = endTime - startTime
    print("Took", deltaTime, "to send 200 000 packets")

main()

Interestingly the python result was always quick, with an avg. output of: Took 0:00:01.831531 to send 200 000 packets

So it seems Go is indeed slowest, but only marginally.