🎈 perf: Optimize mrpdump structure for performance improvements.

Optimize mrpdump structure for performance improvements.

1 files changed, 59 insertions, 52 deletions

diff --git a/service/src/pdump.c b/service/src/pdump.c
index 8df34e1..392755c 100644
--- a/service/src/pdump.c
+++ b/service/src/pdump.c
@@ -20,8 +20,6 @@ struct port_resource
 {
     uint16_t queue;
     uint64_t snaplen;
-    rte_atomic64_t rx_enable;
-    rte_atomic64_t tx_enable;
     struct rte_ring * rx_ring;
     struct rte_ring * tx_ring;
     shmdev_pdump_func rx_pdump_func;
@@ -31,10 +29,13 @@ struct port_resource
     struct rte_pdump_stats rx_stats;
     struct rte_pdump_stats tx_stats;
 };
+
 /* Mrpdump */
 struct mr_pdump
 {
-    struct port_resource ports[MR_DEVICE_MAX];
+    rte_atomic64_t rx_enable[MR_DEVICE_MAX];
+    rte_atomic64_t tx_enable[MR_DEVICE_MAX];
+    struct port_resource * ports[MR_DEVICE_MAX];
     struct rte_mempool * mr_pdump_shmdev_mempool;
     struct rte_mempool * mr_pdump_phydev_mempool;
 };
