5 #include "util/evlist.h"
6 #include "util/cache.h"
7 #include "util/evsel.h"
8 #include "util/symbol.h"
9 #include "util/thread.h"
10 #include "util/header.h"
11 #include "util/session.h"
12 #include "util/tool.h"
14 #include "util/parse-options.h"
15 #include "util/trace-event.h"
17 #include "util/debug.h"
19 #include <sys/prctl.h>
20 #include <sys/resource.h>
22 #include <semaphore.h>
26 #define PR_SET_NAME 15 /* Set process name */
39 unsigned long nr_events
;
40 unsigned long curr_event
;
41 struct sched_atom
**atoms
;
52 enum sched_event_type
{
56 SCHED_EVENT_MIGRATION
,
60 enum sched_event_type type
;
66 struct task_desc
*wakee
;
69 #define TASK_STATE_TO_CHAR_STR "RSDTtZX"
79 struct list_head list
;
80 enum thread_state state
;
88 struct list_head work_list
;
89 struct thread
*thread
;
98 typedef int (*sort_fn_t
)(struct work_atoms
*, struct work_atoms
*);
102 struct trace_sched_handler
{
103 int (*switch_event
)(struct perf_sched
*sched
, struct perf_evsel
*evsel
,
104 struct perf_sample
*sample
, struct machine
*machine
);
106 int (*runtime_event
)(struct perf_sched
*sched
, struct perf_evsel
*evsel
,
107 struct perf_sample
*sample
, struct machine
*machine
);
109 int (*wakeup_event
)(struct perf_sched
*sched
, struct perf_evsel
*evsel
,
110 struct perf_sample
*sample
, struct machine
*machine
);
112 int (*fork_event
)(struct perf_sched
*sched
, struct perf_evsel
*evsel
,
113 struct perf_sample
*sample
);
115 int (*migrate_task_event
)(struct perf_sched
*sched
,
116 struct perf_evsel
*evsel
,
117 struct perf_sample
*sample
,
118 struct machine
*machine
);
122 struct perf_tool tool
;
123 const char *input_name
;
124 const char *sort_order
;
125 unsigned long nr_tasks
;
126 struct task_desc
*pid_to_task
[MAX_PID
];
127 struct task_desc
**tasks
;
128 const struct trace_sched_handler
*tp_handler
;
129 pthread_mutex_t start_work_mutex
;
130 pthread_mutex_t work_done_wait_mutex
;
133 * Track the current task - that way we can know whether there's any
134 * weird events, such as a task being switched away that is not current.
137 u32 curr_pid
[MAX_CPUS
];
138 struct thread
*curr_thread
[MAX_CPUS
];
139 char next_shortname1
;
140 char next_shortname2
;
141 unsigned int replay_repeat
;
142 unsigned long nr_run_events
;
143 unsigned long nr_sleep_events
;
144 unsigned long nr_wakeup_events
;
145 unsigned long nr_sleep_corrections
;
146 unsigned long nr_run_events_optimized
;
147 unsigned long targetless_wakeups
;
148 unsigned long multitarget_wakeups
;
149 unsigned long nr_runs
;
150 unsigned long nr_timestamps
;
151 unsigned long nr_unordered_timestamps
;
152 unsigned long nr_state_machine_bugs
;
153 unsigned long nr_context_switch_bugs
;
154 unsigned long nr_events
;
155 unsigned long nr_lost_chunks
;
156 unsigned long nr_lost_events
;
157 u64 run_measurement_overhead
;
158 u64 sleep_measurement_overhead
;
161 u64 runavg_cpu_usage
;
162 u64 parent_cpu_usage
;
163 u64 runavg_parent_cpu_usage
;
169 u64 cpu_last_switched
[MAX_CPUS
];
170 struct rb_root atom_root
, sorted_atom_root
;
171 struct list_head sort_list
, cmp_pid
;
174 static u64
get_nsecs(void)
178 clock_gettime(CLOCK_MONOTONIC
, &ts
);
180 return ts
.tv_sec
* 1000000000ULL + ts
.tv_nsec
;
183 static void burn_nsecs(struct perf_sched
*sched
, u64 nsecs
)
185 u64 T0
= get_nsecs(), T1
;
189 } while (T1
+ sched
->run_measurement_overhead
< T0
+ nsecs
);
192 static void sleep_nsecs(u64 nsecs
)
196 ts
.tv_nsec
= nsecs
% 999999999;
197 ts
.tv_sec
= nsecs
/ 999999999;
199 nanosleep(&ts
, NULL
);
202 static void calibrate_run_measurement_overhead(struct perf_sched
*sched
)
204 u64 T0
, T1
, delta
, min_delta
= 1000000000ULL;
207 for (i
= 0; i
< 10; i
++) {
209 burn_nsecs(sched
, 0);
212 min_delta
= min(min_delta
, delta
);
214 sched
->run_measurement_overhead
= min_delta
;
216 printf("run measurement overhead: %" PRIu64
" nsecs\n", min_delta
);
219 static void calibrate_sleep_measurement_overhead(struct perf_sched
*sched
)
221 u64 T0
, T1
, delta
, min_delta
= 1000000000ULL;
224 for (i
= 0; i
< 10; i
++) {
229 min_delta
= min(min_delta
, delta
);
232 sched
->sleep_measurement_overhead
= min_delta
;
234 printf("sleep measurement overhead: %" PRIu64
" nsecs\n", min_delta
);
237 static struct sched_atom
*
238 get_new_event(struct task_desc
*task
, u64 timestamp
)
240 struct sched_atom
*event
= zalloc(sizeof(*event
));
241 unsigned long idx
= task
->nr_events
;
244 event
->timestamp
= timestamp
;
248 size
= sizeof(struct sched_atom
*) * task
->nr_events
;
249 task
->atoms
= realloc(task
->atoms
, size
);
250 BUG_ON(!task
->atoms
);
252 task
->atoms
[idx
] = event
;
257 static struct sched_atom
*last_event(struct task_desc
*task
)
259 if (!task
->nr_events
)
262 return task
->atoms
[task
->nr_events
- 1];
265 static void add_sched_event_run(struct perf_sched
*sched
, struct task_desc
*task
,
266 u64 timestamp
, u64 duration
)
268 struct sched_atom
*event
, *curr_event
= last_event(task
);
271 * optimize an existing RUN event by merging this one
274 if (curr_event
&& curr_event
->type
== SCHED_EVENT_RUN
) {
275 sched
->nr_run_events_optimized
++;
276 curr_event
->duration
+= duration
;
280 event
= get_new_event(task
, timestamp
);
282 event
->type
= SCHED_EVENT_RUN
;
283 event
->duration
= duration
;
285 sched
->nr_run_events
++;
288 static void add_sched_event_wakeup(struct perf_sched
*sched
, struct task_desc
*task
,
289 u64 timestamp
, struct task_desc
*wakee
)
291 struct sched_atom
*event
, *wakee_event
;
293 event
= get_new_event(task
, timestamp
);
294 event
->type
= SCHED_EVENT_WAKEUP
;
295 event
->wakee
= wakee
;
297 wakee_event
= last_event(wakee
);
298 if (!wakee_event
|| wakee_event
->type
!= SCHED_EVENT_SLEEP
) {
299 sched
->targetless_wakeups
++;
302 if (wakee_event
->wait_sem
) {
303 sched
->multitarget_wakeups
++;
307 wakee_event
->wait_sem
= zalloc(sizeof(*wakee_event
->wait_sem
));
308 sem_init(wakee_event
->wait_sem
, 0, 0);
309 wakee_event
->specific_wait
= 1;
310 event
->wait_sem
= wakee_event
->wait_sem
;
312 sched
->nr_wakeup_events
++;
315 static void add_sched_event_sleep(struct perf_sched
*sched
, struct task_desc
*task
,
316 u64 timestamp
, u64 task_state __maybe_unused
)
318 struct sched_atom
*event
= get_new_event(task
, timestamp
);
320 event
->type
= SCHED_EVENT_SLEEP
;
322 sched
->nr_sleep_events
++;
325 static struct task_desc
*register_pid(struct perf_sched
*sched
,
326 unsigned long pid
, const char *comm
)
328 struct task_desc
*task
;
330 BUG_ON(pid
>= MAX_PID
);
332 task
= sched
->pid_to_task
[pid
];
337 task
= zalloc(sizeof(*task
));
339 task
->nr
= sched
->nr_tasks
;
340 strcpy(task
->comm
, comm
);
342 * every task starts in sleeping state - this gets ignored
343 * if there's no wakeup pointing to this sleep state:
345 add_sched_event_sleep(sched
, task
, 0, 0);
347 sched
->pid_to_task
[pid
] = task
;
349 sched
->tasks
= realloc(sched
->tasks
, sched
->nr_tasks
* sizeof(struct task_task
*));
350 BUG_ON(!sched
->tasks
);
351 sched
->tasks
[task
->nr
] = task
;
354 printf("registered task #%ld, PID %ld (%s)\n", sched
->nr_tasks
, pid
, comm
);
360 static void print_task_traces(struct perf_sched
*sched
)
362 struct task_desc
*task
;
365 for (i
= 0; i
< sched
->nr_tasks
; i
++) {
366 task
= sched
->tasks
[i
];
367 printf("task %6ld (%20s:%10ld), nr_events: %ld\n",
368 task
->nr
, task
->comm
, task
->pid
, task
->nr_events
);
372 static void add_cross_task_wakeups(struct perf_sched
*sched
)
374 struct task_desc
*task1
, *task2
;
377 for (i
= 0; i
< sched
->nr_tasks
; i
++) {
378 task1
= sched
->tasks
[i
];
380 if (j
== sched
->nr_tasks
)
382 task2
= sched
->tasks
[j
];
383 add_sched_event_wakeup(sched
, task1
, 0, task2
);
387 static void perf_sched__process_event(struct perf_sched
*sched
,
388 struct sched_atom
*atom
)
392 switch (atom
->type
) {
393 case SCHED_EVENT_RUN
:
394 burn_nsecs(sched
, atom
->duration
);
396 case SCHED_EVENT_SLEEP
:
398 ret
= sem_wait(atom
->wait_sem
);
401 case SCHED_EVENT_WAKEUP
:
403 ret
= sem_post(atom
->wait_sem
);
406 case SCHED_EVENT_MIGRATION
:
413 static u64
get_cpu_usage_nsec_parent(void)
419 err
= getrusage(RUSAGE_SELF
, &ru
);
422 sum
= ru
.ru_utime
.tv_sec
*1e9
+ ru
.ru_utime
.tv_usec
*1e3
;
423 sum
+= ru
.ru_stime
.tv_sec
*1e9
+ ru
.ru_stime
.tv_usec
*1e3
;
428 static int self_open_counters(void)
430 struct perf_event_attr attr
;
433 memset(&attr
, 0, sizeof(attr
));
435 attr
.type
= PERF_TYPE_SOFTWARE
;
436 attr
.config
= PERF_COUNT_SW_TASK_CLOCK
;
438 fd
= sys_perf_event_open(&attr
, 0, -1, -1, 0);
441 pr_err("Error: sys_perf_event_open() syscall returned "
442 "with %d (%s)\n", fd
, strerror(errno
));
446 static u64
get_cpu_usage_nsec_self(int fd
)
451 ret
= read(fd
, &runtime
, sizeof(runtime
));
452 BUG_ON(ret
!= sizeof(runtime
));
457 struct sched_thread_parms
{
458 struct task_desc
*task
;
459 struct perf_sched
*sched
;
462 static void *thread_func(void *ctx
)
464 struct sched_thread_parms
*parms
= ctx
;
465 struct task_desc
*this_task
= parms
->task
;
466 struct perf_sched
*sched
= parms
->sched
;
467 u64 cpu_usage_0
, cpu_usage_1
;
468 unsigned long i
, ret
;
474 sprintf(comm2
, ":%s", this_task
->comm
);
475 prctl(PR_SET_NAME
, comm2
);
476 fd
= self_open_counters();
480 ret
= sem_post(&this_task
->ready_for_work
);
482 ret
= pthread_mutex_lock(&sched
->start_work_mutex
);
484 ret
= pthread_mutex_unlock(&sched
->start_work_mutex
);
487 cpu_usage_0
= get_cpu_usage_nsec_self(fd
);
489 for (i
= 0; i
< this_task
->nr_events
; i
++) {
490 this_task
->curr_event
= i
;
491 perf_sched__process_event(sched
, this_task
->atoms
[i
]);
494 cpu_usage_1
= get_cpu_usage_nsec_self(fd
);
495 this_task
->cpu_usage
= cpu_usage_1
- cpu_usage_0
;
496 ret
= sem_post(&this_task
->work_done_sem
);
499 ret
= pthread_mutex_lock(&sched
->work_done_wait_mutex
);
501 ret
= pthread_mutex_unlock(&sched
->work_done_wait_mutex
);
507 static void create_tasks(struct perf_sched
*sched
)
509 struct task_desc
*task
;
514 err
= pthread_attr_init(&attr
);
516 err
= pthread_attr_setstacksize(&attr
,
517 (size_t) max(16 * 1024, PTHREAD_STACK_MIN
));
519 err
= pthread_mutex_lock(&sched
->start_work_mutex
);
521 err
= pthread_mutex_lock(&sched
->work_done_wait_mutex
);
523 for (i
= 0; i
< sched
->nr_tasks
; i
++) {
524 struct sched_thread_parms
*parms
= malloc(sizeof(*parms
));
525 BUG_ON(parms
== NULL
);
526 parms
->task
= task
= sched
->tasks
[i
];
527 parms
->sched
= sched
;
528 sem_init(&task
->sleep_sem
, 0, 0);
529 sem_init(&task
->ready_for_work
, 0, 0);
530 sem_init(&task
->work_done_sem
, 0, 0);
531 task
->curr_event
= 0;
532 err
= pthread_create(&task
->thread
, &attr
, thread_func
, parms
);
537 static void wait_for_tasks(struct perf_sched
*sched
)
539 u64 cpu_usage_0
, cpu_usage_1
;
540 struct task_desc
*task
;
541 unsigned long i
, ret
;
543 sched
->start_time
= get_nsecs();
544 sched
->cpu_usage
= 0;
545 pthread_mutex_unlock(&sched
->work_done_wait_mutex
);
547 for (i
= 0; i
< sched
->nr_tasks
; i
++) {
548 task
= sched
->tasks
[i
];
549 ret
= sem_wait(&task
->ready_for_work
);
551 sem_init(&task
->ready_for_work
, 0, 0);
553 ret
= pthread_mutex_lock(&sched
->work_done_wait_mutex
);
556 cpu_usage_0
= get_cpu_usage_nsec_parent();
558 pthread_mutex_unlock(&sched
->start_work_mutex
);
560 for (i
= 0; i
< sched
->nr_tasks
; i
++) {
561 task
= sched
->tasks
[i
];
562 ret
= sem_wait(&task
->work_done_sem
);
564 sem_init(&task
->work_done_sem
, 0, 0);
565 sched
->cpu_usage
+= task
->cpu_usage
;
569 cpu_usage_1
= get_cpu_usage_nsec_parent();
570 if (!sched
->runavg_cpu_usage
)
571 sched
->runavg_cpu_usage
= sched
->cpu_usage
;
572 sched
->runavg_cpu_usage
= (sched
->runavg_cpu_usage
* 9 + sched
->cpu_usage
) / 10;
574 sched
->parent_cpu_usage
= cpu_usage_1
- cpu_usage_0
;
575 if (!sched
->runavg_parent_cpu_usage
)
576 sched
->runavg_parent_cpu_usage
= sched
->parent_cpu_usage
;
577 sched
->runavg_parent_cpu_usage
= (sched
->runavg_parent_cpu_usage
* 9 +
578 sched
->parent_cpu_usage
)/10;
580 ret
= pthread_mutex_lock(&sched
->start_work_mutex
);
583 for (i
= 0; i
< sched
->nr_tasks
; i
++) {
584 task
= sched
->tasks
[i
];
585 sem_init(&task
->sleep_sem
, 0, 0);
586 task
->curr_event
= 0;
590 static void run_one_test(struct perf_sched
*sched
)
592 u64 T0
, T1
, delta
, avg_delta
, fluct
;
595 wait_for_tasks(sched
);
599 sched
->sum_runtime
+= delta
;
602 avg_delta
= sched
->sum_runtime
/ sched
->nr_runs
;
603 if (delta
< avg_delta
)
604 fluct
= avg_delta
- delta
;
606 fluct
= delta
- avg_delta
;
607 sched
->sum_fluct
+= fluct
;
609 sched
->run_avg
= delta
;
610 sched
->run_avg
= (sched
->run_avg
* 9 + delta
) / 10;
612 printf("#%-3ld: %0.3f, ", sched
->nr_runs
, (double)delta
/ 1000000.0);
614 printf("ravg: %0.2f, ", (double)sched
->run_avg
/ 1e6
);
616 printf("cpu: %0.2f / %0.2f",
617 (double)sched
->cpu_usage
/ 1e6
, (double)sched
->runavg_cpu_usage
/ 1e6
);
621 * rusage statistics done by the parent, these are less
622 * accurate than the sched->sum_exec_runtime based statistics:
624 printf(" [%0.2f / %0.2f]",
625 (double)sched
->parent_cpu_usage
/1e6
,
626 (double)sched
->runavg_parent_cpu_usage
/1e6
);
631 if (sched
->nr_sleep_corrections
)
632 printf(" (%ld sleep corrections)\n", sched
->nr_sleep_corrections
);
633 sched
->nr_sleep_corrections
= 0;
636 static void test_calibrations(struct perf_sched
*sched
)
641 burn_nsecs(sched
, 1e6
);
644 printf("the run test took %" PRIu64
" nsecs\n", T1
- T0
);
650 printf("the sleep test took %" PRIu64
" nsecs\n", T1
- T0
);
654 replay_wakeup_event(struct perf_sched
*sched
,
655 struct perf_evsel
*evsel
, struct perf_sample
*sample
,
656 struct machine
*machine __maybe_unused
)
658 const char *comm
= perf_evsel__strval(evsel
, sample
, "comm");
659 const u32 pid
= perf_evsel__intval(evsel
, sample
, "pid");
660 struct task_desc
*waker
, *wakee
;
663 printf("sched_wakeup event %p\n", evsel
);
665 printf(" ... pid %d woke up %s/%d\n", sample
->tid
, comm
, pid
);
668 waker
= register_pid(sched
, sample
->tid
, "<unknown>");
669 wakee
= register_pid(sched
, pid
, comm
);
671 add_sched_event_wakeup(sched
, waker
, sample
->time
, wakee
);
675 static int replay_switch_event(struct perf_sched
*sched
,
676 struct perf_evsel
*evsel
,
677 struct perf_sample
*sample
,
678 struct machine
*machine __maybe_unused
)
680 const char *prev_comm
= perf_evsel__strval(evsel
, sample
, "prev_comm"),
681 *next_comm
= perf_evsel__strval(evsel
, sample
, "next_comm");
682 const u32 prev_pid
= perf_evsel__intval(evsel
, sample
, "prev_pid"),
683 next_pid
= perf_evsel__intval(evsel
, sample
, "next_pid");
684 const u64 prev_state
= perf_evsel__intval(evsel
, sample
, "prev_state");
685 struct task_desc
*prev
, __maybe_unused
*next
;
686 u64 timestamp0
, timestamp
= sample
->time
;
687 int cpu
= sample
->cpu
;
691 printf("sched_switch event %p\n", evsel
);
693 if (cpu
>= MAX_CPUS
|| cpu
< 0)
696 timestamp0
= sched
->cpu_last_switched
[cpu
];
698 delta
= timestamp
- timestamp0
;
703 pr_err("hm, delta: %" PRIu64
" < 0 ?\n", delta
);
707 pr_debug(" ... switch from %s/%d to %s/%d [ran %" PRIu64
" nsecs]\n",
708 prev_comm
, prev_pid
, next_comm
, next_pid
, delta
);
710 prev
= register_pid(sched
, prev_pid
, prev_comm
);
711 next
= register_pid(sched
, next_pid
, next_comm
);
713 sched
->cpu_last_switched
[cpu
] = timestamp
;
715 add_sched_event_run(sched
, prev
, timestamp
, delta
);
716 add_sched_event_sleep(sched
, prev
, timestamp
, prev_state
);
721 static int replay_fork_event(struct perf_sched
*sched
, struct perf_evsel
*evsel
,
722 struct perf_sample
*sample
)
724 const char *parent_comm
= perf_evsel__strval(evsel
, sample
, "parent_comm"),
725 *child_comm
= perf_evsel__strval(evsel
, sample
, "child_comm");
726 const u32 parent_pid
= perf_evsel__intval(evsel
, sample
, "parent_pid"),
727 child_pid
= perf_evsel__intval(evsel
, sample
, "child_pid");
730 printf("sched_fork event %p\n", evsel
);
731 printf("... parent: %s/%d\n", parent_comm
, parent_pid
);
732 printf("... child: %s/%d\n", child_comm
, child_pid
);
735 register_pid(sched
, parent_pid
, parent_comm
);
736 register_pid(sched
, child_pid
, child_comm
);
740 struct sort_dimension
{
743 struct list_head list
;
747 thread_lat_cmp(struct list_head
*list
, struct work_atoms
*l
, struct work_atoms
*r
)
749 struct sort_dimension
*sort
;
752 BUG_ON(list_empty(list
));
754 list_for_each_entry(sort
, list
, list
) {
755 ret
= sort
->cmp(l
, r
);
763 static struct work_atoms
*
764 thread_atoms_search(struct rb_root
*root
, struct thread
*thread
,
765 struct list_head
*sort_list
)
767 struct rb_node
*node
= root
->rb_node
;
768 struct work_atoms key
= { .thread
= thread
};
771 struct work_atoms
*atoms
;
774 atoms
= container_of(node
, struct work_atoms
, node
);
776 cmp
= thread_lat_cmp(sort_list
, &key
, atoms
);
778 node
= node
->rb_left
;
780 node
= node
->rb_right
;
782 BUG_ON(thread
!= atoms
->thread
);
790 __thread_latency_insert(struct rb_root
*root
, struct work_atoms
*data
,
791 struct list_head
*sort_list
)
793 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
796 struct work_atoms
*this;
799 this = container_of(*new, struct work_atoms
, node
);
802 cmp
= thread_lat_cmp(sort_list
, data
, this);
805 new = &((*new)->rb_left
);
807 new = &((*new)->rb_right
);
810 rb_link_node(&data
->node
, parent
, new);
811 rb_insert_color(&data
->node
, root
);
814 static int thread_atoms_insert(struct perf_sched
*sched
, struct thread
*thread
)
816 struct work_atoms
*atoms
= zalloc(sizeof(*atoms
));
818 pr_err("No memory at %s\n", __func__
);
822 atoms
->thread
= thread
;
823 INIT_LIST_HEAD(&atoms
->work_list
);
824 __thread_latency_insert(&sched
->atom_root
, atoms
, &sched
->cmp_pid
);
828 static int latency_fork_event(struct perf_sched
*sched __maybe_unused
,
829 struct perf_evsel
*evsel __maybe_unused
,
830 struct perf_sample
*sample __maybe_unused
)
832 /* should insert the newcomer */
836 static char sched_out_state(u64 prev_state
)
838 const char *str
= TASK_STATE_TO_CHAR_STR
;
840 return str
[prev_state
];
844 add_sched_out_event(struct work_atoms
*atoms
,
848 struct work_atom
*atom
= zalloc(sizeof(*atom
));
850 pr_err("Non memory at %s", __func__
);
854 atom
->sched_out_time
= timestamp
;
856 if (run_state
== 'R') {
857 atom
->state
= THREAD_WAIT_CPU
;
858 atom
->wake_up_time
= atom
->sched_out_time
;
861 list_add_tail(&atom
->list
, &atoms
->work_list
);
866 add_runtime_event(struct work_atoms
*atoms
, u64 delta
,
867 u64 timestamp __maybe_unused
)
869 struct work_atom
*atom
;
871 BUG_ON(list_empty(&atoms
->work_list
));
873 atom
= list_entry(atoms
->work_list
.prev
, struct work_atom
, list
);
875 atom
->runtime
+= delta
;
876 atoms
->total_runtime
+= delta
;
880 add_sched_in_event(struct work_atoms
*atoms
, u64 timestamp
)
882 struct work_atom
*atom
;
885 if (list_empty(&atoms
->work_list
))
888 atom
= list_entry(atoms
->work_list
.prev
, struct work_atom
, list
);
890 if (atom
->state
!= THREAD_WAIT_CPU
)
893 if (timestamp
< atom
->wake_up_time
) {
894 atom
->state
= THREAD_IGNORE
;
898 atom
->state
= THREAD_SCHED_IN
;
899 atom
->sched_in_time
= timestamp
;
901 delta
= atom
->sched_in_time
- atom
->wake_up_time
;
902 atoms
->total_lat
+= delta
;
903 if (delta
> atoms
->max_lat
) {
904 atoms
->max_lat
= delta
;
905 atoms
->max_lat_at
= timestamp
;
910 static int latency_switch_event(struct perf_sched
*sched
,
911 struct perf_evsel
*evsel
,
912 struct perf_sample
*sample
,
913 struct machine
*machine
)
915 const u32 prev_pid
= perf_evsel__intval(evsel
, sample
, "prev_pid"),
916 next_pid
= perf_evsel__intval(evsel
, sample
, "next_pid");
917 const u64 prev_state
= perf_evsel__intval(evsel
, sample
, "prev_state");
918 struct work_atoms
*out_events
, *in_events
;
919 struct thread
*sched_out
, *sched_in
;
920 u64 timestamp0
, timestamp
= sample
->time
;
921 int cpu
= sample
->cpu
;
924 BUG_ON(cpu
>= MAX_CPUS
|| cpu
< 0);
926 timestamp0
= sched
->cpu_last_switched
[cpu
];
927 sched
->cpu_last_switched
[cpu
] = timestamp
;
929 delta
= timestamp
- timestamp0
;
934 pr_err("hm, delta: %" PRIu64
" < 0 ?\n", delta
);
938 sched_out
= machine__findnew_thread(machine
, prev_pid
);
939 sched_in
= machine__findnew_thread(machine
, next_pid
);
941 out_events
= thread_atoms_search(&sched
->atom_root
, sched_out
, &sched
->cmp_pid
);
943 if (thread_atoms_insert(sched
, sched_out
))
945 out_events
= thread_atoms_search(&sched
->atom_root
, sched_out
, &sched
->cmp_pid
);
947 pr_err("out-event: Internal tree error");
951 if (add_sched_out_event(out_events
, sched_out_state(prev_state
), timestamp
))
954 in_events
= thread_atoms_search(&sched
->atom_root
, sched_in
, &sched
->cmp_pid
);
956 if (thread_atoms_insert(sched
, sched_in
))
958 in_events
= thread_atoms_search(&sched
->atom_root
, sched_in
, &sched
->cmp_pid
);
960 pr_err("in-event: Internal tree error");
964 * Take came in we have not heard about yet,
965 * add in an initial atom in runnable state:
967 if (add_sched_out_event(in_events
, 'R', timestamp
))
970 add_sched_in_event(in_events
, timestamp
);
975 static int latency_runtime_event(struct perf_sched
*sched
,
976 struct perf_evsel
*evsel
,
977 struct perf_sample
*sample
,
978 struct machine
*machine
)
980 const u32 pid
= perf_evsel__intval(evsel
, sample
, "pid");
981 const u64 runtime
= perf_evsel__intval(evsel
, sample
, "runtime");
982 struct thread
*thread
= machine__findnew_thread(machine
, pid
);
983 struct work_atoms
*atoms
= thread_atoms_search(&sched
->atom_root
, thread
, &sched
->cmp_pid
);
984 u64 timestamp
= sample
->time
;
985 int cpu
= sample
->cpu
;
987 BUG_ON(cpu
>= MAX_CPUS
|| cpu
< 0);
989 if (thread_atoms_insert(sched
, thread
))
991 atoms
= thread_atoms_search(&sched
->atom_root
, thread
, &sched
->cmp_pid
);
993 pr_err("in-event: Internal tree error");
996 if (add_sched_out_event(atoms
, 'R', timestamp
))
1000 add_runtime_event(atoms
, runtime
, timestamp
);
1004 static int latency_wakeup_event(struct perf_sched
*sched
,
1005 struct perf_evsel
*evsel
,
1006 struct perf_sample
*sample
,
1007 struct machine
*machine
)
1009 const u32 pid
= perf_evsel__intval(evsel
, sample
, "pid"),
1010 success
= perf_evsel__intval(evsel
, sample
, "success");
1011 struct work_atoms
*atoms
;
1012 struct work_atom
*atom
;
1013 struct thread
*wakee
;
1014 u64 timestamp
= sample
->time
;
1016 /* Note for later, it may be interesting to observe the failing cases */
1020 wakee
= machine__findnew_thread(machine
, pid
);
1021 atoms
= thread_atoms_search(&sched
->atom_root
, wakee
, &sched
->cmp_pid
);
1023 if (thread_atoms_insert(sched
, wakee
))
1025 atoms
= thread_atoms_search(&sched
->atom_root
, wakee
, &sched
->cmp_pid
);
1027 pr_err("wakeup-event: Internal tree error");
1030 if (add_sched_out_event(atoms
, 'S', timestamp
))
1034 BUG_ON(list_empty(&atoms
->work_list
));
1036 atom
= list_entry(atoms
->work_list
.prev
, struct work_atom
, list
);
1039 * You WILL be missing events if you've recorded only
1040 * one CPU, or are only looking at only one, so don't
1041 * make useless noise.
1043 if (sched
->profile_cpu
== -1 && atom
->state
!= THREAD_SLEEPING
)
1044 sched
->nr_state_machine_bugs
++;
1046 sched
->nr_timestamps
++;
1047 if (atom
->sched_out_time
> timestamp
) {
1048 sched
->nr_unordered_timestamps
++;
1052 atom
->state
= THREAD_WAIT_CPU
;
1053 atom
->wake_up_time
= timestamp
;
1057 static int latency_migrate_task_event(struct perf_sched
*sched
,
1058 struct perf_evsel
*evsel
,
1059 struct perf_sample
*sample
,
1060 struct machine
*machine
)
1062 const u32 pid
= perf_evsel__intval(evsel
, sample
, "pid");
1063 u64 timestamp
= sample
->time
;
1064 struct work_atoms
*atoms
;
1065 struct work_atom
*atom
;
1066 struct thread
*migrant
;
1069 * Only need to worry about migration when profiling one CPU.
1071 if (sched
->profile_cpu
== -1)
1074 migrant
= machine__findnew_thread(machine
, pid
);
1075 atoms
= thread_atoms_search(&sched
->atom_root
, migrant
, &sched
->cmp_pid
);
1077 if (thread_atoms_insert(sched
, migrant
))
1079 register_pid(sched
, migrant
->pid
, migrant
->comm
);
1080 atoms
= thread_atoms_search(&sched
->atom_root
, migrant
, &sched
->cmp_pid
);
1082 pr_err("migration-event: Internal tree error");
1085 if (add_sched_out_event(atoms
, 'R', timestamp
))
1089 BUG_ON(list_empty(&atoms
->work_list
));
1091 atom
= list_entry(atoms
->work_list
.prev
, struct work_atom
, list
);
1092 atom
->sched_in_time
= atom
->sched_out_time
= atom
->wake_up_time
= timestamp
;
1094 sched
->nr_timestamps
++;
1096 if (atom
->sched_out_time
> timestamp
)
1097 sched
->nr_unordered_timestamps
++;
1102 static void output_lat_thread(struct perf_sched
*sched
, struct work_atoms
*work_list
)
1108 if (!work_list
->nb_atoms
)
1111 * Ignore idle threads:
1113 if (!strcmp(work_list
->thread
->comm
, "swapper"))
1116 sched
->all_runtime
+= work_list
->total_runtime
;
1117 sched
->all_count
+= work_list
->nb_atoms
;
1119 ret
= printf(" %s:%d ", work_list
->thread
->comm
, work_list
->thread
->pid
);
1121 for (i
= 0; i
< 24 - ret
; i
++)
1124 avg
= work_list
->total_lat
/ work_list
->nb_atoms
;
1126 printf("|%11.3f ms |%9" PRIu64
" | avg:%9.3f ms | max:%9.3f ms | max at: %9.6f s\n",
1127 (double)work_list
->total_runtime
/ 1e6
,
1128 work_list
->nb_atoms
, (double)avg
/ 1e6
,
1129 (double)work_list
->max_lat
/ 1e6
,
1130 (double)work_list
->max_lat_at
/ 1e9
);
1133 static int pid_cmp(struct work_atoms
*l
, struct work_atoms
*r
)
1135 if (l
->thread
->pid
< r
->thread
->pid
)
1137 if (l
->thread
->pid
> r
->thread
->pid
)
1143 static int avg_cmp(struct work_atoms
*l
, struct work_atoms
*r
)
1153 avgl
= l
->total_lat
/ l
->nb_atoms
;
1154 avgr
= r
->total_lat
/ r
->nb_atoms
;
1164 static int max_cmp(struct work_atoms
*l
, struct work_atoms
*r
)
1166 if (l
->max_lat
< r
->max_lat
)
1168 if (l
->max_lat
> r
->max_lat
)
1174 static int switch_cmp(struct work_atoms
*l
, struct work_atoms
*r
)
1176 if (l
->nb_atoms
< r
->nb_atoms
)
1178 if (l
->nb_atoms
> r
->nb_atoms
)
1184 static int runtime_cmp(struct work_atoms
*l
, struct work_atoms
*r
)
1186 if (l
->total_runtime
< r
->total_runtime
)
1188 if (l
->total_runtime
> r
->total_runtime
)
1194 static int sort_dimension__add(const char *tok
, struct list_head
*list
)
1197 static struct sort_dimension avg_sort_dimension
= {
1201 static struct sort_dimension max_sort_dimension
= {
1205 static struct sort_dimension pid_sort_dimension
= {
1209 static struct sort_dimension runtime_sort_dimension
= {
1213 static struct sort_dimension switch_sort_dimension
= {
1217 struct sort_dimension
*available_sorts
[] = {
1218 &pid_sort_dimension
,
1219 &avg_sort_dimension
,
1220 &max_sort_dimension
,
1221 &switch_sort_dimension
,
1222 &runtime_sort_dimension
,
1225 for (i
= 0; i
< ARRAY_SIZE(available_sorts
); i
++) {
1226 if (!strcmp(available_sorts
[i
]->name
, tok
)) {
1227 list_add_tail(&available_sorts
[i
]->list
, list
);
1236 static void perf_sched__sort_lat(struct perf_sched
*sched
)
1238 struct rb_node
*node
;
1241 struct work_atoms
*data
;
1242 node
= rb_first(&sched
->atom_root
);
1246 rb_erase(node
, &sched
->atom_root
);
1247 data
= rb_entry(node
, struct work_atoms
, node
);
1248 __thread_latency_insert(&sched
->sorted_atom_root
, data
, &sched
->sort_list
);
1252 static int process_sched_wakeup_event(struct perf_tool
*tool
,
1253 struct perf_evsel
*evsel
,
1254 struct perf_sample
*sample
,
1255 struct machine
*machine
)
1257 struct perf_sched
*sched
= container_of(tool
, struct perf_sched
, tool
);
1259 if (sched
->tp_handler
->wakeup_event
)
1260 return sched
->tp_handler
->wakeup_event(sched
, evsel
, sample
, machine
);
1265 static int map_switch_event(struct perf_sched
*sched
, struct perf_evsel
*evsel
,
1266 struct perf_sample
*sample
, struct machine
*machine
)
1268 const u32 prev_pid
= perf_evsel__intval(evsel
, sample
, "prev_pid"),
1269 next_pid
= perf_evsel__intval(evsel
, sample
, "next_pid");
1270 struct thread
*sched_out __maybe_unused
, *sched_in
;
1272 u64 timestamp0
, timestamp
= sample
->time
;
1274 int cpu
, this_cpu
= sample
->cpu
;
1276 BUG_ON(this_cpu
>= MAX_CPUS
|| this_cpu
< 0);
1278 if (this_cpu
> sched
->max_cpu
)
1279 sched
->max_cpu
= this_cpu
;
1281 timestamp0
= sched
->cpu_last_switched
[this_cpu
];
1282 sched
->cpu_last_switched
[this_cpu
] = timestamp
;
1284 delta
= timestamp
- timestamp0
;
1289 pr_err("hm, delta: %" PRIu64
" < 0 ?\n", delta
);
1293 sched_out
= machine__findnew_thread(machine
, prev_pid
);
1294 sched_in
= machine__findnew_thread(machine
, next_pid
);
1296 sched
->curr_thread
[this_cpu
] = sched_in
;
1301 if (!sched_in
->shortname
[0]) {
1302 sched_in
->shortname
[0] = sched
->next_shortname1
;
1303 sched_in
->shortname
[1] = sched
->next_shortname2
;
1305 if (sched
->next_shortname1
< 'Z') {
1306 sched
->next_shortname1
++;
1308 sched
->next_shortname1
='A';
1309 if (sched
->next_shortname2
< '9') {
1310 sched
->next_shortname2
++;
1312 sched
->next_shortname2
='0';
1318 for (cpu
= 0; cpu
<= sched
->max_cpu
; cpu
++) {
1319 if (cpu
!= this_cpu
)
1324 if (sched
->curr_thread
[cpu
]) {
1325 if (sched
->curr_thread
[cpu
]->pid
)
1326 printf("%2s ", sched
->curr_thread
[cpu
]->shortname
);
1333 printf(" %12.6f secs ", (double)timestamp
/1e9
);
1334 if (new_shortname
) {
1335 printf("%s => %s:%d\n",
1336 sched_in
->shortname
, sched_in
->comm
, sched_in
->pid
);
1344 static int process_sched_switch_event(struct perf_tool
*tool
,
1345 struct perf_evsel
*evsel
,
1346 struct perf_sample
*sample
,
1347 struct machine
*machine
)
1349 struct perf_sched
*sched
= container_of(tool
, struct perf_sched
, tool
);
1350 int this_cpu
= sample
->cpu
, err
= 0;
1351 u32 prev_pid
= perf_evsel__intval(evsel
, sample
, "prev_pid"),
1352 next_pid
= perf_evsel__intval(evsel
, sample
, "next_pid");
1354 if (sched
->curr_pid
[this_cpu
] != (u32
)-1) {
1356 * Are we trying to switch away a PID that is
1359 if (sched
->curr_pid
[this_cpu
] != prev_pid
)
1360 sched
->nr_context_switch_bugs
++;
1363 if (sched
->tp_handler
->switch_event
)
1364 err
= sched
->tp_handler
->switch_event(sched
, evsel
, sample
, machine
);
1366 sched
->curr_pid
[this_cpu
] = next_pid
;
1370 static int process_sched_runtime_event(struct perf_tool
*tool
,
1371 struct perf_evsel
*evsel
,
1372 struct perf_sample
*sample
,
1373 struct machine
*machine
)
1375 struct perf_sched
*sched
= container_of(tool
, struct perf_sched
, tool
);
1377 if (sched
->tp_handler
->runtime_event
)
1378 return sched
->tp_handler
->runtime_event(sched
, evsel
, sample
, machine
);
1383 static int process_sched_fork_event(struct perf_tool
*tool
,
1384 struct perf_evsel
*evsel
,
1385 struct perf_sample
*sample
,
1386 struct machine
*machine __maybe_unused
)
1388 struct perf_sched
*sched
= container_of(tool
, struct perf_sched
, tool
);
1390 if (sched
->tp_handler
->fork_event
)
1391 return sched
->tp_handler
->fork_event(sched
, evsel
, sample
);
1396 static int process_sched_exit_event(struct perf_tool
*tool __maybe_unused
,
1397 struct perf_evsel
*evsel
,
1398 struct perf_sample
*sample __maybe_unused
,
1399 struct machine
*machine __maybe_unused
)
1401 pr_debug("sched_exit event %p\n", evsel
);
1405 static int process_sched_migrate_task_event(struct perf_tool
*tool
,
1406 struct perf_evsel
*evsel
,
1407 struct perf_sample
*sample
,
1408 struct machine
*machine
)
1410 struct perf_sched
*sched
= container_of(tool
, struct perf_sched
, tool
);
1412 if (sched
->tp_handler
->migrate_task_event
)
1413 return sched
->tp_handler
->migrate_task_event(sched
, evsel
, sample
, machine
);
1418 typedef int (*tracepoint_handler
)(struct perf_tool
*tool
,
1419 struct perf_evsel
*evsel
,
1420 struct perf_sample
*sample
,
1421 struct machine
*machine
);
1423 static int perf_sched__process_tracepoint_sample(struct perf_tool
*tool __maybe_unused
,
1424 union perf_event
*event __maybe_unused
,
1425 struct perf_sample
*sample
,
1426 struct perf_evsel
*evsel
,
1427 struct machine
*machine
)
1429 struct thread
*thread
= machine__findnew_thread(machine
, sample
->tid
);
1432 if (thread
== NULL
) {
1433 pr_debug("problem processing %s event, skipping it.\n",
1434 perf_evsel__name(evsel
));
1438 evsel
->hists
.stats
.total_period
+= sample
->period
;
1439 hists__inc_nr_events(&evsel
->hists
, PERF_RECORD_SAMPLE
);
1441 if (evsel
->handler
.func
!= NULL
) {
1442 tracepoint_handler f
= evsel
->handler
.func
;
1443 err
= f(tool
, evsel
, sample
, machine
);
1449 static int perf_sched__read_events(struct perf_sched
*sched
, bool destroy
,
1450 struct perf_session
**psession
)
1452 const struct perf_evsel_str_handler handlers
[] = {
1453 { "sched:sched_switch", process_sched_switch_event
, },
1454 { "sched:sched_stat_runtime", process_sched_runtime_event
, },
1455 { "sched:sched_wakeup", process_sched_wakeup_event
, },
1456 { "sched:sched_wakeup_new", process_sched_wakeup_event
, },
1457 { "sched:sched_process_fork", process_sched_fork_event
, },
1458 { "sched:sched_process_exit", process_sched_exit_event
, },
1459 { "sched:sched_migrate_task", process_sched_migrate_task_event
, },
1461 struct perf_session
*session
;
1463 session
= perf_session__new(sched
->input_name
, O_RDONLY
, 0, false, &sched
->tool
);
1464 if (session
== NULL
) {
1465 pr_debug("No Memory for session\n");
1469 if (perf_session__set_tracepoints_handlers(session
, handlers
))
1472 if (perf_session__has_traces(session
, "record -R")) {
1473 int err
= perf_session__process_events(session
, &sched
->tool
);
1475 pr_err("Failed to process events, error %d", err
);
1479 sched
->nr_events
= session
->hists
.stats
.nr_events
[0];
1480 sched
->nr_lost_events
= session
->hists
.stats
.total_lost
;
1481 sched
->nr_lost_chunks
= session
->hists
.stats
.nr_events
[PERF_RECORD_LOST
];
1485 perf_session__delete(session
);
1488 *psession
= session
;
1493 perf_session__delete(session
);
1497 static void print_bad_events(struct perf_sched
*sched
)
1499 if (sched
->nr_unordered_timestamps
&& sched
->nr_timestamps
) {
1500 printf(" INFO: %.3f%% unordered timestamps (%ld out of %ld)\n",
1501 (double)sched
->nr_unordered_timestamps
/(double)sched
->nr_timestamps
*100.0,
1502 sched
->nr_unordered_timestamps
, sched
->nr_timestamps
);
1504 if (sched
->nr_lost_events
&& sched
->nr_events
) {
1505 printf(" INFO: %.3f%% lost events (%ld out of %ld, in %ld chunks)\n",
1506 (double)sched
->nr_lost_events
/(double)sched
->nr_events
* 100.0,
1507 sched
->nr_lost_events
, sched
->nr_events
, sched
->nr_lost_chunks
);
1509 if (sched
->nr_state_machine_bugs
&& sched
->nr_timestamps
) {
1510 printf(" INFO: %.3f%% state machine bugs (%ld out of %ld)",
1511 (double)sched
->nr_state_machine_bugs
/(double)sched
->nr_timestamps
*100.0,
1512 sched
->nr_state_machine_bugs
, sched
->nr_timestamps
);
1513 if (sched
->nr_lost_events
)
1514 printf(" (due to lost events?)");
1517 if (sched
->nr_context_switch_bugs
&& sched
->nr_timestamps
) {
1518 printf(" INFO: %.3f%% context switch bugs (%ld out of %ld)",
1519 (double)sched
->nr_context_switch_bugs
/(double)sched
->nr_timestamps
*100.0,
1520 sched
->nr_context_switch_bugs
, sched
->nr_timestamps
);
1521 if (sched
->nr_lost_events
)
1522 printf(" (due to lost events?)");
1527 static int perf_sched__lat(struct perf_sched
*sched
)
1529 struct rb_node
*next
;
1530 struct perf_session
*session
;
1533 if (perf_sched__read_events(sched
, false, &session
))
1535 perf_sched__sort_lat(sched
);
1537 printf("\n ---------------------------------------------------------------------------------------------------------------\n");
1538 printf(" Task | Runtime ms | Switches | Average delay ms | Maximum delay ms | Maximum delay at |\n");
1539 printf(" ---------------------------------------------------------------------------------------------------------------\n");
1541 next
= rb_first(&sched
->sorted_atom_root
);
1544 struct work_atoms
*work_list
;
1546 work_list
= rb_entry(next
, struct work_atoms
, node
);
1547 output_lat_thread(sched
, work_list
);
1548 next
= rb_next(next
);
1551 printf(" -----------------------------------------------------------------------------------------\n");
1552 printf(" TOTAL: |%11.3f ms |%9" PRIu64
" |\n",
1553 (double)sched
->all_runtime
/ 1e6
, sched
->all_count
);
1555 printf(" ---------------------------------------------------\n");
1557 print_bad_events(sched
);
1560 perf_session__delete(session
);
1564 static int perf_sched__map(struct perf_sched
*sched
)
1566 sched
->max_cpu
= sysconf(_SC_NPROCESSORS_CONF
);
1569 if (perf_sched__read_events(sched
, true, NULL
))
1571 print_bad_events(sched
);
1575 static int perf_sched__replay(struct perf_sched
*sched
)
1579 calibrate_run_measurement_overhead(sched
);
1580 calibrate_sleep_measurement_overhead(sched
);
1582 test_calibrations(sched
);
1584 if (perf_sched__read_events(sched
, true, NULL
))
1587 printf("nr_run_events: %ld\n", sched
->nr_run_events
);
1588 printf("nr_sleep_events: %ld\n", sched
->nr_sleep_events
);
1589 printf("nr_wakeup_events: %ld\n", sched
->nr_wakeup_events
);
1591 if (sched
->targetless_wakeups
)
1592 printf("target-less wakeups: %ld\n", sched
->targetless_wakeups
);
1593 if (sched
->multitarget_wakeups
)
1594 printf("multi-target wakeups: %ld\n", sched
->multitarget_wakeups
);
1595 if (sched
->nr_run_events_optimized
)
1596 printf("run atoms optimized: %ld\n",
1597 sched
->nr_run_events_optimized
);
1599 print_task_traces(sched
);
1600 add_cross_task_wakeups(sched
);
1602 create_tasks(sched
);
1603 printf("------------------------------------------------------------\n");
1604 for (i
= 0; i
< sched
->replay_repeat
; i
++)
1605 run_one_test(sched
);
1610 static void setup_sorting(struct perf_sched
*sched
, const struct option
*options
,
1611 const char * const usage_msg
[])
1613 char *tmp
, *tok
, *str
= strdup(sched
->sort_order
);
1615 for (tok
= strtok_r(str
, ", ", &tmp
);
1616 tok
; tok
= strtok_r(NULL
, ", ", &tmp
)) {
1617 if (sort_dimension__add(tok
, &sched
->sort_list
) < 0) {
1618 error("Unknown --sort key: `%s'", tok
);
1619 usage_with_options(usage_msg
, options
);
1625 sort_dimension__add("pid", &sched
->cmp_pid
);
1628 static int __cmd_record(int argc
, const char **argv
)
1630 unsigned int rec_argc
, i
, j
;
1631 const char **rec_argv
;
1632 const char * const record_args
[] = {
1639 "-e", "sched:sched_switch",
1640 "-e", "sched:sched_stat_wait",
1641 "-e", "sched:sched_stat_sleep",
1642 "-e", "sched:sched_stat_iowait",
1643 "-e", "sched:sched_stat_runtime",
1644 "-e", "sched:sched_process_exit",
1645 "-e", "sched:sched_process_fork",
1646 "-e", "sched:sched_wakeup",
1647 "-e", "sched:sched_migrate_task",
1650 rec_argc
= ARRAY_SIZE(record_args
) + argc
- 1;
1651 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
1653 if (rec_argv
== NULL
)
1656 for (i
= 0; i
< ARRAY_SIZE(record_args
); i
++)
1657 rec_argv
[i
] = strdup(record_args
[i
]);
1659 for (j
= 1; j
< (unsigned int)argc
; j
++, i
++)
1660 rec_argv
[i
] = argv
[j
];
1662 BUG_ON(i
!= rec_argc
);
1664 return cmd_record(i
, rec_argv
, NULL
);
1667 int cmd_sched(int argc
, const char **argv
, const char *prefix __maybe_unused
)
1669 const char default_sort_order
[] = "avg, max, switch, runtime";
1670 struct perf_sched sched
= {
1672 .sample
= perf_sched__process_tracepoint_sample
,
1673 .comm
= perf_event__process_comm
,
1674 .lost
= perf_event__process_lost
,
1675 .fork
= perf_event__process_task
,
1676 .ordered_samples
= true,
1678 .cmp_pid
= LIST_HEAD_INIT(sched
.cmp_pid
),
1679 .sort_list
= LIST_HEAD_INIT(sched
.sort_list
),
1680 .start_work_mutex
= PTHREAD_MUTEX_INITIALIZER
,
1681 .work_done_wait_mutex
= PTHREAD_MUTEX_INITIALIZER
,
1682 .curr_pid
= { [0 ... MAX_CPUS
- 1] = -1 },
1683 .sort_order
= default_sort_order
,
1684 .replay_repeat
= 10,
1686 .next_shortname1
= 'A',
1687 .next_shortname2
= '0',
1689 const struct option latency_options
[] = {
1690 OPT_STRING('s', "sort", &sched
.sort_order
, "key[,key2...]",
1691 "sort by key(s): runtime, switch, avg, max"),
1692 OPT_INCR('v', "verbose", &verbose
,
1693 "be more verbose (show symbol address, etc)"),
1694 OPT_INTEGER('C', "CPU", &sched
.profile_cpu
,
1695 "CPU to profile on"),
1696 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace
,
1697 "dump raw trace in ASCII"),
1700 const struct option replay_options
[] = {
1701 OPT_UINTEGER('r', "repeat", &sched
.replay_repeat
,
1702 "repeat the workload replay N times (-1: infinite)"),
1703 OPT_INCR('v', "verbose", &verbose
,
1704 "be more verbose (show symbol address, etc)"),
1705 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace
,
1706 "dump raw trace in ASCII"),
1709 const struct option sched_options
[] = {
1710 OPT_STRING('i', "input", &sched
.input_name
, "file",
1712 OPT_INCR('v', "verbose", &verbose
,
1713 "be more verbose (show symbol address, etc)"),
1714 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace
,
1715 "dump raw trace in ASCII"),
1718 const char * const latency_usage
[] = {
1719 "perf sched latency [<options>]",
1722 const char * const replay_usage
[] = {
1723 "perf sched replay [<options>]",
1726 const char * const sched_usage
[] = {
1727 "perf sched [<options>] {record|latency|map|replay|script}",
1730 struct trace_sched_handler lat_ops
= {
1731 .wakeup_event
= latency_wakeup_event
,
1732 .switch_event
= latency_switch_event
,
1733 .runtime_event
= latency_runtime_event
,
1734 .fork_event
= latency_fork_event
,
1735 .migrate_task_event
= latency_migrate_task_event
,
1737 struct trace_sched_handler map_ops
= {
1738 .switch_event
= map_switch_event
,
1740 struct trace_sched_handler replay_ops
= {
1741 .wakeup_event
= replay_wakeup_event
,
1742 .switch_event
= replay_switch_event
,
1743 .fork_event
= replay_fork_event
,
1746 argc
= parse_options(argc
, argv
, sched_options
, sched_usage
,
1747 PARSE_OPT_STOP_AT_NON_OPTION
);
1749 usage_with_options(sched_usage
, sched_options
);
1752 * Aliased to 'perf script' for now:
1754 if (!strcmp(argv
[0], "script"))
1755 return cmd_script(argc
, argv
, prefix
);
1758 if (!strncmp(argv
[0], "rec", 3)) {
1759 return __cmd_record(argc
, argv
);
1760 } else if (!strncmp(argv
[0], "lat", 3)) {
1761 sched
.tp_handler
= &lat_ops
;
1763 argc
= parse_options(argc
, argv
, latency_options
, latency_usage
, 0);
1765 usage_with_options(latency_usage
, latency_options
);
1767 setup_sorting(&sched
, latency_options
, latency_usage
);
1768 return perf_sched__lat(&sched
);
1769 } else if (!strcmp(argv
[0], "map")) {
1770 sched
.tp_handler
= &map_ops
;
1771 setup_sorting(&sched
, latency_options
, latency_usage
);
1772 return perf_sched__map(&sched
);
1773 } else if (!strncmp(argv
[0], "rep", 3)) {
1774 sched
.tp_handler
= &replay_ops
;
1776 argc
= parse_options(argc
, argv
, replay_options
, replay_usage
, 0);
1778 usage_with_options(replay_usage
, replay_options
);
1780 return perf_sched__replay(&sched
);
1782 usage_with_options(sched_usage
, sched_options
);