ASIO,无锁,高并发,高可靠, 统一,网络架构,抗DOS,低端4核心服务器CPU 每秒87万QPS ECHO

wlmqgzm

4核心测试, 小字节数据包收发流量每秒100Mbyte, 已经可以把一个千兆网络占满了,
目前的测试, 测试软件基本上占了一半的CPU使用率, 对真实测试结果有影响. 估计, 目前, 4核心CPU的真实处理能力已经超过100万QPS ECHO,
如果另外找一台机器来做测试, 如果期望有超过82万QPS ECHO的性能, 那么,至少要绑定2个千兆网卡或者使用万兆网络, 才能得到理想的结果,   

暂时没有机器, 可以拿来做测试, 对网络层的测试暂时告一段落, 后面继续其他工作.  

wlmqgzm

以前没有太多调优，　现在很多底层的东西都要自己测试, 积累经验．

测试mutex的效率，１亿次无锁冲突的lock, 大约1.５秒
测试atomic的效率，１亿次atomic, 大约0.５秒
测试内存屏障 １亿次全屏障, 大约0.41秒
测试循环的效率，１亿次循环加法, 大约0.０秒

guo@guo-desktop:/cpp/echo_server/bin/Release$ ./echo_server
begin test mutex.
100000000
1.503490s wall, 1.500000s user + 0.000000s system = 1.500000s CPU (99.8%)
begin test atomic.
0.509658s wall, 0.500000s user + 0.000000s system = 0.500000s CPU (98.1%)
100000000
begin test loop.
0.000000s wall, 0.000000s user + 0.000000s system = 0.000000s CPU (n/a%)
100000000
begin test fenced_block
0.410092s wall, 0.400000s user + 0.000000s system = 0.400000s CPU (97.5%)
100000000

1. 
   
2. void  test_mutex( void )
   
3. {
   
4.   unsigned int i;
   
5.   std::mutex  mutex1;
   
6.   unsigned int j = 0;
   
7.   std::cout << "begin test mutex."<< std::endl;
   
8.   boost::timer::auto_cpu_timer   a2;
   
9. 
   
10.   for( i=0; i<100000000; ++i ) {
    
11.     std::lock_guard<std::mutex>  lock(cout_mutex);
    
12.     ++j;
    
13.     continue;
    
14.     }
    
15.   std::cout << j << std::endl;
    
16.   return;
    
17. }
    
18. 
    
19. 
    
20. void  test_atomic( void )
    
21. {
    
22.   unsigned int i;
    
23.   std::atomic<unsigned int>   j(0);
    
24.   std::cout << "begin test atomic."<< std::endl;
    
25.   {
    
26.   boost::timer::auto_cpu_timer   a2;
    
27.   for( i=0; i<100000000; ++i ) {
    
28.     ++j;
    
29.     continue;
    
30.     }
    
31.   }
    
32.   std::cout << j << std::endl;
    
33.   return;
    
34. }
    
35. 
    
36. void  test_loop( void )
    
37. {
    
38.   unsigned int i;
    
39.   unsigned int   j=0;
    
40.    std::cout << "begin test loop."<< std::endl;
    
41.   {
    
42.   boost::timer::auto_cpu_timer   a2;
    
43.   for( i=0; i<100000000; ++i ) {
    
44.     ++j;
    
45.     continue;
    
46.     }
    
47.   }
    
48.   std::cout << j << std::endl;
    
49.   return;
    
50. }
    
51. 
    
52. 
    
53. void  test_fenced_block( void )
    
54. {
    
55.   unsigned int i;
    
56.   unsigned int   j=0;
    
57.    std::cout << "begin test fenced_block"<< std::endl;
    
58. 
    
59.   {
    
60.   boost::timer::auto_cpu_timer   a2;
    
61.   for( i=0; i<100000000; ++i ) {
    
62.    boost::asio::detail::fenced_block  fb(  boost::asio::detail::fenced_block::full );
    
63.     ++j;
    
64.     continue;
    
65.     }
    
66.   }
    
67.   std::cout << j << std::endl;
    
68.   return;
    
69. }

复制代码

wlmqgzm

各类内存池对比，内存申请的测试，基本上还是std默认的性能最优，Boost等都慢多了, 差距非常大，．因此　内存池无法更加优化．

