GO的TCP性能测试，优化结果

来源：互联网发布：vscode 联想输入编辑：程序博客网时间：2024/05/17 03:30

之前做过一次测试，没有任何优化的情况下C++(16Gbps)是GO(4Gbps)的4倍性能，参考http://blog.csdn.net/win_lin/article/details/40744175

这次针对TCP部分对go做了优化，测试结果令人满意。GO单进程(7Gbps)不输c++(8Gbps)，是c++使用writev(16Gbps)的一半，GO多进程(59Gbps)完胜c++是c++的好几倍。

测试代码参考：https://github.com/winlinvip/go-srs/tree/master/research/tcp

备注：之前的测试是在虚拟机上，这次在物理机上，结果可能会略有不同。

这次使用的GO的版本是1.3.3。

Why TCP

TCP是网络通讯的基础，而web则是基于HTTP框架，HTTP又基于TCP。RTMP也是基于TCP。

TCP的吞吐率能达标，那么就奠定了这个语言能开发高性能服务器的基础。

之前srs1.0时，调研过go，写了一个go版本的srs，但是性能和red5差不多就删除了。

现在srs2.0单进程单线程网络吞吐能达到4Gbps（6千客户端，码率522Kbps），GO如果不能达到这个目标，那么SRS就不可能用go重写。

Platform

此次测试在24CPU的服务器上，CPU不是瓶颈。

测试使用lo网卡，直接内存拷贝，网络也不是瓶颈。

CPU和网络都资源充足时，服务器本身的执行速度就是关键了。

OS选用Centos6 64bits。

客户端选用c++做客户端，使用同一个客户端测试。

Write

下面是C++服务器，单进程单线程作为服务器：

g++ tcp.server.cpp -g -O0 -o tcp.server && ./tcp.server 1990 4096 g++ tcp.client.cpp -g -O0 -o tcp.client && ./tcp.client 127.0.0.1 1990 4096 ----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   0   6  92   0   0   1|   0    11k|1073M 1073M|   0     0 |2790    81k  0   6  93   0   0   1|   0  7782B|1049M 1049M|   0     0 |2536    76k    PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND32573 winlin    20   0 11744  892  756 R 99.9  0.0  17:56.88 ./tcp.server 1990 4096 2880 winlin    20   0 11740  900  764 S 85.3  0.0   0:32.53 ./tcp.client 127.0.0.1 1990 4096

单进程的c++效率还是非常高的1049MBps，对比目前SRS1的168MBps，SRS2跑到的391MBps，其实SRS没有达到性能极限。

下面是go作为服务器，no delay设置为1，即go默认的tcp选项，这个选项会造成tcp性能降低：

go build ./tcp.server.go && ./tcp.server 1 1 1990 4096g++ tcp.client.cpp -g -O0 -o tcp.client && ./tcp.client 127.0.0.1 1990 4096 ----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   0   5  93   0   0   2|   0  7509B| 587M  587M|   0     0 |2544   141k  0   5  93   0   0   2|   0    10k| 524M  524M|   0     0 |2629   123k   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                           5496 winlin    20   0 98248 1968 1360 S 100.5  0.0   4:40.54 ./tcp.server 1 1 1990 4096       5517 winlin    20   0 11740  896  764 S 72.3  0.0   3:24.22 ./tcp.client 127.0.0.1 1990 4096

可见在开启tcp no delay的go只有c++的性能的一半。

下面是go作为服务器，关闭了tcp no delay选项，单进程作为服务器：

go build ./tcp.server.go && ./tcp.server 1 0 1990 4096g++ tcp.client.cpp -g -O0 -o tcp.client && ./tcp.client 127.0.0.1 1990 4096 ----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   0   5  93   0   0   1|   0    10k| 868M  868M|   0     0 |2674    79k  1   5  93   0   0   1|   0    16k| 957M  957M|   0     0 |2660    85k   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                          3004 winlin    20   0 98248 1968 1360 R 100.2  0.0   2:27.32 ./tcp.server 1 0 1990 4096      3030 winlin    20   0 11740  900  764 R 81.0  0.0   1:59.42 ./tcp.client 127.0.0.1 1990 4096

