hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

perf tools: Move threads & last_match to threads.c 

This was just being copy'n'pasted all over.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Mike Galbraith <efault@gmx.de>
LKML-Reference: <20091013141629.GD21809@ghostprotocols.net>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Arnaldo Carvalho de Melo 2009-10-13 11:16:29 -03:00 committed by Ingo Molnar
parent f4f0b41818
commit d5b889f2ec
6 changed files with 45 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
tools/perf/builtin-annotate.c
View File

@ -37,10 +37,6 @@ static int print_line;
static unsigned long page_size; static unsigned long page_size;
static unsigned long mmap_window = 32; static unsigned long mmap_window = 32;
static struct rb_root threads;
static struct thread *last_match;
struct sym_ext { struct sym_ext {
struct rb_node node; struct rb_node node;
double percent; double percent;
@ -96,12 +92,10 @@ static int
process_sample_event(event_t *event, unsigned long offset, unsigned long head) process_sample_event(event_t *event, unsigned long offset, unsigned long head)
{ {
char level; char level;
struct thread *thread;
u64 ip = event->ip.ip; u64 ip = event->ip.ip;
struct map *map = NULL; struct map *map = NULL;
struct symbol *sym = NULL; struct symbol *sym = NULL;
struct thread *thread = threads__findnew(event->ip.pid);
thread = threads__findnew(event->ip.pid, &threads, &last_match);
dump_printf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n", dump_printf("%p [%p]: PERF_EVENT (IP, %d): %d: %p\n",
(void *)(offset + head), (void *)(offset + head),
@ -166,10 +160,8 @@ got_map:
static int static int
process_mmap_event(event_t *event, unsigned long offset, unsigned long head) process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread;
struct map *map = map__new(&event->mmap, NULL, 0); struct map *map = map__new(&event->mmap, NULL, 0);
struct thread *thread = threads__findnew(event->mmap.pid);
thread = threads__findnew(event->mmap.pid, &threads, &last_match);
dump_printf("%p [%p]: PERF_RECORD_MMAP %d: [%p(%p) @ %p]: %s\n", dump_printf("%p [%p]: PERF_RECORD_MMAP %d: [%p(%p) @ %p]: %s\n",
(void *)(offset + head), (void *)(offset + head),
@ -194,9 +186,8 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
static int static int
process_comm_event(event_t *event, unsigned long offset, unsigned long head) process_comm_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread; struct thread *thread = threads__findnew(event->comm.pid);
thread = threads__findnew(event->comm.pid, &threads, &last_match);
dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n", dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
(void *)(offset + head), (void *)(offset + head),
(void *)(long)(event->header.size), (void *)(long)(event->header.size),
@ -215,11 +206,9 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
static int static int
process_fork_event(event_t *event, unsigned long offset, unsigned long head) process_fork_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread; struct thread *thread = threads__findnew(event->fork.pid);
struct thread *parent; struct thread *parent = threads__findnew(event->fork.ppid);
thread = threads__findnew(event->fork.pid, &threads, &last_match);
parent = threads__findnew(event->fork.ppid, &threads, &last_match);
dump_printf("%p [%p]: PERF_RECORD_FORK: %d:%d\n", dump_printf("%p [%p]: PERF_RECORD_FORK: %d:%d\n",
(void *)(offset + head), (void *)(offset + head),
(void *)(long)(event->header.size), (void *)(long)(event->header.size),
@ -558,7 +547,7 @@ static int __cmd_annotate(void)
uint32_t size; uint32_t size;
char *buf; char *buf;
register_idle_thread(&threads, &last_match); register_idle_thread();
input = open(input_name, O_RDONLY); input = open(input_name, O_RDONLY);
if (input < 0) { if (input < 0) {
@ -659,7 +648,7 @@ more:
return 0; return 0;
if (verbose > 3) if (verbose > 3)
threads__fprintf(stdout, &threads); threads__fprintf(stdout);
if (verbose > 2) if (verbose > 2)
dsos__fprintf(stdout); dsos__fprintf(stdout);

26
tools/perf/builtin-report.c
View File

@ -55,9 +55,6 @@ static char callchain_default_opt[] = "fractal,0.5";
static char *cwd; static char *cwd;
static int cwdlen; static int cwdlen;
static struct rb_root threads;
static struct thread *last_match;
static struct perf_header *header; static struct perf_header *header;
static u64 sample_type; static u64 sample_type;
@ -593,15 +590,13 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
{ {
char level; char level;
struct symbol *sym = NULL; struct symbol *sym = NULL;
struct thread *thread;
u64 ip = event->ip.ip; u64 ip = event->ip.ip;
u64 period = 1; u64 period = 1;
struct map *map = NULL; struct map *map = NULL;
void *more_data = event->ip.__more_data; void *more_data = event->ip.__more_data;
struct ip_callchain *chain = NULL; struct ip_callchain *chain = NULL;
int cpumode; int cpumode;
struct thread *thread = threads__findnew(event->ip.pid);
thread = threads__findnew(event->ip.pid, &threads, &last_match);
if (sample_type & PERF_SAMPLE_PERIOD) { if (sample_type & PERF_SAMPLE_PERIOD) {
period = *(u64 *)more_data; period = *(u64 *)more_data;
@ -685,10 +680,8 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
static int static int
process_mmap_event(event_t *event, unsigned long offset, unsigned long head) process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread;
struct map *map = map__new(&event->mmap, cwd, cwdlen); struct map *map = map__new(&event->mmap, cwd, cwdlen);
struct thread *thread = threads__findnew(event->mmap.pid);
thread = threads__findnew(event->mmap.pid, &threads, &last_match);
dump_printf("%p [%p]: PERF_RECORD_MMAP %d/%d: [%p(%p) @ %p]: %s\n", dump_printf("%p [%p]: PERF_RECORD_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
(void *)(offset + head), (void *)(offset + head),
@ -714,9 +707,7 @@ process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
static int static int
process_comm_event(event_t *event, unsigned long offset, unsigned long head) process_comm_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread; struct thread *thread = threads__findnew(event->comm.pid);
thread = threads__findnew(event->comm.pid, &threads, &last_match);
dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n", dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
(void *)(offset + head), (void *)(offset + head),
@ -736,11 +727,8 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
static int static int
process_task_event(event_t *event, unsigned long offset, unsigned long head) process_task_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread; struct thread *thread = threads__findnew(event->fork.pid);
struct thread *parent; struct thread *parent = threads__findnew(event->fork.ppid);
thread = threads__findnew(event->fork.pid, &threads, &last_match);
parent = threads__findnew(event->fork.ppid, &threads, &last_match);
dump_printf("%p [%p]: PERF_RECORD_%s: (%d:%d):(%d:%d)\n", dump_printf("%p [%p]: PERF_RECORD_%s: (%d:%d):(%d:%d)\n",
(void *)(offset + head), (void *)(offset + head),
@ -857,7 +845,7 @@ static int __cmd_report(void)
struct thread *idle; struct thread *idle;
int ret; int ret;
idle = register_idle_thread(&threads, &last_match); idle = register_idle_thread();
thread__comm_adjust(idle); thread__comm_adjust(idle);
if (show_threads) if (show_threads)
@ -881,7 +869,7 @@ static int __cmd_report(void)
return 0; return 0;
if (verbose > 3) if (verbose > 3)
threads__fprintf(stdout, &threads); threads__fprintf(stdout);
if (verbose > 2) if (verbose > 2)
dsos__fprintf(stdout); dsos__fprintf(stdout);

30
tools/perf/builtin-sched.c
View File

@ -24,9 +24,6 @@ static char const *input_name = "perf.data";
static unsigned long total_comm = 0; static unsigned long total_comm = 0;
static struct rb_root threads;
static struct thread *last_match;
static struct perf_header *header; static struct perf_header *header;
static u64 sample_type; static u64 sample_type;
@ -641,9 +638,7 @@ static void test_calibrations(void)
static int static int
process_comm_event(event_t *event, unsigned long offset, unsigned long head) process_comm_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread; struct thread *thread = threads__findnew(event->comm.tid);
thread = threads__findnew(event->comm.tid, &threads, &last_match);
dump_printf("%p [%p]: perf_event_comm: %s:%d\n", dump_printf("%p [%p]: perf_event_comm: %s:%d\n",
(void *)(offset + head), (void *)(offset + head),
@ -1086,8 +1081,8 @@ latency_switch_event(struct trace_switch_event *switch_event,
die("hm, delta: %Ld < 0 ?\n", delta); die("hm, delta: %Ld < 0 ?\n", delta);
sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match); sched_out = threads__findnew(switch_event->prev_pid);
sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match); sched_in = threads__findnew(switch_event->next_pid);
out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid); out_events = thread_atoms_search(&atom_root, sched_out, &cmp_pid);
if (!out_events) { if (!out_events) {
@ -1120,13 +1115,10 @@ latency_runtime_event(struct trace_runtime_event *runtime_event,
u64 timestamp, u64 timestamp,
struct thread *this_thread __used) struct thread *this_thread __used)
{ {
struct work_atoms *atoms; struct thread *thread = threads__findnew(runtime_event->pid);
struct thread *thread; struct work_atoms *atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
BUG_ON(cpu >= MAX_CPUS || cpu < 0); BUG_ON(cpu >= MAX_CPUS || cpu < 0);
thread = threads__findnew(runtime_event->pid, &threads, &last_match);
atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
if (!atoms) { if (!atoms) {
thread_atoms_insert(thread); thread_atoms_insert(thread);
atoms = thread_atoms_search(&atom_root, thread, &cmp_pid); atoms = thread_atoms_search(&atom_root, thread, &cmp_pid);
@ -1153,7 +1145,7 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
if (!wakeup_event->success) if (!wakeup_event->success)
return; return;
wakee = threads__findnew(wakeup_event->pid, &threads, &last_match); wakee = threads__findnew(wakeup_event->pid);
atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid); atoms = thread_atoms_search(&atom_root, wakee, &cmp_pid);
if (!atoms) { if (!atoms) {
thread_atoms_insert(wakee); thread_atoms_insert(wakee);
@ -1202,7 +1194,7 @@ latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
if (profile_cpu == -1) if (profile_cpu == -1)
return; return;
migrant = threads__findnew(migrate_task_event->pid, &threads, &last_match); migrant = threads__findnew(migrate_task_event->pid);
atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid); atoms = thread_atoms_search(&atom_root, migrant, &cmp_pid);
if (!atoms) { if (!atoms) {
thread_atoms_insert(migrant); thread_atoms_insert(migrant);
@ -1458,8 +1450,8 @@ map_switch_event(struct trace_switch_event *switch_event,
die("hm, delta: %Ld < 0 ?\n", delta); die("hm, delta: %Ld < 0 ?\n", delta);
sched_out = threads__findnew(switch_event->prev_pid, &threads, &last_match); sched_out = threads__findnew(switch_event->prev_pid);
sched_in = threads__findnew(switch_event->next_pid, &threads, &last_match); sched_in = threads__findnew(switch_event->next_pid);
curr_thread[this_cpu] = sched_in; curr_thread[this_cpu] = sched_in;
@ -1649,7 +1641,7 @@ process_sample_event(event_t *event, unsigned long offset, unsigned long head)
if (!(sample_type & PERF_SAMPLE_RAW)) if (!(sample_type & PERF_SAMPLE_RAW))
return 0; return 0;
thread = threads__findnew(event->ip.pid, &threads, &last_match); thread = threads__findnew(event->ip.pid);
if (sample_type & PERF_SAMPLE_TIME) { if (sample_type & PERF_SAMPLE_TIME) {
timestamp = *(u64 *)more_data; timestamp = *(u64 *)more_data;
@ -1725,7 +1717,7 @@ static struct perf_file_handler file_handler = {
static int read_events(void) static int read_events(void)
{ {
register_idle_thread(&threads, &last_match); register_idle_thread();
register_perf_file_handler(&file_handler); register_perf_file_handler(&file_handler);
return mmap_dispatch_perf_file(&header, input_name, 0, 0, &cwdlen, &cwd); return mmap_dispatch_perf_file(&header, input_name, 0, 0, &cwdlen, &cwd);

13
tools/perf/builtin-trace.c
View File

@ -19,9 +19,6 @@ static char const *input_name = "perf.data";
static unsigned long total = 0; static unsigned long total = 0;
static unsigned long total_comm = 0; static unsigned long total_comm = 0;
static struct rb_root threads;
static struct thread *last_match;
static struct perf_header *header; static struct perf_header *header;
static u64 sample_type; static u64 sample_type;
@ -32,9 +29,7 @@ static int cwdlen;
static int static int
process_comm_event(event_t *event, unsigned long offset, unsigned long head) process_comm_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread; struct thread *thread = threads__findnew(event->comm.pid);
thread = threads__findnew(event->comm.pid, &threads, &last_match);
dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n", dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
(void *)(offset + head), (void *)(offset + head),
@ -54,14 +49,12 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
static int static int
process_sample_event(event_t *event, unsigned long offset, unsigned long head) process_sample_event(event_t *event, unsigned long offset, unsigned long head)
{ {
struct thread *thread;
u64 ip = event->ip.ip; u64 ip = event->ip.ip;
u64 timestamp = -1; u64 timestamp = -1;
u32 cpu = -1; u32 cpu = -1;
u64 period = 1; u64 period = 1;
void *more_data = event->ip.__more_data; void *more_data = event->ip.__more_data;
struct thread *thread = threads__findnew(event->ip.pid);
thread = threads__findnew(event->ip.pid, &threads, &last_match);
if (sample_type & PERF_SAMPLE_TIME) { if (sample_type & PERF_SAMPLE_TIME) {
timestamp = *(u64 *)more_data; timestamp = *(u64 *)more_data;
@ -135,7 +128,7 @@ static struct perf_file_handler file_handler = {
static int __cmd_trace(void) static int __cmd_trace(void)
{ {
register_idle_thread(&threads, &last_match); register_idle_thread();
register_perf_file_handler(&file_handler); register_perf_file_handler(&file_handler);
return mmap_dispatch_perf_file(&header, input_name, 0, 0, &cwdlen, &cwd); return mmap_dispatch_perf_file(&header, input_name, 0, 0, &cwdlen, &cwd);

27
tools/perf/util/thread.c
View File

@ -6,6 +6,9 @@
#include "util.h" #include "util.h"
#include "debug.h" #include "debug.h"
static struct rb_root threads;
static struct thread *last_match;
static struct thread *thread__new(pid_t pid) static struct thread *thread__new(pid_t pid)
{ {
struct thread *self = calloc(1, sizeof(*self)); struct thread *self = calloc(1, sizeof(*self));
@ -50,10 +53,9 @@ static size_t thread__fprintf(struct thread *self, FILE *fp)
return ret; return ret;
} }
struct thread * struct thread *threads__findnew(pid_t pid)
threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
{ {
struct rb_node **p = &threads->rb_node; struct rb_node **p = &threads.rb_node;
struct rb_node *parent = NULL; struct rb_node *parent = NULL;
struct thread *th; struct thread *th;
@ -62,15 +64,15 @@ threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
* so most of the time we dont have to look up * so most of the time we dont have to look up
* the full rbtree: * the full rbtree:
*/ */
if (*last_match && (*last_match)->pid == pid) if (last_match && last_match->pid == pid)
return *last_match; return last_match;
while (*p != NULL) { while (*p != NULL) {
parent = *p; parent = *p;
th = rb_entry(parent, struct thread, rb_node); th = rb_entry(parent, struct thread, rb_node);
if (th->pid == pid) { if (th->pid == pid) {
*last_match = th; last_match = th;
return th; return th;
} }
@ -83,17 +85,16 @@ threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match)
th = thread__new(pid); th = thread__new(pid);
if (th != NULL) { if (th != NULL) {
rb_link_node(&th->rb_node, parent, p); rb_link_node(&th->rb_node, parent, p);
rb_insert_color(&th->rb_node, threads); rb_insert_color(&th->rb_node, &threads);
*last_match = th; last_match = th;
} }
return th; return th;
} }
struct thread * struct thread *register_idle_thread(void)
register_idle_thread(struct rb_root *threads, struct thread **last_match)
{ {
struct thread *thread = threads__findnew(0, threads, last_match); struct thread *thread = threads__findnew(0);
if (!thread || thread__set_comm(thread, "swapper")) { if (!thread || thread__set_comm(thread, "swapper")) {
fprintf(stderr, "problem inserting idle task.\n"); fprintf(stderr, "problem inserting idle task.\n");
@ -197,12 +198,12 @@ int thread__fork(struct thread *self, struct thread *parent)
return 0; return 0;
} }
size_t threads__fprintf(FILE *fp, struct rb_root *threads) size_t threads__fprintf(FILE *fp)
{ {
size_t ret = 0; size_t ret = 0;
struct rb_node *nd; struct rb_node *nd;
for (nd = rb_first(threads); nd; nd = rb_next(nd)) { for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
struct thread *pos = rb_entry(nd, struct thread, rb_node); struct thread *pos = rb_entry(nd, struct thread, rb_node);
ret += thread__fprintf(pos, fp); ret += thread__fprintf(pos, fp);

8
tools/perf/util/thread.h
View File

@ -15,13 +15,11 @@ struct thread {
}; };
int thread__set_comm(struct thread *self, const char *comm); int thread__set_comm(struct thread *self, const char *comm);
struct thread * struct thread *threads__findnew(pid_t pid);
threads__findnew(pid_t pid, struct rb_root *threads, struct thread **last_match); struct thread *register_idle_thread(void);
struct thread *
register_idle_thread(struct rb_root *threads, struct thread **last_match);
void thread__insert_map(struct thread *self, struct map *map); void thread__insert_map(struct thread *self, struct map *map);
int thread__fork(struct thread *self, struct thread *parent); int thread__fork(struct thread *self, struct thread *parent);
size_t threads__fprintf(FILE *fp, struct rb_root *threads); size_t threads__fprintf(FILE *fp);
void maps__insert(struct rb_root *maps, struct map *map); void maps__insert(struct rb_root *maps, struct map *map);
struct map *maps__find(struct rb_root *maps, u64 ip); struct map *maps__find(struct rb_root *maps, u64 ip);