tools/perf/util/stream.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Compare and figure out the top N hottest streams
  * Copyright (c) 2020, Intel Corporation.
  * Author: Jin Yao
  */

 #include <inttypes.h>
 #include <stdlib.h>
 #include <linux/zalloc.h>
 #include "debug.h"
 #include "hist.h"
 #include "sort.h"
 #include "stream.h"
 #include "evlist.h"

 static void evsel_streams__delete(struct evsel_streams *es, int nr_evsel)
 {
 	for (int i = 0; i < nr_evsel; i++)
 		zfree(&es[i].streams);

 	free(es);
 }

 void evlist_streams__delete(struct evlist_streams *els)
 {
 	evsel_streams__delete(els->ev_streams, els->nr_evsel);
 	free(els);
 }

 static struct evlist_streams *evlist_streams__new(int nr_evsel,
 						  int nr_streams_max)
 {
 	struct evlist_streams *els;
 	struct evsel_streams *es;

 	els = zalloc(sizeof(*els));
 	if (!els)
 		return NULL;

 	es = calloc(nr_evsel, sizeof(struct evsel_streams));
 	if (!es) {
 		free(els);
 		return NULL;
 	}

 	for (int i = 0; i < nr_evsel; i++) {
 		struct evsel_streams *s = &es[i];

 		s->streams = calloc(nr_streams_max, sizeof(struct stream));
 		if (!s->streams)
 			goto err;

 		s->nr_streams_max = nr_streams_max;
 		s->evsel_idx = -1;
 	}

 	els->ev_streams = es;
 	els->nr_evsel = nr_evsel;
 	return els;

 err:
 	evsel_streams__delete(es, nr_evsel);
 	return NULL;
 }

 /*
  * The cnodes with high hit number are hot callchains.
  */
 static void evsel_streams__set_hot_cnode(struct evsel_streams *es,
 					 struct callchain_node *cnode)
 {
 	int i, idx = 0;
 	u64 hit;

 	if (es->nr_streams < es->nr_streams_max) {
 		i = es->nr_streams;
 		es->streams[i].cnode = cnode;
 		es->nr_streams++;
 		return;
 	}

 	/*
 	 * Considering a few number of hot streams, only use simple
 	 * way to find the cnode with smallest hit number and replace.
 	 */
 	hit = (es->streams[0].cnode)->hit;
 	for (i = 1; i < es->nr_streams; i++) {
 		if ((es->streams[i].cnode)->hit < hit) {
 			hit = (es->streams[i].cnode)->hit;
 			idx = i;
 		}
 	}

 	if (cnode->hit > hit)
 		es->streams[idx].cnode = cnode;
 }

 static void update_hot_callchain(struct hist_entry *he,
 				 struct evsel_streams *es)
 {
 	struct rb_root *root = &he->sorted_chain;
 	struct rb_node *rb_node = rb_first(root);
 	struct callchain_node *cnode;

 	while (rb_node) {
 		cnode = rb_entry(rb_node, struct callchain_node, rb_node);
 		evsel_streams__set_hot_cnode(es, cnode);
 		rb_node = rb_next(rb_node);
 	}
 }

 static void init_hot_callchain(struct hists *hists, struct evsel_streams *es)
 {
 	struct rb_node *next = rb_first_cached(&hists->entries);

 	while (next) {
 		struct hist_entry *he;

 		he = rb_entry(next, struct hist_entry, rb_node);
 		update_hot_callchain(he, es);
 		next = rb_next(&he->rb_node);
 	}

 	es->streams_hits = callchain_total_hits(hists);
 }

 static int evlist__init_callchain_streams(struct evlist *evlist,
 					  struct evlist_streams *els)
 {
 	struct evsel_streams *es = els->ev_streams;
 	struct evsel *pos;
 	int i = 0;

 	BUG_ON(els->nr_evsel < evlist->core.nr_entries);

 	evlist__for_each_entry(evlist, pos) {
 		struct hists *hists = evsel__hists(pos);

 		hists__output_resort(hists, NULL);
 		init_hot_callchain(hists, &es[i]);
 		es[i].evsel_idx = pos->core.idx;
 		i++;
 	}

 	return 0;
 }

 struct evlist_streams *evlist__create_streams(struct evlist *evlist,
 					      int nr_streams_max)
 {
 	int nr_evsel = evlist->core.nr_entries, ret = -1;
 	struct evlist_streams *els = evlist_streams__new(nr_evsel,
 							 nr_streams_max);

 	if (!els)
 		return NULL;

 	ret = evlist__init_callchain_streams(evlist, els);
 	if (ret) {
 		evlist_streams__delete(els);
 		return NULL;
 	}

 	return els;
 }

 struct evsel_streams *evsel_streams__entry(struct evlist_streams *els,
 					   int evsel_idx)
 {
 	struct evsel_streams *es = els->ev_streams;

 	for (int i = 0; i < els->nr_evsel; i++) {
 		if (es[i].evsel_idx == evsel_idx)
 			return &es[i];
 	}

 	return NULL;
 }

 static struct stream *stream__callchain_match(struct stream *base_stream,
 					      struct evsel_streams *es_pair)
 {
 	for (int i = 0; i < es_pair->nr_streams; i++) {
 		struct stream *pair_stream = &es_pair->streams[i];

 		if (callchain_cnode_matched(base_stream->cnode,
 					    pair_stream->cnode)) {
 			return pair_stream;
 		}
 	}

 	return NULL;
 }

 static struct stream *stream__match(struct stream *base_stream,
 				    struct evsel_streams *es_pair)
 {
 	return stream__callchain_match(base_stream, es_pair);
 }

 static void stream__link(struct stream *base_stream, struct stream *pair_stream)
 {
 	base_stream->pair_cnode = pair_stream->cnode;
 	pair_stream->pair_cnode = base_stream->cnode;
 }

 void evsel_streams__match(struct evsel_streams *es_base,
 			  struct evsel_streams *es_pair)
 {
 	for (int i = 0; i < es_base->nr_streams; i++) {
 		struct stream *base_stream = &es_base->streams[i];
 		struct stream *pair_stream;

 		pair_stream = stream__match(base_stream, es_pair);
 		if (pair_stream)
 			stream__link(base_stream, pair_stream);
 	}
 }

 static void print_callchain_pair(struct stream *base_stream, int idx,
 				 struct evsel_streams *es_base,
 				 struct evsel_streams *es_pair)
 {
 	struct callchain_node *base_cnode = base_stream->cnode;
 	struct callchain_node *pair_cnode = base_stream->pair_cnode;
 	struct callchain_list *base_chain, *pair_chain;
 	char buf1[512], buf2[512], cbuf1[256], cbuf2[256];
 	char *s1, *s2;
 	double pct;

 	printf("\nhot chain pair %d:\n", idx);

 	pct = (double)base_cnode->hit / (double)es_base->streams_hits;
 	scnprintf(buf1, sizeof(buf1), "cycles: %ld, hits: %.2f%%",
 		  callchain_avg_cycles(base_cnode), pct * 100.0);

 	pct = (double)pair_cnode->hit / (double)es_pair->streams_hits;
 	scnprintf(buf2, sizeof(buf2), "cycles: %ld, hits: %.2f%%",
 		  callchain_avg_cycles(pair_cnode), pct * 100.0);

 	printf("%35s\t%35s\n", buf1, buf2);

 	printf("%35s\t%35s\n",
 	       "---------------------------",
 	       "--------------------------");

 	pair_chain = list_first_entry(&pair_cnode->val,
 				      struct callchain_list,
 				      list);

 	list_for_each_entry(base_chain, &base_cnode->val, list) {
 		if (&pair_chain->list == &pair_cnode->val)
 			return;

 		s1 = callchain_list__sym_name(base_chain, cbuf1, sizeof(cbuf1),
 					      false);
 		s2 = callchain_list__sym_name(pair_chain, cbuf2, sizeof(cbuf2),
 					      false);

 		scnprintf(buf1, sizeof(buf1), "%35s\t%35s", s1, s2);
 		printf("%s\n", buf1);
 		pair_chain = list_next_entry(pair_chain, list);
 	}
 }

 static void print_stream_callchain(struct stream *stream, int idx,
 				   struct evsel_streams *es, bool pair)
 {
 	struct callchain_node *cnode = stream->cnode;
 	struct callchain_list *chain;
 	char buf[512], cbuf[256], *s;
 	double pct;

 	printf("\nhot chain %d:\n", idx);

 	pct = (double)cnode->hit / (double)es->streams_hits;
 	scnprintf(buf, sizeof(buf), "cycles: %ld, hits: %.2f%%",
 		  callchain_avg_cycles(cnode), pct * 100.0);

 	if (pair) {
 		printf("%35s\t%35s\n", "", buf);
 		printf("%35s\t%35s\n",
 		       "", "--------------------------");
 	} else {
 		printf("%35s\n", buf);
 		printf("%35s\n", "--------------------------");
 	}

 	list_for_each_entry(chain, &cnode->val, list) {
 		s = callchain_list__sym_name(chain, cbuf, sizeof(cbuf), false);

 		if (pair)
 			scnprintf(buf, sizeof(buf), "%35s\t%35s", "", s);
 		else
 			scnprintf(buf, sizeof(buf), "%35s", s);

 		printf("%s\n", buf);
 	}
 }

 static void callchain_streams_report(struct evsel_streams *es_base,
 				     struct evsel_streams *es_pair)
 {
 	struct stream *base_stream;
 	int i, idx = 0;

 	printf("[ Matched hot streams ]\n");
 	for (i = 0; i < es_base->nr_streams; i++) {
 		base_stream = &es_base->streams[i];
 		if (base_stream->pair_cnode) {
 			print_callchain_pair(base_stream, ++idx,
 					     es_base, es_pair);
 		}
 	}

 	idx = 0;
 	printf("\n[ Hot streams in old perf data only ]\n");
 	for (i = 0; i < es_base->nr_streams; i++) {
 		base_stream = &es_base->streams[i];
 		if (!base_stream->pair_cnode) {
 			print_stream_callchain(base_stream, ++idx,
 					       es_base, false);
 		}
 	}

 	idx = 0;
 	printf("\n[ Hot streams in new perf data only ]\n");
 	for (i = 0; i < es_pair->nr_streams; i++) {
 		base_stream = &es_pair->streams[i];
 		if (!base_stream->pair_cnode) {
 			print_stream_callchain(base_stream, ++idx,
 					       es_pair, true);
 		}
 	}
 }

 void evsel_streams__report(struct evsel_streams *es_base,
 			   struct evsel_streams *es_pair)
 {
 	return callchain_streams_report(es_base, es_pair);
 }
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Compare and figure out the top N hottest streams
	* Copyright (c) 2020, Intel Corporation.
	* Author: Jin Yao
	*/

	#include <inttypes.h>
	#include <stdlib.h>
	#include <linux/zalloc.h>
	#include "debug.h"
	#include "hist.h"
	#include "sort.h"
	#include "stream.h"
	#include "evlist.h"

	static void evsel_streams__delete(struct evsel_streams *es, int nr_evsel)
	{
	for (int i = 0; i < nr_evsel; i++)
	zfree(&es[i].streams);

	free(es);
	}

	void evlist_streams__delete(struct evlist_streams *els)
	{
	evsel_streams__delete(els->ev_streams, els->nr_evsel);
	free(els);
	}

	static struct evlist_streams *evlist_streams__new(int nr_evsel,
	int nr_streams_max)
	{
	struct evlist_streams *els;
	struct evsel_streams *es;

	els = zalloc(sizeof(*els));
	if (!els)
	return NULL;

	es = calloc(nr_evsel, sizeof(struct evsel_streams));
	if (!es) {
	free(els);
	return NULL;
	}

	for (int i = 0; i < nr_evsel; i++) {
	struct evsel_streams *s = &es[i];

	s->streams = calloc(nr_streams_max, sizeof(struct stream));
	if (!s->streams)
	goto err;

	s->nr_streams_max = nr_streams_max;
	s->evsel_idx = -1;
	}

	els->ev_streams = es;
	els->nr_evsel = nr_evsel;
	return els;

	err:
	evsel_streams__delete(es, nr_evsel);
	return NULL;
	}

	/*
	* The cnodes with high hit number are hot callchains.
	*/
	static void evsel_streams__set_hot_cnode(struct evsel_streams *es,
	struct callchain_node *cnode)
	{
	int i, idx = 0;
	u64 hit;

	if (es->nr_streams < es->nr_streams_max) {
	i = es->nr_streams;
	es->streams[i].cnode = cnode;
	es->nr_streams++;
	return;
	}

	/*
	* Considering a few number of hot streams, only use simple
	* way to find the cnode with smallest hit number and replace.
	*/
	hit = (es->streams[0].cnode)->hit;
	for (i = 1; i < es->nr_streams; i++) {
	if ((es->streams[i].cnode)->hit < hit) {
	hit = (es->streams[i].cnode)->hit;
	idx = i;
	}
	}

	if (cnode->hit > hit)
	es->streams[idx].cnode = cnode;
	}

	static void update_hot_callchain(struct hist_entry *he,
	struct evsel_streams *es)
	{
	struct rb_root *root = &he->sorted_chain;
	struct rb_node *rb_node = rb_first(root);
	struct callchain_node *cnode;

	while (rb_node) {
	cnode = rb_entry(rb_node, struct callchain_node, rb_node);
	evsel_streams__set_hot_cnode(es, cnode);
	rb_node = rb_next(rb_node);
	}
	}

	static void init_hot_callchain(struct hists hists, struct evsel_streams es)
	{
	struct rb_node *next = rb_first_cached(&hists->entries);

	while (next) {
	struct hist_entry *he;

	he = rb_entry(next, struct hist_entry, rb_node);
	update_hot_callchain(he, es);
	next = rb_next(&he->rb_node);
	}

	es->streams_hits = callchain_total_hits(hists);
	}

	static int evlist__init_callchain_streams(struct evlist *evlist,
	struct evlist_streams *els)
	{
	struct evsel_streams *es = els->ev_streams;
	struct evsel *pos;
	int i = 0;

	BUG_ON(els->nr_evsel < evlist->core.nr_entries);

	evlist__for_each_entry(evlist, pos) {
	struct hists *hists = evsel__hists(pos);

	hists__output_resort(hists, NULL);
	init_hot_callchain(hists, &es[i]);
	es[i].evsel_idx = pos->core.idx;
	i++;
	}

	return 0;
	}

	struct evlist_streams evlist__create_streams(struct evlist evlist,
	int nr_streams_max)
	{
	int nr_evsel = evlist->core.nr_entries, ret = -1;
	struct evlist_streams *els = evlist_streams__new(nr_evsel,
	nr_streams_max);

	if (!els)
	return NULL;

	ret = evlist__init_callchain_streams(evlist, els);
	if (ret) {
	evlist_streams__delete(els);
	return NULL;
	}

	return els;
	}

	struct evsel_streams evsel_streams__entry(struct evlist_streams els,
	int evsel_idx)
	{
	struct evsel_streams *es = els->ev_streams;

	for (int i = 0; i < els->nr_evsel; i++) {
	if (es[i].evsel_idx == evsel_idx)
	return &es[i];
	}

	return NULL;
	}

	static struct stream stream__callchain_match(struct stream base_stream,
	struct evsel_streams *es_pair)
	{
	for (int i = 0; i < es_pair->nr_streams; i++) {
	struct stream *pair_stream = &es_pair->streams[i];

	if (callchain_cnode_matched(base_stream->cnode,
	pair_stream->cnode)) {
	return pair_stream;
	}
	}

	return NULL;
	}

	static struct stream stream__match(struct stream base_stream,
	struct evsel_streams *es_pair)
	{
	return stream__callchain_match(base_stream, es_pair);
	}

	static void stream__link(struct stream base_stream, struct stream pair_stream)
	{
	base_stream->pair_cnode = pair_stream->cnode;
	pair_stream->pair_cnode = base_stream->cnode;
	}

	void evsel_streams__match(struct evsel_streams *es_base,
	struct evsel_streams *es_pair)
	{
	for (int i = 0; i < es_base->nr_streams; i++) {
	struct stream *base_stream = &es_base->streams[i];
	struct stream *pair_stream;

	pair_stream = stream__match(base_stream, es_pair);
	if (pair_stream)
	stream__link(base_stream, pair_stream);
	}
	}

	static void print_callchain_pair(struct stream *base_stream, int idx,
	struct evsel_streams *es_base,
	struct evsel_streams *es_pair)
	{
	struct callchain_node *base_cnode = base_stream->cnode;
	struct callchain_node *pair_cnode = base_stream->pair_cnode;
	struct callchain_list base_chain, pair_chain;
	char buf1[512], buf2[512], cbuf1[256], cbuf2[256];
	char s1, s2;
	double pct;

	printf("\nhot chain pair %d:\n", idx);

	pct = (double)base_cnode->hit / (double)es_base->streams_hits;
	scnprintf(buf1, sizeof(buf1), "cycles: %ld, hits: %.2f%%",
	callchain_avg_cycles(base_cnode), pct * 100.0);

	pct = (double)pair_cnode->hit / (double)es_pair->streams_hits;
	scnprintf(buf2, sizeof(buf2), "cycles: %ld, hits: %.2f%%",
	callchain_avg_cycles(pair_cnode), pct * 100.0);

	printf("%35s\t%35s\n", buf1, buf2);

	printf("%35s\t%35s\n",
	"---------------------------",
	"--------------------------");

	pair_chain = list_first_entry(&pair_cnode->val,
	struct callchain_list,
	list);

	list_for_each_entry(base_chain, &base_cnode->val, list) {
	if (&pair_chain->list == &pair_cnode->val)
	return;

	s1 = callchain_list__sym_name(base_chain, cbuf1, sizeof(cbuf1),
	false);
	s2 = callchain_list__sym_name(pair_chain, cbuf2, sizeof(cbuf2),
	false);

	scnprintf(buf1, sizeof(buf1), "%35s\t%35s", s1, s2);
	printf("%s\n", buf1);
	pair_chain = list_next_entry(pair_chain, list);
	}
	}

	static void print_stream_callchain(struct stream *stream, int idx,
	struct evsel_streams *es, bool pair)
	{
	struct callchain_node *cnode = stream->cnode;
	struct callchain_list *chain;
	char buf[512], cbuf[256], *s;
	double pct;

	printf("\nhot chain %d:\n", idx);

	pct = (double)cnode->hit / (double)es->streams_hits;
	scnprintf(buf, sizeof(buf), "cycles: %ld, hits: %.2f%%",
	callchain_avg_cycles(cnode), pct * 100.0);

	if (pair) {
	printf("%35s\t%35s\n", "", buf);
	printf("%35s\t%35s\n",
	"", "--------------------------");
	} else {
	printf("%35s\n", buf);
	printf("%35s\n", "--------------------------");
	}

	list_for_each_entry(chain, &cnode->val, list) {
	s = callchain_list__sym_name(chain, cbuf, sizeof(cbuf), false);

	if (pair)
	scnprintf(buf, sizeof(buf), "%35s\t%35s", "", s);
	else
	scnprintf(buf, sizeof(buf), "%35s", s);

	printf("%s\n", buf);
	}
	}

	static void callchain_streams_report(struct evsel_streams *es_base,
	struct evsel_streams *es_pair)
	{
	struct stream *base_stream;
	int i, idx = 0;

	printf("[ Matched hot streams ]\n");
	for (i = 0; i < es_base->nr_streams; i++) {
	base_stream = &es_base->streams[i];
	if (base_stream->pair_cnode) {
	print_callchain_pair(base_stream, ++idx,
	es_base, es_pair);
	}
	}

	idx = 0;
	printf("\n[ Hot streams in old perf data only ]\n");
	for (i = 0; i < es_base->nr_streams; i++) {
	base_stream = &es_base->streams[i];
	if (!base_stream->pair_cnode) {
	print_stream_callchain(base_stream, ++idx,
	es_base, false);
	}
	}

	idx = 0;
	printf("\n[ Hot streams in new perf data only ]\n");
	for (i = 0; i < es_pair->nr_streams; i++) {
	base_stream = &es_pair->streams[i];
	if (!base_stream->pair_cnode) {
	print_stream_callchain(base_stream, ++idx,
	es_pair, true);
	}
	}
	}

	void evsel_streams__report(struct evsel_streams *es_base,
	struct evsel_streams *es_pair)
	{
	return callchain_streams_report(es_base, es_pair);
	}