xref: /linux/tools/perf/util/stream.c (revision 24bce201d79807b668bf9d9e0aca801c5c0d5f78) 
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 	es->streams_hits = callchain_total_hits(hists);
126 }
127 
128 static int evlist__init_callchain_streams(struct evlist *evlist,
129 					  struct evlist_streams *els)
130 {
131 	struct evsel_streams *es = els->ev_streams;
132 	struct evsel *pos;
133 	int i = 0;
134 
135 	BUG_ON(els->nr_evsel < evlist->core.nr_entries);
136 
137 	evlist__for_each_entry(evlist, pos) {
138 		struct hists *hists = evsel__hists(pos);
139 
140 		hists__output_resort(hists, NULL);
141 		init_hot_callchain(hists, &es[i]);
142 		es[i].evsel_idx = pos->core.idx;
143 		i++;
144 	}
145 
146 	return 0;
147 }
148 
149 struct evlist_streams *evlist__create_streams(struct evlist *evlist,
150 					      int nr_streams_max)
151 {
152 	int nr_evsel = evlist->core.nr_entries, ret = -1;
153 	struct evlist_streams *els = evlist_streams__new(nr_evsel,
154 							 nr_streams_max);
155 
156 	if (!els)
157 		return NULL;
158 
159 	ret = evlist__init_callchain_streams(evlist, els);
160 	if (ret) {
161 		evlist_streams__delete(els);
162 		return NULL;
163 	}
164 
165 	return els;
166 }
167 
168 struct evsel_streams *evsel_streams__entry(struct evlist_streams *els,
169 					   int evsel_idx)
170 {
171 	struct evsel_streams *es = els->ev_streams;
172 
173 	for (int i = 0; i < els->nr_evsel; i++) {
174 		if (es[i].evsel_idx == evsel_idx)
175 			return &es[i];
176 	}
177 
178 	return NULL;
179 }
180 
181 static struct stream *stream__callchain_match(struct stream *base_stream,
182 					      struct evsel_streams *es_pair)
183 {
184 	for (int i = 0; i < es_pair->nr_streams; i++) {
185 		struct stream *pair_stream = &es_pair->streams[i];
186 
187 		if (callchain_cnode_matched(base_stream->cnode,
188 					    pair_stream->cnode)) {
189 			return pair_stream;
190 		}
191 	}
192 
193 	return NULL;
194 }
195 
196 static struct stream *stream__match(struct stream *base_stream,
197 				    struct evsel_streams *es_pair)
198 {
199 	return stream__callchain_match(base_stream, es_pair);
200 }
201 
202 static void stream__link(struct stream *base_stream, struct stream *pair_stream)
203 {
204 	base_stream->pair_cnode = pair_stream->cnode;
205 	pair_stream->pair_cnode = base_stream->cnode;
206 }
207 
208 void evsel_streams__match(struct evsel_streams *es_base,
209 			  struct evsel_streams *es_pair)
210 {
211 	for (int i = 0; i < es_base->nr_streams; i++) {
212 		struct stream *base_stream = &es_base->streams[i];
213 		struct stream *pair_stream;
214 
215 		pair_stream = stream__match(base_stream, es_pair);
216 		if (pair_stream)
217 			stream__link(base_stream, pair_stream);
218 	}
219 }
220 
221 static void print_callchain_pair(struct stream *base_stream, int idx,
222 				 struct evsel_streams *es_base,
223 				 struct evsel_streams *es_pair)
224 {
225 	struct callchain_node *base_cnode = base_stream->cnode;
226 	struct callchain_node *pair_cnode = base_stream->pair_cnode;
227 	struct callchain_list *base_chain, *pair_chain;
228 	char buf1[512], buf2[512], cbuf1[256], cbuf2[256];
229 	char *s1, *s2;
230 	double pct;
231 
232 	printf("\nhot chain pair %d:\n", idx);
233 
234 	pct = (double)base_cnode->hit / (double)es_base->streams_hits;
235 	scnprintf(buf1, sizeof(buf1), "cycles: %ld, hits: %.2f%%",
236 		  callchain_avg_cycles(base_cnode), pct * 100.0);
237 
238 	pct = (double)pair_cnode->hit / (double)es_pair->streams_hits;
239 	scnprintf(buf2, sizeof(buf2), "cycles: %ld, hits: %.2f%%",
240 		  callchain_avg_cycles(pair_cnode), pct * 100.0);
241 
242 	printf("%35s\t%35s\n", buf1, buf2);
243 
244 	printf("%35s\t%35s\n",
245 	       "---------------------------",
246 	       "--------------------------");
247 
248 	pair_chain = list_first_entry(&pair_cnode->val,
249 				      struct callchain_list,
250 				      list);
251 
252 	list_for_each_entry(base_chain, &base_cnode->val, list) {
253 		if (&pair_chain->list == &pair_cnode->val)
254 			return;
255 
256 		s1 = callchain_list__sym_name(base_chain, cbuf1, sizeof(cbuf1),
257 					      false);
258 		s2 = callchain_list__sym_name(pair_chain, cbuf2, sizeof(cbuf2),
259 					      false);
260 
261 		scnprintf(buf1, sizeof(buf1), "%35s\t%35s", s1, s2);
262 		printf("%s\n", buf1);
263 		pair_chain = list_next_entry(pair_chain, list);
264 	}
265 }
266 
267 static void print_stream_callchain(struct stream *stream, int idx,
268 				   struct evsel_streams *es, bool pair)
269 {
270 	struct callchain_node *cnode = stream->cnode;
271 	struct callchain_list *chain;
272 	char buf[512], cbuf[256], *s;
273 	double pct;
274 
275 	printf("\nhot chain %d:\n", idx);
276 
277 	pct = (double)cnode->hit / (double)es->streams_hits;
278 	scnprintf(buf, sizeof(buf), "cycles: %ld, hits: %.2f%%",
279 		  callchain_avg_cycles(cnode), pct * 100.0);
280 
281 	if (pair) {
282 		printf("%35s\t%35s\n", "", buf);
283 		printf("%35s\t%35s\n",
284 		       "", "--------------------------");
285 	} else {
286 		printf("%35s\n", buf);
287 		printf("%35s\n", "--------------------------");
288 	}
289 
290 	list_for_each_entry(chain, &cnode->val, list) {
291 		s = callchain_list__sym_name(chain, cbuf, sizeof(cbuf), false);
292 
293 		if (pair)
294 			scnprintf(buf, sizeof(buf), "%35s\t%35s", "", s);
295 		else
296 			scnprintf(buf, sizeof(buf), "%35s", s);
297 
298 		printf("%s\n", buf);
299 	}
300 }
301 
302 static void callchain_streams_report(struct evsel_streams *es_base,
303 				     struct evsel_streams *es_pair)
304 {
305 	struct stream *base_stream;
306 	int i, idx = 0;
307 
308 	printf("[ Matched hot streams ]\n");
309 	for (i = 0; i < es_base->nr_streams; i++) {
310 		base_stream = &es_base->streams[i];
311 		if (base_stream->pair_cnode) {
312 			print_callchain_pair(base_stream, ++idx,
313 					     es_base, es_pair);
314 		}
315 	}
316 
317 	idx = 0;
318 	printf("\n[ Hot streams in old perf data only ]\n");
319 	for (i = 0; i < es_base->nr_streams; i++) {
320 		base_stream = &es_base->streams[i];
321 		if (!base_stream->pair_cnode) {
322 			print_stream_callchain(base_stream, ++idx,
323 					       es_base, false);
324 		}
325 	}
326 
327 	idx = 0;
328 	printf("\n[ Hot streams in new perf data only ]\n");
329 	for (i = 0; i < es_pair->nr_streams; i++) {
330 		base_stream = &es_pair->streams[i];
331 		if (!base_stream->pair_cnode) {
332 			print_stream_callchain(base_stream, ++idx,
333 					       es_pair, true);
334 		}
335 	}
336 }
337 
338 void evsel_streams__report(struct evsel_streams *es_base,
339 			   struct evsel_streams *es_pair)
340 {
341 	return callchain_streams_report(es_base, es_pair);
342 }
343