1 #include <math.h> 2 #include <linux/compiler.h> 3 4 #include "../util/hist.h" 5 #include "../util/util.h" 6 #include "../util/sort.h" 7 #include "../util/evsel.h" 8 9 /* hist period print (hpp) functions */ 10 11 #define hpp__call_print_fn(hpp, fn, fmt, ...) \ 12 ({ \ 13 int __ret = fn(hpp, fmt, ##__VA_ARGS__); \ 14 advance_hpp(hpp, __ret); \ 15 __ret; \ 16 }) 17 18 int __hpp__fmt(struct perf_hpp *hpp, struct hist_entry *he, 19 hpp_field_fn get_field, const char *fmt, 20 hpp_snprint_fn print_fn, bool fmt_percent) 21 { 22 int ret; 23 struct hists *hists = he->hists; 24 struct perf_evsel *evsel = hists_to_evsel(hists); 25 char *buf = hpp->buf; 26 size_t size = hpp->size; 27 28 if (fmt_percent) { 29 double percent = 0.0; 30 u64 total = hists__total_period(hists); 31 32 if (total) 33 percent = 100.0 * get_field(he) / total; 34 35 ret = hpp__call_print_fn(hpp, print_fn, fmt, percent); 36 } else 37 ret = hpp__call_print_fn(hpp, print_fn, fmt, get_field(he)); 38 39 if (perf_evsel__is_group_event(evsel)) { 40 int prev_idx, idx_delta; 41 struct hist_entry *pair; 42 int nr_members = evsel->nr_members; 43 44 prev_idx = perf_evsel__group_idx(evsel); 45 46 list_for_each_entry(pair, &he->pairs.head, pairs.node) { 47 u64 period = get_field(pair); 48 u64 total = hists__total_period(pair->hists); 49 50 if (!total) 51 continue; 52 53 evsel = hists_to_evsel(pair->hists); 54 idx_delta = perf_evsel__group_idx(evsel) - prev_idx - 1; 55 56 while (idx_delta--) { 57 /* 58 * zero-fill group members in the middle which 59 * have no sample 60 */ 61 if (fmt_percent) { 62 ret += hpp__call_print_fn(hpp, print_fn, 63 fmt, 0.0); 64 } else { 65 ret += hpp__call_print_fn(hpp, print_fn, 66 fmt, 0ULL); 67 } 68 } 69 70 if (fmt_percent) { 71 ret += hpp__call_print_fn(hpp, print_fn, fmt, 72 100.0 * period / total); 73 } else { 74 ret += hpp__call_print_fn(hpp, print_fn, fmt, 75 period); 76 } 77 78 prev_idx = perf_evsel__group_idx(evsel); 79 } 80 81 idx_delta = nr_members - prev_idx - 1; 82 83 while (idx_delta--) { 84 /* 85 * zero-fill group members at last which have no sample 86 */ 87 if (fmt_percent) { 88 ret += hpp__call_print_fn(hpp, print_fn, 89 fmt, 0.0); 90 } else { 91 ret += hpp__call_print_fn(hpp, print_fn, 92 fmt, 0ULL); 93 } 94 } 95 } 96 97 /* 98 * Restore original buf and size as it's where caller expects 99 * the result will be saved. 100 */ 101 hpp->buf = buf; 102 hpp->size = size; 103 104 return ret; 105 } 106 107 static int field_cmp(u64 field_a, u64 field_b) 108 { 109 if (field_a > field_b) 110 return 1; 111 if (field_a < field_b) 112 return -1; 113 return 0; 114 } 115 116 static int __hpp__sort(struct hist_entry *a, struct hist_entry *b, 117 hpp_field_fn get_field) 118 { 119 s64 ret; 120 int i, nr_members; 121 struct perf_evsel *evsel; 122 struct hist_entry *pair; 123 u64 *fields_a, *fields_b; 124 125 ret = field_cmp(get_field(a), get_field(b)); 126 if (ret || !symbol_conf.event_group) 127 return ret; 128 129 evsel = hists_to_evsel(a->hists); 130 if (!perf_evsel__is_group_event(evsel)) 131 return ret; 132 133 nr_members = evsel->nr_members; 134 fields_a = calloc(sizeof(*fields_a), nr_members); 135 fields_b = calloc(sizeof(*fields_b), nr_members); 136 137 if (!fields_a || !fields_b) 138 goto out; 139 140 list_for_each_entry(pair, &a->pairs.head, pairs.node) { 141 evsel = hists_to_evsel(pair->hists); 142 fields_a[perf_evsel__group_idx(evsel)] = get_field(pair); 143 } 144 145 list_for_each_entry(pair, &b->pairs.head, pairs.node) { 146 evsel = hists_to_evsel(pair->hists); 147 fields_b[perf_evsel__group_idx(evsel)] = get_field(pair); 148 } 149 150 for (i = 1; i < nr_members; i++) { 151 ret = field_cmp(fields_a[i], fields_b[i]); 152 if (ret) 153 break; 154 } 155 156 out: 157 free(fields_a); 158 free(fields_b); 159 160 return ret; 161 } 162 163 #define __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ 164 static int hpp__header_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 165 struct perf_hpp *hpp, \ 166 struct perf_evsel *evsel) \ 167 { \ 168 int len = _min_width; \ 169 \ 170 if (symbol_conf.event_group) \ 171 len = max(len, evsel->nr_members * _unit_width); \ 172 \ 173 return scnprintf(hpp->buf, hpp->size, "%*s", len, _str); \ 174 } 175 176 #define __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ 177 static int hpp__width_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 178 struct perf_hpp *hpp __maybe_unused, \ 179 struct perf_evsel *evsel) \ 180 { \ 181 int len = _min_width; \ 182 \ 183 if (symbol_conf.event_group) \ 184 len = max(len, evsel->nr_members * _unit_width); \ 185 \ 186 return len; \ 187 } 188 189 static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) 190 { 191 va_list args; 192 ssize_t ssize = hpp->size; 193 double percent; 194 int ret; 195 196 va_start(args, fmt); 197 percent = va_arg(args, double); 198 ret = value_color_snprintf(hpp->buf, hpp->size, fmt, percent); 199 va_end(args); 200 201 return (ret >= ssize) ? (ssize - 1) : ret; 202 } 203 204 static int hpp_entry_scnprintf(struct perf_hpp *hpp, const char *fmt, ...) 205 { 206 va_list args; 207 ssize_t ssize = hpp->size; 208 int ret; 209 210 va_start(args, fmt); 211 ret = vsnprintf(hpp->buf, hpp->size, fmt, args); 212 va_end(args); 213 214 return (ret >= ssize) ? (ssize - 1) : ret; 215 } 216 217 #define __HPP_COLOR_PERCENT_FN(_type, _field) \ 218 static u64 he_get_##_field(struct hist_entry *he) \ 219 { \ 220 return he->stat._field; \ 221 } \ 222 \ 223 static int hpp__color_##_type(struct perf_hpp_fmt *fmt __maybe_unused, \ 224 struct perf_hpp *hpp, struct hist_entry *he) \ 225 { \ 226 return __hpp__fmt(hpp, he, he_get_##_field, " %6.2f%%", \ 227 hpp_color_scnprintf, true); \ 228 } 229 230 #define __HPP_ENTRY_PERCENT_FN(_type, _field) \ 231 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \ 232 struct perf_hpp *hpp, struct hist_entry *he) \ 233 { \ 234 const char *fmt = symbol_conf.field_sep ? " %.2f" : " %6.2f%%"; \ 235 return __hpp__fmt(hpp, he, he_get_##_field, fmt, \ 236 hpp_entry_scnprintf, true); \ 237 } 238 239 #define __HPP_SORT_FN(_type, _field) \ 240 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \ 241 { \ 242 return __hpp__sort(a, b, he_get_##_field); \ 243 } 244 245 #define __HPP_ENTRY_RAW_FN(_type, _field) \ 246 static u64 he_get_raw_##_field(struct hist_entry *he) \ 247 { \ 248 return he->stat._field; \ 249 } \ 250 \ 251 static int hpp__entry_##_type(struct perf_hpp_fmt *_fmt __maybe_unused, \ 252 struct perf_hpp *hpp, struct hist_entry *he) \ 253 { \ 254 const char *fmt = symbol_conf.field_sep ? " %"PRIu64 : " %11"PRIu64; \ 255 return __hpp__fmt(hpp, he, he_get_raw_##_field, fmt, \ 256 hpp_entry_scnprintf, false); \ 257 } 258 259 #define __HPP_SORT_RAW_FN(_type, _field) \ 260 static int64_t hpp__sort_##_type(struct hist_entry *a, struct hist_entry *b) \ 261 { \ 262 return __hpp__sort(a, b, he_get_raw_##_field); \ 263 } 264 265 266 #define HPP_PERCENT_FNS(_type, _str, _field, _min_width, _unit_width) \ 267 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ 268 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ 269 __HPP_COLOR_PERCENT_FN(_type, _field) \ 270 __HPP_ENTRY_PERCENT_FN(_type, _field) \ 271 __HPP_SORT_FN(_type, _field) 272 273 #define HPP_RAW_FNS(_type, _str, _field, _min_width, _unit_width) \ 274 __HPP_HEADER_FN(_type, _str, _min_width, _unit_width) \ 275 __HPP_WIDTH_FN(_type, _min_width, _unit_width) \ 276 __HPP_ENTRY_RAW_FN(_type, _field) \ 277 __HPP_SORT_RAW_FN(_type, _field) 278 279 280 HPP_PERCENT_FNS(overhead, "Overhead", period, 8, 8) 281 HPP_PERCENT_FNS(overhead_sys, "sys", period_sys, 8, 8) 282 HPP_PERCENT_FNS(overhead_us, "usr", period_us, 8, 8) 283 HPP_PERCENT_FNS(overhead_guest_sys, "guest sys", period_guest_sys, 9, 8) 284 HPP_PERCENT_FNS(overhead_guest_us, "guest usr", period_guest_us, 9, 8) 285 286 HPP_RAW_FNS(samples, "Samples", nr_events, 12, 12) 287 HPP_RAW_FNS(period, "Period", period, 12, 12) 288 289 static int64_t hpp__nop_cmp(struct hist_entry *a __maybe_unused, 290 struct hist_entry *b __maybe_unused) 291 { 292 return 0; 293 } 294 295 #define HPP__COLOR_PRINT_FNS(_name) \ 296 { \ 297 .header = hpp__header_ ## _name, \ 298 .width = hpp__width_ ## _name, \ 299 .color = hpp__color_ ## _name, \ 300 .entry = hpp__entry_ ## _name, \ 301 .cmp = hpp__nop_cmp, \ 302 .collapse = hpp__nop_cmp, \ 303 .sort = hpp__sort_ ## _name, \ 304 } 305 306 #define HPP__PRINT_FNS(_name) \ 307 { \ 308 .header = hpp__header_ ## _name, \ 309 .width = hpp__width_ ## _name, \ 310 .entry = hpp__entry_ ## _name, \ 311 .cmp = hpp__nop_cmp, \ 312 .collapse = hpp__nop_cmp, \ 313 .sort = hpp__sort_ ## _name, \ 314 } 315 316 struct perf_hpp_fmt perf_hpp__format[] = { 317 HPP__COLOR_PRINT_FNS(overhead), 318 HPP__COLOR_PRINT_FNS(overhead_sys), 319 HPP__COLOR_PRINT_FNS(overhead_us), 320 HPP__COLOR_PRINT_FNS(overhead_guest_sys), 321 HPP__COLOR_PRINT_FNS(overhead_guest_us), 322 HPP__PRINT_FNS(samples), 323 HPP__PRINT_FNS(period) 324 }; 325 326 LIST_HEAD(perf_hpp__list); 327 LIST_HEAD(perf_hpp__sort_list); 328 329 330 #undef HPP__COLOR_PRINT_FNS 331 #undef HPP__PRINT_FNS 332 333 #undef HPP_PERCENT_FNS 334 #undef HPP_RAW_FNS 335 336 #undef __HPP_HEADER_FN 337 #undef __HPP_WIDTH_FN 338 #undef __HPP_COLOR_PERCENT_FN 339 #undef __HPP_ENTRY_PERCENT_FN 340 #undef __HPP_ENTRY_RAW_FN 341 342 343 void perf_hpp__init(void) 344 { 345 struct list_head *list; 346 int i; 347 348 for (i = 0; i < PERF_HPP__MAX_INDEX; i++) { 349 struct perf_hpp_fmt *fmt = &perf_hpp__format[i]; 350 351 INIT_LIST_HEAD(&fmt->list); 352 353 /* sort_list may be linked by setup_sorting() */ 354 if (fmt->sort_list.next == NULL) 355 INIT_LIST_HEAD(&fmt->sort_list); 356 } 357 358 /* 359 * If user specified field order, no need to setup default fields. 360 */ 361 if (field_order) 362 return; 363 364 perf_hpp__column_enable(PERF_HPP__OVERHEAD); 365 366 if (symbol_conf.show_cpu_utilization) { 367 perf_hpp__column_enable(PERF_HPP__OVERHEAD_SYS); 368 perf_hpp__column_enable(PERF_HPP__OVERHEAD_US); 369 370 if (perf_guest) { 371 perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_SYS); 372 perf_hpp__column_enable(PERF_HPP__OVERHEAD_GUEST_US); 373 } 374 } 375 376 if (symbol_conf.show_nr_samples) 377 perf_hpp__column_enable(PERF_HPP__SAMPLES); 378 379 if (symbol_conf.show_total_period) 380 perf_hpp__column_enable(PERF_HPP__PERIOD); 381 382 /* prepend overhead field for backward compatiblity. */ 383 list = &perf_hpp__format[PERF_HPP__OVERHEAD].sort_list; 384 if (list_empty(list)) 385 list_add(list, &perf_hpp__sort_list); 386 } 387 388 void perf_hpp__column_register(struct perf_hpp_fmt *format) 389 { 390 list_add_tail(&format->list, &perf_hpp__list); 391 } 392 393 void perf_hpp__register_sort_field(struct perf_hpp_fmt *format) 394 { 395 list_add_tail(&format->sort_list, &perf_hpp__sort_list); 396 } 397 398 void perf_hpp__column_enable(unsigned col) 399 { 400 BUG_ON(col >= PERF_HPP__MAX_INDEX); 401 perf_hpp__column_register(&perf_hpp__format[col]); 402 } 403 404 void perf_hpp__setup_output_field(void) 405 { 406 struct perf_hpp_fmt *fmt; 407 408 /* append sort keys to output field */ 409 perf_hpp__for_each_sort_list(fmt) { 410 if (!list_empty(&fmt->list)) 411 continue; 412 413 /* 414 * sort entry fields are dynamically created, 415 * so they can share a same sort key even though 416 * the list is empty. 417 */ 418 if (perf_hpp__is_sort_entry(fmt)) { 419 struct perf_hpp_fmt *pos; 420 421 perf_hpp__for_each_format(pos) { 422 if (perf_hpp__same_sort_entry(pos, fmt)) 423 goto next; 424 } 425 } 426 427 perf_hpp__column_register(fmt); 428 next: 429 continue; 430 } 431 } 432 433 void perf_hpp__append_sort_keys(void) 434 { 435 struct perf_hpp_fmt *fmt; 436 437 /* append output fields to sort keys */ 438 perf_hpp__for_each_format(fmt) { 439 if (!list_empty(&fmt->sort_list)) 440 continue; 441 442 /* 443 * sort entry fields are dynamically created, 444 * so they can share a same sort key even though 445 * the list is empty. 446 */ 447 if (perf_hpp__is_sort_entry(fmt)) { 448 struct perf_hpp_fmt *pos; 449 450 perf_hpp__for_each_sort_list(pos) { 451 if (perf_hpp__same_sort_entry(pos, fmt)) 452 goto next; 453 } 454 } 455 456 perf_hpp__register_sort_field(fmt); 457 next: 458 continue; 459 } 460 } 461 462 void perf_hpp__reset_output_field(void) 463 { 464 struct perf_hpp_fmt *fmt, *tmp; 465 466 /* reset output fields */ 467 perf_hpp__for_each_format_safe(fmt, tmp) { 468 list_del_init(&fmt->list); 469 list_del_init(&fmt->sort_list); 470 } 471 472 /* reset sort keys */ 473 perf_hpp__for_each_sort_list_safe(fmt, tmp) { 474 list_del_init(&fmt->list); 475 list_del_init(&fmt->sort_list); 476 } 477 } 478 479 /* 480 * See hists__fprintf to match the column widths 481 */ 482 unsigned int hists__sort_list_width(struct hists *hists) 483 { 484 struct perf_hpp_fmt *fmt; 485 int ret = 0; 486 bool first = true; 487 struct perf_hpp dummy_hpp; 488 489 perf_hpp__for_each_format(fmt) { 490 if (perf_hpp__should_skip(fmt)) 491 continue; 492 493 if (first) 494 first = false; 495 else 496 ret += 2; 497 498 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists)); 499 } 500 501 if (verbose && sort__has_sym) /* Addr + origin */ 502 ret += 3 + BITS_PER_LONG / 4; 503 504 return ret; 505 } 506