Skip to contentSkip to conversation

sched: new APIs for per-subport queue sizes

RFC New [email protected] 1 participant 2 messages Feb 28, 2018

lore
Share & tools
lore
#0 lore raw

RFC 1/2 sched: new APIs for per-subport queue sizes

From: Alan Dewar <[email protected]>

Added new APIs to allow the maximum queue sizes for each traffic class to be configured on a per-subport basis, rather than all subport's inheriting their maximum queue sizes from their parent port.

Added new sched unit-test to exercise the new APIs.

---
 lib/librte_sched/rte_sched.c           | 243 +++++++++++++++++++++---------
 lib/librte_sched/rte_sched.h           |  48 ++++++
 lib/librte_sched/rte_sched_version.map |   8 +
 test/test/test_sched.c                 | 260 ++++++++++++++++++++++++++++++++-
 4 files changed, 485 insertions(+), 74 deletions(-)
lib/librte_sched/rte_sched.c +177 -66
index 634486c..9436ba5 100644
@@ -58,6 +58,7 @@ struct rte_sched_subport {
 	uint64_t tc_time; /* time of next update */
 	uint32_t tc_credits_per_period[RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE];
 	uint32_t tc_credits[RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE];
+	uint16_t qsize[RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE];
 	uint32_t tc_period;
 
 	/* TC oversubscription */
@@ -71,6 +72,11 @@ struct rte_sched_subport {
 
 	/* Statistics */
 	struct rte_sched_subport_stats stats;
+
+	/* Queue base calculation */
+	uint32_t qsize_add[RTE_SCHED_QUEUES_PER_PIPE];
+	uint32_t qsize_sum;
+	uint32_t qoffset;
 };
 
 struct rte_sched_pipe_profile {
@@ -215,10 +221,6 @@ struct rte_sched_port {
 	struct rte_mbuf **pkts_out;
 	uint32_t n_pkts_out;
 
-	/* Queue base calculation */
-	uint32_t qsize_add[RTE_SCHED_QUEUES_PER_PIPE];
-	uint32_t qsize_sum;
-
 	/* Large data structures */
 	struct rte_sched_subport *subport;
 	struct rte_sched_pipe *pipe;
@@ -241,16 +243,12 @@ enum rte_sched_port_array {
 	e_RTE_SCHED_PORT_ARRAY_TOTAL,
 };
 
-#ifdef RTE_SCHED_COLLECT_STATS
-
 static inline uint32_t
 rte_sched_port_queues_per_subport(struct rte_sched_port *port)
 {
 	return RTE_SCHED_QUEUES_PER_PIPE * port->n_pipes_per_subport;
 }
 
-#endif
-
 static inline uint32_t
 rte_sched_port_queues_per_port(struct rte_sched_port *port)
 {
@@ -260,19 +258,27 @@ rte_sched_port_queues_per_port(struct rte_sched_port *port)
 static inline struct rte_mbuf **
 rte_sched_port_qbase(struct rte_sched_port *port, uint32_t qindex)
 {
-	uint32_t pindex = qindex >> 4;
 	uint32_t qpos = qindex & 0xF;
+	uint32_t subport_id = qindex / rte_sched_port_queues_per_subport(port);
+	struct rte_sched_subport *subport = port->subport + subport_id;
+	uint32_t subport_pipe_offset;
+
+	subport_pipe_offset = qindex % rte_sched_port_queues_per_subport(port);
+	subport_pipe_offset /= RTE_SCHED_QUEUES_PER_PIPE;
+	subport_pipe_offset *= RTE_SCHED_QUEUES_PER_PIPE;
 
-	return (port->queue_array + pindex *
-		port->qsize_sum + port->qsize_add[qpos]);
+	return (port->queue_array + subport->qoffset + subport_pipe_offset +
+		subport->qsize_add[qpos]);
 }
 
 static inline uint16_t
 rte_sched_port_qsize(struct rte_sched_port *port, uint32_t qindex)
 {
 	uint32_t tc = (qindex >> 2) & 0x3;
+	uint32_t subport_id = qindex / rte_sched_port_queues_per_subport(port);
+	struct rte_sched_subport *subport = port->subport + subport_id;
 
-	return port->qsize[tc];
+	return subport->qsize[tc];
 }
 
 static int
@@ -360,7 +366,9 @@ rte_sched_port_check_params(struct rte_sched_port_params *params)
 }
 
 static uint32_t
-rte_sched_port_get_array_base(struct rte_sched_port_params *params, enum rte_sched_port_array array)
+rte_sched_port_get_array_base(struct rte_sched_port_params *params,
+			      enum rte_sched_port_array array,
+			      uint32_t size_queue_array)
 {
 	uint32_t n_subports_per_port = params->n_subports_per_port;
 	uint32_t n_pipes_per_subport = params->n_pipes_per_subport;
@@ -375,16 +383,19 @@ rte_sched_port_get_array_base(struct rte_sched_port_params *params, enum rte_sch
 	uint32_t size_pipe_profiles
 		= RTE_SCHED_PIPE_PROFILES_PER_PORT * sizeof(struct rte_sched_pipe_profile);
 	uint32_t size_bmp_array = rte_bitmap_get_memory_footprint(n_queues_per_port);
-	uint32_t size_per_pipe_queue_array, size_queue_array;
+	uint32_t size_per_pipe_queue_array;
 
 	uint32_t base, i;
 
-	size_per_pipe_queue_array = 0;
-	for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) {
-		size_per_pipe_queue_array += RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS
-			* params->qsize[i] * sizeof(struct rte_mbuf *);
+	if (size_queue_array == 0) {
+		size_per_pipe_queue_array = 0;
+		for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) {
+			size_per_pipe_queue_array +=
+				RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS
+				* params->qsize[i] * sizeof(struct rte_mbuf *);
+		}
+		size_queue_array = n_pipes_per_port * size_per_pipe_queue_array;
 	}
-	size_queue_array = n_pipes_per_port * size_per_pipe_queue_array;
 
 	base = 0;
 
@@ -419,8 +430,9 @@ rte_sched_port_get_array_base(struct rte_sched_port_params *params, enum rte_sch
 	return base;
 }
 
-uint32_t
-rte_sched_port_get_memory_footprint(struct rte_sched_port_params *params)
+static uint32_t
+rte_sched_port_get_memory_footprint_common(struct rte_sched_port_params *params,
+					   uint32_t size_queue_array)
 {
 	uint32_t size0, size1;
 	int status;
@@ -434,39 +446,93 @@ rte_sched_port_get_memory_footprint(struct rte_sched_port_params *params)
 	}
 
 	size0 = sizeof(struct rte_sched_port);
-	size1 = rte_sched_port_get_array_base(params, e_RTE_SCHED_PORT_ARRAY_TOTAL);
+	size1 = rte_sched_port_get_array_base(params,
+					      e_RTE_SCHED_PORT_ARRAY_TOTAL,
+					      size_queue_array);
 
 	return size0 + size1;
 }
 
+uint32_t
+rte_sched_port_get_memory_footprint(struct rte_sched_port_params *params)
+{
+	return rte_sched_port_get_memory_footprint_common(params, 0);
+}
+
+uint32_t
+rte_sched_port_get_memory_footprint_v2(struct rte_sched_port_params *params,
+				       uint32_t size_queue_array)
+{
+	return rte_sched_port_get_memory_footprint_common(params,
+							  size_queue_array);
+}
+
 static void
-rte_sched_port_config_qsize(struct rte_sched_port *port)
+rte_sched_subport_config_qsize(struct rte_sched_port *port,
+			       uint32_t subport_id,
+			       uint16_t *qsize)
 {
+	struct rte_sched_subport *subport = port->subport + subport_id;
+	uint32_t tc;
+
+	for (tc = 0; tc < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; tc++) {
+		if (qsize == NULL)
+			/* The subport inherits its qsizes from the port */
+			subport->qsize[tc] = port->qsize[tc];
+		else
+			/* The subport has explicity configured qsizes */
+			subport->qsize[tc] = qsize[tc];
+	}
+
 	/* TC 0 */
-	port->qsize_add[0] = 0;
-	port->qsize_add[1] = port->qsize_add[0] + port->qsize[0];
-	port->qsize_add[2] = port->qsize_add[1] + port->qsize[0];
-	port->qsize_add[3] = port->qsize_add[2] + port->qsize[0];
+	subport->qsize_add[0] = 0;
+	subport->qsize_add[1] = subport->qsize_add[0] + subport->qsize[0];
+	subport->qsize_add[2] = subport->qsize_add[1] + subport->qsize[0];
+	subport->qsize_add[3] = subport->qsize_add[2] + subport->qsize[0];
 
 	/* TC 1 */
-	port->qsize_add[4] = port->qsize_add[3] + port->qsize[0];
-	port->qsize_add[5] = port->qsize_add[4] + port->qsize[1];
-	port->qsize_add[6] = port->qsize_add[5] + port->qsize[1];
-	port->qsize_add[7] = port->qsize_add[6] + port->qsize[1];
+	subport->qsize_add[4] = subport->qsize_add[3] + subport->qsize[0];
+	subport->qsize_add[5] = subport->qsize_add[4] + subport->qsize[1];
+	subport->qsize_add[6] = subport->qsize_add[5] + subport->qsize[1];
+	subport->qsize_add[7] = subport->qsize_add[6] + subport->qsize[1];
 
 	/* TC 2 */
-	port->qsize_add[8] = port->qsize_add[7] + port->qsize[1];
-	port->qsize_add[9] = port->qsize_add[8] + port->qsize[2];
-	port->qsize_add[10] = port->qsize_add[9] + port->qsize[2];
-	port->qsize_add[11] = port->qsize_add[10] + port->qsize[2];
+	subport->qsize_add[8] = subport->qsize_add[7] + subport->qsize[1];
+	subport->qsize_add[9] = subport->qsize_add[8] + subport->qsize[2];
+	subport->qsize_add[10] = subport->qsize_add[9] + subport->qsize[2];
+	subport->qsize_add[11] = subport->qsize_add[10] + subport->qsize[2];
 
 	/* TC 3 */
-	port->qsize_add[12] = port->qsize_add[11] + port->qsize[2];
-	port->qsize_add[13] = port->qsize_add[12] + port->qsize[3];
-	port->qsize_add[14] = port->qsize_add[13] + port->qsize[3];
-	port->qsize_add[15] = port->qsize_add[14] + port->qsize[3];
+	subport->qsize_add[12] = subport->qsize_add[11] + subport->qsize[2];
+	subport->qsize_add[13] = subport->qsize_add[12] + subport->qsize[3];
+	subport->qsize_add[14] = subport->qsize_add[13] + subport->qsize[3];
+	subport->qsize_add[15] = subport->qsize_add[14] + subport->qsize[3];
+
+	subport->qsize_sum = subport->qsize_add[15] + subport->qsize[3];
 
-	port->qsize_sum = port->qsize_add[15] + port->qsize[3];
+	if (subport_id != 0) {
+		struct rte_sched_subport *prev = port->subport +
+			(subport_id - 1);
+
+		subport->qoffset = prev->qoffset + prev->qsize_sum;
+	}
+}
+
+static char *
+rte_sched_build_queue_size_string(uint16_t *qsize, char *output_str)
+{
+	uint32_t tc;
+	int str_len;
+
+	str_len = sprintf(output_str, "[");
+	for (tc = 0; tc < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; tc++) {
+		str_len += sprintf(output_str + str_len, "%u",
+				   qsize[tc]);
+		if (tc != RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE - 1)
+			str_len += sprintf(output_str + str_len, ", ");
+	}
+	sprintf(output_str + str_len, "]");
+	return output_str;
 }
 
 static void
@@ -590,16 +656,12 @@ rte_sched_port_config_pipe_profile_table(struct rte_sched_port *port, struct rte
 	}
 }
 
-struct rte_sched_port *
-rte_sched_port_config(struct rte_sched_port_params *params)
+static struct rte_sched_port *
+rte_sched_port_config_common(struct rte_sched_port_params *params,
+			     uint32_t mem_size)
 {
 	struct rte_sched_port *port = NULL;
-	uint32_t mem_size, bmp_mem_size, n_queues_per_port, i, cycles_per_byte;
-
-	/* Check user parameters. Determine the amount of memory to allocate */
-	mem_size = rte_sched_port_get_memory_footprint(params);
-	if (mem_size == 0)
-		return NULL;
+	uint32_t bmp_mem_size, n_queues_per_port, i, cycles_per_byte;
 
 	/* Allocate memory to store the data structures */
 	port = rte_zmalloc("qos_params", mem_size, RTE_CACHE_LINE_SIZE);
@@ -659,30 +721,28 @@ rte_sched_port_config(struct rte_sched_port_params *params)
 	port->pkts_out = NULL;
 	port->n_pkts_out = 0;
 
-	/* Queue base calculation */
-	rte_sched_port_config_qsize(port);
-
 	/* Large data structures */
 	port->subport = (struct rte_sched_subport *)
 		(port->memory + rte_sched_port_get_array_base(params,
-							      e_RTE_SCHED_PORT_ARRAY_SUBPORT));
+			e_RTE_SCHED_PORT_ARRAY_SUBPORT, 0));
 	port->pipe = (struct rte_sched_pipe *)
 		(port->memory + rte_sched_port_get_array_base(params,
-							      e_RTE_SCHED_PORT_ARRAY_PIPE));
+			e_RTE_SCHED_PORT_ARRAY_PIPE, 0));
 	port->queue = (struct rte_sched_queue *)
 		(port->memory + rte_sched_port_get_array_base(params,
-							      e_RTE_SCHED_PORT_ARRAY_QUEUE));
+			e_RTE_SCHED_PORT_ARRAY_QUEUE, 0));
 	port->queue_extra = (struct rte_sched_queue_extra *)
 		(port->memory + rte_sched_port_get_array_base(params,
-							      e_RTE_SCHED_PORT_ARRAY_QUEUE_EXTRA));
+			e_RTE_SCHED_PORT_ARRAY_QUEUE_EXTRA, 0));
 	port->pipe_profiles = (struct rte_sched_pipe_profile *)
 		(port->memory + rte_sched_port_get_array_base(params,
-							      e_RTE_SCHED_PORT_ARRAY_PIPE_PROFILES));
+			e_RTE_SCHED_PORT_ARRAY_PIPE_PROFILES, 0));
 	port->bmp_array =  port->memory
