net/sfc: support SW stats groups

Add support for grouping SW stats together. When stats are
grouped the corresponding stats values for each queue
are obtained during calling one read callback. This is useful
to group per-queue stats 'packets' and 'bytes' to keep stats
consistent, i.e. a number of bytes corresponds to a number of
packets. These stats will be added in the following patches.

Signed-off-by: Ivan Ilchenko <ivan.ilchenko@oktetlabs.ru>
Signed-off-by: Andrew Rybchenko <andrew.rybchenko@oktetlabs.ru>

diff --git a/drivers/net/sfc/sfc.h b/drivers/net/sfc/sfc.h
index 5a40a73c7fe3cc7a6c1fe0ee0c21bbe640c6a59c..30679014e385fccbaf0d86bbdca51f58c906d4b8 100644 (file)
--- a/drivers/net/sfc/sfc.h
+++ b/drivers/net/sfc/sfc.h
@@ -30,6 +30,7 @@
 #include "sfc_sriov.h"
 #include "sfc_mae.h"
 #include "sfc_dp.h"
+#include "sfc_sw_stats.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -219,6 +220,8 @@ struct sfc_counter_rxq {
 
 struct sfc_sw_stat_data {
        const struct sfc_sw_stat_descr *descr;
+       /* Cache fragment */
+       uint64_t                        *cache;
 };
 
 struct sfc_sw_stats {
@@ -227,6 +230,11 @@ struct sfc_sw_stats {
        /* Supported SW statistics */
        struct sfc_sw_stat_data         *supp;
        unsigned int                    supp_count;
+
+       /* Cache for all supported SW statistics */
+       uint64_t                        *cache;
+       unsigned int                    cache_count;
+
        uint64_t                        *reset_vals;
 
        rte_spinlock_t                  queues_bitmap_lock;

diff --git a/drivers/net/sfc/sfc_sw_stats.c b/drivers/net/sfc/sfc_sw_stats.c
index 63fc334d2b3e03c09e5e1c52bcebc2f408d2aaa9..81bd531a17ee09858923d5cf4f4bcc5e2fdc1556 100644 (file)
--- a/drivers/net/sfc/sfc_sw_stats.c
+++ b/drivers/net/sfc/sfc_sw_stats.c
@@ -10,12 +10,17 @@
 #include "sfc_tx.h"
 #include "sfc_sw_stats.h"
 
+#define SFC_SW_STAT_INVALID            UINT64_MAX
+
+#define SFC_SW_STATS_GROUP_SIZE_MAX    1U
+
 enum sfc_sw_stats_type {
        SFC_SW_STATS_RX,
        SFC_SW_STATS_TX,
 };
 
-typedef uint64_t sfc_get_sw_stat_val_t(struct sfc_adapter *sa, uint16_t qid);
+typedef void sfc_get_sw_stat_val_t(struct sfc_adapter *sa, uint16_t qid,
+                                  uint64_t *values, unsigned int values_count);
 
 struct sfc_sw_stat_descr {
        const char *name;
@@ -25,31 +30,41 @@ struct sfc_sw_stat_descr {
 };
 
 static sfc_get_sw_stat_val_t sfc_get_sw_stat_val_rx_dbells;
-static uint64_t
-sfc_get_sw_stat_val_rx_dbells(struct sfc_adapter *sa, uint16_t qid)
+static void
+sfc_get_sw_stat_val_rx_dbells(struct sfc_adapter *sa, uint16_t qid,
+                              uint64_t *values, unsigned int values_count)
 {
        struct sfc_adapter_shared *sas = sfc_sa2shared(sa);
        struct sfc_rxq_info *rxq_info;
 
+       RTE_SET_USED(values_count);
+       SFC_ASSERT(values_count == 1);
        rxq_info = sfc_rxq_info_by_ethdev_qid(sas, qid);
-       if (rxq_info->state & SFC_RXQ_INITIALIZED)
-               return rxq_info->dp->dpq.rx_dbells;
-       return 0;
+       values[0] = rxq_info->state & SFC_RXQ_INITIALIZED ?
+                   rxq_info->dp->dpq.rx_dbells : 0;
 }
 
 static sfc_get_sw_stat_val_t sfc_get_sw_stat_val_tx_dbells;
-static uint64_t
-sfc_get_sw_stat_val_tx_dbells(struct sfc_adapter *sa, uint16_t qid)
+static void
+sfc_get_sw_stat_val_tx_dbells(struct sfc_adapter *sa, uint16_t qid,
+                              uint64_t *values, unsigned int values_count)
 {
        struct sfc_adapter_shared *sas = sfc_sa2shared(sa);
        struct sfc_txq_info *txq_info;
 
+       RTE_SET_USED(values_count);
+       SFC_ASSERT(values_count == 1);
        txq_info = sfc_txq_info_by_ethdev_qid(sas, qid);
-       if (txq_info->state & SFC_TXQ_INITIALIZED)
-               return txq_info->dp->dpq.tx_dbells;
-       return 0;
+       values[0] = txq_info->state & SFC_TXQ_INITIALIZED ?
+                   txq_info->dp->dpq.tx_dbells : 0;
 }
 
+/*
+ * SW stats can be grouped together. When stats are grouped the corresponding
+ * stats values for each queue are obtained during calling one get value
+ * callback. Stats of the same group are contiguous in the structure below.
+ * The start of the group is denoted by stat implementing get value callback.
+ */
 const struct sfc_sw_stat_descr sfc_sw_stats_descr[] = {
        {
                .name = "dbells",
@@ -228,9 +243,53 @@ sfc_sw_xstat_get_names_by_id(struct sfc_adapter *sa,
        return 0;
 }
 
+static uint64_t
+sfc_sw_stat_get_val(struct sfc_adapter *sa,
+                   unsigned int sw_stat_idx, uint16_t qid)
+{
+       struct sfc_sw_stats *sw_stats = &sa->sw_stats;
+       uint64_t *res = &sw_stats->supp[sw_stat_idx].cache[qid];
+       uint64_t values[SFC_SW_STATS_GROUP_SIZE_MAX];
+       unsigned int group_start_idx;
+       unsigned int group_size;
+       unsigned int i;
+
+       if (*res != SFC_SW_STAT_INVALID)
+               return *res;
+
+       /*
+        * Search for the group start, i.e. the stat that implements
+        * get value callback.
+        */
+       group_start_idx = sw_stat_idx;
+       while (sw_stats->supp[group_start_idx].descr->get_val == NULL)
+               group_start_idx--;
+
+       /*
+        * Calculate number of elements in the group with loop till the next
+        * group start or the list end.
+        */
+       group_size = 1;
+       for (i = sw_stat_idx + 1; i < sw_stats->supp_count; i++) {
+               if (sw_stats->supp[i].descr->get_val != NULL)
+                       break;
+               group_size++;
+       }
+       group_size += sw_stat_idx - group_start_idx;
+
+       SFC_ASSERT(group_size <= SFC_SW_STATS_GROUP_SIZE_MAX);
+       sw_stats->supp[group_start_idx].descr->get_val(sa, qid, values,
+                                                      group_size);
+       for (i = group_start_idx; i < (group_start_idx + group_size); i++)
+               sw_stats->supp[i].cache[qid] = values[i - group_start_idx];
+
+       return *res;
+}
+
 static void
 sfc_sw_xstat_get_values(struct sfc_adapter *sa,
                        const struct sfc_sw_stat_descr *sw_stat,
+                       unsigned int sw_stat_idx,
                        struct rte_eth_xstat *xstats,
                        unsigned int xstats_size,
                        unsigned int *nb_written,
@@ -260,7 +319,7 @@ sfc_sw_xstat_get_values(struct sfc_adapter *sa,
        }
 
        for (qid = 0; qid < nb_queues; ++qid) {
-               value = sw_stat->get_val(sa, qid);
+               value = sfc_sw_stat_get_val(sa, sw_stat_idx, qid);
 
                if (*nb_written < xstats_size) {
                        xstats[*nb_written].id = *nb_written;
@@ -276,6 +335,7 @@ sfc_sw_xstat_get_values(struct sfc_adapter *sa,
 static void
 sfc_sw_xstat_get_values_by_id(struct sfc_adapter *sa,
                              const struct sfc_sw_stat_descr *sw_stat,
+                             unsigned int sw_stat_idx,
                              const uint64_t *ids,
                              uint64_t *values,
                              unsigned int ids_size,
@@ -316,7 +376,7 @@ sfc_sw_xstat_get_values_by_id(struct sfc_adapter *sa,
                        }
                        id_base_q = id_base + sw_stat->provide_total;
                        qid = ids[i] - id_base_q;
-                       values[i] = sw_stat->get_val(sa, qid);
+                       values[i] = sfc_sw_stat_get_val(sa, sw_stat_idx, qid);
                        total_value += values[i];
 
                        rte_bitmap_set(bmp, qid);
@@ -328,7 +388,9 @@ sfc_sw_xstat_get_values_by_id(struct sfc_adapter *sa,
                for (qid = 0; qid < nb_queues; ++qid) {
                        if (rte_bitmap_get(bmp, qid) != 0)
                                continue;
-                       values[total_value_idx] += sw_stat->get_val(sa, qid);
+                       values[total_value_idx] += sfc_sw_stat_get_val(sa,
+                                                                   sw_stat_idx,
+                                                                   qid);
                }
                values[total_value_idx] += total_value;
        }
@@ -344,6 +406,16 @@ sfc_sw_xstats_get_nb_supported(struct sfc_adapter *sa)
        return sa->sw_stats.xstats_count;
 }
 
+static void
+sfc_sw_stats_clear_cache(struct sfc_adapter *sa)
+{
+       unsigned int cache_count = sa->sw_stats.cache_count;
+       uint64_t *cache = sa->sw_stats.cache;
+
+       RTE_BUILD_BUG_ON(UINT64_C(0xffffffffffffffff) != SFC_SW_STAT_INVALID);
+       memset(cache, 0xff, cache_count * sizeof(*cache));
+}
+
 void
 sfc_sw_xstats_get_vals(struct sfc_adapter *sa,
                       struct rte_eth_xstat *xstats,
@@ -358,11 +430,13 @@ sfc_sw_xstats_get_vals(struct sfc_adapter *sa,
 
        sfc_adapter_lock(sa);
 
+       sfc_sw_stats_clear_cache(sa);
+
        sw_xstats_offset = *nb_supported;
 
-       for (i = 0; i < sw_stats->xstats_count; i++) {
-               sfc_sw_xstat_get_values(sa, sw_stats->supp[i].descr, xstats,
-                                       xstats_count, nb_written, nb_supported);
+       for (i = 0; i < sw_stats->supp_count; i++) {
+               sfc_sw_xstat_get_values(sa, sw_stats->supp[i].descr, i,
+                               xstats, xstats_count, nb_written, nb_supported);
        }
 
        for (i = sw_xstats_offset; i < *nb_written; i++)
@@ -413,11 +487,13 @@ sfc_sw_xstats_get_vals_by_id(struct sfc_adapter *sa,
 
        sfc_adapter_lock(sa);
 
+       sfc_sw_stats_clear_cache(sa);
+
        sw_xstats_offset = *nb_supported;
 
        for (i = 0; i < sw_stats->supp_count; i++) {
-               sfc_sw_xstat_get_values_by_id(sa, sw_stats->supp[i].descr, ids,
-                                             values, n, nb_supported);
+               sfc_sw_xstat_get_values_by_id(sa, sw_stats->supp[i].descr, i,
+                                             ids, values, n, nb_supported);
        }
 
        for (i = 0; i < n; i++) {
@@ -460,6 +536,7 @@ sfc_sw_xstats_get_names_by_id(struct sfc_adapter *sa,
 static void
 sfc_sw_xstat_reset(struct sfc_adapter *sa,
                   const struct sfc_sw_stat_descr *sw_stat,
+                  unsigned int sw_stat_idx,
                   uint64_t *reset_vals)
 {
        unsigned int nb_queues;
@@ -483,7 +560,7 @@ sfc_sw_xstat_reset(struct sfc_adapter *sa,
        }
 
        for (qid = 0; qid < nb_queues; ++qid) {
-               reset_vals[qid] = sw_stat->get_val(sa, qid);
+               reset_vals[qid] = sfc_sw_stat_get_val(sa, sw_stat_idx, qid);
                if (sw_stat->provide_total)
                        *total_xstat_reset += reset_vals[qid];
        }
@@ -498,8 +575,10 @@ sfc_sw_xstats_reset(struct sfc_adapter *sa)
 
        SFC_ASSERT(sfc_adapter_is_locked(sa));
 
+       sfc_sw_stats_clear_cache(sa);
+
        for (i = 0; i < sw_stats->supp_count; i++) {
-               sfc_sw_xstat_reset(sa, sw_stats->supp[i].descr, reset_vals);
+               sfc_sw_xstat_reset(sa, sw_stats->supp[i].descr, i, reset_vals);
                reset_vals += sfc_sw_xstat_get_nb_supported(sa,
                                                       sw_stats->supp[i].descr);
        }
@@ -510,6 +589,9 @@ sfc_sw_xstats_configure(struct sfc_adapter *sa)
 {
        uint64_t **reset_vals = &sa->sw_stats.reset_vals;
        struct sfc_sw_stats *sw_stats = &sa->sw_stats;
+       unsigned int cache_count = 0;
+       uint64_t **cache =  &sa->sw_stats.cache;
+       uint64_t *stat_cache;
        size_t nb_supported = 0;
        unsigned int i;
        int rc;
@@ -524,9 +606,12 @@ sfc_sw_xstats_configure(struct sfc_adapter *sa)
        for (i = 0; i < sw_stats->supp_count; i++)
                sw_stats->supp[i].descr = &sfc_sw_stats_descr[i];
 
-       for (i = 0; i < sw_stats->supp_count; i++)
+       for (i = 0; i < sw_stats->supp_count; i++) {
                nb_supported += sfc_sw_xstat_get_nb_supported(sa,
                                                       sw_stats->supp[i].descr);
+               cache_count += sfc_sw_stat_get_queue_count(sa,
+                                                      sw_stats->supp[i].descr);
+       }
        sa->sw_stats.xstats_count = nb_supported;
 
        *reset_vals = rte_realloc(*reset_vals,
@@ -538,8 +623,25 @@ sfc_sw_xstats_configure(struct sfc_adapter *sa)
 
        memset(*reset_vals, 0, nb_supported * sizeof(**reset_vals));
 
+       *cache = rte_realloc(*cache, cache_count * sizeof(*cache), 0);
+       if (*cache == NULL) {
+               rc = ENOMEM;
+               goto fail_cache;
+       }
+       sa->sw_stats.cache_count = cache_count;
+       stat_cache = *cache;
+
+       for (i = 0; i < sw_stats->supp_count; i++) {
+               sw_stats->supp[i].cache = stat_cache;
+               stat_cache += sfc_sw_stat_get_queue_count(sa,
+                                                      sw_stats->supp[i].descr);
+       }
+
        return 0;
 
+fail_cache:
+       rte_free(*reset_vals);
+       *reset_vals = NULL;
 fail_reset_vals:
        sa->sw_stats.xstats_count = 0;
        rte_free(sw_stats->supp);
@@ -594,6 +696,8 @@ sfc_sw_xstats_init(struct sfc_adapter *sa)
        sa->sw_stats.xstats_count = 0;
        sa->sw_stats.supp = NULL;
        sa->sw_stats.supp_count = 0;
+       sa->sw_stats.cache = NULL;
+       sa->sw_stats.cache_count = 0;
        sa->sw_stats.reset_vals = NULL;
 
        return sfc_sw_xstats_alloc_queues_bitmap(sa);
@@ -603,8 +707,11 @@ void
 sfc_sw_xstats_close(struct sfc_adapter *sa)
 {
        sfc_sw_xstats_free_queues_bitmap(sa);
-       rte_free(sa->sw_stats.reset_vals);
        sa->sw_stats.reset_vals = NULL;
+       rte_free(sa->sw_stats.cache);
+       sa->sw_stats.cache = NULL;
+       sa->sw_stats.cache_count = 0;
+       rte_free(sa->sw_stats.reset_vals);
        rte_free(sa->sw_stats.supp);
        sa->sw_stats.supp = NULL;
        sa->sw_stats.supp_count = 0;