From 57e852429ded674ff27ed03eb3dc6b3d6f66f393 Mon Sep 17 00:00:00 2001
From: Bruce Richardson <bruce.richardson@intel.com>
Date: Wed, 12 Feb 2014 16:09:58 +0000
Subject: [PATCH] app/testpmd: added new macfwd-retry mode
This adds a new forwarding mode to testpmd, whereby it will forward
packets, but on a transmit failure, it will wait a small amount of time
before retrying the transmit again. This mode can be useful in some
cases to set a zero-packet loss rate at the cost of overall throughput,
especially in cases where TX ring size/buffering is constrained, such as
with virtio.
Signed-off-by: Bruce Richardson <bruce.richardson@intel.com>
---
app/test-pmd/Makefile | 1 +
app/test-pmd/cmdline.c | 83 +++++++++++++++---
app/test-pmd/config.c | 3 +
app/test-pmd/macfwd-retry.c | 165 ++++++++++++++++++++++++++++++++++++
app/test-pmd/testpmd.c | 1 +
app/test-pmd/testpmd.h | 4 +
6 files changed, 247 insertions(+), 10 deletions(-)
create mode 100644 app/test-pmd/macfwd-retry.c
diff --git a/app/test-pmd/Makefile b/app/test-pmd/Makefile
index 9882c6145e..4f80442cd4 100644
--- a/app/test-pmd/Makefile
+++ b/app/test-pmd/Makefile
@@ -52,6 +52,7 @@ SRCS-$(CONFIG_RTE_TEST_PMD) += cmdline.c
SRCS-$(CONFIG_RTE_TEST_PMD) += config.c
SRCS-$(CONFIG_RTE_TEST_PMD) += iofwd.c
SRCS-$(CONFIG_RTE_TEST_PMD) += macfwd.c
+SRCS-$(CONFIG_RTE_TEST_PMD) += macfwd-retry.c
SRCS-$(CONFIG_RTE_TEST_PMD) += rxonly.c
SRCS-$(CONFIG_RTE_TEST_PMD) += txonly.c
SRCS-$(CONFIG_RTE_TEST_PMD) += csumonly.c
diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 4bf0720eb2..8c47c01f0b 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -224,6 +224,10 @@ static void cmd_help_long_parsed(void *parsed_result,
"set burst (num)\n"
" Set number of packets per burst.\n\n"
+ "set burst tx delay (microseconds) retry (num)\n"
+ " Set the transmit delay time and number of retries"
+ " in mac_retry forwarding mode.\n\n"
+
"set txpkts (x[,y]*)\n"
" Set the length of each segment of TXONLY"
" packets.\n\n"
@@ -289,13 +293,13 @@ static void cmd_help_long_parsed(void *parsed_result,
" Please check the NIC datasheet for HW limits.\n\n"
#ifdef RTE_LIBRTE_IEEE1588
- "set fwd (io|mac|rxonly|txonly|csum|ieee1588)\n"
- " Set IO, MAC, RXONLY, CSUM or TXONLY or ieee1588"
+ "set fwd (io|mac|mac_retry|rxonly|txonly|csum|ieee1588)\n"
+ " Set IO, MAC, MAC_RETRY, RXONLY, CSUM or TXONLY or ieee1588"
" packet forwarding mode.\n\n"
#else
- "set fwd (io|mac|rxonly|txonly|csum)\n"
- " Set IO, MAC, RXONLY, CSUM or TXONLY packet"
+ "set fwd (io|mac|mac_retry|rxonly|txonly|csum)\n"
+ " Set IO, MAC, MAC_RETRY, RXONLY, CSUM or TXONLY packet"
" forwarding mode.\n\n"
#endif
@@ -2683,20 +2687,20 @@ cmdline_parse_token_string_t cmd_setfwd_fwd =
cmdline_parse_token_string_t cmd_setfwd_mode =
TOKEN_STRING_INITIALIZER(struct cmd_set_fwd_mode_result, mode,
#ifdef RTE_LIBRTE_IEEE1588
- "io#mac#rxonly#txonly#csum#ieee1588");
+ "io#mac#mac_retry#rxonly#txonly#csum#ieee1588");
#else
- "io#mac#rxonly#txonly#csum");
+ "io#mac#mac_retry#rxonly#txonly#csum");
#endif
cmdline_parse_inst_t cmd_set_fwd_mode = {
.f = cmd_set_fwd_mode_parsed,
.data = NULL,
#ifdef RTE_LIBRTE_IEEE1588
- .help_str = "set fwd io|mac|rxonly|txonly|csum|ieee1588 - set IO, MAC,"
- " RXONLY, TXONLY, CSUM or IEEE1588 packet forwarding mode",
+ .help_str = "set fwd io|mac|mac_retry|rxonly|txonly|csum|ieee1588 - set IO, MAC,"
+ " MAC_RETRY, RXONLY, TXONLY, CSUM or IEEE1588 packet forwarding mode",
#else
- .help_str = "set fwd io|mac|rxonly|txonly|csum - set IO, MAC,"
- " RXONLY, CSUM or TXONLY packet forwarding mode",
+ .help_str = "set fwd io|mac|mac_retry|rxonly|txonly|csum - set IO, MAC,"
+ " MAC_RETRY, RXONLY, CSUM or TXONLY packet forwarding mode",
#endif
.tokens = {
(void *)&cmd_setfwd_set,
@@ -2706,6 +2710,64 @@ cmdline_parse_inst_t cmd_set_fwd_mode = {
},
};
+/* *** SET BURST TX DELAY TIME RETRY NUMBER *** */
+struct cmd_set_burst_tx_retry_result {
+ cmdline_fixed_string_t set;
+ cmdline_fixed_string_t burst;
+ cmdline_fixed_string_t tx;
+ cmdline_fixed_string_t delay;
+ uint32_t time;
+ cmdline_fixed_string_t retry;
+ uint32_t retry_num;
+};
+
+static void cmd_set_burst_tx_retry_parsed(void *parsed_result,
+ __attribute__((unused)) struct cmdline *cl,
+ __attribute__((unused)) void *data)
+{
+ struct cmd_set_burst_tx_retry_result *res = parsed_result;
+
+ if (!strcmp(res->set, "set") && !strcmp(res->burst, "burst")
+ && !strcmp(res->tx, "tx")) {
+ if (!strcmp(res->delay, "delay"))
+ burst_tx_delay_time = res->time;
+ if (!strcmp(res->retry, "retry"))
+ burst_tx_retry_num = res->retry_num;
+ }
+
+}
+
+cmdline_parse_token_string_t cmd_set_burst_tx_retry_set =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, set, "set");
+cmdline_parse_token_string_t cmd_set_burst_tx_retry_burst =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, burst,
+ "burst");
+cmdline_parse_token_string_t cmd_set_burst_tx_retry_tx =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, tx, "tx");
+cmdline_parse_token_string_t cmd_set_burst_tx_retry_delay =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, delay, "delay");
+cmdline_parse_token_num_t cmd_set_burst_tx_retry_time =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, time, UINT32);
+cmdline_parse_token_string_t cmd_set_burst_tx_retry_retry =
+ TOKEN_STRING_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry, "retry");
+cmdline_parse_token_num_t cmd_set_burst_tx_retry_retry_num =
+ TOKEN_NUM_INITIALIZER(struct cmd_set_burst_tx_retry_result, retry_num, UINT32);
+
+cmdline_parse_inst_t cmd_set_burst_tx_retry = {
+ .f = cmd_set_burst_tx_retry_parsed,
+ .help_str = "set burst tx delay (time_by_useconds) retry (retry_num)",
+ .tokens = {
+ (void *)&cmd_set_burst_tx_retry_set,
+ (void *)&cmd_set_burst_tx_retry_burst,
+ (void *)&cmd_set_burst_tx_retry_tx,
+ (void *)&cmd_set_burst_tx_retry_delay,
+ (void *)&cmd_set_burst_tx_retry_time,
+ (void *)&cmd_set_burst_tx_retry_retry,
+ (void *)&cmd_set_burst_tx_retry_retry_num,
+ NULL,
+ },
+};
+
/* *** SET PROMISC MODE *** */
struct cmd_set_promisc_mode_result {
cmdline_fixed_string_t set;
@@ -4952,6 +5014,7 @@ cmdline_parse_ctx_t main_ctx[] = {
(cmdline_parse_inst_t *)&cmd_set_fwd_list,
(cmdline_parse_inst_t *)&cmd_set_fwd_mask,
(cmdline_parse_inst_t *)&cmd_set_fwd_mode,
+ (cmdline_parse_inst_t *)&cmd_set_burst_tx_retry,
(cmdline_parse_inst_t *)&cmd_set_promisc_mode_one,
(cmdline_parse_inst_t *)&cmd_set_promisc_mode_all,
(cmdline_parse_inst_t *)&cmd_set_allmulti_mode_one,
diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index a7a125b66f..3a244f5473 100644
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -980,6 +980,9 @@ pkt_fwd_config_display(struct fwd_config *cfg)
numa_support == 1 ? "enabled" : "disabled",
mp_anon != 0 ? "enabled" : "disabled");
+ if (strcmp(cfg->fwd_eng->fwd_mode_name, "mac_retry") == 0)
+ printf("TX retry num: %u, delay between TX retries: %uus\n",
+ burst_tx_retry_num, burst_tx_delay_time);
for (lc_id = 0; lc_id < cfg->nb_fwd_lcores; lc_id++) {
printf("Logical Core %u (socket %u) forwards packets on "
"%d streams:",
diff --git a/app/test-pmd/macfwd-retry.c b/app/test-pmd/macfwd-retry.c
new file mode 100644
index 0000000000..98fc037e6e
--- /dev/null
+++ b/app/test-pmd/macfwd-retry.c
@@ -0,0 +1,165 @@
+/*-
+ * BSD LICENSE
+ *
+ * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * * Neither the name of Intel Corporation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <inttypes.h>
+
+#include <sys/queue.h>
+#include <sys/stat.h>
+
+#include <rte_common.h>
+#include <rte_byteorder.h>
+#include <rte_log.h>
+#include <rte_debug.h>
+#include <rte_cycles.h>
+#include <rte_memory.h>
+#include <rte_memcpy.h>
+#include <rte_memzone.h>
+#include <rte_launch.h>
+#include <rte_tailq.h>
+#include <rte_eal.h>
+#include <rte_per_lcore.h>
+#include <rte_lcore.h>
+#include <rte_atomic.h>
+#include <rte_branch_prediction.h>
+#include <rte_ring.h>
+#include <rte_memory.h>
+#include <rte_mempool.h>
+#include <rte_mbuf.h>
+#include <rte_interrupts.h>
+#include <rte_pci.h>
+#include <rte_ether.h>
+#include <rte_ethdev.h>
+#include <rte_ip.h>
+#include <rte_string_fns.h>
+
+#include "testpmd.h"
+
+#define BURST_TX_WAIT_US 10
+#define BURST_TX_RETRIES 5
+
+/*
+ * Global variables that control number of retires and
+ * timeout (in us) between retires.
+ */
+uint32_t burst_tx_delay_time = BURST_TX_WAIT_US;
+uint32_t burst_tx_retry_num = BURST_TX_RETRIES;
+
+/*
+ * Forwarding of packets in MAC mode with a wait and retry on TX to reduce packet loss.
+ * Change the source and the destination Ethernet addressed of packets
+ * before forwarding them.
+ */
+static void
+pkt_burst_mac_retry_forward(struct fwd_stream *fs)
+{
+ struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
+ struct rte_mbuf *mb;
+ struct ether_hdr *eth_hdr;
+ uint32_t retry;
+ uint16_t nb_rx;
+ uint16_t nb_tx;
+ uint16_t i;
+#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
+
+ /*
+ * Receive a burst of packets and forward them.
+ */
+ nb_rx = rte_eth_rx_burst(fs->rx_port, fs->rx_queue, pkts_burst,
+ nb_pkt_per_burst);
+ if (unlikely(nb_rx == 0))
+ return;
+
+#ifdef RTE_TEST_PMD_RECORD_BURST_STATS
+ fs->rx_burst_stats.pkt_burst_spread[nb_rx]++;
+#endif
+ fs->rx_packets += nb_rx;
+ for (i = 0; i < nb_rx; i++) {
+ mb = pkts_burst[i];
+ eth_hdr = (struct ether_hdr *) mb->pkt.data;
+ ether_addr_copy(&peer_eth_addrs[fs->peer_addr],
+ ð_hdr->d_addr);
+ ether_addr_copy(&ports[fs->tx_port].eth_addr,
+ ð_hdr->s_addr);
+ }
+ nb_tx = rte_eth_tx_burst(fs->tx_port, fs->tx_queue, pkts_burst, nb_rx);
+
+ /*
+ * If not all packets have been TX'd then wait and retry.
+ */
+ if (unlikely(nb_tx < nb_rx)) {
+ for (retry = 0; retry < burst_tx_retry_num; retry++) {
+ 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);
+ if (nb_tx == nb_rx)
+ break;
+ }
+ }
+
+ 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
+}
+
+struct fwd_engine mac_retry_fwd_engine = {
+ .fwd_mode_name = "mac_retry",
+ .port_fwd_begin = NULL,
+ .port_fwd_end = NULL,
+ .packet_fwd = pkt_burst_mac_retry_forward,
+};
diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c
index 0b376ccc4d..28440e5a43 100644
--- a/app/test-pmd/testpmd.c
+++ b/app/test-pmd/testpmd.c
@@ -143,6 +143,7 @@ streamid_t nb_fwd_streams; /**< Is equal to (nb_ports * nb_rxq). */
struct fwd_engine * fwd_engines[] = {
&io_fwd_engine,
&mac_fwd_engine,
+ &mac_retry_fwd_engine,
&rx_only_engine,
&tx_only_engine,
&csum_fwd_engine,
diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h
index 834277a611..5b4ee6f929 100644
--- a/app/test-pmd/testpmd.h
+++ b/app/test-pmd/testpmd.h
@@ -198,6 +198,7 @@ struct fwd_engine {
extern struct fwd_engine io_fwd_engine;
extern struct fwd_engine mac_fwd_engine;
+extern struct fwd_engine mac_retry_fwd_engine;
extern struct fwd_engine rx_only_engine;
extern struct fwd_engine tx_only_engine;
extern struct fwd_engine csum_fwd_engine;
@@ -363,6 +364,9 @@ extern struct fwd_stream **fwd_streams;
extern portid_t nb_peer_eth_addrs; /**< Number of peer ethernet addresses. */
extern struct ether_addr peer_eth_addrs[RTE_MAX_ETHPORTS];
+extern uint32_t burst_tx_delay_time; /**< Burst tx delay time(us) for mac-retry. */
+extern uint32_t burst_tx_retry_num; /**< Burst tx retry number for mac-retry. */
+
static inline unsigned int
lcore_num(void)
{
--
2.39.5