其实在关闭了tcp no delay之后，go的性能和c++相差不大了。

Multiple CPU

go最厉害的是考虑多cpu并行计算。其实c/c++也可以用fork多进程，对于业务代码有很大影响；go在不影响业务代码时直接扩展支持多cpu。

go开启10个cpu，8个客户端，开启no delay（默认）时的性能：

go build ./tcp.server.go && ./tcp.server 10 1 1990 4096g++ tcp.client.cpp -g -O0 -o tcp.client && for((i=0;i<8;i++)); do (./tcp.client 127.0.0.1 1990 4096 &); done----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   4  37  47   0   0  12|   0   105k|3972M 3972M|   0     0 |  14k  995k  4  37  46   0   0  13|   0  8055B|3761M 3761M|   0     0 |  14k  949k  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                           6353 winlin    20   0  517m 6896 1372 R 789.6  0.0  13:24.49 ./tcp.server 10 1 1990 4096      6384 winlin    20   0 11740  900  764 S 68.4  0.0   1:11.57 ./tcp.client 127.0.0.1 1990 4096  6386 winlin    20   0 11740  896  764 R 67.4  0.0   1:09.53 ./tcp.client 127.0.0.1 1990 4096  6390 winlin    20   0 11740  900  764 R 66.7  0.0   1:11.24 ./tcp.client 127.0.0.1 1990 4096  6382 winlin    20   0 11740  896  764 R 64.8  0.0   1:11.30 ./tcp.client 127.0.0.1 1990 4096  6388 winlin    20   0 11740  896  764 R 64.4  0.0   1:11.80 ./tcp.client 127.0.0.1 1990 4096  6380 winlin    20   0 11740  896  764 S 63.4  0.0   1:08.78 ./tcp.client 127.0.0.1 1990 4096  6396 winlin    20   0 11740  896  764 R 62.8  0.0   1:09.47 ./tcp.client 127.0.0.1 1990 4096  6393 winlin    20   0 11740  900  764 R 61.4  0.0   1:11.90 ./tcp.client 127.0.0.1 1990 4096

也比较厉害了，能跑到30Gbps。

开启10个cpu，8个客户端，关闭no delay时看看go的性能：

go build ./tcp.server.go && ./tcp.server 10 0 1990 4096g++ tcp.client.cpp -g -O0 -o tcp.client && for((i=0;i<8;i++)); do (./tcp.client 127.0.0.1 1990 4096 &); done----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   5  42  41   0   0  12|   0  8602B|7132M 7132M|   0     0 |  15k  602k  5  41  41   0   0  12|   0    13k|7426M 7426M|   0     0 |  15k  651k  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                          4148 winlin    20   0  528m 9.8m 1376 R 795.5  0.1  81:48.12 ./tcp.server 10 0 1990 4096     4167 winlin    20   0 11740  896  764 S 89.8  0.0   8:16.52 ./tcp.client 127.0.0.1 1990 4096 4161 winlin    20   0 11740  900  764 R 87.8  0.0   8:14.63 ./tcp.client 127.0.0.1 1990 4096 4174 winlin    20   0 11740  896  764 S 83.2  0.0   8:09.40 ./tcp.client 127.0.0.1 1990 4096 4163 winlin    20   0 11740  896  764 R 82.6  0.0   8:07.80 ./tcp.client 127.0.0.1 1990 4096 4171 winlin    20   0 11740  900  764 R 82.2  0.0   8:08.75 ./tcp.client 127.0.0.1 1990 4096 4169 winlin    20   0 11740  900  764 S 81.9  0.0   8:15.37 ./tcp.client 127.0.0.1 1990 4096 4165 winlin    20   0 11740  900  764 R 78.9  0.0   8:09.98 ./tcp.client 127.0.0.1 1990 4096 4177 winlin    20   0 11740  900  764 R 74.0  0.0   8:07.63 ./tcp.client 127.0.0.1 1990 4096