@@ -49,21 +50,21 @@ void mr_pdump_rx(port_id_t shmdev_port_id, queue_id_t qid, struct rte_mbuf ** mb
     port_id_t port_id = shmdev_port_id + RTE_MAX_ETHPORTS;
 
     /* Check enable  */
-    if (likely(rte_atomic64_read(&_mr_pdump_main->ports[port_id].rx_enable) == 0))
+    if (likely(rte_atomic64_read(&_mr_pdump_main->rx_enable[port_id]) == 0))
         return;
-    if (likely((_mr_pdump_main->ports[port_id].rx_pdump_func == NULL)))
+    if (likely((_mr_pdump_main->ports[port_id]->rx_pdump_func == NULL)))
         return;
-    if (unlikely((_mr_pdump_main->ports[port_id].queue != RTE_PDUMP_ALL_QUEUES)) &&
-        (_mr_pdump_main->ports[port_id].queue != qid))
+    if (unlikely((_mr_pdump_main->ports[port_id]->queue != RTE_PDUMP_ALL_QUEUES)) &&
+        (_mr_pdump_main->ports[port_id]->queue != qid))
         return;
 
     /* Get pdump info */
     struct rte_mempool * mp = _mr_pdump_main->mr_pdump_shmdev_mempool;
-    struct rte_ring * ring = _mr_pdump_main->ports[port_id].rx_ring;
-    struct rte_pdump_stats * stats = &_mr_pdump_main->ports[port_id].rx_stats;
-    shmdev_pdump_func pdump_func = _mr_pdump_main->ports[port_id].rx_pdump_func;
-    struct rte_bpf * bpf = _mr_pdump_main->ports[port_id].rx_bpf;
-    uint64_t snaplen = _mr_pdump_main->ports[port_id].snaplen;
+    struct rte_ring * ring = _mr_pdump_main->ports[port_id]->rx_ring;
+    struct rte_pdump_stats * stats = &_mr_pdump_main->ports[port_id]->rx_stats;
+    shmdev_pdump_func pdump_func = _mr_pdump_main->ports[port_id]->rx_pdump_func;
+    struct rte_bpf * bpf = _mr_pdump_main->ports[port_id]->rx_bpf;
+    uint64_t snaplen = _mr_pdump_main->ports[port_id]->snaplen;
 
     /* Dump the pkt */
     pdump_func(port_id, qid, mp, ring, mbufs, nr_pkts, stats, bpf, snaplen, RTE_PCAPNG_DIRECTION_IN);
@@ -76,21 +77,21 @@ void mr_pdump_tx(port_id_t shmdev_port_id, queue_id_t qid, struct rte_mbuf ** mb
     port_id_t port_id = shmdev_port_id + RTE_MAX_ETHPORTS;
 
     /* Check enable  */
-    if (likely(rte_atomic64_read(&_mr_pdump_main->ports[port_id].tx_enable) == 0))
+    if (likely(rte_atomic64_read(&_mr_pdump_main->tx_enable[port_id]) == 0))
         return;
-    if (likely((_mr_pdump_main->ports[port_id].tx_pdump_func == NULL)))
+    if (likely((_mr_pdump_main->ports[port_id]->tx_pdump_func == NULL)))
         return;
-    if (unlikely((_mr_pdump_main->ports[port_id].queue != RTE_PDUMP_ALL_QUEUES)) &&
-        (_mr_pdump_main->ports[port_id].queue != qid))
+    if (unlikely((_mr_pdump_main->ports[port_id]->queue != RTE_PDUMP_ALL_QUEUES)) &&
+        (_mr_pdump_main->ports[port_id]->queue != qid))
         return;
 
     /* Get pdump info */
     struct rte_mempool * mp = _mr_pdump_main->mr_pdump_shmdev_mempool;
-    struct rte_ring * ring = _mr_pdump_main->ports[port_id].tx_ring;
-    struct rte_pdump_stats * stats = &_mr_pdump_main->ports[port_id].tx_stats;
-    shmdev_pdump_func pdump_func = _mr_pdump_main->ports[port_id].tx_pdump_func;
-    struct rte_bpf * bpf = _mr_pdump_main->ports[port_id].tx_bpf;
-    uint64_t snaplen = _mr_pdump_main->ports[port_id].snaplen;
+    struct rte_ring * ring = _mr_pdump_main->ports[port_id]->tx_ring;
+    struct rte_pdump_stats * stats = &_mr_pdump_main->ports[port_id]->tx_stats;
+    shmdev_pdump_func pdump_func = _mr_pdump_main->ports[port_id]->tx_pdump_func;
+    struct rte_bpf * bpf = _mr_pdump_main->ports[port_id]->tx_bpf;
+    uint64_t snaplen = _mr_pdump_main->ports[port_id]->snaplen;
 
     /* Dump the pkt */
     pdump_func(port_id, qid, mp, ring, mbufs, nr_pkts, stats, bpf, snaplen, RTE_PCAPNG_DIRECTION_OUT);
@@ -161,18 +162,18 @@ int mr_pdump_enable(const struct mr_pdump_request * _cli_req, struct mr_pdump_re
     if (_cli_req->flags & RTE_PDUMP_FLAG_RX)
     {
         /* Fill the rx response */
-        _out_response->rx_ring = _mr_pdump_main->ports[port_id].rx_ring;
+        _out_response->rx_ring = _mr_pdump_main->ports[port_id]->rx_ring;
 
         /* Clear rx stats */
-        memset(&_mr_pdump_main->ports[port_id].rx_stats, 0, sizeof(struct rte_pdump_stats));
+        memset(&_mr_pdump_main->ports[port_id]->rx_stats, 0, sizeof(struct rte_pdump_stats));
 
         /* Set shmdev pdump func */
         if (dev_desc->drv_type == MR_DEV_DRV_TYPE_SHMDEV)
         {
             _mempool = _mr_pdump_main->mr_pdump_shmdev_mempool;
-            _mr_pdump_main->ports[port_id].rx_pdump_func = (shmdev_pdump_func)shmdev_pdump_copy;
+            _mr_pdump_main->ports[port_id]->rx_pdump_func = (shmdev_pdump_func)shmdev_pdump_copy;
             if (_cli_req->prm != NULL)
-                _mr_pdump_main->ports[port_id].rx_bpf = rte_bpf_load(_cli_req->prm);
+                _mr_pdump_main->ports[port_id]->rx_bpf = rte_bpf_load(_cli_req->prm);
         }
         else
         {
@@ -180,25 +181,25 @@ int mr_pdump_enable(const struct mr_pdump_request * _cli_req, struct mr_pdump_re
         }
 
         /* Enable rx pdump */
-        rte_atomic64_test_and_set(&_mr_pdump_main->ports[port_id].rx_enable);
+        rte_atomic64_test_and_set(&_mr_pdump_main->rx_enable[port_id]);
     }
 
     /* Deal tx ring */
     if (_cli_req->flags & RTE_PDUMP_FLAG_TX)
     {
         /* Fill the tx response */
-        _out_response->tx_ring = _mr_pdump_main->ports[port_id].tx_ring;
+        _out_response->tx_ring = _mr_pdump_main->ports[port_id]->tx_ring;
 
         /* Clear tx stats */
-        memset(&_mr_pdump_main->ports[port_id].tx_stats, 0, sizeof(struct rte_pdump_stats));
+        memset(&_mr_pdump_main->ports[port_id]->tx_stats, 0, sizeof(struct rte_pdump_stats));
 
         /* Set shmdev pdump func */
         if (dev_desc->drv_type == MR_DEV_DRV_TYPE_SHMDEV)
         {
             _mempool = _mr_pdump_main->mr_pdump_shmdev_mempool;
-            _mr_pdump_main->ports[port_id].tx_pdump_func = (shmdev_pdump_func)shmdev_pdump_copy;
+            _mr_pdump_main->ports[port_id]->tx_pdump_func = (shmdev_pdump_func)shmdev_pdump_copy;
             if (_cli_req->prm != NULL)
-                _mr_pdump_main->ports[port_id].tx_bpf = rte_bpf_load(_cli_req->prm);
+                _mr_pdump_main->ports[port_id]->tx_bpf = rte_bpf_load(_cli_req->prm);
         }
         else
         {
@@ -206,7 +207,7 @@ int mr_pdump_enable(const struct mr_pdump_request * _cli_req, struct mr_pdump_re
         }
 
         /* Enable tx pdump */
-        rte_atomic64_test_and_set(&_mr_pdump_main->ports[port_id].tx_enable);
+        rte_atomic64_test_and_set(&_mr_pdump_main->tx_enable[port_id]);
     }
 
     /* Fill the response for public */
@@ -218,8 +219,8 @@ int mr_pdump_enable(const struct mr_pdump_request * _cli_req, struct mr_pdump_re
     rte_ether_addr_copy(&dev_desc->eth_addr, &_out_response->eth_addr);
 
     /* Save the pdump info for public */
-    _mr_pdump_main->ports[port_id].queue = _cli_req->queue;
-    _mr_pdump_main->ports[port_id].snaplen = _cli_req->snaplen;
+    _mr_pdump_main->ports[port_id]->queue = _cli_req->queue;
+    _mr_pdump_main->ports[port_id]->snaplen = _cli_req->snaplen;
 
     return RT_SUCCESS;
 }
@@ -260,46 +261,46 @@ int mr_pdump_disable(const struct mr_pdump_request * _cli_req, struct mr_pdump_r
     if (_cli_req->flags & RTE_PDUMP_FLAG_RX)
     {
         /* Set rx disable */
-        rte_atomic64_clear(&_mr_pdump_main->ports[port_id].rx_enable);
+        rte_atomic64_clear(&_mr_pdump_main->rx_enable[port_id]);
 
         /* Fill the response for rx */
         _out_response->rx_ring = NULL;
 
         /* Clear pdump func for rx */
-        _mr_pdump_main->ports[port_id].rx_pdump_func = NULL;
+        _mr_pdump_main->ports[port_id]->rx_pdump_func = NULL;
 
-        if (_mr_pdump_main->ports[port_id].rx_bpf != NULL)
+        if (_mr_pdump_main->ports[port_id]->rx_bpf != NULL)
         {
-            rte_bpf_destroy(_mr_pdump_main->ports[port_id].rx_bpf);
-            _mr_pdump_main->ports[port_id].rx_bpf = NULL;
+            rte_bpf_destroy(_mr_pdump_main->ports[port_id]->rx_bpf);
+            _mr_pdump_main->ports[port_id]->rx_bpf = NULL;
         }
 
         /* Dump and clear rx stats */
-        mr_pdump_stats_dump(_dev_desc, &_mr_pdump_main->ports[port_id].rx_stats, RTE_PDUMP_FLAG_RX);
-        memset(&_mr_pdump_main->ports[port_id].rx_stats, 0, sizeof(struct rte_pdump_stats));
+        mr_pdump_stats_dump(_dev_desc, &_mr_pdump_main->ports[port_id]->rx_stats, RTE_PDUMP_FLAG_RX);
+        memset(&_mr_pdump_main->ports[port_id]->rx_stats, 0, sizeof(struct rte_pdump_stats));
     }
 
     /* Deal tx ring */
     if (_cli_req->flags & RTE_PDUMP_FLAG_TX)
     {
         /* Set tx disable */
-        rte_atomic64_clear(&_mr_pdump_main->ports[port_id].tx_enable);
+        rte_atomic64_clear(&_mr_pdump_main->tx_enable[port_id]);
 
         /* Fill the response for tx */
         _out_response->tx_ring = NULL;
 
         /* Clear pdump func for tx */
-        _mr_pdump_main->ports[port_id].tx_pdump_func = NULL;
+        _mr_pdump_main->ports[port_id]->tx_pdump_func = NULL;
 
-        if (_mr_pdump_main->ports[port_id].tx_bpf != NULL)
+        if (_mr_pdump_main->ports[port_id]->tx_bpf != NULL)
         {
-            rte_bpf_destroy(_mr_pdump_main->ports[port_id].tx_bpf);
-            _mr_pdump_main->ports[port_id].tx_bpf = NULL;
+            rte_bpf_destroy(_mr_pdump_main->ports[port_id]->tx_bpf);
+            _mr_pdump_main->ports[port_id]->tx_bpf = NULL;
         }
 
         /* Dump and clear tx stats */
-        mr_pdump_stats_dump(_dev_desc, &_mr_pdump_main->ports[port_id].tx_stats, RTE_PDUMP_FLAG_TX);
-        memset(&_mr_pdump_main->ports[port_id].tx_stats, 0, sizeof(struct rte_pdump_stats));
+        mr_pdump_stats_dump(_dev_desc, &_mr_pdump_main->ports[port_id]->tx_stats, RTE_PDUMP_FLAG_TX);
+        memset(&_mr_pdump_main->ports[port_id]->tx_stats, 0, sizeof(struct rte_pdump_stats));
     }
 
     /* Fill the response for public */
@@ -310,7 +311,7 @@ int mr_pdump_disable(const struct mr_pdump_request * _cli_req, struct mr_pdump_r
     _out_response->mp = NULL;
 
     /* Save pdump info for public */
-    _mr_pdump_main->ports[port_id].queue = 0;
+    _mr_pdump_main->ports[port_id]->queue = 0;
 
     return RT_SUCCESS;
 }
@@ -381,6 +382,12 @@ int mr_pdump_init(struct sc_main * sc)
     MR_VERIFY_MALLOC(mr_pdump_main);
     g_mr_pdump_main = mr_pdump_main;
 
+    for (int index = 0; index < MR_DEVICE_MAX; index++) 
+    {
+        mr_pdump_main->ports[index] = ZMALLOC(sizeof(struct port_resource));
+        MR_VERIFY_MALLOC(mr_pdump_main->ports[index]);
+    }
+
     /* Message register */
     int ret = rte_mp_action_register(MR_PDUMP_MP, mr_pdump_server);
     if (ret < 0)
@@ -433,15 +440,15 @@ int mr_pdump_init(struct sc_main * sc)
             return RT_ERR;
         }
 
-        mr_pdump_main->ports[index].rx_ring = rx_ring;
-        mr_pdump_main->ports[index].tx_ring = tx_ring;
+        mr_pdump_main->ports[index]->rx_ring = rx_ring;
+        mr_pdump_main->ports[index]->tx_ring = tx_ring;
     }
 
     /* Init enable switch */
     for (int index = 0; index < MR_DEVICE_MAX; index++)
     {
-        rte_atomic64_init(&mr_pdump_main->ports[index].rx_enable);
-        rte_atomic64_init(&mr_pdump_main->ports[index].tx_enable);
+        rte_atomic64_init(&mr_pdump_main->rx_enable[index]);
+        rte_atomic64_init(&mr_pdump_main->tx_enable[index]);
     }
 
     return RT_SUCCESS;