CN115174583A - Server load balancing method based on programmable data plane - Google Patents

Abstract

The invention relates to a server load balancing method based on a programmable data plane, which is characterized in that in a server cluster of a data center, the current actual performance of a server is measured and weighted according to the real-time load and the available computing power of the server, and the weight of the server is calculated through the WMLCF algorithm, so that the current actual performance of the server can be more accurately reflected. The algorithm periodically updates M servers with higher current performance and issues the servers to the data plane in the form of table entries for load balancing scheduling of new connection requests. In addition, the load balancing method is realized in a band state, and a bloom filter is introduced to ensure the connection consistency in the process of updating the server weight. Finally, the invention uses table compression method to store table to reduce the consumption of limited SRAM memory of programmable data plane, and can save a large amount of connection state, thereby ensuring load balance under high concurrency condition of connection request. Therefore, the invention can realize the load balance of the server with higher performance.

Description

Server Load Balancing Method Based on Programmable Data Plane

technical field

The invention relates to the field of load balancing of a programmable network and a server cluster in a data center, in particular to a stateful load balancing method based on a programmable data plane for a server cluster of a data center.

Background technique

A large-scale data center usually provides thousands of services, such as e-commerce, social and video services. Each service is assigned a virtual IP (VIP, Virtual IP) address. At the same time, multiple physical servers form a server cluster to jointly provide the service. Each physical server has a dedicated IP (DIP, Direct IP) address. For a data center, VIP traffic accounts for about 44%, and these large amounts of traffic need to flow through the load balancer for scheduling between backend servers. Therefore, an efficient load balancing scheme is required to map and forward each data packet of the VIP traffic to the corresponding backend server. At the same time, all data packets belonging to the same connection must be sent to the same server for processing to ensure that Connection consistency. If the data packets of the same connection are forwarded to different servers, the connection will be interrupted, additional forwarding delay will be introduced, and the end user experience will be affected.

The main implementation methods of the existing load balancer include software-based, hardware-based, and software-hardware hybrid. Software load balancers, implemented on off-the-shelf servers, have the advantages of low cost, high scalability and high flexibility, but there are two basic problems of high latency and low throughput. In addition, in order to ensure connection consistency, software load balancers usually use consistent hashing to distribute connection requests to backend servers for processing. In order to solve the problem of limited performance of software load balancers, mixed software and hardware load balancers combine the high performance advantages of hardware such as switches. However, most of the scheduling process of new connection requests in the backend server is only implemented through consistent hashing. In recent years, switch manufacturers have begun to develop programmable switching ASICs, such as Intel's Tofino series of chips. The landing of programmable switching ASICs makes the switch data plane also programmable. Because programmable switching ASICs have higher performance (eg, Tb-level throughput) and programmability, there are already many load balancing schemes to balance the load. Functions are offloaded to the programmable data plane. These schemes can achieve higher throughput and lower forwarding delay in performance. However, for the scheduling of backend servers, most schemes use general hashing algorithms or variants of consistent hashing.

SUMMARY OF THE INVENTION

For the existing load balancing solutions, most of them rely on the hash or consistent hash variant mechanism to distribute connection requests among servers, without considering the difference in the actual state of different servers, that is, the different computing capabilities and Actual load, which may lead to unbalanced load distribution among servers, in other words, may cause high-performance servers to be idle while low-performance servers are overloaded, and server resources cannot be effectively utilized. In view of this, the present invention proposes a stateful load balancing method based on a programmable data plane, which schedules connection requests based on the server's available processing capability and real-time load, while the stateful method ensures connection consistency.

The invention aims to realize a load balancing method which can improve the fairness of server load distribution based on the programmable data plane, and at the same time guarantee high-performance forwarding and connection consistency and reduce the SRAM space occupation of the switch during the load balancing scheduling process.

In order to minimize the unbalanced server load distribution, the present invention proposes the WMLCF (Weighted M-Least-Connection First) algorithm, which calculates the dynamic weights of different servers based on the server's available computing power and real-time load. During the cycle, M servers with higher actual remaining computing power are selected according to different weights to receive connection requests. In addition, the present invention introduces a bloom filter to avoid problems that may lead to violation of connection consistency during the weight update process of the backend server. At the same time, considering the limitation of the limited memory of the switch, the present invention adopts the method of compressing and storing table entries in the data plane, so as to save the consumption of the SRAM memory of the switch and store a large number of connection states, so as to ensure the high concurrency of connection requests. Load balancing performance.

