[linux-2.6-block.git] / tools / perf / ui / gtk / hists.c

#include "../evlist.h"
#include "../cache.h"
#include "../evsel.h"
#include "../sort.h"
#include "../hist.h"
#include "../helpline.h"
#include "gtk.h"

#define MAX_COLUMNS			32

static int __percent_color_snprintf(char *buf, size_t size, double percent)
{
	int ret = 0;
	const char *markup;

	markup = perf_gtk__get_percent_color(percent);
	if (markup)
		ret += scnprintf(buf, size, markup);

	ret += scnprintf(buf + ret, size - ret, " %6.2f%%", percent);

	if (markup)
		ret += scnprintf(buf + ret, size - ret, "</span>");

	return ret;
}


static int __hpp__color_fmt(struct perf_hpp *hpp, struct hist_entry *he,
			    u64 (*get_field)(struct hist_entry *))
{
	int ret;
	double percent = 0.0;
	struct hists *hists = he->hists;

	if (hists->stats.total_period)
		percent = 100.0 * get_field(he) / hists->stats.total_period;

	ret = __percent_color_snprintf(hpp->buf, hpp->size, percent);

	if (symbol_conf.event_group) {
		int prev_idx, idx_delta;
		struct perf_evsel *evsel = hists_to_evsel(hists);
		struct hist_entry *pair;
		int nr_members = evsel->nr_members;

		if (nr_members <= 1)
			return ret;

		prev_idx = perf_evsel__group_idx(evsel);

		list_for_each_entry(pair, &he->pairs.head, pairs.node) {
			u64 period = get_field(pair);
			u64 total = pair->hists->stats.total_period;

			evsel = hists_to_evsel(pair->hists);
			idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;

			while (idx_delta--) {
				/*
				 * zero-fill group members in the middle which
				 * have no sample
				 */
				ret += __percent_color_snprintf(hpp->buf + ret,
								hpp->size - ret,
								0.0);
			}

			percent = 100.0 * period / total;
			ret += __percent_color_snprintf(hpp->buf + ret,
							hpp->size - ret,
							percent);

			prev_idx = perf_evsel__group_idx(evsel);
		}

		idx_delta = nr_members - prev_idx - 1;

		while (idx_delta--) {
			/*
			 * zero-fill group members at last which have no sample
			 */
			ret += __percent_color_snprintf(hpp->buf + ret,
							hpp->size - ret,
							0.0);
		}
	}
	return ret;
}

#define __HPP_COLOR_PERCENT_FN(_type, _field)					\
static u64 he_get_##_field(struct hist_entry *he)				\
{										\
	return he->stat._field;							\
}										\
										\
static int perf_gtk__hpp_color_##_type(struct perf_hpp *hpp,			\
				       struct hist_entry *he)			\
{										\
	return __hpp__color_fmt(hpp, he, he_get_##_field);			\
}

__HPP_COLOR_PERCENT_FN(overhead, period)
__HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
__HPP_COLOR_PERCENT_FN(overhead_us, period_us)
__HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
__HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)

#undef __HPP_COLOR_PERCENT_FN


void perf_gtk__init_hpp(void)
{
	perf_hpp__column_enable(PERF_HPP__OVERHEAD);

	perf_hpp__init();

	perf_hpp__format[PERF_HPP__OVERHEAD].color =
				perf_gtk__hpp_color_overhead;
	perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
				perf_gtk__hpp_color_overhead_sys;
	perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
				perf_gtk__hpp_color_overhead_us;
	perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
				perf_gtk__hpp_color_overhead_guest_sys;
	perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
				perf_gtk__hpp_color_overhead_guest_us;
}