这个更厉害了，能跑到59Gbps，厉害！

Writev

GO中是没有writev的，可以用c/c++的writev和go的多进程比一比。

考虑SRS2目前使用writev提升了一倍性能，若srs使用go则可以使用多进程，这两个对比还是有意义的。

同时，客户端也使用readv来一次读取多次，弥补客户端单进程的瓶颈。

g++ tcp.server.writev.cpp -g -O0 -o tcp.server && ./tcp.server 64 1990 4096 g++ tcp.client.readv.cpp -g -O0 -o tcp.client && ./tcp.client 127.0.0.1 1990 64 4096 ----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   0   6  93   0   0   1|   0    15k|1742M 1742M|   0     0 |2578    30k  0   6  93   0   0   1|   0    13k|1779M 1779M|   0     0 |2412    30k    PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                             9468 winlin    20   0 12008 1192  800 R 99.8  0.0   1:17.63 ./tcp.server 64 1990 4096           9487 winlin    20   0 12008 1192  800 R 80.3  0.0   1:02.49 ./tcp.client 127.0.0.1 1990 64 4096

使用writev确实能提升一倍的性能，减少了系统调用的时间。

对比使用readv客户端的go，禁用tcp no delay的情况：

go build ./tcp.server.go && ./tcp.server 1 0 1990 4096g++ tcp.client.readv.cpp -g -O0 -o tcp.client && ./tcp.client 127.0.0.1 1990 64 4096 ----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   0   5  93   0   0   1|   0  5734B| 891M  891M|   0     0 |2601   101k  0   5  93   0   0   2|   0  9830B| 897M  897M|   0     0 |2518   103k  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                             9690 winlin    20   0 98248 3984 1360 R 100.2  0.0   2:46.84 ./tcp.server 1 0 1990 4096         9698 winlin    20   0 12008 1192  800 R 79.3  0.0   2:13.23 ./tcp.client 127.0.0.1 1990 64 4096

这时候go单进程没有提升，因为瓶颈不在客户端，所以客户端使用readv之后也没有改变。

对比go用10个cpu，客户端使用readv，禁用tcp no delay：

go build ./tcp.server.go && ./tcp.server 10 0 1990 4096g++ tcp.client.readv.cpp -g -O0 -o tcp.client && for((i=0;i<8;i++)); do (./tcp.client 127.0.0.1 1990 64 4096 &); done----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   5  41  42   0   0  12|   0  7236B|6872M 6872M|   0     0 |  15k  780k  4  42  41   0   0  12|   0  9557B|6677M 6677M|   0     0 |  15k  723k  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                            10169 winlin    20   0  655m 7072 1388 R 799.9  0.0  51:39.13 ./tcp.server 10 0 1990 4096       10253 winlin    20   0 12008 1192  800 R 84.5  0.0   5:05.05 ./tcp.client 127.0.0.1 1990 64 409610261 winlin    20   0 12008 1192  800 S 80.6  0.0   5:04.77 ./tcp.client 127.0.0.1 1990 64 409610255 winlin    20   0 12008 1192  800 R 79.9  0.0   5:05.32 ./tcp.client 127.0.0.1 1990 64 409610271 winlin    20   0 12008 1192  800 S 79.3  0.0   5:05.15 ./tcp.client 127.0.0.1 1990 64 409610258 winlin    20   0 12008 1192  800 S 78.3  0.0   5:05.45 ./tcp.client 127.0.0.1 1990 64 409610268 winlin    20   0 12008 1192  800 R 77.6  0.0   5:06.54 ./tcp.client 127.0.0.1 1990 64 409610251 winlin    20   0 12008 1188  800 R 76.6  0.0   5:03.68 ./tcp.client 127.0.0.1 1990 64 409610265 winlin    20   0 12008 1192  800 R 74.6  0.0   5:03.35 ./tcp.client 127.0.0.1 1990 64 4096

