JOB ASSIGNMENT USING ARTIFICIALLY DELAYED RESPONSES IN LOAD-BALANCED GROUPS

A detection is made that a first handshake packet has been received from a data processing system at a first system. The first system participates in a load-balanced group managed by a load-balancer. A value is obtained of a metric configured in the first system. from a set of delay functions, a delay function that corresponds to the metric is selected. Using the value of the metric in the selected delay function, a delay period is computed. A transmission of a second handshake packet is delayed for at least the delay period. An intentionally delayed transmission of the second handshake packet is caused after the delay period from the first system to the data processing system.

TECHNICAL FIELD

The present invention relates generally to a method, system, and computer program product for improving job execution performance in load-balanced groups of peer data processing systems. More particularly, the present invention relates to a method, system, and computer program product for job assignment using artificially delayed responses in load-balanced groups.

BACKGROUND

In a load-balanced configuration, a load-balancer system receives requests for service from numerous client systems. Depending on the load-balancing algorithm used therein, the load-balancer sends a received request to one of the systems participating in the load-balanced group of systems serviced by the load-balancer. The system that receives the request from the load-balancer processes the request, or queues the request for processing, depending on the conditions and configuration of the system.

Before sending a request to a system in the group, or from time to time, some load-balancers perform active probing of the systems using a handshake process similar to the TCP handshake. For example, a load-balancer sends a request (called a SYN packet) to a subset of the systems in the load-balanced group. In the TCP handshake analogy, the TCP handshake process uses the SYN packet to synchronize the sender's sequence number with the receiver.

A system that receives the SYN packet (the receiving system) sends a packet (called a SYN-ACK or SYN/ACK packet) to the load-balancer. In the TCP handshake analogy, the SYN-ACK packet is request from the receiver to the sender to synchronize the receiver's sequence number and an acknowledgement of the sender's sequence number.

The SYN-ACK packet allows the load-balancer to monitor the health of the receiving system and the receiving system's TCP stack performance. For example, if the network link between the load-balancer and the receiving system is currently congested, the congested link introduces a delay in receiving the SYN at the server or the SYN-ACK packet at the load-balancer, which informs the load-balancer that there is a currently existing issue in using the receiver system for servicing a request and perhaps the request should be sent to another system in the group. Similarly, if the TCP stack of the receiving system is currently exhibiting poor performance, the SYN-ACK packet will consequently be delayed, informing the load-balancer in a similar way.

Conversely, if the SYN-ACK arriving from a particular system in the group is the first to arrive—with the shortest delay due to the current circumstances—the load-balancer concludes that the network link to the particular system is presently healthy, and the particular system is presently able to process requests just as rapidly as the SYN SYN-ACK handshake. Consequently, the load-balancer sends the request to the fastest responding system in the group.

Offloading of a request is the process of diverting a request from one system to another in a load-balanced group of systems. Presently, if a system in a load-balanced group is experiencing a problem, or has excessive utilization of a computing resource such as the processor, the memory, the network bandwidth, the electrical power, or some other computing resource, the system can offload the request to another peer system in the group.

The active probing method employed by some load-balancers allows the load-balancer to consider the SYN-ACK response from the various systems in the group to assign a request. For example, the load-balancing algorithm selects that system for sending the request whose SYN-ACK is received first.

SUMMARY

The illustrative embodiments provide a method, system, and computer program product. An embodiment includes a method that detects receiving from a data processing system a first handshake packet at a first system, the first system participating in a load-balanced group managed by a load-balancer. The embodiment obtains a value of a metric configured in the first system. The embodiment selects, from a set of delay functions, a delay function that corresponds to the metric. The embodiment computes, using the value of the metric in the selected delay function, a delay period. The embodiment prevents a transmission of a second handshake packet for at least the delay period. The embodiment causes, from the first system to the data processing system, an intentionally delayed transmission of the second handshake packet after the delay period.

DETAILED DESCRIPTION

The illustrative embodiments recognize that there are instances when a participant system of a load-balancing group may not want to take a request for processing. For example, there may exist a current condition at the system, which would not delay the SYN-ACK, but is a reason why the system should not accept a request.

