[dpdk-dev] [PATCH v2 5/9] app/procinfo: add code for debug tm

[Vipin Varghese <vipin.varghese@intel.com>]

Function debug_tm is used for displaying the tm PMD under the
primary process. This covers basic and per node|level details.

Signed-off-by: Vipin Varghese <vipin.varghese@intel.com>
---
 app/proc-info/main.c | 247 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 246 insertions(+), 1 deletion(-)

diff --git a/app/proc-info/main.c b/app/proc-info/main.c
index 5c75764a1..f518935a2 100644
--- a/app/proc-info/main.c
+++ b/app/proc-info/main.c
@@ -32,6 +32,7 @@
 #include <rte_cycles.h>
 #include <rte_security.h>
 #include <rte_cryptodev.h>
+#include <rte_tm.h>
 
 /* Maximum long option length for option parsing. */
 #define MAX_LONG_OPT_SZ 64
@@ -748,7 +749,251 @@ debug_port(void)
 static void
 debug_tm(void)
 {
-	printf(" tm");
+	int ret = 0, is_leaf = 0;
+	unsigned int j, k;
+	uint16_t i = 0;
+
+	snprintf(bdr_str, 100, "debug - TM PMD %"PRIu64, rte_get_tsc_hz());
+	STATS_BDR_STR(10, bdr_str);
+
+	RTE_ETH_FOREACH_DEV(i) {
+		struct rte_eth_dev_info dev_info = {0};
+		struct rte_tm_capabilities cap = {0};
+		struct rte_tm_error error = {0};
+		struct rte_tm_node_capabilities	capnode = {0};
+		struct rte_tm_level_capabilities caplevel = {0};
+		uint32_t n_leaf_nodes = 0;
+
+		snprintf(bdr_str, 100, " TM for port (%u) ", i);
+		STATS_BDR_STR(5, bdr_str);
+
+		rte_eth_dev_info_get(i, &dev_info);
+		printf("  - Generic\n"
+		       "\t  -- driver name %s\n"
+		       "\t  -- max vf (%u)\n"
+		       "\t  -- max tx queues (%u)\n"
+		       "\t  -- number of tx queues (%u)\n",
+		       dev_info.driver_name,
+		       dev_info.max_vfs,
+		       dev_info.max_tx_queues,
+		       dev_info.nb_tx_queues);
+
+		ret = rte_tm_get_number_of_leaf_nodes(i, &n_leaf_nodes, &error);
+		if (ret == 0)
+			printf("  - leaf nodes (%u)\n", n_leaf_nodes);
+
+		ret = rte_tm_capabilities_get(i, &cap, &error);
+		if (ret)
+			continue;
+
+		printf("  - MAX:"
+		       " nodes (%u)"
+		       " levels (%u)"
+		       " children (%u)\n",
+		       cap.n_nodes_max,
+		       cap.n_levels_max,
+		       cap.sched_n_children_max);
+
+		printf("  - identical nodes:"
+		       "  non leaf (%d) leaf (%d)\n",
+		       cap.non_leaf_nodes_identical,
+		       cap.leaf_nodes_identical);
+
+		printf("  - Shaper MAX:\n"
+		       "\t  -- total (%u)\n"
+		       "\t  -- private (%u) private dual (%d)\n"
+		       "\t  -- shared (%u) shared dual (%u)\n",
+		       cap.shaper_n_max,
+		       cap.shaper_private_n_max,
+		       cap.shaper_private_dual_rate_n_max,
+		       cap.shaper_shared_n_max,
+		       cap.shaper_shared_dual_rate_n_max);
+
+		printf("  - mark support:\n");
+		printf("\t  -- vlan dei: GREEN (%d) YELLOW (%d) RED (%d)\n",
+		       cap.mark_vlan_dei_supported[RTE_TM_GREEN],
+		       cap.mark_vlan_dei_supported[RTE_TM_YELLOW],
+		       cap.mark_vlan_dei_supported[RTE_TM_RED]);
+		printf("\t  -- ip ecn tcp: GREEN (%d) YELLOW (%d) RED (%d)\n",
+		       cap.mark_ip_ecn_tcp_supported[RTE_TM_GREEN],
+		       cap.mark_ip_ecn_tcp_supported[RTE_TM_YELLOW],
+		       cap.mark_ip_ecn_tcp_supported[RTE_TM_RED]);
+		printf("\t  -- ip ecn sctp: GREEN (%d) YELLOW (%d) RED (%d)\n",
+		       cap.mark_ip_ecn_sctp_supported[RTE_TM_GREEN],
+		       cap.mark_ip_ecn_sctp_supported[RTE_TM_YELLOW],
+		       cap.mark_ip_ecn_sctp_supported[RTE_TM_RED]);
+		printf("\t  -- ip dscp: GREEN (%d) YELLOW (%d) RED (%d)\n",
+		       cap.mark_ip_dscp_supported[RTE_TM_GREEN],
+		       cap.mark_ip_dscp_supported[RTE_TM_YELLOW],
+		       cap.mark_ip_dscp_supported[RTE_TM_RED]);
+
+		printf("  - mask stats (0x%"PRIx64")"
+		       " dynamic update (0x%"PRIx64")\n",
+		       cap.stats_mask,
+		       cap.dynamic_update_mask);
+
+		printf("  - sched MAX:\n"
+		       "\t  -- total (%u)\n"
+		       "\t  -- sp levels (%u)\n"
+		       "\t  -- wfq children per group (%u)\n"
+		       "\t  -- wfq groups (%u)\n"
+		       "\t  -- wfq weight (%u)\n",
+		       cap.sched_sp_n_priorities_max,
+		       cap.sched_sp_n_priorities_max,
+		       cap.sched_wfq_n_children_per_group_max,
+		       cap.sched_wfq_n_groups_max,
+		       cap.sched_wfq_weight_max);
+
+		printf("  - CMAN support:\n"
+		       "\t  -- WRED mode: pkt (%d) byte (%d)\n"
+		       "\t  -- head drop (%d)\n",
+		       cap.cman_wred_packet_mode_supported,
+		       cap.cman_wred_byte_mode_supported,
+		       cap.cman_head_drop_supported);
+		printf("\t  -- MAX WRED CONTEXT:"
+		       " total (%u) private (%u) shared (%u)\n",
+		       cap.cman_wred_context_n_max,
+		       cap.cman_wred_context_private_n_max,
+		       cap.cman_wred_context_shared_n_max);
+
+		for (j = 0; j < cap.n_nodes_max; j++) {
+			ret = rte_tm_node_capabilities_get(i, j,
+				&capnode, &error);
+			if (ret)
+				continue;
+
+			printf("  NODE %u\n", j);
+			printf("\t  - shaper private: (%d) dual rate (%d)\n",
+			       capnode.shaper_private_supported,
+			       capnode.shaper_private_dual_rate_supported);
+			printf("\t  - shaper shared max: (%u)\n",
+			       capnode.shaper_shared_n_max);
+			printf("\t  - stats mask %"PRIx64"\n",
+			       capnode.stats_mask);
+
+			ret = rte_tm_node_type_get(i, j, &is_leaf, &error);
+			if (ret)
+				continue;
+
+			if (!is_leaf) {
+#define DSP_CAP_NODE_NON_LEAF(x) printf("\t  -- nonleaf sched max:" \
+" children (%u) sp priorities (%u) " \
+" wfq children per group (%u) wfq groups (%u) wfq weight (%u)\n", \
+x.sched_n_children_max, x.sched_sp_n_priorities_max, \
+x.sched_wfq_n_children_per_group_max, x.sched_wfq_n_groups_max, \
+x.sched_wfq_weight_max)
+				DSP_CAP_NODE_NON_LEAF(capnode.nonleaf);
+			} else {
+#define DSP_CAP_NODE_LEAF(x) printf("\t  -- leaf cman support:" \
+" wred pkt mode (%d) wred byte mode (%d) head drop (%d)" \
+" wred context private (%d) wred context shared (%u)\n", \
+x.cman_wred_packet_mode_supported, x.cman_wred_byte_mode_supported, \
+x.cman_head_drop_supported, x.cman_wred_context_private_supported, \
+x.cman_wred_context_shared_n_max)
+				DSP_CAP_NODE_LEAF(capnode.leaf);
+			}
+		}
+
+		for (j = 0; j < cap.n_levels_max; j++) {
+			ret = rte_tm_level_capabilities_get(i, j,
+				&caplevel, &error);
+			if (ret)
+				continue;
+
+			printf("  - Level %u\n", j);
+			printf("\t  -- node MAX: %u"
+			       " non leaf %u"
+			       " leaf %u\n",
+			       caplevel.n_nodes_max,
+			       caplevel.n_nodes_nonleaf_max,
+			       caplevel.n_nodes_leaf_max);
+			printf("\t  -- indetical:"
+			       " non leaf %u"
+			       " leaf %u\n",
+			       caplevel.non_leaf_nodes_identical,
+			       caplevel.leaf_nodes_identical);
+
+			for (k = 0; k < caplevel.n_nodes_max; k++) {
+				ret = rte_tm_node_type_get(i, k,
+					&is_leaf, &error);
+				if (ret)
+					continue;
+
+				if (!is_leaf) {
+#define DSP_CAP_LVL_NON_LEAF(x) do { \
+printf("\t  - shaper private:" \
+" (%d) dual rate (%d)\n", x.shaper_private_supported, \
+x.shaper_private_dual_rate_supported); \
+printf("\t  - shaper share: (%u)\n", \
+x.shaper_shared_n_max); \
+printf("\t  - non leaf sched MAX:" \
+" children (%u) sp (%u)" \
+" wfq children per group (%u)" \
+" wfq groups (%u) wfq weight (%u)\n", \
+x.sched_n_children_max, x.sched_sp_n_priorities_max, \
+x.sched_wfq_n_children_per_group_max, \
+x.sched_wfq_n_groups_max, x.sched_wfq_weight_max); \
+} while (0)
+					DSP_CAP_LVL_NON_LEAF(caplevel.nonleaf);
+				} else {
+#define DSP_CAP_LVL_LEAF(x) do { \
+printf("\t  - shaper private: (%d) dual rate (%d)\n", \
+x.shaper_private_supported, x.shaper_private_dual_rate_supported); \
+printf("\t - shaper share: (%u)\n", x.shaper_shared_n_max); \
+printf("  -- leaf cman support: wred pkt mode (%d)" \
+" wred byte mode (%d) head drop (%d)" \
+" wred context private (%d) wred context shared (%u)\n", \
+x.cman_wred_packet_mode_supported, x.cman_wred_byte_mode_supported, \
+x.cman_head_drop_supported, x.cman_wred_context_private_supported, \
+x.cman_wred_context_shared_n_max); \
+} while (0)
+
+					DSP_CAP_LVL_LEAF(caplevel.leaf);
+				}
+			}
+		}
+
+		for (j = 0; j < n_leaf_nodes; j++) {
+			struct rte_tm_node_stats stats = {0};
+
+			ret = rte_tm_node_stats_read(i, j,
+				&stats, &cap.stats_mask, 0, &error);
+			if (ret)
+				continue;
+
+			printf("  - STATS for node (%u)\n", j);
+			printf("  -- pkts (%"PRIu64") bytes (%"PRIu64")\n",
+				stats.n_pkts, stats.n_bytes);
+
+			ret = rte_tm_node_type_get(i, j, &is_leaf, &error);
+			if ((ret) | (!is_leaf))
+				continue;
+
+			printf("  -- leaf queued:"
+				" pkts (%"PRIu64")"
+				" bytes (%"PRIu64")\n",
+				stats.leaf.n_pkts_queued,
+				stats.leaf.n_bytes_queued);
+			printf("  - dropped:\n"
+			       "\t  -- GREEN:"
+			       " pkts (%"PRIu64")"
+			       " bytes (%"PRIu64")\n"
+			       "\t  -- YELLOW:"
+			       " pkts (%"PRIu64")"
+			       " bytes (%"PRIu64")\n"
+			       "\t  -- RED:"
+			       " pkts (%"PRIu64")"
+			       " bytes (%"PRIu64")\n",
+			       stats.leaf.n_pkts_dropped[RTE_TM_GREEN],
+			       stats.leaf.n_bytes_dropped[RTE_TM_GREEN],
+			       stats.leaf.n_pkts_dropped[RTE_TM_YELLOW],
+			       stats.leaf.n_bytes_dropped[RTE_TM_YELLOW],
+			       stats.leaf.n_pkts_dropped[RTE_TM_RED],
+			       stats.leaf.n_bytes_dropped[RTE_TM_RED]);
+		}
+	}
+
+	STATS_BDR_STR(50, "");
 }
 
 static void
-- 
2.17.1