[ceph.git] / ceph / src / spdk / dpdk / app / test-pmd / softnicfwd.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2017 Intel Corporation
 */
#include <stdio.h>
#include <sys/stat.h>

#include <rte_cycles.h>
#include <rte_mbuf.h>
#include <rte_malloc.h>
#include <rte_ethdev.h>
#include <rte_flow.h>
#include <rte_meter.h>
#include <rte_eth_softnic.h>
#include <rte_tm.h>

#include "testpmd.h"

#define SUBPORT_NODES_PER_PORT		1
#define PIPE_NODES_PER_SUBPORT		4096
#define TC_NODES_PER_PIPE			4
#define QUEUE_NODES_PER_TC			4

#define NUM_PIPE_NODES						\
	(SUBPORT_NODES_PER_PORT * PIPE_NODES_PER_SUBPORT)

#define NUM_TC_NODES						\
	(NUM_PIPE_NODES * TC_NODES_PER_PIPE)

#define ROOT_NODE_ID				1000000
#define SUBPORT_NODES_START_ID		900000
#define PIPE_NODES_START_ID			800000
#define TC_NODES_START_ID			700000

#define STATS_MASK_DEFAULT					\
	(RTE_TM_STATS_N_PKTS |					\
	RTE_TM_STATS_N_BYTES |					\
	RTE_TM_STATS_N_PKTS_GREEN_DROPPED |			\
	RTE_TM_STATS_N_BYTES_GREEN_DROPPED)

#define STATS_MASK_QUEUE					\
	(STATS_MASK_DEFAULT |					\
	RTE_TM_STATS_N_PKTS_QUEUED)

#define BYTES_IN_MBPS				(1000 * 1000 / 8)
#define TOKEN_BUCKET_SIZE			1000000

/* TM Hierarchy Levels */
enum tm_hierarchy_level {
	TM_NODE_LEVEL_PORT = 0,
	TM_NODE_LEVEL_SUBPORT,
	TM_NODE_LEVEL_PIPE,
	TM_NODE_LEVEL_TC,
	TM_NODE_LEVEL_QUEUE,
	TM_NODE_LEVEL_MAX,
};

struct tm_hierarchy {
	/* TM Nodes */
	uint32_t root_node_id;
	uint32_t subport_node_id[SUBPORT_NODES_PER_PORT];
	uint32_t pipe_node_id[SUBPORT_NODES_PER_PORT][PIPE_NODES_PER_SUBPORT];
	uint32_t tc_node_id[NUM_PIPE_NODES][TC_NODES_PER_PIPE];
	uint32_t queue_node_id[NUM_TC_NODES][QUEUE_NODES_PER_TC];

	/* TM Hierarchy Nodes Shaper Rates */
	uint32_t root_node_shaper_rate;
	uint32_t subport_node_shaper_rate;
	uint32_t pipe_node_shaper_rate;
	uint32_t tc_node_shaper_rate;
	uint32_t tc_node_shared_shaper_rate;

	uint32_t n_shapers;
};

static struct fwd_lcore *softnic_fwd_lcore;
static uint16_t softnic_port_id;
struct fwd_engine softnic_fwd_engine;

/*
 * Softnic packet forward
 */
static void
softnic_fwd(struct fwd_stream *fs)
{
	struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
	uint16_t nb_rx;
	uint16_t nb_tx;
	uint32_t retry;

#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
	uint64_t start_tsc;
	uint64_t end_tsc;
	uint64_t core_cycles;
#endif

#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
	start_tsc = rte_rdtsc();
#endif

	/*  Packets Receive */
	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue,
			pkts_burst, nb_pkt_per_burst);
	fs->rx_packets += nb_rx;

#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
	fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
#endif

	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
			pkts_burst, nb_rx);

	/* Retry if necessary */
	if (unlikely(nb_tx < nb_rx) && fs->retry_enabled) {
		retry = 0;
		while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
			rte_delay_us(burst_tx_delay_time);
			nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
					&pkts_burst[nb_tx], nb_rx - nb_tx);
		}
	}
	fs->tx_packets += nb_tx;

#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
	fs->tx_burst_stats.pkt_burst_spread[nb_tx]++;
#endif

	if (unlikely(nb_tx < nb_rx)) {
		fs->fwd_dropped += (nb_rx - nb_tx);
		do {
			rte_pktmbuf_free(pkts_burst[nb_tx]);
		} while (++nb_tx < nb_rx);
	}
#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
	end_tsc = rte_rdtsc();
	core_cycles = (end_tsc - start_tsc);
	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
#endif
}

static void
softnic_fwd_run(struct fwd_stream *fs)
{
	rte_pmd_softnic_run(softnic_port_id);
	softnic_fwd(fs);
}

/**
 * Softnic init
 */
static int
softnic_begin(void *arg __rte_unused)
{
	for (;;) {
		if (!softnic_fwd_lcore->stopped)
			break;
	}

	do {
		/* Run softnic */
		rte_pmd_softnic_run(softnic_port_id);
	} while (!softnic_fwd_lcore->stopped);

	return 0;
}

static int
set_tm_hiearchy_nodes_shaper_rate(portid_t port_id,
	struct tm_hierarchy *h)
{
	struct rte_eth_link link_params;
	uint64_t tm_port_rate;
	int ret;

	memset(&link_params, 0, sizeof(link_params));

	ret = rte_eth_link_get(port_id, &link_params);
	if (ret < 0) {
		printf("Error during getting device (port %u) link info: %s\n",
			port_id, rte_strerror(-ret));
		return ret;
	}
	tm_port_rate = (uint64_t)ETH_SPEED_NUM_10G * BYTES_IN_MBPS;

	/* Set tm hierarchy shapers rate */
	h->root_node_shaper_rate = tm_port_rate;
	h->subport_node_shaper_rate =
		tm_port_rate / SUBPORT_NODES_PER_PORT;
	h->pipe_node_shaper_rate
		= h->subport_node_shaper_rate / PIPE_NODES_PER_SUBPORT;
	h->tc_node_shaper_rate = h->pipe_node_shaper_rate;
	h->tc_node_shared_shaper_rate = h->subport_node_shaper_rate;

