From ea251d51d2c7d7233790123227f787c477f567f5 Mon Sep 17 00:00:00 2001 From: Namhyung Kim Date: Mon, 3 Sep 2012 11:53:06 +0900 Subject: perf hists: Introduce perf_hpp for hist period printing Current hist print functions are messy because it has to consider many of command line options and the code doing that is scattered around to places. So when someone wants to add an option to manipulate the hist output it'd very easy to miss to update all of them in sync. And things getting worse as more options/features are added continuously. So I'd like to refactor them using hpp formats and move common code to ui/hist.c in order to make it easy to maintain and to add new features. Signed-off-by: Namhyung Kim Cc: Ingo Molnar Cc: Paul Mackerras Cc: Peter Zijlstra Link: http://lkml.kernel.org/r/1346640790-17197-2-git-send-email-namhyung@kernel.org Signed-off-by: Arnaldo Carvalho de Melo --- tools/perf/ui/hist.c | 340 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 340 insertions(+) create mode 100644 tools/perf/ui/hist.c (limited to 'tools/perf/ui/hist.c') diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c new file mode 100644 index 000000000000..8ccd1f2330d1 --- /dev/null +++ b/tools/perf/ui/hist.c @@ -0,0 +1,340 @@ +#include + +#include "../util/hist.h" +#include "../util/util.h" +#include "../util/sort.h" + + +/* hist period print (hpp) functions */ +static int hpp__header_overhead(struct perf_hpp *hpp) +{ + if (hpp->ptr) + return scnprintf(hpp->buf, hpp->size, "Baseline"); + else + return scnprintf(hpp->buf, hpp->size, "Overhead"); +} + +static int hpp__width_overhead(struct perf_hpp *hpp __used) +{ + return 8; +} + +static int hpp__color_overhead(struct perf_hpp *hpp, struct hist_entry *he) +{ + double percent = 100.0 * he->period / hpp->total_period; + + if (hpp->ptr) { + struct hists *old_hists = hpp->ptr; + u64 total_period = old_hists->stats.total_period; + u64 base_period = he->pair ? he->pair->period : 0; + + if (total_period) + percent = 100.0 * base_period / total_period; + else + percent = 0.0; + } + + return percent_color_snprintf(hpp->buf, hpp->size, " %5.2f%%", percent); +} + +static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he) +{ + double percent = 100.0 * he->period / hpp->total_period; + + if (hpp->ptr) { + struct hists *old_hists = hpp->ptr; + u64 total_period = old_hists->stats.total_period; + u64 base_period = he->pair ? he->pair->period : 0; + + if (total_period) + percent = 100.0 * base_period / total_period; + else + percent = 0.0; + } + + return scnprintf(hpp->buf, hpp->size, " %5.2f%%", percent); +} + +static int hpp__header_overhead_sys(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, " sys "); +} + +static int hpp__width_overhead_sys(struct perf_hpp *hpp __used) +{ + return 6; +} + +static int hpp__color_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he) +{ + double percent = 100.0 * he->period_sys / hpp->total_period; + return percent_color_snprintf(hpp->buf, hpp->size, "%5.2f%%", percent); +} + +static int hpp__entry_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he) +{ + double percent = 100.0 * he->period_sys / hpp->total_period; + return scnprintf(hpp->buf, hpp->size, "%5.2f%%", percent); +} + +static int hpp__header_overhead_us(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, " user "); +} + +static int hpp__width_overhead_us(struct perf_hpp *hpp __used) +{ + return 6; +} + +static int hpp__color_overhead_us(struct perf_hpp *hpp, struct hist_entry *he) +{ + double percent = 100.0 * he->period_us / hpp->total_period; + return percent_color_snprintf(hpp->buf, hpp->size, "%5.2f%%", percent); +} + +static int hpp__entry_overhead_us(struct perf_hpp *hpp, struct hist_entry *he) +{ + double percent = 100.0 * he->period_us / hpp->total_period; + return scnprintf(hpp->buf, hpp->size, "%5.2f%%", percent); +} + +static int hpp__header_overhead_guest_sys(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, "guest sys"); +} + +static int hpp__width_overhead_guest_sys(struct perf_hpp *hpp __used) +{ + return 9; +} + +static int hpp__color_overhead_guest_sys(struct perf_hpp *hpp, + struct hist_entry *he) +{ + double percent = 100.0 * he->period_guest_sys / hpp->total_period; + return percent_color_snprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); +} + +static int hpp__entry_overhead_guest_sys(struct perf_hpp *hpp, + struct hist_entry *he) +{ + double percent = 100.0 * he->period_guest_sys / hpp->total_period; + return scnprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); +} + +static int hpp__header_overhead_guest_us(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, "guest usr"); +} + +static int hpp__width_overhead_guest_us(struct perf_hpp *hpp __used) +{ + return 9; +} + +static int hpp__color_overhead_guest_us(struct perf_hpp *hpp, + struct hist_entry *he) +{ + double percent = 100.0 * he->period_guest_us / hpp->total_period; + return percent_color_snprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); +} + +static int hpp__entry_overhead_guest_us(struct perf_hpp *hpp, + struct hist_entry *he) +{ + double percent = 100.0 * he->period_guest_us / hpp->total_period; + return scnprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); +} + +static int hpp__header_samples(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, " Samples "); +} + +static int hpp__width_samples(struct perf_hpp *hpp __used) +{ + return 11; +} + +static int hpp__entry_samples(struct perf_hpp *hpp, struct hist_entry *he) +{ + return scnprintf(hpp->buf, hpp->size, "%11" PRIu64, he->nr_events); +} + +static int hpp__header_period(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, " Period "); +} + +static int hpp__width_period(struct perf_hpp *hpp __used) +{ + return 12; +} + +static int hpp__entry_period(struct perf_hpp *hpp, struct hist_entry *he) +{ + return scnprintf(hpp->buf, hpp->size, "%12" PRIu64, he->period); +} + +static int hpp__header_delta(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, " Delta "); +} + +static int hpp__width_delta(struct perf_hpp *hpp __used) +{ + return 7; +} + +static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he) +{ + struct hists *pair_hists = hpp->ptr; + u64 old_total, new_total; + double old_percent = 0, new_percent = 0; + double diff; + char buf[32]; + + old_total = pair_hists->stats.total_period; + if (old_total > 0 && he->pair) + old_percent = 100.0 * he->pair->period / old_total; + + new_total = hpp->total_period; + if (new_total > 0) + new_percent = 100.0 * he->period / new_total; + + diff = new_percent - old_percent; + if (fabs(diff) < 0.01) + return scnprintf(hpp->buf, hpp->size, " "); + + scnprintf(buf, sizeof(buf), "%+4.2F%%", diff); + return scnprintf(hpp->buf, hpp->size, "%7.7s", buf); +} + +static int hpp__header_displ(struct perf_hpp *hpp) +{ + return scnprintf(hpp->buf, hpp->size, "Displ."); +} + +static int hpp__width_displ(struct perf_hpp *hpp __used) +{ + return 6; +} + +static int hpp__entry_displ(struct perf_hpp *hpp, struct hist_entry *he __used) +{ + char buf[32]; + + if (!hpp->displacement) + return scnprintf(hpp->buf, hpp->size, " "); + + scnprintf(buf, sizeof(buf), "%+4ld", hpp->displacement); + return scnprintf(hpp->buf, hpp->size, "%6.6s", buf); +} + +#define HPP__COLOR_PRINT_FNS(_name) \ + .header = hpp__header_ ## _name, \ + .width = hpp__width_ ## _name, \ + .color = hpp__color_ ## _name, \ + .entry = hpp__entry_ ## _name + +#define HPP__PRINT_FNS(_name) \ + .header = hpp__header_ ## _name, \ + .width = hpp__width_ ## _name, \ + .entry = hpp__entry_ ## _name + +struct perf_hpp_fmt perf_hpp__format[] = { + { .cond = true, HPP__COLOR_PRINT_FNS(overhead) }, + { .cond = false, HPP__COLOR_PRINT_FNS(overhead_sys) }, + { .cond = false, HPP__COLOR_PRINT_FNS(overhead_us) }, + { .cond = false, HPP__COLOR_PRINT_FNS(overhead_guest_sys) }, + { .cond = false, HPP__COLOR_PRINT_FNS(overhead_guest_us) }, + { .cond = false, HPP__PRINT_FNS(samples) }, + { .cond = false, HPP__PRINT_FNS(period) }, + { .cond = false, HPP__PRINT_FNS(delta) }, + { .cond = false, HPP__PRINT_FNS(displ) } +}; + +#undef HPP__COLOR_PRINT_FNS +#undef HPP__PRINT_FNS + +void perf_hpp__init(bool need_pair, bool show_displacement) +{ + if (symbol_conf.show_cpu_utilization) { + perf_hpp__format[PERF_HPP__OVERHEAD_SYS].cond = true; + perf_hpp__format[PERF_HPP__OVERHEAD_US].cond = true; + + if (perf_guest) { + perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].cond = true; + perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].cond = true; + } + } + + if (symbol_conf.show_nr_samples) + perf_hpp__format[PERF_HPP__SAMPLES].cond = true; + + if (symbol_conf.show_total_period) + perf_hpp__format[PERF_HPP__PERIOD].cond = true; + + if (need_pair) { + perf_hpp__format[PERF_HPP__DELTA].cond = true; + + if (show_displacement) + perf_hpp__format[PERF_HPP__DISPL].cond = true; + } +} + +static inline void advance_hpp(struct perf_hpp *hpp, int inc) +{ + hpp->buf += inc; + hpp->size -= inc; +} + +int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he, + bool color) +{ + const char *sep = symbol_conf.field_sep; + char *start = hpp->buf; + int i, ret; + + if (symbol_conf.exclude_other && !he->parent) + return 0; + + for (i = 0; i < PERF_HPP__MAX_INDEX; i++) { + if (!perf_hpp__format[i].cond) + continue; + + if (!sep || i > 0) { + ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: " "); + advance_hpp(hpp, ret); + } + + if (color && perf_hpp__format[i].color) + ret = perf_hpp__format[i].color(hpp, he); + else + ret = perf_hpp__format[i].entry(hpp, he); + + advance_hpp(hpp, ret); + } + + return hpp->buf - start; +} + +int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size, + struct hists *hists) +{ + const char *sep = symbol_conf.field_sep; + struct sort_entry *se; + int ret = 0; + + list_for_each_entry(se, &hist_entry__sort_list, list) { + if (se->elide) + continue; + + ret += scnprintf(s + ret, size - ret, "%s", sep ?: " "); + ret += se->se_snprintf(he, s + ret, size - ret, + hists__col_len(hists, se->se_width_idx)); + } + + return ret; +} -- cgit v1.2.3 From 9ffad987ff565999d91fc2783dd77f08094a743b Mon Sep 17 00:00:00 2001 From: Namhyung Kim Date: Mon, 3 Sep 2012 11:53:07 +0900 Subject: perf hists: Handle field separator properly When a field separator is given, the output format doesn't need to be fancy like aligning to column length, coloring the percent value and so on. And since there's a slight difference to normal format, fix it not to break backward compatibility. Signed-off-by: Namhyung Kim Cc: Ingo Molnar Cc: Paul Mackerras Cc: Peter Zijlstra Link: http://lkml.kernel.org/r/1346640790-17197-3-git-send-email-namhyung@kernel.org Signed-off-by: Arnaldo Carvalho de Melo --- tools/perf/ui/hist.c | 74 ++++++++++++++++++++++++++++++++++------------------ 1 file changed, 48 insertions(+), 26 deletions(-) (limited to 'tools/perf/ui/hist.c') diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c index 8ccd1f2330d1..009adf206c81 100644 --- a/tools/perf/ui/hist.c +++ b/tools/perf/ui/hist.c @@ -8,10 +8,9 @@ /* hist period print (hpp) functions */ static int hpp__header_overhead(struct perf_hpp *hpp) { - if (hpp->ptr) - return scnprintf(hpp->buf, hpp->size, "Baseline"); - else - return scnprintf(hpp->buf, hpp->size, "Overhead"); + const char *fmt = hpp->ptr ? "Baseline" : "Overhead"; + + return scnprintf(hpp->buf, hpp->size, fmt); } static int hpp__width_overhead(struct perf_hpp *hpp __used) @@ -40,6 +39,7 @@ static int hpp__color_overhead(struct perf_hpp *hpp, struct hist_entry *he) static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period / hpp->total_period; + const char *fmt = symbol_conf.field_sep ? "%.2f" : " %5.2f%%"; if (hpp->ptr) { struct hists *old_hists = hpp->ptr; @@ -52,12 +52,14 @@ static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he) percent = 0.0; } - return scnprintf(hpp->buf, hpp->size, " %5.2f%%", percent); + return scnprintf(hpp->buf, hpp->size, fmt, percent); } static int hpp__header_overhead_sys(struct perf_hpp *hpp) { - return scnprintf(hpp->buf, hpp->size, " sys "); + const char *fmt = symbol_conf.field_sep ? "%s" : "%6s"; + + return scnprintf(hpp->buf, hpp->size, fmt, "sys"); } static int hpp__width_overhead_sys(struct perf_hpp *hpp __used) @@ -74,12 +76,16 @@ static int hpp__color_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he) static int hpp__entry_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_sys / hpp->total_period; - return scnprintf(hpp->buf, hpp->size, "%5.2f%%", percent); + const char *fmt = symbol_conf.field_sep ? "%.2f" : "%5.2f%%"; + + return scnprintf(hpp->buf, hpp->size, fmt, percent); } static int hpp__header_overhead_us(struct perf_hpp *hpp) { - return scnprintf(hpp->buf, hpp->size, " user "); + const char *fmt = symbol_conf.field_sep ? "%s" : "%6s"; + + return scnprintf(hpp->buf, hpp->size, fmt, "user"); } static int hpp__width_overhead_us(struct perf_hpp *hpp __used) @@ -96,7 +102,9 @@ static int hpp__color_overhead_us(struct perf_hpp *hpp, struct hist_entry *he) static int hpp__entry_overhead_us(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_us / hpp->total_period; - return scnprintf(hpp->buf, hpp->size, "%5.2f%%", percent); + const char *fmt = symbol_conf.field_sep ? "%.2f" : "%5.2f%%"; + + return scnprintf(hpp->buf, hpp->size, fmt, percent); } static int hpp__header_overhead_guest_sys(struct perf_hpp *hpp) @@ -120,7 +128,9 @@ static int hpp__entry_overhead_guest_sys(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_guest_sys / hpp->total_period; - return scnprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); + const char *fmt = symbol_conf.field_sep ? "%.2f" : " %5.2f%% "; + + return scnprintf(hpp->buf, hpp->size, fmt, percent); } static int hpp__header_overhead_guest_us(struct perf_hpp *hpp) @@ -144,12 +154,16 @@ static int hpp__entry_overhead_guest_us(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_guest_us / hpp->total_period; - return scnprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); + const char *fmt = symbol_conf.field_sep ? "%.2f" : " %5.2f%% "; + + return scnprintf(hpp->buf, hpp->size, fmt, percent); } static int hpp__header_samples(struct perf_hpp *hpp) { - return scnprintf(hpp->buf, hpp->size, " Samples "); + const char *fmt = symbol_conf.field_sep ? "%s" : "%11s"; + + return scnprintf(hpp->buf, hpp->size, fmt, "Samples"); } static int hpp__width_samples(struct perf_hpp *hpp __used) @@ -159,12 +173,16 @@ static int hpp__width_samples(struct perf_hpp *hpp __used) static int hpp__entry_samples(struct perf_hpp *hpp, struct hist_entry *he) { - return scnprintf(hpp->buf, hpp->size, "%11" PRIu64, he->nr_events); + const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%11" PRIu64; + + return scnprintf(hpp->buf, hpp->size, fmt, he->nr_events); } static int hpp__header_period(struct perf_hpp *hpp) { - return scnprintf(hpp->buf, hpp->size, " Period "); + const char *fmt = symbol_conf.field_sep ? "%s" : "%12s"; + + return scnprintf(hpp->buf, hpp->size, fmt, "Period"); } static int hpp__width_period(struct perf_hpp *hpp __used) @@ -174,12 +192,16 @@ static int hpp__width_period(struct perf_hpp *hpp __used) static int hpp__entry_period(struct perf_hpp *hpp, struct hist_entry *he) { - return scnprintf(hpp->buf, hpp->size, "%12" PRIu64, he->period); + const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%12" PRIu64; + + return scnprintf(hpp->buf, hpp->size, fmt, he->period); } static int hpp__header_delta(struct perf_hpp *hpp) { - return scnprintf(hpp->buf, hpp->size, " Delta "); + const char *fmt = symbol_conf.field_sep ? "%s" : "%7s"; + + return scnprintf(hpp->buf, hpp->size, fmt, "Delta"); } static int hpp__width_delta(struct perf_hpp *hpp __used) @@ -193,7 +215,8 @@ static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he) u64 old_total, new_total; double old_percent = 0, new_percent = 0; double diff; - char buf[32]; + const char *fmt = symbol_conf.field_sep ? "%s" : "%7.7s"; + char buf[32] = " "; old_total = pair_hists->stats.total_period; if (old_total > 0 && he->pair) @@ -204,11 +227,10 @@ static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he) new_percent = 100.0 * he->period / new_total; diff = new_percent - old_percent; - if (fabs(diff) < 0.01) - return scnprintf(hpp->buf, hpp->size, " "); + if (fabs(diff) >= 0.01) + scnprintf(buf, sizeof(buf), "%+4.2F%%", diff); - scnprintf(buf, sizeof(buf), "%+4.2F%%", diff); - return scnprintf(hpp->buf, hpp->size, "%7.7s", buf); + return scnprintf(hpp->buf, hpp->size, fmt, buf); } static int hpp__header_displ(struct perf_hpp *hpp) @@ -223,13 +245,13 @@ static int hpp__width_displ(struct perf_hpp *hpp __used) static int hpp__entry_displ(struct perf_hpp *hpp, struct hist_entry *he __used) { - char buf[32]; + const char *fmt = symbol_conf.field_sep ? "%s" : "%6.6s"; + char buf[32] = " "; - if (!hpp->displacement) - return scnprintf(hpp->buf, hpp->size, " "); + if (hpp->displacement) + scnprintf(buf, sizeof(buf), "%+4ld", hpp->displacement); - scnprintf(buf, sizeof(buf), "%+4ld", hpp->displacement); - return scnprintf(hpp->buf, hpp->size, "%6.6s", buf); + return scnprintf(hpp->buf, hpp->size, fmt, buf); } #define HPP__COLOR_PRINT_FNS(_name) \ -- cgit v1.2.3 From 7e62ef44e89e7b7f2c48090a048f2a5dffa838c7 Mon Sep 17 00:00:00 2001 From: Namhyung Kim Date: Mon, 3 Sep 2012 11:53:08 +0900 Subject: perf hists: Use perf_hpp__format->width to calculate the column widths Signed-off-by: Namhyung Kim Cc: Ingo Molnar Cc: Paul Mackerras Cc: Peter Zijlstra Link: http://lkml.kernel.org/r/1346640790-17197-4-git-send-email-namhyung@kernel.org Signed-off-by: Arnaldo Carvalho de Melo --- tools/perf/ui/hist.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) (limited to 'tools/perf/ui/hist.c') diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c index 009adf206c81..031b349a3f84 100644 --- a/tools/perf/ui/hist.c +++ b/tools/perf/ui/hist.c @@ -360,3 +360,30 @@ int hist_entry__sort_snprintf(struct hist_entry *he, char *s, size_t size, return ret; } + +/* + * See hists__fprintf to match the column widths + */ +unsigned int hists__sort_list_width(struct hists *hists) +{ + struct sort_entry *se; + int i, ret = 0; + + for (i = 0; i < PERF_HPP__MAX_INDEX; i++) { + if (!perf_hpp__format[i].cond) + continue; + if (i) + ret += 2; + + ret += perf_hpp__format[i].width(NULL); + } + + list_for_each_entry(se, &hist_entry__sort_list, list) + if (!se->elide) + ret += 2 + hists__col_len(hists, se->se_width_idx); + + if (verbose) /* Addr + origin */ + ret += 3 + BITS_PER_LONG / 4; + + return ret; +} -- cgit v1.2.3 From 1d037ca1648b775277fc96401ec2aa233724906c Mon Sep 17 00:00:00 2001 From: Irina Tirdea Date: Tue, 11 Sep 2012 01:15:03 +0300 Subject: perf tools: Use __maybe_used for unused variables perf defines both __used and __unused variables to use for marking unused variables. The variable __used is defined to __attribute__((__unused__)), which contradicts the kernel definition to __attribute__((__used__)) for new gcc versions. On Android, __used is also defined in system headers and this leads to warnings like: warning: '__used__' attribute ignored __unused is not defined in the kernel and is not a standard definition. If __unused is included everywhere instead of __used, this leads to conflicts with glibc headers, since glibc has a variables with this name in its headers. The best approach is to use __maybe_unused, the definition used in the kernel for __attribute__((unused)). In this way there is only one definition in perf sources (instead of 2 definitions that point to the same thing: __used and __unused) and it works on both Linux and Android. This patch simply replaces all instances of __used and __unused with __maybe_unused. Signed-off-by: Irina Tirdea Acked-by: Pekka Enberg Cc: David Ahern Cc: Ingo Molnar Cc: Namhyung Kim Cc: Paul Mackerras Cc: Peter Zijlstra Cc: Steven Rostedt Link: http://lkml.kernel.org/r/1347315303-29906-7-git-send-email-irina.tirdea@intel.com [ committer note: fixed up conflict with a116e05 in builtin-sched.c ] Signed-off-by: Arnaldo Carvalho de Melo --- tools/perf/ui/hist.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) (limited to 'tools/perf/ui/hist.c') diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c index 031b349a3f84..407e855cccb8 100644 --- a/tools/perf/ui/hist.c +++ b/tools/perf/ui/hist.c @@ -13,7 +13,7 @@ static int hpp__header_overhead(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, fmt); } -static int hpp__width_overhead(struct perf_hpp *hpp __used) +static int hpp__width_overhead(struct perf_hpp *hpp __maybe_unused) { return 8; } @@ -62,7 +62,7 @@ static int hpp__header_overhead_sys(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, fmt, "sys"); } -static int hpp__width_overhead_sys(struct perf_hpp *hpp __used) +static int hpp__width_overhead_sys(struct perf_hpp *hpp __maybe_unused) { return 6; } @@ -88,7 +88,7 @@ static int hpp__header_overhead_us(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, fmt, "user"); } -static int hpp__width_overhead_us(struct perf_hpp *hpp __used) +static int hpp__width_overhead_us(struct perf_hpp *hpp __maybe_unused) { return 6; } @@ -112,7 +112,7 @@ static int hpp__header_overhead_guest_sys(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, "guest sys"); } -static int hpp__width_overhead_guest_sys(struct perf_hpp *hpp __used) +static int hpp__width_overhead_guest_sys(struct perf_hpp *hpp __maybe_unused) { return 9; } @@ -138,7 +138,7 @@ static int hpp__header_overhead_guest_us(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, "guest usr"); } -static int hpp__width_overhead_guest_us(struct perf_hpp *hpp __used) +static int hpp__width_overhead_guest_us(struct perf_hpp *hpp __maybe_unused) { return 9; } @@ -166,7 +166,7 @@ static int hpp__header_samples(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, fmt, "Samples"); } -static int hpp__width_samples(struct perf_hpp *hpp __used) +static int hpp__width_samples(struct perf_hpp *hpp __maybe_unused) { return 11; } @@ -185,7 +185,7 @@ static int hpp__header_period(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, fmt, "Period"); } -static int hpp__width_period(struct perf_hpp *hpp __used) +static int hpp__width_period(struct perf_hpp *hpp __maybe_unused) { return 12; } @@ -204,7 +204,7 @@ static int hpp__header_delta(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, fmt, "Delta"); } -static int hpp__width_delta(struct perf_hpp *hpp __used) +static int hpp__width_delta(struct perf_hpp *hpp __maybe_unused) { return 7; } @@ -238,12 +238,13 @@ static int hpp__header_displ(struct perf_hpp *hpp) return scnprintf(hpp->buf, hpp->size, "Displ."); } -static int hpp__width_displ(struct perf_hpp *hpp __used) +static int hpp__width_displ(struct perf_hpp *hpp __maybe_unused) { return 6; } -static int hpp__entry_displ(struct perf_hpp *hpp, struct hist_entry *he __used) +static int hpp__entry_displ(struct perf_hpp *hpp, + struct hist_entry *he __maybe_unused) { const char *fmt = symbol_conf.field_sep ? "%s" : "%6.6s"; char buf[32] = " "; -- cgit v1.2.3 From 721b3112f5882a6de7b86b9bef5813c80d1223de Mon Sep 17 00:00:00 2001 From: Namhyung Kim Date: Wed, 12 Sep 2012 15:35:05 +0900 Subject: perf hists browser: Fix output for 100.00% Current hpp format functions assume that the output will fit to 6 character including % sign (XX.YY%) so used "%5.2f%%" as a format string. However it might be the case if collapsing resulted in a single entry which has 100.00% (7 character) of period. In this case the output will be shifted by 1 character. Signed-off-by: Namhyung Kim Cc: Ingo Molnar Cc: Paul Mackerras Cc: Peter Zijlstra Link: http://lkml.kernel.org/r/1347431706-7839-1-git-send-email-namhyung@kernel.org Signed-off-by: Arnaldo Carvalho de Melo --- tools/perf/ui/hist.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'tools/perf/ui/hist.c') diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c index 407e855cccb8..e3f8cd46e7d7 100644 --- a/tools/perf/ui/hist.c +++ b/tools/perf/ui/hist.c @@ -33,13 +33,13 @@ static int hpp__color_overhead(struct perf_hpp *hpp, struct hist_entry *he) percent = 0.0; } - return percent_color_snprintf(hpp->buf, hpp->size, " %5.2f%%", percent); + return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%%", percent); } static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period / hpp->total_period; - const char *fmt = symbol_conf.field_sep ? "%.2f" : " %5.2f%%"; + const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%%"; if (hpp->ptr) { struct hists *old_hists = hpp->ptr; @@ -57,52 +57,52 @@ static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he) static int hpp__header_overhead_sys(struct perf_hpp *hpp) { - const char *fmt = symbol_conf.field_sep ? "%s" : "%6s"; + const char *fmt = symbol_conf.field_sep ? "%s" : "%7s"; return scnprintf(hpp->buf, hpp->size, fmt, "sys"); } static int hpp__width_overhead_sys(struct perf_hpp *hpp __maybe_unused) { - return 6; + return 7; } static int hpp__color_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_sys / hpp->total_period; - return percent_color_snprintf(hpp->buf, hpp->size, "%5.2f%%", percent); + return percent_color_snprintf(hpp->buf, hpp->size, "%6.2f%%", percent); } static int hpp__entry_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_sys / hpp->total_period; - const char *fmt = symbol_conf.field_sep ? "%.2f" : "%5.2f%%"; + const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%"; return scnprintf(hpp->buf, hpp->size, fmt, percent); } static int hpp__header_overhead_us(struct perf_hpp *hpp) { - const char *fmt = symbol_conf.field_sep ? "%s" : "%6s"; + const char *fmt = symbol_conf.field_sep ? "%s" : "%7s"; return scnprintf(hpp->buf, hpp->size, fmt, "user"); } static int hpp__width_overhead_us(struct perf_hpp *hpp __maybe_unused) { - return 6; + return 7; } static int hpp__color_overhead_us(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_us / hpp->total_period; - return percent_color_snprintf(hpp->buf, hpp->size, "%5.2f%%", percent); + return percent_color_snprintf(hpp->buf, hpp->size, "%6.2f%%", percent); } static int hpp__entry_overhead_us(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_us / hpp->total_period; - const char *fmt = symbol_conf.field_sep ? "%.2f" : "%5.2f%%"; + const char *fmt = symbol_conf.field_sep ? "%.2f" : "%6.2f%%"; return scnprintf(hpp->buf, hpp->size, fmt, percent); } @@ -121,14 +121,14 @@ static int hpp__color_overhead_guest_sys(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_guest_sys / hpp->total_period; - return percent_color_snprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); + return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%% ", percent); } static int hpp__entry_overhead_guest_sys(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_guest_sys / hpp->total_period; - const char *fmt = symbol_conf.field_sep ? "%.2f" : " %5.2f%% "; + const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%% "; return scnprintf(hpp->buf, hpp->size, fmt, percent); } @@ -147,14 +147,14 @@ static int hpp__color_overhead_guest_us(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_guest_us / hpp->total_period; - return percent_color_snprintf(hpp->buf, hpp->size, " %5.2f%% ", percent); + return percent_color_snprintf(hpp->buf, hpp->size, " %6.2f%% ", percent); } static int hpp__entry_overhead_guest_us(struct perf_hpp *hpp, struct hist_entry *he) { double percent = 100.0 * he->period_guest_us / hpp->total_period; - const char *fmt = symbol_conf.field_sep ? "%.2f" : " %5.2f%% "; + const char *fmt = symbol_conf.field_sep ? "%.2f" : " %6.2f%% "; return scnprintf(hpp->buf, hpp->size, fmt, percent); } -- cgit v1.2.3