As some non-limiting examples, suppose that the system is processing a high-priority workload, which should proceed as smoothly on the system as possible according to a service level agreement (SLA). The workload might not be utilizing the resources of the system beyond a level when the utilization level begins to slow down SYN-ACK packet transmission from the system. However, it may be desired that the system not process a request while the workload is processing. For example, a second workload/request could make the system process the first workload in a less efficient manner. Such reduction in the efficiency of the first workload may be undesirable for some reason.

The illustrative embodiments recognize that presently a participant system of a load-balancing group cannot indicate such non-delaying present circumstances-related desires to the load-balancer. Even if a participant system theoretically could send this info to a load-balancer, such communication is not scalable, has high overhead, and requires modifications to the load-balancer. Presently, the load-balancer will avoid sending a request to the system if a SYN-ACK from another system arrives at the load-balancer before the SYN-ACK of the system.

The illustrative embodiments recognize that there are other instances when a participant system of a load-balancing group may not want to take a request for processing. For example, a future condition may be planned at the system, which would have no delaying effect on the SYN-ACK at the current time, but is a reason why the system should not presently accept a request.

As some non-limiting examples, suppose that the system is planned to process a high-priority workload in the future, or that the system is planned for undergoing maintenance in the future, for which the system should prepare by emptying the queue and not accepting further requests at the present time. The future plans might not have any delaying effect on the SYN-ACK packet transmission at the present time from the system. A queue is any suitable method of organizing the requests that arrive at a system before the requests are processed by the system.

The illustrative embodiments recognize that presently a participant system of a load-balancing group cannot indicate such desires related to a future or expected condition of the system to the load-balancer. Presently, the load-balancer will avoid sending a request to the system so long as a SYN-ACK from another system arrives at the load-balancer before the SYN-ACK of the system.

The illustrative embodiments recognize that the presently available tools or solutions do not address these needs or provide adequate solutions for these needs. The illustrative embodiments used to describe the invention generally address and solve the above-described problems and other problems related to job assignment using artificially delayed responses in load-balanced groups.

An embodiment can be implemented as a software application. The application implementing an embodiment can be configured as a modification of an existing SYN SYN-ACK transaction handling system in a participant system of a load-balanced group, as a separate application that operates in conjunction with an existing SYN SYN-ACK transaction handling system in the participant system of the load-balanced group, a standalone application, or some combination thereof. While the operations of the various embodiments are described using SYN SYN-ACK transactions, the same operations can be implemented using other request-response packets without departing the scope of the illustrative embodiments. For example, if a load-balancer uses long-lived connections, the load-balancer may broadcast a request (not necessarily a SYN packet) in a manner described herein. The load-balancer may receive responses (not necessarily SYN-ACK packets) from the managed servers in a manner described herein. The load-balancer may then assign a job to the server whose response arrives first at the load-balancer.

For example, an embodiment can be implemented in or with a virtual switch on hypervisor, can be a part of an operating system kernel, can be implemented as a part of a server application, can be implemented in the TCP stack, or some combination thereof. Furthermore, an embodiment operates to provide present or future condition-based deliberate request refusal functionality to a system; and in doing so operates separately and independently of any prior-art algorithm that uses unintentional and consequential SYN-ACK packet delays caused by currently existing packet-delaying conditions in the system and/or the network.

An embodiment executes at a participant system of a load-balanced group. The embodiment detects that a SYN packet, or an equivalent thereof, has been received at the participant system (also referred to herein as the “receiving system”). The embodiment is configured to measure a specific metric of the receiving system, or receive a measurement of the metric.

Some non-limiting examples of the metric include—a highest priority of a workload being currently processed or planned for the future, a restriction currently in effect or planned to be in effect in the future, number of current workloads being processed on the system, a utilization level of a system or network resource currently reached or predicted to be reached in the future, a condition of a system or network resource currently reached or forecasted to be reached in the future, and so on.

