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>

diff --git a/app/test-pmd/Makefile b/app/test-pmd/Makefile
index 9882c61..4f80442 100644 (file)
--- 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 4bf0720..8c47c01 100644 (file)
--- 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 a7a125b..3a244f5 100644 (file)
--- 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 (file)
index 0000000..98fc037
--- /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],
+                               &eth_hdr->d_addr);
+               ether_addr_copy(&ports[fs->tx_port].eth_addr,
+                               &eth_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 0b376cc..28440e5 100644 (file)
--- 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 834277a..5b4ee6f 100644 (file)
--- 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)
 {