Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 05e8b080 authored by Arnaldo Carvalho de Melo's avatar Arnaldo Carvalho de Melo
Browse files

perf ui browser: Stop using 'self' 



Stop using this python/OOP convention, doesn't really helps. Will do
more from time to time till we get it cleaned up in all of /perf.

Suggested-by: default avatarThomas Gleixner <tglx@linutronix.de>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@gmail.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-5dyxyb8o0gf4yndk27kafbd1@git.kernel.org


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent c323cf04

tools/perf/ui/browser.c

+90 −90
Original line number Diff line number Diff line
@@ -35,16 +35,16 @@ int ui_browser__set_color(struct ui_browser *browser, int color) 
	return ret;

}



void ui_browser__set_percent_color(struct ui_browser *self,

void ui_browser__set_percent_color(struct ui_browser *browser,

				   double percent, bool current)

{

	 int color = ui_browser__percent_color(self, percent, current);

	 ui_browser__set_color(self, color);

	 int color = ui_browser__percent_color(browser, percent, current);

	 ui_browser__set_color(browser, color);

}



void ui_browser__gotorc(struct ui_browser *self, int y, int x)

void ui_browser__gotorc(struct ui_browser *browser, int y, int x)

{

	SLsmg_gotorc(self->y + y, self->x + x);

	SLsmg_gotorc(browser->y + y, browser->x + x);

}



static struct list_head *
@@ -73,23 +73,23 @@ ui_browser__list_head_filter_prev_entries(struct ui_browser *browser, 
	return NULL;

}



void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)

void ui_browser__list_head_seek(struct ui_browser *browser, off_t offset, int whence)

{

	struct list_head *head = self->entries;

	struct list_head *head = browser->entries;

	struct list_head *pos;



	if (self->nr_entries == 0)

	if (browser->nr_entries == 0)

		return;



	switch (whence) {

	case SEEK_SET:

		pos = ui_browser__list_head_filter_entries(self, head->next);

		pos = ui_browser__list_head_filter_entries(browser, head->next);

		break;

	case SEEK_CUR:

		pos = self->top;

		pos = browser->top;

		break;

	case SEEK_END:

		pos = ui_browser__list_head_filter_prev_entries(self, head->prev);

		pos = ui_browser__list_head_filter_prev_entries(browser, head->prev);

		break;

	default:

		return;
@@ -99,18 +99,18 @@ void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whenc 


	if (offset > 0) {

		while (offset-- != 0)

			pos = ui_browser__list_head_filter_entries(self, pos->next);

			pos = ui_browser__list_head_filter_entries(browser, pos->next);

	} else {

		while (offset++ != 0)

			pos = ui_browser__list_head_filter_prev_entries(self, pos->prev);

			pos = ui_browser__list_head_filter_prev_entries(browser, pos->prev);

	}



	self->top = pos;

	browser->top = pos;

}



void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)

void ui_browser__rb_tree_seek(struct ui_browser *browser, off_t offset, int whence)

{

	struct rb_root *root = self->entries;

	struct rb_root *root = browser->entries;

	struct rb_node *nd;



	switch (whence) {
@@ -118,7 +118,7 @@ void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence) 
		nd = rb_first(root);

		break;

	case SEEK_CUR:

		nd = self->top;

		nd = browser->top;

		break;

	case SEEK_END:

		nd = rb_last(root);
@@ -135,23 +135,23 @@ void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence) 
			nd = rb_prev(nd);

	}



	self->top = nd;

	browser->top = nd;

}



unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)

unsigned int ui_browser__rb_tree_refresh(struct ui_browser *browser)