	return 0;
}

static int
softport_tm_root_node_add(portid_t port_id, struct tm_hierarchy *h,
	struct rte_tm_error *error)
{
	struct rte_tm_node_params rnp;
	struct rte_tm_shaper_params rsp;
	uint32_t priority, weight, level_id, shaper_profile_id;

	memset(&rsp, 0, sizeof(struct rte_tm_shaper_params));
	memset(&rnp, 0, sizeof(struct rte_tm_node_params));

	/* Shaper profile Parameters */
	rsp.peak.rate = h->root_node_shaper_rate;
	rsp.peak.size = TOKEN_BUCKET_SIZE;
	rsp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
	shaper_profile_id = 0;

	if (rte_tm_shaper_profile_add(port_id, shaper_profile_id,
		&rsp, error)) {
		printf("%s ERROR(%d)-%s!(shaper_id %u)\n ",
			__func__, error->type, error->message,
			shaper_profile_id);
		return -1;
	}

	/* Root Node Parameters */
	h->root_node_id = ROOT_NODE_ID;
	weight = 1;
	priority = 0;
	level_id = TM_NODE_LEVEL_PORT;
	rnp.shaper_profile_id = shaper_profile_id;
	rnp.nonleaf.n_sp_priorities = 1;
	rnp.stats_mask = STATS_MASK_DEFAULT;

	/* Add Node to TM Hierarchy */
	if (rte_tm_node_add(port_id, h->root_node_id, RTE_TM_NODE_ID_NULL,
		priority, weight, level_id, &rnp, error)) {
		printf("%s ERROR(%d)-%s!(node_id %u, parent_id %u, level %u)\n",
			__func__, error->type, error->message,
			h->root_node_id, RTE_TM_NODE_ID_NULL,
			level_id);
		return -1;
	}
	/* Update */
	h->n_shapers++;

	printf("  Root node added (Start id %u, Count %u, level %u)\n",
		h->root_node_id, 1, level_id);

	return 0;
}

static int
softport_tm_subport_node_add(portid_t port_id,
	struct tm_hierarchy *h,
	struct rte_tm_error *error)
{
	uint32_t subport_parent_node_id, subport_node_id = 0;
	struct rte_tm_node_params snp;
	struct rte_tm_shaper_params ssp;
	uint32_t priority, weight, level_id, shaper_profile_id;
	uint32_t i;

	memset(&ssp, 0, sizeof(struct rte_tm_shaper_params));
	memset(&snp, 0, sizeof(struct rte_tm_node_params));

	shaper_profile_id = h->n_shapers;

	/* Add Shaper Profile to TM Hierarchy */
	for (i = 0; i < SUBPORT_NODES_PER_PORT; i++) {
		ssp.peak.rate = h->subport_node_shaper_rate;
		ssp.peak.size = TOKEN_BUCKET_SIZE;
		ssp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;

		if (rte_tm_shaper_profile_add(port_id, shaper_profile_id,
			&ssp, error)) {
			printf("%s ERROR(%d)-%s!(shaper_id %u)\n ",
				__func__, error->type, error->message,
				shaper_profile_id);
			return -1;
		}

		/* Node Parameters */
		h->subport_node_id[i] = SUBPORT_NODES_START_ID + i;
		subport_parent_node_id = h->root_node_id;
		weight = 1;
		priority = 0;
		level_id = TM_NODE_LEVEL_SUBPORT;
		snp.shaper_profile_id = shaper_profile_id;
		snp.nonleaf.n_sp_priorities = 1;
		snp.stats_mask = STATS_MASK_DEFAULT;

		/* Add Node to TM Hiearchy */
		if (rte_tm_node_add(port_id,
				h->subport_node_id[i],
				subport_parent_node_id,
				priority, weight,
				level_id,
				&snp,
				error)) {
			printf("%s ERROR(%d)-%s!(node %u,parent %u,level %u)\n",
					__func__,
					error->type,
					error->message,
					h->subport_node_id[i],
					subport_parent_node_id,
					level_id);
			return -1;
		}
		shaper_profile_id++;
		subport_node_id++;
	}
	/* Update */
	h->n_shapers = shaper_profile_id;

	printf("  Subport nodes added (Start id %u, Count %u, level %u)\n",
		h->subport_node_id[0], SUBPORT_NODES_PER_PORT, level_id);

	return 0;
}

static int
softport_tm_pipe_node_add(portid_t port_id,
	struct tm_hierarchy *h,
	struct rte_tm_error *error)
{
	uint32_t pipe_parent_node_id;
	struct rte_tm_node_params pnp;
	struct rte_tm_shaper_params psp;
	uint32_t priority, weight, level_id, shaper_profile_id;
	uint32_t i, j;

	memset(&psp, 0, sizeof(struct rte_tm_shaper_params));
	memset(&pnp, 0, sizeof(struct rte_tm_node_params));

	shaper_profile_id = h->n_shapers;

	/* Shaper Profile Parameters */
	psp.peak.rate = h->pipe_node_shaper_rate;
	psp.peak.size = TOKEN_BUCKET_SIZE;
	psp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;

	/* Pipe Node Parameters */
	weight = 1;
	priority = 0;
	level_id = TM_NODE_LEVEL_PIPE;
	pnp.nonleaf.n_sp_priorities = 4;
	pnp.stats_mask = STATS_MASK_DEFAULT;

	/* Add Shaper Profiles and Nodes to TM Hierarchy */
	for (i = 0; i < SUBPORT_NODES_PER_PORT; i++) {
		for (j = 0; j < PIPE_NODES_PER_SUBPORT; j++) {
			if (rte_tm_shaper_profile_add(port_id,
				shaper_profile_id, &psp, error)) {
				printf("%s ERROR(%d)-%s!(shaper_id %u)\n ",
					__func__, error->type, error->message,
					shaper_profile_id);
				return -1;
			}
			pnp.shaper_profile_id = shaper_profile_id;
			pipe_parent_node_id = h->subport_node_id[i];
			h->pipe_node_id[i][j] = PIPE_NODES_START_ID +
				(i * PIPE_NODES_PER_SUBPORT) + j;

			if (rte_tm_node_add(port_id,
					h->pipe_node_id[i][j],
					pipe_parent_node_id,
					priority, weight, level_id,
					&pnp,
					error)) {
				printf("%s ERROR(%d)-%s!(node %u,parent %u )\n",
					__func__,
					error->type,
					error->message,
					h->pipe_node_id[i][j],
					pipe_parent_node_id);

				return -1;
			}
			shaper_profile_id++;
		}
	}
	/* Update */
	h->n_shapers = shaper_profile_id;