-		+ rte_sched_port_get_array_base(params, e_RTE_SCHED_PORT_ARRAY_BMP_ARRAY);
+		+ rte_sched_port_get_array_base(params,
+			e_RTE_SCHED_PORT_ARRAY_BMP_ARRAY, 0);
 	port->queue_array = (struct rte_mbuf **)
 		(port->memory + rte_sched_port_get_array_base(params,
-							      e_RTE_SCHED_PORT_ARRAY_QUEUE_ARRAY));
+			e_RTE_SCHED_PORT_ARRAY_QUEUE_ARRAY, 0));
 
 	/* Pipe profile table */
 	rte_sched_port_config_pipe_profile_table(port, params);
@@ -704,6 +764,35 @@ rte_sched_port_config(struct rte_sched_port_params *params)
 	return port;
 }
 
+
+struct rte_sched_port *
+rte_sched_port_config(struct rte_sched_port_params *params)
+{
+	uint32_t mem_size;
+
+	/* Check user parameters. Determine the amount of memory to allocate */
+	mem_size = rte_sched_port_get_memory_footprint(params);
+	if (mem_size == 0)
+		return NULL;
+
+	return rte_sched_port_config_common(params, mem_size);
+}
+
+struct rte_sched_port *
+rte_sched_port_config_v2(struct rte_sched_port_params *params,
+			 uint32_t queue_array_size)
+{
+	uint32_t mem_size;
+
+	/* Check user parameters. Determine the amount of memory to allocate */
+	mem_size = rte_sched_port_get_memory_footprint_common(params,
+							      queue_array_size);
+	if (mem_size == 0)
+		return NULL;
+
+	return rte_sched_port_config_common(params, mem_size);
+}
+
 void
 rte_sched_port_free(struct rte_sched_port *port)
 {
@@ -736,10 +825,13 @@ static void
 rte_sched_port_log_subport_config(struct rte_sched_port *port, uint32_t i)
 {
 	struct rte_sched_subport *s = port->subport + i;
+	char queue_size_str[(7 * RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE) + 3];
 
+	rte_sched_build_queue_size_string(s->qsize, queue_size_str);
 	RTE_LOG(DEBUG, SCHED, "Low level config for subport %u:\n"
 		"    Token bucket: period = %u, credits per period = %u, size = %u\n"
 		"    Traffic classes: period = %u, credits per period = [%u, %u, %u, %u]\n"
+		"    Traffic class queue-sizes: %s\n"
 		"    Traffic class 3 oversubscription: wm min = %u, wm max = %u\n",
 		i,
 
@@ -754,16 +846,18 @@ rte_sched_port_log_subport_config(struct rte_sched_port *port, uint32_t i)
 		s->tc_credits_per_period[1],
 		s->tc_credits_per_period[2],
 		s->tc_credits_per_period[3],
+		queue_size_str,
 
 		/* Traffic class 3 oversubscription */
 		s->tc_ov_wm_min,
 		s->tc_ov_wm_max);
 }
 
-int
-rte_sched_subport_config(struct rte_sched_port *port,
-	uint32_t subport_id,
-	struct rte_sched_subport_params *params)
+static int
+rte_sched_subport_config_common(struct rte_sched_port *port,
+				uint32_t subport_id,
+				struct rte_sched_subport_params *params,
+				uint16_t *qsize)
 {
 	struct rte_sched_subport *s;
 	uint32_t i;
@@ -808,15 +902,13 @@ rte_sched_subport_config(struct rte_sched_port *port,
 
 	/* Traffic Classes (TCs) */
 	s->tc_period = rte_sched_time_ms_to_bytes(params->tc_period, port->rate);
+	s->tc_time = port->time + s->tc_period;
 	for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) {
 		s->tc_credits_per_period[i]
 			= rte_sched_time_ms_to_bytes(params->tc_period,
 						     params->tc_rate[i]);
-	}
-	s->tc_time = port->time + s->tc_period;
-	for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
 		s->tc_credits[i] = s->tc_credits_per_period[i];
-
+	}
 #ifdef RTE_SCHED_SUBPORT_TC_OV
 	/* TC oversubscription */
 	s->tc_ov_wm_min = port->mtu;
@@ -829,12 +921,31 @@ rte_sched_subport_config(struct rte_sched_port *port,
 	s->tc_ov_rate = 0;
 #endif
 
+	rte_sched_subport_config_qsize(port, subport_id, qsize);
 	rte_sched_port_log_subport_config(port, subport_id);
 
 	return 0;
 }
 
 int
+rte_sched_subport_config(struct rte_sched_port *port,
+			 uint32_t subport_id,
+			 struct rte_sched_subport_params *params)
+{
+	return rte_sched_subport_config_common(port, subport_id, params, NULL);
+}
+
+int
+rte_sched_subport_config_v2(struct rte_sched_port *port,
+			    uint32_t subport_id,
+			    struct rte_sched_subport_params *params,
+			    uint16_t *qsize)
+{
+	return rte_sched_subport_config_common(port, subport_id, params,
+					       qsize);
+}
+
+int
 rte_sched_pipe_config(struct rte_sched_port *port,
 	uint32_t subport_id,
 	uint32_t pipe_id,
lib/librte_sched/rte_sched.h +48 -0

66 lines not on this page · raw message

lib/librte_sched/rte_sched_version.map +8 -0
index 3aa159a..ce92b82 100644
@@ -29,3 +29,11 @@ DPDK_2.1 {
 	rte_sched_port_pkt_read_color;
 
 } DPDK_2.0;
+
+DPDK_18.05 {
+	global;
+
+	rte_sched_port_config_v2;
+	rte_sched_subport_config_v2;
+	rte_sched_port_get_memory_footprint_v2;
+} DPDK_2.1;
test/test/test_sched.c +252 -8

296 lines not on this page · raw message

Signature · 1 line
2.7.4
#1 lore raw

RFC 2/2 sched: support per-subport wred configurations

From: Alan Dewar <[email protected]>

Move the WRED queue configuration parameters from rte_sched_port_params into rte_sched_subport_params so that we can have different WRED configuations on each subport.

Updated sched unit-test to exercise new functionality.

---
 lib/librte_sched/rte_sched.c |  54 +++++-
 lib/librte_sched/rte_sched.h |   6 +-
 test/test/test_sched.c       | 402 +++++++++++++++++++++++++++++++++----------
 3 files changed, 363 insertions(+), 99 deletions(-)
lib/librte_sched/rte_sched.c +49 -5
index 9436ba5..087d7fc 100644
@@ -77,6 +77,11 @@ struct rte_sched_subport {
 	uint32_t qsize_add[RTE_SCHED_QUEUES_PER_PIPE];
 	uint32_t qsize_sum;
 	uint32_t qoffset;
+
+#ifdef RTE_SCHED_RED
+	struct rte_red_config red_config[RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE]
+		[e_RTE_METER_COLORS];
+#endif
 };
 
 struct rte_sched_pipe_profile {
@@ -857,7 +862,9 @@ static int
 rte_sched_subport_config_common(struct rte_sched_port *port,
 				uint32_t subport_id,
 				struct rte_sched_subport_params *params,
-				uint16_t *qsize)
+				uint16_t *qsize,
+				struct rte_red_params red_params[]
+					[e_RTE_METER_COLORS])
 {
 	struct rte_sched_subport *s;
 	uint32_t i;
@@ -909,6 +916,38 @@ rte_sched_subport_config_common(struct rte_sched_port *port,
 						     params->tc_rate[i]);
 		s->tc_credits[i] = s->tc_credits_per_period[i];
 	}
+
+#ifdef RTE_SCHED_RED
+	for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) {
+		uint32_t j;
+
+		if (!red_params) {
+			/* Copy the red configuration from port */
+			for (j = 0; j < e_RTE_METER_COLORS; j++)
+				s->red_config[i][j] = port->red_config[i][j];
+		} else {
+			/* Subport has an individual red configuration */
+			for (j = 0; j < e_RTE_METER_COLORS; j++) {
+				/* if min/max are both zero, then RED is
+				 * disabled
+				 */
+				if ((red_params[i][j].min_th |
+				     red_params[i][j].max_th) == 0) {
+					continue;
+				}
+
+				if (rte_red_config_init(&s->red_config[i][j],
+					red_params[i][j].wq_log2,
+					red_params[i][j].min_th,
+					red_params[i][j].max_th,
+					red_params[i][j].maxp_inv) != 0) {
+					return -6;
+				}
+			}
+		}
+	}
+#endif
+
 #ifdef RTE_SCHED_SUBPORT_TC_OV
 	/* TC oversubscription */
 	s->tc_ov_wm_min = port->mtu;
@@ -932,17 +971,20 @@ rte_sched_subport_config(struct rte_sched_port *port,
 			 uint32_t subport_id,
 			 struct rte_sched_subport_params *params)
 {
-	return rte_sched_subport_config_common(port, subport_id, params, NULL);
+	return rte_sched_subport_config_common(port, subport_id, params, NULL,
+					       NULL);
 }
 
 int
 rte_sched_subport_config_v2(struct rte_sched_port *port,
 			    uint32_t subport_id,
 			    struct rte_sched_subport_params *params,
-			    uint16_t *qsize)
+			    uint16_t *qsize,
+			    struct rte_red_params red_params[]
+				[e_RTE_METER_COLORS])
 {
 	return rte_sched_subport_config_common(port, subport_id, params,
-					       qsize);
+					       qsize, red_params);
 }
 
 int