{

	struct rb_node *nd;

	int row = 0;



	if (self->top == NULL)

                self->top = rb_first(self->entries);

	if (browser->top == NULL)

                browser->top = rb_first(browser->entries);



	nd = self->top;

	nd = browser->top;



	while (nd != NULL) {

		ui_browser__gotorc(self, row, 0);

		self->write(self, nd, row);

		if (++row == self->height)

		ui_browser__gotorc(browser, row, 0);

		browser->write(browser, nd, row);

		if (++row == browser->height)

			break;

		nd = rb_next(nd);

	}
@@ -159,17 +159,17 @@ unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self) 
	return row;

}



bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)

bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row)

{

	return self->top_idx + row == self->index;

	return browser->top_idx + row == browser->index;

}



void ui_browser__refresh_dimensions(struct ui_browser *self)

void ui_browser__refresh_dimensions(struct ui_browser *browser)

{

	self->width = SLtt_Screen_Cols - 1;

	self->height = SLtt_Screen_Rows - 2;

	self->y = 1;

	self->x = 0;

	browser->width = SLtt_Screen_Cols - 1;

	browser->height = SLtt_Screen_Rows - 2;

	browser->y = 1;

	browser->x = 0;

}



void ui_browser__handle_resize(struct ui_browser *browser)
@@ -225,10 +225,10 @@ bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text) 
	return key == K_ENTER || toupper(key) == 'Y';

}



void ui_browser__reset_index(struct ui_browser *self)

void ui_browser__reset_index(struct ui_browser *browser)

{

	self->index = self->top_idx = 0;

	self->seek(self, 0, SEEK_SET);

	browser->index = browser->top_idx = 0;

	browser->seek(browser, 0, SEEK_SET);

}



void __ui_browser__show_title(struct ui_browser *browser, const char *title)
@@ -245,26 +245,26 @@ void ui_browser__show_title(struct ui_browser *browser, const char *title) 
	pthread_mutex_unlock(&ui__lock);

}



int ui_browser__show(struct ui_browser *self, const char *title,

int ui_browser__show(struct ui_browser *browser, const char *title,

		     const char *helpline, ...)

{

	int err;

	va_list ap;



	ui_browser__refresh_dimensions(self);

	ui_browser__refresh_dimensions(browser);



	pthread_mutex_lock(&ui__lock);

	__ui_browser__show_title(self, title);

	__ui_browser__show_title(browser, title);



	self->title = title;

	free(self->helpline);

	self->helpline = NULL;

	browser->title = title;

	free(browser->helpline);

	browser->helpline = NULL;



	va_start(ap, helpline);

	err = vasprintf(&self->helpline, helpline, ap);

	err = vasprintf(&browser->helpline, helpline, ap);

	va_end(ap);

	if (err > 0)

		ui_helpline__push(self->helpline);

		ui_helpline__push(browser->helpline);

	pthread_mutex_unlock(&ui__lock);

	return err ? 0 : -1;

}
@@ -350,7 +350,7 @@ void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries) 
	browser->seek(browser, browser->top_idx, SEEK_SET);

}



int ui_browser__run(struct ui_browser *self, int delay_secs)

int ui_browser__run(struct ui_browser *browser, int delay_secs)

