Release 4.7 tools/perf/builtin-sched.c

Directory: tools/perf
#include "builtin.h"
#include "perf.h"

#include "util/util.h"
#include "util/evlist.h"
#include "util/cache.h"
#include "util/evsel.h"
#include "util/symbol.h"
#include "util/thread.h"
#include "util/header.h"
#include "util/session.h"
#include "util/tool.h"
#include "util/cloexec.h"
#include "util/thread_map.h"
#include "util/color.h"

#include <subcmd/parse-options.h>
#include "util/trace-event.h"

#include "util/debug.h"

#include <sys/prctl.h>
#include <sys/resource.h>

#include <semaphore.h>
#include <pthread.h>
#include <math.h>
#include <api/fs/fs.h>


#define PR_SET_NAME		15               
/* Set process name */

#define MAX_CPUS		4096

#define COMM_LEN		20

#define SYM_LEN			129

#define MAX_PID			1024000

struct sched_atom;


struct task_desc {
	
unsigned long		nr;
	
unsigned long		pid;
	
char			comm[COMM_LEN];

	
unsigned long		nr_events;
	
unsigned long		curr_event;
	
struct sched_atom	**atoms;

	
pthread_t		thread;
	
sem_t			sleep_sem;

	
sem_t			ready_for_work;
	
sem_t			work_done_sem;

	
u64			cpu_usage;
};


enum sched_event_type {
	
SCHED_EVENT_RUN,
	
SCHED_EVENT_SLEEP,
	
SCHED_EVENT_WAKEUP,
	
SCHED_EVENT_MIGRATION,
};


struct sched_atom {
	
enum sched_event_type	type;
	
int			specific_wait;
	
u64			timestamp;
	
u64			duration;
	
unsigned long		nr;
	
sem_t			*wait_sem;
	
struct task_desc	*wakee;
};


#define TASK_STATE_TO_CHAR_STR "RSDTtZXxKWP"


enum thread_state {
	
THREAD_SLEEPING = 0,
	
THREAD_WAIT_CPU,
	
THREAD_SCHED_IN,
	
THREAD_IGNORE
};


struct work_atom {
	
struct list_head	list;
	
enum thread_state	state;
	
u64			sched_out_time;
	
u64			wake_up_time;
	
u64			sched_in_time;
	
u64			runtime;
};


struct work_atoms {
	
struct list_head	work_list;
	
struct thread		*thread;
	
struct rb_node		node;
	
u64			max_lat;
	
u64			max_lat_at;
	
u64			total_lat;
	
u64			nb_atoms;
	
u64			total_runtime;
	
int			num_merged;
};


typedef int (*sort_fn_t)(struct work_atoms *, struct work_atoms *);

struct perf_sched;


struct trace_sched_handler {
	
int (*switch_event)(struct perf_sched *sched, struct perf_evsel *evsel,
			    struct perf_sample *sample, struct machine *machine);

	
int (*runtime_event)(struct perf_sched *sched, struct perf_evsel *evsel,
			     struct perf_sample *sample, struct machine *machine);

	
int (*wakeup_event)(struct perf_sched *sched, struct perf_evsel *evsel,
			    struct perf_sample *sample, struct machine *machine);

	/* PERF_RECORD_FORK event, not sched_process_fork tracepoint */
	
int (*fork_event)(struct perf_sched *sched, union perf_event *event,
			  struct machine *machine);

	
int (*migrate_task_event)(struct perf_sched *sched,
				  struct perf_evsel *evsel,
				  struct perf_sample *sample,
				  struct machine *machine);
};


#define COLOR_PIDS PERF_COLOR_BLUE

#define COLOR_CPUS PERF_COLOR_BG_RED


struct perf_sched_map {
	DECLARE_BITMAP(comp_cpus_mask, MAX_CPUS);
	
int			*comp_cpus;
	
bool			 comp;
	
struct thread_map	*color_pids;
	
const char		*color_pids_str;
	
struct cpu_map		*color_cpus;
	
const char		*color_cpus_str;
	
struct cpu_map		*cpus;
	
const char		*cpus_str;
};


struct perf_sched {
	
struct perf_tool tool;
	
const char	 *sort_order;
	
unsigned long	 nr_tasks;
	
struct task_desc **pid_to_task;
	
struct task_desc **tasks;
	
const struct trace_sched_handler *tp_handler;
	
pthread_mutex_t	 start_work_mutex;
	
pthread_mutex_t	 work_done_wait_mutex;
	
int		 profile_cpu;
/*
 * Track the current task - that way we can know whether there's any
 * weird events, such as a task being switched away that is not current.
 */
	
int		 max_cpu;
	
u32		 curr_pid[MAX_CPUS];
	
struct thread	 *curr_thread[MAX_CPUS];
	
char		 next_shortname1;
	
char		 next_shortname2;
	
unsigned int	 replay_repeat;
	
unsigned long	 nr_run_events;
	
unsigned long	 nr_sleep_events;
	
unsigned long	 nr_wakeup_events;
	
unsigned long	 nr_sleep_corrections;
	
unsigned long	 nr_run_events_optimized;
	
unsigned long	 targetless_wakeups;
	
unsigned long	 multitarget_wakeups;
	
unsigned long	 nr_runs;
	
unsigned long	 nr_timestamps;
	
unsigned long	 nr_unordered_timestamps;
	
unsigned long	 nr_context_switch_bugs;
	
unsigned long	 nr_events;
	
unsigned long	 nr_lost_chunks;
	
unsigned long	 nr_lost_events;
	
u64		 run_measurement_overhead;
	
u64		 sleep_measurement_overhead;
	
u64		 start_time;
	
u64		 cpu_usage;
	
u64		 runavg_cpu_usage;
	
u64		 parent_cpu_usage;
	
u64		 runavg_parent_cpu_usage;
	
u64		 sum_runtime;
	
u64		 sum_fluct;
	
u64		 run_avg;
	
u64		 all_runtime;
	
u64		 all_count;
	
u64		 cpu_last_switched[MAX_CPUS];
	


struct rb_root	 atom_root, sorted_atom_root, merged_atom_root;
	

struct list_head sort_list, cmp_pid;
	
bool force;
	
bool skip_merge;
	
struct perf_sched_map map;
};



