The statistic service is responsible for collecting statistics.

Signed-off-by: Serhii Iliushyk <sil-...@napatech.com>
---
 drivers/net/ntnic/include/ntdrv_4ga.h |   1 -
 drivers/net/ntnic/ntnic_ethdev.c      | 146 ++++++++++++++------------
 drivers/net/ntnic/ntutil/nt_service.c |   6 ++
 drivers/net/ntnic/rte_pmd_ntnic.h     |   1 +
 4 files changed, 84 insertions(+), 70 deletions(-)

diff --git a/drivers/net/ntnic/include/ntdrv_4ga.h 
b/drivers/net/ntnic/include/ntdrv_4ga.h
index 35afcd546c..c143c0c2b6 100644
--- a/drivers/net/ntnic/include/ntdrv_4ga.h
+++ b/drivers/net/ntnic/include/ntdrv_4ga.h
@@ -16,7 +16,6 @@ typedef struct ntdrv_4ga_s {
 
        volatile bool b_shutdown;
        rte_spinlock_t stat_lck;
-       rte_thread_t stat_thread;
        rte_thread_t port_event_thread;
 } ntdrv_4ga_t;
 
diff --git a/drivers/net/ntnic/ntnic_ethdev.c b/drivers/net/ntnic/ntnic_ethdev.c
index c114017db8..54c9e218bc 100644
--- a/drivers/net/ntnic/ntnic_ethdev.c
+++ b/drivers/net/ntnic/ntnic_ethdev.c
@@ -1542,9 +1542,9 @@ drv_deinit(struct drv_s *p_drv)
        clear_pdrv(p_drv);
        nt_os_wait_usec(1000000);
 
-       /* stop statistics threads */
+       /* stop statistics service */
        p_drv->ntdrv.b_shutdown = true;
-       THREAD_JOIN(p_nt_drv->stat_thread);
+       nthw_service_del(RTE_NTNIC_SERVICE_STAT);
 
        if (fpga_info->profile == FPGA_INFO_PROFILE_INLINE) {
                nthw_service_del(RTE_NTNIC_SERVICE_FLM_UPDATE);
@@ -2024,84 +2024,86 @@ static int adapter_flm_update_service(void *context)
 }
 
 /*
- * Adapter stat thread
+ * Adapter stat service
  */