申请３２字节大小，１亿次
begin test vector mem 1, std default   .
2.132984s wall, 2.120000s user + 0.000000s system = 2.120000s CPU (99.4%)
100000000
begin test vector mem 2, boost::pool_allocator.
8.729578s wall, 8.720000s user + 0.000000s system = 8.720000s CPU (99.9%)
100000000
begin test vector mem 3.  boost::fast_pool_allocator
8.764987s wall, 8.760000s user + 0.000000s system = 8.760000s CPU (99.9%)
100000000
begin test vector mem 4.  __gnu_cxx::__pool_alloc
4.872141s wall, 4.870000s user + 0.000000s system = 4.870000s CPU (100.0%)
100000000
begin test vector mem 5.  __gnu_cxx::malloc_allocato
2.955835s wall, 2.950000s user + 0.000000s system = 2.950000s CPU (99.8%)
100000000
begin test vector mem 6.  __gnu_cxx::__mt_alloc
3.311399s wall, 3.300000s user + 0.000000s system = 3.300000s CPU (99.7%)
100000000

申请４KByte字节大小，１亿次
begin test vector mem 1, std default   .
6.051421s wall, 6.040000s user + 0.000000s system = 6.040000s CPU (99.8%)
100000000
begin test vector mem 2, boost::pool_allocator.
200.278515s wall, 200.100000s user + 0.000000s system = 200.100000s CPU (99.9%)
100000000
begin test vector mem 3.  boost::fast_pool_allocator
196.984990s wall, 196.820000s user + 0.000000s system = 196.820000s CPU (99.9%)
100000000
begin test vector mem 4.  __gnu_cxx::__pool_alloc
112.791246s wall, 112.680000s user + 0.000000s system = 112.680000s CPU (99.9%)
100000000
begin test vector mem 5.  __gnu_cxx::malloc_allocator
112.410630s wall, 112.310000s user + 0.000000s system = 112.310000s CPU (99.9%)
100000000
begin test vector mem 6.  __gnu_cxx::__mt_alloc
113.117813s wall, 113.020000s user + 0.000000s system = 113.020000s CPU (99.9%)
100000000

1. 
   
2. void  test_vector_mem1( void )
   
3. {
   
4.   unsigned int i;
   
5.   unsigned int   j=0;
   
6.    std::cout << "begin test vector mem 1, std default   ."<< std::endl;
   
7.    std::vector<char>  vt0(32);
   
8.   {
   
9.   boost::timer::auto_cpu_timer   a2;
   
10.   for( i=0; i<100000000; ++i ) {
    
11.     std::vector<char>  vt1(32);
    
12.     ++j;
    
13.     continue;
    
14.     }
    
15.   }
    
16.   std::cout << j << std::endl;
    
17.   return;
    
18. }
    
19. 
    
20. 
    
21. void  test_vector_mem2( void )
    
22. {
    
23.   unsigned int i;
    
24.   unsigned int   j=0;
    
25.    std::cout << "begin test vector mem 2, boost::pool_allocator."<< std::endl;
    
26.    std::vector<char, boost::pool_allocator<char> >  vt0(32);
    
27.   {
    
28.   boost::timer::auto_cpu_timer   a2;
    
29.   for( i=0; i<100000000; ++i ) {
    
30.     std::vector<char, boost::pool_allocator<char> >  vt1(32);
    
31.     ++j;
    
32.     continue;
    
33.     }
    
34.   }
    
35.   std::cout << j << std::endl;
    
36.   return;
    
37. }
    
38. 
    
39. 
    
40. void  test_vector_mem3( void )
    
41. {
    
42.   unsigned int i;
    
43.   unsigned int   j=0;
    
44.    std::cout << "begin test vector mem 3.  boost::fast_pool_allocator"<< std::endl;
    
45.    std::vector<char, boost::fast_pool_allocator<char> >  vt0(32);
    
46.   {
    
47.   boost::timer::auto_cpu_timer   a2;
    
48.   for( i=0; i<100000000; ++i ) {
    
49.     std::vector<char, boost::fast_pool_allocator<char> >  vt1(32);
    
50.     ++j;
    
51.     continue;
    
52.     }
    
53.   }
    
54.   std::cout << j << std::endl;
    
55.   return;
    
56. }
    
57. 
    
58. 
    
59. void  test_vector_mem4( void )
    
