tools/perf/util/sort.c

   1 #include "sort.h"
   2
   3 regex_t         parent_regex;
   4 char            default_parent_pattern[] = "^sys_|^do_page_fault";
   5 char            *parent_pattern = default_parent_pattern;
   6 char            default_sort_order[] = "comm,dso,symbol";
   7 char            *sort_order = default_sort_order;
   8 int sort__need_collapse = 0;
   9 int sort__has_parent = 0;
  10
  11 unsigned int dsos__col_width;
  12 unsigned int comms__col_width;
  13 unsigned int threads__col_width;
  14 static unsigned int parent_symbol__col_width;
  15 char * field_sep;
  16
  17 LIST_HEAD(hist_entry__sort_list);
  18
  19 struct sort_entry sort_thread = {
  20         .header = "Command:  Pid",
  21         .cmp    = sort__thread_cmp,
  22         .print  = sort__thread_print,
  23         .width  = &threads__col_width,
  24 };
  25
  26 struct sort_entry sort_comm = {
  27         .header         = "Command",
  28         .cmp            = sort__comm_cmp,
  29         .collapse       = sort__comm_collapse,
  30         .print          = sort__comm_print,
  31         .width          = &comms__col_width,
  32 };
  33
  34 struct sort_entry sort_dso = {
  35         .header = "Shared Object",
  36         .cmp    = sort__dso_cmp,
  37         .print  = sort__dso_print,
  38         .width  = &dsos__col_width,
  39 };
  40
  41 struct sort_entry sort_sym = {
  42         .header = "Symbol",
  43         .cmp    = sort__sym_cmp,
  44         .print  = sort__sym_print,
  45 };
  46
  47 struct sort_entry sort_parent = {
  48         .header = "Parent symbol",
  49         .cmp    = sort__parent_cmp,
  50         .print  = sort__parent_print,
  51         .width  = &parent_symbol__col_width,
  52 };
  53
  54 struct sort_dimension {
  55         const char              *name;
  56         struct sort_entry       *entry;
  57         int                     taken;
  58 };
  59
  60 static struct sort_dimension sort_dimensions[] = {
  61         { .name = "pid",        .entry = &sort_thread,  },
  62         { .name = "comm",       .entry = &sort_comm,    },
  63         { .name = "dso",        .entry = &sort_dso,     },
  64         { .name = "symbol",     .entry = &sort_sym,     },
  65         { .name = "parent",     .entry = &sort_parent,  },
  66 };
  67
  68 int64_t cmp_null(void *l, void *r)
  69 {
  70         if (!l && !r)
  71                 return 0;
  72         else if (!l)
  73                 return -1;
  74         else
  75                 return 1;
  76 }
  77
  78 /* --sort pid */
  79
  80 int64_t
  81 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
  82 {
  83         return right->thread->pid - left->thread->pid;
  84 }
  85
  86 int repsep_fprintf(FILE *fp, const char *fmt, ...)
  87 {
  88         int n;
  89         va_list ap;
  90
  91         va_start(ap, fmt);
  92         if (!field_sep)
  93                 n = vfprintf(fp, fmt, ap);
  94         else {
  95                 char *bf = NULL;
  96                 n = vasprintf(&bf, fmt, ap);
  97                 if (n > 0) {
  98                         char *sep = bf;
  99
 100                         while (1) {
 101                                 sep = strchr(sep, *field_sep);
 102                                 if (sep == NULL)
 103                                         break;
 104                                 *sep = '.';
 105                         }
 106                 }
 107                 fputs(bf, fp);
 108                 free(bf);
 109         }
 110         va_end(ap);
 111         return n;
 112 }
 113
 114 size_t
 115 sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
 116 {
 117         return repsep_fprintf(fp, "%*s:%5d", width - 6,
 118                               self->thread->comm ?: "", self->thread->pid);
 119 }
 120
 121 size_t
 122 sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
 123 {
 124         return repsep_fprintf(fp, "%*s", width, self->thread->comm);
 125 }
 126
 127 /* --sort dso */
 128
 129 int64_t
 130 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 131 {
 132         struct dso *dso_l = left->map ? left->map->dso : NULL;
 133         struct dso *dso_r = right->map ? right->map->dso : NULL;
 134         const char *dso_name_l, *dso_name_r;
 135
 136         if (!dso_l || !dso_r)
 137                 return cmp_null(dso_l, dso_r);
 138
 139         if (verbose) {
 140                 dso_name_l = dso_l->long_name;
 141                 dso_name_r = dso_r->long_name;
 142         } else {
 143                 dso_name_l = dso_l->short_name;
 144                 dso_name_r = dso_r->short_name;
 145         }
 146
 147         return strcmp(dso_name_l, dso_name_r);
 148 }
 149
 150 size_t
 151 sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
 152 {
 153         if (self->map && self->map->dso) {
 154                 const char *dso_name = !verbose ? self->map->dso->short_name :
 155                                                   self->map->dso->long_name;
 156                 return repsep_fprintf(fp, "%-*s", width, dso_name);
 157         }
 158
 159         return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
 160 }
 161
 162 /* --sort symbol */
 163
 164 int64_t
 165 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 166 {
 167         u64 ip_l, ip_r;
 168
 169         if (left->sym == right->sym)
 170                 return 0;
 171
 172         ip_l = left->sym ? left->sym->start : left->ip;
 173         ip_r = right->sym ? right->sym->start : right->ip;
 174
 175         return (int64_t)(ip_r - ip_l);
 176 }
 177
 178
 179 size_t
 180 sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
 181 {
 182         size_t ret = 0;
 183
 184         if (verbose) {
 185                 char o = self->map ? dso__symtab_origin(self->map->dso) : '!';
 186                 ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip, o);
 187         }
 188
 189         ret += repsep_fprintf(fp, "[%c] ", self->level);
 190         if (self->sym)
 191                 ret += repsep_fprintf(fp, "%s", self->sym->name);
 192         else
 193                 ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
 194
 195         return ret;
 196 }
 197
 198 /* --sort comm */
 199
 200 int64_t
 201 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
 202 {
 203         return right->thread->pid - left->thread->pid;
 204 }
 205
 206 int64_t
 207 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
 208 {
 209         char *comm_l = left->thread->comm;
 210         char *comm_r = right->thread->comm;
 211
 212         if (!comm_l || !comm_r)
 213                 return cmp_null(comm_l, comm_r);
 214
 215         return strcmp(comm_l, comm_r);
 216 }
 217
 218 /* --sort parent */
 219
 220 int64_t
 221 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
 222 {
 223         struct symbol *sym_l = left->parent;
 224         struct symbol *sym_r = right->parent;
 225
 226         if (!sym_l || !sym_r)
 227                 return cmp_null(sym_l, sym_r);
 228
 229         return strcmp(sym_l->name, sym_r->name);
 230 }
 231
 232 size_t
 233 sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
 234 {
 235         return repsep_fprintf(fp, "%-*s", width,
 236                               self->parent ? self->parent->name : "[other]");
 237 }
 238
 239 int sort_dimension__add(const char *tok)
 240 {
 241         unsigned int i;
 242
 243         for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
 244                 struct sort_dimension *sd = &sort_dimensions[i];
 245
 246                 if (sd->taken)
 247                         continue;
 248
 249                 if (strncasecmp(tok, sd->name, strlen(tok)))
 250                         continue;
 251
 252                 if (sd->entry->collapse)
 253                         sort__need_collapse = 1;
 254
 255                 if (sd->entry == &sort_parent) {
 256                         int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
 257                         if (ret) {
 258                                 char err[BUFSIZ];
 259
 260                                 regerror(ret, &parent_regex, err, sizeof(err));
 261                                 fprintf(stderr, "Invalid regex: %s\n%s",
 262                                         parent_pattern, err);
 263                                 exit(-1);
 264                         }
 265                         sort__has_parent = 1;
 266                 }
 267
 268                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
 269                 sd->taken = 1;
 270
 271                 return 0;
 272         }
 273
 274         return -ESRCH;
 275 }
 276