-THREAD_FUNC adapter_stat_thread_fn(void *context)
+static int adapter_stat_service(void *context)
 {
-       const struct nt4ga_stat_ops *nt4ga_stat_ops = get_nt4ga_stat_ops();
+       static struct ntdrv_4ga_s *p_nt_drv;
+       static nt4ga_stat_t *p_nt4ga_stat;
+       static nthw_stat_t *p_nthw_stat;
+       static const struct nt4ga_stat_ops *nt4ga_stat_ops;
 
-       if (nt4ga_stat_ops == NULL) {
-               NT_LOG_DBGX(ERR, NTNIC, "Statistics module uninitialized");
-               return THREAD_RETURN;
-       }
+       struct nt_service *stat_srv = 
nthw_service_get_info(RTE_NTNIC_SERVICE_STAT);
+       RTE_ASSERT(stat_srv != NULL);
 
-       struct drv_s *p_drv = context;
+       if (!NT_SERVICE_GET_STATE(stat_srv)) {
+               struct drv_s *p_drv = context;
+               RTE_ASSERT(p_drv != NULL);
 
-       ntdrv_4ga_t *p_nt_drv = &p_drv->ntdrv;
-       nt4ga_stat_t *p_nt4ga_stat = &p_nt_drv->adapter_info.nt4ga_stat;
-       nthw_stat_t *p_nthw_stat = p_nt4ga_stat->mp_nthw_stat;
-       const char *const p_adapter_id_str = 
p_nt_drv->adapter_info.mp_adapter_id_str;
-       (void)p_adapter_id_str;
+               nt4ga_stat_ops = get_nt4ga_stat_ops();
+               RTE_ASSERT(nt4ga_stat_ops != NULL);
 
-       if (!p_nthw_stat)
-               return THREAD_RETURN;
+               p_nt_drv = &p_drv->ntdrv;
+               p_nt4ga_stat = &p_nt_drv->adapter_info.nt4ga_stat;
+               p_nthw_stat = p_nt4ga_stat->mp_nthw_stat;
 
-       NT_LOG_DBGX(DBG, NTNIC, "%s: begin", p_adapter_id_str);
+               if (!p_nthw_stat)
+                       return 0;
 
-       RTE_ASSERT(p_nthw_stat);
+               NT_LOG(INF, NTNIC, "statistic service started on lcore %u",  
rte_lcore_id());
+               stat_srv->lcore = rte_lcore_id();
+               NT_SERVICE_SET_STATE(stat_srv, true);
+               return 0;
+       }
 
-       while (!p_drv->ntdrv.b_shutdown) {
-               nt_os_wait_usec(10 * 1000);
-
-               nthw_stat_trigger(p_nthw_stat);
-
-               uint32_t loop = 0;
-
-               while ((!p_drv->ntdrv.b_shutdown) &&
-                       (*p_nthw_stat->mp_timestamp == (uint64_t)-1)) {
-                       nt_os_wait_usec(1 * 100);
-
-                       if (rte_log_get_level(nt_log_ntnic) == RTE_LOG_DEBUG &&
-                               (++loop & 0x3fff) == 0) {
-                               if (p_nt4ga_stat->mp_nthw_rpf) {
-                                       NT_LOG(ERR, NTNIC, "Statistics DMA 
frozen");
-
-                               } else if (p_nt4ga_stat->mp_nthw_rmc) {
-                                       uint32_t sf_ram_of =
-                                               
nthw_rmc_get_status_sf_ram_of(p_nt4ga_stat
-                                                       ->mp_nthw_rmc);
-                                       uint32_t descr_fifo_of =
-                                               
nthw_rmc_get_status_descr_fifo_of(p_nt4ga_stat
-                                                       ->mp_nthw_rmc);
-
-                                       uint32_t dbg_merge =
-                                               
nthw_rmc_get_dbg_merge(p_nt4ga_stat->mp_nthw_rmc);
-                                       uint32_t mac_if_err =
-                                               
nthw_rmc_get_mac_if_err(p_nt4ga_stat->mp_nthw_rmc);
-
-                                       NT_LOG(ERR, NTNIC, "Statistics DMA 
frozen");
-                                       NT_LOG(ERR, NTNIC, "SF RAM Overflow     
: %08x",
-                                               sf_ram_of);
-                                       NT_LOG(ERR, NTNIC, "Descr Fifo Overflow 
: %08x",
-                                               descr_fifo_of);
-                                       NT_LOG(ERR, NTNIC, "DBG Merge           
: %08x",
-                                               dbg_merge);
-                                       NT_LOG(ERR, NTNIC, "MAC If Errors       
: %08x",
-                                               mac_if_err);
-                               }
+       nt_os_wait_usec(10 * 1000);
+
+       nthw_stat_trigger(p_nthw_stat);
+
+       uint32_t loop = 0;
+
+       while (rte_service_runstate_get(stat_srv->id) &&
+               (*p_nthw_stat->mp_timestamp == (uint64_t)-1)) {
+               nt_os_wait_usec(1 * 100);
+
+               if ((++loop & 0x3fff) == 0) {
+                       if (p_nt4ga_stat->mp_nthw_rpf) {
+                               NT_LOG(DBG, NTNIC, "Statistics DMA frozen");
+
+                       } else if (p_nt4ga_stat->mp_nthw_rmc) {
+                               uint32_t sf_ram_of =
+                                       
nthw_rmc_get_status_sf_ram_of(p_nt4ga_stat
+                                               ->mp_nthw_rmc);
+                               uint32_t descr_fifo_of =
+                                       
nthw_rmc_get_status_descr_fifo_of(p_nt4ga_stat
+                                               ->mp_nthw_rmc);
+
+                               uint32_t dbg_merge =
+                                       
nthw_rmc_get_dbg_merge(p_nt4ga_stat->mp_nthw_rmc);
+                               uint32_t mac_if_err =
+                                       
nthw_rmc_get_mac_if_err(p_nt4ga_stat->mp_nthw_rmc);
+
+                               NT_LOG(DBG, NTNIC, "Statistics DMA frozen");
+                               NT_LOG(DBG, NTNIC, "SF RAM Overflow     : %08x",
+                                       sf_ram_of);
+                               NT_LOG(DBG, NTNIC, "Descr Fifo Overflow : %08x",
+                                       descr_fifo_of);
+                               NT_LOG(DBG, NTNIC, "DBG Merge           : %08x",
+                                       dbg_merge);
+                               NT_LOG(DBG, NTNIC, "MAC If Errors       : %08x",
+                                       mac_if_err);
                        }
                }
+       }
 
-               /* Check then collect */
-               {
-                       rte_spinlock_lock(&p_nt_drv->stat_lck);
-                       
nt4ga_stat_ops->nt4ga_stat_collect(&p_nt_drv->adapter_info, p_nt4ga_stat);
-                       rte_spinlock_unlock(&p_nt_drv->stat_lck);
-               }
+       /* Check then collect */
+       {
+               rte_spinlock_lock(&p_nt_drv->stat_lck);
+               nt4ga_stat_ops->nt4ga_stat_collect(&p_nt_drv->adapter_info, 
p_nt4ga_stat);
+               rte_spinlock_unlock(&p_nt_drv->stat_lck);
        }
 
-       NT_LOG_DBGX(DBG, NTNIC, "%s: end", p_adapter_id_str);
-       return THREAD_RETURN;
+       return 0;
 }
 
 static int
@@ -2371,9 +2373,15 @@ nthw_pci_dev_init(struct rte_pci_device *pci_dev)
                }
        }
 
-       rte_spinlock_init(&p_nt_drv->stat_lck);
-       res = THREAD_CTRL_CREATE(&p_nt_drv->stat_thread, "nt4ga_stat_thr", 
adapter_stat_thread_fn,
-                       (void *)p_drv);
+       struct rte_service_spec stat_spec = {
+               .name = "ntnic-stat_collect_service",
+               .callback = adapter_stat_service,
+               .socket_id = SOCKET_ID_ANY,
+               .capabilities = RTE_SERVICE_CAP_MT_SAFE,
+               .callback_userdata = p_drv
+       };
+
+       res = nthw_service_add(&stat_spec, RTE_NTNIC_SERVICE_STAT);
 
        if (res) {
                NT_LOG(ERR, NTNIC, "%s: error=%d",
diff --git a/drivers/net/ntnic/ntutil/nt_service.c 
b/drivers/net/ntnic/ntutil/nt_service.c
index 86f709e401..c109b44483 100644
--- a/drivers/net/ntnic/ntutil/nt_service.c
+++ b/drivers/net/ntnic/ntutil/nt_service.c
@@ -18,6 +18,12 @@ static struct nt_service 
g_nt_services[RTE_NTNIC_SERVICE_MAX] = {
                .lcore = RTE_MAX_LCORE,
                .initialized = false,
        },
+       [RTE_NTNIC_SERVICE_STAT] = {
+               .tag = RTE_NTNIC_SERVICE_STAT,
+               .id = NT_SERVICE_UNKNOWN_ID,
+               .lcore = RTE_MAX_LCORE,
+               .initialized = false,
+       },
 };
 
 inline struct nt_service *nthw_service_get_info(const enum 
rte_ntnic_service_tag tag)
diff --git a/drivers/net/ntnic/rte_pmd_ntnic.h 
b/drivers/net/ntnic/rte_pmd_ntnic.h
index d6236dae32..6fe6541984 100644
--- a/drivers/net/ntnic/rte_pmd_ntnic.h
+++ b/drivers/net/ntnic/rte_pmd_ntnic.h
@@ -42,6 +42,7 @@ enum rte_ntnic_event_type {
 
 enum rte_ntnic_service_tag {
        RTE_NTNIC_SERVICE_FLM_UPDATE = 0,
+       RTE_NTNIC_SERVICE_STAT = 1,
        RTE_NTNIC_SERVICE_MAX
 };
 
-- 
2.45.0

Reply via email to