tools/perf/util/stream.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Compare and figure out the top N hottest streams
   4  * Copyright (c) 2020, Intel Corporation.
   5  * Author: Jin Yao
   6  */
   7
   8 #include <inttypes.h>
   9 #include <stdlib.h>
  10 #include <linux/zalloc.h>
  11 #include "debug.h"
  12 #include "hist.h"
  13 #include "sort.h"
  14 #include "stream.h"
  15 #include "evlist.h"
  16
  17 static void evsel_streams__delete(struct evsel_streams *es, int nr_evsel)
  18 {
  19         for (int i = 0; i < nr_evsel; i++)
  20                 zfree(&es[i].streams);
  21
  22         free(es);
  23 }
  24
  25 void evlist_streams__delete(struct evlist_streams *els)
  26 {
  27         evsel_streams__delete(els->ev_streams, els->nr_evsel);
  28         free(els);
  29 }
  30
  31 static struct evlist_streams *evlist_streams__new(int nr_evsel,
  32                                                   int nr_streams_max)
  33 {
  34         struct evlist_streams *els;
  35         struct evsel_streams *es;
  36
  37         els = zalloc(sizeof(*els));
  38         if (!els)
  39                 return NULL;
  40
  41         es = calloc(nr_evsel, sizeof(struct evsel_streams));
  42         if (!es) {
  43                 free(els);
  44                 return NULL;
  45         }
  46
  47         for (int i = 0; i < nr_evsel; i++) {
  48                 struct evsel_streams *s = &es[i];
  49
  50                 s->streams = calloc(nr_streams_max, sizeof(struct stream));
  51                 if (!s->streams)
  52                         goto err;
  53
  54                 s->nr_streams_max = nr_streams_max;
  55                 s->evsel_idx = -1;
  56         }
  57
  58         els->ev_streams = es;
  59         els->nr_evsel = nr_evsel;
  60         return els;
  61
  62 err:
  63         evsel_streams__delete(es, nr_evsel);
  64         return NULL;
  65 }
  66
  67 /*
  68  * The cnodes with high hit number are hot callchains.
  69  */
  70 static void evsel_streams__set_hot_cnode(struct evsel_streams *es,
  71                                          struct callchain_node *cnode)
  72 {
  73         int i, idx = 0;
  74         u64 hit;
  75
  76         if (es->nr_streams < es->nr_streams_max) {
  77                 i = es->nr_streams;
  78                 es->streams[i].cnode = cnode;
  79                 es->nr_streams++;
  80                 return;
  81         }
  82
  83         /*
  84          * Considering a few number of hot streams, only use simple
  85          * way to find the cnode with smallest hit number and replace.
  86          */
  87         hit = (es->streams[0].cnode)->hit;
  88         for (i = 1; i < es->nr_streams; i++) {
  89                 if ((es->streams[i].cnode)->hit < hit) {
  90                         hit = (es->streams[i].cnode)->hit;
  91                         idx = i;
  92                 }
  93         }
  94
  95         if (cnode->hit > hit)
  96                 es->streams[idx].cnode = cnode;
  97 }
  98
  99 static void update_hot_callchain(struct hist_entry *he,
 100                                  struct evsel_streams *es)
 101 {
 102         struct rb_root *root = &he->sorted_chain;
 103         struct rb_node *rb_node = rb_first(root);
 104         struct callchain_node *cnode;
 105
 106         while (rb_node) {
 107                 cnode = rb_entry(rb_node, struct callchain_node, rb_node);
 108                 evsel_streams__set_hot_cnode(es, cnode);
 109                 rb_node = rb_next(rb_node);
 110         }
 111 }
 112
 113 static void init_hot_callchain(struct hists *hists, struct evsel_streams *es)
 114 {
 115         struct rb_node *next = rb_first_cached(&hists->entries);
 116
 117         while (next) {
 118                 struct hist_entry *he;
 119
 120                 he = rb_entry(next, struct hist_entry, rb_node);
 121                 update_hot_callchain(he, es);
 122                 next = rb_next(&he->rb_node);
 123         }
 124 }
 125
 126 static int evlist__init_callchain_streams(struct evlist *evlist,
 127                                           struct evlist_streams *els)
 128 {
 129         struct evsel_streams *es = els->ev_streams;
 130         struct evsel *pos;
 131         int i = 0;
 132
 133         BUG_ON(els->nr_evsel < evlist->core.nr_entries);
 134
 135         evlist__for_each_entry(evlist, pos) {
 136                 struct hists *hists = evsel__hists(pos);
 137
 138                 hists__output_resort(hists, NULL);
 139                 init_hot_callchain(hists, &es[i]);
 140                 es[i].evsel_idx = pos->idx;
 141                 i++;
 142         }
 143
 144         return 0;
 145 }
 146
 147 struct evlist_streams *evlist__create_streams(struct evlist *evlist,
 148                                               int nr_streams_max)
 149 {
 150         int nr_evsel = evlist->core.nr_entries, ret = -1;
 151         struct evlist_streams *els = evlist_streams__new(nr_evsel,
 152                                                          nr_streams_max);
 153
 154         if (!els)
 155                 return NULL;
 156
 157         ret = evlist__init_callchain_streams(evlist, els);
 158         if (ret) {
 159                 evlist_streams__delete(els);
 160                 return NULL;
 161         }
 162
 163         return els;
 164 }
 165
 166 struct evsel_streams *evsel_streams__entry(struct evlist_streams *els,
 167                                            int evsel_idx)
 168 {
 169         struct evsel_streams *es = els->ev_streams;
 170
 171         for (int i = 0; i < els->nr_evsel; i++) {
 172                 if (es[i].evsel_idx == evsel_idx)
 173                         return &es[i];
 174         }
 175
 176         return NULL;
 177 }