测试结果和之前差不多。

GO Write Analysis

调试go的TcpConn.Write方法，调用堆栈是：

    at /home/winlin/go/src/github.com/winlinvip/srs.go/research/tcp/tcp.server.go:203203        n, err := conn.Write(b)

调用的代码是：

func handleConnection(conn *net.TCPConn, no_delay int, packet_bytes int) {    for {        n, err := conn.Write(b)        if err != nil {            fmt.Println("write data error, n is", n, "and err is", err)            break        }    }

s调试进去，调用的是：

net.(*conn).Write (c=0xc20805bf18, b=..., ~r1=0, ~r2=...) at /usr/local/go/src/pkg/net/net.go:130130return c.fd.Write(b)

这部分的代码是：

func (c *conn) Write(b []byte) (int, error) {if !c.ok() {return 0, syscall.EINVAL}return c.fd.Write(b)}

接下来是：

Breakpoint 2, net.(*netFD).Write (fd=0x0, p=..., nn=0, err=...) at /usr/local/go/src/pkg/net/fd_unix.go:327327n, err = syscall.Write(int(fd.sysfd), p[nn:])

这部分代码是：

func (fd *netFD) Write(p []byte) (nn int, err error) {if err := fd.writeLock(); err != nil {return 0, err}defer fd.writeUnlock()if err := fd.pd.PrepareWrite(); err != nil {return 0, &OpError{"write", fd.net, fd.raddr, err}}for {var n intn, err = syscall.Write(int(fd.sysfd), p[nn:])if n > 0 {nn += n}if nn == len(p) {break}if err == syscall.EAGAIN {if err = fd.pd.WaitWrite(); err == nil {continue}}if err != nil {n = 0break}if n == 0 {err = io.ErrUnexpectedEOFbreak}}if err != nil {err = &OpError{"write", fd.net, fd.raddr, err}}return nn, err}

系统调用层是：

syscall.Write (fd=0, p=..., n=0, err=...) at /usr/local/go/src/pkg/syscall/syscall_unix.go:152152n, err = write(fd, p)

代码是：

func Write(fd int, p []byte) (n int, err error) {if raceenabled {raceReleaseMerge(unsafe.Pointer(&ioSync))}n, err = write(fd, p)if raceenabled && n > 0 {raceReadRange(unsafe.Pointer(&p[0]), n)}return}

最后是：

#0  syscall.write (fd=12, p=..., n=4354699, err=...) at /usr/local/go/src/pkg/syscall/zsyscall_linux_amd64.go:12281228r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))

代码是：

func write(fd int, p []byte) (n int, err error) {var _p0 unsafe.Pointerif len(p) > 0 {_p0 = unsafe.Pointer(&p[0])} else {_p0 = unsafe.Pointer(&_zero)}r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))n = int(r0)if e1 != 0 {err = e1}return}

调用的是SYS_WRITE，即write。查找发现是有writev的：

[winlin@dev6 src]$ find . -name "*.go"|xargs grep -in "SYS_WRITEV"./pkg/syscall/zsysnum_linux_amd64.go:27:SYS_WRITEV                 = 20

可惜没有发现使用这个的代码，所以go肯定是没有支持writev的了。

最后所有的Syscall，是用asm汇编写的：

syscall.Syscall () at /usr/local/go/src/pkg/syscall/asm_linux_amd64.s:2020CALLruntime·entersyscall(SB)

代码是：

TEXT·Syscall(SB),NOSPLIT,$0-56CALLruntime·entersyscall(SB)MOVQ16(SP), DIMOVQ24(SP), SIMOVQ32(SP), DXMOVQ$0, R10MOVQ$0, R8MOVQ$0, R9MOVQ8(SP), AX// syscall entrySYSCALLCMPQAX, $0xfffffffffffff001JLSokMOVQ$-1, 40(SP)// r1MOVQ$0, 48(SP)// r2NEGQAXMOVQAX, 56(SP)  // errnoCALLruntime·exitsyscall(SB)RETok:MOVQAX, 40(SP)// r1MOVQDX, 48(SP)// r2MOVQ$0, 56(SP)// errnoCALLruntime·exitsyscall(SB)RET