The overall implementation of the present invention includes the switch data plane and the control plane:

1. The data plane is responsible for data packet processing and forwarding. This process does not involve the control plane, which ensures a fast load balancing speed. It mainly includes the following components:

(1) Connection table (ConnTable): stores the state of each connection, that is, the mapping of each connection (quintuple) to the DIP server. When the data packet of the existing connection arrives, it will match the corresponding DIP in the connection table, and then directly forward it out, ensuring that all data packets of the same connection are forwarded to the same DIP server, that is, connection consistency. If it is a new connection request, perform the following steps.

(2) Service table (VIPTable): maintains all VIPs as services provided by the server cluster. If a new connection cannot obtain a match in the service table, it means that the service requested by the connection is not in the server cluster, and directly Connection packets are dropped.

(3) Forwarding Table: It is used to allocate DIP server processing for new connection requests, store the DIP pool corresponding to each VIP, and only store the DIPs corresponding to M servers with higher actual available computing power calculated by the control plane.

(4) Server Table (DIPTable): Stores the actual DIPs of all servers in the data center for matching and forwarding.

(5) Bloom filter: Bloom filter is a small but efficient data structure commonly used for element query. We use it to store new connections that arrive during the server weight adjustment process, so that for Existing connections are either in the connection table or in the bloom filter, which guarantees connection consistency during weight adjustment.

2. The control plane is responsible for the calculation and update of the real-time weight of the server, and at the same time sends the corresponding table items to the data plane, mainly including the following modules:

(1) Connection Statistics Module (Conn_Count Module): Count the number of long and short connections on each server. The detection of long and short connections is implemented on the data plane, and then the control plane is notified.

(2) Server weight module (DIP_Weight Module): Stores the weight of each VIP corresponding to the DIP server, and periodically sends the M DIP servers with the smallest weight to the data plane in the form of table entries for load balancing scheduling.

(3) Weight calculation module (WMLCF Module): Responsible for regularly calculating the weight of the server based on the WMLCF algorithm proposed by the server's real-time remaining computing power and real-time load application, and then storing the result in the server weight module.

The present invention specifically adopts the following steps to design:

A method for server load balancing based on a programmable data plane, characterized in that it comprises the following steps:

Step S1: The switch control plane evaluates the real-time loads of different servers in the server cluster;

Step S2: The switch control plane evaluates the real-time available computing power of different servers in the server cluster;

Step S3: The switch control plane uses the WMLCF algorithm to periodically calculate and update the real-time weight of the server for different servers in the server cluster according to its real-time load and available computing power, to measure the current actual performance of the server;

Step S4: Selecting M servers with smaller current actual weights (that is, higher performance) and regularly delivering them to the data plane in the form of table entries for load balancing scheduling;

Step S5: In the process of regularly adjusting the server weight, ensure the connection consistency of data plane data packet forwarding;

Step S6: In order to save a large number of connection states in the limited SRAM memory of the data plane to ensure high-speed load balancing scheduling, the table entries are compressed to reduce memory usage;

The WMLCF algorithm calculates the dynamic weights of different servers based on the server's available computing power and real-time load, so as to select M servers with higher actual remaining computing power to receive connection requests according to different weights in each update cycle of the server weights.

Further, in step S1, the real-time load evaluation of the server includes detection of long and short connections on the server, statistics of the number of active long and short connections, weights of long and short connections, and calculation of real-time server load.

Further, in step S1, the detection of long and short connections on the server is realized on the data plane based on the connected data packet quantity threshold; The active long and short connection number is connected according to the SYN data packet (the beginning of the mark connection) and the FIN/RST data packet (sign of the TCP connection). The end of the connection) is detected and counted; the weights of long and short connections are pre-configured, and the larger the weight, the higher the connection load; the real-time load of the server is the accumulation of the product of the number of active long and short connections on the server and its weight.

Further, in step S2, the real-time available computing power evaluation of the server includes the selection of computing power evaluation indicators and the calculation of real-time available computing power.

Further, in step S2, the indicators selected for the evaluation of server computing power include the available utilization of CPU and memory that have an important impact on server performance; linear weighting is performed according to the degree of impact on server performance as the real-time available computing power of the server.

Further, in step S3, the current actual performance measurement of the server includes the synthesis of the real-time load of the server in step S1 and the real-time available computing power of the server in step S2, and the calculation of the dynamic weight of the server.

