MEDIUM: quic: define cubic-pacing congestion algorithm

Author: a-denoyelle

include/haproxy/listener-t.h

@@ -185,6 +185,7 @@ struct bind_conf {
 	struct quic_cc_algo *quic_cc_algo; /* QUIC control congestion algorithm */
 	size_t max_cwnd;                   /* QUIC maximumu congestion control window size (kB) */
 	enum quic_sock_mode quic_mode;     /* QUIC socket allocation strategy */
+	int quic_pacing_burst;             /* QUIC allowed pacing burst size */
 #endif
 	struct proxy *frontend;    /* the frontend all these listeners belong to, or NULL */
 	const struct mux_proto_list *mux_proto; /* the mux to use for all incoming connections (specified by the "proto" keyword) */

include/haproxy/quic_cc-t.h

@@ -113,6 +113,8 @@ struct quic_cc_path {
 	uint64_t in_flight;
 	/* Number of in flight ack-eliciting packets. */
 	uint64_t ifae_pkts;
+	/* Burst size if pacing is used. Not used if congestion algo handle pacing itself. */
+	uint32_t pacing_burst;
 };
 
 struct quic_cc_algo {

include/haproxy/quic_cc.h

@@ -78,7 +78,8 @@ static inline void *quic_cc_priv(const struct quic_cc *cc)
  * which is true for an IPv4 path, if not false for an IPv6 path.
  */
 static inline void quic_cc_path_init(struct quic_cc_path *path, int ipv4, unsigned long max_cwnd,
-                                     struct quic_cc_algo *algo, struct quic_conn *qc)
+                                     struct quic_cc_algo *algo, int burst,
+                                     struct quic_conn *qc)
 {
 	unsigned int max_dgram_sz;
 
@@ -92,6 +93,7 @@ static inline void quic_cc_path_init(struct quic_cc_path *path, int ipv4, unsign
 	path->prep_in_flight = 0;
 	path->in_flight = 0;
 	path->ifae_pkts = 0;
+	path->pacing_burst = burst;
 	quic_cc_init(&path->cc, algo, qc);
 }
 

src/cfgparse-quic.c

@@ -13,7 +13,7 @@
 #include <haproxy/global.h>
 #include <haproxy/listener.h>
 #include <haproxy/proxy.h>
-#include <haproxy/quic_cc-t.h>
+#include <haproxy/quic_cc.h>
 #include <haproxy/quic_rules.h>
 #include <haproxy/tools.h>
 
@@ -69,12 +69,30 @@ static unsigned long parse_window_size(const char *kw, char *value,
 	return 0;
 }
 
+static int parse_burst(const char *kw, char *value, char **end_opt, char **err)
+{
+	int burst;
+
+	errno = 0;
+	burst = strtoul(value, end_opt, 0);
+	if (*end_opt == value || errno != 0) {
+		memprintf(err, "'%s' : could not burst value", kw);
+		goto fail;
+	}
+
+	return burst;
+
+ fail:
+	return -1;
+}
+
 /* parse "quic-cc-algo" bind keyword */
 static int bind_parse_quic_cc_algo(char **args, int cur_arg, struct proxy *px,
                                    struct bind_conf *conf, char **err)
 {
 	struct quic_cc_algo *cc_algo;
 	const char *algo = NULL;
+	int pacing = 0;
 	char *arg;
 
 	if (!*args[cur_arg + 1]) {
@@ -94,6 +112,18 @@ static int bind_parse_quic_cc_algo(char **args, int cur_arg, struct proxy *px,
 		algo = QUIC_CC_CUBIC_STR;
 		cc_algo = &quic_cc_algo_cubic;
 		arg += strlen(QUIC_CC_CUBIC_STR);
+
+		if (strncmp(arg, "-pacing", strlen("-pacing")) == 0) {
+			if (!experimental_directives_allowed) {
+				memprintf(err, "'%s' : support for pacing is experimental, must be allowed via a global "
+				          "'expose-experimental-directives'\n", args[cur_arg]);
+				goto fail;
+			}
+
+			cc_algo->pacing_rate = quic_cc_default_pacing_rate;
+			cc_algo->pacing_burst = quic_cc_default_pacing_burst;
+			pacing = 1;
+		}
 	}
 	else if (strncmp(arg, QUIC_CC_NO_CC_STR, strlen(QUIC_CC_NO_CC_STR)) == 0) {
 		/* nocc */
@@ -127,6 +157,18 @@ static int bind_parse_quic_cc_algo(char **args, int cur_arg, struct proxy *px,
 
 			conf->max_cwnd = cwnd;
 		}
+		else if (pacing) {
+			int burst = parse_burst(args[cur_arg], arg, &end_opt, err);
+			if (burst < 0)
+				goto fail;
+
+			if (*end_opt != ')') {
+				memprintf(err, "'%s' : expects %s(<burst>)", args[cur_arg + 1], algo);
+				goto fail;
+			}
+
+			conf->quic_pacing_burst = burst;
+		}
 		else {
 			if (*arg++ != ')') {
 				memprintf(err, "'%s' : unexpected extra argument for '%s' algorithm", args[cur_arg], algo);

src/listener.c

@@ -2040,6 +2040,7 @@ struct bind_conf *bind_conf_alloc(struct proxy *fe, const char *file,
 	/* Use connection socket for QUIC by default. */
 	bind_conf->quic_mode = QUIC_SOCK_MODE_CONN;
 	bind_conf->max_cwnd = global.tune.quic_frontend_max_window_size;
+	bind_conf->quic_pacing_burst = 0;
 #endif
 	LIST_INIT(&bind_conf->listeners);
 

src/quic_conn.c

@@ -1224,7 +1224,8 @@ struct quic_conn *qc_new_conn(const struct quic_version *qv, int ipv4,
 	/* Only one path at this time (multipath not supported) */
 	qc->path = &qc->paths[0];
 	quic_cc_path_init(qc->path, ipv4, server ? l->bind_conf->max_cwnd : 0,
-	                  cc_algo ? cc_algo : default_quic_cc_algo, qc);
+	                  cc_algo ? cc_algo : default_quic_cc_algo,
+	                  l->bind_conf->quic_pacing_burst, qc);
 
 	memcpy(&qc->local_addr, local_addr, sizeof(qc->local_addr));
 	memcpy(&qc->peer_addr, peer_addr, sizeof qc->peer_addr);