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
17static 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
25void evlist_streams__delete(struct evlist_streams *els)
26{
27 evsel_streams__delete(es: els->ev_streams, nr_evsel: els->nr_evsel);
28 free(els);
29}
30
31static 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 }
56
57 els->ev_streams = es;
58 els->nr_evsel = nr_evsel;
59 return els;
60
61err:
62 evsel_streams__delete(es, nr_evsel);
63 return NULL;
64}
65
66/*
67 * The cnodes with high hit number are hot callchains.
68 */
69static void evsel_streams__set_hot_cnode(struct evsel_streams *es,
70 struct callchain_node *cnode)
71{
72 int i, idx = 0;
73 u64 hit;
74
75 if (es->nr_streams < es->nr_streams_max) {
76 i = es->nr_streams;
77 es->streams[i].cnode = cnode;
78 es->nr_streams++;
79 return;
80 }
81
82 /*
83 * Considering a few number of hot streams, only use simple
84 * way to find the cnode with smallest hit number and replace.
85 */
86 hit = (es->streams[0].cnode)->hit;
87 for (i = 1; i < es->nr_streams; i++) {
88 if ((es->streams[i].cnode)->hit < hit) {
89 hit = (es->streams[i].cnode)->hit;
90 idx = i;
91 }
92 }
93
94 if (cnode->hit > hit)
95 es->streams[idx].cnode = cnode;
96}
97
98static void update_hot_callchain(struct hist_entry *he,
99 struct evsel_streams *es)
100{
101 struct rb_root *root = &he->sorted_chain;
102 struct rb_node *rb_node = rb_first(root);
103 struct callchain_node *cnode;
104
105 while (rb_node) {
106 cnode = rb_entry(rb_node, struct callchain_node, rb_node);
107 evsel_streams__set_hot_cnode(es, cnode);
108 rb_node = rb_next(rb_node);
109 }
110}
111
112static void init_hot_callchain(struct hists *hists, struct evsel_streams *es)
113{
114 struct rb_node *next = rb_first_cached(&hists->entries);
115
116 while (next) {
117 struct hist_entry *he;
118
119 he = rb_entry(next, struct hist_entry, rb_node);
120 update_hot_callchain(he, es);
121 next = rb_next(&he->rb_node);
122 }
123
124 es->streams_hits = callchain_total_hits(hists);
125}
126
127static int evlist__init_callchain_streams(struct evlist *evlist,
128 struct evlist_streams *els)
129{
130 struct evsel_streams *es = els->ev_streams;
131 struct evsel *pos;
132 int i = 0;
133
134 BUG_ON(els->nr_evsel < evlist->core.nr_entries);
135
136 evlist__for_each_entry(evlist, pos) {
137 struct hists *hists = evsel__hists(evsel: pos);
138
139 hists__output_resort(hists, NULL);
140 init_hot_callchain(hists, es: &es[i]);
141 es[i].evsel = pos;
142 i++;
143 }
144
145 return 0;
146}
147
148struct evlist_streams *evlist__create_streams(struct evlist *evlist,
149 int nr_streams_max)
150{
151 int nr_evsel = evlist->core.nr_entries, ret = -1;
152 struct evlist_streams *els = evlist_streams__new(nr_evsel,
153 nr_streams_max);
154
155 if (!els)
156 return NULL;
157
158 ret = evlist__init_callchain_streams(evlist, els);
159 if (ret) {
160 evlist_streams__delete(els);
161 return NULL;
162 }
163
164 return els;
165}
166
167struct evsel_streams *evsel_streams__entry(struct evlist_streams *els,
168 const struct evsel *evsel)
169{
170 struct evsel_streams *es = els->ev_streams;
171
172 for (int i = 0; i < els->nr_evsel; i++) {
173 if (es[i].evsel == evsel)
174 return &es[i];
175 }
176
177 return NULL;
178}
179
180static struct stream *stream__callchain_match(struct stream *base_stream,
181 struct evsel_streams *es_pair)
182{
183 for (int i = 0; i < es_pair->nr_streams; i++) {
184 struct stream *pair_stream = &es_pair->streams[i];
185
186 if (callchain_cnode_matched(base_cnode: base_stream->cnode,
187 pair_cnode: pair_stream->cnode)) {
188 return pair_stream;
189 }
190 }
191
192 return NULL;
193}
194
195static struct stream *stream__match(struct stream *base_stream,
196 struct evsel_streams *es_pair)
197{
198 return stream__callchain_match(base_stream, es_pair);
199}
200
201static void stream__link(struct stream *base_stream, struct stream *pair_stream)
202{
203 base_stream->pair_cnode = pair_stream->cnode;
204 pair_stream->pair_cnode = base_stream->cnode;
205}
206
207void evsel_streams__match(struct evsel_streams *es_base,
208 struct evsel_streams *es_pair)
209{
210 for (int i = 0; i < es_base->nr_streams; i++) {
211 struct stream *base_stream = &es_base->streams[i];
212 struct stream *pair_stream;
213
214 pair_stream = stream__match(base_stream, es_pair);
215 if (pair_stream)
216 stream__link(base_stream, pair_stream);
217 }
218}
219
220static void print_callchain_pair(struct stream *base_stream, int idx,
221 struct evsel_streams *es_base,
222 struct evsel_streams *es_pair)
223{
224 struct callchain_node *base_cnode = base_stream->cnode;
225 struct callchain_node *pair_cnode = base_stream->pair_cnode;
226 struct callchain_list *base_chain, *pair_chain;
227 char buf1[512], buf2[512], cbuf1[256], cbuf2[256];
228 char *s1, *s2;
229 double pct;
230
231 printf("\nhot chain pair %d:\n", idx);
232
233 pct = (double)base_cnode->hit / (double)es_base->streams_hits;
234 scnprintf(buf: buf1, size: sizeof(buf1), fmt: "cycles: %ld, hits: %.2f%%",
235 callchain_avg_cycles(cnode: base_cnode), pct * 100.0);
236
237 pct = (double)pair_cnode->hit / (double)es_pair->streams_hits;
238 scnprintf(buf: buf2, size: sizeof(buf2), fmt: "cycles: %ld, hits: %.2f%%",
239 callchain_avg_cycles(cnode: pair_cnode), pct * 100.0);
240
241 printf("%35s\t%35s\n", buf1, buf2);
242
243 printf("%35s\t%35s\n",
244 "---------------------------",
245 "--------------------------");
246
247 pair_chain = list_first_entry(&pair_cnode->val,
248 struct callchain_list,
249 list);
250
251 list_for_each_entry(base_chain, &base_cnode->val, list) {
252 if (&pair_chain->list == &pair_cnode->val)
253 return;
254
255 s1 = callchain_list__sym_name(cl: base_chain, bf: cbuf1, bfsize: sizeof(cbuf1),
256 show_dso: false);
257 s2 = callchain_list__sym_name(cl: pair_chain, bf: cbuf2, bfsize: sizeof(cbuf2),
258 show_dso: false);
259
260 scnprintf(buf: buf1, size: sizeof(buf1), fmt: "%35s\t%35s", s1, s2);
261 printf("%s\n", buf1);
262 pair_chain = list_next_entry(pair_chain, list);
263 }
264}
265
266static void print_stream_callchain(struct stream *stream, int idx,
267 struct evsel_streams *es, bool pair)
268{
269 struct callchain_node *cnode = stream->cnode;
270 struct callchain_list *chain;
271 char buf[512], cbuf[256], *s;
272 double pct;
273
274 printf("\nhot chain %d:\n", idx);
275
276 pct = (double)cnode->hit / (double)es->streams_hits;
277 scnprintf(buf, size: sizeof(buf), fmt: "cycles: %ld, hits: %.2f%%",
278 callchain_avg_cycles(cnode), pct * 100.0);
279
280 if (pair) {
281 printf("%35s\t%35s\n", "", buf);
282 printf("%35s\t%35s\n",
283 "", "--------------------------");
284 } else {
285 printf("%35s\n", buf);
286 printf("%35s\n", "--------------------------");
287 }
288
289 list_for_each_entry(chain, &cnode->val, list) {
290 s = callchain_list__sym_name(cl: chain, bf: cbuf, bfsize: sizeof(cbuf), show_dso: false);
291
292 if (pair)
293 scnprintf(buf, size: sizeof(buf), fmt: "%35s\t%35s", "", s);
294 else
295 scnprintf(buf, size: sizeof(buf), fmt: "%35s", s);
296
297 printf("%s\n", buf);
298 }
299}
300
301static void callchain_streams_report(struct evsel_streams *es_base,
302 struct evsel_streams *es_pair)
303{
304 struct stream *base_stream;
305 int i, idx = 0;
306
307 printf("[ Matched hot streams ]\n");
308 for (i = 0; i < es_base->nr_streams; i++) {
309 base_stream = &es_base->streams[i];
310 if (base_stream->pair_cnode) {
311 print_callchain_pair(base_stream, idx: ++idx,
312 es_base, es_pair);
313 }
314 }
315
316 idx = 0;
317 printf("\n[ Hot streams in old perf data only ]\n");
318 for (i = 0; i < es_base->nr_streams; i++) {
319 base_stream = &es_base->streams[i];
320 if (!base_stream->pair_cnode) {
321 print_stream_callchain(stream: base_stream, idx: ++idx,
322 es: es_base, pair: false);
323 }
324 }
325
326 idx = 0;
327 printf("\n[ Hot streams in new perf data only ]\n");
328 for (i = 0; i < es_pair->nr_streams; i++) {
329 base_stream = &es_pair->streams[i];
330 if (!base_stream->pair_cnode) {
331 print_stream_callchain(stream: base_stream, idx: ++idx,
332 es: es_pair, pair: true);
333 }
334 }
335}
336
337void evsel_streams__report(struct evsel_streams *es_base,
338 struct evsel_streams *es_pair)
339{
340 return callchain_streams_report(es_base, es_pair);
341}
342

source code of linux/tools/perf/util/stream.c