static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
{
	struct perf_hpp_fmt *fmt;
	GType col_types[MAX_COLUMNS];
	GtkCellRenderer *renderer;
	struct sort_entry *se;
	GtkListStore *store;
	struct rb_node *nd;
	GtkWidget *view;
	int col_idx;
	int nr_cols;
	char s[512];

	struct perf_hpp hpp = {
		.buf		= s,
		.size		= sizeof(s),
		.ptr		= hists_to_evsel(hists),
	};

	nr_cols = 0;

	perf_hpp__for_each_format(fmt)
		col_types[nr_cols++] = G_TYPE_STRING;

	list_for_each_entry(se, &hist_entry__sort_list, list) {
		if (se->elide)
			continue;

		col_types[nr_cols++] = G_TYPE_STRING;
	}

	store = gtk_list_store_newv(nr_cols, col_types);

	view = gtk_tree_view_new();

	renderer = gtk_cell_renderer_text_new();

	col_idx = 0;

	perf_hpp__for_each_format(fmt) {
		fmt->header(&hpp);

		gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
							    -1, ltrim(s),
							    renderer, "markup",
							    col_idx++, NULL);
	}

	list_for_each_entry(se, &hist_entry__sort_list, list) {
		if (se->elide)
			continue;

		gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
							    -1, se->se_header,
							    renderer, "text",
							    col_idx++, NULL);
	}

	gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));

	g_object_unref(GTK_TREE_MODEL(store));

	for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
		struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
		GtkTreeIter iter;

		if (h->filtered)
			continue;

		gtk_list_store_append(store, &iter);

		col_idx = 0;

		perf_hpp__for_each_format(fmt) {
			if (fmt->color)
				fmt->color(&hpp, h);
			else
				fmt->entry(&hpp, h);

			gtk_list_store_set(store, &iter, col_idx++, s, -1);
		}

		list_for_each_entry(se, &hist_entry__sort_list, list) {
			if (se->elide)
				continue;

			se->se_snprintf(h, s, ARRAY_SIZE(s),
					hists__col_len(hists, se->se_width_idx));

			gtk_list_store_set(store, &iter, col_idx++, s, -1);
		}
	}

	gtk_container_add(GTK_CONTAINER(window), view);
}

int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
				  const char *help,
				  struct hist_browser_timer *hbt __maybe_unused)
{
	struct perf_evsel *pos;
	GtkWidget *vbox;
	GtkWidget *notebook;
	GtkWidget *info_bar;
	GtkWidget *statbar;
	GtkWidget *window;

	signal(SIGSEGV, perf_gtk__signal);
	signal(SIGFPE,  perf_gtk__signal);
	signal(SIGINT,  perf_gtk__signal);
	signal(SIGQUIT, perf_gtk__signal);
	signal(SIGTERM, perf_gtk__signal);

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	gtk_window_set_title(GTK_WINDOW(window), "perf report");

	g_signal_connect(window, "delete_event", gtk_main_quit, NULL);

	pgctx = perf_gtk__activate_context(window);
	if (!pgctx)
		return -1;

	vbox = gtk_vbox_new(FALSE, 0);

	notebook = gtk_notebook_new();

	gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);

	info_bar = perf_gtk__setup_info_bar();
	if (info_bar)
		gtk_box_pack_start(GTK_BOX(vbox), info_bar, FALSE, FALSE, 0);

	statbar = perf_gtk__setup_statusbar();
	gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);

	gtk_container_add(GTK_CONTAINER(window), vbox);

	list_for_each_entry(pos, &evlist->entries, node) {
		struct hists *hists = &pos->hists;
		const char *evname = perf_evsel__name(pos);
		GtkWidget *scrolled_window;
		GtkWidget *tab_label;
		char buf[512];
		size_t size = sizeof(buf);

		if (symbol_conf.event_group) {
			if (!perf_evsel__is_group_leader(pos))
				continue;

			if (pos->nr_members > 1) {
				perf_evsel__group_desc(pos, buf, size);
				evname = buf;
			}
		}

		scrolled_window = gtk_scrolled_window_new(NULL, NULL);

		gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
							GTK_POLICY_AUTOMATIC,
							GTK_POLICY_AUTOMATIC);

		perf_gtk__show_hists(scrolled_window, hists);

		tab_label = gtk_label_new(evname);

		gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
	}

	gtk_widget_show_all(window);

	perf_gtk__resize_window(window);

	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

	ui_helpline__push(help);

	gtk_main();

	perf_gtk__deactivate_context(&pgctx);

	return 0;
}
Commit	Line	Data
0da41ce9 NK	1	#include "../evlist.h"
	2	#include "../cache.h"
	3	#include "../evsel.h"
	4	#include "../sort.h"
	5	#include "../hist.h"
	6	#include "../helpline.h"
	7	#include "gtk.h"
	8
	9	#define MAX_COLUMNS 32
	10