Further, in step S3, the dynamic weight of the server is calculated according to the WMLCF algorithm to measure the current actual performance of the server, and the WMLCF algorithm is implemented based on the real-time load and real-time available computing power of the server, that is, the dynamic weight of the server is in step S1. The ratio between the real-time load of the server and the real-time available computing power of the server in step S2; the smaller the server weight, the smaller the real-time load of the server, and the higher the available computing power, that is, the higher the current actual performance of the server;

The specific implementation process of the WMLCF algorithm includes:

1. Server real-time load assessment

In the data plane, the method based on the threshold of the number of packets is used to detect the long and short connections, and then the control plane is notified, which classifies the active long and short connections on the server and assigns different weights. The larger the weight, the higher the load of the connection;

Suppose a server cluster S={S ₁ , S ₂ ,...,S _n }, and the real-time load of server S _i is L(S _i ), then:

Among them, C _ij represents the number of active connection types j of the server S _i ; j=0 or j=1 represents the short connection and long connection respectively; w _j represents the weight of the connection type j; from formula (1), for L (S _i ), the smaller the value is, the lower the real-time load of the server S _i is;

2. Evaluation of the available computing power of the server

Only the remaining available utilization of CPU and memory, two indicators that have an important impact on server performance, are considered, and the linear weighting of these two indicators is the remaining available computing power of the server C(S _i ):

Among them, A _C (Si) and A _M (Si) represent the remaining available _utilization of CPU and memory of server Si, respectively; the coefficients α and β depend on the degree of influence of CPU and memory on server performance, and the greater the degree of influence, the greater the coefficient. is larger; from formula (2), for C(S _i ), the larger the value, the more the remaining available computing power of the server S _i ;

3. Server weight calculation

The server weight is the ratio of the real-time load to the remaining available computing power. According to formula (1) and formula (2), the weight W(S _i ) of the server S _i is:

W(S _i )=L(S _i )/C(S _i ) (3)

From formula (3), for the server S _i , the smaller the weight W(S _i ) is, the lower the real-time load L(S _i ) is and the more the remaining available computing power C(S _i ) is, which means that its current actual load is lower. higher performance.

Further, the M servers selected in step S4 are based on the server weights calculated in step S3, and M servers with smaller weights are selected to be sent to the data plane in the form of entries for load balancing scheduling; The size of the server cluster is dynamically configured.

Further, in step S5, during the periodic update of the server weight, in order to avoid that the new connection may have a delay in the delivery of the table entry, the first few data packets of the connection are selected to be processed by the original server and the subsequent data packets are selected to be newly issued. Server processing, which leads to violation of connection consistency, uses Bloom filter to store new connections that arrive during this period, and new connections are selected to be forwarded to the original server to ensure connection consistency.

Further, in step S6, in order to store a large number of connection states in the limited SRAM space of the programmable data plane, the entries in the connection table are compressed and stored: for each connection state, the matching key Key of the entry does not directly store five yuan. Group, namely: source IP address, destination IP address, source port, destination port, protocol, but store its hash value; the action value Action of the table entry does not directly store the actual server IP address and port, but stores its mapping server Number ID.

In the present invention and its preferred solution, in the server cluster of the data center, the current actual performance of the server is measured and weighted according to the real-time load of the server and the available computing power, and the weight of the server is calculated by the proposed WMLCF (Weighted M-Least-Connection First) algorithm. More accurately reflects the current actual performance of the server. The algorithm regularly updates M servers with higher current performance (smaller weight) and sends them to the data plane in the form of entries for load balancing scheduling of new connection requests. Because the load balancing scheduling is implemented on the data plane, it ensures faster The fast load balancing speed also enables higher-performance servers to handle more new connection requests, improving the balance of server load distribution and server resource utilization. In addition, the load balancing method is implemented with state, and at the same time, a Bloom filter is introduced to ensure connection consistency in the process of server weight update. Finally, the present invention uses the method of table entry compression to store table entries to reduce the consumption of limited SRAM memory of the programmable data plane, and can save a large number of connection states, thereby ensuring load balance in the case of high concurrency of connection requests. Therefore, the present invention can realize server load balancing with higher performance.

Description of drawings

The present invention will be described in further detail below in conjunction with the accompanying drawings and specific embodiments;

1 is a framework diagram of a server load balancing method based on a programmable data plane according to an embodiment of the present invention;

FIG. 2 is a schematic diagram of pseudo-code of the WMLCF (Weighted M-Least-Connection First) algorithm proposed by the server load balancing method based on the programmable data plane according to an embodiment of the present invention;

FIG. 3 is a flowchart of a server load balancing method based on a programmable data plane according to an embodiment of the present invention.