	printf("  Pipe nodes added (Start id %u, Count %u, level %u)\n",
		h->pipe_node_id[0][0], NUM_PIPE_NODES, level_id);

	return 0;
}

static int
softport_tm_tc_node_add(portid_t port_id,
	struct tm_hierarchy *h,
	struct rte_tm_error *error)
{
	uint32_t tc_parent_node_id;
	struct rte_tm_node_params tnp;
	struct rte_tm_shaper_params tsp, tssp;
	uint32_t shared_shaper_profile_id[TC_NODES_PER_PIPE];
	uint32_t priority, weight, level_id, shaper_profile_id;
	uint32_t pos, n_tc_nodes, i, j, k;

	memset(&tsp, 0, sizeof(struct rte_tm_shaper_params));
	memset(&tssp, 0, sizeof(struct rte_tm_shaper_params));
	memset(&tnp, 0, sizeof(struct rte_tm_node_params));

	shaper_profile_id = h->n_shapers;

	/* Private Shaper Profile (TC) Parameters */
	tsp.peak.rate = h->tc_node_shaper_rate;
	tsp.peak.size = TOKEN_BUCKET_SIZE;
	tsp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;

	/* Shared Shaper Profile (TC) Parameters */
	tssp.peak.rate = h->tc_node_shared_shaper_rate;
	tssp.peak.size = TOKEN_BUCKET_SIZE;
	tssp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;

	/* TC Node Parameters */
	weight = 1;
	level_id = TM_NODE_LEVEL_TC;
	tnp.n_shared_shapers = 1;
	tnp.nonleaf.n_sp_priorities = 1;
	tnp.stats_mask = STATS_MASK_DEFAULT;

	/* Add Shared Shaper Profiles to TM Hierarchy */
	for (i = 0; i < TC_NODES_PER_PIPE; i++) {
		shared_shaper_profile_id[i] = shaper_profile_id;

		if (rte_tm_shaper_profile_add(port_id,
			shared_shaper_profile_id[i], &tssp, error)) {
			printf("%s ERROR(%d)-%s!(Shared shaper profileid %u)\n",
				__func__, error->type, error->message,
				shared_shaper_profile_id[i]);

			return -1;
		}
		if (rte_tm_shared_shaper_add_update(port_id,  i,
			shared_shaper_profile_id[i], error)) {
			printf("%s ERROR(%d)-%s!(Shared shaper id %u)\n",
				__func__, error->type, error->message, i);

			return -1;
		}
		shaper_profile_id++;
	}

	/* Add Shaper Profiles and Nodes to TM Hierarchy */
	n_tc_nodes = 0;
	for (i = 0; i < SUBPORT_NODES_PER_PORT; i++) {
		for (j = 0; j < PIPE_NODES_PER_SUBPORT; j++) {
			for (k = 0; k < TC_NODES_PER_PIPE ; k++) {
				priority = k;
				tc_parent_node_id = h->pipe_node_id[i][j];
				tnp.shared_shaper_id =
					(uint32_t *)calloc(1, sizeof(uint32_t));
				if (tnp.shared_shaper_id == NULL) {
					printf("Shared shaper mem alloc err\n");
					return -1;
				}
				tnp.shared_shaper_id[0] = k;
				pos = j + (i * PIPE_NODES_PER_SUBPORT);
				h->tc_node_id[pos][k] =
					TC_NODES_START_ID + n_tc_nodes;

				if (rte_tm_shaper_profile_add(port_id,
					shaper_profile_id, &tsp, error)) {
					printf("%s ERROR(%d)-%s!(shaper %u)\n",
						__func__, error->type,
						error->message,
						shaper_profile_id);

					free(tnp.shared_shaper_id);
					return -1;
				}
				tnp.shaper_profile_id = shaper_profile_id;
				if (rte_tm_node_add(port_id,
						h->tc_node_id[pos][k],
						tc_parent_node_id,
						priority, weight,
						level_id,
						&tnp, error)) {
					printf("%s ERROR(%d)-%s!(node id %u)\n",
						__func__,
						error->type,
						error->message,
						h->tc_node_id[pos][k]);

					free(tnp.shared_shaper_id);
					return -1;
				}
				shaper_profile_id++;
				n_tc_nodes++;
			}
		}
	}
	/* Update */
	h->n_shapers = shaper_profile_id;

	printf("  TC nodes added (Start id %u, Count %u, level %u)\n",
		h->tc_node_id[0][0], n_tc_nodes, level_id);

	return 0;
}

static int
softport_tm_queue_node_add(portid_t port_id, struct tm_hierarchy *h,
	struct rte_tm_error *error)
{
	uint32_t queue_parent_node_id;
	struct rte_tm_node_params qnp;
	uint32_t priority, weight, level_id, pos;
	uint32_t n_queue_nodes, i, j, k;

	memset(&qnp, 0, sizeof(struct rte_tm_node_params));

	/* Queue Node Parameters */
	priority = 0;
	weight = 1;
	level_id = TM_NODE_LEVEL_QUEUE;
	qnp.shaper_profile_id = RTE_TM_SHAPER_PROFILE_ID_NONE;
	qnp.leaf.cman = RTE_TM_CMAN_TAIL_DROP;
	qnp.stats_mask = STATS_MASK_QUEUE;

