~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/builtin-timechart.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * builtin-timechart.c - make an svg timechart of system activity
  3  *
  4  * (C) Copyright 2009 Intel Corporation
  5  *
  6  * Authors:
  7  *     Arjan van de Ven <arjan@linux.intel.com>
  8  *
  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
 12  * of the License.
 13  */
 14 
 15 #include <traceevent/event-parse.h>
 16 
 17 #include "builtin.h"
 18 
 19 #include "util/util.h"
 20 
 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"
 30 
 31 #include "perf.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 
 40 #define SUPPORT_OLD_POWER_EVENTS 1
 41 #define PWR_EVENT_EXIT -1
 42 
 43 
 44 static unsigned int     numcpus;
 45 static u64              min_freq;       /* Lowest CPU frequency seen */
 46 static u64              max_freq;       /* Highest CPU frequency seen */
 47 static u64              turbo_frequency;
 48 
 49 static u64              first_time, last_time;
 50 
 51 static bool             power_only;
 52 
 53 
 54 struct per_pid;
 55 struct per_pidcomm;
 56 
 57 struct cpu_sample;
 58 struct power_event;
 59 struct wake_event;
 60 
 61 struct sample_wrapper;
 62 
 63 /*
 64  * Datastructure layout:
 65  * We keep an list of "pid"s, matching the kernels notion of a task struct.
 66  * Each "pid" entry, has a list of "comm"s.
 67  *      this is because we want to track different programs different, while
 68  *      exec will reuse the original pid (by design).
 69  * Each comm has a list of samples that will be used to draw
 70  * final graph.
 71  */
 72 
 73 struct per_pid {
 74         struct per_pid *next;
 75 
 76         int             pid;
 77         int             ppid;
 78 
 79         u64             start_time;
 80         u64             end_time;
 81         u64             total_time;
 82         int             display;
 83 
 84         struct per_pidcomm *all;
 85         struct per_pidcomm *current;
 86 };
 87 
 88 
 89 struct per_pidcomm {
 90         struct per_pidcomm *next;
 91 
 92         u64             start_time;
 93         u64             end_time;
 94         u64             total_time;
 95 
 96         int             Y;
 97         int             display;
 98 
 99         long            state;
100         u64             state_since;
101 
102         char            *comm;
103 
104         struct cpu_sample *samples;
105 };
106 
107 struct sample_wrapper {
108         struct sample_wrapper *next;
109 
110         u64             timestamp;
111         unsigned char   data[0];
112 };
113 
114 #define TYPE_NONE       0
115 #define TYPE_RUNNING    1
116 #define TYPE_WAITING    2
117 #define TYPE_BLOCKED    3
118 
119 struct cpu_sample {
120         struct cpu_sample *next;
121 
122         u64 start_time;
123         u64 end_time;
124         int type;
125         int cpu;
126 };
127 
128 static struct per_pid *all_data;
129 
130 #define CSTATE 1
131 #define PSTATE 2
132 
133 struct power_event {
134         struct power_event *next;
135         int type;
136         int state;
137         u64 start_time;
138         u64 end_time;
139         int cpu;
140 };
141 
142 struct wake_event {
143         struct wake_event *next;
144         int waker;
145         int wakee;
146         u64 time;
147 };
148 
149 static struct power_event    *power_events;
150 static struct wake_event     *wake_events;
151 
152 struct process_filter;
153 struct process_filter {
154         char                    *name;
155         int                     pid;
156         struct process_filter   *next;
157 };
158 
159 static struct process_filter *process_filter;
160 
161 
162 static struct per_pid *find_create_pid(int pid)
163 {
164         struct per_pid *cursor = all_data;
165 
166         while (cursor) {
167                 if (cursor->pid == pid)
168                         return cursor;
169                 cursor = cursor->next;
170         }
171         cursor = zalloc(sizeof(*cursor));
172         assert(cursor != NULL);
173         cursor->pid = pid;
174         cursor->next = all_data;
175         all_data = cursor;
176         return cursor;
177 }
178 
179 static void pid_set_comm(int pid, char *comm)
180 {
181         struct per_pid *p;
182         struct per_pidcomm *c;
183         p = find_create_pid(pid);
184         c = p->all;
185         while (c) {
186                 if (c->comm && strcmp(c->comm, comm) == 0) {
187                         p->current = c;
188                         return;
189                 }
190                 if (!c->comm) {
191                         c->comm = strdup(comm);
192                         p->current = c;
193                         return;
194                 }
195                 c = c->next;
196         }
197         c = zalloc(sizeof(*c));
198         assert(c != NULL);
199         c->comm = strdup(comm);
200         p->current = c;
201         c->next = p->all;
202         p->all = c;
203 }
204 
205 static void pid_fork(int pid, int ppid, u64 timestamp)
206 {
207         struct per_pid *p, *pp;
208         p = find_create_pid(pid);
209         pp = find_create_pid(ppid);
210         p->ppid = ppid;
211         if (pp->current && pp->current->comm && !p->current)
212                 pid_set_comm(pid, pp->current->comm);
213 
214         p->start_time = timestamp;
215         if (p->current) {
216                 p->current->start_time = timestamp;
217                 p->current->state_since = timestamp;
218         }
219 }
220 
221 static void pid_exit(int pid, u64 timestamp)
222 {
223         struct per_pid *p;
224         p = find_create_pid(pid);
225         p->end_time = timestamp;
226         if (p->current)
227                 p->current->end_time = timestamp;
228 }
229 
230 static void
231 pid_put_sample(int pid, int type, unsigned int cpu, u64 start, u64 end)
232 {
233         struct per_pid *p;
234         struct per_pidcomm *c;
235         struct cpu_sample *sample;
236 
237         p = find_create_pid(pid);
238         c = p->current;
239         if (!c) {
240                 c = zalloc(sizeof(*c));
241                 assert(c != NULL);
242                 p->current = c;
243                 c->next = p->all;
244                 p->all = c;
245         }
246 
247         sample = zalloc(sizeof(*sample));
248         assert(sample != NULL);
249         sample->start_time = start;
250         sample->end_time = end;
251         sample->type = type;
252         sample->next = c->samples;
253         sample->cpu = cpu;
254         c->samples = sample;
255 
256         if (sample->type == TYPE_RUNNING && end > start && start > 0) {
257                 c->total_time += (end-start);
258                 p->total_time += (end-start);
259         }
260 
261         if (c->start_time == 0 || c->start_time > start)
262                 c->start_time = start;
263         if (p->start_time == 0 || p->start_time > start)
264                 p->start_time = start;
265 }
266 
267 #define MAX_CPUS 4096
268 
269 static u64 cpus_cstate_start_times[MAX_CPUS];
270 static int cpus_cstate_state[MAX_CPUS];
271 static u64 cpus_pstate_start_times[MAX_CPUS];
272 static u64 cpus_pstate_state[MAX_CPUS];
273 
274 static int process_comm_event(struct perf_tool *tool __maybe_unused,
275                               union perf_event *event,
276                               struct perf_sample *sample __maybe_unused,
277                               struct machine *machine __maybe_unused)
278 {
279         pid_set_comm(event->comm.tid, event->comm.comm);
280         return 0;
281 }
282 
283 static int process_fork_event(struct perf_tool *tool __maybe_unused,
284                               union perf_event *event,
285                               struct perf_sample *sample __maybe_unused,
286                               struct machine *machine __maybe_unused)
287 {
288         pid_fork(event->fork.pid, event->fork.ppid, event->fork.time);
289         return 0;
290 }
291 
292 static int process_exit_event(struct perf_tool *tool __maybe_unused,
293                               union perf_event *event,
294                               struct perf_sample *sample __maybe_unused,
295                               struct machine *machine __maybe_unused)
296 {
297         pid_exit(event->fork.pid, event->fork.time);
298         return 0;
299 }
300 
301 struct trace_entry {
302         unsigned short          type;
303         unsigned char           flags;
304         unsigned char           preempt_count;
305         int                     pid;
306         int                     lock_depth;
307 };
308 
309 #ifdef SUPPORT_OLD_POWER_EVENTS
310 static int use_old_power_events;
311 struct power_entry_old {
312         struct trace_entry te;
313         u64     type;
314         u64     value;
315         u64     cpu_id;
316 };
317 #endif
318 
319 struct power_processor_entry {
320         struct trace_entry te;
321         u32     state;
322         u32     cpu_id;
323 };
324 
325 #define TASK_COMM_LEN 16
326 struct wakeup_entry {
327         struct trace_entry te;
328         char comm[TASK_COMM_LEN];
329         int   pid;
330         int   prio;
331         int   success;
332 };
333 
334 struct sched_switch {
335         struct trace_entry te;
336         char prev_comm[TASK_COMM_LEN];
337         int  prev_pid;
338         int  prev_prio;
339         long prev_state; /* Arjan weeps. */
340         char next_comm[TASK_COMM_LEN];
341         int  next_pid;
342         int  next_prio;
343 };
344 
345 static void c_state_start(int cpu, u64 timestamp, int state)
346 {
347         cpus_cstate_start_times[cpu] = timestamp;
348         cpus_cstate_state[cpu] = state;
349 }
350 
351 static void c_state_end(int cpu, u64 timestamp)
352 {
353         struct power_event *pwr = zalloc(sizeof(*pwr));
354 
355         if (!pwr)
356                 return;
357 
358         pwr->state = cpus_cstate_state[cpu];
359         pwr->start_time = cpus_cstate_start_times[cpu];
360         pwr->end_time = timestamp;
361         pwr->cpu = cpu;
362         pwr->type = CSTATE;
363         pwr->next = power_events;
364 
365         power_events = pwr;
366 }
367 
368 static void p_state_change(int cpu, u64 timestamp, u64 new_freq)
369 {
370         struct power_event *pwr;
371 
372         if (new_freq > 8000000) /* detect invalid data */
373                 return;
374 
375         pwr = zalloc(sizeof(*pwr));
376         if (!pwr)
377                 return;
378 
379         pwr->state = cpus_pstate_state[cpu];
380         pwr->start_time = cpus_pstate_start_times[cpu];
381         pwr->end_time = timestamp;
382         pwr->cpu = cpu;
383         pwr->type = PSTATE;
384         pwr->next = power_events;
385 
386         if (!pwr->start_time)
387                 pwr->start_time = first_time;
388 
389         power_events = pwr;
390 
391         cpus_pstate_state[cpu] = new_freq;
392         cpus_pstate_start_times[cpu] = timestamp;
393 
394         if ((u64)new_freq > max_freq)
395                 max_freq = new_freq;
396 
397         if (new_freq < min_freq || min_freq == 0)
398                 min_freq = new_freq;
399 
400         if (new_freq == max_freq - 1000)
401                         turbo_frequency = max_freq;
402 }
403 
404 static void
405 sched_wakeup(int cpu, u64 timestamp, int pid, struct trace_entry *te)
406 {
407         struct per_pid *p;
408         struct wakeup_entry *wake = (void *)te;
409         struct wake_event *we = zalloc(sizeof(*we));
410 
411         if (!we)
412                 return;
413 
414         we->time = timestamp;
415         we->waker = pid;
416 
417         if ((te->flags & TRACE_FLAG_HARDIRQ) || (te->flags & TRACE_FLAG_SOFTIRQ))
418                 we->waker = -1;
419 
420         we->wakee = wake->pid;
421         we->next = wake_events;
422         wake_events = we;
423         p = find_create_pid(we->wakee);
424 
425         if (p && p->current && p->current->state == TYPE_NONE) {
426                 p->current->state_since = timestamp;
427                 p->current->state = TYPE_WAITING;
428         }
429         if (p && p->current && p->current->state == TYPE_BLOCKED) {
430                 pid_put_sample(p->pid, p->current->state, cpu, p->current->state_since, timestamp);
431                 p->current->state_since = timestamp;
432                 p->current->state = TYPE_WAITING;
433         }
434 }
435 
436 static void sched_switch(int cpu, u64 timestamp, struct trace_entry *te)
437 {
438         struct per_pid *p = NULL, *prev_p;
439         struct sched_switch *sw = (void *)te;
440 
441 
442         prev_p = find_create_pid(sw->prev_pid);
443 
444         p = find_create_pid(sw->next_pid);
445 
446         if (prev_p->current && prev_p->current->state != TYPE_NONE)
447                 pid_put_sample(sw->prev_pid, TYPE_RUNNING, cpu, prev_p->current->state_since, timestamp);
448         if (p && p->current) {
449                 if (p->current->state != TYPE_NONE)
450                         pid_put_sample(sw->next_pid, p->current->state, cpu, p->current->state_since, timestamp);
451 
452                 p->current->state_since = timestamp;
453                 p->current->state = TYPE_RUNNING;
454         }
455 
456         if (prev_p->current) {
457                 prev_p->current->state = TYPE_NONE;
458                 prev_p->current->state_since = timestamp;
459                 if (sw->prev_state & 2)
460                         prev_p->current->state = TYPE_BLOCKED;
461                 if (sw->prev_state == 0)
462                         prev_p->current->state = TYPE_WAITING;
463         }
464 }
465 
466 typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
467                                   struct perf_sample *sample);
468 
469 static int process_sample_event(struct perf_tool *tool __maybe_unused,
470                                 union perf_event *event __maybe_unused,
471                                 struct perf_sample *sample,
472                                 struct perf_evsel *evsel,
473                                 struct machine *machine __maybe_unused)
474 {
475         if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
476                 if (!first_time || first_time > sample->time)
477                         first_time = sample->time;
478                 if (last_time < sample->time)
479                         last_time = sample->time;
480         }
481 
482         if (sample->cpu > numcpus)
483                 numcpus = sample->cpu;
484 
485         if (evsel->handler.func != NULL) {
486                 tracepoint_handler f = evsel->handler.func;
487                 return f(evsel, sample);
488         }
489 
490         return 0;
491 }
492 
493 static int
494 process_sample_cpu_idle(struct perf_evsel *evsel __maybe_unused,
495                         struct perf_sample *sample)
496 {
497         struct power_processor_entry *ppe = sample->raw_data;
498 
499         if (ppe->state == (u32) PWR_EVENT_EXIT)
500                 c_state_end(ppe->cpu_id, sample->time);
501         else
502                 c_state_start(ppe->cpu_id, sample->time, ppe->state);
503         return 0;
504 }
505 
506 static int
507 process_sample_cpu_frequency(struct perf_evsel *evsel __maybe_unused,
508                              struct perf_sample *sample)
509 {
510         struct power_processor_entry *ppe = sample->raw_data;
511 
512         p_state_change(ppe->cpu_id, sample->time, ppe->state);
513         return 0;
514 }
515 
516 static int
517 process_sample_sched_wakeup(struct perf_evsel *evsel __maybe_unused,
518                             struct perf_sample *sample)
519 {
520         struct trace_entry *te = sample->raw_data;
521 
522         sched_wakeup(sample->cpu, sample->time, sample->pid, te);
523         return 0;
524 }
525 
526 static int
527 process_sample_sched_switch(struct perf_evsel *evsel __maybe_unused,
528                             struct perf_sample *sample)
529 {
530         struct trace_entry *te = sample->raw_data;
531 
532         sched_switch(sample->cpu, sample->time, te);
533         return 0;
534 }
535 
536 #ifdef SUPPORT_OLD_POWER_EVENTS
537 static int
538 process_sample_power_start(struct perf_evsel *evsel __maybe_unused,
539                            struct perf_sample *sample)
540 {
541         struct power_entry_old *peo = sample->raw_data;
542 
543         c_state_start(peo->cpu_id, sample->time, peo->value);
544         return 0;
545 }
546 
547 static int
548 process_sample_power_end(struct perf_evsel *evsel __maybe_unused,
549                          struct perf_sample *sample)
550 {
551         c_state_end(sample->cpu, sample->time);
552         return 0;
553 }
554 
555 static int
556 process_sample_power_frequency(struct perf_evsel *evsel __maybe_unused,
557                                struct perf_sample *sample)
558 {
559         struct power_entry_old *peo = sample->raw_data;
560 
561         p_state_change(peo->cpu_id, sample->time, peo->value);
562         return 0;
563 }
564 #endif /* SUPPORT_OLD_POWER_EVENTS */
565 
566 /*
567  * After the last sample we need to wrap up the current C/P state
568  * and close out each CPU for these.
569  */
570 static void end_sample_processing(void)
571 {
572         u64 cpu;
573         struct power_event *pwr;
574 
575         for (cpu = 0; cpu <= numcpus; cpu++) {
576                 /* C state */
577 #if 0
578                 pwr = zalloc(sizeof(*pwr));
579                 if (!pwr)
580                         return;
581 
582                 pwr->state = cpus_cstate_state[cpu];
583                 pwr->start_time = cpus_cstate_start_times[cpu];
584                 pwr->end_time = last_time;
585                 pwr->cpu = cpu;
586                 pwr->type = CSTATE;
587                 pwr->next = power_events;
588 
589                 power_events = pwr;
590 #endif
591                 /* P state */
592 
593                 pwr = zalloc(sizeof(*pwr));
594                 if (!pwr)
595                         return;
596 
597                 pwr->state = cpus_pstate_state[cpu];
598                 pwr->start_time = cpus_pstate_start_times[cpu];
599                 pwr->end_time = last_time;
600                 pwr->cpu = cpu;
601                 pwr->type = PSTATE;
602                 pwr->next = power_events;
603 
604                 if (!pwr->start_time)
605                         pwr->start_time = first_time;
606                 if (!pwr->state)
607                         pwr->state = min_freq;
608                 power_events = pwr;
609         }
610 }
611 
612 /*
613  * Sort the pid datastructure
614  */
615 static void sort_pids(void)
616 {
617         struct per_pid *new_list, *p, *cursor, *prev;
618         /* sort by ppid first, then by pid, lowest to highest */
619 
620         new_list = NULL;
621 
622         while (all_data) {
623                 p = all_data;
624                 all_data = p->next;
625                 p->next = NULL;
626 
627                 if (new_list == NULL) {
628                         new_list = p;
629                         p->next = NULL;
630                         continue;
631                 }
632                 prev = NULL;
633                 cursor = new_list;
634                 while (cursor) {
635                         if (cursor->ppid > p->ppid ||
636                                 (cursor->ppid == p->ppid && cursor->pid > p->pid)) {
637                                 /* must insert before */
638                                 if (prev) {
639                                         p->next = prev->next;
640                                         prev->next = p;
641                                         cursor = NULL;
642                                         continue;
643                                 } else {
644                                         p->next = new_list;
645                                         new_list = p;
646                                         cursor = NULL;
647                                         continue;
648                                 }
649                         }
650 
651                         prev = cursor;
652                         cursor = cursor->next;
653                         if (!cursor)
654                                 prev->next = p;
655                 }
656         }
657         all_data = new_list;
658 }
659 
660 
661 static void draw_c_p_states(void)
662 {
663         struct power_event *pwr;
664         pwr = power_events;
665 
666         /*
667          * two pass drawing so that the P state bars are on top of the C state blocks
668          */
669         while (pwr) {
670                 if (pwr->type == CSTATE)
671                         svg_cstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
672                 pwr = pwr->next;
673         }
674 
675         pwr = power_events;
676         while (pwr) {
677                 if (pwr->type == PSTATE) {
678                         if (!pwr->state)
679                                 pwr->state = min_freq;
680                         svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
681                 }
682                 pwr = pwr->next;
683         }
684 }
685 
686 static void draw_wakeups(void)
687 {
688         struct wake_event *we;
689         struct per_pid *p;
690         struct per_pidcomm *c;
691 
692         we = wake_events;
693         while (we) {
694                 int from = 0, to = 0;
695                 char *task_from = NULL, *task_to = NULL;
696 
697                 /* locate the column of the waker and wakee */
698                 p = all_data;
699                 while (p) {
700                         if (p->pid == we->waker || p->pid == we->wakee) {
701                                 c = p->all;
702                                 while (c) {
703                                         if (c->Y && c->start_time <= we->time && c->end_time >= we->time) {
704                                                 if (p->pid == we->waker && !from) {
705                                                         from = c->Y;
706                                                         task_from = strdup(c->comm);
707                                                 }
708                                                 if (p->pid == we->wakee && !to) {
709                                                         to = c->Y;
710                                                         task_to = strdup(c->comm);
711                                                 }
712                                         }
713                                         c = c->next;
714                                 }
715                                 c = p->all;
716                                 while (c) {
717                                         if (p->pid == we->waker && !from) {
718                                                 from = c->Y;
719                                                 task_from = strdup(c->comm);
720                                         }
721                                         if (p->pid == we->wakee && !to) {
722                                                 to = c->Y;
723                                                 task_to = strdup(c->comm);
724                                         }
725                                         c = c->next;
726                                 }
727                         }
728                         p = p->next;
729                 }
730 
731                 if (!task_from) {
732                         task_from = malloc(40);
733                         sprintf(task_from, "[%i]", we->waker);
734                 }
735                 if (!task_to) {
736                         task_to = malloc(40);
737                         sprintf(task_to, "[%i]", we->wakee);
738                 }
739 
740                 if (we->waker == -1)
741                         svg_interrupt(we->time, to);
742                 else if (from && to && abs(from - to) == 1)
743                         svg_wakeline(we->time, from, to);
744                 else
745                         svg_partial_wakeline(we->time, from, task_from, to, task_to);
746                 we = we->next;
747 
748                 free(task_from);
749                 free(task_to);
750         }
751 }
752 
753 static void draw_cpu_usage(void)
754 {
755         struct per_pid *p;
756         struct per_pidcomm *c;
757         struct cpu_sample *sample;
758         p = all_data;
759         while (p) {
760                 c = p->all;
761                 while (c) {
762                         sample = c->samples;
763                         while (sample) {
764                                 if (sample->type == TYPE_RUNNING)
765                                         svg_process(sample->cpu, sample->start_time, sample->end_time, "sample", c->comm);
766 
767                                 sample = sample->next;
768                         }
769                         c = c->next;
770                 }
771                 p = p->next;
772         }
773 }
774 
775 static void draw_process_bars(void)
776 {
777         struct per_pid *p;
778         struct per_pidcomm *c;
779         struct cpu_sample *sample;
780         int Y = 0;
781 
782         Y = 2 * numcpus + 2;
783 
784         p = all_data;
785         while (p) {
786                 c = p->all;
787                 while (c) {
788                         if (!c->display) {
789                                 c->Y = 0;
790                                 c = c->next;
791                                 continue;
792                         }
793 
794                         svg_box(Y, c->start_time, c->end_time, "process");
795                         sample = c->samples;
796                         while (sample) {
797                                 if (sample->type == TYPE_RUNNING)
798                                         svg_sample(Y, sample->cpu, sample->start_time, sample->end_time);
799                                 if (sample->type == TYPE_BLOCKED)
800                                         svg_box(Y, sample->start_time, sample->end_time, "blocked");
801                                 if (sample->type == TYPE_WAITING)
802                                         svg_waiting(Y, sample->start_time, sample->end_time);
803                                 sample = sample->next;
804                         }
805 
806                         if (c->comm) {
807                                 char comm[256];
808                                 if (c->total_time > 5000000000) /* 5 seconds */
809                                         sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / 1000000000.0);
810                                 else
811                                         sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / 1000000.0);
812 
813                                 svg_text(Y, c->start_time, comm);
814                         }
815                         c->Y = Y;
816                         Y++;
817                         c = c->next;
818                 }
819                 p = p->next;
820         }
821 }
822 
823 static void add_process_filter(const char *string)
824 {
825         int pid = strtoull(string, NULL, 10);
826         struct process_filter *filt = malloc(sizeof(*filt));
827 
828         if (!filt)
829                 return;
830 
831         filt->name = strdup(string);
832         filt->pid  = pid;
833         filt->next = process_filter;
834 
835         process_filter = filt;
836 }
837 
838 static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
839 {
840         struct process_filter *filt;
841         if (!process_filter)
842                 return 1;
843 
844         filt = process_filter;
845         while (filt) {
846                 if (filt->pid && p->pid == filt->pid)
847                         return 1;
848                 if (strcmp(filt->name, c->comm) == 0)
849                         return 1;
850                 filt = filt->next;
851         }
852         return 0;
853 }
854 
855 static int determine_display_tasks_filtered(void)
856 {
857         struct per_pid *p;
858         struct per_pidcomm *c;
859         int count = 0;
860 
861         p = all_data;
862         while (p) {
863                 p->display = 0;
864                 if (p->start_time == 1)
865                         p->start_time = first_time;
866 
867                 /* no exit marker, task kept running to the end */
868                 if (p->end_time == 0)
869                         p->end_time = last_time;
870 
871                 c = p->all;
872 
873                 while (c) {
874                         c->display = 0;
875 
876                         if (c->start_time == 1)
877                                 c->start_time = first_time;
878 
879                         if (passes_filter(p, c)) {
880                                 c->display = 1;
881                                 p->display = 1;
882                                 count++;
883                         }
884 
885                         if (c->end_time == 0)
886                                 c->end_time = last_time;
887 
888                         c = c->next;
889                 }
890                 p = p->next;
891         }
892         return count;
893 }
894 
895 static int determine_display_tasks(u64 threshold)
896 {
897         struct per_pid *p;
898         struct per_pidcomm *c;
899         int count = 0;
900 
901         if (process_filter)
902                 return determine_display_tasks_filtered();
903 
904         p = all_data;
905         while (p) {
906                 p->display = 0;
907                 if (p->start_time == 1)
908                         p->start_time = first_time;
909 
910                 /* no exit marker, task kept running to the end */
911                 if (p->end_time == 0)
912                         p->end_time = last_time;
913                 if (p->total_time >= threshold && !power_only)
914                         p->display = 1;
915 
916                 c = p->all;
917 
918                 while (c) {
919                         c->display = 0;
920 
921                         if (c->start_time == 1)
922                                 c->start_time = first_time;
923 
924                         if (c->total_time >= threshold && !power_only) {
925                                 c->display = 1;
926                                 count++;
927                         }
928 
929                         if (c->end_time == 0)
930                                 c->end_time = last_time;
931 
932                         c = c->next;
933                 }
934                 p = p->next;
935         }
936         return count;
937 }
938 
939 
940 
941 #define TIME_THRESH 10000000
942 
943 static void write_svg_file(const char *filename)
944 {
945         u64 i;
946         int count;
947 
948         numcpus++;
949 
950 
951         count = determine_display_tasks(TIME_THRESH);
952 
953         /* We'd like to show at least 15 tasks; be less picky if we have fewer */
954         if (count < 15)
955                 count = determine_display_tasks(TIME_THRESH / 10);
956 
957         open_svg(filename, numcpus, count, first_time, last_time);
958 
959         svg_time_grid();
960         svg_legenda();
961 
962         for (i = 0; i < numcpus; i++)
963                 svg_cpu_box(i, max_freq, turbo_frequency);
964 
965         draw_cpu_usage();
966         draw_process_bars();
967         draw_c_p_states();
968         draw_wakeups();
969 
970         svg_close();
971 }
972 
973 static int __cmd_timechart(const char *output_name)
974 {
975         struct perf_tool perf_timechart = {
976                 .comm            = process_comm_event,
977                 .fork            = process_fork_event,
978                 .exit            = process_exit_event,
979                 .sample          = process_sample_event,
980                 .ordered_samples = true,
981         };
982         const struct perf_evsel_str_handler power_tracepoints[] = {
983                 { "power:cpu_idle",             process_sample_cpu_idle },
984                 { "power:cpu_frequency",        process_sample_cpu_frequency },
985                 { "sched:sched_wakeup",         process_sample_sched_wakeup },
986                 { "sched:sched_switch",         process_sample_sched_switch },
987 #ifdef SUPPORT_OLD_POWER_EVENTS
988                 { "power:power_start",          process_sample_power_start },
989                 { "power:power_end",            process_sample_power_end },
990                 { "power:power_frequency",      process_sample_power_frequency },
991 #endif
992         };
993         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
994                                                          0, false, &perf_timechart);
995         int ret = -EINVAL;
996 
997         if (session == NULL)
998                 return -ENOMEM;
999 
1000         if (!perf_session__has_traces(session, "timechart record"))
1001                 goto out_delete;
1002 
1003         if (perf_session__set_tracepoints_handlers(session,
1004                                                    power_tracepoints)) {
1005                 pr_err("Initializing session tracepoint handlers failed\n");
1006                 goto out_delete;
1007         }
1008 
1009         ret = perf_session__process_events(session, &perf_timechart);
1010         if (ret)
1011                 goto out_delete;
1012 
1013         end_sample_processing();
1014 
1015         sort_pids();
1016 
1017         write_svg_file(output_name);
1018 
1019         pr_info("Written %2.1f seconds of trace to %s.\n",
1020                 (last_time - first_time) / 1000000000.0, output_name);
1021 out_delete:
1022         perf_session__delete(session);
1023         return ret;
1024 }
1025 
1026 static int __cmd_record(int argc, const char **argv)
1027 {
1028 #ifdef SUPPORT_OLD_POWER_EVENTS
1029         const char * const record_old_args[] = {
1030                 "record", "-a", "-R", "-c", "1",
1031                 "-e", "power:power_start",
1032                 "-e", "power:power_end",
1033                 "-e", "power:power_frequency",
1034                 "-e", "sched:sched_wakeup",
1035                 "-e", "sched:sched_switch",
1036         };
1037 #endif
1038         const char * const record_new_args[] = {
1039                 "record", "-a", "-R", "-c", "1",
1040                 "-e", "power:cpu_frequency",
1041                 "-e", "power:cpu_idle",
1042                 "-e", "sched:sched_wakeup",
1043                 "-e", "sched:sched_switch",
1044         };
1045         unsigned int rec_argc, i, j;
1046         const char **rec_argv;
1047         const char * const *record_args = record_new_args;
1048         unsigned int record_elems = ARRAY_SIZE(record_new_args);
1049 
1050 #ifdef SUPPORT_OLD_POWER_EVENTS
1051         if (!is_valid_tracepoint("power:cpu_idle") &&
1052             is_valid_tracepoint("power:power_start")) {
1053                 use_old_power_events = 1;
1054                 record_args = record_old_args;
1055                 record_elems = ARRAY_SIZE(record_old_args);
1056         }
1057 #endif
1058 
1059         rec_argc = record_elems + argc - 1;
1060         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1061 
1062         if (rec_argv == NULL)
1063                 return -ENOMEM;
1064 
1065         for (i = 0; i < record_elems; i++)
1066                 rec_argv[i] = strdup(record_args[i]);
1067 
1068         for (j = 1; j < (unsigned int)argc; j++, i++)
1069                 rec_argv[i] = argv[j];
1070 
1071         return cmd_record(i, rec_argv, NULL);
1072 }
1073 
1074 static int
1075 parse_process(const struct option *opt __maybe_unused, const char *arg,
1076               int __maybe_unused unset)
1077 {
1078         if (arg)
1079                 add_process_filter(arg);
1080         return 0;
1081 }
1082 
1083 int cmd_timechart(int argc, const char **argv,
1084                   const char *prefix __maybe_unused)
1085 {
1086         const char *output_name = "output.svg";
1087         const struct option options[] = {
1088         OPT_STRING('i', "input", &input_name, "file", "input file name"),
1089         OPT_STRING('o', "output", &output_name, "file", "output file name"),
1090         OPT_INTEGER('w', "width", &svg_page_width, "page width"),
1091         OPT_BOOLEAN('P', "power-only", &power_only, "output power data only"),
1092         OPT_CALLBACK('p', "process", NULL, "process",
1093                       "process selector. Pass a pid or process name.",
1094                        parse_process),
1095         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
1096                     "Look for files with symbols relative to this directory"),
1097         OPT_END()
1098         };
1099         const char * const timechart_usage[] = {
1100                 "perf timechart [<options>] {record}",
1101                 NULL
1102         };
1103 
1104         argc = parse_options(argc, argv, options, timechart_usage,
1105                         PARSE_OPT_STOP_AT_NON_OPTION);
1106 
1107         symbol__init();
1108 
1109         if (argc && !strncmp(argv[0], "rec", 3))
1110                 return __cmd_record(argc, argv);
1111         else if (argc)
1112                 usage_with_options(timechart_usage, options);
1113 
1114         setup_pager();
1115 
1116         return __cmd_timechart(output_name);
1117 }
1118 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp