MINOR: mux-quic: use send-list for immediate sending retry
Sending is done with several iterations over qcs streams in qc_send().
The first loop is conducted over streams in <qcc.send_list>. After this
first iteration, some streams may still have data in their Tx buffer but
were blocked by a full qc_stream_desc buffer. In this case, they have
release their qc_stream_desc buffer in qcc_streams_sent_done().
New iterations can be done for these streams which can allocate new
qc_stream_desc buffer if available. Before this patch, this was done
through another stream list <qcc.send_retry_list>. Now, we can reuse the
new <qcc.send_list> for this usage.
This is safe to use as after first iteration, we have guarantee that
either one of the following is true if there is still streams in
<qcc.send_list> :
* transport layer has rejected data due to congestion
* stream is left because it is blocked on stream flow control
* stream still has data and has released a fulfilled qc_stream_desc
buffer. Immediate retry is useful for these streams : they will
allocate a new qc_stream_desc buffer if possible to continue sending.
This must be backported up to 2.7.
diff --git a/src/mux_quic.c b/src/mux_quic.c
index 195ba9f..71aae71 100644
--- a/src/mux_quic.c
+++ b/src/mux_quic.c
@@ -1499,12 +1499,10 @@
TRACE_STATE("stream flow-control reached", QMUX_EV_QCS_SEND, qcc->conn, qcs);
}
+ /* If qcs.stream.buf is full, release it to the lower layer. */
if (qcs->tx.offset == qcs->tx.sent_offset &&
b_full(&qcs->stream->buf->buf)) {
qc_stream_buf_release(qcs->stream);
- /* prepare qcs for immediate send retry if data to send */
- if (b_data(&qcs->tx.buf))
- LIST_APPEND(&qcc->send_retry_list, &qcs->el);
}
}
@@ -1539,8 +1537,6 @@
goto err;
}
- LIST_INIT(&qcc->send_retry_list);
-
if (!qc_send_mux(qcc->conn->handle.qc, frms))
goto err;
@@ -1725,7 +1721,7 @@
{
struct list frms = LIST_HEAD_INIT(frms);
struct qcs *qcs, *qcs_tmp;
- int total = 0, tmp_total = 0;
+ int total = 0;
TRACE_ENTER(QMUX_EV_QCC_SEND, qcc->conn);
@@ -1797,27 +1793,25 @@
total += _qc_send_qcs(qcs, &frms);
}
- if (qc_send_frames(qcc, &frms)) {
- /* data rejected by transport layer, do not retry. */
- goto out;
- }
-
- retry:
- tmp_total = 0;
- list_for_each_entry_safe(qcs, qcs_tmp, &qcc->send_retry_list, el) {
- int ret;
- BUG_ON(!b_data(&qcs->tx.buf));
- BUG_ON(qc_stream_buf_get(qcs->stream));
+ /* Retry sending until no frame to send, data rejected or connection
+ * flow-control limit reached.
+ */
+ while (qc_send_frames(qcc, &frms) == 0 && !(qcc->flags & QC_CF_BLK_MFCTL)) {
+ /* Reloop over <qcc.send_list>. Useful for streams which have
+ * fulfilled their qc_stream_desc buf and have now release it.
+ */
+ list_for_each_entry(qcs, &qcc->send_list, el_send) {
+ /* Only streams blocked on flow-control or waiting on a
+ * new qc_stream_desc should be present in send_list as
+ * long as transport layer can handle all data.
+ */
+ BUG_ON(qcs->stream->buf && !(qcs->flags & QC_SF_BLK_SFCTL));
- ret = _qc_send_qcs(qcs, &frms);
- tmp_total += ret;
- LIST_DELETE(&qcs->el);
+ if (!(qcs->flags & QC_SF_BLK_SFCTL))
+ total += _qc_send_qcs(qcs, &frms);
+ }
}
- total += tmp_total;
- if (!qc_send_frames(qcc, &frms) && !LIST_ISEMPTY(&qcc->send_retry_list))
- goto retry;
-
out:
/* Deallocate frames that the transport layer has rejected. */
if (!LIST_ISEMPTY(&frms)) {
@@ -2174,7 +2168,6 @@
}
LIST_INIT(&qcc->send_list);
- LIST_INIT(&qcc->send_retry_list);
qcc->wait_event.tasklet->process = qc_io_cb;
qcc->wait_event.tasklet->context = qcc;