	/* Add Queue Nodes to TM Hierarchy */
	n_queue_nodes = 0;
	for (i = 0; i < NUM_PIPE_NODES; i++) {
		for (j = 0; j < TC_NODES_PER_PIPE; j++) {
			queue_parent_node_id = h->tc_node_id[i][j];
			for (k = 0; k < QUEUE_NODES_PER_TC; k++) {
				pos = j + (i * TC_NODES_PER_PIPE);
				h->queue_node_id[pos][k] = n_queue_nodes;
				if (rte_tm_node_add(port_id,
						h->queue_node_id[pos][k],
						queue_parent_node_id,
						priority,
						weight,
						level_id,
						&qnp, error)) {
					printf("%s ERROR(%d)-%s!(node %u)\n",
						__func__,
						error->type,
						error->message,
						h->queue_node_id[pos][k]);

					return -1;
				}
				n_queue_nodes++;
			}
		}
	}
	printf("  Queue nodes added (Start id %u, Count %u, level %u)\n",
		h->queue_node_id[0][0], n_queue_nodes, level_id);

	return 0;
}

static int
softport_tm_hierarchy_specify(portid_t port_id,
	struct rte_tm_error *error)
{

	struct tm_hierarchy h;
	int status;

	memset(&h, 0, sizeof(struct tm_hierarchy));

	/* TM hierarchy shapers rate */
	status = set_tm_hiearchy_nodes_shaper_rate(port_id, &h);
	if (status)
		return status;

	/* Add root node (level 0) */
	status = softport_tm_root_node_add(port_id, &h, error);
	if (status)
		return status;

	/* Add subport node (level 1) */
	status = softport_tm_subport_node_add(port_id, &h, error);
	if (status)
		return status;

	/* Add pipe nodes (level 2) */
	status = softport_tm_pipe_node_add(port_id, &h, error);
	if (status)
		return status;

	/* Add traffic class nodes (level 3) */
	status = softport_tm_tc_node_add(port_id, &h, error);
	if (status)
		return status;

	/* Add queue nodes (level 4) */
	status = softport_tm_queue_node_add(port_id, &h, error);
	if (status)
		return status;

	return 0;
}

/*
 * Softnic TM default configuration
 */
static void
softnic_tm_default_config(portid_t pi)
{
	struct rte_port *port = &ports[pi];
	struct rte_tm_error error;
	int status;

	/* Stop port */
	rte_eth_dev_stop(pi);

	/* TM hierarchy specification */
	status = softport_tm_hierarchy_specify(pi, &error);
	if (status) {
		printf("  TM Hierarchy built error(%d) - %s\n",
			error.type, error.message);
		return;
	}
	printf("\n  TM Hierarchy Specified!\n");

	/* TM hierarchy commit */
	status = rte_tm_hierarchy_commit(pi, 0, &error);
	if (status) {
		printf("  Hierarchy commit error(%d) - %s\n",
			error.type, error.message);
		return;
	}
	printf("  Hierarchy Committed (port %u)!\n", pi);

	/* Start port */
	status = rte_eth_dev_start(pi);
	if (status) {
		printf("\n  Port %u start error!\n", pi);
		return;
	}

	/* Reset the default hierarchy flag */
	port->softport.default_tm_hierarchy_enable = 0;
}

/*
 * Softnic forwarding init
 */
static void
softnic_fwd_begin(portid_t pi)
{
	struct rte_port *port = &ports[pi];
	uint32_t lcore, fwd_core_present = 0, softnic_run_launch = 0;
	int	status;

	softnic_fwd_lcore = port->softport.fwd_lcore_arg[0];
	softnic_port_id = pi;

	/* Launch softnic_run function on lcores */
	for (lcore = 0; lcore < RTE_MAX_LCORE; lcore++) {
		if (!rte_lcore_is_enabled(lcore))
			continue;

		if (lcore == rte_get_master_lcore())
			continue;

		if (fwd_core_present == 0) {
			fwd_core_present++;
			continue;
		}

		status = rte_eal_remote_launch(softnic_begin, NULL, lcore);
		if (status)
			printf("softnic launch on lcore %u failed (%d)\n",
				       lcore, status);

		softnic_run_launch = 1;
	}

	if (!softnic_run_launch)
		softnic_fwd_engine.packet_fwd = softnic_fwd_run;

	/* Softnic TM default configuration */
	if (port->softport.default_tm_hierarchy_enable == 1)
		softnic_tm_default_config(pi);
}

