Shulou(Shulou.com)05/31 Report--

In view of how to optimize the performance of the server in high concurrency scenarios, this article introduces the corresponding analysis and solutions in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible method.

The simple, stable and scalable delay message queue framework developed by the author in high concurrency scenarios has accurate timing tasks and delay queue processing functions. Since the open source for more than half a year, it has successfully provided a precise timing scheduling scheme for more than a dozen small and medium-sized enterprises, which has withstood the test of the production environment.

Write at the front

Recently, some friends asked in the group: how to set the tcp_nodelay parameter in the Linux system? Some of my friends asked me. Today, let's talk about how to optimize server performance in high concurrency scenarios.

In fact, the tcp_nodelay parameter is not configured at the operating system level, but the tcp_nodelay parameter is added to the TCP socket to turn off the sticking algorithm so that the packet can be delivered immediately. Tcp_nodelay parameters are mainly for TCP sockets, so for server hardware, if we want to enable it to support millions or even tens of millions of concurrency, how can we optimize it?

Operating system

Here, the operating system I use is CentOS 8, and we can enter the following command to view the version of the operating system.

CentOS Linux release 8.0.1905 (Core)

For high concurrency scenarios, we mainly optimize the network performance of the operating system, and there are many network protocol parameters in the operating system. We optimize the server network performance mainly to optimize these system parameters to achieve the purpose of improving our application access performance.

System parameters

In the CentOS operating system, we can view all the system parameters with the following command.

/ sbin/sysctl-a

Some of the output results are shown below.

There are too many parameters here, about a thousand or so. In high concurrency scenarios, it is impossible to tune all the parameters of the operating system. We pay more attention to the parameters related to the network. If we want to get network-related parameters, we first need to get the type of operating system parameters, which can be obtained by the following command.

/ sbin/sysctl-a | awk-F "."'{print $1}'| sort-K1 | uniq

The result information from running the command is shown below.

Abi crypto debug dev fs kernel net sunrpc user vm

The net type is the operating system parameter related to the network that we should pay attention to. We can get the subtypes under the net type, as shown below.

/ sbin/sysctl-a | grep "^ net." | awk-F "[. |]"'{print $2}'| sort-K1 | uniq

The output result information is shown below.

Bridge core ipv4 ipv6 netfilter nf_conntrack_max unix

In the Linux operating system, these network-related parameters can be modified in the / etc/sysctl.conf file. If these parameters do not exist in the / etc/sysctl.conf file, we can add these parameters in the / etc/sysctl.conf file ourselves.

Among the subtypes of the net type, the subtypes we need to focus on are: core and ipv4.

Optimize socket buffer

If the network socket buffer of the server is too small, it will cause the application to read and write multiple times before the data can be processed, which will greatly affect the performance of our program. If the network socket buffer is set large enough, it can improve the performance of our program to a certain extent.

We can enter the following command on the server's command line to get information about the server socket buffer.

/ sbin/sysctl-a | grep "^ net." | grep "[r | w | _] mem [_ |]"

The output result information is shown below.

Net.core.rmem_default = 212992 net.core.rmem_max = 212992 net.core.wmem_default = 212992 net.core.wmem_max = 212992 net.ipv4.tcp_mem = 43545 58062 87090 net.ipv4.tcp_rmem = 4096 87380 6291456 net.ipv4.tcp_wmem = 4096 16384 4194304 net.ipv4.udp_mem = 87093 116125 174186 net.ipv4.udp_rmem_min = 4096 net.ipv4.udp_wmem_min = 4096

Among them, the ones with max, default and min keywords represent the maximum, default and minimum values, while those with the keywords mem, rmem and wmem are total memory, receive buffer memory and send buffer memory, respectively.

It is important to note that the units with the rmem and wmem keywords are "bytes", while the units with the mem keyword are "pages". "pages" is the smallest unit of memory managed by the operating system, and on Linux systems, the default page size is 4KB.

How to optimize the frequent sending and receiving of large files

If we need to send and receive large files frequently in high concurrency scenarios, how can we optimize the performance of the server?

Here, the system parameters that we can modify are as follows.

Net.core.rmem_default net.core.rmem_max net.core.wmem_default net.core.wmem_max net.ipv4.tcp_mem net.ipv4.tcp_rmem net.ipv4.tcp_wmem

Here, let's assume that the system can allocate maximum 2GB memory to TCP, with a minimum value of 256MB and a pressure value of 1.5GB. Calculated according to the 4KB per page, the minimum, pressure and maximum values of tcp_mem are 65536, 393216 and 524288, respectively, in "pages".

If the average file packet is 512KB, each socket read-write buffer can hold at least 2 packets, 4 packets by default, and a maximum of 10 packets each, then we can calculate the minimum, default and maximum values of tcp_rmem and tcp_wmem are 1048576, 2097152 and 5242880, respectively, in "bytes". While rmem_default and wmem_default are 2097152 and wmem_max is 5242880.

Note: how these values are calculated will be described in detail later.

Here, it is also important to note that the buffer is over 65535, and you also need to set the net.ipv4.tcp_window_scaling parameter to 1.

After the above analysis, we finally get the system tuning parameters as follows.

Net.core.rmem_default = 2097152 net.core.rmem_max = 5242880 net.core.wmem_default = 2097152 net.core.wmem_max = 5242880 net.ipv4.tcp_mem = 65536 393216 524288 net.ipv4.tcp_rmem = 1048576 2097152 5242880 net.ipv4.tcp_wmem = 1048576 2097152 5242880

Optimize TCP connection

Partners who have some knowledge of computer networks all know that the connection of TCP needs to go through "three-way handshake" and "four-wave hand", as well as a series of technical support to support reliable transmission, such as slow start, sliding window, sticky packet algorithm, and so on. Although these can guarantee the reliability of the TCP protocol, sometimes it will affect the performance of our program.

So, how do we optimize TCP connections in high concurrency scenarios?

(1) turn off the sticking algorithm

If the user is sensitive to the time consuming of the request, we need to add the tcp_nodelay parameter to the TCP socket to turn off the sticking algorithm so that the packet can be sent out immediately. At this point, we can also set the parameter value of net.ipv4.tcp_syncookies to 1.

(2) avoid frequent creation and recycling of connected resources

The creation and recovery of network connections is very performance-consuming, and we can optimize the performance of the server by closing idle connections and reusing allocated connection resources. In fact, it is not unfamiliar to reuse the allocated connection resources, such as thread pool, database connection pool is to reuse threads and database connections.

We can close idle connections to the server and reuse allocated connection resources with the following parameters.

Net.ipv4.tcp_tw_reuse = 1 net.ipv4.tcp_tw_recycle = 1 net.ipv4.tcp_fin_timeout = 30 net.ipv4.tcp_keepalive_time=1800

(3) avoid sending packets repeatedly.

TCP supports timeout retransmission mechanism. If the sender has sent the packet to the receiver, but the sender has not received feedback, if the set time interval is reached, the timeout retransmission mechanism of TCP will be triggered. To prevent successful packets from being sent again, we need to set the server's net.ipv4.tcp_sack parameter to 1.

(4) increase the number of server file descriptors

In the Linux operating system, a network connection also takes up a file descriptor, and the more connections it takes, the more file descriptors it takes. If the file descriptor setting is relatively small, it will also affect the performance of our server. At this point, we need to increase the number of server file descriptors.

For example: fs.file-max = 10240000, which means that the server can open up to 10240000 files.

This is the answer to the question on how to optimize the performance of the server in high concurrency scenarios. I hope the above content can be of some help to you. If you still have a lot of doubts to be solved, you can follow the industry information channel for more related knowledge.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.