xref: /dpdk/examples/qos_sched/stats.c (revision 27b549c12df2ef2db6b271795b4df7b14a2d9c2c) 
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4 
5 #include <unistd.h>
6 #include <string.h>
7 
8 #include "main.h"
9 
10 int
11 qavg_q(uint16_t port_id, uint32_t subport_id, uint32_t pipe_id, uint8_t tc,
12 		uint8_t q)
13 {
14 	struct rte_sched_queue_stats stats;
15 	struct rte_sched_port *port;
16 	uint16_t qlen;
17 	uint32_t count, i, queue_id = 0;
18 	uint32_t average;
19 
20 	for (i = 0; i < nb_pfc; i++) {
21 		if (qos_conf[i].tx_port == port_id)
22 			break;
23 	}
24 
25 	if (i == nb_pfc ||
26 		subport_id >= port_params.n_subports_per_port ||
27 		pipe_id >= subport_params[subport_id].n_pipes_per_subport_enabled  ||
28 		tc >= RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE ||
29 		q >= RTE_SCHED_BE_QUEUES_PER_PIPE ||
30 		(tc < RTE_SCHED_TRAFFIC_CLASS_BE && q > 0))
31 		return -1;
32 
33 	port = qos_conf[i].sched_port;
34 	for (i = 0; i < subport_id; i++)
35 		queue_id += subport_params[i].n_pipes_per_subport_enabled *
36 				RTE_SCHED_QUEUES_PER_PIPE;
37 	if (tc < RTE_SCHED_TRAFFIC_CLASS_BE)
38 		queue_id += pipe_id * RTE_SCHED_QUEUES_PER_PIPE + tc;
39 	else
40 		queue_id += pipe_id * RTE_SCHED_QUEUES_PER_PIPE + tc + q;
41 
42 	average = 0;
43 	for (count = 0; count < qavg_ntimes; count++) {
44 		rte_sched_queue_read_stats(port, queue_id, &stats, &qlen);
45 		average += qlen;
46 		usleep(qavg_period);
47 	}
48 
49 	average /= qavg_ntimes;
50 
51 	printf("\nAverage queue size: %" PRIu32 " bytes.\n\n", average);
52 
53 	return 0;
54 }
55 
56 int
57 qavg_tcpipe(uint16_t port_id, uint32_t subport_id, uint32_t pipe_id,
58 		uint8_t tc)
59 {
60 	struct rte_sched_queue_stats stats;
61 	struct rte_sched_port *port;
62 	uint16_t qlen;
63 	uint32_t count, i, queue_id = 0;
64 	uint32_t average, part_average;
65 
66 	for (i = 0; i < nb_pfc; i++) {
67 		if (qos_conf[i].tx_port == port_id)
68 			break;
69 	}
70 
71 	if (i == nb_pfc || subport_id >= port_params.n_subports_per_port ||
72 		pipe_id >= subport_params[subport_id].n_pipes_per_subport_enabled ||
73 		tc >= RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE)
74 		return -1;
75 
76 	port = qos_conf[i].sched_port;
77 
78 	for (i = 0; i < subport_id; i++)
79 		queue_id +=
80 			subport_params[i].n_pipes_per_subport_enabled *
81 			RTE_SCHED_QUEUES_PER_PIPE;
82 
83 	queue_id += pipe_id * RTE_SCHED_QUEUES_PER_PIPE + tc;
84 
85 	average = 0;
86 
87 	for (count = 0; count < qavg_ntimes; count++) {
88 		part_average = 0;
89 
90 		if (tc < RTE_SCHED_TRAFFIC_CLASS_BE) {
91 			rte_sched_queue_read_stats(port, queue_id,
92 				&stats, &qlen);
93 			part_average += qlen;
94 		} else {
95 			for (i = 0; i < RTE_SCHED_BE_QUEUES_PER_PIPE; i++) {
96 				rte_sched_queue_read_stats(port, queue_id + i,
97 					&stats, &qlen);
98 				part_average += qlen;
99 			}
100 			average += part_average / RTE_SCHED_BE_QUEUES_PER_PIPE;
101 		}
102 		usleep(qavg_period);
103 	}
104 
105 	average /= qavg_ntimes;
106 
107 	printf("\nAverage queue size: %" PRIu32 " bytes.\n\n", average);
108 
109 	return 0;
110 }
111 
112 int
113 qavg_pipe(uint16_t port_id, uint32_t subport_id, uint32_t pipe_id)
114 {
115 	struct rte_sched_queue_stats stats;
116 	struct rte_sched_port *port;
117 	uint16_t qlen;
118 	uint32_t count, i, queue_id = 0;
119 	uint32_t average, part_average;
120 
121 	for (i = 0; i < nb_pfc; i++) {
122 		if (qos_conf[i].tx_port == port_id)
123 			break;
124 	}
125 
126 	if (i == nb_pfc ||
127 		subport_id >= port_params.n_subports_per_port ||
128 		pipe_id >= subport_params[subport_id].n_pipes_per_subport_enabled)
129 		return -1;
130 
131 	port = qos_conf[i].sched_port;
132 
133 	for (i = 0; i < subport_id; i++)
134 		queue_id += subport_params[i].n_pipes_per_subport_enabled *
135 				RTE_SCHED_QUEUES_PER_PIPE;
136 
137 	queue_id += pipe_id * RTE_SCHED_QUEUES_PER_PIPE;
138 
139 	average = 0;
140 
141 	for (count = 0; count < qavg_ntimes; count++) {
142 		part_average = 0;
143 		for (i = 0; i < RTE_SCHED_QUEUES_PER_PIPE; i++) {
144 			rte_sched_queue_read_stats(port, queue_id + i,
145 				&stats, &qlen);
146 			part_average += qlen;
147 		}
148 		average += part_average / RTE_SCHED_QUEUES_PER_PIPE;
149 		usleep(qavg_period);
150 	}
151 
152 	average /= qavg_ntimes;
153 
154 	printf("\nAverage queue size: %" PRIu32 " bytes.\n\n", average);
155 
156 	return 0;
157 }
158 
159 int
160 qavg_tcsubport(uint16_t port_id, uint32_t subport_id, uint8_t tc)
161 {
162 	struct rte_sched_queue_stats stats;
163 	struct rte_sched_port *port;
164 	uint16_t qlen;
165 	uint32_t queue_id, count, i, j, subport_queue_id = 0;
166 	uint32_t average, part_average;
167 
168 	for (i = 0; i < nb_pfc; i++) {
169 		if (qos_conf[i].tx_port == port_id)
170 			break;
171 	}
172 
173 	if (i == nb_pfc ||
174 		subport_id >= port_params.n_subports_per_port ||
175 		tc >= RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE)
176 		return -1;
177 
178 	port = qos_conf[i].sched_port;
179 
180 	for (i = 0; i < subport_id; i++)
181 		subport_queue_id +=
182 			subport_params[i].n_pipes_per_subport_enabled *
183 			RTE_SCHED_QUEUES_PER_PIPE;
184 
185 	average = 0;
186 
187 	for (count = 0; count < qavg_ntimes; count++) {
188 		uint32_t n_pipes_per_subport =
189 			subport_params[subport_id].n_pipes_per_subport_enabled;
190 
191 		part_average = 0;
192 		for (i = 0; i < n_pipes_per_subport; i++) {
193 			if (tc < RTE_SCHED_TRAFFIC_CLASS_BE) {
194 				queue_id = subport_queue_id +
195 					i * RTE_SCHED_QUEUES_PER_PIPE + tc;
196 				rte_sched_queue_read_stats(port, queue_id,
197 					&stats, &qlen);
198 				part_average += qlen;
199 			} else {
200 				for (j = 0; j < RTE_SCHED_BE_QUEUES_PER_PIPE; j++) {
201 					queue_id = subport_queue_id +
202 							i * RTE_SCHED_QUEUES_PER_PIPE +
203 							tc + j;
204 					rte_sched_queue_read_stats(port, queue_id,
205 						&stats, &qlen);
206 					part_average += qlen;
207 				}
208 			}
209 		}
210 
211 		if (tc < RTE_SCHED_TRAFFIC_CLASS_BE)
212 			average += part_average /
213 				(subport_params[subport_id].n_pipes_per_subport_enabled);
214 		else
215 			average += part_average /
216 				(subport_params[subport_id].n_pipes_per_subport_enabled) *
217 				RTE_SCHED_BE_QUEUES_PER_PIPE;
218 
219 		usleep(qavg_period);
220 	}
221 
222 	average /= qavg_ntimes;
223 
224 	printf("\nAverage queue size: %" PRIu32 " bytes.\n\n", average);
225 
226 	return 0;
227 }
228 
229 int
230 qavg_subport(uint16_t port_id, uint32_t subport_id)
231 {
232 	struct rte_sched_queue_stats stats;
233 	struct rte_sched_port *port;
234 	uint16_t qlen;
235 	uint32_t queue_id, count, i, j, subport_queue_id = 0;
236 	uint32_t average, part_average;
237 
238 	for (i = 0; i < nb_pfc; i++) {
239 		if (qos_conf[i].tx_port == port_id)
240 			break;
241 	}
242 
243 	if (i == nb_pfc ||
244 		subport_id >= port_params.n_subports_per_port)
245 		return -1;
246 
247 	port = qos_conf[i].sched_port;
248 
249 	for (i = 0; i < subport_id; i++)
250 		subport_queue_id += subport_params[i].n_pipes_per_subport_enabled *
251 			RTE_SCHED_QUEUES_PER_PIPE;
252 
253 	average = 0;
254 
255 	for (count = 0; count < qavg_ntimes; count++) {
256 		uint32_t n_pipes_per_subport =
257 			subport_params[subport_id].n_pipes_per_subport_enabled;
258 
259 		part_average = 0;
260 		for (i = 0; i < n_pipes_per_subport; i++) {
261 			queue_id = subport_queue_id + i * RTE_SCHED_QUEUES_PER_PIPE;
262 
263 			for (j = 0; j < RTE_SCHED_QUEUES_PER_PIPE; j++) {
264 				rte_sched_queue_read_stats(port, queue_id + j,
265 					&stats, &qlen);
266 				part_average += qlen;
267 			}
268 		}
269 
270 		average += part_average /
271 			(subport_params[subport_id].n_pipes_per_subport_enabled *
272 			RTE_SCHED_QUEUES_PER_PIPE);
273 		usleep(qavg_period);
274 	}
275 
276 	average /= qavg_ntimes;
277 
278 	printf("\nAverage queue size: %" PRIu32 " bytes.\n\n", average);
279 
280 	return 0;
281 }
282 
283 int
284 subport_stat(uint16_t port_id, uint32_t subport_id)
285 {
286 	struct rte_sched_subport_stats stats;
287 	struct rte_sched_port *port;
288 	uint32_t tc_ov[RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE];
289 	uint8_t i;
290 
291 	for (i = 0; i < nb_pfc; i++) {
292 		if (qos_conf[i].tx_port == port_id)
293 			break;
294 	}
295 
296 	if (i == nb_pfc || subport_id >= port_params.n_subports_per_port)
297 		return -1;
298 
299 	port = qos_conf[i].sched_port;
300 	memset(tc_ov, 0, sizeof(tc_ov));
301 
302 	rte_sched_subport_read_stats(port, subport_id, &stats, tc_ov);
303 
304 	printf("\n");
305 	printf("+----+-------------+-------------+-------------+-------------+-------------+\n");
306 	printf("| TC |   Pkts OK   |Pkts Dropped |  Bytes OK   |Bytes Dropped|  OV Status  |\n");
307 	printf("+----+-------------+-------------+-------------+-------------+-------------+\n");
308 
309 	for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) {
310 		printf("|  %d | %11" PRIu64 " | %11" PRIu64 " | %11" PRIu64 " | %11" PRIu64 " | %11" PRIu32 " |\n",
311 			i, stats.n_pkts_tc[i], stats.n_pkts_tc_dropped[i],
312 		stats.n_bytes_tc[i], stats.n_bytes_tc_dropped[i], tc_ov[i]);
313 		printf("+----+-------------+-------------+-------------+-------------+-------------+\n");
314 	}
315 	printf("\n");
316 
317 	return 0;
318 }
319 
320 int
321 pipe_stat(uint16_t port_id, uint32_t subport_id, uint32_t pipe_id)
322 {
323 	struct rte_sched_queue_stats stats;
324 	struct rte_sched_port *port;
325 	uint16_t qlen;
326 	uint8_t i, j;
327 	uint32_t queue_id = 0;
328 
329 	for (i = 0; i < nb_pfc; i++) {
330 		if (qos_conf[i].tx_port == port_id)
331 			break;
332 	}
333 
334 	if (i == nb_pfc ||
335 		subport_id >= port_params.n_subports_per_port ||
336 		pipe_id >= subport_params[subport_id].n_pipes_per_subport_enabled)
337 		return -1;
338 
339 	port = qos_conf[i].sched_port;
340 	for (i = 0; i < subport_id; i++)
341 		queue_id += subport_params[i].n_pipes_per_subport_enabled *
342 			RTE_SCHED_QUEUES_PER_PIPE;
343 
344 	queue_id += pipe_id * RTE_SCHED_QUEUES_PER_PIPE;
345 
346 	printf("\n");
347 	printf("+----+-------+-------------+-------------+-------------+-------------+-------------+\n");
348 	printf("| TC | Queue |   Pkts OK   |Pkts Dropped |  Bytes OK   |Bytes Dropped|    Length   |\n");
349 	printf("+----+-------+-------------+-------------+-------------+-------------+-------------+\n");
350 
351 	for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) {
352 		if (i < RTE_SCHED_TRAFFIC_CLASS_BE) {
353 			rte_sched_queue_read_stats(port, queue_id + i, &stats, &qlen);
354 			printf("|  %d |   %d   | %11" PRIu64 " | %11" PRIu64 " | %11" PRIu64 " | %11" PRIu64 " | %11i |\n",
355 				i, 0, stats.n_pkts, stats.n_pkts_dropped, stats.n_bytes,
356 				stats.n_bytes_dropped, qlen);
357 			printf("+----+-------+-------------+-------------+-------------+-------------+-------------+\n");
358 		} else {
359 			for (j = 0; j < RTE_SCHED_BE_QUEUES_PER_PIPE; j++) {
360 				rte_sched_queue_read_stats(port, queue_id + i + j,
361 					&stats, &qlen);
362 				printf("|  %d |   %d   | %11" PRIu64 " | %11" PRIu64 " | %11" PRIu64 " | %11" PRIu64 " | %11i |\n",
363 					i, j, stats.n_pkts, stats.n_pkts_dropped, stats.n_bytes,
364 					stats.n_bytes_dropped, qlen);
365 				printf("+----+-------+-------------+-------------+-------------+-------------+-------------+\n");
366 			}
367 		}
368 	}
369 	printf("\n");
370 
371 	return 0;
372 }
373