A delay function is a computation, or an algorithm for performing a computation, where the input value is a measurement of a metric, and an output value is an amount of time by which a transmission of a SYN-ACK packet should be delayed from the system. Furthermore, it is possible, but not necessary, to have different delay functions correspond to different metrics, different ranges of the measured values of a metric, different combinations of metrics, or some combination thereof.

Additionally, a delay function may be static. For example, the delay function may employ a computation to provide the same output for the same input. Alternatively, a delay function may be dynamic. For example, the delay function may employ a computation that produces different output values for the same input value based on conditions other than the metric. A non-limiting example of a static delay function computes a delay value that is proportional to a measured value of the selected metric. A non-limiting dynamic delay function may enable a server to delay the response based on a previous response to a previous request within some timeframe. This dynamic adjustment may be helpful in the case when the server may expect to receive a lot of workloads because the server set a very small delay value on some previous SYN-ACKs. Accordingly, the server may then start to dynamically increase the delay in future SYN/ACKs based on this anticipation of increased workload.

Given the selected metric and the measured value of the metric, an embodiment selects a suitable delay function from a set of delay functions. The embodiment computes a delay value using the measured value of the metric. The embodiment outputs the computed delay amount to another application or component of the system, causes another application or component of the system to delay a transmission of a SYN-ACK packet, or an equivalent hereof, to the load-balancer, itself delays the transmission of the SYN-ACK packet to the load-balancer, or some combination thereof.

The manner of job assignment using artificially delayed responses in load-balanced groups described herein is unavailable in the presently available methods. A method of an embodiment described herein, when implemented to execute on a device or data processing system, comprises substantial advancement of the functionality of that device or data processing system in enabling a participating system-side control of when to receive or avoid receiving a request from a load-balancer in a load-balanced group.

Furthermore, aspects of the illustrative embodiments are described using SYNs transmitted from a load-balancer and SYN-ACKs transmitted from a participant server only as a non-limiting example. Using a similar principle of operation, a server may offload a request to another server as well. For example, a server may have to choose which other server to use for offloading a request. If a server decides to offload an already assigned request to another server, the server may employ a procedure similar to a load-balancer's active probing. The server, to which the request has been assigned, may transmit SYN or equivalent packets to one or more other servers in the load-balanced group. The other servers may delay their SYN-ACKs or equivalent responses to the SYN-sending server in a manner described herein. Thus, other servers can try to bias the offload decision of the SYN-sending server.

The illustrative embodiments are described with respect to certain types of requests, packets, delay-causing present and future conditions, delay functions, metrics, measurements, delays, algorithms, peer systems, load-balancing, thresholds, tolerances, devices, data processing systems, environments, components, and applications only as examples. Any specific manifestations of these and other similar artifacts are not intended to be limiting to the invention. Any suitable manifestation of these and other similar artifacts can be selected within the scope of the illustrative embodiments.

Assume that servers104and106are participant systems in a group managed by a load-balancer—a role played by data processing system114. Application105implements an embodiment in participant system104, and application107implements an embodiment in participant system106, as described herein. Delay functions109is a collection of delay functions for use with various measurements of various metrics or various combinations thereof, in repository108. Load-balancing application115in load-balancer114sends SYN packets, or an equivalent thereof, to participant systems104and106. Application105, and/or application107cause the SYN-ACK packets, or equivalents thereof, to be delayed according to the selected metrics in their respective systems and the measured values of those metrics. The measured value may be a presently measured value of the metric or a forecasted value of the metric at a future time. As an example operation, application105uses a delay function109to compute a delay value corresponding to the measured value of the selected metric. Application105prevents the transmission of the SYN-ACK packet from participant system104until a time period equal to the computed delay value has elapsed. After the expiration of the delay value computed by application105, application105causes the transmission of the SYN-ACK packet from participant system104to load-balancer114. Application107operates in a similar manner.

Servers104and106, storage unit108, and clients110,112, and114, and device132may couple to network102using wired connections, wireless communication protocols, or other suitable data connectivity. Clients110,112, and114may be, for example, personal computers or network computers.

