net/failsafe: add fast burst functions

Signed-off-by: Gaetan Rivet <gaetan.rivet@6wind.com>
Acked-by: Olga Shern <olgas@mellanox.com>

diff --git a/drivers/net/failsafe/failsafe_private.h b/drivers/net/failsafe/failsafe_private.h
index 82d969d..aac4754 100644 (file)
--- a/drivers/net/failsafe/failsafe_private.h
+++ b/drivers/net/failsafe/failsafe_private.h
@@ -141,11 +141,18 @@ int failsafe_hotplug_alarm_cancel(struct rte_eth_dev *dev);
 
 /* RX / TX */
 
+void set_burst_fn(struct rte_eth_dev *dev, int force_safe);
+
 uint16_t failsafe_rx_burst(void *rxq,
                struct rte_mbuf **rx_pkts, uint16_t nb_pkts);
 uint16_t failsafe_tx_burst(void *txq,
                struct rte_mbuf **tx_pkts, uint16_t nb_pkts);
 
+uint16_t failsafe_rx_burst_fast(void *rxq,
+               struct rte_mbuf **rx_pkts, uint16_t nb_pkts);
+uint16_t failsafe_tx_burst_fast(void *txq,
+               struct rte_mbuf **tx_pkts, uint16_t nb_pkts);
+
 /* ARGS */
 
 int failsafe_args_parse(struct rte_eth_dev *dev, const char *params);
@@ -282,6 +289,7 @@ fs_switch_dev(struct rte_eth_dev *dev)
        } else {
                return;
        }
+       set_burst_fn(dev, 0);
        rte_wmb();
 }
 

diff --git a/drivers/net/failsafe/failsafe_rxtx.c b/drivers/net/failsafe/failsafe_rxtx.c
index a45b4e5..5e380fe 100644 (file)
--- a/drivers/net/failsafe/failsafe_rxtx.c
+++ b/drivers/net/failsafe/failsafe_rxtx.c
@@ -31,16 +31,62 @@
  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <rte_debug.h>
 #include <rte_mbuf.h>
 #include <rte_ethdev.h>
 
 #include "failsafe_private.h"
 
-/*
- * TODO: write fast version,
- * without additional checks, to be activated once
- * everything has been verified to comply.
- */
+static inline int
+fs_rx_unsafe(struct sub_device *sdev)
+{
+       return (ETH(sdev) == NULL) ||
+               (ETH(sdev)->rx_pkt_burst == NULL) ||
+               (sdev->state != DEV_STARTED);
+}
+
+static inline int
+fs_tx_unsafe(struct sub_device *sdev)
+{
+       return (sdev == NULL) ||
+               (ETH(sdev) == NULL) ||
+               (ETH(sdev)->tx_pkt_burst == NULL) ||
+               (sdev->state != DEV_STARTED);
+}
+
+void
+set_burst_fn(struct rte_eth_dev *dev, int force_safe)
+{
+       struct sub_device *sdev;
+       uint8_t i;
+       int need_safe;
+       int safe_set;
+
+       need_safe = force_safe;
+       FOREACH_SUBDEV(sdev, i, dev)
+               need_safe |= fs_rx_unsafe(sdev);
+       safe_set = (dev->rx_pkt_burst == &failsafe_rx_burst);
+       if (need_safe && !safe_set) {
+               DEBUG("Using safe RX bursts%s",
+                     (force_safe ? " (forced)" : ""));
+               dev->rx_pkt_burst = &failsafe_rx_burst;
+       } else if (!need_safe && safe_set) {
+               DEBUG("Using fast RX bursts");
+               dev->rx_pkt_burst = &failsafe_rx_burst_fast;
+       }
+       need_safe = force_safe || fs_tx_unsafe(TX_SUBDEV(dev));
+       safe_set = (dev->tx_pkt_burst == &failsafe_tx_burst);
+       if (need_safe && !safe_set) {
+               DEBUG("Using safe TX bursts%s",
+                     (force_safe ? " (forced)" : ""));
+               dev->tx_pkt_burst = &failsafe_tx_burst;
+       } else if (!need_safe && safe_set) {
+               DEBUG("Using fast TX bursts");
+               dev->tx_pkt_burst = &failsafe_tx_burst_fast;
+       }
+       rte_wmb();
+}
+
 uint16_t
 failsafe_rx_burst(void *queue,
                  struct rte_mbuf **rx_pkts,
@@ -63,11 +109,7 @@ failsafe_rx_burst(void *queue,
                if (i == priv->subs_tail)
                        i = priv->subs_head;
                sdev = &priv->subs[i];
-               if (unlikely(ETH(sdev) == NULL))
-                       continue;
-               if (unlikely(ETH(sdev)->rx_pkt_burst == NULL))
-                       continue;
-               if (unlikely(sdev->state != DEV_STARTED))
+               if (unlikely(fs_rx_unsafe(sdev)))
                        continue;
                sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
                nb_rx = ETH(sdev)->
@@ -80,11 +122,40 @@ failsafe_rx_burst(void *queue,
        return 0;
 }
 
-/*
- * TODO: write fast version,
- * without additional checks, to be activated once
- * everything has been verified to comply.
- */
+uint16_t
+failsafe_rx_burst_fast(void *queue,
+                        struct rte_mbuf **rx_pkts,
+                        uint16_t nb_pkts)
+{
+       struct fs_priv *priv;
+       struct sub_device *sdev;
+       struct rxq *rxq;
+       void *sub_rxq;
+       uint16_t nb_rx;
+       uint8_t nb_polled, nb_subs;
+       uint8_t i;
+
+       rxq = queue;
+       priv = rxq->priv;
+       nb_subs = priv->subs_tail - priv->subs_head;
+       nb_polled = 0;
+       for (i = rxq->last_polled; nb_polled < nb_subs; nb_polled++) {
+               i++;
+               if (i == priv->subs_tail)
+                       i = priv->subs_head;
+               sdev = &priv->subs[i];
+               RTE_ASSERT(!fs_rx_unsafe(sdev));
+               sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
+               nb_rx = ETH(sdev)->
+                       rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
+               if (nb_rx) {
+                       rxq->last_polled = i;
+                       return nb_rx;
+               }
+       }
+       return 0;
+}
+
 uint16_t
 failsafe_tx_burst(void *queue,
                  struct rte_mbuf **tx_pkts,
@@ -96,12 +167,24 @@ failsafe_tx_burst(void *queue,
 
        txq = queue;
        sdev = TX_SUBDEV(txq->priv->dev);
-       if (unlikely(sdev == NULL))
-               return 0;
-       if (unlikely(ETH(sdev) == NULL))
-               return 0;
-       if (unlikely(ETH(sdev)->tx_pkt_burst == NULL))
+       if (unlikely(fs_tx_unsafe(sdev)))
                return 0;
        sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
        return ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
 }
+
+uint16_t
+failsafe_tx_burst_fast(void *queue,
+                        struct rte_mbuf **tx_pkts,
+                        uint16_t nb_pkts)
+{
+       struct sub_device *sdev;
+       struct txq *txq;
+       void *sub_txq;
+
+       txq = queue;
+       sdev = TX_SUBDEV(txq->priv->dev);
+       RTE_ASSERT(!fs_tx_unsafe(sdev));
+       sub_txq = ETH(sdev)->data->tx_queues[txq->qid];
+       return ETH(sdev)->tx_pkt_burst(sub_txq, tx_pkts, nb_pkts);
+}