60. {
    
61.   unsigned int i;
    
62.   unsigned int   j=0;
    
63.    std::cout << "begin test vector mem 4.  __gnu_cxx::__pool_alloc"<< std::endl;
    
64.    std::vector<char, __gnu_cxx::__pool_alloc<char> >  vt0(32);
    
65.   {
    
66.   boost::timer::auto_cpu_timer   a2;
    
67.   for( i=0; i<100000000; ++i ) {
    
68.     std::vector<char, __gnu_cxx::__pool_alloc<char> >  vt0(32);
    
69.     ++j;
    
70.     continue;
    
71.     }
    
72.   }
    
73.   std::cout << j << std::endl;
    
74.   return;
    
75. }
    
76. 
    
77. 
    
78. void  test_vector_mem5( void )
    
79. {
    
80.   unsigned int i;
    
81.   unsigned int   j=0;
    
82.    std::cout << "begin test vector mem 5.  __gnu_cxx::malloc_allocato"<< std::endl;
    
83.    std::vector<char, __gnu_cxx::malloc_allocator<char> >  vt0(32);
    
84.   {
    
85.   boost::timer::auto_cpu_timer   a2;
    
86.   for( i=0; i<100000000; ++i ) {
    
87.     std::vector<char, __gnu_cxx::malloc_allocator<char> >  vt1(32);
    
88.     ++j;
    
89.     continue;
    
90.     }
    
91.   }
    
92.   std::cout << j << std::endl;
    
93.   return;
    
94. }
    
95. 
    
96. 
    
97. void  test_vector_mem6( void )
    
98. {
    
99.   unsigned int i;
    
100.   unsigned int   j=0;
     
101.    std::cout << "begin test vector mem 6.  __gnu_cxx::__mt_alloc"<< std::endl;
     
102.    std::vector<char, __gnu_cxx::__mt_alloc<char> >  vt0(32);
     
103.   {
     
104.   boost::timer::auto_cpu_timer   a2;
     
105.   for( i=0; i<100000000; ++i ) {
     
106.     std::vector<char, __gnu_cxx::__mt_alloc<char> >  vt1(32);
     
107.     ++j;
     
108.     continue;
     
109.     }
     
110.   }
     
111.   std::cout << j << std::endl;
     
112.   return;
     
113. }

复制代码

windoze

回复 113# wlmqgzm

至少你需要试试tcmalloc，dlmalloc，libumem之类现成的malloc实现，然后再试试自制一个lock free/wait free slab based memory allocator。
光这么一句“std默认的性能最优”说明你完全没搞清这玩意儿里面到底怎么转的。

我才不会告诉你当前Linux GLIBC默认用的是ptmalloc…………

wlmqgzm

回复 114# windoze

谢谢提醒, 多测试一下, 以前用过google-perftools里面带有tcmalloc, 好久不用都忘记了.
只测试了最主流的三种, 默认:ptmalloc, 性能最快的tcmalloc, 号称多线程下有更好表现的jemalloc.  
ptmalloc是dlmalloc的分支, libumem没有找到新的版本, 只有2007年的版本, 就不测试了.
基本上还是tcmalloc性能最快.

另外, 更换内存引擎, Echo server收发包性能无变化, 因为accept时预先分配了12KByte, 单ab测试程序只有100个连接, 后来每个收发包都不涉及内存分配
应该对新建连接性能有影响.

ptmalloc 32Byte
begin test vector mem 1, std default   .
2.132984s wall, 2.120000s user + 0.000000s system = 2.120000s CPU (99.4%)
100000000

jemalloc 32Byte
begin test vector mem 1, std default   .
1.625155s wall, 1.620000s user + 0.000000s system = 1.620000s CPU (99.7%)
100000000

tcmalloc 32Byte
begin test vector mem 1, std default   .
1.210702s wall, 1.210000s user + 0.000000s system = 1.210000s CPU (99.9%)
100000000

===================================================

ptmalloc 4KByte
begin test vector mem 1, std default   .
6.051421s wall, 6.040000s user + 0.000000s system = 6.040000s CPU (99.8%)
100000000

jemalloc4k
begin test vector mem 1, std default   .
5.321043s wall, 5.310000s user + 0.000000s system = 5.310000s CPU (99.8%)
100000000

tcmalloc 4K
begin test vector mem 1, std default   .
4.931310s wall, 4.920000s user + 0.000000s system = 4.920000s CPU (99.8%)
100000000  

wlmqgzm

回复 95# hellioncu