With reference toFIG. 3, this figure depicts a block diagram of an example configuration for job assignment using artificially delayed responses in load-balanced groups in accordance with an illustrative embodiment. Applications302A,302B, and302N are each an example of application105or107inFIG. 1. Data processing systems S1, S2, . . . Sn are participant systems in a load balanced group manages by load-balancer304over data network306. Application302A operates in system S1, application302B operates in system S2, and application302N operates in server Sn.

Load-balancer304sends SYN or equivalent packets to each of S1, S2, . . . Sn, or a subset thereof. Each participant system that receives a SYN or an equivalent packet responds with a SYN-ACK or an equivalent packet.

According to an operation described herein, application302A in S1computes an intentional delay of D1x. S1does not transmit SYN-ACK308until D1xhas elapsed. Thereafter, S1transmits SYN-ACK308to load-balancer304. Only for the clarity of the description, assume that SYN-ACK packet308of S1will suffer some unintended delay D1due to some conditions currently prevailing in system S1, network306, or both. Thus, SYN-ACK308arrives at load-balancer after delay D1+D1x.

Thus, each participant system S1. . . Sn can intentionally delay their respective SYN-ACK packets in order to indicate some present or future value of some metric or combination of metrics to load-balancer304. From load-balancer304's point of view, the SYN-ACKs are simply arriving with some total delays, and load-balancer304does not know or care whether some part of the total delay is intentional. Operating in this manner, and entirely by a participant system-side functionality, a participant system has successfully influenced the load-balancer's decision to send a request to the system without the load-balancer knowing about the influence, without the load-balancer being modified for such influence.

For example, if only the unintentional delays D1, D2, and Dn were available to load-balancer304, and if D1was less than D2and Dn, load-balancer304would send a request to S1. However, if D1+D1xis greater than D2+D2xand Dn+Dnx, load-balancer304will send the request to a participant system other than S1. For example, if D2+D2xwas smaller than both D1+D1xand Dn+Dnx, then load-balancer304would divert or send the request to S2instead of S1.

With reference toFIG. 4, this figure depicts a block diagram of an example configuration for job assignment using artificially delayed responses in load-balanced groups in accordance with an illustrative embodiment. Application402is an example of any of applications302A,302B, or302ninFIG. 3.

Application402receives or measures value404of a selected metric of the participant system where application402is executing. Repository406is an example of repository108inFIG. 1, and stores a set of delay functions408in the manner of delay functions109inFIG. 1.

Component410detects or receives a SYN packet, or an equivalent thereof, from a load-balancer, e.g., from load-balancer304inFIG. 3. Depending on the selected metric, value404, or both, component412selects a delay function from delay functions408. Component414computes a delay value using the selected delay function and value404.

Component416causes the sending of the SYN-ACK packet, or an equivalent thereof, to be delayed by the computed delay value. For example, application402may output delay value418to another application which delays the SYN-ACK packet transmission. Alternatively, application402itself delays the transmission of the SYN-ACK packet by the delay value, as described herein.

With reference toFIG. 5, this figure depicts a flowchart of an example process for job assignment using artificially delayed responses in load-balanced groups in accordance with an illustrative embodiment. Process500can be implemented in application402inFIG. 4.

The application detects the reception of a SYN packet from a load-balancer (block502). The application measures or obtains a value of a selected metric of the receiving system (block504). The value of the metric can be an actual present value being measured, or a predicted future value expected for the metric at a future time.

The application selects a delay function that is configured to at least correspond to the selected metric (block506). Using the delay function and the value of the metric, the application computes a delay value (block508). The application causes a transmission from the receiving system of a SYN-ACK packet to be delayed by the delay value (block510). The application ends process500thereafter.

Thus, a computer implemented method, system or apparatus, and computer program product are provided in the illustrative embodiments for job assignment using artificially delayed responses in load-balanced groups and other related features, functions, or operations. Where an embodiment or a portion thereof is described with respect to a type of device, the computer implemented method, system or apparatus, the computer program product, or a portion thereof, are adapted or configured for use with a suitable and comparable manifestation of that type of device.