1/* 2 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com> 3 * 4 * Refactored from builtin-top.c, see that files for further copyright notes. 5 * 6 * Released under the GPL v2. (and only v2, not any later version) 7 */ 8 9#include "cpumap.h" 10#include "event.h" 11#include "evlist.h" 12#include "evsel.h" 13#include "parse-events.h" 14#include "symbol.h" 15#include "top.h" 16#include <inttypes.h> 17 18/* 19 * Ordering weight: count-1 * count-2 * ... / count-n 20 */ 21static double sym_weight(const struct sym_entry *sym, struct perf_top *top) 22{ 23 double weight = sym->snap_count; 24 int counter; 25 26 if (!top->display_weighted) 27 return weight; 28 29 for (counter = 1; counter < top->evlist->nr_entries - 1; counter++) 30 weight *= sym->count[counter]; 31 32 weight /= (sym->count[counter] + 1); 33 34 return weight; 35} 36 37static void perf_top__remove_active_sym(struct perf_top *top, struct sym_entry *syme) 38{ 39 pthread_mutex_lock(&top->active_symbols_lock); 40 list_del_init(&syme->node); 41 pthread_mutex_unlock(&top->active_symbols_lock); 42} 43 44static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se) 45{ 46 struct rb_node **p = &tree->rb_node; 47 struct rb_node *parent = NULL; 48 struct sym_entry *iter; 49 50 while (*p != NULL) { 51 parent = *p; 52 iter = rb_entry(parent, struct sym_entry, rb_node); 53 54 if (se->weight > iter->weight) 55 p = &(*p)->rb_left; 56 else 57 p = &(*p)->rb_right; 58 } 59 60 rb_link_node(&se->rb_node, parent, p); 61 rb_insert_color(&se->rb_node, tree); 62} 63 64#define SNPRINTF(buf, size, fmt, args...) \ 65({ \ 66 size_t r = snprintf(buf, size, fmt, ## args); \ 67 r > size ? size : r; \ 68}) 69 70size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size) 71{ 72 struct perf_evsel *counter; 73 float samples_per_sec = top->samples / top->delay_secs; 74 float ksamples_per_sec = top->kernel_samples / top->delay_secs; 75 float esamples_percent = (100.0 * top->exact_samples) / top->samples; 76 size_t ret = 0; 77 78 if (!perf_guest) { 79 ret = SNPRINTF(bf, size, 80 " PerfTop:%8.0f irqs/sec kernel:%4.1f%%" 81 " exact: %4.1f%% [", samples_per_sec, 82 100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) / 83 samples_per_sec)), 84 esamples_percent); 85 } else { 86 float us_samples_per_sec = top->us_samples / top->delay_secs; 87 float guest_kernel_samples_per_sec = top->guest_kernel_samples / top->delay_secs; 88 float guest_us_samples_per_sec = top->guest_us_samples / top->delay_secs; 89 90 ret = SNPRINTF(bf, size, 91 " PerfTop:%8.0f irqs/sec kernel:%4.1f%% us:%4.1f%%" 92 " guest kernel:%4.1f%% guest us:%4.1f%%" 93 " exact: %4.1f%% [", samples_per_sec, 94 100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) / 95 samples_per_sec)), 96 100.0 - (100.0 * ((samples_per_sec - us_samples_per_sec) / 97 samples_per_sec)), 98 100.0 - (100.0 * ((samples_per_sec - 99 guest_kernel_samples_per_sec) / 100 samples_per_sec)), 101 100.0 - (100.0 * ((samples_per_sec - 102 guest_us_samples_per_sec) / 103 samples_per_sec)), 104 esamples_percent); 105 } 106 107 if (top->evlist->nr_entries == 1 || !top->display_weighted) { 108 struct perf_evsel *first; 109 first = list_entry(top->evlist->entries.next, struct perf_evsel, node); 110 ret += SNPRINTF(bf + ret, size - ret, "%" PRIu64 "%s ", 111 (uint64_t)first->attr.sample_period, 112 top->freq ? "Hz" : ""); 113 } 114 115 if (!top->display_weighted) { 116 ret += SNPRINTF(bf + ret, size - ret, "%s", 117 event_name(top->sym_evsel)); 118 } else { 119 /* 120 * Don't let events eat all the space. Leaving 30 bytes 121 * for the rest should be enough. 122 */ 123 size_t last_pos = size - 30; 124 125 list_for_each_entry(counter, &top->evlist->entries, node) { 126 ret += SNPRINTF(bf + ret, size - ret, "%s%s", 127 counter->idx ? "/" : "", 128 event_name(counter)); 129 if (ret > last_pos) { 130 sprintf(bf + last_pos - 3, ".."); 131 ret = last_pos - 1; 132 break; 133 } 134 } 135 } 136 137 ret += SNPRINTF(bf + ret, size - ret, "], "); 138 139 if (top->target_pid != -1) 140 ret += SNPRINTF(bf + ret, size - ret, " (target_pid: %d", 141 top->target_pid); 142 else if (top->target_tid != -1) 143 ret += SNPRINTF(bf + ret, size - ret, " (target_tid: %d", 144 top->target_tid); 145 else 146 ret += SNPRINTF(bf + ret, size - ret, " (all"); 147 148 if (top->cpu_list) 149 ret += SNPRINTF(bf + ret, size - ret, ", CPU%s: %s)", 150 top->evlist->cpus->nr > 1 ? "s" : "", top->cpu_list); 151 else { 152 if (top->target_tid != -1) 153 ret += SNPRINTF(bf + ret, size - ret, ")"); 154 else 155 ret += SNPRINTF(bf + ret, size - ret, ", %d CPU%s)", 156 top->evlist->cpus->nr, 157 top->evlist->cpus->nr > 1 ? "s" : ""); 158 } 159 160 return ret; 161} 162 163void perf_top__reset_sample_counters(struct perf_top *top) 164{ 165 top->samples = top->us_samples = top->kernel_samples = 166 top->exact_samples = top->guest_kernel_samples = 167 top->guest_us_samples = 0; 168} 169 170float perf_top__decay_samples(struct perf_top *top, struct rb_root *root) 171{ 172 struct sym_entry *syme, *n; 173 float sum_ksamples = 0.0; 174 int snap = !top->display_weighted ? top->sym_evsel->idx : 0, j; 175 176 /* Sort the active symbols */ 177 pthread_mutex_lock(&top->active_symbols_lock); 178 syme = list_entry(top->active_symbols.next, struct sym_entry, node); 179 pthread_mutex_unlock(&top->active_symbols_lock); 180 181 top->rb_entries = 0; 182 list_for_each_entry_safe_from(syme, n, &top->active_symbols, node) { 183 syme->snap_count = syme->count[snap]; 184 if (syme->snap_count != 0) { 185 186 if ((top->hide_user_symbols && 187 syme->map->dso->kernel == DSO_TYPE_USER) || 188 (top->hide_kernel_symbols && 189 syme->map->dso->kernel == DSO_TYPE_KERNEL)) { 190 perf_top__remove_active_sym(top, syme); 191 continue; 192 } 193 syme->weight = sym_weight(syme, top); 194 195 if ((int)syme->snap_count >= top->count_filter) { 196 rb_insert_active_sym(root, syme); 197 ++top->rb_entries; 198 } 199 sum_ksamples += syme->snap_count; 200 201 for (j = 0; j < top->evlist->nr_entries; j++) 202 syme->count[j] = top->zero ? 0 : syme->count[j] * 7 / 8; 203 } else 204 perf_top__remove_active_sym(top, syme); 205 } 206 207 return sum_ksamples; 208} 209 210/* 211 * Find the longest symbol name that will be displayed 212 */ 213void perf_top__find_widths(struct perf_top *top, struct rb_root *root, 214 int *dso_width, int *dso_short_width, int *sym_width) 215{ 216 struct rb_node *nd; 217 int printed = 0; 218 219 *sym_width = *dso_width = *dso_short_width = 0; 220 221 for (nd = rb_first(root); nd; nd = rb_next(nd)) { 222 struct sym_entry *syme = rb_entry(nd, struct sym_entry, rb_node); 223 struct symbol *sym = sym_entry__symbol(syme); 224 225 if (++printed > top->print_entries || 226 (int)syme->snap_count < top->count_filter) 227 continue; 228 229 if (syme->map->dso->long_name_len > *dso_width) 230 *dso_width = syme->map->dso->long_name_len; 231 232 if (syme->map->dso->short_name_len > *dso_short_width) 233 *dso_short_width = syme->map->dso->short_name_len; 234 235 if (sym->namelen > *sym_width) 236 *sym_width = sym->namelen; 237 } 238} 239