cb16008b	11	static int __percent_color_snprintf(char *buf, size_t size, double percent)
843985e9 NK	12	{
	13	int ret = 0;
	14	const char *markup;
	15
	16	markup = perf_gtk__get_percent_color(percent);
	17	if (markup)
	18	ret += scnprintf(buf, size, markup);
	19
cb16008b	20	ret += scnprintf(buf + ret, size - ret, " %6.2f%%", percent);
843985e9 NK	21
	22	if (markup)
	23	ret += scnprintf(buf + ret, size - ret, "</span>");
	24
	25	return ret;
	26	}
	27
	28
	29	static int __hpp__color_fmt(struct perf_hpp hpp, struct hist_entry he,
	30	u64 (get_field)(struct hist_entry ))
	31	{
	32	int ret;
	33	double percent = 0.0;
	34	struct hists *hists = he->hists;
	35
	36	if (hists->stats.total_period)
	37	percent = 100.0 * get_field(he) / hists->stats.total_period;
	38
cb16008b NK	39	ret = __percent_color_snprintf(hpp->buf, hpp->size, percent);
	40
	41	if (symbol_conf.event_group) {
	42	int prev_idx, idx_delta;
	43	struct perf_evsel *evsel = hists_to_evsel(hists);
	44	struct hist_entry *pair;
	45	int nr_members = evsel->nr_members;
	46
	47	if (nr_members <= 1)
	48	return ret;
	49
	50	prev_idx = perf_evsel__group_idx(evsel);
	51
	52	list_for_each_entry(pair, &he->pairs.head, pairs.node) {
	53	u64 period = get_field(pair);
	54	u64 total = pair->hists->stats.total_period;
	55
	56	evsel = hists_to_evsel(pair->hists);
	57	idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1;
	58
	59	while (idx_delta--) {
	60	/*
	61	* zero-fill group members in the middle which
	62	* have no sample
	63	*/
	64	ret += __percent_color_snprintf(hpp->buf + ret,
	65	hpp->size - ret,
	66	0.0);
	67	}
	68
	69	percent = 100.0 * period / total;
	70	ret += __percent_color_snprintf(hpp->buf + ret,
	71	hpp->size - ret,
	72	percent);
	73
	74	prev_idx = perf_evsel__group_idx(evsel);
	75	}
	76
	77	idx_delta = nr_members - prev_idx - 1;
	78
	79	while (idx_delta--) {
	80	/*
	81	* zero-fill group members at last which have no sample
	82	*/
	83	ret += __percent_color_snprintf(hpp->buf + ret,
	84	hpp->size - ret,
	85	0.0);
	86	}
	87	}
843985e9 NK	88	return ret;
	89	}
	90
	91	#define __HPP_COLOR_PERCENT_FN(_type, _field) \
	92	static u64 he_get_##_field(struct hist_entry *he) \
0da41ce9	93	{ \
843985e9 NK	94	return he->stat._field; \
843985e9 NK	95	} \
0da41ce9	96	\
843985e9 NK	97	static int perf_gtk__hpp_color_##_type(struct perf_hpp *hpp, \
	98	struct hist_entry *he) \
	99	{ \
	100	return __hpp__color_fmt(hpp, he, he_get_##_field); \
0da41ce9 NK	101	}
0da41ce9 NK	102
843985e9 NK	103	__HPP_COLOR_PERCENT_FN(overhead, period)
	104	__HPP_COLOR_PERCENT_FN(overhead_sys, period_sys)
	105	__HPP_COLOR_PERCENT_FN(overhead_us, period_us)
	106	__HPP_COLOR_PERCENT_FN(overhead_guest_sys, period_guest_sys)
	107	__HPP_COLOR_PERCENT_FN(overhead_guest_us, period_guest_us)
0da41ce9	108
843985e9	109	#undef __HPP_COLOR_PERCENT_FN
0da41ce9 NK	110
	111
	112	void perf_gtk__init_hpp(void)
	113	{
	114	perf_hpp__column_enable(PERF_HPP__OVERHEAD);
	115
	116	perf_hpp__init();
	117
	118	perf_hpp__format[PERF_HPP__OVERHEAD].color =
	119	perf_gtk__hpp_color_overhead;
	120	perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
	121	perf_gtk__hpp_color_overhead_sys;
	122	perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
	123	perf_gtk__hpp_color_overhead_us;
	124	perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
	125	perf_gtk__hpp_color_overhead_guest_sys;
	126	perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
	127	perf_gtk__hpp_color_overhead_guest_us;
	128	}
	129
	130	static void perf_gtk__show_hists(GtkWidget window, struct hists hists)
	131	{
	132	struct perf_hpp_fmt *fmt;
	133	GType col_types[MAX_COLUMNS];
	134	GtkCellRenderer *renderer;
	135	struct sort_entry *se;
	136	GtkListStore *store;
	137	struct rb_node *nd;
	138	GtkWidget *view;
	139	int col_idx;
	140	int nr_cols;
	141	char s[512];
	142
	143	struct perf_hpp hpp = {
	144	.buf = s,
	145	.size = sizeof(s),
cb16008b	146	.ptr = hists_to_evsel(hists),
0da41ce9 NK	147	};
	148
	149	nr_cols = 0;
	150
	151	perf_hpp__for_each_format(fmt)
	152	col_types[nr_cols++] = G_TYPE_STRING;
	153
	154	list_for_each_entry(se, &hist_entry__sort_list, list) {
	155	if (se->elide)
	156	continue;
	157
	158	col_types[nr_cols++] = G_TYPE_STRING;
	159	}
	160
	161	store = gtk_list_store_newv(nr_cols, col_types);
	162
	163	view = gtk_tree_view_new();
	164
	165	renderer = gtk_cell_renderer_text_new();
	166
	167	col_idx = 0;
	168
	169	perf_hpp__for_each_format(fmt) {
	170	fmt->header(&hpp);
	171
	172	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
34b95643	173	-1, ltrim(s),
0da41ce9 NK	174	renderer, "markup",
	175	col_idx++, NULL);
	176	}
	177
	178	list_for_each_entry(se, &hist_entry__sort_list, list) {
	179	if (se->elide)
	180	continue;
	181
	182	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
	183	-1, se->se_header,
	184	renderer, "text",
	185	col_idx++, NULL);
	186	}
	187
	188	gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
	189
	190	g_object_unref(GTK_TREE_MODEL(store));
	191
	192	for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
	193	struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
	194	GtkTreeIter iter;
	195
	196	if (h->filtered)
	197	continue;
	198
	199	gtk_list_store_append(store, &iter);
	200
	201	col_idx = 0;
	202
	203	perf_hpp__for_each_format(fmt) {
	204	if (fmt->color)
	205	fmt->color(&hpp, h);
	206	else
	207	fmt->entry(&hpp, h);
	208
	209	gtk_list_store_set(store, &iter, col_idx++, s, -1);
	210	}
	211
	212	list_for_each_entry(se, &hist_entry__sort_list, list) {
	213	if (se->elide)
	214	continue;
	215
	216	se->se_snprintf(h, s, ARRAY_SIZE(s),
	217	hists__col_len(hists, se->se_width_idx));
	218
	219	gtk_list_store_set(store, &iter, col_idx++, s, -1);
	220	}
	221	}
	222
	223	gtk_container_add(GTK_CONTAINER(window), view);
	224	}
	225
	226	int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
	227	const char *help,
	228	struct hist_browser_timer *hbt __maybe_unused)
	229	{
	230	struct perf_evsel *pos;
	231	GtkWidget *vbox;
	232	GtkWidget *notebook;
	233	GtkWidget *info_bar;
	234	GtkWidget *statbar;
	235	GtkWidget *window;
	236
	237	signal(SIGSEGV, perf_gtk__signal);
238	signal(SIGFPE, perf_gtk__signal);
239	signal(SIGINT, perf_gtk__signal);
240	signal(SIGQUIT, perf_gtk__signal);
241	signal(SIGTERM, perf_gtk__signal);
242
243	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
244
245	gtk_window_set_title(GTK_WINDOW(window), "perf report");
246
247	g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
248
249	pgctx = perf_gtk__activate_context(window);
250	if (!pgctx)
251	return -1;
252
253	vbox = gtk_vbox_new(FALSE, 0);
254
255	notebook = gtk_notebook_new();
256
6bf1a295 NK	257	gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
	258
	259	info_bar = perf_gtk__setup_info_bar();
	260	if (info_bar)
	261	gtk_box_pack_start(GTK_BOX(vbox), info_bar, FALSE, FALSE, 0);
	262
	263	statbar = perf_gtk__setup_statusbar();
	264	gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
	265
	266	gtk_container_add(GTK_CONTAINER(window), vbox);
	267
0da41ce9 NK	268	list_for_each_entry(pos, &evlist->entries, node) {
	269	struct hists *hists = &pos->hists;
	270	const char *evname = perf_evsel__name(pos);
	271	GtkWidget *scrolled_window;
	272	GtkWidget *tab_label;
717e263f NK	273	char buf[512];
717e263f NK	274	size_t size = sizeof(buf);
0da41ce9	275
717e263f NK	276	if (symbol_conf.event_group) {
	277	if (!perf_evsel__is_group_leader(pos))
	278	continue;
	279
	280	if (pos->nr_members > 1) {
	281	perf_evsel__group_desc(pos, buf, size);
	282	evname = buf;
	283	}
	284	}
fc24d7c2	285
0da41ce9 NK	286	scrolled_window = gtk_scrolled_window_new(NULL, NULL);
	287
	288	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
	289	GTK_POLICY_AUTOMATIC,
	290	GTK_POLICY_AUTOMATIC);
	291
	292	perf_gtk__show_hists(scrolled_window, hists);
	293
	294	tab_label = gtk_label_new(evname);
	295
	296	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
	297	}
	298
0da41ce9 NK	299	gtk_widget_show_all(window);
	300
	301	perf_gtk__resize_window(window);
	302
	303	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	304
	305	ui_helpline__push(help);
	306
	307	gtk_main();
	308
	309	perf_gtk__deactivate_context(&pgctx);
	310
	311	return 0;
	312	}