{

	int err, key;
@@ -358,7 +358,7 @@ int ui_browser__run(struct ui_browser *self, int delay_secs) 
		off_t offset;



		pthread_mutex_lock(&ui__lock);

		err = __ui_browser__refresh(self);

		err = __ui_browser__refresh(browser);

		SLsmg_refresh();

		pthread_mutex_unlock(&ui__lock);

		if (err < 0)
@@ -368,18 +368,18 @@ int ui_browser__run(struct ui_browser *self, int delay_secs) 


		if (key == K_RESIZE) {

			ui__refresh_dimensions(false);

			ui_browser__refresh_dimensions(self);

			__ui_browser__show_title(self, self->title);

			ui_helpline__puts(self->helpline);

			ui_browser__refresh_dimensions(browser);

			__ui_browser__show_title(browser, browser->title);

			ui_helpline__puts(browser->helpline);

			continue;

		}



		if (self->use_navkeypressed && !self->navkeypressed) {

		if (browser->use_navkeypressed && !browser->navkeypressed) {

			if (key == K_DOWN || key == K_UP ||

			    key == K_PGDN || key == K_PGUP ||

			    key == K_HOME || key == K_END ||

			    key == ' ') {

				self->navkeypressed = true;

				browser->navkeypressed = true;

				continue;

			} else

				return key;
@@ -387,59 +387,59 @@ int ui_browser__run(struct ui_browser *self, int delay_secs) 


		switch (key) {

		case K_DOWN:

			if (self->index == self->nr_entries - 1)

			if (browser->index == browser->nr_entries - 1)

				break;

			++self->index;

			if (self->index == self->top_idx + self->height) {

				++self->top_idx;

				self->seek(self, +1, SEEK_CUR);

			++browser->index;

			if (browser->index == browser->top_idx + browser->height) {

				++browser->top_idx;

				browser->seek(browser, +1, SEEK_CUR);

			}

			break;

		case K_UP:

			if (self->index == 0)

			if (browser->index == 0)

				break;

			--self->index;

			if (self->index < self->top_idx) {

				--self->top_idx;

				self->seek(self, -1, SEEK_CUR);

			--browser->index;

			if (browser->index < browser->top_idx) {

				--browser->top_idx;

				browser->seek(browser, -1, SEEK_CUR);

			}

			break;

		case K_PGDN:

		case ' ':

			if (self->top_idx + self->height > self->nr_entries - 1)

			if (browser->top_idx + browser->height > browser->nr_entries - 1)

				break;



			offset = self->height;

			if (self->index + offset > self->nr_entries - 1)

				offset = self->nr_entries - 1 - self->index;

			self->index += offset;

			self->top_idx += offset;

			self->seek(self, +offset, SEEK_CUR);

			offset = browser->height;

			if (browser->index + offset > browser->nr_entries - 1)

				offset = browser->nr_entries - 1 - browser->index;

			browser->index += offset;

			browser->top_idx += offset;

			browser->seek(browser, +offset, SEEK_CUR);

			break;

		case K_PGUP:

			if (self->top_idx == 0)

			if (browser->top_idx == 0)

				break;



			if (self->top_idx < self->height)

				offset = self->top_idx;

			if (browser->top_idx < browser->height)

				offset = browser->top_idx;

			else

				offset = self->height;

				offset = browser->height;



			self->index -= offset;

			self->top_idx -= offset;

			self->seek(self, -offset, SEEK_CUR);

			browser->index -= offset;

			browser->top_idx -= offset;

			browser->seek(browser, -offset, SEEK_CUR);

			break;

		case K_HOME:

			ui_browser__reset_index(self);

			ui_browser__reset_index(browser);

			break;

		case K_END:

			offset = self->height - 1;

			if (offset >= self->nr_entries)

				offset = self->nr_entries - 1;

			offset = browser->height - 1;

			if (offset >= browser->nr_entries)

				offset = browser->nr_entries - 1;



			self->index = self->nr_entries - 1;

			self->top_idx = self->index - offset;

			self->seek(self, -offset, SEEK_END);

			browser->index = browser->nr_entries - 1;

			browser->top_idx = browser->index - offset;

			browser->seek(browser, -offset, SEEK_END);

			break;

		default:

			return key;
@@ -448,22 +448,22 @@ int ui_browser__run(struct ui_browser *self, int delay_secs) 
	return -1;

}



unsigned int ui_browser__list_head_refresh(struct ui_browser *self)

unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)

{

	struct list_head *pos;

	struct list_head *head = self->entries;

	struct list_head *head = browser->entries;

	int row = 0;



	if (self->top == NULL || self->top == self->entries)

                self->top = ui_browser__list_head_filter_entries(self, head->next);

	if (browser->top == NULL || browser->top == browser->entries)

                browser->top = ui_browser__list_head_filter_entries(browser, head->next);



	pos = self->top;

	pos = browser->top;



	list_for_each_from(pos, head) {

		if (!self->filter || !self->filter(self, pos)) {

			ui_browser__gotorc(self, row, 0);

			self->write(self, pos, row);

			if (++row == self->height)

		if (!browser->filter || !browser->filter(browser, pos)) {

			ui_browser__gotorc(browser, row, 0);

			browser->write(browser, pos, row);

			if (++row == browser->height)

				break;

		}

	}

tools/perf/ui/browsers/annotate.c

+61 −61
Original line number Diff line number Diff line
@@ -83,30 +83,30 @@ static int annotate_browser__set_jumps_percent_color(struct annotate_browser *br 
	 return ui_browser__set_color(&browser->b, color);

}



static void annotate_browser__write(struct ui_browser *self, void *entry, int row)

static void annotate_browser__write(struct ui_browser *browser, void *entry, int row)

{

	struct annotate_browser *ab = container_of(self, struct annotate_browser, b);

	struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);

	struct disasm_line *dl = list_entry(entry, struct disasm_line, node);

	struct browser_disasm_line *bdl = disasm_line__browser(dl);

	bool current_entry = ui_browser__is_current_entry(self, row);

	bool current_entry = ui_browser__is_current_entry(browser, row);

	bool change_color = (!annotate_browser__opts.hide_src_code &&

			     (!current_entry || (self->use_navkeypressed &&

					         !self->navkeypressed)));

	int width = self->width, printed;

			     (!current_entry || (browser->use_navkeypressed &&

					         !browser->navkeypressed)));

	int width = browser->width, printed;

	char bf[256];



	if (dl->offset != -1 && bdl->percent != 0.0) {

		ui_browser__set_percent_color(self, bdl->percent, current_entry);

		ui_browser__set_percent_color(browser, bdl->percent, current_entry);

		slsmg_printf("%6.2f ", bdl->percent);

	} else {

		ui_browser__set_percent_color(self, 0, current_entry);

		ui_browser__set_percent_color(browser, 0, current_entry);

		slsmg_write_nstring(" ", 7);

	}



	SLsmg_write_char(' ');



	/* The scroll bar isn't being used */

	if (!self->navkeypressed)

	if (!browser->navkeypressed)

		width += 1;



	if (!*dl->line)
@@ -135,7 +135,7 @@ static void annotate_browser__write(struct ui_browser *self, void *entry, int ro 
					prev = annotate_browser__set_jumps_percent_color(ab, bdl->jump_sources,

											 current_entry);

					slsmg_write_nstring(bf, printed);

					ui_browser__set_color(self, prev);

					ui_browser__set_color(browser, prev);

				}



				printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ",
@@ -147,19 +147,19 @@ static void annotate_browser__write(struct ui_browser *self, void *entry, int ro 
		}



		if (change_color)

			color = ui_browser__set_color(self, HE_COLORSET_ADDR);

			color = ui_browser__set_color(browser, HE_COLORSET_ADDR);

		slsmg_write_nstring(bf, printed);

		if (change_color)

			ui_browser__set_color(self, color);

			ui_browser__set_color(browser, color);

		if (dl->ins && dl->ins->ops->scnprintf) {

			if (ins__is_jump(dl->ins)) {

				bool fwd = dl->ops.target.offset > (u64)dl->offset;



				ui_browser__write_graph(self, fwd ? SLSMG_DARROW_CHAR :

				ui_browser__write_graph(browser, fwd ? SLSMG_DARROW_CHAR :

								    SLSMG_UARROW_CHAR);

				SLsmg_write_char(' ');

			} else if (ins__is_call(dl->ins)) {

				ui_browser__write_graph(self, SLSMG_RARROW_CHAR);

				ui_browser__write_graph(browser, SLSMG_RARROW_CHAR);

				SLsmg_write_char(' ');

			} else {

				slsmg_write_nstring(" ", 2);
@@ -168,7 +168,7 @@ static void annotate_browser__write(struct ui_browser *self, void *entry, int ro 
			if (strcmp(dl->name, "retq")) {

				slsmg_write_nstring(" ", 2);

			} else {

				ui_browser__write_graph(self, SLSMG_LARROW_CHAR);

				ui_browser__write_graph(browser, SLSMG_LARROW_CHAR);

				SLsmg_write_char(' ');

			}

		}
@@ -275,27 +275,27 @@ static void disasm_rb_tree__insert(struct rb_root *root, struct browser_disasm_l 
	rb_insert_color(&bdl->rb_node, root);

}



static void annotate_browser__set_top(struct annotate_browser *self,

static void annotate_browser__set_top(struct annotate_browser *browser,

				      struct disasm_line *pos, u32 idx)

{

	unsigned back;



	ui_browser__refresh_dimensions(&self->b);

	back = self->b.height / 2;

	self->b.top_idx = self->b.index = idx;

	ui_browser__refresh_dimensions(&browser->b);

	back = browser->b.height / 2;

	browser->b.top_idx = browser->b.index = idx;



	while (self->b.top_idx != 0 && back != 0) {

	while (browser->b.top_idx != 0 && back != 0) {

		pos = list_entry(pos->node.prev, struct disasm_line, node);



		if (disasm_line__filter(&self->b, &pos->node))

		if (disasm_line__filter(&browser->b, &pos->node))

			continue;



		--self->b.top_idx;

		--browser->b.top_idx;

		--back;

	}



	self->b.top = pos;

	self->b.navkeypressed = true;

	browser->b.top = pos;

	browser->b.navkeypressed = true;

}



static void annotate_browser__set_rb_top(struct annotate_browser *browser,
@@ -600,33 +600,33 @@ static void annotate_browser__update_addr_width(struct annotate_browser *browser 
		browser->addr_width += browser->jumps_width + 1;

}



static int annotate_browser__run(struct annotate_browser *self, int evidx,

static int annotate_browser__run(struct annotate_browser *browser, int evidx,

				 void(*timer)(void *arg),

				 void *arg, int delay_secs)

{

	struct rb_node *nd = NULL;

	struct map_symbol *ms = self->b.priv;

	struct map_symbol *ms = browser->b.priv;

	struct symbol *sym = ms->sym;

	const char *help = "Press 'h' for help on key bindings";

	int key;



	if (ui_browser__show(&self->b, sym->name, help) < 0)

	if (ui_browser__show(&browser->b, sym->name, help) < 0)

		return -1;



	annotate_browser__calc_percent(self, evidx);

	annotate_browser__calc_percent(browser, evidx);



	if (self->curr_hot) {

		annotate_browser__set_rb_top(self, self->curr_hot);

		self->b.navkeypressed = false;

	if (browser->curr_hot) {

		annotate_browser__set_rb_top(browser, browser->curr_hot);

		browser->b.navkeypressed = false;

	}



	nd = self->curr_hot;

	nd = browser->curr_hot;



	while (1) {

		key = ui_browser__run(&self->b, delay_secs);

		key = ui_browser__run(&browser->b, delay_secs);



		if (delay_secs != 0) {

			annotate_browser__calc_percent(self, evidx);

			annotate_browser__calc_percent(browser, evidx);

			/*

			 * Current line focus got out of the list of most active

			 * lines, NULL it so that if TAB|UNTAB is pressed, we
@@ -648,21 +648,21 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx, 
			if (nd != NULL) {

				nd = rb_prev(nd);

				if (nd == NULL)

					nd = rb_last(&self->entries);

					nd = rb_last(&browser->entries);

			} else

				nd = self->curr_hot;

				nd = browser->curr_hot;

			break;

		case K_UNTAB:

			if (nd != NULL)

				nd = rb_next(nd);

				if (nd == NULL)

					nd = rb_first(&self->entries);

					nd = rb_first(&browser->entries);

			else

				nd = self->curr_hot;

				nd = browser->curr_hot;

			break;

		case K_F1:

		case 'h':

			ui_browser__help_window(&self->b,

			ui_browser__help_window(&browser->b,

		"UP/DOWN/PGUP\n"

		"PGDN/SPACE    Navigate\n"

		"q/ESC/CTRL+C  Exit\n\n"
@@ -678,62 +678,62 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx, 
		"?             Search previous string\n");

			continue;

		case 'H':

			nd = self->curr_hot;

			nd = browser->curr_hot;

			break;

		case 's':

			if (annotate_browser__toggle_source(self))

			if (annotate_browser__toggle_source(browser))

				ui_helpline__puts(help);

			continue;

		case 'o':

			annotate_browser__opts.use_offset = !annotate_browser__opts.use_offset;

			annotate_browser__update_addr_width(self);

			annotate_browser__update_addr_width(browser);

			continue;

		case 'j':

			annotate_browser__opts.jump_arrows = !annotate_browser__opts.jump_arrows;

			continue;

		case 'J':

			annotate_browser__opts.show_nr_jumps = !annotate_browser__opts.show_nr_jumps;

			annotate_browser__update_addr_width(self);

			annotate_browser__update_addr_width(browser);

			continue;

		case '/':

			if (annotate_browser__search(self, delay_secs)) {

			if (annotate_browser__search(browser, delay_secs)) {

show_help:

				ui_helpline__puts(help);

			}

			continue;

		case 'n':

			if (self->searching_backwards ?

			    annotate_browser__continue_search_reverse(self, delay_secs) :

			    annotate_browser__continue_search(self, delay_secs))

			if (browser->searching_backwards ?

			    annotate_browser__continue_search_reverse(browser, delay_secs) :

			    annotate_browser__continue_search(browser, delay_secs))

				goto show_help;

			continue;

		case '?':

			if (annotate_browser__search_reverse(self, delay_secs))

			if (annotate_browser__search_reverse(browser, delay_secs))

				goto show_help;

			continue;

		case 'D': {

			static int seq;

			ui_helpline__pop();

			ui_helpline__fpush("%d: nr_ent=%d, height=%d, idx=%d, top_idx=%d, nr_asm_entries=%d",

					   seq++, self->b.nr_entries,

					   self->b.height,

					   self->b.index,

					   self->b.top_idx,

					   self->nr_asm_entries);

					   seq++, browser->b.nr_entries,

					   browser->b.height,

					   browser->b.index,

					   browser->b.top_idx,

					   browser->nr_asm_entries);

		}

			continue;

		case K_ENTER:

		case K_RIGHT:

			if (self->selection == NULL)

			if (browser->selection == NULL)

				ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");

			else if (self->selection->offset == -1)

			else if (browser->selection->offset == -1)

				ui_helpline__puts("Actions are only available for assembly lines.");

			else if (!self->selection->ins) {

				if (strcmp(self->selection->name, "retq"))

			else if (!browser->selection->ins) {

				if (strcmp(browser->selection->name, "retq"))

					goto show_sup_ins;

				goto out;

			} else if (!(annotate_browser__jump(self) ||

				     annotate_browser__callq(self, evidx, timer, arg, delay_secs))) {

			} else if (!(annotate_browser__jump(browser) ||

				     annotate_browser__callq(browser, evidx, timer, arg, delay_secs))) {

show_sup_ins:

				ui_helpline__puts("Actions are only available for 'callq', 'retq' & jump instructions.");

			}
@@ -748,10 +748,10 @@ show_sup_ins: 
		}



		if (nd != NULL)

			annotate_browser__set_rb_top(self, nd);

			annotate_browser__set_rb_top(browser, nd);

	}

out:

	ui_browser__hide(&self->b);

	ui_browser__hide(&browser->b);

	return key;

}

tools/perf/ui/browsers/hists.c

+169 −169

File changed.

Preview size limit exceeded, changes collapsed.