jenna
/
kernel_samsung_sm7125
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

perf timechart: Move all_data per_pid list to 'struct timechart'

Browse Source 
Removing another global variable.

This one tho would be better done by using the machine infrastructure,
searching for the 'struct thread' with a pid, then using thread->priv,
etc.

TODO list material for now.

Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stanislav Fomichev <stfomichev@yandex-team.ru>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-yyfpudgjvr6mev4bue9u72a2@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
tirimbino
Arnaldo Carvalho de Melo 11 years ago
parent 985b12e633
commit 5e22f6d22b
1 changed files with 59 additions and 54 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 113
      tools/perf/builtin-timechart.c

113
tools/perf/builtin-timechart.c
Unescape View File

@ -41,8 +41,11 @@
#define SUPPORT_OLD_POWER_EVENTS 1
#define PWR_EVENT_EXIT -1
struct per_pid;
struct timechart {
struct perf_tool tool;
struct per_pid *all_data;
int proc_num;
unsigned int numcpus;
u64 min_freq, /* Lowest CPU frequency seen */
@ -123,8 +126,6 @@ struct cpu_sample {
const char *backtrace;
};
static struct per_pid *all_data;
#define CSTATE 1
#define PSTATE 2
@ -157,9 +158,9 @@ struct process_filter {
static struct process_filter *process_filter;
static struct per_pid *find_create_pid(int pid)
static struct per_pid *find_create_pid(struct timechart *tchart, int pid)
{
struct per_pid *cursor = all_data;
struct per_pid *cursor = tchart->all_data;
while (cursor) {
if (cursor->pid == pid)
@ -169,16 +170,16 @@ static struct per_pid *find_create_pid(int pid)
cursor = zalloc(sizeof(*cursor));
assert(cursor != NULL);
cursor->pid = pid;
cursor->next = all_data;
all_data = cursor;
cursor->next = tchart->all_data;
tchart->all_data = cursor;
return cursor;
}
static void pid_set_comm(int pid, char *comm)
static void pid_set_comm(struct timechart *tchart, int pid, char *comm)
{
struct per_pid *p;
struct per_pidcomm *c;
p = find_create_pid(pid);
p = find_create_pid(tchart, pid);
c = p->all;
while (c) {
if (c->comm && strcmp(c->comm, comm) == 0) {
@ -200,14 +201,14 @@ static void pid_set_comm(int pid, char *comm)
p->all = c;
}
static void pid_fork(int pid, int ppid, u64 timestamp)
static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
{
struct per_pid *p, *pp;
p = find_create_pid(pid);
pp = find_create_pid(ppid);
p = find_create_pid(tchart, pid);
pp = find_create_pid(tchart, ppid);
p->ppid = ppid;
if (pp->current && pp->current->comm && !p->current)
pid_set_comm(pid, pp->current->comm);
pid_set_comm(tchart, pid, pp->current->comm);
p->start_time = timestamp;
if (p->current) {
@ -216,24 +217,24 @@ static void pid_fork(int pid, int ppid, u64 timestamp)
}
}
static void pid_exit(int pid, u64 timestamp)
static void pid_exit(struct timechart *tchart, int pid, u64 timestamp)
{
struct per_pid *p;
p = find_create_pid(pid);
p = find_create_pid(tchart, pid);
p->end_time = timestamp;
if (p->current)
p->current->end_time = timestamp;
}
static void
pid_put_sample(int pid, int type, unsigned int cpu, u64 start, u64 end,
const char *backtrace)
static void pid_put_sample(struct timechart *tchart, int pid, int type,
unsigned int cpu, u64 start, u64 end,
const char *backtrace)
{
struct per_pid *p;
struct per_pidcomm *c;
struct cpu_sample *sample;
p = find_create_pid(pid);
p = find_create_pid(tchart, pid);
c = p->current;
if (!c) {
c = zalloc(sizeof(*c));
@ -271,30 +272,33 @@ static int cpus_cstate_state[MAX_CPUS];
static u64 cpus_pstate_start_times[MAX_CPUS];
static u64 cpus_pstate_state[MAX_CPUS];
static int process_comm_event(struct perf_tool *tool __maybe_unused,
static int process_comm_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
pid_set_comm(event->comm.tid, event->comm.comm);
struct timechart *tchart = container_of(tool, struct timechart, tool);
pid_set_comm(tchart, event->comm.tid, event->comm.comm);
return 0;
}
static int process_fork_event(struct perf_tool *tool __maybe_unused,
static int process_fork_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
pid_fork(event->fork.pid, event->fork.ppid, event->fork.time);
struct timechart *tchart = container_of(tool, struct timechart, tool);
pid_fork(tchart, event->fork.pid, event->fork.ppid, event->fork.time);
return 0;
}
static int process_exit_event(struct perf_tool *tool __maybe_unused,
static int process_exit_event(struct perf_tool *tool,
union perf_event *event,
struct perf_sample *sample __maybe_unused,
struct machine *machine __maybe_unused)
{
pid_exit(event->fork.pid, event->fork.time);
struct timechart *tchart = container_of(tool, struct timechart, tool);
pid_exit(tchart, event->fork.pid, event->fork.time);
return 0;
}
@ -361,8 +365,8 @@ static void p_state_change(struct timechart *tchart, int cpu, u64 timestamp, u64
tchart->turbo_frequency = tchart->max_freq;
}
static void sched_wakeup(int cpu, u64 timestamp, int waker, int wakee,
u8 flags, const char *backtrace)
static void sched_wakeup(struct timechart *tchart, int cpu, u64 timestamp,
int waker, int wakee, u8 flags, const char *backtrace)
{
struct per_pid *p;
struct wake_event *we = zalloc(sizeof(*we));
@ -380,36 +384,37 @@ static void sched_wakeup(int cpu, u64 timestamp, int waker, int wakee,
we->wakee = wakee;
we->next = wake_events;
wake_events = we;
p = find_create_pid(we->wakee);
p = find_create_pid(tchart, we->wakee);
if (p && p->current && p->current->state == TYPE_NONE) {
p->current->state_since = timestamp;
p->current->state = TYPE_WAITING;
}
if (p && p->current && p->current->state == TYPE_BLOCKED) {
pid_put_sample(p->pid, p->current->state, cpu,
pid_put_sample(tchart, p->pid, p->current->state, cpu,
p->current->state_since, timestamp, NULL);
p->current->state_since = timestamp;
p->current->state = TYPE_WAITING;
}
}
static void sched_switch(int cpu, u64 timestamp, int prev_pid, int next_pid,
u64 prev_state, const char *backtrace)
static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp,
int prev_pid, int next_pid, u64 prev_state,
const char *backtrace)
{
struct per_pid *p = NULL, *prev_p;
prev_p = find_create_pid(prev_pid);
prev_p = find_create_pid(tchart, prev_pid);
p = find_create_pid(next_pid);
p = find_create_pid(tchart, next_pid);
if (prev_p->current && prev_p->current->state != TYPE_NONE)
pid_put_sample(prev_pid, TYPE_RUNNING, cpu,
pid_put_sample(tchart, prev_pid, TYPE_RUNNING, cpu,
prev_p->current->state_since, timestamp,
backtrace);
if (p && p->current) {
if (p->current->state != TYPE_NONE)
pid_put_sample(next_pid, p->current->state, cpu,
pid_put_sample(tchart, next_pid, p->current->state, cpu,
p->current->state_since, timestamp,
backtrace);
@ -566,7 +571,7 @@ process_sample_cpu_frequency(struct timechart *tchart,
}
static int
process_sample_sched_wakeup(struct timechart *tchart __maybe_unused,
process_sample_sched_wakeup(struct timechart *tchart,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace)
@ -575,12 +580,12 @@ process_sample_sched_wakeup(struct timechart *tchart __maybe_unused,
int waker = perf_evsel__intval(evsel, sample, "common_pid");
int wakee = perf_evsel__intval(evsel, sample, "pid");
sched_wakeup(sample->cpu, sample->time, waker, wakee, flags, backtrace);
sched_wakeup(tchart, sample->cpu, sample->time, waker, wakee, flags, backtrace);
return 0;
}
static int
process_sample_sched_switch(struct timechart *tchart __maybe_unused,
process_sample_sched_switch(struct timechart *tchart,
struct perf_evsel *evsel,
struct perf_sample *sample,
const char *backtrace)
@ -589,8 +594,8 @@ process_sample_sched_switch(struct timechart *tchart __maybe_unused,
int next_pid = perf_evsel__intval(evsel, sample, "next_pid");
u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
sched_switch(sample->cpu, sample->time, prev_pid, next_pid, prev_state,
backtrace);
sched_switch(tchart, sample->cpu, sample->time, prev_pid, next_pid,
prev_state, backtrace);
return 0;
}
@ -681,16 +686,16 @@ static void end_sample_processing(struct timechart *tchart)
/*
* Sort the pid datastructure
*/
static void sort_pids(void)
static void sort_pids(struct timechart *tchart)
{
struct per_pid *new_list, *p, *cursor, *prev;
/* sort by ppid first, then by pid, lowest to highest */
new_list = NULL;
while (all_data) {
p = all_data;
all_data = p->next;
while (tchart->all_data) {
p = tchart->all_data;
tchart->all_data = p->next;
p->next = NULL;
if (new_list == NULL) {
@ -723,7 +728,7 @@ static void sort_pids(void)
prev->next = p;
}
}
all_data = new_list;
tchart->all_data = new_list;
}
@ -752,7 +757,7 @@ static void draw_c_p_states(struct timechart *tchart)
}
}
static void draw_wakeups(void)
static void draw_wakeups(struct timechart *tchart)
{
struct wake_event *we;
struct per_pid *p;
@ -764,7 +769,7 @@ static void draw_wakeups(void)
char *task_from = NULL, *task_to = NULL;
/* locate the column of the waker and wakee */
p = all_data;
p = tchart->all_data;
while (p) {
if (p->pid == we->waker || p->pid == we->wakee) {
c = p->all;
@ -820,12 +825,12 @@ static void draw_wakeups(void)
}
}
static void draw_cpu_usage(void)
static void draw_cpu_usage(struct timechart *tchart)
{
struct per_pid *p;
struct per_pidcomm *c;
struct cpu_sample *sample;
p = all_data;
p = tchart->all_data;
while (p) {
c = p->all;
while (c) {
@ -851,7 +856,7 @@ static void draw_process_bars(struct timechart *tchart)
Y = 2 * tchart->numcpus + 2;
p = all_data;
p = tchart->all_data;
while (p) {
c = p->all;
while (c) {
@ -937,7 +942,7 @@ static int determine_display_tasks_filtered(struct timechart *tchart)
struct per_pidcomm *c;
int count = 0;
p = all_data;
p = tchart->all_data;
while (p) {
p->display = 0;
if (p->start_time == 1)
@ -980,7 +985,7 @@ static int determine_display_tasks(struct timechart *tchart, u64 threshold)
if (process_filter)
return determine_display_tasks_filtered(tchart);
p = all_data;
p = tchart->all_data;
while (p) {
p->display = 0;
if (p->start_time == 1)
@ -1045,13 +1050,13 @@ static void write_svg_file(struct timechart *tchart, const char *filename)
for (i = 0; i < tchart->numcpus; i++)
svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
draw_cpu_usage();
draw_cpu_usage(tchart);
if (tchart->proc_num)
draw_process_bars(tchart);
if (!tchart->tasks_only)
draw_c_p_states(tchart);
if (tchart->proc_num)
draw_wakeups();
draw_wakeups(tchart);
svg_close();
}
@ -1096,7 +1101,7 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
end_sample_processing(tchart);
sort_pids();
sort_pids(tchart);
write_svg_file(tchart, output_name);

Write Preview
Loading…
Cancel
Save