2 * builtin-timechart.c - make an svg timechart of system activity
4 * (C) Copyright 2009 Intel Corporation
7 * Arjan van de Ven <arjan@linux.intel.com>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; version 2
15 #include <traceevent/event-parse.h>
19 #include "util/util.h"
21 #include "util/color.h"
22 #include <linux/list.h>
23 #include "util/cache.h"
24 #include "util/evlist.h"
25 #include "util/evsel.h"
26 #include <linux/rbtree.h>
27 #include "util/symbol.h"
28 #include "util/callchain.h"
29 #include "util/strlist.h"
32 #include "util/header.h"
33 #include "util/parse-options.h"
34 #include "util/parse-events.h"
35 #include "util/event.h"
36 #include "util/session.h"
37 #include "util/svghelper.h"
38 #include "util/tool.h"
39 #include "util/data.h"
41 #define SUPPORT_OLD_POWER_EVENTS 1
42 #define PWR_EVENT_EXIT -1
49 struct perf_tool tool;
50 struct per_pid *all_data;
51 struct power_event *power_events;
52 struct wake_event *wake_events;
55 u64 min_freq, /* Lowest CPU frequency seen */
56 max_freq, /* Highest CPU frequency seen */
58 first_time, last_time;
69 * Datastructure layout:
70 * We keep an list of "pid"s, matching the kernels notion of a task struct.
71 * Each "pid" entry, has a list of "comm"s.
72 * this is because we want to track different programs different, while
73 * exec will reuse the original pid (by design).
74 * Each comm has a list of samples that will be used to draw
89 struct per_pidcomm *all;
90 struct per_pidcomm *current;
95 struct per_pidcomm *next;
109 struct cpu_sample *samples;
112 struct sample_wrapper {
113 struct sample_wrapper *next;
116 unsigned char data[0];
120 #define TYPE_RUNNING 1
121 #define TYPE_WAITING 2
122 #define TYPE_BLOCKED 3
125 struct cpu_sample *next;
131 const char *backtrace;
138 struct power_event *next;
147 struct wake_event *next;
151 const char *backtrace;
154 struct process_filter {
157 struct process_filter *next;
160 static struct process_filter *process_filter;
163 static struct per_pid *find_create_pid(struct timechart *tchart, int pid)
165 struct per_pid *cursor = tchart->all_data;
168 if (cursor->pid == pid)
170 cursor = cursor->next;
172 cursor = zalloc(sizeof(*cursor));
173 assert(cursor != NULL);
175 cursor->next = tchart->all_data;
176 tchart->all_data = cursor;
180 static void pid_set_comm(struct timechart *tchart, int pid, char *comm)
183 struct per_pidcomm *c;
184 p = find_create_pid(tchart, pid);
187 if (c->comm && strcmp(c->comm, comm) == 0) {
192 c->comm = strdup(comm);
198 c = zalloc(sizeof(*c));
200 c->comm = strdup(comm);
206 static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
208 struct per_pid *p, *pp;
209 p = find_create_pid(tchart, pid);
210 pp = find_create_pid(tchart, ppid);
212 if (pp->current && pp->current->comm && !p->current)
213 pid_set_comm(tchart, pid, pp->current->comm);
215 p->start_time = timestamp;
217 p->current->start_time = timestamp;
218 p->current->state_since = timestamp;
222 static void pid_exit(struct timechart *tchart, int pid, u64 timestamp)
225 p = find_create_pid(tchart, pid);
226 p->end_time = timestamp;
228 p->current->end_time = timestamp;
231 static void pid_put_sample(struct timechart *tchart, int pid, int type,
232 unsigned int cpu, u64 start, u64 end,
233 const char *backtrace)
236 struct per_pidcomm *c;
237 struct cpu_sample *sample;
239 p = find_create_pid(tchart, pid);
242 c = zalloc(sizeof(*c));
249 sample = zalloc(sizeof(*sample));
250 assert(sample != NULL);
251 sample->start_time = start;
252 sample->end_time = end;
254 sample->next = c->samples;
256 sample->backtrace = backtrace;
259 if (sample->type == TYPE_RUNNING && end > start && start > 0) {
260 c->total_time += (end-start);
261 p->total_time += (end-start);
264 if (c->start_time == 0 || c->start_time > start)
265 c->start_time = start;
266 if (p->start_time == 0 || p->start_time > start)
267 p->start_time = start;
270 #define MAX_CPUS 4096
272 static u64 cpus_cstate_start_times[MAX_CPUS];
273 static int cpus_cstate_state[MAX_CPUS];
274 static u64 cpus_pstate_start_times[MAX_CPUS];
275 static u64 cpus_pstate_state[MAX_CPUS];
277 static int process_comm_event(struct perf_tool *tool,
278 union perf_event *event,
279 struct perf_sample *sample __maybe_unused,
280 struct machine *machine __maybe_unused)
282 struct timechart *tchart = container_of(tool, struct timechart, tool);
283 pid_set_comm(tchart, event->comm.tid, event->comm.comm);
287 static int process_fork_event(struct perf_tool *tool,
288 union perf_event *event,
289 struct perf_sample *sample __maybe_unused,
290 struct machine *machine __maybe_unused)
292 struct timechart *tchart = container_of(tool, struct timechart, tool);
293 pid_fork(tchart, event->fork.pid, event->fork.ppid, event->fork.time);
297 static int process_exit_event(struct perf_tool *tool,
298 union perf_event *event,
299 struct perf_sample *sample __maybe_unused,
300 struct machine *machine __maybe_unused)
302 struct timechart *tchart = container_of(tool, struct timechart, tool);
303 pid_exit(tchart, event->fork.pid, event->fork.time);
307 #ifdef SUPPORT_OLD_POWER_EVENTS
308 static int use_old_power_events;
311 static void c_state_start(int cpu, u64 timestamp, int state)
313 cpus_cstate_start_times[cpu] = timestamp;
314 cpus_cstate_state[cpu] = state;
317 static void c_state_end(struct timechart *tchart, int cpu, u64 timestamp)
319 struct power_event *pwr = zalloc(sizeof(*pwr));
324 pwr->state = cpus_cstate_state[cpu];
325 pwr->start_time = cpus_cstate_start_times[cpu];
326 pwr->end_time = timestamp;
329 pwr->next = tchart->power_events;
331 tchart->power_events = pwr;
334 static void p_state_change(struct timechart *tchart, int cpu, u64 timestamp, u64 new_freq)
336 struct power_event *pwr;
338 if (new_freq > 8000000) /* detect invalid data */
341 pwr = zalloc(sizeof(*pwr));
345 pwr->state = cpus_pstate_state[cpu];
346 pwr->start_time = cpus_pstate_start_times[cpu];
347 pwr->end_time = timestamp;
350 pwr->next = tchart->power_events;
352 if (!pwr->start_time)
353 pwr->start_time = tchart->first_time;
355 tchart->power_events = pwr;
357 cpus_pstate_state[cpu] = new_freq;
358 cpus_pstate_start_times[cpu] = timestamp;
360 if ((u64)new_freq > tchart->max_freq)
361 tchart->max_freq = new_freq;
363 if (new_freq < tchart->min_freq || tchart->min_freq == 0)
364 tchart->min_freq = new_freq;
366 if (new_freq == tchart->max_freq - 1000)
367 tchart->turbo_frequency = tchart->max_freq;
370 static void sched_wakeup(struct timechart *tchart, int cpu, u64 timestamp,
371 int waker, int wakee, u8 flags, const char *backtrace)
374 struct wake_event *we = zalloc(sizeof(*we));
379 we->time = timestamp;
381 we->backtrace = backtrace;
383 if ((flags & TRACE_FLAG_HARDIRQ) || (flags & TRACE_FLAG_SOFTIRQ))
387 we->next = tchart->wake_events;
388 tchart->wake_events = we;
389 p = find_create_pid(tchart, we->wakee);
391 if (p && p->current && p->current->state == TYPE_NONE) {
392 p->current->state_since = timestamp;
393 p->current->state = TYPE_WAITING;
395 if (p && p->current && p->current->state == TYPE_BLOCKED) {
396 pid_put_sample(tchart, p->pid, p->current->state, cpu,
397 p->current->state_since, timestamp, NULL);
398 p->current->state_since = timestamp;
399 p->current->state = TYPE_WAITING;
403 static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp,
404 int prev_pid, int next_pid, u64 prev_state,
405 const char *backtrace)
407 struct per_pid *p = NULL, *prev_p;
409 prev_p = find_create_pid(tchart, prev_pid);
411 p = find_create_pid(tchart, next_pid);
413 if (prev_p->current && prev_p->current->state != TYPE_NONE)
414 pid_put_sample(tchart, prev_pid, TYPE_RUNNING, cpu,
415 prev_p->current->state_since, timestamp,
417 if (p && p->current) {
418 if (p->current->state != TYPE_NONE)
419 pid_put_sample(tchart, next_pid, p->current->state, cpu,
420 p->current->state_since, timestamp,
423 p->current->state_since = timestamp;
424 p->current->state = TYPE_RUNNING;
427 if (prev_p->current) {
428 prev_p->current->state = TYPE_NONE;
429 prev_p->current->state_since = timestamp;
431 prev_p->current->state = TYPE_BLOCKED;
433 prev_p->current->state = TYPE_WAITING;
437 static const char *cat_backtrace(union perf_event *event,
438 struct perf_sample *sample,
439 struct machine *machine)
441 struct addr_location al;
445 u8 cpumode = PERF_RECORD_MISC_USER;
446 struct addr_location tal;
447 struct ip_callchain *chain = sample->callchain;
448 FILE *f = open_memstream(&p, &p_len);
451 perror("open_memstream error");
458 if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
459 fprintf(stderr, "problem processing %d event, skipping it.\n",
464 for (i = 0; i < chain->nr; i++) {
467 if (callchain_param.order == ORDER_CALLEE)
470 ip = chain->ips[chain->nr - i - 1];
472 if (ip >= PERF_CONTEXT_MAX) {
474 case PERF_CONTEXT_HV:
475 cpumode = PERF_RECORD_MISC_HYPERVISOR;
477 case PERF_CONTEXT_KERNEL:
478 cpumode = PERF_RECORD_MISC_KERNEL;
480 case PERF_CONTEXT_USER:
481 cpumode = PERF_RECORD_MISC_USER;
484 pr_debug("invalid callchain context: "
485 "%"PRId64"\n", (s64) ip);
488 * It seems the callchain is corrupted.
498 tal.filtered = false;
499 thread__find_addr_location(al.thread, machine, cpumode,
500 MAP__FUNCTION, ip, &tal);
503 fprintf(f, "..... %016" PRIx64 " %s\n", ip,
506 fprintf(f, "..... %016" PRIx64 "\n", ip);
515 typedef int (*tracepoint_handler)(struct timechart *tchart,
516 struct perf_evsel *evsel,
517 struct perf_sample *sample,
518 const char *backtrace);
520 static int process_sample_event(struct perf_tool *tool,
521 union perf_event *event,
522 struct perf_sample *sample,
523 struct perf_evsel *evsel,
524 struct machine *machine)
526 struct timechart *tchart = container_of(tool, struct timechart, tool);
528 if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
529 if (!tchart->first_time || tchart->first_time > sample->time)
530 tchart->first_time = sample->time;
531 if (tchart->last_time < sample->time)
532 tchart->last_time = sample->time;
535 if (evsel->handler != NULL) {
536 tracepoint_handler f = evsel->handler;
537 return f(tchart, evsel, sample,
538 cat_backtrace(event, sample, machine));
545 process_sample_cpu_idle(struct timechart *tchart __maybe_unused,
546 struct perf_evsel *evsel,
547 struct perf_sample *sample,
548 const char *backtrace __maybe_unused)
550 u32 state = perf_evsel__intval(evsel, sample, "state");
551 u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
553 if (state == (u32)PWR_EVENT_EXIT)
554 c_state_end(tchart, cpu_id, sample->time);
556 c_state_start(cpu_id, sample->time, state);
561 process_sample_cpu_frequency(struct timechart *tchart,
562 struct perf_evsel *evsel,
563 struct perf_sample *sample,
564 const char *backtrace __maybe_unused)
566 u32 state = perf_evsel__intval(evsel, sample, "state");
567 u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
569 p_state_change(tchart, cpu_id, sample->time, state);
574 process_sample_sched_wakeup(struct timechart *tchart,
575 struct perf_evsel *evsel,
576 struct perf_sample *sample,
577 const char *backtrace)
579 u8 flags = perf_evsel__intval(evsel, sample, "common_flags");
580 int waker = perf_evsel__intval(evsel, sample, "common_pid");
581 int wakee = perf_evsel__intval(evsel, sample, "pid");
583 sched_wakeup(tchart, sample->cpu, sample->time, waker, wakee, flags, backtrace);
588 process_sample_sched_switch(struct timechart *tchart,
589 struct perf_evsel *evsel,
590 struct perf_sample *sample,
591 const char *backtrace)
593 int prev_pid = perf_evsel__intval(evsel, sample, "prev_pid");
594 int next_pid = perf_evsel__intval(evsel, sample, "next_pid");
595 u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
597 sched_switch(tchart, sample->cpu, sample->time, prev_pid, next_pid,
598 prev_state, backtrace);
602 #ifdef SUPPORT_OLD_POWER_EVENTS
604 process_sample_power_start(struct timechart *tchart __maybe_unused,
605 struct perf_evsel *evsel,
606 struct perf_sample *sample,
607 const char *backtrace __maybe_unused)
609 u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
610 u64 value = perf_evsel__intval(evsel, sample, "value");
612 c_state_start(cpu_id, sample->time, value);
617 process_sample_power_end(struct timechart *tchart,
618 struct perf_evsel *evsel __maybe_unused,
619 struct perf_sample *sample,
620 const char *backtrace __maybe_unused)
622 c_state_end(tchart, sample->cpu, sample->time);
627 process_sample_power_frequency(struct timechart *tchart,
628 struct perf_evsel *evsel,
629 struct perf_sample *sample,
630 const char *backtrace __maybe_unused)
632 u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
633 u64 value = perf_evsel__intval(evsel, sample, "value");
635 p_state_change(tchart, cpu_id, sample->time, value);
638 #endif /* SUPPORT_OLD_POWER_EVENTS */
641 * After the last sample we need to wrap up the current C/P state
642 * and close out each CPU for these.
644 static void end_sample_processing(struct timechart *tchart)
647 struct power_event *pwr;
649 for (cpu = 0; cpu <= tchart->numcpus; cpu++) {
652 pwr = zalloc(sizeof(*pwr));
656 pwr->state = cpus_cstate_state[cpu];
657 pwr->start_time = cpus_cstate_start_times[cpu];
658 pwr->end_time = tchart->last_time;
661 pwr->next = tchart->power_events;
663 tchart->power_events = pwr;
667 pwr = zalloc(sizeof(*pwr));
671 pwr->state = cpus_pstate_state[cpu];
672 pwr->start_time = cpus_pstate_start_times[cpu];
673 pwr->end_time = tchart->last_time;
676 pwr->next = tchart->power_events;
678 if (!pwr->start_time)
679 pwr->start_time = tchart->first_time;
681 pwr->state = tchart->min_freq;
682 tchart->power_events = pwr;
687 * Sort the pid datastructure
689 static void sort_pids(struct timechart *tchart)
691 struct per_pid *new_list, *p, *cursor, *prev;
692 /* sort by ppid first, then by pid, lowest to highest */
696 while (tchart->all_data) {
697 p = tchart->all_data;
698 tchart->all_data = p->next;
701 if (new_list == NULL) {
709 if (cursor->ppid > p->ppid ||
710 (cursor->ppid == p->ppid && cursor->pid > p->pid)) {
711 /* must insert before */
713 p->next = prev->next;
726 cursor = cursor->next;
731 tchart->all_data = new_list;
735 static void draw_c_p_states(struct timechart *tchart)
737 struct power_event *pwr;
738 pwr = tchart->power_events;
741 * two pass drawing so that the P state bars are on top of the C state blocks
744 if (pwr->type == CSTATE)
745 svg_cstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
749 pwr = tchart->power_events;
751 if (pwr->type == PSTATE) {
753 pwr->state = tchart->min_freq;
754 svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
760 static void draw_wakeups(struct timechart *tchart)
762 struct wake_event *we;
764 struct per_pidcomm *c;
766 we = tchart->wake_events;
768 int from = 0, to = 0;
769 char *task_from = NULL, *task_to = NULL;
771 /* locate the column of the waker and wakee */
772 p = tchart->all_data;
774 if (p->pid == we->waker || p->pid == we->wakee) {
777 if (c->Y && c->start_time <= we->time && c->end_time >= we->time) {
778 if (p->pid == we->waker && !from) {
780 task_from = strdup(c->comm);
782 if (p->pid == we->wakee && !to) {
784 task_to = strdup(c->comm);
791 if (p->pid == we->waker && !from) {
793 task_from = strdup(c->comm);
795 if (p->pid == we->wakee && !to) {
797 task_to = strdup(c->comm);
806 task_from = malloc(40);
807 sprintf(task_from, "[%i]", we->waker);
810 task_to = malloc(40);
811 sprintf(task_to, "[%i]", we->wakee);
815 svg_interrupt(we->time, to, we->backtrace);
816 else if (from && to && abs(from - to) == 1)
817 svg_wakeline(we->time, from, to, we->backtrace);
819 svg_partial_wakeline(we->time, from, task_from, to,
820 task_to, we->backtrace);
828 static void draw_cpu_usage(struct timechart *tchart)
831 struct per_pidcomm *c;
832 struct cpu_sample *sample;
833 p = tchart->all_data;
839 if (sample->type == TYPE_RUNNING) {
840 svg_process(sample->cpu,
848 sample = sample->next;
856 static void draw_process_bars(struct timechart *tchart)
859 struct per_pidcomm *c;
860 struct cpu_sample *sample;
863 Y = 2 * tchart->numcpus + 2;
865 p = tchart->all_data;
875 svg_box(Y, c->start_time, c->end_time, "process");
878 if (sample->type == TYPE_RUNNING)
879 svg_running(Y, sample->cpu,
883 if (sample->type == TYPE_BLOCKED)
884 svg_blocked(Y, sample->cpu,
888 if (sample->type == TYPE_WAITING)
889 svg_waiting(Y, sample->cpu,
893 sample = sample->next;
898 if (c->total_time > 5000000000) /* 5 seconds */
899 sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / 1000000000.0);
901 sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / 1000000.0);
903 svg_text(Y, c->start_time, comm);
913 static void add_process_filter(const char *string)
915 int pid = strtoull(string, NULL, 10);
916 struct process_filter *filt = malloc(sizeof(*filt));
921 filt->name = strdup(string);
923 filt->next = process_filter;
925 process_filter = filt;
928 static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
930 struct process_filter *filt;
934 filt = process_filter;
936 if (filt->pid && p->pid == filt->pid)
938 if (strcmp(filt->name, c->comm) == 0)
945 static int determine_display_tasks_filtered(struct timechart *tchart)
948 struct per_pidcomm *c;
951 p = tchart->all_data;
954 if (p->start_time == 1)
955 p->start_time = tchart->first_time;
957 /* no exit marker, task kept running to the end */
958 if (p->end_time == 0)
959 p->end_time = tchart->last_time;
966 if (c->start_time == 1)
967 c->start_time = tchart->first_time;
969 if (passes_filter(p, c)) {
975 if (c->end_time == 0)
976 c->end_time = tchart->last_time;
985 static int determine_display_tasks(struct timechart *tchart, u64 threshold)
988 struct per_pidcomm *c;
992 return determine_display_tasks_filtered(tchart);
994 p = tchart->all_data;
997 if (p->start_time == 1)
998 p->start_time = tchart->first_time;
1000 /* no exit marker, task kept running to the end */
1001 if (p->end_time == 0)
1002 p->end_time = tchart->last_time;
1003 if (p->total_time >= threshold)
1011 if (c->start_time == 1)
1012 c->start_time = tchart->first_time;
1014 if (c->total_time >= threshold) {
1019 if (c->end_time == 0)
1020 c->end_time = tchart->last_time;
1031 #define TIME_THRESH 10000000
1033 static void write_svg_file(struct timechart *tchart, const char *filename)
1037 int thresh = TIME_THRESH;
1039 if (tchart->power_only)
1040 tchart->proc_num = 0;
1042 /* We'd like to show at least proc_num tasks;
1043 * be less picky if we have fewer */
1045 count = determine_display_tasks(tchart, thresh);
1047 } while (!process_filter && thresh && count < tchart->proc_num);
1049 open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
1054 for (i = 0; i < tchart->numcpus; i++)
1055 svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
1057 draw_cpu_usage(tchart);
1058 if (tchart->proc_num)
1059 draw_process_bars(tchart);
1060 if (!tchart->tasks_only)
1061 draw_c_p_states(tchart);
1062 if (tchart->proc_num)
1063 draw_wakeups(tchart);
1068 static int process_header(struct perf_file_section *section __maybe_unused,
1069 struct perf_header *ph,
1071 int fd __maybe_unused,
1074 struct timechart *tchart = data;
1078 tchart->numcpus = ph->env.nr_cpus_avail;
1081 case HEADER_CPU_TOPOLOGY:
1082 if (!tchart->topology)
1085 if (svg_build_topology_map(ph->env.sibling_cores,
1086 ph->env.nr_sibling_cores,
1087 ph->env.sibling_threads,
1088 ph->env.nr_sibling_threads))
1089 fprintf(stderr, "problem building topology\n");
1099 static int __cmd_timechart(struct timechart *tchart, const char *output_name)
1101 const struct perf_evsel_str_handler power_tracepoints[] = {
1102 { "power:cpu_idle", process_sample_cpu_idle },
1103 { "power:cpu_frequency", process_sample_cpu_frequency },
1104 { "sched:sched_wakeup", process_sample_sched_wakeup },
1105 { "sched:sched_switch", process_sample_sched_switch },
1106 #ifdef SUPPORT_OLD_POWER_EVENTS
1107 { "power:power_start", process_sample_power_start },
1108 { "power:power_end", process_sample_power_end },
1109 { "power:power_frequency", process_sample_power_frequency },
1112 struct perf_data_file file = {
1114 .mode = PERF_DATA_MODE_READ,
1117 struct perf_session *session = perf_session__new(&file, false,
1121 if (session == NULL)
1124 (void)perf_header__process_sections(&session->header,
1125 perf_data_file__fd(session->file),
1129 if (!perf_session__has_traces(session, "timechart record"))
1132 if (perf_session__set_tracepoints_handlers(session,
1133 power_tracepoints)) {
1134 pr_err("Initializing session tracepoint handlers failed\n");
1138 ret = perf_session__process_events(session, &tchart->tool);
1142 end_sample_processing(tchart);
1146 write_svg_file(tchart, output_name);
1148 pr_info("Written %2.1f seconds of trace to %s.\n",
1149 (tchart->last_time - tchart->first_time) / 1000000000.0, output_name);
1151 perf_session__delete(session);
1155 static int timechart__record(struct timechart *tchart, int argc, const char **argv)
1157 unsigned int rec_argc, i, j;
1158 const char **rec_argv;
1160 unsigned int record_elems;
1162 const char * const common_args[] = {
1163 "record", "-a", "-R", "-c", "1",
1165 unsigned int common_args_nr = ARRAY_SIZE(common_args);
1167 const char * const backtrace_args[] = {
1170 unsigned int backtrace_args_no = ARRAY_SIZE(backtrace_args);
1172 const char * const power_args[] = {
1173 "-e", "power:cpu_frequency",
1174 "-e", "power:cpu_idle",
1176 unsigned int power_args_nr = ARRAY_SIZE(power_args);
1178 const char * const old_power_args[] = {
1179 #ifdef SUPPORT_OLD_POWER_EVENTS
1180 "-e", "power:power_start",
1181 "-e", "power:power_end",
1182 "-e", "power:power_frequency",
1185 unsigned int old_power_args_nr = ARRAY_SIZE(old_power_args);
1187 const char * const tasks_args[] = {
1188 "-e", "sched:sched_wakeup",
1189 "-e", "sched:sched_switch",
1191 unsigned int tasks_args_nr = ARRAY_SIZE(tasks_args);
1193 #ifdef SUPPORT_OLD_POWER_EVENTS
1194 if (!is_valid_tracepoint("power:cpu_idle") &&
1195 is_valid_tracepoint("power:power_start")) {
1196 use_old_power_events = 1;
1199 old_power_args_nr = 0;
1203 if (tchart->power_only)
1206 if (tchart->tasks_only) {
1208 old_power_args_nr = 0;
1211 if (!tchart->with_backtrace)
1212 backtrace_args_no = 0;
1214 record_elems = common_args_nr + tasks_args_nr +
1215 power_args_nr + old_power_args_nr + backtrace_args_no;
1217 rec_argc = record_elems + argc;
1218 rec_argv = calloc(rec_argc + 1, sizeof(char *));
1220 if (rec_argv == NULL)
1224 for (i = 0; i < common_args_nr; i++)
1225 *p++ = strdup(common_args[i]);
1227 for (i = 0; i < backtrace_args_no; i++)
1228 *p++ = strdup(backtrace_args[i]);
1230 for (i = 0; i < tasks_args_nr; i++)
1231 *p++ = strdup(tasks_args[i]);
1233 for (i = 0; i < power_args_nr; i++)
1234 *p++ = strdup(power_args[i]);
1236 for (i = 0; i < old_power_args_nr; i++)
1237 *p++ = strdup(old_power_args[i]);
1239 for (j = 1; j < (unsigned int)argc; j++)
1242 return cmd_record(rec_argc, rec_argv, NULL);
1246 parse_process(const struct option *opt __maybe_unused, const char *arg,
1247 int __maybe_unused unset)
1250 add_process_filter(arg);
1255 parse_highlight(const struct option *opt __maybe_unused, const char *arg,
1256 int __maybe_unused unset)
1258 unsigned long duration = strtoul(arg, NULL, 0);
1260 if (svg_highlight || svg_highlight_name)
1264 svg_highlight = duration;
1266 svg_highlight_name = strdup(arg);
1271 int cmd_timechart(int argc, const char **argv,
1272 const char *prefix __maybe_unused)
1274 struct timechart tchart = {
1276 .comm = process_comm_event,
1277 .fork = process_fork_event,
1278 .exit = process_exit_event,
1279 .sample = process_sample_event,
1280 .ordered_samples = true,
1284 const char *output_name = "output.svg";
1285 const struct option timechart_options[] = {
1286 OPT_STRING('i', "input", &input_name, "file", "input file name"),
1287 OPT_STRING('o', "output", &output_name, "file", "output file name"),
1288 OPT_INTEGER('w', "width", &svg_page_width, "page width"),
1289 OPT_CALLBACK(0, "highlight", NULL, "duration or task name",
1290 "highlight tasks. Pass duration in ns or process name.",
1292 OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
1293 OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
1294 "output processes data only"),
1295 OPT_CALLBACK('p', "process", NULL, "process",
1296 "process selector. Pass a pid or process name.",
1298 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
1299 "Look for files with symbols relative to this directory"),
1300 OPT_INTEGER('n', "proc-num", &tchart.proc_num,
1301 "min. number of tasks to print"),
1302 OPT_BOOLEAN('t', "topology", &tchart.topology,
1303 "sort CPUs according to topology"),
1306 const char * const timechart_usage[] = {
1307 "perf timechart [<options>] {record}",
1311 const struct option record_options[] = {
1312 OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
1313 OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
1314 "output processes data only"),
1315 OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
1318 const char * const record_usage[] = {
1319 "perf timechart record [<options>]",
1322 argc = parse_options(argc, argv, timechart_options, timechart_usage,
1323 PARSE_OPT_STOP_AT_NON_OPTION);
1325 if (tchart.power_only && tchart.tasks_only) {
1326 pr_err("-P and -T options cannot be used at the same time.\n");
1332 if (argc && !strncmp(argv[0], "rec", 3)) {
1333 argc = parse_options(argc, argv, record_options, record_usage,
1334 PARSE_OPT_STOP_AT_NON_OPTION);
1336 if (tchart.power_only && tchart.tasks_only) {
1337 pr_err("-P and -T options cannot be used at the same time.\n");
1341 return timechart__record(&tchart, argc, argv);
1343 usage_with_options(timechart_usage, timechart_options);
1347 return __cmd_timechart(&tchart, output_name);