@@ -1236,6 +1278,8 @@ rte_sched_port_update_queue_stats_on_drop(struct rte_sched_port *port,
 static inline int
 rte_sched_port_red_drop(struct rte_sched_port *port, struct rte_mbuf *pkt, uint32_t qindex, uint16_t qlen)
 {
+	struct rte_sched_subport *subport = port->subport +
+		(qindex / rte_sched_port_queues_per_subport(port));
 	struct rte_sched_queue_extra *qe;
 	struct rte_red_config *red_cfg;
 	struct rte_red *red;
@@ -1244,7 +1288,7 @@ rte_sched_port_red_drop(struct rte_sched_port *port, struct rte_mbuf *pkt, uint3
 
 	tc_index = (qindex >> 2) & 0x3;
 	color = rte_sched_port_pkt_read_color(pkt);
-	red_cfg = &port->red_config[tc_index][color];
+	red_cfg = &subport->red_config[tc_index][color];
 
 	if ((red_cfg->min_th | red_cfg->max_th) == 0)
 		return 0;
lib/librte_sched/rte_sched.h +5 -1
index 1e1d618..fe41ae4 100644
@@ -275,6 +275,8 @@ rte_sched_subport_config(struct rte_sched_port *port,
  *   Subport configuration parameters
  * @param qsize
  *   Array of traffic-class maximum queue-lengths
+ * @param red_params
+ *   Subport WRED queue configuration parameters
  * @return
  *   0 upon success, error code otherwise
  */
@@ -282,7 +284,9 @@ int
 rte_sched_subport_config_v2(struct rte_sched_port *port,
 			    uint32_t subport_id,
 			    struct rte_sched_subport_params *params,
-			    uint16_t *qsize);
+			    uint16_t *qsize,
+			    struct rte_red_params red_params[]
+				[e_RTE_METER_COLORS]);
 
 /**
  * Hierarchical scheduler pipe configuration
test/test/test_sched.c +309 -93

517 lines not on this page · raw message

Signature · 1 line
2.7.4