这个过程就结束了。

GO PPROF

使用性能测试工具测试性能，确保性能瓶颈不在应用层。

服务器使用加了两个参数，打开pprof和退出的条件，当连接的客户端超过一定数目就退出，这样就可以收集性能数据了。

go build ./tcp.server.go && ./tcp.server 1 0 1990 4096 1 1g++ tcp.client.cpp -g -O0 -o tcp.client && ./tcp.client 127.0.0.1 1990 4096 ----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   0   6  92   0   0   1|   0  8329B| 974M  974M|   0     0 |2734    72k  0   6  92   0   0   1|   0  7782B| 930M  930M|   0     0 |2737    69k   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                         17389 winlin    20   0  247m 2700 1540 S 100.1  0.0   3:23.69 ./tcp.server 1 0 1990 4096 1   17422 winlin    20   0 11740  896  764 R 85.2  0.0   2:52.34 ./tcp.client 127.0.0.1 1990 4096 [winlin@dell-demo tcp]$    go tool pprof tcp.server tcp.profWelcome to pprof!  For help, type 'help'.(pprof) topTotal: 21446 samples   19715  91.9%  91.9%    20124  93.8% syscall.Syscall     165   0.8%  92.7%    21246  99.1% net.(*netFD).Write     123   0.6%  93.3%      203   0.9% runtime.deferreturn     106   0.5%  93.8%    21435  99.9% main.handleConnection     106   0.5%  94.3%      106   0.5% sync/atomic.CompareAndSwapUint64     103   0.5%  94.7%      162   0.8% net.(*fdMutex).RWLock     100   0.5%  95.2%      211   1.0% runtime.exitsyscall      95   0.4%  95.6%      178   0.8% net.(*fdMutex).RWUnlock      83   0.4%  96.0%    21329  99.5% net.(*conn).Write      82   0.4%  96.4%      155   0.7% runtime.reentersyscall

以及开启多cpu的版本：

go build ./tcp.server.go && ./tcp.server 10 0 1990 4096 1 8g++ tcp.client.readv.cpp -g -O0 -o tcp.client && for((i=0;i<8;i++)); do (./tcp.client 127.0.0.1 1990 64 4096 &); done----total-cpu-usage---- -dsk/total- ---net/lo-- ---paging-- ---system--usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw   5  42  41   0   0  12|   0   117k|6867M 6867M|   0     0 |  15k  738k  5  41  42   0   0  12|   0  5598B|6627M 6627M|   0     0 |  15k  750k[winlin@dell-demo tcp]$    go tool pprof tcp.server tcp.profWelcome to pprof!  For help, type 'help'.(pprof) topTotal: 72052 samples   63097  87.6%  87.6%    65102  90.4% syscall.Syscall     816   1.1%  88.7%     1244   1.7% runtime.deferreturn     801   1.1%  89.8%      801   1.1% sync/atomic.CompareAndSwapUint64     774   1.1%  90.9%    71371  99.1% net.(*netFD).Write     584   0.8%  91.7%      988   1.4% runtime.reentersyscall     412   0.6%  92.3%      790   1.1% net.(*pollDesc).Prepare     403   0.6%  92.8%     1256   1.7% net.(*fdMutex).RWUnlock     389   0.5%  93.4%      816   1.1% runtime.exitsyscall     371   0.5%  93.9%    71742  99.6% net.(*conn).Write     361   0.5%  94.4%    65701  91.2% syscall.Write

可见性能没有问题，都在系统调用那里。

总结

GO单进程关闭tcp no delay和c/c++的write性能差不多，但是只有c/c++的writev的一半。

GO多进程能线性提升性能，在不改变业务代码的前提下，性能是c/c++单进程的数倍。

Winlin 2014.11.22

0 0