mbuf: remove build option to disable refcnt

[dpdk.git] / lib / librte_pmd_ixgbe / ixgbe_rxtx_vec.c

diff --git a/lib/librte_pmd_ixgbe/ixgbe_rxtx_vec.c b/lib/librte_pmd_ixgbe/ixgbe_rxtx_vec.c
index 42c0f60..1f46f0f 100644 (file)
--- a/lib/librte_pmd_ixgbe/ixgbe_rxtx_vec.c
+++ b/lib/librte_pmd_ixgbe/ixgbe_rxtx_vec.c
@@ -71,19 +71,30 @@ ixgbe_rxq_rearm(struct igb_rx_queue *rxq)
                                                dma_addr0);
                        }
                }
+               rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed +=
+                       RTE_IXGBE_RXQ_REARM_THRESH;
                return;
        }
 
        /* Initialize the mbufs in vector, process 2 mbufs in one loop */
        for (i = 0; i < RTE_IXGBE_RXQ_REARM_THRESH; i += 2, rxep += 2) {
                __m128i vaddr0, vaddr1;
+               uintptr_t p0, p1;
 
                mb0 = rxep[0].mbuf;
                mb1 = rxep[1].mbuf;
 
-               /* flush mbuf with pkt template */
-               mb0->rearm_data[0] = rxq->mbuf_initializer;
-               mb1->rearm_data[0] = rxq->mbuf_initializer;
+               /*
+                * Flush mbuf with pkt template.
+                * Data to be rearmed is 6 bytes long.
+                * Though, RX will overwrite ol_flags that are coming next
+                * anyway. So overwrite whole 8 bytes with one load:
+                * 6 bytes of rearm_data plus first 2 bytes of ol_flags.
+                */
+               p0 = (uintptr_t)&mb0->rearm_data;
+               *(uint64_t *)p0 = rxq->mbuf_initializer;
+               p1 = (uintptr_t)&mb1->rearm_data;
+               *(uint64_t *)p1 = rxq->mbuf_initializer;
 
                /* load buf_addr(lo 64bit) and buf_physaddr(hi 64bit) */
                vaddr0 = _mm_loadu_si128((__m128i *)&(mb0->buf_addr));
@@ -391,10 +402,10 @@ reassemble_packets(struct igb_rx_queue *rxq, struct rte_mbuf **rx_bufs,
        struct rte_mbuf *pkts[RTE_IXGBE_VPMD_RX_BURST]; /*finished pkts*/
        struct rte_mbuf *start = rxq->pkt_first_seg;
        struct rte_mbuf *end =  rxq->pkt_last_seg;
-       unsigned pkt_idx = 0, buf_idx = 0;
+       unsigned pkt_idx, buf_idx;
 
 
-       while (buf_idx < nb_bufs) {
+       for (buf_idx = 0, pkt_idx = 0; buf_idx < nb_bufs; buf_idx++) {
                if (end != NULL) {
                        /* processing a split packet */
                        end->next = rx_bufs[buf_idx];
@@ -437,7 +448,6 @@ reassemble_packets(struct igb_rx_queue *rxq, struct rte_mbuf **rx_bufs,
                        rx_bufs[buf_idx]->data_len += rxq->crc_len;
                        rx_bufs[buf_idx]->pkt_len += rxq->crc_len;
                }
-               buf_idx++;
        }
 
        /* save the partial packet for next time */
@@ -478,7 +488,7 @@ ixgbe_recv_scattered_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
        unsigned i = 0;
        if (rxq->pkt_first_seg == NULL) {
                /* find the first split flag, and only reassemble then*/
-               while (!split_flags[i] && i < nb_bufs)
+               while (i < nb_bufs && !split_flags[i])
                        i++;
                if (i == nb_bufs)
                        return nb_bufs;
@@ -529,20 +539,12 @@ ixgbe_tx_free_bufs(struct igb_tx_queue *txq)
         */
        txep = &((struct igb_tx_entry_v *)txq->sw_ring)[txq->tx_next_dd -
                        (n - 1)];
-#ifdef RTE_MBUF_REFCNT
        m = __rte_pktmbuf_prefree_seg(txep[0].mbuf);
-#else
-       m = txep[0].mbuf;
-#endif
        if (likely(m != NULL)) {
                free[0] = m;
                nb_free = 1;
                for (i = 1; i < n; i++) {
-#ifdef RTE_MBUF_REFCNT
                        m = __rte_pktmbuf_prefree_seg(txep[i].mbuf);
-#else
-                       m = txep[i].mbuf;
-#endif
                        if (likely(m != NULL)) {
                                if (likely(m->pool == free[0]->pool))
                                        free[nb_free++] = m;
@@ -730,14 +732,18 @@ static struct ixgbe_txq_ops vec_txq_ops = {
 int
 ixgbe_rxq_vec_setup(struct igb_rx_queue *rxq)
 {
+       uintptr_t p;
        struct rte_mbuf mb_def = { .buf_addr = 0 }; /* zeroed mbuf */
 
        mb_def.nb_segs = 1;
        mb_def.data_off = RTE_PKTMBUF_HEADROOM;
-       mb_def.buf_len = rxq->mb_pool->elt_size - sizeof(struct rte_mbuf);
        mb_def.port = rxq->port_id;
        rte_mbuf_refcnt_set(&mb_def, 1);
-       rxq->mbuf_initializer = *((uint64_t *)&mb_def.rearm_data);
+
+       /* prevent compiler reordering: rearm_data covers previous fields */
+       rte_compiler_barrier();
+       p = (uintptr_t)&mb_def.rearm_data;
+       rxq->mbuf_initializer = *(uint64_t *)p;
        return 0;
 }