d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net/failsafe: add fast burst functions

Browse Source 
Signed-off-by: Gaetan Rivet <gaetan.rivet@6wind.com>
Acked-by: Olga Shern <olgas@mellanox.com>
This commit is contained in:
Gaetan Rivet 2017-07-18 14:48:19 +02:00 committed by Ferruh Yigit
parent bbc6a53dda
commit 72a57bfd9a
2 changed files with 111 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
drivers/net/failsafe/failsafe_private.h
View File

@ -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();
}

123
drivers/net/failsafe/failsafe_rxtx.c
View File

@ -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);
}