Detailed ways

In order to make the features and advantages of this patent more obvious and easy to understand, the following specific examples are given and described in detail as follows:

It should be noted that the following detailed description is exemplary and intended to provide further explanation of the application. Unless otherwise defined, all technical and scientific terms used in this specification have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs.

It should be noted that the terminology used herein is for the purpose of describing specific embodiments only, and is not intended to limit the exemplary embodiments according to the present application. As used herein, unless the context clearly dictates otherwise, the singular is intended to include the plural as well, furthermore, it is to be understood that when the terms "comprising" and/or "including" are used in this specification, it indicates that There are features, steps, operations, devices, components and/or combinations thereof.

As shown in Figures 1-3, the WMLCF algorithm proposed in the embodiment of the present invention calculates the server weight according to the real-time load of the server and the available computing power, and then selects M servers with higher comprehensive performance according to different server weights. The data plane is used for load balancing scheduling. The pseudo code of the WMLCF algorithm is shown in Figure 2. The specific implementation principles are as follows: 1. Real-time server load evaluation

The load of the server depends on the number of active connections, and the large and small streams (long and short connections) coexist in the data center, and its traffic distribution also conforms to the "80/20" criterion. Compared with short connections, long connection data packets are larger in size and last longer, and consume more server resources, which is equivalent to a higher load. Therefore, in order to more accurately reflect the real-time load of the server, a method based on the threshold of the number of packets is used on the data plane to detect long and short connections, and then the control plane is notified, which classifies the active long and short connections on the server and assigns different weights. A larger value means a higher load on the connection. In addition, the number of active connections is detected and counted according to the SYN data packet (marking the start of the connection) and the FIN/RST data packet (marking the end of the connection) of the TCP connection.

Assuming a server cluster S={S ₁ , S ₂ ,...,S _n }, and the real-time load of server Si is L(S _{i )} , then:

Among them, C _ij represents the number of active connection types j of the server S _i ; j=0 or j=1 represents the short connection and the long connection respectively; w _j represents the weight of the connection type j; it can be drawn from formula (1) that for L( S _i ), the smaller the value is, the lower the real-time load of the server S _i is.

2. Evaluation of the available computing power of the server

Considering the heterogeneity of servers in a server cluster, that is, different servers have different hardware configurations, it is not enough to only consider the real-time load of the server, and the actual performance of the server also depends on the remaining available computing power. The main indicators that affect the remaining computing power of the server are CPU, memory, hard disk type, I/O speed, and network bandwidth. In order to reduce computing overhead, we only consider the remaining available utilization of CPU and memory, two indicators that have an important impact on server performance. Then, linearly weighting these two indicators is the remaining available computing power C(S _i ) of the server:

C(Si)=αA _C (Si)+βA _M (Si),α+β=1 ⑵

Among them, A _C (Si) and A _M (Si) represent the remaining available _utilization of CPU and memory of server Si, respectively; the coefficients α and β depend on the degree of influence of CPU and memory on server performance, and the greater the degree of influence, the greater the coefficient. bigger. It can be obtained from formula (2) that, for C(S _i ), the larger the value is _, the more computing power the server Si has remaining available.

3. Server weight calculation

The current actual performance of the server depends on its real-time load and available processing capacity. We use the weight to represent the current actual performance of the server, and the server weight is the ratio of its real-time load to the remaining available computing power. According to formula (1) and formula (2), the server S _i The weight W(S _i ) is:

W(S _i )=L(S _i )/C(S _i ) ⑶

From formula (3), it can be concluded that for the server S _i , the smaller the weight W(S _i ) is, the lower the real-time load L(S _i ) is and the more the remaining available computing power C(S _i ) is, which means its current actual performance higher.

In the WMLCF algorithm, the server weight changes dynamically with the real-time load and remaining available computing power, so it can more accurately reflect the current actual performance of the server. The M servers with the smallest weight in the server cluster (which can be set according to the size of the server) are sent to the data plane in the form of entries for load balancing scheduling of new requests. The only server with the smallest weight is not selected for delivery because it is considered that If a large number of connection requests arrive in a short period of time, the server may be overloaded, and at the same time, it is ensured that the server with higher actual performance can handle more connection requests. Therefore, we choose multiple servers to jointly handle new connection requests to avoid the above problems.

