mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-20 21:31:28 +02:00
Code Issues Projects Releases Wiki Activity

[MEDIUM] rearrange forwarding condition to enable splice during analysis

Browse Source 
The forwarding condition was not very clear. We would only enable
forwarding when send_max is zero, and we would only splice when no
analyser is installed. In fact we want to enable forward when there
is no analyser and we want to splice at soon as there is data to
forward, regardless of the analysers.
This commit is contained in:
Willy Tarreau 2009-03-08 21:38:23 +01:00
parent e8a28bf165
commit 7c84bab879
2 changed files with 92 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/proto_uxst.c
View File

@ -812,13 +812,25 @@ struct task *uxst_process_session(struct task *t)
if (!s->req->analysers && !(s->req->flags & BF_HIJACK))
s->req->send_max = s->req->l;
/* if noone is interested in analysing data, let's forward everything
* and only wake up every 1-2 MB. We still wake up when send_max is
* reached though.
/* If noone is interested in analysing data, it's time to forward
* everything. We will wake up from time to time when either send_max
* or to_forward are reached.
*/
if (!s->req->send_max && s->req->prod->state >= SI_ST_EST &&
!s->req->analysers && !(s->req->flags & BF_HIJACK)) {
if (s->req->to_forward < FORWARD_DEFAULT_SIZE)
if (!s->req->analysers &&
!(s->req->flags & (BF_HIJACK|BF_SHUTW)) &&
(s->req->prod->state >= SI_ST_EST)) {
/* This buffer is freewheeling, there's no analyser nor hijacker
* attached to it. If any data are left in, we'll permit them to
* move.
*/
buffer_flush(s->req);
/* If the producer is still connected, we'll schedule large blocks
* of data to be forwarded from the producer to the consumer (which
* might possibly not be connected yet).
*/
if (!(s->req->flags & BF_SHUTR) &&
s->req->to_forward < FORWARD_DEFAULT_SIZE)
buffer_forward(s->req, FORWARD_DEFAULT_SIZE);
}
@ -895,13 +907,25 @@ struct task *uxst_process_session(struct task *t)
resync = 1;
}
/* if noone is interested in analysing data, let's forward everything
* and only wake up every 1-2 MB. We still wake up when send_max is
* reached though.
/* If noone is interested in analysing data, it's time to forward
* everything. We will wake up from time to time when either send_max
* or to_forward are reached.
*/
if (!s->rep->send_max && s->rep->prod->state >= SI_ST_EST &&
!s->rep->analysers && !(s->rep->flags & BF_HIJACK)) {
if (s->rep->to_forward < FORWARD_DEFAULT_SIZE)
if (!s->rep->analysers &&
!(s->rep->flags & (BF_HIJACK|BF_SHUTW)) &&
(s->rep->prod->state >= SI_ST_EST)) {
/* This buffer is freewheeling, there's no analyser nor hijacker
* attached to it. If any data are left in, we'll permit them to
* move.
*/
buffer_flush(s->rep);
/* If the producer is still connected, we'll schedule large blocks
* of data to be forwarded from the producer to the consumer (which
* might possibly not be connected yet).
*/
if (!(s->rep->flags & BF_SHUTR) &&
s->rep->to_forward < FORWARD_DEFAULT_SIZE)
buffer_forward(s->rep, FORWARD_DEFAULT_SIZE);
}

84
src/session.c
View File

@ -764,25 +764,39 @@ resync_stream_interface:
resync = 1;
}
/* if noone is interested in analysing data, let's forward everything
* and only wake up every 1-2 MB. We still wake up when send_max is
* reached though.
/* If noone is interested in analysing data, it's time to forward
* everything. We will wake up from time to time when either send_max
* or to_forward are reached.
*/
if (!s->req->send_max && s->req->prod->state >= SI_ST_EST &&
!s->req->analysers && !(s->req->flags & BF_HIJACK)) {
/* check if it is wise to enable kernel splicing on the request buffer */
if (!(s->req->flags & (BF_KERN_SPLICING|BF_SHUTR)) &&
(global.tune.options & GTUNE_USE_SPLICE) &&
(pipes_used < global.maxpipes) &&
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
(s->req->flags & BF_STREAMER_FAST))))
s->req->flags |= BF_KERN_SPLICING;
if (!s->req->analysers &&
!(s->req->flags & (BF_HIJACK|BF_SHUTW)) &&
(s->req->prod->state >= SI_ST_EST)) {
/* This buffer is freewheeling, there's no analyser nor hijacker
* attached to it. If any data are left in, we'll permit them to
* move.
*/
buffer_flush(s->req);
if (s->req->to_forward < FORWARD_DEFAULT_SIZE)
/* If the producer is still connected, we'll schedule large blocks
* of data to be forwarded from the producer to the consumer (which
* might possibly not be connected yet).
*/
if (!(s->req->flags & BF_SHUTR) &&
s->req->to_forward < FORWARD_DEFAULT_SIZE)
buffer_forward(s->req, FORWARD_DEFAULT_SIZE);
}
/* check if it is wise to enable kernel splicing to forward request data */
if (!(s->req->flags & (BF_KERN_SPLICING|BF_SHUTR)) &&
s->req->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) &&
(pipes_used < global.maxpipes) &&
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_REQ) ||
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
(s->req->flags & BF_STREAMER_FAST)))) {
s->req->flags |= BF_KERN_SPLICING;
}
/* reflect what the L7 analysers have seen last */
rqf_last = s->req->flags;
@ -898,25 +912,39 @@ resync_stream_interface:
resync = 1;
}
/* if noone is interested in analysing data, let's forward everything
* and only wake up every 1-2 MB. We still wake up when send_max is
* reached though.
/* If noone is interested in analysing data, it's time to forward
* everything. We will wake up from time to time when either send_max
* or to_forward are reached.
*/
if (!s->rep->send_max && s->rep->prod->state >= SI_ST_EST &&
!s->rep->analysers && !(s->rep->flags & BF_HIJACK)) {
/* check if it is wise to enable kernel splicing on the response buffer */
if (!(s->rep->flags & (BF_KERN_SPLICING|BF_SHUTR)) &&
(global.tune.options & GTUNE_USE_SPLICE) &&
(pipes_used < global.maxpipes) &&
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
(s->rep->flags & BF_STREAMER_FAST))))
s->rep->flags |= BF_KERN_SPLICING;
if (!s->rep->analysers &&
!(s->rep->flags & (BF_HIJACK|BF_SHUTW)) &&
(s->rep->prod->state >= SI_ST_EST)) {
/* This buffer is freewheeling, there's no analyser nor hijacker
* attached to it. If any data are left in, we'll permit them to
* move.
*/
buffer_flush(s->rep);
if (s->rep->to_forward < FORWARD_DEFAULT_SIZE)
/* If the producer is still connected, we'll schedule large blocks
* of data to be forwarded from the producer to the consumer (which
* might possibly not be connected yet).
*/
if (!(s->rep->flags & BF_SHUTR) &&
s->rep->to_forward < FORWARD_DEFAULT_SIZE)
buffer_forward(s->rep, FORWARD_DEFAULT_SIZE);
}
/* check if it is wise to enable kernel splicing to forward response data */
if (!(s->rep->flags & (BF_KERN_SPLICING|BF_SHUTR)) &&
s->rep->to_forward &&
(global.tune.options & GTUNE_USE_SPLICE) &&
(pipes_used < global.maxpipes) &&
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_RTR) ||
(((s->fe->options2|s->be->options2) & PR_O2_SPLIC_AUT) &&
(s->rep->flags & BF_STREAMER_FAST)))) {
s->rep->flags |= BF_KERN_SPLICING;
}
/* reflect what the L7 analysers have seen last */
rpf_last = s->rep->flags;