static u64 get_nsecs(void)
{
	struct timespec ts;

	clock_gettime(CLOCK_MONOTONIC, &ts);

	return ts.tv_sec * 1000000000ULL + ts.tv_nsec;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 24 77.42% 1 50.00%
ingo molnar ingo molnar 7 22.58% 1 50.00%
Total 31 100.00% 2 100.00%



static void burn_nsecs(struct perf_sched *sched, u64 nsecs)
{
	u64 T0 = get_nsecs(), T1;

	do {
		T1 = get_nsecs();
	} while (T1 + sched->run_measurement_overhead < T0 + nsecs);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 37 86.05% 1 50.00%
ingo molnar ingo molnar 6 13.95% 1 50.00%
Total 43 100.00% 2 100.00%



static void sleep_nsecs(u64 nsecs)
{
	struct timespec ts;

	ts.tv_nsec = nsecs % 999999999;
	ts.tv_sec = nsecs / 999999999;

	nanosleep(&ts, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 37 100.00% 1 100.00%
Total 37 100.00% 1 100.00%



static void calibrate_run_measurement_overhead(struct perf_sched *sched)
{
	u64 T0, T1, delta, min_delta = 1000000000ULL;
	int i;

	for (i = 0; i < 10; i++) {
		T0 = get_nsecs();
		burn_nsecs(sched, 0);
		T1 = get_nsecs();
		delta = T1-T0;
		min_delta = min(min_delta, delta);
	}
	sched->run_measurement_overhead = min_delta;

	printf("run measurement overhead: %" PRIu64 " nsecs\n", min_delta);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 62 71.26% 1 50.00%
ingo molnar ingo molnar 25 28.74% 1 50.00%
Total 87 100.00% 2 100.00%



static void calibrate_sleep_measurement_overhead(struct perf_sched *sched)
{
	u64 T0, T1, delta, min_delta = 1000000000ULL;
	int i;

	for (i = 0; i < 10; i++) {
		T0 = get_nsecs();
		sleep_nsecs(10000);
		T1 = get_nsecs();
		delta = T1-T0;
		min_delta = min(min_delta, delta);
	}
	min_delta -= 10000;
	sched->sleep_measurement_overhead = min_delta;

	printf("sleep measurement overhead: %" PRIu64 " nsecs\n", min_delta);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 54 60.67% 1 33.33%
ingo molnar ingo molnar 35 39.33% 2 66.67%
Total 89 100.00% 3 100.00%


static struct sched_atom *

get_new_event(struct task_desc *task, u64 timestamp)
{
	struct sched_atom *event = zalloc(sizeof(*event));
	unsigned long idx = task->nr_events;
	size_t size;

	event->timestamp = timestamp;
	event->nr = idx;

	task->nr_events++;
	size = sizeof(struct sched_atom *) * task->nr_events;
	task->atoms = realloc(task->atoms, size);
	BUG_ON(!task->atoms);

	task->atoms[idx] = event;

	return event;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 71 68.27% 1 25.00%
ingo molnar ingo molnar 33 31.73% 3 75.00%
Total 104 100.00% 4 100.00%



static struct sched_atom *last_event(struct task_desc *task)
{
	if (!task->nr_events)
		return NULL;

	return task->atoms[task->nr_events - 1];
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 28 80.00% 1 50.00%
ingo molnar ingo molnar 7 20.00% 1 50.00%
Total 35 100.00% 2 100.00%



static void add_sched_event_run(struct perf_sched *sched, struct task_desc *task,
				u64 timestamp, u64 duration)
{
	struct sched_atom *event, *curr_event = last_event(task);

	/*
         * optimize an existing RUN event by merging this one
         * to it:
         */
	if (curr_event && curr_event->type == SCHED_EVENT_RUN) {
		sched->nr_run_events_optimized++;
		curr_event->duration += duration;
		return;
	}

	event = get_new_event(task, timestamp);

	event->type = SCHED_EVENT_RUN;
	event->duration = duration;

	sched->nr_run_events++;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 69 80.23% 1 33.33%
ingo molnar ingo molnar 15 17.44% 1 33.33%
xiao guangrong xiao guangrong 2 2.33% 1 33.33%
Total 86 100.00% 3 100.00%



static void add_sched_event_wakeup(struct perf_sched *sched, struct task_desc *task,
				   u64 timestamp, struct task_desc *wakee)
{
	struct sched_atom *event, *wakee_event;

	event = get_new_event(task, timestamp);
	event->type = SCHED_EVENT_WAKEUP;
	event->wakee = wakee;

	wakee_event = last_event(wakee);
	if (!wakee_event || wakee_event->type != SCHED_EVENT_SLEEP) {
		sched->targetless_wakeups++;
		return;
	}
	if (wakee_event->wait_sem) {
		sched->multitarget_wakeups++;
		return;
	}

	wakee_event->wait_sem = zalloc(sizeof(*wakee_event->wait_sem));
	sem_init(wakee_event->wait_sem, 0, 0);
	wakee_event->specific_wait = 1;
	event->wait_sem = wakee_event->wait_sem;

	sched->nr_wakeup_events++;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 120 86.96% 1 33.33%
xiao guangrong xiao guangrong 11 7.97% 1 33.33%
ingo molnar ingo molnar 7 5.07% 1 33.33%
Total 138 100.00% 3 100.00%



static void add_sched_event_sleep(struct perf_sched *sched, struct task_desc *task,
				  u64 timestamp, u64 task_state __maybe_unused)
{
	struct sched_atom *event = get_new_event(task, timestamp);

	event->type = SCHED_EVENT_SLEEP;

	sched->nr_sleep_events++;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 37 80.43% 1 33.33%
ingo molnar ingo molnar 9 19.57% 2 66.67%
Total 46 100.00% 3 100.00%



static struct task_desc *register_pid(struct perf_sched *sched,
				      unsigned long pid, const char *comm)
{
	struct task_desc *task;
	static int pid_max;

	if (sched->pid_to_task == NULL) {
		if (sysctl__read_int("kernel/pid_max", &pid_max) < 0)
			pid_max = MAX_PID;
		BUG_ON((sched->pid_to_task = calloc(pid_max, sizeof(struct task_desc *))) == NULL);
	}
	if (pid >= (unsigned long)pid_max) {
		BUG_ON((sched->pid_to_task = realloc(sched->pid_to_task, (pid + 1) *
			sizeof(struct task_desc *))) == NULL);
		while (pid >= (unsigned long)pid_max)
			sched->pid_to_task[pid_max++] = NULL;
	}

	task = sched->pid_to_task[pid];

	if (task)
		return task;

	task = zalloc(sizeof(*task));
	task->pid = pid;
	task->nr = sched->nr_tasks;
	strcpy(task->comm, comm);
	/*
         * every task starts in sleeping state - this gets ignored
         * if there's no wakeup pointing to this sleep state:
         */
	add_sched_event_sleep(sched, task, 0, 0);

	sched->pid_to_task[pid] = task;
	sched->nr_tasks++;
	sched->tasks = realloc(sched->tasks, sched->nr_tasks * sizeof(struct task_desc *));
	BUG_ON(!sched->tasks);
	sched->tasks[task->nr] = task;

	if (verbose)
		printf("registered task #%ld, PID %ld (%s)\n", sched->nr_tasks, pid, comm);

	return task;
}


Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 136 48.57% 2 28.57%
yunlong song yunlong song 112 40.00% 3 42.86%
ingo molnar ingo molnar 28 10.00% 1 14.29%
xiao guangrong xiao guangrong 4 1.43% 1 14.29%
Total 280 100.00% 7 100.00%



static void print_task_traces(struct perf_sched *sched)
{
	struct task_desc *task;
	unsigned long i;

	for (i = 0; i < sched->nr_tasks; i++) {
		task = sched->tasks[i];
		printf("task %6ld (%20s:%10ld), nr_events: %ld\n",
			task->nr, task->comm, task->pid, task->nr_events);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 41 61.19% 1 33.33%
ingo molnar ingo molnar 25 37.31% 1 33.33%
xiao guangrong xiao guangrong 1 1.49% 1 33.33%
Total 67 100.00% 3 100.00%



static void add_cross_task_wakeups(struct perf_sched *sched)
{
	struct task_desc *task1, *task2;
	unsigned long i, j;

	for (i = 0; i < sched->nr_tasks; i++) {
		task1 = sched->tasks[i];
		j = i + 1;
		if (j == sched->nr_tasks)
			j = 0;
		task2 = sched->tasks[j];
		add_sched_event_wakeup(sched, task1, 0, task2);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 47 52.81% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 42 47.19% 1 50.00%
Total 89 100.00% 2 100.00%



static void perf_sched__process_event(struct perf_sched *sched,
				      struct sched_atom *atom)
{
	int ret = 0;

	switch (atom->type) {
		case SCHED_EVENT_RUN:
			burn_nsecs(sched, atom->duration);
			break;
		case SCHED_EVENT_SLEEP:
			if (atom->wait_sem)
				ret = sem_wait(atom->wait_sem);
			BUG_ON(ret);
			break;
		case SCHED_EVENT_WAKEUP:
			if (atom->wait_sem)
				ret = sem_post(atom->wait_sem);
			BUG_ON(ret);
			break;
		case SCHED_EVENT_MIGRATION:
			break;
		default:
			BUG_ON(1);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 64 64.00% 1 50.00%
ingo molnar ingo molnar 36 36.00% 1 50.00%
Total 100 100.00% 2 100.00%



static u64 get_cpu_usage_nsec_parent(void)
{
	struct rusage ru;
	u64 sum;
	int err;

	err = getrusage(RUSAGE_SELF, &ru);
	BUG_ON(err);

	sum =  ru.ru_utime.tv_sec*1e9 + ru.ru_utime.tv_usec*1e3;
	sum += ru.ru_stime.tv_sec*1e9 + ru.ru_stime.tv_usec*1e3;

	return sum;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 62 86.11% 1 50.00%
ingo molnar ingo molnar 10 13.89% 1 50.00%
Total 72 100.00% 2 100.00%



static int self_open_counters(struct perf_sched *sched, unsigned long cur_task)
{
	struct perf_event_attr attr;
	char sbuf[STRERR_BUFSIZE], info[STRERR_BUFSIZE];
	int fd;
	struct rlimit limit;
	bool need_privilege = false;

	memset(&attr, 0, sizeof(attr));

	attr.type = PERF_TYPE_SOFTWARE;
	attr.config = PERF_COUNT_SW_TASK_CLOCK;

force_again:
	fd = sys_perf_event_open(&attr, 0, -1, -1,
				 perf_event_open_cloexec_flag());

	if (fd < 0) {
		if (errno == EMFILE) {
			if (sched->force) {
				BUG_ON(getrlimit(RLIMIT_NOFILE, &limit) == -1);
				limit.rlim_cur += sched->nr_tasks - cur_task;
				if (limit.rlim_cur > limit.rlim_max) {
					limit.rlim_max = limit.rlim_cur;
					need_privilege = true;
				}
				if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
					if (need_privilege && errno == EPERM)
						strcpy(info, "Need privilege\n");
				} else
					goto force_again;
			} else
				strcpy(info, "Have a try with -f option\n");
		}
		pr_err("Error: sys_perf_event_open() syscall returned "
		       "with %d (%s)\n%s", fd,
		       strerror_r(errno, sbuf, sizeof(sbuf)), info);
		exit(EXIT_FAILURE);
	}
	return fd;
}

Contributors
Person Tokens Prop Commits CommitProp
yunlong song yunlong song 140 60.34% 2 28.57%
arnaldo carvalho de melo arnaldo carvalho de melo 60 25.86% 1 14.29%
masami hiramatsu masami hiramatsu 14 6.03% 1 14.29%
ingo molnar ingo molnar 14 6.03% 1 14.29%
yann droneaud yann droneaud 2 0.86% 1 14.29%
namhyung kim namhyung kim 2 0.86% 1 14.29%
Total 232 100.00% 7 100.00%



static u64 get_cpu_usage_nsec_self(int fd)
{
	u64 runtime;
	int ret;

	ret = read(fd, &runtime, sizeof(runtime));
	BUG_ON(ret != sizeof(runtime));

	return runtime;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 42 97.67% 1 50.00%
ingo molnar ingo molnar 1 2.33% 1 50.00%
Total 43 100.00% 2 100.00%


struct sched_thread_parms {
	
struct task_desc  *task;
	
struct perf_sched *sched;
	
int fd;
};



static void *thread_func(void *ctx)
{
	struct sched_thread_parms *parms = ctx;
	struct task_desc *this_task = parms->task;
	struct perf_sched *sched = parms->sched;
	u64 cpu_usage_0, cpu_usage_1;
	unsigned long i, ret;
	char comm2[22];
	int fd = parms->fd;

	zfree(&parms);

	sprintf(comm2, ":%s", this_task->comm);
	prctl(PR_SET_NAME, comm2);
	if (fd < 0)
		return NULL;
again:
	ret = sem_post(&this_task->ready_for_work);
	BUG_ON(ret);
	ret = pthread_mutex_lock(&sched->start_work_mutex);
	BUG_ON(ret);
	ret = pthread_mutex_unlock(&sched->start_work_mutex);
	BUG_ON(ret);

	cpu_usage_0 = get_cpu_usage_nsec_self(fd);

	for (i = 0; i < this_task->nr_events; i++) {
		this_task->curr_event = i;
		perf_sched__process_event(sched, this_task->atoms[i]);
	}

	cpu_usage_1 = get_cpu_usage_nsec_self(fd);
	this_task->cpu_usage = cpu_usage_1 - cpu_usage_0;
	ret = sem_post(&this_task->work_done_sem);
	BUG_ON(ret);

	ret = pthread_mutex_lock(&sched->work_done_wait_mutex);
	BUG_ON(ret);
	ret = pthread_mutex_unlock(&sched->work_done_wait_mutex);
	BUG_ON(ret);

	goto again;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 177 72.24% 2 50.00%
ingo molnar ingo molnar 64 26.12% 1 25.00%
yunlong song yunlong song 4 1.63% 1 25.00%
Total 245 100.00% 4 100.00%



static void create_tasks(struct perf_sched *sched)
{
	struct task_desc *task;
	pthread_attr_t attr;
	unsigned long i;
	int err;

	err = pthread_attr_init(&attr);
	BUG_ON(err);
	err = pthread_attr_setstacksize(&attr,
			(size_t) max(16 * 1024, PTHREAD_STACK_MIN));
	BUG_ON(err);
	err = pthread_mutex_lock(&sched->start_work_mutex);
	BUG_ON(err);
	err = pthread_mutex_lock(&sched->work_done_wait_mutex);
	BUG_ON(err);
	for (i = 0; i < sched->nr_tasks; i++) {
		struct sched_thread_parms *parms = malloc(sizeof(*parms));
		BUG_ON(parms == NULL);
		parms->task = task = sched->tasks[i];
		parms->sched = sched;
		parms->fd = self_open_counters(sched, i);
		sem_init(&task->sleep_sem, 0, 0);
		sem_init(&task->ready_for_work, 0, 0);
		sem_init(&task->work_done_sem, 0, 0);
		task->curr_event = 0;
		err = pthread_create(&task->thread, &attr, thread_func, parms);
		BUG_ON(err);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 187 82.74% 1 25.00%
ingo molnar ingo molnar 28 12.39% 1 25.00%
yunlong song yunlong song 11 4.87% 2 50.00%
Total 226 100.00% 4 100.00%



static void wait_for_tasks(struct perf_sched *sched)
{
	u64 cpu_usage_0, cpu_usage_1;
	struct task_desc *task;
	unsigned long i, ret;

	sched->start_time = get_nsecs();
	sched->cpu_usage = 0;
	pthread_mutex_unlock(&sched->work_done_wait_mutex);

	for (i = 0; i < sched->nr_tasks; i++) {
		task = sched->tasks[i];
		ret = sem_wait(&task->ready_for_work);
		BUG_ON(ret);
		sem_init(&task->ready_for_work, 0, 0);
	}
	ret = pthread_mutex_lock(&sched->work_done_wait_mutex);
	BUG_ON(ret);

	cpu_usage_0 = get_cpu_usage_nsec_parent();

	pthread_mutex_unlock(&sched->start_work_mutex);

	for (i = 0; i < sched->nr_tasks; i++) {
		task = sched->tasks[i];
		ret = sem_wait(&task->work_done_sem);
		BUG_ON(ret);
		sem_init(&task->work_done_sem, 0, 0);
		sched->cpu_usage += task->cpu_usage;
		task->cpu_usage = 0;
	}

	cpu_usage_1 = get_cpu_usage_nsec_parent();
	if (!sched->runavg_cpu_usage)
		sched->runavg_cpu_usage = sched->cpu_usage;
	sched->runavg_cpu_usage = (sched->runavg_cpu_usage * (sched->replay_repeat - 1) + sched->cpu_usage) / sched->replay_repeat;

	sched->parent_cpu_usage = cpu_usage_1 - cpu_usage_0;
	if (!sched->runavg_parent_cpu_usage)
		sched->runavg_parent_cpu_usage = sched->parent_cpu_usage;
	sched->runavg_parent_cpu_usage = (sched->runavg_parent_cpu_usage * (sched->replay_repeat - 1) +
					 sched->parent_cpu_usage)/sched->replay_repeat;

	ret = pthread_mutex_lock(&sched->start_work_mutex);
	BUG_ON(ret);

	for (i = 0; i < sched->nr_tasks; i++) {
		task = sched->tasks[i];
		sem_init(&task->sleep_sem, 0, 0);
		task->curr_event = 0;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 313 89.43% 1 14.29%
yunlong song yunlong song 20 5.71% 1 14.29%
frederic weisbecker frederic weisbecker 7 2.00% 2 28.57%
ingo molnar ingo molnar 7 2.00% 2 28.57%
mike galbraith mike galbraith 3 0.86% 1 14.29%
Total 350 100.00% 7 100.00%



static void run_one_test(struct perf_sched *sched)
{
	u64 T0, T1, delta, avg_delta, fluct;

	T0 = get_nsecs();
	wait_for_tasks(sched);
	T1 = get_nsecs();

	delta = T1 - T0;
	sched->sum_runtime += delta;
	sched->nr_runs++;

	avg_delta = sched->sum_runtime / sched->nr_runs;
	if (delta < avg_delta)
		fluct = avg_delta - delta;
	else
		fluct = delta - avg_delta;
	sched->sum_fluct += fluct;
	if (!sched->run_avg)
		sched->run_avg = delta;
	sched->run_avg = (sched->run_avg * (sched->replay_repeat - 1) + delta) / sched->replay_repeat;

	printf("#%-3ld: %0.3f, ", sched->nr_runs, (double)delta / 1000000.0);

	printf("ravg: %0.2f, ", (double)sched->run_avg / 1e6);

	printf("cpu: %0.2f / %0.2f",
		(double)sched->cpu_usage / 1e6, (double)sched->runavg_cpu_usage / 1e6);

#if 0
	/*
         * rusage statistics done by the parent, these are less
         * accurate than the sched->sum_exec_runtime based statistics:
         */
	printf(" [%0.2f / %0.2f]",
                (double)sched->parent_cpu_usage/1e6,
                (double)sched->runavg_parent_cpu_usage/1e6);
#endif

	printf("\n");

	if (sched->nr_sleep_corrections)
		printf(" (%ld sleep corrections)\n", sched->nr_sleep_corrections);
	sched->nr_sleep_corrections = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 201 94.81% 1 33.33%
yunlong song yunlong song 10 4.72% 1 33.33%
mike galbraith mike galbraith 1 0.47% 1 33.33%
Total 212 100.00% 3 100.00%



static void test_calibrations(struct perf_sched *sched)
{
	u64 T0, T1;

	T0 = get_nsecs();
	burn_nsecs(sched, 1e6);
	T1 = get_nsecs();

	printf("the run test took %" PRIu64 " nsecs\n", T1 - T0);

	T0 = get_nsecs();
	sleep_nsecs(1e6);
	T1 = get_nsecs();

	printf("the sleep test took %" PRIu64 " nsecs\n", T1 - T0);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 68 97.14% 1 50.00%
mike galbraith mike galbraith 2 2.86% 1 50.00%
Total 70 100.00% 2 100.00%


static int

replay_wakeup_event(struct perf_sched *sched,
		    struct perf_evsel *evsel, struct perf_sample *sample,
		    struct machine *machine __maybe_unused)
{
	const char *comm = perf_evsel__strval(evsel, sample, "comm");
	const u32 pid	 = perf_evsel__intval(evsel, sample, "pid");
	struct task_desc *waker, *wakee;

	if (verbose) {
		printf("sched_wakeup event %p\n", evsel);

		printf(" ... pid %d woke up %s/%d\n", sample->tid, comm, pid);
	}

	waker = register_pid(sched, sample->tid, "<unknown>");
	wakee = register_pid(sched, pid, comm);

	add_sched_event_wakeup(sched, waker, sample->time, wakee);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 60 46.88% 5 55.56%
frederic weisbecker frederic weisbecker 51 39.84% 2 22.22%
ingo molnar ingo molnar 17 13.28% 2 22.22%
Total 128 100.00% 9 100.00%



static int replay_switch_event(struct perf_sched *sched,
			       struct perf_evsel *evsel,
			       struct perf_sample *sample,
			       struct machine *machine __maybe_unused)
{
	const char *prev_comm  = perf_evsel__strval(evsel, sample, "prev_comm"),
		   *next_comm  = perf_evsel__strval(evsel, sample, "next_comm");
	const u32 prev_pid = perf_evsel__intval(evsel, sample, "prev_pid"),
		  next_pid = perf_evsel__intval(evsel, sample, "next_pid");
	const u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
	struct task_desc *prev, __maybe_unused *next;
	u64 timestamp0, timestamp = sample->time;
	int cpu = sample->cpu;
	s64 delta;

	if (verbose)
		printf("sched_switch event %p\n", evsel);

	if (cpu >= MAX_CPUS || cpu < 0)
		return 0;

	timestamp0 = sched->cpu_last_switched[cpu];
	if (timestamp0)
		delta = timestamp - timestamp0;
	else
		delta = 0;

	if (delta < 0) {
		pr_err("hm, delta: %" PRIu64 " < 0 ?\n", delta);
		return -1;
	}

	pr_debug(" ... switch from %s/%d to %s/%d [ran %" PRIu64 " nsecs]\n",
		 prev_comm, prev_pid, next_comm, next_pid, delta);

	prev = register_pid(sched, prev_pid, prev_comm);
	next = register_pid(sched, next_pid, next_comm);

	sched->cpu_last_switched[cpu] = timestamp;

	add_sched_event_run(sched, prev, timestamp, delta);
	add_sched_event_sleep(sched, prev, timestamp, prev_state);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 133 51.15% 6 60.00%
frederic weisbecker frederic weisbecker 125 48.08% 2 20.00%
irina tirdea irina tirdea 1 0.38% 1 10.00%
namhyung kim namhyung kim 1 0.38% 1 10.00%
Total 260 100.00% 10 100.00%



static int replay_fork_event(struct perf_sched *sched,
			     union perf_event *event,
			     struct machine *machine)
{
	struct thread *child, *parent;

	child = machine__findnew_thread(machine, event->fork.pid,
					event->fork.tid);
	parent = machine__findnew_thread(machine, event->fork.ppid,
					 event->fork.ptid);

	if (child == NULL || parent == NULL) {
		pr_debug("thread does not exist on fork event: child %p, parent %p\n",
				 child, parent);
		goto out_put;
	}

	if (verbose) {
		printf("fork event\n");
		printf("... parent: %s/%d\n", thread__comm_str(parent), parent->tid);
		printf("...  child: %s/%d\n", thread__comm_str(child), child->tid);
	}

	register_pid(sched, parent->tid, thread__comm_str(parent));
	register_pid(sched, child->tid, thread__comm_str(child));
out_put:
	thread__put(child);
	thread__put(parent);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
david ahern david ahern 64 36.99% 1 9.09%
arnaldo carvalho de melo arnaldo carvalho de melo 40 23.12% 4 36.36%
frederic weisbecker frederic weisbecker 30 17.34% 2 18.18%
ingo molnar ingo molnar 27 15.61% 3 27.27%
adrian hunter adrian hunter 12 6.94% 1 9.09%
Total 173 100.00% 11 100.00%


struct sort_dimension {
	
const char		*name;
	
sort_fn_t		cmp;
	
struct list_head	list;
};


static int

thread_lat_cmp(struct list_head *list, struct work_atoms *l, struct work_atoms *r)
{
	struct sort_dimension *sort;
	int ret = 0;

	BUG_ON(list_empty(list));

	list_for_each_entry(sort, list, list) {
		ret = sort->cmp(l, r);
		if (ret)
			return ret;
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 60 85.71% 2 50.00%
ingo molnar ingo molnar 10 14.29% 2 50.00%
Total 70 100.00% 4 100.00%


static struct work_atoms *

thread_atoms_search(struct rb_root *root, struct thread *thread,
			 struct list_head *sort_list)
{
	struct rb_node *node = root->rb_node;
	struct work_atoms key = { .thread = thread };

	while (node) {
		struct work_atoms *atoms;
		int cmp;

		atoms = container_of(node, struct work_atoms, node);

		cmp = thread_lat_cmp(sort_list, &key, atoms);
		if (cmp > 0)
			node = node->rb_left;
		else if (cmp < 0)
			node = node->rb_right;
		else {
			BUG_ON(thread != atoms->thread);
			return atoms;
		}
	}
	return NULL;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 123 99.19% 2 66.67%
frederic weisbecker frederic weisbecker 1 0.81% 1 33.33%
Total 124 100.00% 3 100.00%


static void

__thread_latency_insert(struct rb_root *root, struct work_atoms *data,
			 struct list_head *sort_list)
{
	struct rb_node **new = &(root->rb_node), *parent = NULL;

	while (*new) {
		struct work_atoms *this;
		int cmp;

		this = container_of(*new, struct work_atoms, node);
		parent = *new;

		cmp = thread_lat_cmp(sort_list, data, this);

		if (cmp > 0)
			new = &((*new)->rb_left);
		else
			new = &((*new)->rb_right);
	}

	rb_link_node(&data->node, parent, new);
	rb_insert_color(&data->node, root);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 128 94.12% 3 50.00%
ingo molnar ingo molnar 8 5.88% 3 50.00%
Total 136 100.00% 6 100.00%



static int thread_atoms_insert(struct perf_sched *sched, struct thread *thread)
{
	struct work_atoms *atoms = zalloc(sizeof(*atoms));
	if (!atoms) {
		pr_err("No memory at %s\n", __func__);
		return -1;
	}

	atoms->thread = thread__get(thread);
	INIT_LIST_HEAD(&atoms->work_list);
	__thread_latency_insert(&sched->atom_root, atoms, &sched->cmp_pid);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 50 60.24% 3 33.33%
arnaldo carvalho de melo arnaldo carvalho de melo 29 34.94% 4 44.44%
ingo molnar ingo molnar 4 4.82% 2 22.22%
Total 83 100.00% 9 100.00%



static char sched_out_state(u64 prev_state)
{
	const char *str = TASK_STATE_TO_CHAR_STR;

	return str[prev_state];
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 20 90.91% 1 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 2 9.09% 1 50.00%
Total 22 100.00% 2 100.00%


static int

add_sched_out_event(struct work_atoms *atoms,
		    char run_state,
		    u64 timestamp)
{
	struct work_atom *atom = zalloc(sizeof(*atom));
	if (!atom) {
		pr_err("Non memory at %s", __func__);
		return -1;
	}

	atom->sched_out_time = timestamp;

	if (run_state == 'R') {
		atom->state = THREAD_WAIT_CPU;
		atom->wake_up_time = atom->sched_out_time;
	}

	list_add_tail(&atom->list, &atoms->work_list);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 61 65.59% 4 50.00%
arnaldo carvalho de melo arnaldo carvalho de melo 17 18.28% 2 25.00%
ingo molnar ingo molnar 15 16.13% 2 25.00%
Total 93 100.00% 8 100.00%


static void

add_runtime_event(struct work_atoms *atoms, u64 delta,
		  u64 timestamp __maybe_unused)
{
	struct work_atom *atom;

	BUG_ON(list_empty(&atoms->work_list));

	atom = list_entry(atoms->work_list.prev, struct work_atom, list);

	atom->runtime += delta;
	atoms->total_runtime += delta;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 58 93.55% 1 33.33%
frederic weisbecker frederic weisbecker 3 4.84% 1 33.33%
irina tirdea irina tirdea 1 1.61% 1 33.33%
Total 62 100.00% 3 100.00%


static void

add_sched_in_event(struct work_atoms *atoms, u64 timestamp)
{
	struct work_atom *atom;
	u64 delta;

	if (list_empty(&atoms->work_list))
		return;

	atom = list_entry(atoms->work_list.prev, struct work_atom, list);

	if (atom->state != THREAD_WAIT_CPU)
		return;

	if (timestamp < atom->wake_up_time) {
		atom->state = THREAD_IGNORE;
		return;
	}

	atom->state = THREAD_SCHED_IN;
	atom->sched_in_time = timestamp;

	delta = atom->sched_in_time - atom->wake_up_time;
	atoms->total_lat += delta;
	if (delta > atoms->max_lat) {
		atoms->max_lat = delta;
		atoms->max_lat_at = timestamp;
	}
	atoms->nb_atoms++;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 117 90.00% 5 71.43%
ingo molnar ingo molnar 13 10.00% 2 28.57%
Total 130 100.00% 7 100.00%



static int latency_switch_event(struct perf_sched *sched,
				struct perf_evsel *evsel,
				struct perf_sample *sample,
				struct machine *machine)
{
	const u32 prev_pid = perf_evsel__intval(evsel, sample, "prev_pid"),
		  next_pid = perf_evsel__intval(evsel, sample, "next_pid");
	const u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
	struct work_atoms *out_events, *in_events;
	struct thread *sched_out, *sched_in;
	u64 timestamp0, timestamp = sample->time;
	int cpu = sample->cpu, err = -1;
	s64 delta;

	BUG_ON(cpu >= MAX_CPUS || cpu < 0);

	timestamp0 = sched->cpu_last_switched[cpu];
	sched->cpu_last_switched[cpu] = timestamp;
	if (timestamp0)
		delta = timestamp - timestamp0;
	else
		delta = 0;

	if (delta < 0) {
		pr_err("hm, delta: %" PRIu64 " < 0 ?\n", delta);
		return -1;
	}

	sched_out = machine__findnew_thread(machine, -1, prev_pid);
	sched_in = machine__findnew_thread(machine, -1, next_pid);
	if (sched_out == NULL || sched_in == NULL)
		goto out_put;

	out_events = thread_atoms_search(&sched->atom_root, sched_out, &sched->cmp_pid);
	if (!out_events) {
		if (thread_atoms_insert(sched, sched_out))
			goto out_put;
		out_events = thread_atoms_search(&sched->atom_root, sched_out, &sched->cmp_pid);
		if (!out_events) {
			pr_err("out-event: Internal tree error");
			goto out_put;
		}
	}
	if (add_sched_out_event(out_events, sched_out_state(prev_state), timestamp))
		return -1;

	in_events = thread_atoms_search(&sched->atom_root, sched_in, &sched->cmp_pid);
	if (!in_events) {
		if (thread_atoms_insert(sched, sched_in))
			goto out_put;
		in_events = thread_atoms_search(&sched->atom_root, sched_in, &sched->cmp_pid);
		if (!in_events) {
			pr_err("in-event: Internal tree error");
			goto out_put;
		}
		/*
                 * Take came in we have not heard about yet,
                 * add in an initial atom in runnable state:
                 */
		if (add_sched_out_event(in_events, 'R', timestamp))
			goto out_put;
	}
	add_sched_in_event(in_events, timestamp);
	err = 0;
out_put:
	thread__put(sched_out);
	thread__put(sched_in);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 180 45.00% 9 56.25%
ingo molnar ingo molnar 150 37.50% 4 25.00%
frederic weisbecker frederic weisbecker 64 16.00% 1 6.25%
adrian hunter adrian hunter 6 1.50% 2 12.50%
Total 400 100.00% 16 100.00%



static int latency_runtime_event(struct perf_sched *sched,
				 struct perf_evsel *evsel,
				 struct perf_sample *sample,
				 struct machine *machine)
{
	const u32 pid	   = perf_evsel__intval(evsel, sample, "pid");
	const u64 runtime  = perf_evsel__intval(evsel, sample, "runtime");
	struct thread *thread = machine__findnew_thread(machine, -1, pid);
	struct work_atoms *atoms = thread_atoms_search(&sched->atom_root, thread, &sched->cmp_pid);
	u64 timestamp = sample->time;
	int cpu = sample->cpu, err = -1;

	if (thread == NULL)
		return -1;

	BUG_ON(cpu >= MAX_CPUS || cpu < 0);
	if (!atoms) {
		if (thread_atoms_insert(sched, thread))
			goto out_put;
		atoms = thread_atoms_search(&sched->atom_root, thread, &sched->cmp_pid);
		if (!atoms) {
			pr_err("in-event: Internal tree error");
			goto out_put;
		}
		if (add_sched_out_event(atoms, 'R', timestamp))
			goto out_put;
	}

	add_runtime_event(atoms, runtime, timestamp);
	err = 0;
out_put:
	thread__put(thread);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 131 60.93% 8 47.06%
ingo molnar ingo molnar 45 20.93% 4 23.53%
frederic weisbecker frederic weisbecker 35 16.28% 2 11.76%
adrian hunter adrian hunter 3 1.40% 2 11.76%
namhyung kim namhyung kim 1 0.47% 1 5.88%
Total 215 100.00% 17 100.00%



static int latency_wakeup_event(struct perf_sched *sched,
				struct perf_evsel *evsel,
				struct perf_sample *sample,
				struct machine *machine)
{
	const u32 pid	  = perf_evsel__intval(evsel, sample, "pid");
	struct work_atoms *atoms;
	struct work_atom *atom;
	struct thread *wakee;
	u64 timestamp = sample->time;
	int err = -1;

	wakee = machine__findnew_thread(machine, -1, pid);
	if (wakee == NULL)
		return -1;
	atoms = thread_atoms_search(&sched->atom_root, wakee, &sched->cmp_pid);
	if (!atoms) {
		if (thread_atoms_insert(sched, wakee))
			goto out_put;
		atoms = thread_atoms_search(&sched->atom_root, wakee, &sched->cmp_pid);
		if (!atoms) {
			pr_err("wakeup-event: Internal tree error");
			goto out_put;
		}
		if (add_sched_out_event(atoms, 'S', timestamp))
			goto out_put;
	}

	BUG_ON(list_empty(&atoms->work_list));

	atom = list_entry(atoms->work_list.prev, struct work_atom, list);

	/*
         * As we do not guarantee the wakeup event happens when
         * task is out of run queue, also may happen when task is
         * on run queue and wakeup only change ->state to TASK_RUNNING,
         * then we should not set the ->wake_up_time when wake up a
         * task which is on run queue.
         *
         * You WILL be missing events if you've recorded only
         * one CPU, or are only looking at only one, so don't
         * skip in this case.
         */
	if (sched->profile_cpu == -1 && atom->state != THREAD_SLEEPING)
		goto out_ok;

	sched->nr_timestamps++;
	if (atom->sched_out_time > timestamp) {
		sched->nr_unordered_timestamps++;
		goto out_ok;
	}

	atom->state = THREAD_WAIT_CPU;
	atom->wake_up_time = timestamp;
out_ok:
	err = 0;
out_put:
	thread__put(wakee);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 109 40.67% 8 34.78%
frederic weisbecker frederic weisbecker 94 35.07% 5 21.74%
ingo molnar ingo molnar 55 20.52% 5 21.74%
mike galbraith mike galbraith 5 1.87% 1 4.35%
adrian hunter adrian hunter 3 1.12% 2 8.70%
namhyung kim namhyung kim 1 0.37% 1 4.35%
dongsheng yang dongsheng yang 1 0.37% 1 4.35%
Total 268 100.00% 23 100.00%



static int latency_migrate_task_event(struct perf_sched *sched,
				      struct perf_evsel *evsel,
				      struct perf_sample *sample,
				      struct machine *machine)
{
	const u32 pid = perf_evsel__intval(evsel, sample, "pid");
	u64 timestamp = sample->time;
	struct work_atoms *atoms;
	struct work_atom *atom;
	struct thread *migrant;
	int err = -1;

	/*
         * Only need to worry about migration when profiling one CPU.
         */
	if (sched->profile_cpu == -1)
		return 0;

	migrant = machine__findnew_thread(machine, -1, pid);
	if (migrant == NULL)
		return -1;
	atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);
	if (!atoms) {
		if (thread_atoms_insert(sched, migrant))
			goto out_put;
		register_pid(sched, migrant->tid, thread__comm_str(migrant));
		atoms = thread_atoms_search(&sched->atom_root, migrant, &sched->cmp_pid);
		if (!atoms) {
			pr_err("migration-event: Internal tree error");
			goto out_put;
		}
		if (add_sched_out_event(atoms, 'R', timestamp))
			goto out_put;
	}

	BUG_ON(list_empty(&atoms->work_list));

	atom = list_entry(atoms->work_list.prev, struct work_atom, list);
	atom->sched_in_time = atom->sched_out_time = atom->wake_up_time = timestamp;

	sched->nr_timestamps++;

	if (atom->sched_out_time > timestamp)
		sched->nr_unordered_timestamps++;
	err = 0;
out_put:
	thread__put(migrant);
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
mike galbraith mike galbraith 157 57.93% 1 7.69%
arnaldo carvalho de melo arnaldo carvalho de melo 106 39.11% 7 53.85%
adrian hunter adrian hunter 4 1.48% 3 23.08%
frederic weisbecker frederic weisbecker 3 1.11% 1 7.69%
namhyung kim namhyung kim 1 0.37% 1 7.69%
Total 271 100.00% 13 100.00%



static void output_lat_thread(struct perf_sched *sched, struct work_atoms *work_list)
{
	int i;
	int ret;
	u64 avg;

	if (!work_list->nb_atoms)
		return;
	/*
         * Ignore idle threads:
         */
	if (!strcmp(thread__comm_str(work_list->thread), "swapper"))
		return;

	sched->all_runtime += work_list->total_runtime;
	sched->all_count   += work_list->nb_atoms;

	if (work_list->num_merged > 1)
		ret = printf("  %s:(%d) ", thread__comm_str(work_list->thread), work_list->num_merged);
	else
		ret = printf("  %s:%d ", thread__comm_str(work_list->thread), work_list->thread->tid);

	for (i = 0; i < 24 - ret; i++)
		printf(" ");

	avg = work_list->total_lat / work_list->nb_atoms;

	printf("|%11.3f ms |%9" PRIu64 " | avg:%9.3f ms | max:%9.3f ms | max at: %13.6f s\n",
	      (double)work_list->total_runtime / 1e6,
		 work_list->nb_atoms, (double)avg / 1e6,
		 (double)work_list->max_lat / 1e6,
		 (double)work_list->max_lat_at / 1e9);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 96 51.06% 5 29.41%
ingo molnar ingo molnar 52 27.66% 7 41.18%
josef bacik josef bacik 27 14.36% 1 5.88%
arnaldo carvalho de melo arnaldo carvalho de melo 11 5.85% 2 11.76%
adrian hunter adrian hunter 1 0.53% 1 5.88%
ramkumar ramachandra ramkumar ramachandra 1 0.53% 1 5.88%
Total 188 100.00% 17 100.00%



static int pid_cmp(struct work_atoms *l, struct work_atoms *r)
{
	if (l->thread == r->thread)
		return 0;
	if (l->thread->tid < r->thread->tid)
		return -1;
	if (l->thread->tid > r->thread->tid)
		return 1;
	return (int)(l->thread - r->thread);
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 47 60.26% 2 40.00%
jiri olsa jiri olsa 25 32.05% 1 20.00%
adrian hunter adrian hunter 4 5.13% 1 20.00%
ingo molnar ingo molnar 2 2.56% 1 20.00%
Total 78 100.00% 5 100.00%



static int avg_cmp(struct work_atoms *l, struct work_atoms *r)
{
	u64 avgl, avgr;

	if (!l->nb_atoms)
		return -1;

	if (!r->nb_atoms)
		return 1;

	avgl = l->total_lat / l->nb_atoms;
	avgr = r->total_lat / r->nb_atoms;

	if (avgl < avgr)
		return -1;
	if (avgl > avgr)
		return 1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 82 97.62% 1 50.00%
ingo molnar ingo molnar 2 2.38% 1 50.00%
Total 84 100.00% 2 100.00%



static int max_cmp(struct work_atoms *l, struct work_atoms *r)
{
	if (l->max_lat < r->max_lat)
		return -1;
	if (l->max_lat > r->max_lat)
		return 1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 44 95.65% 1 50.00%
ingo molnar ingo molnar 2 4.35% 1 50.00%
Total 46 100.00% 2 100.00%



static int switch_cmp(struct work_atoms *l, struct work_atoms *r)
{
	if (l->nb_atoms < r->nb_atoms)
		return -1;
	if (l->nb_atoms > r->nb_atoms)
		return 1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 44 95.65% 1 50.00%
ingo molnar ingo molnar 2 4.35% 1 50.00%
Total 46 100.00% 2 100.00%



static int runtime_cmp(struct work_atoms *l, struct work_atoms *r)
{
	if (l->total_runtime < r->total_runtime)
		return -1;
	if (l->total_runtime > r->total_runtime)
		return 1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 44 95.65% 1 50.00%
ingo molnar ingo molnar 2 4.35% 1 50.00%
Total 46 100.00% 2 100.00%



static int sort_dimension__add(const char *tok, struct list_head *list)
{
	size_t i;
	static struct sort_dimension avg_sort_dimension = {
		.name = "avg",
		.cmp  = avg_cmp,
        };
	static struct sort_dimension max_sort_dimension = {
		.name = "max",
		.cmp  = max_cmp,
        };
	static struct sort_dimension pid_sort_dimension = {
		.name = "pid",
		.cmp  = pid_cmp,
        };
	static struct sort_dimension runtime_sort_dimension = {
		.name = "runtime",
		.cmp  = runtime_cmp,
        };
	static struct sort_dimension switch_sort_dimension = {
		.name = "switch",
		.cmp  = switch_cmp,
        };
	struct sort_dimension *available_sorts[] = {
		&pid_sort_dimension,
		&avg_sort_dimension,
		&max_sort_dimension,
		&switch_sort_dimension,
		&runtime_sort_dimension,
        };

	for (i = 0; i < ARRAY_SIZE(available_sorts); i++) {
		if (!strcmp(available_sorts[i]->name, tok)) {
			list_add_tail(&available_sorts[i]->list, list);

			return 0;
		}
	}

	return -1;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 103 56.59% 1 50.00%
frederic weisbecker frederic weisbecker 79 43.41% 1 50.00%
Total 182 100.00% 2 100.00%



static void perf_sched__sort_lat(struct perf_sched *sched)
{
	struct rb_node *node;
	struct rb_root *root = &sched->atom_root;
again:
	for (;;) {
		struct work_atoms *data;
		node = rb_first(root);
		if (!node)
			break;

		rb_erase(node, root);
		data = rb_entry(node, struct work_atoms, node);
		__thread_latency_insert(&sched->sorted_atom_root, data, &sched->sort_list);
	}
	if (root == &sched->atom_root) {
		root = &sched->merged_atom_root;
		goto again;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
frederic weisbecker frederic weisbecker 61 56.48% 1 20.00%
josef bacik josef bacik 35 32.41% 1 20.00%
arnaldo carvalho de melo arnaldo carvalho de melo 9 8.33% 1 20.00%
ingo molnar ingo molnar 3 2.78% 2 40.00%
Total 108 100.00% 5 100.00%



static int process_sched_wakeup_event(struct perf_tool *tool,
				      struct perf_evsel *evsel,
				      struct perf_sample *sample,
				      struct machine *machine)
{
	struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

	if (sched->tp_handler->wakeup_event)
		return sched->tp_handler->wakeup_event(sched, evsel, sample, machine);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 53 77.94% 6 60.00%
ingo molnar ingo molnar 11 16.18% 3 30.00%
frederic weisbecker frederic weisbecker 4 5.88% 1 10.00%
Total 68 100.00% 10 100.00%


union map_priv {
	
void	*ptr;
	
bool	 color;
};



static bool thread__has_color(struct thread *thread)
{
	union map_priv priv = {
		.ptr = thread__priv(thread),
        };

	return priv.color;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%


static struct thread*

map__findnew_thread(struct perf_sched *sched, struct machine *machine, pid_t pid, pid_t tid)
{
	struct thread *thread = machine__findnew_thread(machine, pid, tid);
	union map_priv priv = {
		.color = false,
        };

	if (!sched->map.color_pids || !thread || thread__priv(thread))
		return thread;

	if (thread_map__has(sched->map.color_pids, tid))
		priv.color = true;

	thread__set_priv(thread, priv.ptr);
	return thread;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 100 100.00% 1 100.00%
Total 100 100.00% 1 100.00%



static int map_switch_event(struct perf_sched *sched, struct perf_evsel *evsel,
			    struct perf_sample *sample, struct machine *machine)
{
	const u32 next_pid = perf_evsel__intval(evsel, sample, "next_pid");
	struct thread *sched_in;
	int new_shortname;
	u64 timestamp0, timestamp = sample->time;
	s64 delta;
	int i, this_cpu = sample->cpu;
	int cpus_nr;
	bool new_cpu = false;
	const char *color = PERF_COLOR_NORMAL;

	BUG_ON(this_cpu >= MAX_CPUS || this_cpu < 0);

	if (this_cpu > sched->max_cpu)
		sched->max_cpu = this_cpu;

	if (sched->map.comp) {
		cpus_nr = bitmap_weight(sched->map.comp_cpus_mask, MAX_CPUS);
		if (!test_and_set_bit(this_cpu, sched->map.comp_cpus_mask)) {
			sched->map.comp_cpus[cpus_nr++] = this_cpu;
			new_cpu = true;
		}
	} else
		cpus_nr = sched->max_cpu;

	timestamp0 = sched->cpu_last_switched[this_cpu];
	sched->cpu_last_switched[this_cpu] = timestamp;
	if (timestamp0)
		delta = timestamp - timestamp0;
	else
		delta = 0;

	if (delta < 0) {
		pr_err("hm, delta: %" PRIu64 " < 0 ?\n", delta);
		return -1;
	}

	sched_in = map__findnew_thread(sched, machine, -1, next_pid);
	if (sched_in == NULL)
		return -1;

	sched->curr_thread[this_cpu] = thread__get(sched_in);

	printf("  ");

	new_shortname = 0;
	if (!sched_in->shortname[0]) {
		if (!strcmp(thread__comm_str(sched_in), "swapper")) {
			/*
                         * Don't allocate a letter-number for swapper:0
                         * as a shortname. Instead, we use '.' for it.
                         */
			sched_in->shortname[0] = '.';
			sched_in->shortname[1] = ' ';
		} else {
			sched_in->shortname[0] = sched->next_shortname1;
			sched_in->shortname[1] = sched->next_shortname2;

			if (sched->next_shortname1 < 'Z') {
				sched->next_shortname1++;
			} else {
				sched->next_shortname1 = 'A';
				if (sched->next_shortname2 < '9')
					sched->next_shortname2++;
				else
					sched->next_shortname2 = '0';
			}
		}
		new_shortname = 1;
	}

	for (i = 0; i < cpus_nr; i++) {
		int cpu = sched->map.comp ? sched->map.comp_cpus[i] : i;
		struct thread *curr_thread = sched->curr_thread[cpu];
		const char *pid_color = color;
		const char *cpu_color = color;

		if (curr_thread && thread__has_color(curr_thread))
			pid_color = COLOR_PIDS;

		if (sched->map.cpus && !cpu_map__has(sched->map.cpus, cpu))
			continue;

		if (sched->map.color_cpus && cpu_map__has(sched->map.color_cpus, cpu))
			cpu_color = COLOR_CPUS;

		if (cpu != this_cpu)
			color_fprintf(stdout, cpu_color, " ");
		else
			color_fprintf(stdout, cpu_color, "*");

		if (sched->curr_thread[cpu])
			color_fprintf(stdout, pid_color, "%2s ", sched->curr_thread[cpu]->shortname);
		else
			color_fprintf(stdout, color, "   ");
	}

	if (sched->map.cpus && !cpu_map__has(sched->map.cpus, this_cpu))
		goto out;

	color_fprintf(stdout, color, "  %12.6f secs ", (double)timestamp/1e9);
	if (new_shortname) {
		const char *pid_color = color;

		if (thread__has_color(sched_in))
			pid_color = COLOR_PIDS;

		color_fprintf(stdout, pid_color, "%s => %s:%d",
		       sched_in->shortname, thread__comm_str(sched_in), sched_in->tid);
	}

	if (sched->map.comp && new_cpu)
		color_fprintf(stdout, color, " (CPU %d)", this_cpu);

out:
	color_fprintf(stdout, color, "\n");

	thread__put(sched_in);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 289 41.70% 5 22.73%
ingo molnar ingo molnar 224 32.32% 1 4.55%
arnaldo carvalho de melo arnaldo carvalho de melo 102 14.72% 9 40.91%
frederic weisbecker frederic weisbecker 37 5.34% 2 9.09%
dongsheng yang dongsheng yang 36 5.19% 1 4.55%
adrian hunter adrian hunter 4 0.58% 3 13.64%
namhyung kim namhyung kim 1 0.14% 1 4.55%
Total 693 100.00% 22 100.00%



static int process_sched_switch_event(struct perf_tool *tool,
				      struct perf_evsel *evsel,
				      struct perf_sample *sample,
				      struct machine *machine)
{
	struct perf_sched *sched = container_of(tool, struct perf_sched, tool);
	int this_cpu = sample->cpu, err = 0;
	u32 prev_pid = perf_evsel__intval(evsel, sample, "prev_pid"),
	    next_pid = perf_evsel__intval(evsel, sample, "next_pid");

	if (sched->curr_pid[this_cpu] != (u32)-1) {
		/*
                 * Are we trying to switch away a PID that is
                 * not current?
                 */
		if (sched->curr_pid[this_cpu] != prev_pid)
			sched->nr_context_switch_bugs++;
	}

	if (sched->tp_handler->switch_event)
		err = sched->tp_handler->switch_event(sched, evsel, sample, machine);

	sched->curr_pid[this_cpu] = next_pid;
	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 80 54.79% 6 50.00%
ingo molnar ingo molnar 50 34.25% 4 33.33%
frederic weisbecker frederic weisbecker 16 10.96% 2 16.67%
Total 146 100.00% 12 100.00%



static int process_sched_runtime_event(struct perf_tool *tool,
				       struct perf_evsel *evsel,
				       struct perf_sample *sample,
				       struct machine *machine)
{
	struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

	if (sched->tp_handler->runtime_event)
		return sched->tp_handler->runtime_event(sched, evsel, sample, machine);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 54 79.41% 6 75.00%
ingo molnar ingo molnar 14 20.59% 2 25.00%
Total 68 100.00% 8 100.00%



static int perf_sched__process_fork_event(struct perf_tool *tool,
					  union perf_event *event,
					  struct perf_sample *sample,
					  struct machine *machine)
{
	struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

	/* run the fork event through the perf machineruy */
	perf_event__process_fork(tool, event, sample, machine);

	/* and then run additional processing needed for this command */
	if (sched->tp_handler->fork_event)
		return sched->tp_handler->fork_event(sched, event, machine);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 46 58.23% 5 55.56%
david ahern david ahern 19 24.05% 1 11.11%
ingo molnar ingo molnar 13 16.46% 2 22.22%
frederic weisbecker frederic weisbecker 1 1.27% 1 11.11%
Total 79 100.00% 9 100.00%



static int process_sched_migrate_task_event(struct perf_tool *tool,
					    struct perf_evsel *evsel,
					    struct perf_sample *sample,
					    struct machine *machine)
{
	struct perf_sched *sched = container_of(tool, struct perf_sched, tool);

	if (sched->tp_handler->migrate_task_event)
		return sched->tp_handler->migrate_task_event(sched, evsel, sample, machine);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 54 79.41% 6 75.00%
mike galbraith mike galbraith 13 19.12% 1 12.50%
ingo molnar ingo molnar 1 1.47% 1 12.50%
Total 68 100.00% 8 100.00%


typedef int (*tracepoint_handler)(struct perf_tool *tool,
				  struct perf_evsel *evsel,
				  struct perf_sample *sample,
				  struct machine *machine);



static int perf_sched__process_tracepoint_sample(struct perf_tool *tool __maybe_unused,
						 union perf_event *event __maybe_unused,
						 struct perf_sample *sample,
						 struct perf_evsel *evsel,
						 struct machine *machine)
{
	int err = 0;

	if (evsel->handler != NULL) {
		tracepoint_handler f = evsel->handler;
		err = f(tool, evsel, sample, machine);
	}

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 60 84.51% 11 73.33%
ingo molnar ingo molnar 6 8.45% 2 13.33%
mike galbraith mike galbraith 3 4.23% 1 6.67%
irina tirdea irina tirdea 2 2.82% 1 6.67%
Total 71 100.00% 15 100.00%



static int perf_sched__read_events(struct perf_sched *sched)
{
	const struct perf_evsel_str_handler handlers[] = {
		{ "sched:sched_switch",	      process_sched_switch_event, },
		{ "sched:sched_stat_runtime", process_sched_runtime_event, },
		{ "sched:sched_wakeup",	      process_sched_wakeup_event, },
		{ "sched:sched_wakeup_new",   process_sched_wakeup_event, },
		{ "sched:sched_migrate_task", process_sched_migrate_task_event, },
        };
	struct perf_session *session;
	struct perf_data_file file = {
		.path = input_name,
		.mode = PERF_DATA_MODE_READ,
		.force = sched->force,
        };
	int rc = -1;

	session = perf_session__new(&file, false, &sched->tool);
	if (session == NULL) {
		pr_debug("No Memory for session\n");
		return -1;
	}

	symbol__init(&session->header.env);

	if (perf_session__set_tracepoints_handlers(session, handlers))
		goto out_delete;

	if (perf_session__has_traces(session, "record -R")) {
		int err = perf_session__process_events(session);
		if (err) {
			pr_err("Failed to process events, error %d", err);
			goto out_delete;
		}

		sched->nr_events      = session->evlist->stats.nr_events[0];
		sched->nr_lost_events = session->evlist->stats.total_lost;
		sched->nr_lost_chunks = session->evlist->stats.nr_events[PERF_RECORD_LOST];
	}

	rc = 0;
out_delete:
	perf_session__delete(session);
	return rc;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 168 73.68% 9 50.00%
jiri olsa jiri olsa 32 14.04% 2 11.11%
namhyung kim namhyung kim 10 4.39% 2 11.11%
yunlong song yunlong song 7 3.07% 1 5.56%
frederic weisbecker frederic weisbecker 4 1.75% 1 5.56%
ingo molnar ingo molnar 3 1.32% 1 5.56%
tom zanussi tom zanussi 2 0.88% 1 5.56%
ian munsie ian munsie 2 0.88% 1 5.56%
Total 228 100.00% 18 100.00%



static void print_bad_events(struct perf_sched *sched)
{
	if (sched->nr_unordered_timestamps && sched->nr_timestamps) {
		printf("  INFO: %.3f%% unordered timestamps (%ld out of %ld)\n",
			(double)sched->nr_unordered_timestamps/(double)sched->nr_timestamps*100.0,
			sched->nr_unordered_timestamps, sched->nr_timestamps);
	}
	if (sched->nr_lost_events && sched->nr_events) {
		printf("  INFO: %.3f%% lost events (%ld out of %ld, in %ld chunks)\n",
			(double)sched->nr_lost_events/(double)sched->nr_events * 100.0,
			sched->nr_lost_events, sched->nr_events, sched->nr_lost_chunks);
	}
	if (sched->nr_context_switch_bugs && sched->nr_timestamps) {
		printf("  INFO: %.3f%% context switch bugs (%ld out of %ld)",
			(double)sched->nr_context_switch_bugs/(double)sched->nr_timestamps*100.0,
			sched->nr_context_switch_bugs, sched->nr_timestamps);
		if (sched->nr_lost_events)
			printf(" (due to lost events?)");
		printf("\n");
	}
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 110 71.43% 2 66.67%
arnaldo carvalho de melo arnaldo carvalho de melo 44 28.57% 1 33.33%
Total 154 100.00% 3 100.00%



static void __merge_work_atoms(struct rb_root *root, struct work_atoms *data)
{
	struct rb_node **new = &(root->rb_node), *parent = NULL;
	struct work_atoms *this;
	const char *comm = thread__comm_str(data->thread), *this_comm;

	while (*new) {
		int cmp;

		this = container_of(*new, struct work_atoms, node);
		parent = *new;

		this_comm = thread__comm_str(this->thread);
		cmp = strcmp(comm, this_comm);
		if (cmp > 0) {
			new = &((*new)->rb_left);
		} else if (cmp < 0) {
			new = &((*new)->rb_right);
		} else {
			this->num_merged++;
			this->total_runtime += data->total_runtime;
			this->nb_atoms += data->nb_atoms;
			this->total_lat += data->total_lat;
			list_splice(&data->work_list, &this->work_list);
			if (this->max_lat < data->max_lat) {
				this->max_lat = data->max_lat;
				this->max_lat_at = data->max_lat_at;
			}
			zfree(&data);
			return;
		}
	}

	data->num_merged++;
	rb_link_node(&data->node, parent, new);
	rb_insert_color(&data->node, root);
}

Contributors
Person Tokens Prop Commits CommitProp
josef bacik josef bacik 248 100.00% 1 100.00%
Total 248 100.00% 1 100.00%



static void perf_sched__merge_lat(struct perf_sched *sched)
{
	struct work_atoms *data;
	struct rb_node *node;

	if (sched->skip_merge)
		return;

	while ((node = rb_first(&sched->atom_root))) {
		rb_erase(node, &sched->atom_root);
		data = rb_entry(node, struct work_atoms, node);
		__merge_work_atoms(&sched->merged_atom_root, data);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
josef bacik josef bacik 76 100.00% 1 100.00%
Total 76 100.00% 1 100.00%



static int perf_sched__lat(struct perf_sched *sched)
{
	struct rb_node *next;

	setup_pager();

	if (perf_sched__read_events(sched))
		return -1;

	perf_sched__merge_lat(sched);
	perf_sched__sort_lat(sched);

	printf("\n -----------------------------------------------------------------------------------------------------------------\n");
	printf("  Task                  |   Runtime ms  | Switches | Average delay ms | Maximum delay ms | Maximum delay at       |\n");
	printf(" -----------------------------------------------------------------------------------------------------------------\n");

	next = rb_first(&sched->sorted_atom_root);

	while (next) {
		struct work_atoms *work_list;

		work_list = rb_entry(next, struct work_atoms, node);
		output_lat_thread(sched, work_list);
		next = rb_next(next);
		thread__zput(work_list->thread);
	}

	printf(" -----------------------------------------------------------------------------------------------------------------\n");
	printf("  TOTAL:                |%11.3f ms |%9" PRIu64 " |\n",
		(double)sched->all_runtime / 1e6, sched->all_count);

	printf(" ---------------------------------------------------\n");

	print_bad_events(sched);
	printf("\n");

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 134 88.16% 3 42.86%
ingo molnar ingo molnar 9 5.92% 2 28.57%
josef bacik josef bacik 5 3.29% 1 14.29%
ramkumar ramachandra ramkumar ramachandra 4 2.63% 1 14.29%
Total 152 100.00% 7 100.00%



static int setup_map_cpus(struct perf_sched *sched)
{
	struct cpu_map *map;

	sched->max_cpu  = sysconf(_SC_NPROCESSORS_CONF);

	if (sched->map.comp) {
		sched->map.comp_cpus = zalloc(sched->max_cpu * sizeof(int));
		if (!sched->map.comp_cpus)
			return -1;
	}

	if (!sched->map.cpus_str)
		return 0;

	map = cpu_map__new(sched->map.cpus_str);
	if (!map) {
		pr_err("failed to get cpus map from %s\n", sched->map.cpus_str);
		return -1;
	}

	sched->map.cpus = map;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 104 85.25% 3 75.00%
arnaldo carvalho de melo arnaldo carvalho de melo 18 14.75% 1 25.00%
Total 122 100.00% 4 100.00%



static int setup_color_pids(struct perf_sched *sched)
{
	struct thread_map *map;

	if (!sched->map.color_pids_str)
		return 0;

	map = thread_map__new_by_tid_str(sched->map.color_pids_str);
	if (!map) {
		pr_err("failed to get thread map from %s\n", sched->map.color_pids_str);
		return -1;
	}

	sched->map.color_pids = map;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%



static int setup_color_cpus(struct perf_sched *sched)
{
	struct cpu_map *map;

	if (!sched->map.color_cpus_str)
		return 0;

	map = cpu_map__new(sched->map.color_cpus_str);
	if (!map) {
		pr_err("failed to get thread map from %s\n", sched->map.color_cpus_str);
		return -1;
	}

	sched->map.color_cpus = map;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 72 100.00% 1 100.00%
Total 72 100.00% 1 100.00%



static int perf_sched__map(struct perf_sched *sched)
{
	if (setup_map_cpus(sched))
		return -1;

	if (setup_color_pids(sched))
		return -1;

	if (setup_color_cpus(sched))
		return -1;

	setup_pager();
	if (perf_sched__read_events(sched))
		return -1;
	print_bad_events(sched);
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
jiri olsa jiri olsa 43 65.15% 3 75.00%
arnaldo carvalho de melo arnaldo carvalho de melo 23 34.85% 1 25.00%
Total 66 100.00% 4 100.00%



static int perf_sched__replay(struct perf_sched *sched)
{
	unsigned long i;

	calibrate_run_measurement_overhead(sched);
	calibrate_sleep_measurement_overhead(sched);

	test_calibrations(sched);

	if (perf_sched__read_events(sched))
		return -1;

	printf("nr_run_events:        %ld\n", sched->nr_run_events);
	printf("nr_sleep_events:      %ld\n", sched->nr_sleep_events);
	printf("nr_wakeup_events:     %ld\n", sched->nr_wakeup_events);

	if (sched->targetless_wakeups)
		printf("target-less wakeups:  %ld\n", sched->targetless_wakeups);
	if (sched->multitarget_wakeups)
		printf("multi-target wakeups: %ld\n", sched->multitarget_wakeups);
	if (sched->nr_run_events_optimized)
		printf("run atoms optimized: %ld\n",
			sched->nr_run_events_optimized);

	print_task_traces(sched);
	add_cross_task_wakeups(sched);

	create_tasks(sched);
	printf("------------------------------------------------------------\n");
	for (i = 0; i < sched->replay_repeat; i++)
		run_one_test(sched);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 111 71.15% 2 40.00%
ingo molnar ingo molnar 39 25.00% 2 40.00%
jiri olsa jiri olsa 6 3.85% 1 20.00%
Total 156 100.00% 5 100.00%



static void setup_sorting(struct perf_sched *sched, const struct option *options,
			  const char * const usage_msg[])
{
	char *tmp, *tok, *str = strdup(sched->sort_order);

	for (tok = strtok_r(str, ", ", &tmp);
			tok; tok = strtok_r(NULL, ", ", &tmp)) {
		if (sort_dimension__add(tok, &sched->sort_list) < 0) {
			usage_with_options_msg(usage_msg, options,
					"Unknown --sort key: `%s'", tok);
		}
	}

	free(str);

	sort_dimension__add("pid", &sched->cmp_pid);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 92 81.42% 1 16.67%
ingo molnar ingo molnar 13 11.50% 3 50.00%
namhyung kim namhyung kim 5 4.42% 1 16.67%
jiri olsa jiri olsa 3 2.65% 1 16.67%
Total 113 100.00% 6 100.00%



static int __cmd_record(int argc, const char **argv)
{
	unsigned int rec_argc, i, j;
	const char **rec_argv;
	const char * const record_args[] = {
		"record",
		"-a",
		"-R",
		"-m", "1024",
		"-c", "1",
		"-e", "sched:sched_switch",
		"-e", "sched:sched_stat_wait",
		"-e", "sched:sched_stat_sleep",
		"-e", "sched:sched_stat_iowait",
		"-e", "sched:sched_stat_runtime",
		"-e", "sched:sched_process_fork",
		"-e", "sched:sched_wakeup",
		"-e", "sched:sched_wakeup_new",
		"-e", "sched:sched_migrate_task",
        };

	rec_argc = ARRAY_SIZE(record_args) + argc - 1;
	rec_argv = calloc(rec_argc + 1, sizeof(char *));

	if (rec_argv == NULL)
		return -ENOMEM;

	for (i = 0; i < ARRAY_SIZE(record_args); i++)
		rec_argv[i] = strdup(record_args[i]);

	for (j = 1; j < (unsigned int)argc; j++, i++)
		rec_argv[i] = argv[j];

	BUG_ON(i != rec_argc);

	return cmd_record(i, rec_argv, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 161 80.50% 2 33.33%
ingo molnar ingo molnar 33 16.50% 2 33.33%
dongsheng yang dongsheng yang 4 2.00% 1 16.67%
jiri olsa jiri olsa 2 1.00% 1 16.67%
Total 200 100.00% 6 100.00%



int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
{
	const char default_sort_order[] = "avg, max, switch, runtime";
	struct perf_sched sched = {
		.tool = {
			.sample		 = perf_sched__process_tracepoint_sample,
			.comm		 = perf_event__process_comm,
			.lost		 = perf_event__process_lost,
			.fork		 = perf_sched__process_fork_event,
			.ordered_events = true,
                },
		.cmp_pid	      = LIST_HEAD_INIT(sched.cmp_pid),
		.sort_list	      = LIST_HEAD_INIT(sched.sort_list),
		.start_work_mutex     = PTHREAD_MUTEX_INITIALIZER,
		.work_done_wait_mutex = PTHREAD_MUTEX_INITIALIZER,
		.sort_order	      = default_sort_order,
		.replay_repeat	      = 10,
		.profile_cpu	      = -1,
		.next_shortname1      = 'A',
		.next_shortname2      = '0',
		.skip_merge           = 0,
        };
	const struct option latency_options[] = {
	OPT_STRING('s', "sort", &sched.sort_order, "key[,key2...]",
		   "sort by key(s): runtime, switch, avg, max"),
	OPT_INCR('v', "verbose", &verbose,
		    "be more verbose (show symbol address, etc)"),
	OPT_INTEGER('C', "CPU", &sched.profile_cpu,
		    "CPU to profile on"),
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
	OPT_BOOLEAN('p', "pids", &sched.skip_merge,
		    "latency stats per pid instead of per comm"),
	OPT_END()
	};
	const struct option replay_options[] = {
	OPT_UINTEGER('r', "repeat", &sched.replay_repeat,
		     "repeat the workload replay N times (-1: infinite)"),
	OPT_INCR('v', "verbose", &verbose,
		    "be more verbose (show symbol address, etc)"),
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
	OPT_BOOLEAN('f', "force", &sched.force, "don't complain, do it"),
	OPT_END()
	};
	const struct option sched_options[] = {
	OPT_STRING('i', "input", &input_name, "file",
		    "input file name"),
	OPT_INCR('v', "verbose", &verbose,
		    "be more verbose (show symbol address, etc)"),
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
	OPT_END()
	};
	const struct option map_options[] = {
	OPT_BOOLEAN(0, "compact", &sched.map.comp,
		    "map output in compact mode"),
	OPT_STRING(0, "color-pids", &sched.map.color_pids_str, "pids",
		   "highlight given pids in map"),
	OPT_STRING(0, "color-cpus", &sched.map.color_cpus_str, "cpus",
                    "highlight given CPUs in map"),
	OPT_STRING(0, "cpus", &sched.map.cpus_str, "cpus",
                    "display given CPUs in map"),
	OPT_END()
	};
	const char * const latency_usage[] = {
		"perf sched latency [<options>]",
		NULL
	};
	const char * const replay_usage[] = {
		"perf sched replay [<options>]",
		NULL
	};
	const char * const map_usage[] = {
		"perf sched map [<options>]",
		NULL
	};
	const char *const sched_subcommands[] = { "record", "latency", "map",
						  "replay", "script", NULL };
	const char *sched_usage[] = {
		NULL,
		NULL
	};
	struct trace_sched_handler lat_ops  = {
		.wakeup_event	    = latency_wakeup_event,
		.switch_event	    = latency_switch_event,
		.runtime_event	    = latency_runtime_event,
		.migrate_task_event = latency_migrate_task_event,
        };
	struct trace_sched_handler map_ops  = {
		.switch_event	    = map_switch_event,
        };
	struct trace_sched_handler replay_ops  = {
		.wakeup_event	    = replay_wakeup_event,
		.switch_event	    = replay_switch_event,
		.fork_event	    = replay_fork_event,
        };
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(sched.curr_pid); i++)
		sched.curr_pid[i] = -1;

	argc = parse_options_subcommand(argc, argv, sched_options, sched_subcommands,
					sched_usage, PARSE_OPT_STOP_AT_NON_OPTION);
	if (!argc)
		usage_with_options(sched_usage, sched_options);

	/*
         * Aliased to 'perf script' for now:
         */
	if (!strcmp(argv[0], "script"))
		return cmd_script(argc, argv, prefix);

	if (!strncmp(argv[0], "rec", 3)) {
		return __cmd_record(argc, argv);
	} else if (!strncmp(argv[0], "lat", 3)) {
		sched.tp_handler = &lat_ops;
		if (argc > 1) {
			argc = parse_options(argc, argv, latency_options, latency_usage, 0);
			if (argc)
				usage_with_options(latency_usage, latency_options);
		}
		setup_sorting(&sched, latency_options, latency_usage);
		return perf_sched__lat(&sched);
	} else if (!strcmp(argv[0], "map")) {
		if (argc) {
			argc = parse_options(argc, argv, map_options, map_usage, 0);
			if (argc)
				usage_with_options(map_usage, map_options);
		}
		sched.tp_handler = &map_ops;
		setup_sorting(&sched, latency_options, latency_usage);
		return perf_sched__map(&sched);
	} else if (!strncmp(argv[0], "rep", 3)) {
		sched.tp_handler = &replay_ops;
		if (argc) {
			argc = parse_options(argc, argv, replay_options, replay_usage, 0);
			if (argc)
				usage_with_options(replay_usage, replay_options);
		}
		return perf_sched__replay(&sched);
	} else {
		usage_with_options(sched_usage, sched_options);
	}

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 308 35.77% 2 7.41%
ingo molnar ingo molnar 256 29.73% 8 29.63%
jiri olsa jiri olsa 127 14.75% 5 18.52%
adrian hunter adrian hunter 53 6.16% 2 7.41%
frederic weisbecker frederic weisbecker 36 4.18% 3 11.11%
ramkumar ramachandra ramkumar ramachandra 24 2.79% 1 3.70%
xiao guangrong xiao guangrong 21 2.44% 1 3.70%
josef bacik josef bacik 19 2.21% 1 3.70%
yunlong song yunlong song 14 1.63% 1 3.70%
mike galbraith mike galbraith 1 0.12% 1 3.70%
ian munsie ian munsie 1 0.12% 1 3.70%
david ahern david ahern 1 0.12% 1 3.70%
Total 861 100.00% 27 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
arnaldo carvalho de melo arnaldo carvalho de melo 4696 44.80% 29 26.36%
ingo molnar ingo molnar 2075 19.79% 21 19.09%
frederic weisbecker frederic weisbecker 1450 13.83% 13 11.82%
jiri olsa jiri olsa 984 9.39% 9 8.18%
josef bacik josef bacik 418 3.99% 1 0.91%
yunlong song yunlong song 329 3.14% 9 8.18%
mike galbraith mike galbraith 187 1.78% 2 1.82%
adrian hunter adrian hunter 90 0.86% 5 4.55%
david ahern david ahern 90 0.86% 1 0.91%
dongsheng yang dongsheng yang 42 0.40% 4 3.64%
xiao guangrong xiao guangrong 39 0.37% 2 1.82%
ramkumar ramachandra ramkumar ramachandra 29 0.28% 2 1.82%
namhyung kim namhyung kim 22 0.21% 4 3.64%
masami hiramatsu masami hiramatsu 14 0.13% 1 0.91%
yann droneaud yann droneaud 5 0.05% 1 0.91%
irina tirdea irina tirdea 4 0.04% 1 0.91%
markus trippelsdorf markus trippelsdorf 3 0.03% 1 0.91%
ian munsie ian munsie 3 0.03% 2 1.82%
tom zanussi tom zanussi 2 0.02% 1 0.91%
josh poimboeuf josh poimboeuf 1 0.01% 1 0.91%
Total 10483 100.00% 110 100.00%
  Directory: tools/perf

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
arnaldo carvalho de melo	arnaldo carvalho de melo	24	77.42%	1	50.00%
ingo molnar	ingo molnar	7	22.58%	1	50.00%
	Total	31	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 tools/perf/builtin-sched.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