Additionally, there may be connection consistency violations during server weight updates. Specifically, if a new connection request arrives during the server weight update and table entry delivery, and the table entry is delivered to the data plane, there is a certain delay (ms level) due to the control plane participation. This may lead to a situation: due to the entry installation delay, the first data packet of this new connection arrives before the new entry is installed, it will select the old server to process, and then the new display installation is completed, this Subsequent packets from the new connection will select the new server, violating connection consistency. In order to solve this situation, the present invention introduces a Bloom filter to store new connections that arrive during the server weight update period. These new connections will be processed by the old server, ensuring connection consistency, and not in the Bloom filter. New connections in will choose the new server to handle. The implementation of the Bloom filter in the data plane can use the register object, and the SRAM memory footprint is small.

At the same time, due to the limited SRAM memory space (~100MB) of existing programmable switch ASICs, it is impossible to directly store the number of connections in the data center on the order of 10 million. For IPv4 connections, each connection state needs to store a 13-byte (five-tuple) matching key (Key) and a 6-byte (DIP:port) action value (Action), which means that the connection table needs to consume 10Million connections to store. At least 190MB, which exceeds the 100MB available SRAM of existing programmable switches. In order to store these connection numbers available, we compress the entries in the connection table. For the matching key, we store the 24-bit hash value of the quintuple; for the action value, we store the DIP_ID. For large data centers, the server scale Usually tens of thousands, so we set DIP_ID to 16-bit. After the table entry is compressed, it only takes 5B to store a connection state, and only 50MB of SRAM space is needed to store 10Million connections. Therefore, it is sufficient to store the number of connections on the order of millions in existing programmable switch ASICs.

As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, apparatus, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations of methods, apparatus (apparatus), and computer program products according to embodiments of the invention. It will be understood that each process in the flowchart, and combinations of processes in the flowchart, can be implemented by computer program instructions. These computer program instructions may be provided to the processor of a general purpose computer, special purpose computer, embedded processor or other programmable data processing device to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing device produce A device that implements the functions specified in one or more of the flow charts.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory result in an article of manufacture comprising instruction means, the instructions The device implements the functions specified in one or more of the flowcharts.

These computer program instructions can also be loaded on a computer or other programmable data processing device to cause a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process such that Instructions provide steps for implementing the functions specified in a flow or flows of the flowchart.

The above are only preferred embodiments of the present invention, and are not intended to limit the present invention in other forms. Any person skilled in the art may use the technical content disclosed above to make changes or modifications to equivalent changes. Example. However, any simple modifications, equivalent changes and modifications made to the above embodiments according to the technical essence of the present invention without departing from the content of the technical solutions of the present invention still belong to the protection scope of the technical solutions of the present invention.

This patent is not limited to the above-mentioned best embodiment, anyone can come up with other various forms of server load balancing methods based on programmable data plane under the inspiration of this patent. Changes and modifications should all fall within the scope of this patent.

Claims (10)

1. A server load balancing method based on a programmable data plane is characterized in that: which comprises the following steps:

step S1: the switch control plane evaluates the real-time load of different servers in the server cluster;

step S2: the switch control plane evaluates the real-time available computing power of different servers in the server cluster;

and step S3: the switch control plane periodically calculates real-time weights of the updated servers for different servers in the server cluster by using a WMLCF algorithm according to real-time loads and available computing power of the different servers so as to measure the current actual performance of the servers;

and step S4: selecting M servers with smaller current actual weights to periodically send the servers to a data plane in a table entry form for load balancing scheduling;

step S5: in the process of regularly adjusting the server weight, the connection consistency of forwarding the data plane data packet is ensured;

step S6: compressing the table entry to reduce the memory occupation;

the WMLCF algorithm calculates the dynamic weights of different servers based on the available computing power and real-time load of the servers, so that M servers with higher actual residual computing power are selected to receive the connection request according to different weights in each updating period of the server weights.

2. The method for server load balancing based on programmable data plane according to claim 1, characterized in that: in step S1, the real-time load evaluation of the server includes detection of long and short connections on the server, statistics of the number of active long and short connections, and calculation of weights of the long and short connections and real-time load of the server.

3. The method for server load balancing based on programmable data plane according to claim 2, characterized in that: in the step S1, the detection of the long and short connections on the server is realized on the basis of a threshold value of the number of connected data packets on a data plane; the number of the active long and short connections is detected and counted according to a SYN data packet and an FIN/RST data packet of the TCP connection; the weight of the long and short connections is configured in advance, and the larger the weight is, the higher the connection load is; the real-time load of the server is the accumulation of the product of the number of the long and short active connections on the server and the weight value of the long and short active connections.