谢谢提醒, 昨天在 服务器代码中又仔细找了一遍可能需要 内存屏障 的地方,  基本上所有的代码都不需要, 因为这些需要线程交换数据的地方, 都调用了io_sevice.post, post内部设置了 内存屏障
只有1个显示统计总计数的函数, 可能会需要.
最终调用这个显示统计总计数函数的地方只有一处, 就是最后退出, 总体析构的时候, 而且析构过程中有至少有1ms sleep保护,最后才调用显示统计总计数, 理论上也不需要  内存屏障
但是考虑以后, 可能要更改代码, 提供随时查看总计数, 在更新计数器的函数中就加上了 sfence.   

boost::asio::detail::fenced_block  fb(  boost::asio::detail::fenced_block::half );

继续进行底层的基本性能测试, 算学习吧, 更精细的了解情况.
测试对比性能, 只使用sfence的代码, 每秒大约可执行6亿次,  比不冲突的锁, 性能要高10倍.  减少锁的使用量, 确实能够提高一点性能.
但是, 非冲突的锁,  单线程下每秒也可以执行6000多万次, 性能也是非常突出的.
所以, 有锁的前提下, 最重要的是减少锁冲突, 代码中有几个锁,如果不冲突的话, 代价并不高.

begin test  half fenced_block(sfence)
0.163584s wall, 0.160000s user + 0.000000s system = 0.160000s CPU (97.8%)
100000000
begin test fenced_block(sfence+lfence)
0.410092s wall, 0.400000s user + 0.000000s system = 0.400000s CPU (97.5%)
100000000
begin test mutex.
100000000
1.503490s wall, 1.500000s user + 0.000000s system = 1.500000s CPU (99.8%)
begin test atomic.
0.509658s wall, 0.500000s user + 0.000000s system = 0.500000s CPU (98.1%)
100000000

1. 
   
2. void  test_fenced_block( void )
   
3. {
   
4.   unsigned int i;
   
5.   unsigned int   j=0;
   
6.    std::cout << "begin test fenced_block"<< std::endl;
   
7. 
   
8.   {
   
9.   boost::timer::auto_cpu_timer   a2;
   
10.   for( i=0; i<100000000; ++i ) {
    
11.    boost::asio::detail::fenced_block  fb(  boost::asio::detail::fenced_block::full );
    
12.     ++j;
    
13.     continue;
    
14.     }
    
15.   }
    
16.   std::cout << j << std::endl;
    
17.   return;
    
18. }
    
19. 
    
20. 
    
21. void  test_half_fenced_block( void )
    
22. {
    
23.   unsigned int i;
    
24.   unsigned int   j=0;
    
25.    std::cout << "begin test  half fenced_block"<< std::endl;
    
26. 
    
27.   {
    
28.   boost::timer::auto_cpu_timer   a2;
    
29.   for( i=0; i<100000000; ++i ) {
    
30.    boost::asio::detail::fenced_block  fb(  boost::asio::detail::fenced_block::half );
    
31.     ++j;
    
32.     continue;
    
33.     }
    
34.   }
    
35.   std::cout << j << std::endl;
    
36.   return;
    
37. }
    

复制代码

windoze

回复 115# wlmqgzm

I服了you，你就拿你现在100个连接的echo server测32个字节的小包看不出区别了…………

难道说你花这么大力气搞这么一堆东西就打算做一个支持100并发的echo server？再说你现在拿这么个echo server往死了做benchmark有什么意义呢？具体应用中的瓶颈肯定不一样啊

wlmqgzm

回复 117# windoze

你说的对, 这个改进当然还是有必要的, 提高了大并发下新建连接的性能, 并且实际应用中, 性能肯定有所改善.  测试不能全面反映情况.
已经将代码中的内存管理, 换用tcmalloc了, 能简单压出一点性能的地方, 都要用上.  

g++  -o bin/Release/echo_server obj/Release/main.o  -s  -lboost_thread -lboost_system -lboost_timer -ltcmalloc_minimal

windoze

回复 118# wlmqgzm

对于框架，我还是觉得自制一个memory pool会比较好，因为框架里的内存分配使用情况基本是已知的，用memory pool可以（几乎）完全消除掉所有的内存分配和释放。

benjiamsh

....900的并发  其实你测试的是大块数据的传输， 这根本没什么压力。 把连接数提到100万以后，再来做测试。 你能做到50wqps 都很高了！