1 // SPDX-License-Identifier: GPL-2.0 2 #include <stdlib.h> 3 #include <string.h> 4 #include <linux/zalloc.h> 5 #include "block-info.h" 6 #include "sort.h" 7 #include "annotate.h" 8 #include "symbol.h" 9 #include "dso.h" 10 #include "map.h" 11 #include "srcline.h" 12 #include "evlist.h" 13 #include "hist.h" 14 #include "ui/browsers/hists.h" 15 16 static struct block_header_column { 17 const char *name; 18 int width; 19 } block_columns[PERF_HPP_REPORT__BLOCK_MAX_INDEX] = { 20 [PERF_HPP_REPORT__BLOCK_TOTAL_CYCLES_PCT] = { 21 .name = "Sampled Cycles%", 22 .width = 15, 23 }, 24 [PERF_HPP_REPORT__BLOCK_LBR_CYCLES] = { 25 .name = "Sampled Cycles", 26 .width = 14, 27 }, 28 [PERF_HPP_REPORT__BLOCK_CYCLES_PCT] = { 29 .name = "Avg Cycles%", 30 .width = 11, 31 }, 32 [PERF_HPP_REPORT__BLOCK_AVG_CYCLES] = { 33 .name = "Avg Cycles", 34 .width = 10, 35 }, 36 [PERF_HPP_REPORT__BLOCK_RANGE] = { 37 .name = "[Program Block Range]", 38 .width = 70, 39 }, 40 [PERF_HPP_REPORT__BLOCK_DSO] = { 41 .name = "Shared Object", 42 .width = 20, 43 } 44 }; 45 46 struct block_info *block_info__get(struct block_info *bi) 47 { 48 if (bi) 49 refcount_inc(&bi->refcnt); 50 return bi; 51 } 52 53 void block_info__put(struct block_info *bi) 54 { 55 if (bi && refcount_dec_and_test(&bi->refcnt)) 56 free(bi); 57 } 58 59 struct block_info *block_info__new(void) 60 { 61 struct block_info *bi = zalloc(sizeof(*bi)); 62 63 if (bi) 64 refcount_set(&bi->refcnt, 1); 65 return bi; 66 } 67 68 int64_t block_info__cmp(struct perf_hpp_fmt *fmt __maybe_unused, 69 struct hist_entry *left, struct hist_entry *right) 70 { 71 struct block_info *bi_l = left->block_info; 72 struct block_info *bi_r = right->block_info; 73 int cmp; 74 75 if (!bi_l->sym || !bi_r->sym) { 76 if (!bi_l->sym && !bi_r->sym) 77 return 0; 78 else if (!bi_l->sym) 79 return -1; 80 else 81 return 1; 82 } 83 84 if (bi_l->sym == bi_r->sym) { 85 if (bi_l->start == bi_r->start) { 86 if (bi_l->end == bi_r->end) 87 return 0; 88 else 89 return (int64_t)(bi_r->end - bi_l->end); 90 } else 91 return (int64_t)(bi_r->start - bi_l->start); 92 } else { 93 cmp = strcmp(bi_l->sym->name, bi_r->sym->name); 94 return cmp; 95 } 96 97 if (bi_l->sym->start != bi_r->sym->start) 98 return (int64_t)(bi_r->sym->start - bi_l->sym->start); 99 100 return (int64_t)(bi_r->sym->end - bi_l->sym->end); 101 } 102 103 static void init_block_info(struct block_info *bi, struct symbol *sym, 104 struct cyc_hist *ch, int offset, 105 u64 total_cycles) 106 { 107 bi->sym = sym; 108 bi->start = ch->start; 109 bi->end = offset; 110 bi->cycles = ch->cycles; 111 bi->cycles_aggr = ch->cycles_aggr; 112 bi->num = ch->num; 113 bi->num_aggr = ch->num_aggr; 114 bi->total_cycles = total_cycles; 115 116 memcpy(bi->cycles_spark, ch->cycles_spark, 117 NUM_SPARKS * sizeof(u64)); 118 } 119 120 int block_info__process_sym(struct hist_entry *he, struct block_hist *bh, 121 u64 *block_cycles_aggr, u64 total_cycles) 122 { 123 struct annotation *notes; 124 struct cyc_hist *ch; 125 static struct addr_location al; 126 u64 cycles = 0; 127 128 if (!he->ms.map || !he->ms.sym) 129 return 0; 130 131 memset(&al, 0, sizeof(al)); 132 al.map = he->ms.map; 133 al.sym = he->ms.sym; 134 135 notes = symbol__annotation(he->ms.sym); 136 if (!notes || !notes->src || !notes->src->cycles_hist) 137 return 0; 138 ch = notes->src->cycles_hist; 139 for (unsigned int i = 0; i < symbol__size(he->ms.sym); i++) { 140 if (ch[i].num_aggr) { 141 struct block_info *bi; 142 struct hist_entry *he_block; 143 144 bi = block_info__new(); 145 if (!bi) 146 return -1; 147 148 init_block_info(bi, he->ms.sym, &ch[i], i, 149 total_cycles); 150 cycles += bi->cycles_aggr / bi->num_aggr; 151 152 he_block = hists__add_entry_block(&bh->block_hists, 153 &al, bi); 154 if (!he_block) { 155 block_info__put(bi); 156 return -1; 157 } 158 } 159 } 160 161 if (block_cycles_aggr) 162 *block_cycles_aggr += cycles; 163 164 return 0; 165 } 166 167 static int block_column_header(struct perf_hpp_fmt *fmt, 168 struct perf_hpp *hpp, 169 struct hists *hists __maybe_unused, 170 int line __maybe_unused, 171 int *span __maybe_unused) 172 { 173 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 174 175 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, 176 block_fmt->header); 177 } 178 179 static int block_column_width(struct perf_hpp_fmt *fmt, 180 struct perf_hpp *hpp __maybe_unused, 181 struct hists *hists __maybe_unused) 182 { 183 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 184 185 return block_fmt->width; 186 } 187 188 static int block_total_cycles_pct_entry(struct perf_hpp_fmt *fmt, 189 struct perf_hpp *hpp, 190 struct hist_entry *he) 191 { 192 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 193 struct block_info *bi = he->block_info; 194 double ratio = 0.0; 195 char buf[16]; 196 197 if (block_fmt->total_cycles) 198 ratio = (double)bi->cycles / (double)block_fmt->total_cycles; 199 200 sprintf(buf, "%.2f%%", 100.0 * ratio); 201 202 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, buf); 203 } 204 205 static int64_t block_total_cycles_pct_sort(struct perf_hpp_fmt *fmt, 206 struct hist_entry *left, 207 struct hist_entry *right) 208 { 209 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 210 struct block_info *bi_l = left->block_info; 211 struct block_info *bi_r = right->block_info; 212 double l, r; 213 214 if (block_fmt->total_cycles) { 215 l = ((double)bi_l->cycles / 216 (double)block_fmt->total_cycles) * 100000.0; 217 r = ((double)bi_r->cycles / 218 (double)block_fmt->total_cycles) * 100000.0; 219 return (int64_t)l - (int64_t)r; 220 } 221 222 return 0; 223 } 224 225 static void cycles_string(u64 cycles, char *buf, int size) 226 { 227 if (cycles >= 1000000) 228 scnprintf(buf, size, "%.1fM", (double)cycles / 1000000.0); 229 else if (cycles >= 1000) 230 scnprintf(buf, size, "%.1fK", (double)cycles / 1000.0); 231 else 232 scnprintf(buf, size, "%1d", cycles); 233 } 234 235 static int block_cycles_lbr_entry(struct perf_hpp_fmt *fmt, 236 struct perf_hpp *hpp, struct hist_entry *he) 237 { 238 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 239 struct block_info *bi = he->block_info; 240 char cycles_buf[16]; 241 242 cycles_string(bi->cycles_aggr, cycles_buf, sizeof(cycles_buf)); 243 244 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, 245 cycles_buf); 246 } 247 248 static int block_cycles_pct_entry(struct perf_hpp_fmt *fmt, 249 struct perf_hpp *hpp, struct hist_entry *he) 250 { 251 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 252 struct block_info *bi = he->block_info; 253 double ratio = 0.0; 254 u64 avg; 255 char buf[16]; 256 257 if (block_fmt->block_cycles && bi->num_aggr) { 258 avg = bi->cycles_aggr / bi->num_aggr; 259 ratio = (double)avg / (double)block_fmt->block_cycles; 260 } 261 262 sprintf(buf, "%.2f%%", 100.0 * ratio); 263 264 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, buf); 265 } 266 267 static int block_avg_cycles_entry(struct perf_hpp_fmt *fmt, 268 struct perf_hpp *hpp, 269 struct hist_entry *he) 270 { 271 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 272 struct block_info *bi = he->block_info; 273 char cycles_buf[16]; 274 275 cycles_string(bi->cycles_aggr / bi->num_aggr, cycles_buf, 276 sizeof(cycles_buf)); 277 278 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, 279 cycles_buf); 280 } 281 282 static int block_range_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 283 struct hist_entry *he) 284 { 285 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 286 struct block_info *bi = he->block_info; 287 char buf[128]; 288 char *start_line, *end_line; 289 290 symbol_conf.disable_add2line_warn = true; 291 292 start_line = map__srcline(he->ms.map, bi->sym->start + bi->start, 293 he->ms.sym); 294 295 end_line = map__srcline(he->ms.map, bi->sym->start + bi->end, 296 he->ms.sym); 297 298 if ((strncmp(start_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0) && 299 (strncmp(end_line, SRCLINE_UNKNOWN, strlen(SRCLINE_UNKNOWN)) != 0)) { 300 scnprintf(buf, sizeof(buf), "[%s -> %s]", 301 start_line, end_line); 302 } else { 303 scnprintf(buf, sizeof(buf), "[%7lx -> %7lx]", 304 bi->start, bi->end); 305 } 306 307 free_srcline(start_line); 308 free_srcline(end_line); 309 310 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, buf); 311 } 312 313 static int block_dso_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, 314 struct hist_entry *he) 315 { 316 struct block_fmt *block_fmt = container_of(fmt, struct block_fmt, fmt); 317 struct map *map = he->ms.map; 318 319 if (map && map->dso) { 320 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, 321 map->dso->short_name); 322 } 323 324 return scnprintf(hpp->buf, hpp->size, "%*s", block_fmt->width, 325 "[unknown]"); 326 } 327 328 static void init_block_header(struct block_fmt *block_fmt) 329 { 330 struct perf_hpp_fmt *fmt = &block_fmt->fmt; 331 332 BUG_ON(block_fmt->idx >= PERF_HPP_REPORT__BLOCK_MAX_INDEX); 333 334 block_fmt->header = block_columns[block_fmt->idx].name; 335 block_fmt->width = block_columns[block_fmt->idx].width; 336 337 fmt->header = block_column_header; 338 fmt->width = block_column_width; 339 } 340 341 static void hpp_register(struct block_fmt *block_fmt, int idx, 342 struct perf_hpp_list *hpp_list) 343 { 344 struct perf_hpp_fmt *fmt = &block_fmt->fmt; 345 346 block_fmt->idx = idx; 347 INIT_LIST_HEAD(&fmt->list); 348 INIT_LIST_HEAD(&fmt->sort_list); 349 350 switch (idx) { 351 case PERF_HPP_REPORT__BLOCK_TOTAL_CYCLES_PCT: 352 fmt->entry = block_total_cycles_pct_entry; 353 fmt->cmp = block_info__cmp; 354 fmt->sort = block_total_cycles_pct_sort; 355 break; 356 case PERF_HPP_REPORT__BLOCK_LBR_CYCLES: 357 fmt->entry = block_cycles_lbr_entry; 358 break; 359 case PERF_HPP_REPORT__BLOCK_CYCLES_PCT: 360 fmt->entry = block_cycles_pct_entry; 361 break; 362 case PERF_HPP_REPORT__BLOCK_AVG_CYCLES: 363 fmt->entry = block_avg_cycles_entry; 364 break; 365 case PERF_HPP_REPORT__BLOCK_RANGE: 366 fmt->entry = block_range_entry; 367 break; 368 case PERF_HPP_REPORT__BLOCK_DSO: 369 fmt->entry = block_dso_entry; 370 break; 371 default: 372 return; 373 } 374 375 init_block_header(block_fmt); 376 perf_hpp_list__column_register(hpp_list, fmt); 377 } 378 379 static void register_block_columns(struct perf_hpp_list *hpp_list, 380 struct block_fmt *block_fmts) 381 { 382 for (int i = 0; i < PERF_HPP_REPORT__BLOCK_MAX_INDEX; i++) 383 hpp_register(&block_fmts[i], i, hpp_list); 384 } 385 386 static void init_block_hist(struct block_hist *bh, struct block_fmt *block_fmts) 387 { 388 __hists__init(&bh->block_hists, &bh->block_list); 389 perf_hpp_list__init(&bh->block_list); 390 bh->block_list.nr_header_lines = 1; 391 392 register_block_columns(&bh->block_list, block_fmts); 393 394 perf_hpp_list__register_sort_field(&bh->block_list, 395 &block_fmts[PERF_HPP_REPORT__BLOCK_TOTAL_CYCLES_PCT].fmt); 396 } 397 398 static void process_block_report(struct hists *hists, 399 struct block_report *block_report, 400 u64 total_cycles) 401 { 402 struct rb_node *next = rb_first_cached(&hists->entries); 403 struct block_hist *bh = &block_report->hist; 404 struct hist_entry *he; 405 406 init_block_hist(bh, block_report->fmts); 407 408 while (next) { 409 he = rb_entry(next, struct hist_entry, rb_node); 410 block_info__process_sym(he, bh, &block_report->cycles, 411 total_cycles); 412 next = rb_next(&he->rb_node); 413 } 414 415 for (int i = 0; i < PERF_HPP_REPORT__BLOCK_MAX_INDEX; i++) { 416 block_report->fmts[i].total_cycles = total_cycles; 417 block_report->fmts[i].block_cycles = block_report->cycles; 418 } 419 420 hists__output_resort(&bh->block_hists, NULL); 421 } 422 423 struct block_report *block_info__create_report(struct evlist *evlist, 424 u64 total_cycles) 425 { 426 struct block_report *block_reports; 427 int nr_hists = evlist->core.nr_entries, i = 0; 428 struct evsel *pos; 429 430 block_reports = calloc(nr_hists, sizeof(struct block_report)); 431 if (!block_reports) 432 return NULL; 433 434 evlist__for_each_entry(evlist, pos) { 435 struct hists *hists = evsel__hists(pos); 436 437 process_block_report(hists, &block_reports[i], total_cycles); 438 i++; 439 } 440 441 return block_reports; 442 } 443 444 int report__browse_block_hists(struct block_hist *bh, float min_percent, 445 struct evsel *evsel, struct perf_env *env, 446 struct annotation_options *annotation_opts) 447 { 448 int ret; 449 450 switch (use_browser) { 451 case 0: 452 symbol_conf.report_individual_block = true; 453 hists__fprintf(&bh->block_hists, true, 0, 0, min_percent, 454 stdout, true); 455 hists__delete_entries(&bh->block_hists); 456 return 0; 457 case 1: 458 symbol_conf.report_individual_block = true; 459 ret = block_hists_tui_browse(bh, evsel, min_percent, 460 env, annotation_opts); 461 hists__delete_entries(&bh->block_hists); 462 return ret; 463 default: 464 return -1; 465 } 466 467 return 0; 468 } 469 470 float block_info__total_cycles_percent(struct hist_entry *he) 471 { 472 struct block_info *bi = he->block_info; 473 474 if (bi->total_cycles) 475 return bi->cycles * 100.0 / bi->total_cycles; 476 477 return 0.0; 478 } 479