4. The method for load balancing servers based on programmable data planes of claim 3, wherein: in step S2, the real-time available calculation power evaluation of the server includes selection of calculation power evaluation indexes and calculation of real-time available calculation power.

5. The method for load balancing servers based on programmable data planes of claim 4, wherein: in step S2, the index selected by the server computing power evaluation comprises the available utilization rate of a CPU and an internal memory which have important influence on the performance of the server; and carrying out linear weighting according to the influence degree of the linear weighting on the performance of the server to serve as the real-time available computing power of the server.

6. The method for server load balancing based on programmable data plane according to claim 5, characterized in that: in step S3, the current actual performance measurement of the server includes the integration of the real-time load of the server in step S1 and the real-time available computing power of the server in step S2, and the calculation of the dynamic weight of the server.

7. The method for server load balancing based on programmable data plane according to claim 6, characterized in that: in the step S3, the dynamic weight of the server is calculated according to a WMLCF algorithm to measure the current actual performance of the server, wherein the WMLCF algorithm is realized based on the real-time load and the real-time available computing power of the server, namely the dynamic weight of the server is the ratio of the real-time load of the server in the step S1 to the real-time available computing power of the server in the step S2; the smaller the weight of the server is, the smaller the real-time load of the server is, and meanwhile, the higher the available computing power is, namely, the higher the current actual performance of the server is;

the specific implementation process of the WMLCF algorithm comprises the following steps:

1. server real-time load assessment

Detecting long and short connections on a data plane by using a method based on a data packet quantity threshold, then informing a control plane, classifying the long and short connections which are active on a server and endowing different weights, wherein the larger the weight is, the higher the connection load is;

let a server cluster S = { S = } ₁ ,S ₂ ,...,S _n }, server S _i Has a real-time load of L (S) _i ) And then:

wherein, C _ij Presentation server S _i The number of active connection types j; j =0 or j =1 represents a short connection and a long connection, respectively; w is a _j Representing the weight of the connection type j; from equation (1), for L (S) _i ) The smaller the value, the server S is represented _i The lower the real-time load;

2. server available computing power assessment

Only two indexes which have important influence on the performance of the server, namely the residual available utilization rate of a CPU (Central processing Unit) and the residual available utilization rate of a memory, are considered, and the two indexes are linearly weighted to obtain the residual available computing power C (S) of the server _i )：

C(Si)＝αA _C (Si)+βA _M (Si),α+β＝1 (2)

Wherein A is _C (Si) and A _M (Si) respectively represents the servers S _i The CPU and the residual available utilization rate of the memory; the alpha and beta coefficients respectively depend on the influence degrees of the CPU and the memory on the performance of the server, and the larger the influence degree is, the larger the coefficient is; from equation (2), for C (S) _i ) The larger the value is, the larger the server S is _i The more remaining available computing power;

3. server weight calculation

The server weight is the ratio of the real-time load to the remaining available computing power, and the server S is based on the formula (1) and the formula (2) _i Weight W (S) _i ) Comprises the following steps:

W(S _i )＝L(S _i )/C(S _i ) (3)

from equation (3), it follows that for server S _i Weight W (S) _i ) The smaller the real-time load L (S) is _i ) Lower simultaneous residual available computing power C (S) _i ) More means higher current actual performance.

8. The method for server load balancing based on programmable data plane according to claim 7, characterized in that: the M servers selected in the step S4 are based on the server weight calculated in the step S3, and the M servers with smaller weights are selected to be issued to the data plane in a table entry form for load balancing scheduling; wherein, M can be dynamically configured according to the scale of the server cluster.

9. The method for load balancing servers based on programmable data planes as claimed in claim 1, wherein: in step S5, during the period of updating the server weight periodically, in order to avoid that the problem of violating the connection consistency is caused by the fact that several data packets before the connection are selected to be processed by the original server and the following data packets are selected to be processed by the newly issued server due to the delay of the table item issue of the new connection, a bloom filter is used to store the new connections arriving during the period, wherein the new connections all select the original forwarding processing of the server, so as to ensure the connection consistency.

10. The method for server load balancing based on programmable data plane according to claim 1, characterized in that: in step S6, in order to store a large number of connection states in the limited SRAM space of the programmable data plane, the table entries in the connection table are compressed and stored: for each connection state, the matching Key of its entry does not directly store the five tuple, i.e.: the source IP address, the destination IP address, the source port, the destination port and the protocol, but the hash value is stored; the Action value Action of the entry does not directly store the actual server IP address and port, but rather its mapping server number ID.

Images