lib/graph/graph_stats.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2020 Marvell International Ltd.
   3  */
   4
   5 #include <fnmatch.h>
   6 #include <stdbool.h>
   7
   8 #include <rte_common.h>
   9 #include <rte_errno.h>
  10 #include <rte_malloc.h>
  11
  12 #include "graph_private.h"
  13
  14 /* Capture all graphs of cluster */
  15 struct cluster {
  16         rte_graph_t nb_graphs;
  17         rte_graph_t size;
  18
  19         struct graph **graphs;
  20 };
  21
  22 /* Capture same node ID across cluster  */
  23 struct cluster_node {
  24         struct rte_graph_cluster_node_stats stat;
  25         rte_node_t nb_nodes;
  26
  27         struct rte_node *nodes[];
  28 };
  29
  30 struct rte_graph_cluster_stats {
  31         /* Header */
  32         rte_graph_cluster_stats_cb_t fn;
  33         uint32_t cluster_node_size; /* Size of struct cluster_node */
  34         rte_node_t max_nodes;
  35         int socket_id;
  36         void *cookie;
  37         size_t sz;
  38
  39         struct cluster_node clusters[];
  40 } __rte_cache_aligned;
  41
  42 #define boarder()                                                              \
  43         fprintf(f, "+-------------------------------+---------------+--------" \
  44                    "-------+---------------+---------------+---------------+-" \
  45                    "----------+\n")
  46
  47 static inline void
  48 print_banner(FILE *f)
  49 {
  50         boarder();
  51         fprintf(f, "%-32s%-16s%-16s%-16s%-16s%-16s%-16s\n", "|Node", "|calls",
  52                 "|objs", "|realloc_count", "|objs/call", "|objs/sec(10E6)",
  53                 "|cycles/call|");
  54         boarder();
  55 }
  56
  57 static inline void
  58 print_node(FILE *f, const struct rte_graph_cluster_node_stats *stat)
  59 {
  60         double objs_per_call, objs_per_sec, cycles_per_call, ts_per_hz;
  61         const uint64_t prev_calls = stat->prev_calls;
  62         const uint64_t prev_objs = stat->prev_objs;
  63         const uint64_t cycles = stat->cycles;
  64         const uint64_t calls = stat->calls;
  65         const uint64_t objs = stat->objs;
  66         uint64_t call_delta;
  67
  68         call_delta = calls - prev_calls;
  69         objs_per_call =
  70                 call_delta ? (double)((objs - prev_objs) / call_delta) : 0;
  71         cycles_per_call =
  72                 call_delta ? (double)((cycles - stat->prev_cycles) / call_delta)
  73                            : 0;
  74         ts_per_hz = (double)((stat->ts - stat->prev_ts) / stat->hz);
  75         objs_per_sec = ts_per_hz ? (objs - prev_objs) / ts_per_hz : 0;
  76         objs_per_sec /= 1000000;
  77
  78         fprintf(f,
  79                 "|%-31s|%-15" PRIu64 "|%-15" PRIu64 "|%-15" PRIu64
  80                 "|%-15.3f|%-15.6f|%-11.4f|\n",
  81                 stat->name, calls, objs, stat->realloc_count, objs_per_call,
  82                 objs_per_sec, cycles_per_call);
  83 }
  84
  85 static int
  86 graph_cluster_stats_cb(bool is_first, bool is_last, void *cookie,
  87                        const struct rte_graph_cluster_node_stats *stat)
  88 {
  89         FILE *f = cookie;
  90
  91         if (unlikely(is_first))
  92                 print_banner(f);
  93         if (stat->objs)
  94                 print_node(f, stat);
  95         if (unlikely(is_last))
  96                 boarder();
  97
  98         return 0;
  99 };
 100
 101 static struct rte_graph_cluster_stats *
 102 stats_mem_init(struct cluster *cluster,
 103                const struct rte_graph_cluster_stats_param *prm)
 104 {
 105         size_t sz = sizeof(struct rte_graph_cluster_stats);
 106         struct rte_graph_cluster_stats *stats;
 107         rte_graph_cluster_stats_cb_t fn;
 108         int socket_id = prm->socket_id;
 109         uint32_t cluster_node_size;
 110
 111         /* Fix up callback */
 112         fn = prm->fn;
 113         if (fn == NULL)
 114                 fn = graph_cluster_stats_cb;
 115
 116         cluster_node_size = sizeof(struct cluster_node);
 117         /* For a given cluster, max nodes will be the max number of graphs */
 118         cluster_node_size += cluster->nb_graphs * sizeof(struct rte_node *);
 119         cluster_node_size = RTE_ALIGN(cluster_node_size, RTE_CACHE_LINE_SIZE);
 120
 121         stats = realloc(NULL, sz);
 122         if (stats) {
 123                 memset(stats, 0, sz);
 124                 stats->fn = fn;
 125                 stats->cluster_node_size = cluster_node_size;
 126                 stats->max_nodes = 0;
 127                 stats->socket_id = socket_id;
 128                 stats->cookie = prm->cookie;
 129                 stats->sz = sz;
 130         }
 131
 132         return stats;
 133 }
 134
 135 static int
 136 stats_mem_populate(struct rte_graph_cluster_stats **stats_in,
 137                    struct rte_graph *graph, struct graph_node *graph_node)
 138 {
 139         struct rte_graph_cluster_stats *stats = *stats_in;
 140         rte_node_t id = graph_node->node->id;
 141         struct cluster_node *cluster;
 142         struct rte_node *node;
 143         rte_node_t count;
 144
 145         cluster = stats->clusters;
 146
 147         /* Iterate over cluster node array to find node ID match */
 148         for (count = 0; count < stats->max_nodes; count++) {
 149                 /* Found an existing node in the reel */
 150                 if (cluster->stat.id == id) {
 151                         node = graph_node_id_to_ptr(graph, id);
 152                         if (node == NULL)
 153                                 SET_ERR_JMP(
 154                                         ENOENT, err,
 155                                         "Failed to find node %s in graph %s",
 156                                         graph_node->node->name, graph->name);
 157
 158                         cluster->nodes[cluster->nb_nodes++] = node;
 159                         return 0;
 160                 }
 161                 cluster = RTE_PTR_ADD(cluster, stats->cluster_node_size);
 162         }
 163
 164         /* Hey, it is a new node, allocate space for it in the reel */
 165         stats = realloc(stats, stats->sz + stats->cluster_node_size);
 166         if (stats == NULL)
 167                 SET_ERR_JMP(ENOMEM, err, "Realloc failed");
 168         *stats_in = NULL;
 169
 170         /* Clear the new struct cluster_node area */
 171         cluster = RTE_PTR_ADD(stats, stats->sz),
 172         memset(cluster, 0, stats->cluster_node_size);
 173         memcpy(cluster->stat.name, graph_node->node->name, RTE_NODE_NAMESIZE);
 174         cluster->stat.id = graph_node->node->id;
 175         cluster->stat.hz = rte_get_timer_hz();
 176         node = graph_node_id_to_ptr(graph, id);
 177         if (node == NULL)
 178                 SET_ERR_JMP(ENOENT, free, "Failed to find node %s in graph %s",
 179                             graph_node->node->name, graph->name);
 180         cluster->nodes[cluster->nb_nodes++] = node;
 181
 182         stats->sz += stats->cluster_node_size;
 183         stats->max_nodes++;
 184         *stats_in = stats;
 185
 186         return 0;
 187 free:
 188         free(stats);
 189 err:
 190         return -rte_errno;
 191 }
 192
 193 static void
 194 stats_mem_fini(struct rte_graph_cluster_stats *stats)
 195 {
 196         free(stats);
 197 }
 198
 199 static void
 200 cluster_init(struct cluster *cluster)
 201 {
 202         memset(cluster, 0, sizeof(*cluster));
 203 }
 204
 205 static int
 206 cluster_add(struct cluster *cluster, struct graph *graph)
 207 {
 208         rte_graph_t count;
 209         size_t sz;
 210
 211         /* Skip the if graph is already added to cluster */
 212         for (count = 0; count < cluster->nb_graphs; count++)
 213                 if (cluster->graphs[count] == graph)
 214                         return 0;
 215
 216         /* Expand the cluster if required to store graph objects */
 217         if (cluster->nb_graphs + 1 > cluster->size) {
 218                 cluster->size = RTE_MAX(1, cluster->size * 2);
 219                 sz = sizeof(struct graph *) * cluster->size;
 220                 cluster->graphs = realloc(cluster->graphs, sz);
 221                 if (cluster->graphs == NULL)
 222                         SET_ERR_JMP(ENOMEM, free, "Failed to realloc");
 223         }
 224
 225         /* Add graph to cluster */
 226         cluster->graphs[cluster->nb_graphs++] = graph;
 227         return 0;
 228
 229 free:
 230         return -rte_errno;
 231 }
 232
 233 static void
 234 cluster_fini(struct cluster *cluster)
 235 {
 236         if (cluster->graphs)
 237                 free(cluster->graphs);
 238 }
 239
 240 static int
 241 expand_pattern_to_cluster(struct cluster *cluster, const char *pattern)
 242 {
 243         struct graph_head *graph_head = graph_list_head_get();
 244         struct graph *graph;
 245         bool found = false;
 246
 247         /* Check for pattern match */
 248         STAILQ_FOREACH(graph, graph_head, next) {
 249                 if (fnmatch(pattern, graph->name, 0) == 0) {
 250                         if (cluster_add(cluster, graph))
 251                                 goto fail;
 252                         found = true;
 253                 }
 254         }
 255         if (found == false)
 256                 SET_ERR_JMP(EFAULT, fail, "Pattern %s graph not found",
 257                             pattern);
 258
 259         return 0;
 260 fail:
 261         return -rte_errno;
 262 }
 263
 264 struct rte_graph_cluster_stats *
 265 rte_graph_cluster_stats_create(const struct rte_graph_cluster_stats_param *prm)
 266 {
 267         struct rte_graph_cluster_stats *stats, *rc = NULL;
 268         struct graph_node *graph_node;
 269         struct cluster cluster;
 270         struct graph *graph;
 271         const char *pattern;
 272         rte_graph_t i;
 273
 274         /* Sanity checks */
 275         if (!rte_graph_has_stats_feature())
 276                 SET_ERR_JMP(EINVAL, fail, "Stats feature is not enabled");
 277
 278         if (prm == NULL)
 279                 SET_ERR_JMP(EINVAL, fail, "Invalid param");
 280
 281         if (prm->graph_patterns == NULL || prm->nb_graph_patterns == 0)
 282                 SET_ERR_JMP(EINVAL, fail, "Invalid graph param");
 283
 284         cluster_init(&cluster);
 285
 286         graph_spinlock_lock();
 287         /* Expand graph pattern and add the graph to the cluster */
 288         for (i = 0; i < prm->nb_graph_patterns; i++) {
 289                 pattern = prm->graph_patterns[i];
 290                 if (expand_pattern_to_cluster(&cluster, pattern))
 291                         goto bad_pattern;
 292         }
 293
 294         /* Alloc the stats memory */
 295         stats = stats_mem_init(&cluster, prm);
 296         if (stats == NULL)
 297                 SET_ERR_JMP(ENOMEM, bad_pattern, "Failed alloc stats memory");
 298
 299         /* Iterate over M(Graph) x N (Nodes in graph) */
 300         for (i = 0; i < cluster.nb_graphs; i++) {
 301                 graph = cluster.graphs[i];
 302                 STAILQ_FOREACH(graph_node, &graph->node_list, next) {
 303                         struct rte_graph *graph_fp = graph->graph;
 304                         if (stats_mem_populate(&stats, graph_fp, graph_node))
 305                                 goto realloc_fail;
 306                 }
 307         }
 308
 309         /* Finally copy to hugepage memory to avoid pressure on rte_realloc */
 310         rc = rte_malloc_socket(NULL, stats->sz, 0, stats->socket_id);
 311         if (rc)
 312                 rte_memcpy(rc, stats, stats->sz);
 313         else
 314                 SET_ERR_JMP(ENOMEM, realloc_fail, "rte_malloc failed");
 315
 316 realloc_fail:
 317         stats_mem_fini(stats);
 318 bad_pattern:
 319         graph_spinlock_unlock();
 320         cluster_fini(&cluster);
 321 fail:
 322         return rc;
 323 }
 324
 325 void
 326 rte_graph_cluster_stats_destroy(struct rte_graph_cluster_stats *stat)
 327 {
 328         return rte_free(stat);
 329 }
 330
 331 static inline void
 332 cluster_node_arregate_stats(struct cluster_node *cluster)
 333 {
 334         uint64_t calls = 0, cycles = 0, objs = 0, realloc_count = 0;
 335         struct rte_graph_cluster_node_stats *stat = &cluster->stat;
 336         struct rte_node *node;
 337         rte_node_t count;
 338
 339         for (count = 0; count < cluster->nb_nodes; count++) {
 340                 node = cluster->nodes[count];
 341
 342                 calls += node->total_calls;
 343                 objs += node->total_objs;
 344                 cycles += node->total_cycles;
 345                 realloc_count += node->realloc_count;
 346         }
 347
 348         stat->calls = calls;
 349         stat->objs = objs;
 350         stat->cycles = cycles;
 351         stat->ts = rte_get_timer_cycles();
 352         stat->realloc_count = realloc_count;
 353 }
 354
 355 static inline void
 356 cluster_node_store_prev_stats(struct cluster_node *cluster)
 357 {
 358         struct rte_graph_cluster_node_stats *stat = &cluster->stat;
 359
 360         stat->prev_ts = stat->ts;
 361         stat->prev_calls = stat->calls;
 362         stat->prev_objs = stat->objs;
 363         stat->prev_cycles = stat->cycles;
 364 }
 365
 366 void
 367 rte_graph_cluster_stats_get(struct rte_graph_cluster_stats *stat, bool skip_cb)
 368 {
 369         struct cluster_node *cluster;
 370         rte_node_t count;
 371         int rc = 0;
 372
 373         cluster = stat->clusters;
 374
 375         for (count = 0; count < stat->max_nodes; count++) {
 376                 cluster_node_arregate_stats(cluster);
 377                 if (!skip_cb)
 378                         rc = stat->fn(!count, (count == stat->max_nodes - 1),
 379                                       stat->cookie, &cluster->stat);
 380                 cluster_node_store_prev_stats(cluster);
 381                 if (rc)
 382                         break;
 383                 cluster = RTE_PTR_ADD(cluster, stat->cluster_node_size);
 384         }
 385 }
 386
 387 void
 388 rte_graph_cluster_stats_reset(struct rte_graph_cluster_stats *stat)
 389 {
 390         struct cluster_node *cluster;
 391         rte_node_t count;
 392
 393         cluster = stat->clusters;
 394
 395         for (count = 0; count < stat->max_nodes; count++) {
 396                 struct rte_graph_cluster_node_stats *node = &cluster->stat;
 397
 398                 node->ts = 0;
 399                 node->calls = 0;
 400                 node->objs = 0;
 401                 node->cycles = 0;
 402                 node->prev_ts = 0;
 403                 node->prev_calls = 0;
 404                 node->prev_objs = 0;
 405                 node->prev_cycles = 0;
 406                 node->realloc_count = 0;
 407                 cluster = RTE_PTR_ADD(cluster, stat->cluster_node_size);
 408         }
 409 }