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

wlmqgzm

回复 28# windoze

感谢指正．　我确实前面弄错了

由于缺乏测试工具，　最大每次只能测试１０００个连接，１０００个收发，　将就用吧．　

这个是新建连接的处理能力测试报告，　大约4.6万每秒新建连接的处理能力．　前面的最优测试报告是１００个并发连接的包处理能力是每秒３３万个数据包．

后面，　还会做这个测试，　如果找到测试合适的方法后，　会专门针对这个出一份更全的测试报告．

　　Requests per second:    46251.33 [#/sec] (mean)

guo@guo-desktop:~$ ab -n 1000 -c 1000 -k ht tp://127.0.0.1:1971/jjjjjjjjjjjjj  
This is ApacheBench, Version 2.3 <$Revision: 1604373 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd,
Licensed to The Apache Software Foundation,


Benchmarking 127.0.0.1 (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests


Server Software:        
Server Hostname:        127.0.0.1
Server Port:            1971

Document Path:          /jjjjjjjjjjjjj
Document Length:        0 bytes

Concurrency Level:      1000
Time taken for tests:   0.022 seconds
Complete requests:      1000
Failed requests:        0
Non-2xx responses:      1000
Keep-Alive requests:    1000
Total transferred:      119000 bytes
HTML transferred:       0 bytes
Requests per second:    46251.33 [#/sec] (mean)
Time per request:       21.621 [ms] (mean)
Time per request:       0.022 [ms] (mean, across all concurrent requests)
Transfer rate:          5374.91 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        5    9   2.3      8      14
Processing:     2    4   0.7      4       5
Waiting:        2    4   0.7      4       5
Total:          8   12   3.0     12      19

Percentage of the requests served within a certain time (ms)
  50%     12
  66%     14
  75%     15
  80%     16
  90%     17
  95%     18
  98%     18
  99%     19
100%     19 (longest request)


   

wlmqgzm

如何避免服务器端大量出现 TIME_WAIT的情况处理机制的说明:

目前正在做的服务器代码,  设计机制上要避免出现大量WAIT_WAIT,
TCP/IP连接, 谁先发起拆线, 谁就要socket TIME_WAIT(30秒-4分钟,取决于unix版本和设置)
  我做的服务器代码, 目前只有一种情况下, 服务器端将主动发起拆线, 就是 读超时,  也是空闲超时.

服务器端读超时前, 服务器端长时间处于收态, 服务器端定时器任务在该socket上发shutdown receive, 关服务器端receive,  EOF标志被附加到服务器端接收缓冲区的最后,  
  服务器端receive收完缓冲区的数据, 将收EOF,
  客户端TCP/IP底层将收到EOF标志, 客户端send如果发包,  也检测Error_code收EOF, 则客户端立即能够知道 , 此包未发成功, 可立即发起双向拆线 , 重连, 重发,  对方先拆, 服务器端无TIME_WAIT.   
  客户端中间只有1个很小的窗口期属于不确定状态, 对此期间的send数据包, 客户端send只能确认数据包进入本地发送缓冲区, 无法确认数据包最终下落,  发送后, 进入收态, .
  客户端如果send未发包, 则不能检测send通道EOF, 处于收态,

  服务器端receive收完缓冲区的数据, 并处理发送完毕, 再接收 将收EOF, BOOST asio receive_handler error_code=2,  同时服务器端检测发现内部read_time_out_set标志, 将执行关闭服务器端send,  然后定时器等待, 此EOF标志被附加到服务器端发送缓冲区的最后,  客户端在收完缓冲区所有数据后,  客户端receive EOF, 客户端将发起双向拆线, 服务器端无TIME_WAIT

      服务器端在延迟一段时间后, 99%以上的概率, 对方已经主动发起了拆线, 尤其是本地局域网,数据收发很快, 只有很小的概率, 数据和EOF未能在此期间发送到对方,
定时器的间隔可以设的很小, 然后轮询计数, 检查TCP/IP底层is_socket_connected( int socket_handle ), 如果对方已经断开, 就可以不等到最大等待时长, 先拆了.
在99%以上的概率中, 你只需要等几毫秒, 客户端就主动拆线了.  
超时后, 服务器端定时器发起主动拆线, 如果采用hard_close, 此时将清空所有缓冲区的数据, reset连接, 服务器端无TIME_WAIT, 满足高性能服务器的要求;  
如果采用soft_close,  就是普通的拆线流程, 此时所有缓冲区的数据被保留, 服务器端主动发起拆线, 系统将进入TIME_WAIT(30秒-240秒,取决于*inx版本和设置), 此方式可满足高可靠服务器的要求.  
     

     这里需要说明的是: 对于高可靠性设计原则的客户端, 需要在上述的"receive EOF, 客户端发起双向拆线"时, 增加 检查并确认, 是否收到响应包.并启动重连, 没有收到响应包, 要重连重发.做到不丢包.

     对于普通客户端, 例如:linux telnet等, 都会在上面的过程中, 主动发起disconnect, 并 退出服务.

     其余的所有情况都可以ASIO析构方式关闭, 或者close方式关闭.     因为都是对方主动拆的, TIME_WAIT在对方


is_socket_connected( int socket_handle )代码

bool is_socket_connected( int socket_handle )
{
  struct tcp_info info;
  int length = sizeof(info);
  if( socket_handle <= 0 )   return false;
  memset( &info,0,sizeof(info) );
  getsockopt( socket_handle, IPPROTO_TCP, TCP_INFO, &info, (socklen_t *)&length );
  if( info.tcpi_state== 1 )     return true;
  return false;
}

wlmqgzm

目前性能30.7万QPS ECHO,  增加新功能模块, 增加了一个shared_ptr, 总共使用shared_ptr数量增加到2个.  时间精度改进为微秒级别, 增加指定socket进行debug功能, 性能指标有所下降, 尤其,发现shared_ptr数量对性能有较大影响, 应该是shared_ptr内部使用了锁的原因,  时间精度修改,从秒级改为微秒级别, 30秒有0.4秒的影响, 大约1%的时间.  
后台管理定时器由每1秒活跃一次, 改进为每100毫秒活跃一次.
目前, 还在进行功能扩充中, 下一个扩充调试的功能是: 防简单DDOS攻击的模块. 总之, 最终性能指标还会变化.

guo@guo-desktop:~$ ab -n 10000000 -c 100 -k http ://127.0.0.1:1971/jjjjjjjjjjjjj
This is ApacheBench, Version 2.3 <$Revision: 1604373 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd,
Licensed to The Apache Software Foundation,

Benchmarking 127.0.0.1 (be patient)
Completed 1000000 requests
Completed 2000000 requests
Completed 3000000 requests
Completed 4000000 requests
Completed 5000000 requests
Completed 6000000 requests
Completed 7000000 requests
Completed 8000000 requests
Completed 9000000 requests
Completed 10000000 requests
Finished 10000000 requests


Server Software:        
Server Hostname:        127.0.0.1
Server Port:            1971

Document Path:          /jjjjjjjjjjjjj
Document Length:        0 bytes

Concurrency Level:      100
Time taken for tests:   32.576 seconds
Complete requests:      10000000
Failed requests:        0
Non-2xx responses:      10000000
Keep-Alive requests:    10000000
Total transferred:      1190000000 bytes
HTML transferred:       0 bytes
Requests per second:    306975.49 [#/sec] (mean)
Time per request:       0.326 [ms] (mean)
Time per request:       0.003 [ms] (mean, across all concurrent requests)
Transfer rate:          35673.91 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.2      0      29
Waiting:        0    0   0.2      0      29
Total:          0    0   0.2      0      29

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      1
  98%      1
  99%      1
100%     29 (longest request)

yulihua49

回复 32# wlmqgzm
我的服务器端这么做的：
//避免 TIME_WAIT
        so_linger.l_onoff=1;
        so_linger.l_linger=0;
        ret=setsockopt(sock, SOL_SOCKET, SO_LINGER, &so_linger, sizeof so_linger);
        if(ret) ShowLog(1,"set SO_LINGER err=%d,%s",errno,strerror(errno));

服务器主动关闭连接出现在如下情形：
1.客户端已经关闭。
2.客户端超时
3.服务器端出现致命错误。
此时，优雅的保护通信buf的数据已经没有任何意义，野蛮的关闭它！！！



   

wlmqgzm

回复 34# yulihua49

对, 这个就是硬关闭, 我的代码中也做了, 但是没有应用的模块.

如果做高可靠服务器的话, 就没有这么霸气, 还是考虑主动协调对方, 让对方主动发起disconnect, 避免丢包, 避免TIME_WAIT;
在目前的TCP/IP机制下, 一般的客户端, 例如telnet等, 都可以协调成功, 避免TIME_WAIT

//  这个是硬关闭，且closesocket立刻返回，同时释放所有资源。
void Asio_tcp_server::socket_hard_close( boost::asio::ip::tcp::socket &socket1,  int socket_handle )
{
  boost::asio::socket_base::linger option( true, 0 );
  socket1.set_option(option);
  socket1.close();
  if( d_display_level>=5 )  {
    log_message_int("socket_hard_close. socket=", socket_handle );
    }
  return;
}


   

wlmqgzm

贴原版的shutdown简介:

Shutting down the writing end of a socket solves a number of thorny problems. They are
    • Flushes out the kernel buffers that contain any pending data to be sent. Data is buffered by the kernel networking software to improve performance.
    • Sends an end-of-file indication to the remote socket. This tells the remote reading process that no more data will be sent to it on this socket.
    • Leaves the partially shutdown socket open for reading. This makes it possible to receive confirmation messages after the end-of-file indication has been sent on the socket.
    • Disregards the number of open references on the socket. Only the last close(2) on a socket will cause an end-of-file indication to be sent.

总之, 无论是客户端, 还是服务器端, 如果要实现高可靠设计, 都要按照规范的要求进行设计, 最终可以保证正常重启动模块, 不丢失一个数据包.

wlmqgzm

使用shutdown对收发依次进行关闭, 最后再hard_close或者soft_close,  比较安全

int  Asio_tcp_server::socket_shutdown_receive( boost::asio::ip::tcp::socket  &socket1 )
{
  boost::system::error_code ec;
  socket1.shutdown( boost::asio::ip::tcp::socket::shutdown_receive, ec );
  if( ec )   {
    if( d_display_level>=2 )  {
      int  socket_handle = socket1.native_handle();
      int value =  ec.value();
      std::string str_msg   = "socket=";
      str_msg += std::to_string( socket_handle );
      str_msg +=  ", error value=";
      str_msg += std::to_string( value );
      str_msg +=  ", error=";
      str_msg += ec.message();
      warn_message_str( str_msg );
      }
    return -1;
    }
  if( d_display_level>=5 )  {
    int  socket_handle = socket1.native_handle();
    log_message_int("ok. shutdown receive. socket=", socket_handle);
    }
  return  0;
}


int  Asio_tcp_server::socket_shutdown_send( boost::asio::ip::tcp::socket  &socket1 )
{
  boost::system::error_code ec;
  socket1.shutdown( boost::asio::ip::tcp::socket::shutdown_send, ec );
  if( ec )   {
    if( d_display_level>=2 )  {
      int  socket_handle = socket1.native_handle();
      int value =  ec.value();
      std::string str_msg   = "socket=";
      str_msg += std::to_string( socket_handle );
      str_msg +=  ", error value=";
      str_msg += std::to_string( value );
      str_msg +=  ", error=";
      str_msg += ec.message();
      warn_message_str( str_msg );
      }
    return -1;
    }
  if( d_display_level>=5 )  {
    int  socket_handle = socket1.native_handle();
    log_message_int("ok. shutdown send. socket=", socket_handle);
    }
  return 0;
}


int  Asio_tcp_server::socket_shutdown_both( boost::asio::ip::tcp::socket  &socket1 )
{
  boost::system::error_code ec;
  socket1.shutdown( boost::asio::ip::tcp::socket::shutdown_both, ec );
  if( ec )   {
    if( d_display_level>=2 )  {
      int  socket_handle = socket1.native_handle();
      int value =  ec.value();
      std::string str_msg   = "socket=";
      str_msg += std::to_string( socket_handle );
      str_msg +=  ", error value=";
      str_msg += std::to_string( value );
      str_msg +=  ", error=";
      str_msg += ec.message();
      warn_message_str( str_msg );
      }
    return -1;
    }
  if( d_display_level>=2 )  {
    int  socket_handle = socket1.native_handle();
    log_message_int("ok. shutdown send. socket=", socket_handle);
    }
  return 0;
}

wlmqgzm

void Asio_tcp_server::socket_hard_close( boost::asio::ip::tcp::socket &socket1,  int socket_handle )
{
  boost::asio::socket_base::linger option( true, 0 );
  socket1.set_option(option);
  socket1.close();
  if( d_display_level>=5 )  {
    log_message_int("socket_hard_close. socket=", socket_handle );
    }
  return;
}


void Asio_tcp_server::socket_soft_close( boost::asio::ip::tcp::socket &socket1, int socket_handle )
{
  boost::asio::socket_base::linger option( false, 0 );
  socket1.set_option(option);
  socket1.close();
  if( d_display_level>=5 )  {
    log_message_int("socket_soft_close. socket=", socket_handle);
    }
  return;
}

hellioncu

我看lz处于一种亢奋的状态，就不说啥了