adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 11:46:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

perf sched: Rename struct lat_snapshot to struct work atoms

Browse source 
To measures the latencies, we capture the sched atoms data into
a specific structure named struct lat_snapshot.

As this structure can be used for other purposes of scheduler
profiling and mirrors what happens in a thread work atom, lets
rename it to struct work_atom and propagate this renaming in
other functions and structures names to keep it coherent.

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Frederic Weisbecker 2009-09-12 23:11:32 +02:00 committed by Ingo Molnar
parent 3e304147cd
commit 1756220530
1 changed files with 56 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

112
tools/perf/builtin-sched.c
View file

@ -872,7 +872,7 @@ enum thread_state {
THREAD_IGNORE THREAD_IGNORE
}; };
struct lat_snapshot { struct work_atom {
struct list_head list; struct list_head list;
enum thread_state state; enum thread_state state;
u64 wake_up_time; u64 wake_up_time;
@ -880,7 +880,7 @@ struct lat_snapshot {
u64 runtime; u64 runtime;
}; };
struct thread_latency { struct task_atoms {
struct list_head snapshot_list; struct list_head snapshot_list;
struct thread *thread; struct thread *thread;
struct rb_node node; struct rb_node node;
@ -888,35 +888,35 @@ struct thread_latency {
static struct rb_root lat_snapshot_root; static struct rb_root lat_snapshot_root;
static struct thread_latency * static struct task_atoms *
thread_latency_search(struct rb_root *root, struct thread *thread) thread_atom_list_search(struct rb_root *root, struct thread *thread)
{ {
struct rb_node *node = root->rb_node; struct rb_node *node = root->rb_node;
while (node) { while (node) {
struct thread_latency *lat; struct task_atoms *atoms;
lat = container_of(node, struct thread_latency, node); atoms = container_of(node, struct task_atoms, node);
if (thread->pid < lat->thread->pid) if (thread->pid < atoms->thread->pid)
node = node->rb_left; node = node->rb_left;
else if (thread->pid > lat->thread->pid) else if (thread->pid > atoms->thread->pid)
node = node->rb_right; node = node->rb_right;
else { else {
return lat; return atoms;
} }
} }
return NULL; return NULL;
} }
static void static void
__thread_latency_insert(struct rb_root *root, struct thread_latency *data) __thread_latency_insert(struct rb_root *root, struct task_atoms *data)
{ {
struct rb_node **new = &(root->rb_node), *parent = NULL; struct rb_node **new = &(root->rb_node), *parent = NULL;
while (*new) { while (*new) {
struct thread_latency *this; struct task_atoms *this;
this = container_of(*new, struct thread_latency, node); this = container_of(*new, struct task_atoms, node);
parent = *new; parent = *new;
if (data->thread->pid < this->thread->pid) if (data->thread->pid < this->thread->pid)
new = &((*new)->rb_left); new = &((*new)->rb_left);
@ -930,16 +930,16 @@ __thread_latency_insert(struct rb_root *root, struct thread_latency *data)
rb_insert_color(&data->node, root); rb_insert_color(&data->node, root);
} }
static void thread_latency_insert(struct thread *thread) static void thread_atom_list_insert(struct thread *thread)
{ {
struct thread_latency *lat; struct task_atoms *atoms;
lat = calloc(sizeof(*lat), 1); atoms = calloc(sizeof(*atoms), 1);
if (!lat) if (!atoms)
die("No memory"); die("No memory");
lat->thread = thread; atoms->thread = thread;
INIT_LIST_HEAD(&lat->snapshot_list); INIT_LIST_HEAD(&atoms->snapshot_list);
__thread_latency_insert(&lat_snapshot_root, lat); __thread_latency_insert(&lat_snapshot_root, atoms);
} }
static void static void
@ -961,28 +961,28 @@ static char sched_out_state(struct trace_switch_event *switch_event)
} }
static void static void
lat_sched_out(struct thread_latency *lat, lat_sched_out(struct task_atoms *atoms,
struct trace_switch_event *switch_event __used, u64 delta) struct trace_switch_event *switch_event __used, u64 delta)
{ {
struct lat_snapshot *snapshot; struct work_atom *snapshot;
snapshot = calloc(sizeof(*snapshot), 1); snapshot = calloc(sizeof(*snapshot), 1);
if (!snapshot) if (!snapshot)
die("Non memory"); die("Non memory");
snapshot->runtime = delta; snapshot->runtime = delta;
list_add_tail(&snapshot->list, &lat->snapshot_list); list_add_tail(&snapshot->list, &atoms->snapshot_list);
} }
static void static void
lat_sched_in(struct thread_latency *lat, u64 timestamp) lat_sched_in(struct task_atoms *atoms, u64 timestamp)
{ {
struct lat_snapshot *snapshot; struct work_atom *snapshot;
if (list_empty(&lat->snapshot_list)) if (list_empty(&atoms->snapshot_list))
return; return;
snapshot = list_entry(lat->snapshot_list.prev, struct lat_snapshot, snapshot = list_entry(atoms->snapshot_list.prev, struct work_atom,
list); list);
if (snapshot->state != THREAD_WAKED_UP) if (snapshot->state != THREAD_WAKED_UP)
@ -1004,7 +1004,7 @@ latency_switch_event(struct trace_switch_event *switch_event,
u64 timestamp, u64 timestamp,
struct thread *thread __used) struct thread *thread __used)
{ {
struct thread_latency *out_lat, *in_lat; struct task_atoms *out_atoms, *in_atoms;
struct thread *sched_out, *sched_in; struct thread *sched_out, *sched_in;
u64 timestamp0; u64 timestamp0;
s64 delta; s64 delta;
@ -1026,24 +1026,24 @@ latency_switch_event(struct trace_switch_event *switch_event,
sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match); sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match);
sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match); sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match);
in_lat = thread_latency_search(&lat_snapshot_root, sched_in); in_atoms = thread_atom_list_search(&lat_snapshot_root, sched_in);
if (!in_lat) { if (!in_atoms) {
thread_latency_insert(sched_in); thread_atom_list_insert(sched_in);
in_lat = thread_latency_search(&lat_snapshot_root, sched_in); in_atoms = thread_atom_list_search(&lat_snapshot_root, sched_in);
if (!in_lat) if (!in_atoms)
die("Internal latency tree error"); die("Internal latency tree error");
} }
out_lat = thread_latency_search(&lat_snapshot_root, sched_out); out_atoms = thread_atom_list_search(&lat_snapshot_root, sched_out);
if (!out_lat) { if (!out_atoms) {
thread_latency_insert(sched_out); thread_atom_list_insert(sched_out);
out_lat = thread_latency_search(&lat_snapshot_root, sched_out); out_atoms = thread_atom_list_search(&lat_snapshot_root, sched_out);
if (!out_lat) if (!out_atoms)
die("Internal latency tree error"); die("Internal latency tree error");
} }
lat_sched_in(in_lat, timestamp); lat_sched_in(in_atoms, timestamp);
lat_sched_out(out_lat, switch_event, delta); lat_sched_out(out_atoms, switch_event, delta);
} }
static void static void
@ -1053,8 +1053,8 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
u64 timestamp, u64 timestamp,
struct thread *thread __used) struct thread *thread __used)
{ {
struct thread_latency *lat; struct task_atoms *atoms;
struct lat_snapshot *snapshot; struct work_atom *snapshot;
struct thread *wakee; struct thread *wakee;
/* Note for later, it may be interesting to observe the failing cases */ /* Note for later, it may be interesting to observe the failing cases */
@ -1062,16 +1062,16 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
return; return;
wakee = threads__findnew(wakeup_event->pid, &threads, &last_match); wakee = threads__findnew(wakeup_event->pid, &threads, &last_match);
lat = thread_latency_search(&lat_snapshot_root, wakee); atoms = thread_atom_list_search(&lat_snapshot_root, wakee);
if (!lat) { if (!atoms) {
thread_latency_insert(wakee); thread_atom_list_insert(wakee);
return; return;
} }
if (list_empty(&lat->snapshot_list)) if (list_empty(&atoms->snapshot_list))
return; return;
snapshot = list_entry(lat->snapshot_list.prev, struct lat_snapshot, snapshot = list_entry(atoms->snapshot_list.prev, struct work_atom,
list); list);
if (snapshot->state != THREAD_SLEEPING) if (snapshot->state != THREAD_SLEEPING)
@ -1090,9 +1090,9 @@ static struct trace_sched_handler lat_ops = {
static u64 all_runtime; static u64 all_runtime;
static u64 all_count; static u64 all_count;
static void output_lat_thread(struct thread_latency *lat) static void output_lat_thread(struct task_atoms *atom_list)
{ {
struct lat_snapshot *shot; struct work_atom *atom;
int count = 0; int count = 0;
int i; int i;
int ret; int ret;
@ -1100,15 +1100,15 @@ static void output_lat_thread(struct thread_latency *lat)
u64 total = 0, delta; u64 total = 0, delta;
u64 total_runtime = 0; u64 total_runtime = 0;
list_for_each_entry(shot, &lat->snapshot_list, list) { list_for_each_entry(atom, &atom_list->snapshot_list, list) {
total_runtime += shot->runtime; total_runtime += atom->runtime;
if (shot->state != THREAD_SCHED_IN) if (atom->state != THREAD_SCHED_IN)
continue; continue;
count++; count++;
delta = shot->sched_in_time - shot->wake_up_time; delta = atom->sched_in_time - atom->wake_up_time;
if (delta > max) if (delta > max)
max = delta; max = delta;
total += delta; total += delta;
@ -1120,7 +1120,7 @@ static void output_lat_thread(struct thread_latency *lat)
if (!count) if (!count)
return; return;
ret = printf(" %s ", lat->thread->comm); ret = printf(" %s ", atom_list->thread->comm);
for (i = 0; i < 19 - ret; i++) for (i = 0; i < 19 - ret; i++)
printf(" "); printf(" ");
@ -1145,10 +1145,10 @@ static void __cmd_lat(void)
next = rb_first(&lat_snapshot_root); next = rb_first(&lat_snapshot_root);
while (next) { while (next) {
struct thread_latency *lat; struct task_atoms *atom_list;
lat = rb_entry(next, struct thread_latency, node); atom_list = rb_entry(next, struct task_atoms, node);
output_lat_thread(lat); output_lat_thread(atom_list);
next = rb_next(next); next = rb_next(next);
} }