net/failsafe: improve Rx sub-devices iteration

Connecting the sub-devices each other by cyclic linked list can help to
iterate over them by Rx burst functions because there is no need to
check the sub-devices ring wraparound.

Create the aforementioned linked-list and change the Rx burst functions
iteration accordingly.

Signed-off-by: Matan Azrad <matan@mellanox.com>
Acked-by: Gaetan Rivet <gaetan.rivet@6wind.com>

diff --git a/drivers/net/failsafe/failsafe.c b/drivers/net/failsafe/failsafe.c
index 8336510f00e192687982fcbbf30b6083dc61f78a..b7673526102c39b387ce3a6a428cf5cb9e9ed196 100644 (file)
--- a/drivers/net/failsafe/failsafe.c
+++ b/drivers/net/failsafe/failsafe.c
@@ -55,6 +55,7 @@ fs_sub_device_alloc(struct rte_eth_dev *dev,
 {
        uint8_t nb_subs;
        int ret;
+       int i;
 
        ret = failsafe_args_count_subdevice(dev, params);
        if (ret)
@@ -72,6 +73,10 @@ fs_sub_device_alloc(struct rte_eth_dev *dev,
                ERROR("Could not allocate sub_devices");
                return -ENOMEM;
        }
+       /* Initiate static sub devices linked list. */
+       for (i = 1; i < nb_subs; i++)
+               PRIV(dev)->subs[i - 1].next = PRIV(dev)->subs + i;
+       PRIV(dev)->subs[i - 1].next = PRIV(dev)->subs;
        return 0;
 }
 

diff --git a/drivers/net/failsafe/failsafe_ops.c b/drivers/net/failsafe/failsafe_ops.c
index e16a590360a4e46e138b19056c755ee485f1ae66..fe957ad7f936baa8cb27f58d21057f5afb657dd1 100644 (file)
--- a/drivers/net/failsafe/failsafe_ops.c
+++ b/drivers/net/failsafe/failsafe_ops.c
@@ -294,6 +294,7 @@ fs_rx_queue_setup(struct rte_eth_dev *dev,
        rxq->info.conf = *rx_conf;
        rxq->info.nb_desc = nb_rx_desc;
        rxq->priv = PRIV(dev);
+       rxq->sdev = PRIV(dev)->subs;
        dev->data->rx_queues[rx_queue_id] = rxq;
        FOREACH_SUBDEV_STATE(sdev, i, dev, DEV_ACTIVE) {
                ret = rte_eth_rx_queue_setup(PORT_ID(sdev),

diff --git a/drivers/net/failsafe/failsafe_private.h b/drivers/net/failsafe/failsafe_private.h
index 4196ece5c0d95b9d9c9035cd10e02c97eab9d1e0..54b5b916935d8655a70dd4e719c68d8cc2bb067d 100644 (file)
--- a/drivers/net/failsafe/failsafe_private.h
+++ b/drivers/net/failsafe/failsafe_private.h
@@ -62,8 +62,8 @@
 struct rxq {
        struct fs_priv *priv;
        uint16_t qid;
-       /* id of last sub_device polled */
-       uint8_t last_polled;
+       /* next sub_device to poll */
+       struct sub_device *sdev;
        unsigned int socket_id;
        struct rte_eth_rxq_info info;
        rte_atomic64_t refcnt[];
@@ -100,6 +100,7 @@ struct fs_stats {
 
 struct sub_device {
        /* Exhaustive DPDK device description */
+       struct sub_device *next;
        struct rte_devargs devargs;
        struct rte_bus *bus;
        struct rte_device *dev;

diff --git a/drivers/net/failsafe/failsafe_rxtx.c b/drivers/net/failsafe/failsafe_rxtx.c
index 178294c2e321062628b4d4001f2422f9c3916367..0ebf06a6f4421afd597c95ef6ce32302b63e70ff 100644 (file)
--- a/drivers/net/failsafe/failsafe_rxtx.c
+++ b/drivers/net/failsafe/failsafe_rxtx.c
@@ -94,36 +94,27 @@ failsafe_rx_burst(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];
-               if (fs_rx_unsafe(sdev))
+       sdev = rxq->sdev;
+       do {
+               if (fs_rx_unsafe(sdev)) {
+                       nb_rx = 0;
                        continue;
+               }
                sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
                FS_ATOMIC_P(rxq->refcnt[sdev->sid]);
                nb_rx = ETH(sdev)->
                        rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
                FS_ATOMIC_V(rxq->refcnt[sdev->sid]);
-               if (nb_rx) {
-                       rxq->last_polled = i;
-                       return nb_rx;
-               }
-       }
-       return 0;
+               sdev = sdev->next;
+       } while (nb_rx == 0 && sdev != rxq->sdev);
+       rxq->sdev = sdev;
+       return nb_rx;
 }
 
 uint16_t
@@ -131,35 +122,24 @@ 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];
+       sdev = rxq->sdev;
+       do {
                RTE_ASSERT(!fs_rx_unsafe(sdev));
                sub_rxq = ETH(sdev)->data->rx_queues[rxq->qid];
                FS_ATOMIC_P(rxq->refcnt[sdev->sid]);
                nb_rx = ETH(sdev)->
                        rx_pkt_burst(sub_rxq, rx_pkts, nb_pkts);
                FS_ATOMIC_V(rxq->refcnt[sdev->sid]);
-               if (nb_rx) {
-                       rxq->last_polled = i;
-                       return nb_rx;
-               }
-       }
-       return 0;
+               sdev = sdev->next;
+       } while (nb_rx == 0 && sdev != rxq->sdev);
+       rxq->sdev = sdev;
+       return nb_rx;
 }
 
 uint16_t