Hi Yongseok,
Some questions/comments below,
On Fri, Aug 25, 2017 at 11:40:23AM -0700, Yongseok Koh wrote:
> New Rx/Tx burst functions are added using NEON vector instructions for ARM
> CPU.
>
> Signed-off-by: Yongseok Koh <ys...@mellanox.com>
> ---
> drivers/net/mlx5/Makefile | 2 +
> drivers/net/mlx5/mlx5_ethdev.c | 4 +-
> drivers/net/mlx5/mlx5_prm.h | 15 +
> drivers/net/mlx5/mlx5_rxq.c | 61 ++
> drivers/net/mlx5/mlx5_rxtx.h | 3 +-
> drivers/net/mlx5/mlx5_rxtx_vec_neon.c | 1464
> +++++++++++++++++++++++++++++++++
> 6 files changed, 1546 insertions(+), 3 deletions(-)
> create mode 100644 drivers/net/mlx5/mlx5_rxtx_vec_neon.c
>
> diff --git a/drivers/net/mlx5/Makefile b/drivers/net/mlx5/Makefile
> index 8736de5d3..616d769f8 100644
> --- a/drivers/net/mlx5/Makefile
> +++ b/drivers/net/mlx5/Makefile
> @@ -41,6 +41,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_MLX5_PMD) += mlx5_txq.c
> SRCS-$(CONFIG_RTE_LIBRTE_MLX5_PMD) += mlx5_rxtx.c
> ifeq ($(CONFIG_RTE_ARCH_X86_64),y)
> SRCS-$(CONFIG_RTE_LIBRTE_MLX5_PMD) += mlx5_rxtx_vec_sse.c
> +else ifeq ($(CONFIG_RTE_ARCH_ARM64),y)
> +SRCS-$(CONFIG_RTE_LIBRTE_MLX5_PMD) += mlx5_rxtx_vec_neon.c
> endif
> SRCS-$(CONFIG_RTE_LIBRTE_MLX5_PMD) += mlx5_trigger.c
> SRCS-$(CONFIG_RTE_LIBRTE_MLX5_PMD) += mlx5_ethdev.c
> diff --git a/drivers/net/mlx5/mlx5_ethdev.c b/drivers/net/mlx5/mlx5_ethdev.c
> index b0eb3cdfc..b387c6fb3 100644
> --- a/drivers/net/mlx5/mlx5_ethdev.c
> +++ b/drivers/net/mlx5/mlx5_ethdev.c
> @@ -1516,7 +1516,7 @@ priv_select_tx_function(struct priv *priv)
> priv->dev->tx_pkt_burst = mlx5_tx_burst_raw_vec;
> else
> priv->dev->tx_pkt_burst = mlx5_tx_burst_vec;
> - DEBUG("selected Enhanced MPW TX vectorized function");
> + WARN("selected Enhanced MPW TX vectorized function");
> } else {
> priv->dev->tx_pkt_burst = mlx5_tx_burst_empw;
> DEBUG("selected Enhanced MPW TX function");
> @@ -1542,7 +1542,7 @@ priv_select_rx_function(struct priv *priv)
> if (priv_check_vec_rx_support(priv) > 0) {
> priv_prep_vec_rx_function(priv);
> priv->dev->rx_pkt_burst = mlx5_rx_burst_vec;
> - DEBUG("selected RX vectorized function");
> + WARN("selected RX vectorized function");
This should remain in DEBUG level.
> } else {
> priv->dev->rx_pkt_burst = mlx5_rx_burst;
> }
> diff --git a/drivers/net/mlx5/mlx5_prm.h b/drivers/net/mlx5/mlx5_prm.h
> index 608072f7e..01e95b466 100644
> --- a/drivers/net/mlx5/mlx5_prm.h
> +++ b/drivers/net/mlx5/mlx5_prm.h
> @@ -224,6 +224,20 @@ struct mlx5_mpw {
> };
>
> /* CQ element structure - should be equal to the cache line size */
> +#if 0
> +struct mlx5_cqe { // 16B
> + uint16_t hdr_type_etc;
> + uint8_t pkt_info;
> + uint8_t sop_drop_qpn; /* flow_tag */
> + uint16_t byte_cnt;
> + uint16_t vlan_info;
> + uint32_t rx_hash_res;
> + uint8_t timestamp;
> + uint8_t wqe_counter;
> + uint8_t rsvd4;
> + uint8_t op_own;
> +};
Seems this structure will never be used due to the #if 0.
> +#else
> struct mlx5_cqe {
> #if (RTE_CACHE_LINE_SIZE == 128)
> uint8_t padding[64];
> @@ -243,6 +257,7 @@ struct mlx5_cqe {
> uint8_t rsvd4;
> uint8_t op_own;
> };
> +#endif
>
> /**
> * Convert a user mark to flow mark.
> diff --git a/drivers/net/mlx5/mlx5_rxq.c b/drivers/net/mlx5/mlx5_rxq.c
> index 74387a797..30654abd3 100644
> --- a/drivers/net/mlx5/mlx5_rxq.c
> +++ b/drivers/net/mlx5/mlx5_rxq.c
> @@ -786,6 +786,61 @@ rxq_cleanup(struct rxq_ctrl *rxq_ctrl)
> memset(rxq_ctrl, 0, sizeof(*rxq_ctrl));
> }
>
> +#ifdef SW_EMULATION
> +#define MLX5_EMUL_MCQE_PER_COMP 64
> +int rxq_cqe_comp_en = 1;
> +/**
> + *
> + * Filling in CQEs to emulate packet arrival
> + *
> + * @param tmpl
> + * Pointer to RX queue control template.
> + */
> + static inline void
> +emulate_rxq_cqe_setup(struct rxq_ctrl *tmpl)
> +{
> + struct rxq *rxq = &tmpl->rxq;
> + const unsigned int cqe_n = 1 << rxq->cqe_n;
> + volatile struct mlx5_cqe *cqe = &(*rxq->cqes)[0];
> + unsigned int i;
> +
> + for (i = 0; i < cqe_n; i++)
> + cqe[i].op_own = MLX5_CQE_INVALIDATE;
> + if (rxq_cqe_comp_en) {
> + volatile struct mlx5_mini_cqe8 *mcqe;
> + unsigned int j;
> +
> + for (i = 0; i < cqe_n;) {
> + if (!(i % MLX5_EMUL_MCQE_PER_COMP)) {
> + /* Fill in title CQE */
> + cqe[i].op_own = 0xc; /* Compressed */
> + /* number of mini CQEs */
> + cqe[i].byte_cnt =
> htonl(MLX5_EMUL_MCQE_PER_COMP);
> + /* Fill in mini CQEs */
> + mcqe = (volatile void *)&cqe[i + 1].pkt_info;
> + for (j = 0; j < MLX5_EMUL_MCQE_PER_COMP; j++) {
> + mcqe[j % 8].byte_cnt =
> + rxq->crc_present ?
> + htonl(64) : htonl(60);
> + if ((j % 8) == 7) {
> + i += 8;
> + mcqe = (volatile void *)
> + &cqe[i].pkt_info;
> + }
> + }
> + } else {
> + ERROR("Error on building compressed CQEs");
> + }
> + }
> + } else {
> + for (i = 0; i < cqe_n; i++) {
> + cqe[i].op_own = 0;
> + cqe[i].byte_cnt = rxq->crc_present ? htonl(64) :
> htonl(60);
> + }
> + }
> +}
> +#endif /* SW_EMULATION */
> +
> /**
> * Initialize RX queue.
> *
> @@ -1064,6 +1119,10 @@ rxq_ctrl_setup(struct rte_eth_dev *dev, struct
> rxq_ctrl *rxq_ctrl,
> (void *)dev, strerror(ret));
> goto error;
> }
> +#ifdef SW_EMULATION
> + rxq_cqe_comp_en = priv->cqe_comp;
> + emulate_rxq_cqe_setup(&tmpl);
> +#endif
> /* Reuse buffers from original queue if possible. */
> if (rxq_ctrl->rxq.elts_n) {
> assert(1 << rxq_ctrl->rxq.elts_n == desc);
> @@ -1092,7 +1151,9 @@ rxq_ctrl_setup(struct rte_eth_dev *dev, struct rxq_ctrl
> *rxq_ctrl,
> /* Update doorbell counter. */
> rxq_ctrl->rxq.rq_ci = desc >> rxq_ctrl->rxq.sges_n;
> rte_wmb();
> +#ifndef SW_EMULATION
> *rxq_ctrl->rxq.rq_db = htonl(rxq_ctrl->rxq.rq_ci);
> +#endif
> DEBUG("%p: rxq updated with %p", (void *)rxq_ctrl, (void *)&tmpl);
> assert(ret == 0);
> return 0;
What is the purpose of this SW_EMULATION?
> diff --git a/drivers/net/mlx5/mlx5_rxtx.h b/drivers/net/mlx5/mlx5_rxtx.h
> index 7de1d1086..6aae00b77 100644
> --- a/drivers/net/mlx5/mlx5_rxtx.h
> +++ b/drivers/net/mlx5/mlx5_rxtx.h
> @@ -602,11 +602,12 @@ mlx5_tx_dbrec(struct txq *txq, volatile struct mlx5_wqe
> *wqe)
> uint64_t *dst = (uint64_t *)((uintptr_t)txq->bf_reg);
> volatile uint64_t *src = ((volatile uint64_t *)wqe);
>
> - rte_wmb();
> + rte_compiler_barrier();
> *txq->qp_db = htonl(txq->wqe_ci);
> /* Ensure ordering between DB record and BF copy. */
> rte_wmb();
> *dst = *src;
> + rte_wmb();
> }
Is this better to have the rte_compiler_barrier() instead of the rte_io_wmb()?
> #endif /* RTE_PMD_MLX5_RXTX_H_ */
> diff --git a/drivers/net/mlx5/mlx5_rxtx_vec_neon.c
> b/drivers/net/mlx5/mlx5_rxtx_vec_neon.c
> new file mode 100644
> index 000000000..e5bce23c2
> --- /dev/null
> +++ b/drivers/net/mlx5/mlx5_rxtx_vec_neon.c
> @@ -0,0 +1,1464 @@
> +/*-
> + * BSD LICENSE
> + *
> + * Copyright 2017 6WIND S.A.
> + * Copyright 2017 Mellanox.
> + *
> + * 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 6WIND S.A. 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 <assert.h>
> +#include <stdint.h>
> +#include <string.h>
> +#include <stdlib.h>
> +#include <arm_neon.h>
> +
> +/* Verbs header. */
> +/* ISO C doesn't support unnamed structs/unions, disabling -pedantic. */
> +#ifdef PEDANTIC
> +#pragma GCC diagnostic ignored "-Wpedantic"
> +#endif
> +#include <infiniband/verbs.h>
> +#include <infiniband/mlx5_hw.h>
> +#include <infiniband/arch.h>
> +#ifdef PEDANTIC
> +#pragma GCC diagnostic error "-Wpedantic"
> +#endif
Should this patch be included before the upstream re-work?
> +
> +#include <rte_mbuf.h>
> +#include <rte_mempool.h>
> +#include <rte_prefetch.h>
> +
> +#include "mlx5.h"
> +#include "mlx5_utils.h"
> +#include "mlx5_rxtx.h"
> +#include "mlx5_autoconf.h"
> +#include "mlx5_defs.h"
> +#include "mlx5_prm.h"
> +
> +#pragma GCC diagnostic ignored "-Wcast-qual"
> +
> +/**
> + * Fill in buffer descriptors in a multi-packet send descriptor.
> + *
> + * @param txq
> + * Pointer to TX queue structure.
> + * @param dseg
> + * Pointer to buffer descriptor to be writen.
> + * @param pkts
> + * Pointer to array of packets to be sent.
> + * @param n
> + * Number of packets to be filled.
> + */
> +static inline void
> +txq_wr_dseg_v(struct txq *txq, uint8_t *dseg,
> + struct rte_mbuf **pkts, unsigned int n)
> +{
> + unsigned int pos;
> + uintptr_t addr;
> + const uint8x16_t dseg_shuf_m = {
> + 3, 2, 1, 0, /* length, bswap32 */
> + 4, 5, 6, 7, /* lkey */
> + 15, 14, 13, 12, /* addr, bswap64 */
> + 11, 10, 9, 8
> + };
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + uint32_t tx_byte = 0;
> +#endif
> +
> + for (pos = 0; pos < n; ++pos, dseg += MLX5_WQE_DWORD_SIZE) {
> + uint8x16_t desc;
> + struct rte_mbuf *pkt = pkts[pos];
> +
> + addr = rte_pktmbuf_mtod(pkt, uintptr_t);
> + desc = vreinterpretq_u8_u32((uint32x4_t) {
> + DATA_LEN(pkt),
> + mlx5_tx_mb2mr(txq, pkt),
> + addr,
> + addr >> 32 });
> + desc = vqtbl1q_u8(desc, dseg_shuf_m);
> + vst1q_u8(dseg, desc);
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + tx_byte += DATA_LEN(pkt);
> +#endif
> + }
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + txq->stats.obytes += tx_byte;
> +#endif
> +}
> +
> +#if 0
#if 0?
It does not help to read an RFC with embed code blocks not even compiled.
>[...]
> +/**
> + * Send burst of packets with Enhanced MPW. If it encounters a multi-seg
> packet,
> + * it returns to make it processed by txq_scatter_v(). All the packets in
> + * the pkts list should be single segment packets having same offload flags.
> + * This must be checked by txq_check_multiseg() and txq_calc_offload().
> + *
> + * @param txq
> + * Pointer to TX queue structure.
> + * @param pkts
> + * Pointer to array of packets to be sent.
> + * @param pkts_n
> + * Number of packets to be sent (<= MLX5_VPMD_TX_MAX_BURST).
> + * @param cs_flags
> + * Checksum offload flags to be written in the descriptor.
> + *
> + * @return
> + * Number of packets successfully transmitted (<= pkts_n).
> + */
> +static inline uint16_t
> +txq_burst_v(struct txq *txq, struct rte_mbuf **pkts, uint16_t pkts_n,
> + uint8_t cs_flags)
> +{
> + struct rte_mbuf **elts;
> + uint16_t elts_head = txq->elts_head;
> + const uint16_t elts_n = 1 << txq->elts_n;
> + const uint16_t elts_m = elts_n - 1;
> + const unsigned int nb_dword_per_wqebb =
> + MLX5_WQE_SIZE / MLX5_WQE_DWORD_SIZE;
> + const unsigned int nb_dword_in_hdr =
> + sizeof(struct mlx5_wqe) / MLX5_WQE_DWORD_SIZE;
> + unsigned int n = 0;
> + unsigned int pos;
> + uint16_t max_elts;
> + uint16_t max_wqe;
> + uint32_t comp_req = 0;
> + const uint16_t wq_n = 1 << txq->wqe_n;
> + const uint16_t wq_mask = wq_n - 1;
> + uint16_t wq_idx = txq->wqe_ci & wq_mask;
> + volatile struct mlx5_wqe64 *wq =
> + &((volatile struct mlx5_wqe64 *)txq->wqes)[wq_idx];
> + volatile struct mlx5_wqe *wqe = (volatile struct mlx5_wqe *)wq;
> + const uint8x16_t ctrl_shuf_m = {
> + 3, 2, 1, 0, /* bswap32 */
> + 7, 6, 5, 4, /* bswap32 */
> + 11, 10, 9, 8, /* bswap32 */
> + 12, 13, 14, 15
> + };
> + uint8x16_t *t_wqe;
> + uint8_t *dseg;
> + uint8x16_t ctrl;
> +
> + /* Make sure all packets can fit into a single WQE. */
> + assert(elts_n > pkts_n);
> + mlx5_tx_complete(txq);
> + max_elts = (elts_n - (elts_head - txq->elts_tail));
> + max_wqe = (1u << txq->wqe_n) - (txq->wqe_ci - txq->wqe_pi);
> + pkts_n = RTE_MIN((unsigned int)RTE_MIN(pkts_n, max_wqe), max_elts);
> + if (unlikely(!pkts_n))
> + return 0;
> + elts = &(*txq->elts)[elts_head & elts_m];
> + /* Loop for available tailroom first. */
> + n = RTE_MIN(elts_n - (elts_head & elts_m), pkts_n);
> + for (pos = 0; pos < (n & -2); pos += 2)
> + vst1q_u64((void *)&elts[pos], vld1q_u64((void *)&pkts[pos]));
> + if (n & 1)
> + elts[pos] = pkts[pos];
> + /* Check if it crosses the end of the queue. */
> + if (unlikely(n < pkts_n)) {
> + elts = &(*txq->elts)[0];
> + for (pos = 0; pos < pkts_n - n; ++pos)
> + elts[pos] = pkts[n + pos];
> + }
> + txq->elts_head += pkts_n;
> + /* Save title WQEBB pointer. */
> + t_wqe = (uint8x16_t *)wqe;
> + dseg = (uint8_t *)(wqe + 1);
> + /* Calculate the number of entries to the end. */
> + n = RTE_MIN(
> + (wq_n - wq_idx) * nb_dword_per_wqebb - nb_dword_in_hdr,
> + pkts_n);
> + /* Fill DSEGs. */
> + txq_wr_dseg_v(txq, dseg, pkts, n);
> + /* Check if it crosses the end of the queue. */
> + if (n < pkts_n) {
> + dseg = (uint8_t *)txq->wqes;
> + txq_wr_dseg_v(txq, dseg, &pkts[n], pkts_n - n);
> + }
> + if (txq->elts_comp + pkts_n < MLX5_TX_COMP_THRESH) {
> + txq->elts_comp += pkts_n;
> + } else {
> + /* Request a completion. */
> + txq->elts_comp = 0;
> + ++txq->cq_pi;
> + comp_req = 8;
> + }
> + /* Fill CTRL in the header. */
> + ctrl = vreinterpretq_u8_u32((uint32x4_t) {
> + MLX5_OPC_MOD_ENHANCED_MPSW << 24 |
> + txq->wqe_ci << 8 | MLX5_OPCODE_ENHANCED_MPSW,
> + txq->qp_num_8s | (pkts_n + 2),
> + comp_req,
> + txq->elts_head });
> + ctrl = vqtbl1q_u8(ctrl, ctrl_shuf_m);
> + vst1q_u8((void *)t_wqe, ctrl);
> + /* Fill ESEG in the header. */
> + vst1q_u8((void *)(t_wqe + 1),
> + (uint8x16_t) { 0, 0, 0, 0,
> + cs_flags, 0, 0, 0,
> + 0, 0, 0, 0,
> + 0, 0, 0, 0 });
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + txq->stats.opackets += pkts_n;
> +#endif
> + txq->wqe_ci += (nb_dword_in_hdr + pkts_n + (nb_dword_per_wqebb - 1)) /
> + nb_dword_per_wqebb;
> + /* Ring QP doorbell. */
> + mlx5_tx_dbrec(txq, wqe);
> + return pkts_n;
> +}
> +
> +/**
> + * DPDK callback for vectorized TX.
> + *
> + * @param dpdk_txq
> + * Generic pointer to TX queue structure.
> + * @param[in] pkts
> + * Packets to transmit.
> + * @param pkts_n
> + * Number of packets in array.
> + *
> + * @return
> + * Number of packets successfully transmitted (<= pkts_n).
> + */
> +uint16_t
> +mlx5_tx_burst_raw_vec(void *dpdk_txq, struct rte_mbuf **pkts,
> + uint16_t pkts_n)
> +{
> + struct txq *txq = (struct txq *)dpdk_txq;
> + uint16_t nb_tx = 0;
> +
> + while (pkts_n > nb_tx) {
> + uint16_t n;
> + uint16_t ret;
> +
> + n = RTE_MIN((uint16_t)(pkts_n - nb_tx), MLX5_VPMD_TX_MAX_BURST);
> + ret = txq_burst_v(txq, &pkts[nb_tx], n, 0);
> + nb_tx += ret;
> + if (!ret)
> + break;
> + }
> + return nb_tx;
> +}
> +
> +#if 0
> +/**
> + * DPDK callback for vectorized TX with multi-seg packets and offload.
> + *
> + * @param dpdk_txq
> + * Generic pointer to TX queue structure.
> + * @param[in] pkts
> + * Packets to transmit.
> + * @param pkts_n
> + * Number of packets in array.
> + *
> + * @return
> + * Number of packets successfully transmitted (<= pkts_n).
> + */
> +uint16_t
> +mlx5_tx_burst_vec(void *dpdk_txq, struct rte_mbuf **pkts, uint16_t pkts_n)
> +{
> + struct txq *txq = (struct txq *)dpdk_txq;
> + uint16_t nb_tx = 0;
> +
> + while (pkts_n > nb_tx) {
> + uint8_t cs_flags = 0;
> + uint16_t n;
> + uint16_t ret;
> +
> + /* Transmit multi-seg packets in the head of pkts list. */
> + if (!(txq->flags & ETH_TXQ_FLAGS_NOMULTSEGS) &&
> + NB_SEGS(pkts[nb_tx]) > 1)
> + nb_tx += txq_scatter_v(txq,
> + &pkts[nb_tx],
> + pkts_n - nb_tx);
> + n = RTE_MIN((uint16_t)(pkts_n - nb_tx), MLX5_VPMD_TX_MAX_BURST);
> + if (!(txq->flags & ETH_TXQ_FLAGS_NOMULTSEGS))
> + n = txq_check_multiseg(&pkts[nb_tx], n);
> + if (!(txq->flags & ETH_TXQ_FLAGS_NOOFFLOADS))
> + n = txq_calc_offload(txq, &pkts[nb_tx], n, &cs_flags);
> + ret = txq_burst_v(txq, &pkts[nb_tx], n, cs_flags);
> + nb_tx += ret;
> + if (!ret)
> + break;
> + }
> + return nb_tx;
> +}
> +#endif
> +
> +/**
> + * Store free buffers to RX SW ring.
> + *
> + * @param rxq
> + * Pointer to RX queue structure.
> + * @param pkts
> + * Pointer to array of packets to be stored.
> + * @param pkts_n
> + * Number of packets to be stored.
> + */
> +static inline void
> +rxq_copy_mbuf_v(struct rxq *rxq, struct rte_mbuf **pkts, uint16_t n)
> +{
> + const uint16_t q_mask = (1 << rxq->elts_n) - 1;
> + struct rte_mbuf **elts = &(*rxq->elts)[rxq->rq_pi & q_mask];
> + unsigned int pos;
> + uint16_t p = n & -2;
> +
> + for (pos = 0; pos < p; pos += 2) {
> + uint64x2_t mbp;
> +
> + mbp = vld1q_u64((void *)&elts[pos]);
> + vst1q_u64((void *)&pkts[pos], mbp);
> + }
> + if (n & 1)
> + pkts[pos] = elts[pos];
> +}
> +
> +/**
> + * Replenish buffers for RX in bulk.
> + *
> + * @param rxq
> + * Pointer to RX queue structure.
> + * @param n
> + * Number of buffers to be replenished.
> + */
> +static inline void
> +rxq_replenish_bulk_mbuf(struct rxq *rxq, uint16_t n)
> +{
> + const uint16_t q_n = 1 << rxq->elts_n;
> + const uint16_t q_mask = q_n - 1;
> + const uint16_t elts_idx = rxq->rq_ci & q_mask;
> + struct rte_mbuf **elts = &(*rxq->elts)[elts_idx];
> + volatile struct mlx5_wqe_data_seg *wq = &(*rxq->wqes)[elts_idx];
> + unsigned int i;
> +
> + assert(n >= MLX5_VPMD_RXQ_RPLNSH_THRESH);
> + assert(n <= (uint16_t)(q_n - (rxq->rq_ci - rxq->rq_pi)));
> + assert(MLX5_VPMD_RXQ_RPLNSH_THRESH > MLX5_VPMD_DESCS_PER_LOOP);
> + /* Not to cross queue end. */
> + n = RTE_MIN(n - MLX5_VPMD_DESCS_PER_LOOP, q_n - elts_idx);
> + if (rte_mempool_get_bulk(rxq->mp, (void *)elts, n) < 0) {
> + rxq->stats.rx_nombuf += n;
> + return;
> + }
> + for (i = 0; i < n; ++i)
> + wq[i].addr = htonll((uintptr_t)elts[i]->buf_addr +
> + RTE_PKTMBUF_HEADROOM);
> + rxq->rq_ci += n;
> +#ifdef SW_EMULATION
> + *rxq->rq_db = 0;
> +#else
> + *rxq->rq_db = htonl(rxq->rq_ci);
> +#endif
> +}
> +
> +/**
> + * Decompress a compressed completion and fill in mbufs in RX SW ring with
> data
> + * extracted from the title completion descriptor.
> + *
> + * @param rxq
> + * Pointer to RX queue structure.
> + * @param cq
> + * Pointer to completion array having a compressed completion at first.
> + * @param elts
> + * Pointer to SW ring to be filled. The first mbuf has to be pre-built from
> + * the title completion descriptor to be copied to the rest of mbufs.
> + */
> +static inline void
> +rxq_cq_decompress_v(struct rxq *rxq,
> + volatile struct mlx5_cqe *cq,
> + struct rte_mbuf **elts)
> +{
> + volatile struct mlx5_mini_cqe8 *mcq = (void *)&(cq + 1)->pkt_info;
> + struct rte_mbuf *t_pkt = elts[0]; /* Title packet is pre-built. */
> + unsigned int pos;
> +#ifdef SW_EMULATION
> + unsigned int inv = 2;
> +#else
> + unsigned int i;
> + unsigned int inv = 0;
> +#endif
> + /* Mask to shuffle from extracted mini CQE to mbuf. */
> + const uint8x16_t mcqe_shuf_m1 = {
> + -1, -1, -1, -1, /* skip packet_type */
> + 7, 6, -1, -1, /* pkt_len, bswap16 */
> + 7, 6, /* data_len, bswap16 */
> + -1, -1, /* skip vlan_tci */
> + 3, 2, 1, 0 /* hash.rss, bswap32 */
> + };
> + const uint8x16_t mcqe_shuf_m2 = {
> + -1, -1, -1, -1, /* skip packet_type */
> + 15, 14, -1, -1, /* pkt_len, bswap16 */
> + 15, 14, /* data_len, bswap16 */
> + -1, -1, /* skip vlan_tci */
> + 11, 10, 9, 8 /* hash.rss, bswap32 */
> + };
> + /* Restore the compressed count. Must be 16 bits. */
> + const uint16_t mcqe_n = t_pkt->data_len +
> + (rxq->crc_present * ETHER_CRC_LEN);
> + const uint64x2_t rearm =
> + vld1q_u64((void *)&t_pkt->rearm_data);
> + const uint32x4_t rxdf_mask = {
> + 0xffffffff, /* packet_type */
> + 0, /* skip pkt_len */
> + 0xffff0000, /* vlan_tci, skip data_len */
> + 0, /* skip hash.rss */
> + };
> + const uint8x16_t rxdf =
> + vandq_u8(vld1q_u8((void *)&t_pkt->rx_descriptor_fields1),
> + vreinterpretq_u8_u32(rxdf_mask));
> + const uint16x8_t crc_adj = {
> + 0, 0,
> + rxq->crc_present * ETHER_CRC_LEN, 0,
> + rxq->crc_present * ETHER_CRC_LEN, 0,
> + 0, 0
> + };
> + const uint32_t flow_tag = t_pkt->hash.fdir.hi;
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + uint32_t rcvd_byte = 0;
> +#endif
> + /* Mask to shuffle byte_cnt to add up stats. Do bswap16 for all. */
> + const uint8x8_t len_shuf_m = {
> + 7, 6, /* 1st mCQE */
> + 15, 14, /* 2nd mCQE */
> + 23, 22, /* 3rd mCQE */
> + 31, 30 /* 4th mCQE */
> + };
> +
> + /* Compile time sanity check for this function. */
> + RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, pkt_len) !=
> + offsetof(struct rte_mbuf, rx_descriptor_fields1) + 4);
> + RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, data_len) !=
> + offsetof(struct rte_mbuf, rx_descriptor_fields1) + 8);
> + RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, hash) !=
> + offsetof(struct rte_mbuf, rx_descriptor_fields1) + 12);
> + /*
> + * A. load mCQEs into a 128bit register.
> + * B. store rearm data to mbuf.
> + * C. combine data from mCQEs with rx_descriptor_fields1.
> + * D. store rx_descriptor_fields1.
> + * E. store flow tag (rte_flow mark).
> + */
> + for (pos = 0; pos < mcqe_n; ) {
> + uint8_t *p = (void *)&mcq[pos % 8];
> + uint8_t *e0 = (void *)&elts[pos]->rearm_data;
> + uint8_t *e1 = (void *)&elts[pos + 1]->rearm_data;
> + uint8_t *e2 = (void *)&elts[pos + 2]->rearm_data;
> + uint8_t *e3 = (void *)&elts[pos + 3]->rearm_data;
> + uint16x4_t byte_cnt;
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + uint16x4_t invalid_mask =
> + vcreate_u16(mcqe_n - pos < MLX5_VPMD_DESCS_PER_LOOP ?
> + -1UL << ((mcqe_n - pos) *
> + sizeof(uint16_t) * 8) : 0);
> +#endif
> +
> + if (!(pos & 0x7) && pos + 8 < mcqe_n)
> + rte_prefetch0((void *)(cq + pos + 8));
> + __asm__ volatile (
> + /* A.1 load mCQEs into a 128bit register. */
> + "ld1 {v16.16b - v17.16b}, [%[mcq]]\n\t"
> + /* B.1 store rearm data to mbuf. */
> + "st1 {%[rearm].2d}, [%[e0]]\n\t"
> + "add %[e0], %[e0], #16\n\t"
> + "st1 {%[rearm].2d}, [%[e1]]\n\t"
> + "add %[e1], %[e1], #16\n\t"
> + /* C.1 combine data from mCQEs with rx_descriptor_fields1. */
> + "tbl v18.16b, {v16.16b}, %[mcqe_shuf_m1].16b\n\t"
> + "tbl v19.16b, {v16.16b}, %[mcqe_shuf_m2].16b\n\t"
> + "sub v18.8h, v18.8h, %[crc_adj].8h\n\t"
> + "sub v19.8h, v19.8h, %[crc_adj].8h\n\t"
> + "orr v18.16b, v18.16b, %[rxdf].16b\n\t"
> + "orr v19.16b, v19.16b, %[rxdf].16b\n\t"
> + /* D.1 store rx_descriptor_fields1. */
> + "st1 {v18.2d}, [%[e0]]\n\t"
> + "st1 {v19.2d}, [%[e1]]\n\t"
> + /* B.1 store rearm data to mbuf. */
> + "st1 {%[rearm].2d}, [%[e2]]\n\t"
> + "add %[e2], %[e2], #16\n\t"
> + "st1 {%[rearm].2d}, [%[e3]]\n\t"
> + "add %[e3], %[e3], #16\n\t"
> + /* C.1 combine data from mCQEs with rx_descriptor_fields1. */
> + "tbl v18.16b, {v17.16b}, %[mcqe_shuf_m1].16b\n\t"
> + "tbl v19.16b, {v17.16b}, %[mcqe_shuf_m2].16b\n\t"
> + "sub v18.8h, v18.8h, %[crc_adj].8h\n\t"
> + "sub v19.8h, v19.8h, %[crc_adj].8h\n\t"
> + "orr v18.16b, v18.16b, %[rxdf].16b\n\t"
> + "orr v19.16b, v19.16b, %[rxdf].16b\n\t"
> + /* D.1 store rx_descriptor_fields1. */
> + "st1 {v18.2d}, [%[e2]]\n\t"
> + "st1 {v19.2d}, [%[e3]]\n\t"
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + "tbl %[byte_cnt].8b, {v16.16b - v17.16b}, %[len_shuf_m].8b\n\t"
> +#endif
> + :[byte_cnt]"=&w"(byte_cnt)
> + :[mcq]"r"(p), [rxdf]"w"(rxdf), [rearm]"w"(rearm),
> + [e3]"r"(e3), [e2]"r"(e2), [e1]"r"(e1), [e0]"r"(e0),
> + [mcqe_shuf_m1]"w"(mcqe_shuf_m1),
> + [mcqe_shuf_m2]"w"(mcqe_shuf_m2),
> + [crc_adj]"w"(crc_adj), [len_shuf_m]"w"(len_shuf_m)
> + :"memory", "v16", "v17", "v18", "v19");
Is not there a better way instead of writing all those assembly instructions,
maybe by using a set of macros?
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + byte_cnt = vbic_u16(byte_cnt, invalid_mask);
> + rcvd_byte += vget_lane_u64(vpaddl_u32(vpaddl_u16(byte_cnt)), 0);
> +#endif
> + if (rxq->mark) {
> + /* E.1 store flow tag (rte_flow mark). */
> + elts[pos]->hash.fdir.hi = flow_tag;
> + elts[pos + 1]->hash.fdir.hi = flow_tag;
> + elts[pos + 2]->hash.fdir.hi = flow_tag;
> + elts[pos + 3]->hash.fdir.hi = flow_tag;
> + }
> + pos += MLX5_VPMD_DESCS_PER_LOOP;
> + /* Move to next CQE and invalidate consumed CQEs. */
> + if (!(pos & 0x7) && pos < mcqe_n) {
> + mcq = (void *)&(cq + pos)->pkt_info;
> +#ifdef SW_EMULATION
> + for (; (inv & 7) != 0; ++inv)
> + cq[inv].op_own = MLX5_CQE_INVALIDATE;
> + ++inv;
> +#else
> + for (i = 0; i < 8; ++i)
> + cq[inv++].op_own = MLX5_CQE_INVALIDATE;
> +#endif
> + }
> + }
> + /* Invalidate the rest of CQEs. */
> + for (; inv < mcqe_n; ++inv)
> + cq[inv].op_own = MLX5_CQE_INVALIDATE;
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + rxq->stats.ipackets += mcqe_n;
> + rxq->stats.ibytes += rcvd_byte;
> +#endif
> + rxq->cq_ci += mcqe_n;
> +}
> +
>[...]
> +
> +/**
> + * Skip error packets.
> + *
> + * @param rxq
> + * Pointer to RX queue structure.
> + * @param[out] pkts
> + * Array to store received packets.
> + * @param pkts_n
> + * Maximum number of packets in array.
> + *
> + * @return
> + * Number of packets successfully received (<= pkts_n).
> + */
> +static uint16_t
> +rxq_handle_pending_error(struct rxq *rxq, struct rte_mbuf **pkts,
> + uint16_t pkts_n)
> +{
> + uint16_t n = 0;
> + unsigned int i;
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + uint32_t err_bytes = 0;
> +#endif
> +
> + for (i = 0; i < pkts_n; ++i) {
> + struct rte_mbuf *pkt = pkts[i];
> +
> + if (pkt->packet_type == RTE_PTYPE_ALL_MASK) {
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + err_bytes += PKT_LEN(pkt);
> +#endif
> + rte_pktmbuf_free_seg(pkt);
> + } else {
> + pkts[n++] = pkt;
> + }
> + }
> + rxq->stats.idropped += (pkts_n - n);
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + /* Correct counters of errored completions. */
> + rxq->stats.ipackets -= (pkts_n - n);
> + rxq->stats.ibytes -= err_bytes;
> +#endif
> + rxq->pending_err = 0;
> + return n;
> +}
> +
> +/**
> + * Receive burst of packets. An errored completion also consumes a mbuf, but
> the
> + * packet_type is set to be RTE_PTYPE_ALL_MASK. Marked mbufs should be freed
> + * before returning to application.
> + *
> + * @param rxq
> + * Pointer to RX queue structure.
> + * @param[out] pkts
> + * Array to store received packets.
> + * @param pkts_n
> + * Maximum number of packets in array.
> + *
> + * @return
> + * Number of packets received including errors (<= pkts_n).
> + */
> +static inline uint16_t
> +rxq_burst_v(struct rxq *rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
> +{
> + const uint16_t q_n = 1 << rxq->cqe_n;
> + const uint16_t q_mask = q_n - 1;
> + volatile struct mlx5_cqe *cq;
> + struct rte_mbuf **elts;
> + unsigned int pos;
> + uint64_t n;
> + uint16_t repl_n;
> + uint64_t comp_idx = MLX5_VPMD_DESCS_PER_LOOP;
> + uint16_t nocmp_n = 0;
> + uint16_t rcvd_pkt = 0;
> + unsigned int cq_idx = rxq->cq_ci & q_mask;
> + unsigned int elts_idx;
> +#ifdef SW_EMULATION
> + const uint16x4_t ownership = vdup_n_u16(1);
> +#else
> + const uint16x4_t ownership = vdup_n_u16(!(rxq->cq_ci & (q_mask + 1)));
> +#endif
> + const uint16x4_t owner_check = vcreate_u16(0x0001000100010001);
> + const uint16x4_t opcode_check = vcreate_u16(0x00f000f000f000f0);
> + const uint16x4_t format_check = vcreate_u16(0x000c000c000c000c);
> + const uint16x4_t resp_err_check = vcreate_u16(0x00e000e000e000e0);
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + uint32_t rcvd_byte = 0;
> +#endif
> + /* Mask to generate 16B length vector. */
> + const uint8x8_t len_shuf_m = {
> + 52, 53, /* 4th CQE */
> + 36, 37, /* 3rd CQE */
> + 20, 21, /* 2nd CQE */
> + 4, 5 /* 1st CQE */
> + };
> + /* Mask to extract 16B data from a 64B CQE. */
> + const uint8x16_t cqe_shuf_m = {
> + 29, 28, /* hdr_type_etc, bswap16 */
> + 0, /* pkt_info */
> + -1, /* null */
> + 47, 46, /* byte_cnt, bswap16 */
> + 31, 30, /* vlan_info, bswap16 */
> + 15, 14, 13, 12, /* rx_hash_res, bswap32 */
> + 57, 58, 59, /* flow_tag */
> + 63 /* op_own */
> + };
> + /* Mask to generate 16B data for mbuf. */
> + const uint8x16_t mb_shuf_m = {
> + 4, 5, -1, -1, /* pkt_len */
> + 4, 5, /* data_len */
> + 6, 7, /* vlan_tci */
> + 8, 9, 10, 11, /* hash.rss */
> + 12, 13, 14, -1 /* hash.fdir.hi */
> + };
> + /* Mask to generate 16B owner vector. */
> + const uint8x8_t owner_shuf_m = {
> + 63, -1, /* 4th CQE */
> + 47, -1, /* 3rd CQE */
> + 31, -1, /* 2nd CQE */
> + 15, -1 /* 1st CQE */
> + };
> + const uint16x8_t crc_adj = {
> + rxq->crc_present * ETHER_CRC_LEN,
> + 0,
> + rxq->crc_present * ETHER_CRC_LEN,
> + 0, 0, 0, 0, 0
> + };
> + const uint32x4_t flow_mark_adj = { 0, 0, 0, rxq->mark * (-1) };
> +
> + /* Compile time sanity check for this function. */
> + RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, pkt_len) !=
> + offsetof(struct rte_mbuf, rx_descriptor_fields1) + 4);
> + RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, data_len) !=
> + offsetof(struct rte_mbuf, rx_descriptor_fields1) + 8);
> +#if (RTE_CACHE_LINE_SIZE == 128)
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, pkt_info) != 64);
> +#else
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, pkt_info) != 0);
> +#endif
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, rx_hash_res) !=
> + offsetof(struct mlx5_cqe, pkt_info) + 12);
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, rsvd1) +
> + sizeof(((struct mlx5_cqe *)0)->rsvd1) !=
> + offsetof(struct mlx5_cqe, hdr_type_etc));
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, vlan_info) !=
> + offsetof(struct mlx5_cqe, hdr_type_etc) + 2);
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, rsvd2) +
> + sizeof(((struct mlx5_cqe *)0)->rsvd2) !=
> + offsetof(struct mlx5_cqe, byte_cnt));
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, sop_drop_qpn) !=
> + RTE_ALIGN(offsetof(struct mlx5_cqe, sop_drop_qpn), 8));
> + RTE_BUILD_BUG_ON(offsetof(struct mlx5_cqe, op_own) !=
> + offsetof(struct mlx5_cqe, sop_drop_qpn) + 7);
> + assert(rxq->sges_n == 0);
> + assert(rxq->cqe_n == rxq->elts_n);
> + cq = &(*rxq->cqes)[cq_idx];
> + rte_prefetch0(cq);
> + rte_prefetch0(cq + 1);
> + rte_prefetch0(cq + 2);
> + rte_prefetch0(cq + 3);
> + pkts_n = RTE_MIN(pkts_n, MLX5_VPMD_RX_MAX_BURST);
> + /*
> + * Order of indexes:
> + * rq_ci >= cq_ci >= rq_pi
> + * Definition of indexes:
> + * rq_ci - cq_ci := # of buffers owned by HW (posted).
> + * cq_ci - rq_pi := # of buffers not returned to app (decompressed).
> + * N - (rq_ci - rq_pi) := # of buffers consumed (to be replenished).
> + */
> + repl_n = q_n - (rxq->rq_ci - rxq->rq_pi);
> + if (repl_n >= MLX5_VPMD_RXQ_RPLNSH_THRESH)
> + rxq_replenish_bulk_mbuf(rxq, repl_n);
> + /* See if there're unreturned mbufs from compressed CQE. */
> + rcvd_pkt = rxq->cq_ci - rxq->rq_pi;
> + if (rcvd_pkt > 0) {
> + rcvd_pkt = RTE_MIN(rcvd_pkt, pkts_n);
> + rxq_copy_mbuf_v(rxq, pkts, rcvd_pkt);
> + rxq->rq_pi += rcvd_pkt;
> + pkts += rcvd_pkt;
> + }
> + elts_idx = rxq->rq_pi & q_mask;
> + elts = &(*rxq->elts)[elts_idx];
> + /* Not to overflow pkts array. */
> + pkts_n = RTE_ALIGN_FLOOR(pkts_n - rcvd_pkt, MLX5_VPMD_DESCS_PER_LOOP);
> + /* Not to cross queue end. */
> + pkts_n = RTE_MIN(pkts_n, q_n - elts_idx);
> + if (!pkts_n)
> + return rcvd_pkt;
> + /* At this point, there shouldn't be any remained packets. */
> + assert(rxq->rq_pi == rxq->cq_ci);
> + /*
> + * A. copy 4 mbuf pointers from elts ring to returing pkts.
> + * B. load 64B CQE and extract necessary fields
> + * Final 16bytes cqes[] extracted from original 64bytes CQE has the
> + * following structure:
> + * struct {
> + * uint16_t hdr_type_etc;
> + * uint8_t pkt_info;
> + * uint8_t rsvd;
> + * uint16_t byte_cnt;
> + * uint16_t vlan_info;
> + * uint32_t rx_has_res;
> + * uint8_t flow_tag[3];
> + * uint8_t op_own;
> + * } c;
> + * C. fill in mbuf.
> + * D. get valid CQEs.
> + * E. find compressed CQE.
> + */
> + for (pos = 0;
> + pos < pkts_n;
> + pos += MLX5_VPMD_DESCS_PER_LOOP) {
> + uint16x4_t op_own;
> + uint16x4_t opcode, owner_mask, invalid_mask;
> + uint16x4_t comp_mask;
> + uint16x4_t mask;
> + uint16x4_t byte_cnt;
> + uint8_t *p0, *p1, *p2, *p3;
> + uint8_t *e0 = (void *)&elts[pos]->pkt_len;
> + uint8_t *e1 = (void *)&elts[pos + 1]->pkt_len;
> + uint8_t *e2 = (void *)&elts[pos + 2]->pkt_len;
> + uint8_t *e3 = (void *)&elts[pos + 3]->pkt_len;
> + void *elts_p = (void *)&elts[pos];
> + void *pkts_p = (void *)&pkts[pos];
> +
> + /* A.0 do not cross the end of CQ. */
> + mask = vcreate_u16(pkts_n - pos < MLX5_VPMD_DESCS_PER_LOOP ?
> + -1UL >> ((pkts_n - pos) *
> + sizeof(uint16_t) * 8) : 0);
> + p0 = (void *)&cq[pos].pkt_info;
> + p1 = p0 + (pkts_n - pos > 1) * sizeof(struct mlx5_cqe);
> + p2 = p1 + (pkts_n - pos > 2) * sizeof(struct mlx5_cqe);
> + p3 = p2 + (pkts_n - pos > 3) * sizeof(struct mlx5_cqe);
> + /* Prefetch next 4 CQEs. */
> + if (pkts_n - pos >= 2 * MLX5_VPMD_DESCS_PER_LOOP) {
> + rte_prefetch0(&cq[pos + MLX5_VPMD_DESCS_PER_LOOP]);
> + rte_prefetch0(&cq[pos + MLX5_VPMD_DESCS_PER_LOOP + 1]);
> + rte_prefetch0(&cq[pos + MLX5_VPMD_DESCS_PER_LOOP + 2]);
> + rte_prefetch0(&cq[pos + MLX5_VPMD_DESCS_PER_LOOP + 3]);
> + }
> + __asm__ volatile (
> + /* B.1 (CQE 3) load a block having op_own. */
> + "ld1 {v19.16b}, [%[p3]]\n\t"
> + "sub %[p3], %[p3], #48\n\t"
> + /* B.2 (CQE 3) load the rest blocks. */
> + "ld1 {v16.16b - v18.16b}, [%[p3]]\n\t"
> + /* B.3 (CQE 3) extract 16B fields. */
> + "tbl v23.16b, {v16.16b - v19.16b}, %[cqe_shuf_m].16b\n\t"
> + /* B.1 (CQE 2) load a block having op_own. */
> + "ld1 {v19.16b}, [%[p2]]\n\t"
> + "sub %[p2], %[p2], #48\n\t"
> + /* C.1 (CQE 3) generate final structure for mbuf. */
> + "tbl v15.16b, {v23.16b}, %[mb_shuf_m].16b\n\t"
> + /* B.2 (CQE 2) load the rest blocks. */
> + "ld1 {v16.16b - v18.16b}, [%[p2]]\n\t"
> + /* B.3 (CQE 2) extract 16B fields. */
> + "tbl v22.16b, {v16.16b - v19.16b}, %[cqe_shuf_m].16b\n\t"
> + /* B.1 (CQE 1) load a block having op_own. */
> + "ld1 {v19.16b}, [%[p1]]\n\t"
> + "sub %[p1], %[p1], #48\n\t"
> + /* C.1 (CQE 2) generate final structure for mbuf. */
> + "tbl v14.16b, {v22.16b}, %[mb_shuf_m].16b\n\t"
> + /* B.2 (CQE 1) load the rest blocks. */
> + "ld1 {v16.16b - v18.16b}, [%[p1]]\n\t"
> + /* B.3 (CQE 1) extract 16B fields. */
> + "tbl v21.16b, {v16.16b - v19.16b}, %[cqe_shuf_m].16b\n\t"
> + /* B.1 (CQE 0) load a block having op_own. */
> + "ld1 {v19.16b}, [%[p0]]\n\t"
> + "sub %[p0], %[p0], #48\n\t"
> + /* C.1 (CQE 1) generate final structure for mbuf. */
> + "tbl v13.16b, {v21.16b}, %[mb_shuf_m].16b\n\t"
> + /* B.2 (CQE 0) load the rest blocks. */
> + "ld1 {v16.16b - v18.16b}, [%[p0]]\n\t"
> + /* B.3 (CQE 0) extract 16B fields. */
> + "tbl v20.16b, {v16.16b - v19.16b}, %[cqe_shuf_m].16b\n\t"
> + /* A.1 load mbuf pointers. */
> + "ld1 {v24.2d - v25.2d}, [%[elts_p]]\n\t"
> + /* D.1 extract op_own byte. */
> + "tbl %[op_own].8b, {v20.16b - v23.16b}, %[owner_shuf_m].8b\n\t"
> + /* C.2 (CQE 3) adjust CRC length. */
> + "sub v15.8h, v15.8h, %[crc_adj].8h\n\t"
> + /* C.3 (CQE 3) adjust flow mark. */
> + "add v15.4s, v15.4s, %[flow_mark_adj].4s\n\t"
> + /* C.4 (CQE 3) fill in mbuf - rx_descriptor_fields1. */
> + "st1 {v15.2d}, [%[e3]]\n\t"
> + /* C.2 (CQE 2) adjust CRC length. */
> + "sub v14.8h, v14.8h, %[crc_adj].8h\n\t"
> + /* C.3 (CQE 2) adjust flow mark. */
> + "add v14.4s, v14.4s, %[flow_mark_adj].4s\n\t"
> + /* C.4 (CQE 2) fill in mbuf - rx_descriptor_fields1. */
> + "st1 {v14.2d}, [%[e2]]\n\t"
> + /* C.1 (CQE 0) generate final structure for mbuf. */
> + "tbl v12.16b, {v20.16b}, %[mb_shuf_m].16b\n\t"
> + /* C.2 (CQE 1) adjust CRC length. */
> + "sub v13.8h, v13.8h, %[crc_adj].8h\n\t"
> + /* C.3 (CQE 1) adjust flow mark. */
> + "add v13.4s, v13.4s, %[flow_mark_adj].4s\n\t"
> + /* C.4 (CQE 1) fill in mbuf - rx_descriptor_fields1. */
> + "st1 {v13.2d}, [%[e1]]\n\t"
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + /* Extract byte_cnt */
> + "tbl %[byte_cnt].8b, {v20.16b - v23.16b}, %[len_shuf_m].8b\n\t"
> +#endif
> + /* A.2 copy mbuf pointers. */
> + "st1 {v24.2d - v25.2d}, [%[pkts_p]]\n\t"
> + /* C.2 (CQE 0) adjust CRC length. */
> + "sub v12.8h, v12.8h, %[crc_adj].8h\n\t"
> + /* C.3 (CQE 0) adjust flow mark. */
> + "add v12.4s, v12.4s, %[flow_mark_adj].4s\n\t"
> + /* C.4 (CQE 1) fill in mbuf - rx_descriptor_fields1. */
> + "st1 {v12.2d}, [%[e0]]\n\t"
> + :[op_own]"=&w"(op_own), [byte_cnt]"=&w"(byte_cnt)
> + :[p3]"r"(p3 + 48), [p2]"r"(p2 + 48),
> + [p1]"r"(p1 + 48), [p0]"r"(p0 + 48),
> + [e3]"r"(e3), [e2]"r"(e2), [e1]"r"(e1), [e0]"r"(e0),
> + [elts_p]"r"(elts_p), [pkts_p]"r"(pkts_p),
> + [cqe_shuf_m]"w"(cqe_shuf_m), [mb_shuf_m]"w"(mb_shuf_m),
> + [owner_shuf_m]"w"(owner_shuf_m), [len_shuf_m]"w"(len_shuf_m),
> + [crc_adj]"w"(crc_adj), [flow_mark_adj]"w"(flow_mark_adj)
> + :"memory",
> + "v12", "v13", "v14", "v15",
> + "v16", "v17", "v18", "v19",
> + "v20", "v21", "v22", "v23",
> + "v24", "v25");
> + /* D.2 flip owner bit to mark CQEs from last round. */
> + owner_mask = vand_u16(op_own, owner_check);
> + owner_mask = vceq_u16(owner_mask, ownership);
> + /* D.3 get mask for invalidated CQEs. */
> + opcode = vand_u16(op_own, opcode_check);
> + invalid_mask = vceq_u16(opcode_check, opcode);
> + /* E.1 find compressed CQE format. */
> + comp_mask = vand_u16(op_own, format_check);
> + comp_mask = vceq_u16(comp_mask, format_check);
> + /* D.4 mask out beyond boundary. */
> + invalid_mask = vorr_u16(invalid_mask, mask);
> + /* D.5 merge invalid_mask with invalid owner. */
> + invalid_mask = vorr_u16(invalid_mask, owner_mask);
> + /* E.2 mask out invalid entries. */
> + comp_mask = vbic_u16(comp_mask, invalid_mask);
> + /* E.3 get the first compressed CQE. */
> + comp_idx = __builtin_clzl(vget_lane_u64(vreinterpret_u64_u16(
> + comp_mask), 0)) / (sizeof(uint16_t) *
> 8);
> + /* D.6 mask out entries after the compressed CQE. */
> + mask = vcreate_u16(comp_idx < MLX5_VPMD_DESCS_PER_LOOP ?
> + -1UL >> (comp_idx * sizeof(uint16_t) * 8) :
> 0);
> + invalid_mask = vorr_u16(invalid_mask, mask);
> + /* D.7 count non-compressed valid CQEs. */
> + n = __builtin_clzl(vget_lane_u64(vreinterpret_u64_u16(
> + invalid_mask), 0)) / (sizeof(uint16_t) * 8);
> + nocmp_n += n;
> + /* D.2 get the final invalid mask. */
> + mask = vcreate_u16(n < MLX5_VPMD_DESCS_PER_LOOP ?
> + -1UL >> (n * sizeof(uint16_t) * 8) : 0);
> + /* TODO: the following isn't needed. */
> + invalid_mask = vorr_u16(invalid_mask, mask);
> + /* D.3 check error in opcode. */
> + opcode = vceq_u16(resp_err_check, opcode);
> + opcode = vbic_u16(opcode, invalid_mask);
> + /* D.4 mark if any error is set */
> + rxq->pending_err |=
> + !!vget_lane_u64(vreinterpret_u64_u16(opcode), 0);
> + /* C.5 fill in mbuf - rearm_data and packet_type. */
> + /* TODO:
> + rxq_cq_to_ptype_oflags_v(rxq, cqes, opcode, &pkts[pos]); */
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + /* Add up received bytes count. */
> + byte_cnt = vbic_u16(byte_cnt, invalid_mask);
> + rcvd_byte += vget_lane_u64(vpaddl_u32(vpaddl_u16(byte_cnt)), 0);
> +#endif
> + /*
> + * Break the loop unless more valid CQE is expected, or if
> + * there's a compressed CQE.
> + */
> + if (n != MLX5_VPMD_DESCS_PER_LOOP)
> + break;
> + }
> + /* If no new CQE seen, return without updating cq_db. */
> + if (unlikely(!nocmp_n && comp_idx == MLX5_VPMD_DESCS_PER_LOOP))
> + return rcvd_pkt;
> + /* Update the consumer indexes for non-compressed CQEs. */
> + assert(nocmp_n <= pkts_n);
> + rxq->cq_ci += nocmp_n;
> + rxq->rq_pi += nocmp_n;
> + rcvd_pkt += nocmp_n;
> +#ifdef MLX5_PMD_SOFT_COUNTERS
> + rxq->stats.ipackets += nocmp_n;
> + rxq->stats.ibytes += rcvd_byte;
> +#endif
> + /* Decompress the last CQE if compressed. */
> + if (comp_idx < MLX5_VPMD_DESCS_PER_LOOP && comp_idx == n) {
> + assert(comp_idx == (nocmp_n % MLX5_VPMD_DESCS_PER_LOOP));
> + rxq_cq_decompress_v(rxq, &cq[nocmp_n], &elts[nocmp_n]);
> + /* Return more packets if needed. */
> + if (nocmp_n < pkts_n) {
> + uint16_t n = rxq->cq_ci - rxq->rq_pi;
> +
> + n = RTE_MIN(n, pkts_n - nocmp_n);
> + rxq_copy_mbuf_v(rxq, &pkts[nocmp_n], n);
> + rxq->rq_pi += n;
> + rcvd_pkt += n;
> + }
> + }
> + rte_compiler_barrier();
> +#ifdef SW_EMULATION
> + *rxq->cq_db = 0;
> +#else
> + *rxq->cq_db = htonl(rxq->cq_ci);
> +#endif
> + return rcvd_pkt;
> +}
> +
> +/**
> + * DPDK callback for vectorized RX.
> + *
> + * @param dpdk_rxq
> + * Generic pointer to RX queue structure.
> + * @param[out] pkts
> + * Array to store received packets.
> + * @param pkts_n
> + * Maximum number of packets in array.
> + *
> + * @return
> + * Number of packets successfully received (<= pkts_n).
> + */
> +uint16_t
> +mlx5_rx_burst_vec(void *dpdk_rxq, struct rte_mbuf **pkts, uint16_t pkts_n)
> +{
> + struct rxq *rxq = dpdk_rxq;
> + uint16_t nb_rx;
> +
> + nb_rx = rxq_burst_v(rxq, pkts, pkts_n);
> + if (unlikely(rxq->pending_err))
> + nb_rx = rxq_handle_pending_error(rxq, pkts, nb_rx);
> + return nb_rx;
> +}
> +
> +/**
> + * Check Tx queue flags are set for raw vectorized Tx.
> + *
> + * @param priv
> + * Pointer to private structure.
> + *
> + * @return
> + * 1 if supported, negative errno value if not.
> + */
> +int __attribute__((cold))
> +priv_check_raw_vec_tx_support(struct priv *priv)
> +{
> + uint16_t i;
> +
> + /* All the configured queues should support. */
> + for (i = 0; i < priv->txqs_n; ++i) {
> + struct txq *txq = (*priv->txqs)[i];
> +
> + if (!(txq->flags & ETH_TXQ_FLAGS_NOMULTSEGS) ||
> + !(txq->flags & ETH_TXQ_FLAGS_NOOFFLOADS))
> + break;
> + }
> + if (i != priv->txqs_n)
> + return -ENOTSUP;
> + return 1;
> +}
> +
> +/**
> + * Check a device can support vectorized TX.
> + *
> + * @param priv
> + * Pointer to private structure.
> + *
> + * @return
> + * 1 if supported, negative errno value if not.
> + */
> +int __attribute__((cold))
> +priv_check_vec_tx_support(struct priv *priv)
> +{
> + if (!priv->tx_vec_en ||
> + priv->txqs_n > MLX5_VPMD_MIN_TXQS ||
> + priv->mps != MLX5_MPW_ENHANCED ||
> + priv->tso)
> + return -ENOTSUP;
> + return 1;
> +}
> +
> +/**
> + * Check a RX queue can support vectorized RX.
> + *
> + * @param rxq
> + * Pointer to RX queue.
> + *
> + * @return
> + * 1 if supported, negative errno value if not.
> + */
> +int __attribute__((cold))
> +rxq_check_vec_support(struct rxq *rxq)
> +{
> + struct rxq_ctrl *ctrl = container_of(rxq, struct rxq_ctrl, rxq);
> +
> + if (!ctrl->priv->rx_vec_en || rxq->sges_n != 0)
> + return -ENOTSUP;
> + return 1;
> +}
> +
> +/**
> + * Check a device can support vectorized RX.
> + *
> + * @param priv
> + * Pointer to private structure.
> + *
> + * @return
> + * 1 if supported, negative errno value if not.
> + */
> +int __attribute__((cold))
> +priv_check_vec_rx_support(struct priv *priv)
> +{
> + uint16_t i;
> +
> + if (!priv->rx_vec_en)
> + return -ENOTSUP;
> + /* All the configured queues should support. */
> + for (i = 0; i < priv->rxqs_n; ++i) {
> + struct rxq *rxq = (*priv->rxqs)[i];
> +
> + if (rxq_check_vec_support(rxq) < 0)
> + break;
> + }
> + if (i != priv->rxqs_n)
> + return -ENOTSUP;
> + return 1;
> +}
> +
> +/**
> + * Prepare for vectorized RX.
> + *
> + * @param priv
> + * Pointer to private structure.
> + */
> +void
> +priv_prep_vec_rx_function(struct priv *priv)
> +{
> + uint16_t i;
> +
> + for (i = 0; i < priv->rxqs_n; ++i) {
> + struct rxq *rxq = (*priv->rxqs)[i];
> + struct rte_mbuf *mbuf_init = &rxq->fake_mbuf;
> + const uint16_t desc = 1 << rxq->elts_n;
> + int j;
> +
> + assert(rxq->elts_n == rxq->cqe_n);
> + /* Initialize default rearm_data for vPMD. */
> + mbuf_init->data_off = RTE_PKTMBUF_HEADROOM;
> + rte_mbuf_refcnt_set(mbuf_init, 1);
> + mbuf_init->nb_segs = 1;
> + mbuf_init->port = rxq->port_id;
> + /*
> + * prevent compiler reordering:
> + * rearm_data covers previous fields.
> + */
> + rte_compiler_barrier();
> + rxq->mbuf_initializer =
> + *(uint64_t *)&mbuf_init->rearm_data;
> + /* Padding with a fake mbuf for vectorized Rx. */
> + for (j = 0; j < MLX5_VPMD_DESCS_PER_LOOP; ++j)
> + (*rxq->elts)[desc + j] = &rxq->fake_mbuf;
> + /* Mark that it need to be cleaned up for rxq_alloc_elts(). */
> + rxq->trim_elts = 1;
> + }
> +}
> --
> 2.11.0
It follows the same algorithm as for x86 side, unless the fact you seem to
need a lot of assembly instruction due to the missing instrasics I suppose.
Do you already have some good feedbacks in performance?
Thanks,
--
Nélio Laranjeiro
6WIND