struct fwd_engine softnic_fwd_engine = {
	.fwd_mode_name  = "softnic",
	.port_fwd_begin = softnic_fwd_begin,
	.port_fwd_end   = NULL,
	.packet_fwd     = softnic_fwd,
};
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
	2	* Copyright(c) 2017 Intel Corporation
	3	*/
	4	#include <stdio.h>
	5	#include <sys/stat.h>
	6
	7	#include <rte_cycles.h>
	8	#include <rte_mbuf.h>
	9	#include <rte_malloc.h>
	10	#include <rte_ethdev.h>
	11	#include <rte_flow.h>
	12	#include <rte_meter.h>
	13	#include <rte_eth_softnic.h>
	14	#include <rte_tm.h>
	15
	16	#include "testpmd.h"
	17
	18	#define SUBPORT_NODES_PER_PORT 1
	19	#define PIPE_NODES_PER_SUBPORT 4096
	20	#define TC_NODES_PER_PIPE 4
	21	#define QUEUE_NODES_PER_TC 4
	22
	23	#define NUM_PIPE_NODES \
	24	(SUBPORT_NODES_PER_PORT * PIPE_NODES_PER_SUBPORT)
	25
	26	#define NUM_TC_NODES \
	27	(NUM_PIPE_NODES * TC_NODES_PER_PIPE)
	28
	29	#define ROOT_NODE_ID 1000000
	30	#define SUBPORT_NODES_START_ID 900000
	31	#define PIPE_NODES_START_ID 800000
	32	#define TC_NODES_START_ID 700000
	33
	34	#define STATS_MASK_DEFAULT \
	35	(RTE_TM_STATS_N_PKTS \| \
	36	RTE_TM_STATS_N_BYTES \| \
	37	RTE_TM_STATS_N_PKTS_GREEN_DROPPED \| \
	38	RTE_TM_STATS_N_BYTES_GREEN_DROPPED)
	39
	40	#define STATS_MASK_QUEUE \
	41	(STATS_MASK_DEFAULT \| \
	42	RTE_TM_STATS_N_PKTS_QUEUED)
	43
	44	#define BYTES_IN_MBPS (1000 * 1000 / 8)
	45	#define TOKEN_BUCKET_SIZE 1000000
	46
	47	/* TM Hierarchy Levels */
	48	enum tm_hierarchy_level {
	49	TM_NODE_LEVEL_PORT = 0,
	50	TM_NODE_LEVEL_SUBPORT,
	51	TM_NODE_LEVEL_PIPE,
	52	TM_NODE_LEVEL_TC,
	53	TM_NODE_LEVEL_QUEUE,
	54	TM_NODE_LEVEL_MAX,
	55	};
	56
	57	struct tm_hierarchy {
	58	/* TM Nodes */
	59	uint32_t root_node_id;
	60	uint32_t subport_node_id[SUBPORT_NODES_PER_PORT];
	61	uint32_t pipe_node_id[SUBPORT_NODES_PER_PORT][PIPE_NODES_PER_SUBPORT];
	62	uint32_t tc_node_id[NUM_PIPE_NODES][TC_NODES_PER_PIPE];
	63	uint32_t queue_node_id[NUM_TC_NODES][QUEUE_NODES_PER_TC];
	64
65	/* TM Hierarchy Nodes Shaper Rates */
66	uint32_t root_node_shaper_rate;
67	uint32_t subport_node_shaper_rate;
68	uint32_t pipe_node_shaper_rate;
69	uint32_t tc_node_shaper_rate;
70	uint32_t tc_node_shared_shaper_rate;
71
72	uint32_t n_shapers;
73	};
74
75	static struct fwd_lcore *softnic_fwd_lcore;
76	static uint16_t softnic_port_id;
77	struct fwd_engine softnic_fwd_engine;
78
79	/*
80	* Softnic packet forward
81	*/
82	static void
83	softnic_fwd(struct fwd_stream *fs)
84	{
85	struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
86	uint16_t nb_rx;
87	uint16_t nb_tx;
88	uint32_t retry;
89
90	#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
91	uint64_t start_tsc;
92	uint64_t end_tsc;
93	uint64_t core_cycles;
94	#endif
95
96	#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
97	start_tsc = rte_rdtsc();
98	#endif
99
100	/* Packets Receive */
101	nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue,
102	pkts_burst, nb_pkt_per_burst);
103	fs->rx_packets += nb_rx;
104
105	#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
106	fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
107	#endif
108
109	nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
110	pkts_burst, nb_rx);
111
112	/* Retry if necessary */
113	if (unlikely(nb_tx < nb_rx) && fs->retry_enabled) {
114	retry = 0;
115	while (nb_tx < nb_rx && retry++ < burst_tx_retry_num) {
116	rte_delay_us(burst_tx_delay_time);
117	nb_tx += rte_eth_tx_burst(fs->tx_port, fs->tx_queue,
118	&pkts_burst[nb_tx], nb_rx - nb_tx);
119	}
120	}
121	fs->tx_packets += nb_tx;
122
123	#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
124	fs->tx_burst_stats.pkt_burst_spread[nb_tx]++;
125	#endif
126
127	if (unlikely(nb_tx < nb_rx)) {
128	fs->fwd_dropped += (nb_rx - nb_tx);
129	do {
130	rte_pktmbuf_free(pkts_burst[nb_tx]);
131	} while (++nb_tx < nb_rx);
132	}
133	#ifdef RTE_TEST_PMD_RECORD_CORE_CYCLES
134	end_tsc = rte_rdtsc();
135	core_cycles = (end_tsc - start_tsc);
136	fs->core_cycles = (uint64_t) (fs->core_cycles + core_cycles);
137	#endif
138	}
139
140	static void
141	softnic_fwd_run(struct fwd_stream *fs)
142	{
143	rte_pmd_softnic_run(softnic_port_id);
144	softnic_fwd(fs);
145	}
146
147	/**
148	* Softnic init
149	*/
150	static int
151	softnic_begin(void *arg __rte_unused)
152	{
153	for (;;) {
154	if (!softnic_fwd_lcore->stopped)
155	break;
156	}
157
158	do {
159	/* Run softnic */
160	rte_pmd_softnic_run(softnic_port_id);
161	} while (!softnic_fwd_lcore->stopped);
162
163	return 0;
164	}
165
f67539c2	166	static int
11fdf7f2 TL	167	set_tm_hiearchy_nodes_shaper_rate(portid_t port_id,
	168	struct tm_hierarchy *h)
	169	{
	170	struct rte_eth_link link_params;
	171	uint64_t tm_port_rate;
f67539c2	172	int ret;
11fdf7f2 TL	173
	174	memset(&link_params, 0, sizeof(link_params));
	175
f67539c2 TL	176	ret = rte_eth_link_get(port_id, &link_params);
	177	if (ret < 0) {
	178	printf("Error during getting device (port %u) link info: %s\n",
	179	port_id, rte_strerror(-ret));
	180	return ret;
	181	}
11fdf7f2 TL	182	tm_port_rate = (uint64_t)ETH_SPEED_NUM_10G * BYTES_IN_MBPS;
	183
	184	/* Set tm hierarchy shapers rate */
	185	h->root_node_shaper_rate = tm_port_rate;
	186	h->subport_node_shaper_rate =
	187	tm_port_rate / SUBPORT_NODES_PER_PORT;
	188	h->pipe_node_shaper_rate
	189	= h->subport_node_shaper_rate / PIPE_NODES_PER_SUBPORT;
	190	h->tc_node_shaper_rate = h->pipe_node_shaper_rate;
	191	h->tc_node_shared_shaper_rate = h->subport_node_shaper_rate;
f67539c2 TL	192
f67539c2 TL	193	return 0;
11fdf7f2 TL	194	}
	195
	196	static int
	197	softport_tm_root_node_add(portid_t port_id, struct tm_hierarchy *h,
	198	struct rte_tm_error *error)
	199	{
	200	struct rte_tm_node_params rnp;
	201	struct rte_tm_shaper_params rsp;
	202	uint32_t priority, weight, level_id, shaper_profile_id;
	203
	204	memset(&rsp, 0, sizeof(struct rte_tm_shaper_params));
	205	memset(&rnp, 0, sizeof(struct rte_tm_node_params));
	206
	207	/* Shaper profile Parameters */
	208	rsp.peak.rate = h->root_node_shaper_rate;
	209	rsp.peak.size = TOKEN_BUCKET_SIZE;
	210	rsp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
	211	shaper_profile_id = 0;
	212
	213	if (rte_tm_shaper_profile_add(port_id, shaper_profile_id,
	214	&rsp, error)) {
	215	printf("%s ERROR(%d)-%s!(shaper_id %u)\n ",
	216	__func__, error->type, error->message,
	217	shaper_profile_id);
	218	return -1;
	219	}
	220
	221	/* Root Node Parameters */
	222	h->root_node_id = ROOT_NODE_ID;
	223	weight = 1;
	224	priority = 0;
	225	level_id = TM_NODE_LEVEL_PORT;
	226	rnp.shaper_profile_id = shaper_profile_id;
	227	rnp.nonleaf.n_sp_priorities = 1;
	228	rnp.stats_mask = STATS_MASK_DEFAULT;
	229
	230	/* Add Node to TM Hierarchy */
	231	if (rte_tm_node_add(port_id, h->root_node_id, RTE_TM_NODE_ID_NULL,
	232	priority, weight, level_id, &rnp, error)) {
	233	printf("%s ERROR(%d)-%s!(node_id %u, parent_id %u, level %u)\n",
	234	__func__, error->type, error->message,
	235	h->root_node_id, RTE_TM_NODE_ID_NULL,
	236	level_id);
	237	return -1;
	238	}
	239	/* Update */
	240	h->n_shapers++;
	241
	242	printf(" Root node added (Start id %u, Count %u, level %u)\n",
	243	h->root_node_id, 1, level_id);
	244
	245	return 0;
	246	}
	247
	248	static int
	249	softport_tm_subport_node_add(portid_t port_id,
	250	struct tm_hierarchy *h,
	251	struct rte_tm_error *error)
	252	{
	253	uint32_t subport_parent_node_id, subport_node_id = 0;
	254	struct rte_tm_node_params snp;
	255	struct rte_tm_shaper_params ssp;
	256	uint32_t priority, weight, level_id, shaper_profile_id;
	257	uint32_t i;
258
259	memset(&ssp, 0, sizeof(struct rte_tm_shaper_params));
260	memset(&snp, 0, sizeof(struct rte_tm_node_params));
261
262	shaper_profile_id = h->n_shapers;
263
264	/* Add Shaper Profile to TM Hierarchy */
265	for (i = 0; i < SUBPORT_NODES_PER_PORT; i++) {
266	ssp.peak.rate = h->subport_node_shaper_rate;
267	ssp.peak.size = TOKEN_BUCKET_SIZE;
268	ssp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
269
270	if (rte_tm_shaper_profile_add(port_id, shaper_profile_id,
271	&ssp, error)) {
272	printf("%s ERROR(%d)-%s!(shaper_id %u)\n ",
273	__func__, error->type, error->message,
274	shaper_profile_id);
275	return -1;
276	}
277
278	/* Node Parameters */
279	h->subport_node_id[i] = SUBPORT_NODES_START_ID + i;
280	subport_parent_node_id = h->root_node_id;
281	weight = 1;
282	priority = 0;
283	level_id = TM_NODE_LEVEL_SUBPORT;
284	snp.shaper_profile_id = shaper_profile_id;
285	snp.nonleaf.n_sp_priorities = 1;
286	snp.stats_mask = STATS_MASK_DEFAULT;
287
288	/* Add Node to TM Hiearchy */
289	if (rte_tm_node_add(port_id,
290	h->subport_node_id[i],
291	subport_parent_node_id,
292	priority, weight,
293	level_id,
294	&snp,
295	error)) {
296	printf("%s ERROR(%d)-%s!(node %u,parent %u,level %u)\n",
297	__func__,
298	error->type,
299	error->message,
300	h->subport_node_id[i],
301	subport_parent_node_id,
302	level_id);
303	return -1;
304	}
305	shaper_profile_id++;
306	subport_node_id++;
307	}
308	/* Update */
309	h->n_shapers = shaper_profile_id;
310
311	printf(" Subport nodes added (Start id %u, Count %u, level %u)\n",
312	h->subport_node_id[0], SUBPORT_NODES_PER_PORT, level_id);
313
314	return 0;
315	}
316
317	static int
318	softport_tm_pipe_node_add(portid_t port_id,
319	struct tm_hierarchy *h,
320	struct rte_tm_error *error)
321	{
322	uint32_t pipe_parent_node_id;
323	struct rte_tm_node_params pnp;
324	struct rte_tm_shaper_params psp;
325	uint32_t priority, weight, level_id, shaper_profile_id;
326	uint32_t i, j;
327
328	memset(&psp, 0, sizeof(struct rte_tm_shaper_params));
329	memset(&pnp, 0, sizeof(struct rte_tm_node_params));
330
331	shaper_profile_id = h->n_shapers;
332
333	/* Shaper Profile Parameters */
334	psp.peak.rate = h->pipe_node_shaper_rate;
335	psp.peak.size = TOKEN_BUCKET_SIZE;
336	psp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
337
338	/* Pipe Node Parameters */
339	weight = 1;
340	priority = 0;
341	level_id = TM_NODE_LEVEL_PIPE;
342	pnp.nonleaf.n_sp_priorities = 4;
343	pnp.stats_mask = STATS_MASK_DEFAULT;
344
345	/* Add Shaper Profiles and Nodes to TM Hierarchy */
346	for (i = 0; i < SUBPORT_NODES_PER_PORT; i++) {
347	for (j = 0; j < PIPE_NODES_PER_SUBPORT; j++) {
348	if (rte_tm_shaper_profile_add(port_id,
349	shaper_profile_id, &psp, error)) {
350	printf("%s ERROR(%d)-%s!(shaper_id %u)\n ",
351	__func__, error->type, error->message,
352	shaper_profile_id);
353	return -1;
354	}
355	pnp.shaper_profile_id = shaper_profile_id;
356	pipe_parent_node_id = h->subport_node_id[i];
357	h->pipe_node_id[i][j] = PIPE_NODES_START_ID +
358	(i * PIPE_NODES_PER_SUBPORT) + j;
359
360	if (rte_tm_node_add(port_id,
361	h->pipe_node_id[i][j],
362	pipe_parent_node_id,
363	priority, weight, level_id,
364	&pnp,
365	error)) {
366	printf("%s ERROR(%d)-%s!(node %u,parent %u )\n",
367	__func__,
368	error->type,
369	error->message,
370	h->pipe_node_id[i][j],
371	pipe_parent_node_id);
372
373	return -1;
374	}
375	shaper_profile_id++;
376	}
377	}
378	/* Update */
379	h->n_shapers = shaper_profile_id;
380
381	printf(" Pipe nodes added (Start id %u, Count %u, level %u)\n",
382	h->pipe_node_id[0][0], NUM_PIPE_NODES, level_id);
383
384	return 0;
385	}
386
387	static int
388	softport_tm_tc_node_add(portid_t port_id,
389	struct tm_hierarchy *h,
390	struct rte_tm_error *error)
391	{
392	uint32_t tc_parent_node_id;
393	struct rte_tm_node_params tnp;
394	struct rte_tm_shaper_params tsp, tssp;
395	uint32_t shared_shaper_profile_id[TC_NODES_PER_PIPE];
396	uint32_t priority, weight, level_id, shaper_profile_id;
397	uint32_t pos, n_tc_nodes, i, j, k;
398
399	memset(&tsp, 0, sizeof(struct rte_tm_shaper_params));
400	memset(&tssp, 0, sizeof(struct rte_tm_shaper_params));
401	memset(&tnp, 0, sizeof(struct rte_tm_node_params));
402
403	shaper_profile_id = h->n_shapers;
404
405	/* Private Shaper Profile (TC) Parameters */
406	tsp.peak.rate = h->tc_node_shaper_rate;
407	tsp.peak.size = TOKEN_BUCKET_SIZE;
408	tsp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
409
410	/* Shared Shaper Profile (TC) Parameters */
411	tssp.peak.rate = h->tc_node_shared_shaper_rate;
412	tssp.peak.size = TOKEN_BUCKET_SIZE;
413	tssp.pkt_length_adjust = RTE_TM_ETH_FRAMING_OVERHEAD_FCS;
414
415	/* TC Node Parameters */
416	weight = 1;
417	level_id = TM_NODE_LEVEL_TC;
418	tnp.n_shared_shapers = 1;
419	tnp.nonleaf.n_sp_priorities = 1;
420	tnp.stats_mask = STATS_MASK_DEFAULT;
421
422	/* Add Shared Shaper Profiles to TM Hierarchy */
423	for (i = 0; i < TC_NODES_PER_PIPE; i++) {
424	shared_shaper_profile_id[i] = shaper_profile_id;
425
426	if (rte_tm_shaper_profile_add(port_id,
427	shared_shaper_profile_id[i], &tssp, error)) {
428	printf("%s ERROR(%d)-%s!(Shared shaper profileid %u)\n",
429	__func__, error->type, error->message,
430	shared_shaper_profile_id[i]);
431
432	return -1;
433	}
434	if (rte_tm_shared_shaper_add_update(port_id, i,
435	shared_shaper_profile_id[i], error)) {
436	printf("%s ERROR(%d)-%s!(Shared shaper id %u)\n",
437	__func__, error->type, error->message, i);
438
439	return -1;
440	}
441	shaper_profile_id++;
442	}
443
444	/* Add Shaper Profiles and Nodes to TM Hierarchy */
445	n_tc_nodes = 0;
446	for (i = 0; i < SUBPORT_NODES_PER_PORT; i++) {
447	for (j = 0; j < PIPE_NODES_PER_SUBPORT; j++) {
448	for (k = 0; k < TC_NODES_PER_PIPE ; k++) {
449	priority = k;
450	tc_parent_node_id = h->pipe_node_id[i][j];
451	tnp.shared_shaper_id =
452	(uint32_t *)calloc(1, sizeof(uint32_t));
453	if (tnp.shared_shaper_id == NULL) {
454	printf("Shared shaper mem alloc err\n");
455	return -1;
456	}
457	tnp.shared_shaper_id[0] = k;
458	pos = j + (i * PIPE_NODES_PER_SUBPORT);
459	h->tc_node_id[pos][k] =
460	TC_NODES_START_ID + n_tc_nodes;
461
462	if (rte_tm_shaper_profile_add(port_id,
463	shaper_profile_id, &tsp, error)) {
464	printf("%s ERROR(%d)-%s!(shaper %u)\n",
465	__func__, error->type,
466	error->message,
467	shaper_profile_id);
468
9f95a23c	469	free(tnp.shared_shaper_id);
11fdf7f2 TL	470	return -1;
	471	}
	472	tnp.shaper_profile_id = shaper_profile_id;
	473	if (rte_tm_node_add(port_id,
	474	h->tc_node_id[pos][k],
	475	tc_parent_node_id,
	476	priority, weight,
	477	level_id,
	478	&tnp, error)) {
	479	printf("%s ERROR(%d)-%s!(node id %u)\n",
	480	__func__,
	481	error->type,
	482	error->message,
	483	h->tc_node_id[pos][k]);
	484
9f95a23c	485	free(tnp.shared_shaper_id);
11fdf7f2 TL	486	return -1;
	487	}
	488	shaper_profile_id++;
	489	n_tc_nodes++;
	490	}
	491	}
	492	}
	493	/* Update */
	494	h->n_shapers = shaper_profile_id;
	495
	496	printf(" TC nodes added (Start id %u, Count %u, level %u)\n",
	497	h->tc_node_id[0][0], n_tc_nodes, level_id);
	498
	499	return 0;
	500	}
	501
	502	static int
	503	softport_tm_queue_node_add(portid_t port_id, struct tm_hierarchy *h,
	504	struct rte_tm_error *error)
	505	{
	506	uint32_t queue_parent_node_id;
	507	struct rte_tm_node_params qnp;
	508	uint32_t priority, weight, level_id, pos;
	509	uint32_t n_queue_nodes, i, j, k;
	510
	511	memset(&qnp, 0, sizeof(struct rte_tm_node_params));
	512
	513	/* Queue Node Parameters */
	514	priority = 0;
	515	weight = 1;
	516	level_id = TM_NODE_LEVEL_QUEUE;
	517	qnp.shaper_profile_id = RTE_TM_SHAPER_PROFILE_ID_NONE;
	518	qnp.leaf.cman = RTE_TM_CMAN_TAIL_DROP;
	519	qnp.stats_mask = STATS_MASK_QUEUE;
	520
	521	/* Add Queue Nodes to TM Hierarchy */
	522	n_queue_nodes = 0;
	523	for (i = 0; i < NUM_PIPE_NODES; i++) {
	524	for (j = 0; j < TC_NODES_PER_PIPE; j++) {
	525	queue_parent_node_id = h->tc_node_id[i][j];
	526	for (k = 0; k < QUEUE_NODES_PER_TC; k++) {
	527	pos = j + (i * TC_NODES_PER_PIPE);
	528	h->queue_node_id[pos][k] = n_queue_nodes;
	529	if (rte_tm_node_add(port_id,
	530	h->queue_node_id[pos][k],
	531	queue_parent_node_id,
	532	priority,
	533	weight,
	534	level_id,
	535	&qnp, error)) {
	536	printf("%s ERROR(%d)-%s!(node %u)\n",
	537	__func__,
	538	error->type,
	539	error->message,
	540	h->queue_node_id[pos][k]);
	541
	542	return -1;
	543	}
	544	n_queue_nodes++;
	545	}
	546	}
	547	}
	548	printf(" Queue nodes added (Start id %u, Count %u, level %u)\n",
	549	h->queue_node_id[0][0], n_queue_nodes, level_id);
550
551	return 0;
552	}
553
554	static int
555	softport_tm_hierarchy_specify(portid_t port_id,
556	struct rte_tm_error *error)
557	{
558
559	struct tm_hierarchy h;
560	int status;
561
562	memset(&h, 0, sizeof(struct tm_hierarchy));
563
564	/* TM hierarchy shapers rate */
f67539c2 TL	565	status = set_tm_hiearchy_nodes_shaper_rate(port_id, &h);
	566	if (status)
	567	return status;
11fdf7f2 TL	568
	569	/* Add root node (level 0) */
	570	status = softport_tm_root_node_add(port_id, &h, error);
	571	if (status)
	572	return status;
	573
	574	/* Add subport node (level 1) */
	575	status = softport_tm_subport_node_add(port_id, &h, error);
	576	if (status)
	577	return status;
	578
	579	/* Add pipe nodes (level 2) */
	580	status = softport_tm_pipe_node_add(port_id, &h, error);
	581	if (status)
	582	return status;
	583
	584	/* Add traffic class nodes (level 3) */
	585	status = softport_tm_tc_node_add(port_id, &h, error);
	586	if (status)
	587	return status;
	588
	589	/* Add queue nodes (level 4) */
	590	status = softport_tm_queue_node_add(port_id, &h, error);
	591	if (status)
	592	return status;
	593
	594	return 0;
	595	}
	596
	597	/*
	598	* Softnic TM default configuration
	599	*/
	600	static void
	601	softnic_tm_default_config(portid_t pi)
	602	{
	603	struct rte_port *port = &ports[pi];
	604	struct rte_tm_error error;
	605	int status;
	606
	607	/* Stop port */
	608	rte_eth_dev_stop(pi);
	609
	610	/* TM hierarchy specification */
	611	status = softport_tm_hierarchy_specify(pi, &error);
	612	if (status) {
	613	printf(" TM Hierarchy built error(%d) - %s\n",
	614	error.type, error.message);
	615	return;
	616	}
	617	printf("\n TM Hierarchy Specified!\n");
	618
	619	/* TM hierarchy commit */
	620	status = rte_tm_hierarchy_commit(pi, 0, &error);
	621	if (status) {
	622	printf(" Hierarchy commit error(%d) - %s\n",
	623	error.type, error.message);
	624	return;
	625	}
	626	printf(" Hierarchy Committed (port %u)!\n", pi);
	627
	628	/* Start port */
	629	status = rte_eth_dev_start(pi);
	630	if (status) {
	631	printf("\n Port %u start error!\n", pi);
632	return;
633	}
634
635	/* Reset the default hierarchy flag */
636	port->softport.default_tm_hierarchy_enable = 0;
637	}
638
639	/*
640	* Softnic forwarding init
641	*/
642	static void
643	softnic_fwd_begin(portid_t pi)
644	{
645	struct rte_port *port = &ports[pi];
646	uint32_t lcore, fwd_core_present = 0, softnic_run_launch = 0;
647	int status;
648
649	softnic_fwd_lcore = port->softport.fwd_lcore_arg[0];
650	softnic_port_id = pi;
651
652	/* Launch softnic_run function on lcores */
653	for (lcore = 0; lcore < RTE_MAX_LCORE; lcore++) {
654	if (!rte_lcore_is_enabled(lcore))
655	continue;
656
657	if (lcore == rte_get_master_lcore())
658	continue;
659
660	if (fwd_core_present == 0) {
661	fwd_core_present++;
662	continue;
663	}
664
665	status = rte_eal_remote_launch(softnic_begin, NULL, lcore);
666	if (status)
667	printf("softnic launch on lcore %u failed (%d)\n",
668	lcore, status);
669
670	softnic_run_launch = 1;
671	}
672
673	if (!softnic_run_launch)
674	softnic_fwd_engine.packet_fwd = softnic_fwd_run;
675
676	/* Softnic TM default configuration */
677	if (port->softport.default_tm_hierarchy_enable == 1)
678	softnic_tm_default_config(pi);
679	}
680
681	struct fwd_engine softnic_fwd_engine = {
682	.fwd_mode_name = "softnic",
683	.port_fwd_begin = softnic_fwd_begin,
684	.port_fwd_end = NULL,
685	.packet_fwd = softnic_fwd,
686	};