perf lock: Use perf_evsel__intval and perf_session__set_tracepoints_handlers
Following the model of 'perf sched': . raw_field_value searches first on the common fields, that are unused in this tool . Leave using perf_evsel__intval to the actual handlers, some may not need to incur some of the cost because they may not need all the fields values. . Using perf_session__set_tracepoints_handlers will save all those strcmp to find the right handler at sample processing time, do it just once and get the handler from evsel->handler.func. 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@gmail.com> Cc: Paul Mackerras <paulus@samba.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Stephane Eranian <eranian@google.com> Link: http://lkml.kernel.org/n/tip-v9x3q9rv4caxtox7wtjpchq5@git.kernel.org Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Arnaldo Carvalho de Melo
Родитель
0f7d2f1b65
Коммит
746f16ec6a
|
|
@ -1,6 +1,7 @@
|
|||
#include "builtin.h"
|
||||
#include "perf.h"
|
||||
|
||||
#include "util/evlist.h"
|
||||
#include "util/evsel.h"
|
||||
#include "util/util.h"
|
||||
#include "util/cache.h"
|
||||
|
|
@ -41,7 +42,7 @@ struct lock_stat {
|
|||
struct rb_node rb; /* used for sorting */
|
||||
|
||||
/*
|
||||
* FIXME: raw_field_value() returns unsigned long long,
|
||||
* FIXME: perf_evsel__intval() returns u64,
|
||||
* so address of lockdep_map should be dealed as 64bit.
|
||||
* Is there more better solution?
|
||||
*/
|
||||
|
|
@ -336,44 +337,18 @@ alloc_failed:
|
|||
|
||||
static const char *input_name;
|
||||
|
||||
struct raw_event_sample {
|
||||
u32 size;
|
||||
char data[0];
|
||||
};
|
||||
|
||||
struct trace_acquire_event {
|
||||
void *addr;
|
||||
const char *name;
|
||||
int flag;
|
||||
};
|
||||
|
||||
struct trace_acquired_event {
|
||||
void *addr;
|
||||
const char *name;
|
||||
};
|
||||
|
||||
struct trace_contended_event {
|
||||
void *addr;
|
||||
const char *name;
|
||||
};
|
||||
|
||||
struct trace_release_event {
|
||||
void *addr;
|
||||
const char *name;
|
||||
};
|
||||
|
||||
struct trace_lock_handler {
|
||||
int (*acquire_event)(struct trace_acquire_event *,
|
||||
const struct perf_sample *sample);
|
||||
int (*acquire_event)(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample);
|
||||
|
||||
int (*acquired_event)(struct trace_acquired_event *,
|
||||
const struct perf_sample *sample);
|
||||
int (*acquired_event)(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample);
|
||||
|
||||
int (*contended_event)(struct trace_contended_event *,
|
||||
const struct perf_sample *sample);
|
||||
int (*contended_event)(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample);
|
||||
|
||||
int (*release_event)(struct trace_release_event *,
|
||||
const struct perf_sample *sample);
|
||||
int (*release_event)(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample);
|
||||
};
|
||||
|
||||
static struct lock_seq_stat *get_seq(struct thread_stat *ts, void *addr)
|
||||
|
|
@ -412,15 +387,20 @@ enum acquire_flags {
|
|||
READ_LOCK = 2,
|
||||
};
|
||||
|
||||
static int
|
||||
report_lock_acquire_event(struct trace_acquire_event *acquire_event,
|
||||
const struct perf_sample *sample)
|
||||
static int report_lock_acquire_event(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
void *addr;
|
||||
struct lock_stat *ls;
|
||||
struct thread_stat *ts;
|
||||
struct lock_seq_stat *seq;
|
||||
const char *name = perf_evsel__strval(evsel, sample, "name");
|
||||
u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
|
||||
int flag = perf_evsel__intval(evsel, sample, "flag");
|
||||
|
||||
ls = lock_stat_findnew(acquire_event->addr, acquire_event->name);
|
||||
memcpy(&addr, &tmp, sizeof(void *));
|
||||
|
||||
ls = lock_stat_findnew(addr, name);
|
||||
if (!ls)
|
||||
return -1;
|
||||
if (ls->discard)
|
||||
|
|
@ -430,19 +410,19 @@ report_lock_acquire_event(struct trace_acquire_event *acquire_event,
|
|||
if (!ts)
|
||||
return -1;
|
||||
|
||||
seq = get_seq(ts, acquire_event->addr);
|
||||
seq = get_seq(ts, addr);
|
||||
if (!seq)
|
||||
return -1;
|
||||
|
||||
switch (seq->state) {
|
||||
case SEQ_STATE_UNINITIALIZED:
|
||||
case SEQ_STATE_RELEASED:
|
||||
if (!acquire_event->flag) {
|
||||
if (!flag) {
|
||||
seq->state = SEQ_STATE_ACQUIRING;
|
||||
} else {
|
||||
if (acquire_event->flag & TRY_LOCK)
|
||||
if (flag & TRY_LOCK)
|
||||
ls->nr_trylock++;
|
||||
if (acquire_event->flag & READ_LOCK)
|
||||
if (flag & READ_LOCK)
|
||||
ls->nr_readlock++;
|
||||
seq->state = SEQ_STATE_READ_ACQUIRED;
|
||||
seq->read_count = 1;
|
||||
|
|
@ -450,7 +430,7 @@ report_lock_acquire_event(struct trace_acquire_event *acquire_event,
|
|||
}
|
||||
break;
|
||||
case SEQ_STATE_READ_ACQUIRED:
|
||||
if (acquire_event->flag & READ_LOCK) {
|
||||
if (flag & READ_LOCK) {
|
||||
seq->read_count++;
|
||||
ls->nr_acquired++;
|
||||
goto end;
|
||||
|
|
@ -480,17 +460,20 @@ end:
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
report_lock_acquired_event(struct trace_acquired_event *acquired_event,
|
||||
const struct perf_sample *sample)
|
||||
static int report_lock_acquired_event(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
u64 timestamp = sample->time;
|
||||
void *addr;
|
||||
struct lock_stat *ls;
|
||||
struct thread_stat *ts;
|
||||
struct lock_seq_stat *seq;
|
||||
u64 contended_term;
|
||||
const char *name = perf_evsel__strval(evsel, sample, "name");
|
||||
u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
|
||||
|
||||
ls = lock_stat_findnew(acquired_event->addr, acquired_event->name);
|
||||
memcpy(&addr, &tmp, sizeof(void *));
|
||||
|
||||
ls = lock_stat_findnew(addr, name);
|
||||
if (!ls)
|
||||
return -1;
|
||||
if (ls->discard)
|
||||
|
|
@ -500,7 +483,7 @@ report_lock_acquired_event(struct trace_acquired_event *acquired_event,
|
|||
if (!ts)
|
||||
return -1;
|
||||
|
||||
seq = get_seq(ts, acquired_event->addr);
|
||||
seq = get_seq(ts, addr);
|
||||
if (!seq)
|
||||
return -1;
|
||||
|
||||
|
|
@ -511,7 +494,7 @@ report_lock_acquired_event(struct trace_acquired_event *acquired_event,
|
|||
case SEQ_STATE_ACQUIRING:
|
||||
break;
|
||||
case SEQ_STATE_CONTENDED:
|
||||
contended_term = timestamp - seq->prev_event_time;
|
||||
contended_term = sample->time - seq->prev_event_time;
|
||||
ls->wait_time_total += contended_term;
|
||||
if (contended_term < ls->wait_time_min)
|
||||
ls->wait_time_min = contended_term;
|
||||
|
|
@ -536,20 +519,24 @@ report_lock_acquired_event(struct trace_acquired_event *acquired_event,
|
|||
|
||||
seq->state = SEQ_STATE_ACQUIRED;
|
||||
ls->nr_acquired++;
|
||||
seq->prev_event_time = timestamp;
|
||||
seq->prev_event_time = sample->time;
|
||||
end:
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
report_lock_contended_event(struct trace_contended_event *contended_event,
|
||||
const struct perf_sample *sample)
|
||||
static int report_lock_contended_event(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
void *addr;
|
||||
struct lock_stat *ls;
|
||||
struct thread_stat *ts;
|
||||
struct lock_seq_stat *seq;
|
||||
const char *name = perf_evsel__strval(evsel, sample, "name");
|
||||
u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
|
||||
|
||||
ls = lock_stat_findnew(contended_event->addr, contended_event->name);
|
||||
memcpy(&addr, &tmp, sizeof(void *));
|
||||
|
||||
ls = lock_stat_findnew(addr, name);
|
||||
if (!ls)
|
||||
return -1;
|
||||
if (ls->discard)
|
||||
|
|
@ -559,7 +546,7 @@ report_lock_contended_event(struct trace_contended_event *contended_event,
|
|||
if (!ts)
|
||||
return -1;
|
||||
|
||||
seq = get_seq(ts, contended_event->addr);
|
||||
seq = get_seq(ts, addr);
|
||||
if (!seq)
|
||||
return -1;
|
||||
|
||||
|
|
@ -592,15 +579,19 @@ end:
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
report_lock_release_event(struct trace_release_event *release_event,
|
||||
const struct perf_sample *sample)
|
||||
static int report_lock_release_event(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
void *addr;
|
||||
struct lock_stat *ls;
|
||||
struct thread_stat *ts;
|
||||
struct lock_seq_stat *seq;
|
||||
const char *name = perf_evsel__strval(evsel, sample, "name");
|
||||
u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
|
||||
|
||||
ls = lock_stat_findnew(release_event->addr, release_event->name);
|
||||
memcpy(&addr, &tmp, sizeof(void *));
|
||||
|
||||
ls = lock_stat_findnew(addr, name);
|
||||
if (!ls)
|
||||
return -1;
|
||||
if (ls->discard)
|
||||
|
|
@ -610,7 +601,7 @@ report_lock_release_event(struct trace_release_event *release_event,
|
|||
if (!ts)
|
||||
return -1;
|
||||
|
||||
seq = get_seq(ts, release_event->addr);
|
||||
seq = get_seq(ts, addr);
|
||||
if (!seq)
|
||||
return -1;
|
||||
|
||||
|
|
@ -663,96 +654,33 @@ static struct trace_lock_handler *trace_handler;
|
|||
static int perf_evsel__process_lock_acquire(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
struct trace_acquire_event acquire_event;
|
||||
struct event_format *event = evsel->tp_format;
|
||||
void *data = sample->raw_data;
|
||||
u64 tmp; /* this is required for casting... */
|
||||
int rc = 0;
|
||||
|
||||
tmp = raw_field_value(event, "lockdep_addr", data);
|
||||
memcpy(&acquire_event.addr, &tmp, sizeof(void *));
|
||||
acquire_event.name = (char *)raw_field_ptr(event, "name", data);
|
||||
acquire_event.flag = (int)raw_field_value(event, "flag", data);
|
||||
|
||||
if (trace_handler->acquire_event)
|
||||
rc = trace_handler->acquire_event(&acquire_event, sample);
|
||||
|
||||
return rc;
|
||||
return trace_handler->acquire_event(evsel, sample);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int perf_evsel__process_lock_acquired(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
struct trace_acquired_event acquired_event;
|
||||
struct event_format *event = evsel->tp_format;
|
||||
void *data = sample->raw_data;
|
||||
u64 tmp; /* this is required for casting... */
|
||||
int rc = 0;
|
||||
|
||||
tmp = raw_field_value(event, "lockdep_addr", data);
|
||||
memcpy(&acquired_event.addr, &tmp, sizeof(void *));
|
||||
acquired_event.name = (char *)raw_field_ptr(event, "name", data);
|
||||
|
||||
if (trace_handler->acquired_event)
|
||||
rc = trace_handler->acquired_event(&acquired_event, sample);
|
||||
|
||||
return rc;
|
||||
return trace_handler->acquired_event(evsel, sample);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int perf_evsel__process_lock_contended(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
struct trace_contended_event contended_event;
|
||||
struct event_format *event = evsel->tp_format;
|
||||
void *data = sample->raw_data;
|
||||
u64 tmp; /* this is required for casting... */
|
||||
int rc = 0;
|
||||
|
||||
tmp = raw_field_value(event, "lockdep_addr", data);
|
||||
memcpy(&contended_event.addr, &tmp, sizeof(void *));
|
||||
contended_event.name = (char *)raw_field_ptr(event, "name", data);
|
||||
|
||||
if (trace_handler->contended_event)
|
||||
rc = trace_handler->contended_event(&contended_event, sample);
|
||||
|
||||
return rc;
|
||||
return trace_handler->contended_event(evsel, sample);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int perf_evsel__process_lock_release(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
struct trace_release_event release_event;
|
||||
struct event_format *event = evsel->tp_format;
|
||||
void *data = sample->raw_data;
|
||||
u64 tmp; /* this is required for casting... */
|
||||
int rc = 0;
|
||||
|
||||
tmp = raw_field_value(event, "lockdep_addr", data);
|
||||
memcpy(&release_event.addr, &tmp, sizeof(void *));
|
||||
release_event.name = (char *)raw_field_ptr(event, "name", data);
|
||||
|
||||
if (trace_handler->release_event)
|
||||
rc = trace_handler->release_event(&release_event, sample);
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int perf_evsel__process_lock_event(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
struct event_format *event = evsel->tp_format;
|
||||
int rc = 0;
|
||||
|
||||
if (!strcmp(event->name, "lock_acquire"))
|
||||
rc = perf_evsel__process_lock_acquire(evsel, sample);
|
||||
if (!strcmp(event->name, "lock_acquired"))
|
||||
rc = perf_evsel__process_lock_acquired(evsel, sample);
|
||||
if (!strcmp(event->name, "lock_contended"))
|
||||
rc = perf_evsel__process_lock_contended(evsel, sample);
|
||||
if (!strcmp(event->name, "lock_release"))
|
||||
rc = perf_evsel__process_lock_release(evsel, sample);
|
||||
|
||||
return rc;
|
||||
return trace_handler->release_event(evsel, sample);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void print_bad_events(int bad, int total)
|
||||
|
|
@ -870,6 +798,9 @@ static int dump_info(void)
|
|||
return rc;
|
||||
}
|
||||
|
||||
typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
|
||||
struct perf_sample *sample);
|
||||
|
||||
static int process_sample_event(struct perf_tool *tool __maybe_unused,
|
||||
union perf_event *event,
|
||||
struct perf_sample *sample,
|
||||
|
|
@ -884,7 +815,12 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,
|
|||
return -1;
|
||||
}
|
||||
|
||||
return perf_evsel__process_lock_event(evsel, sample);
|
||||
if (evsel->handler.func != NULL) {
|
||||
tracepoint_handler f = evsel->handler.func;
|
||||
return f(evsel, sample);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct perf_tool eops = {
|
||||
|
|
@ -893,6 +829,13 @@ static struct perf_tool eops = {
|
|||
.ordered_samples = true,
|
||||
};
|
||||
|
||||
static const struct perf_evsel_str_handler lock_tracepoints[] = {
|
||||
{ "lock:lock_acquire", perf_evsel__process_lock_acquire, }, /* CONFIG_LOCKDEP */
|
||||
{ "lock:lock_acquired", perf_evsel__process_lock_acquired, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
|
||||
{ "lock:lock_contended", perf_evsel__process_lock_contended, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
|
||||
{ "lock:lock_release", perf_evsel__process_lock_release, }, /* CONFIG_LOCKDEP */
|
||||
};
|
||||
|
||||
static int read_events(void)
|
||||
{
|
||||
session = perf_session__new(input_name, O_RDONLY, 0, false, &eops);
|
||||
|
|
@ -901,6 +844,11 @@ static int read_events(void)
|
|||
return -1;
|
||||
}
|
||||
|
||||
if (perf_session__set_tracepoints_handlers(session, lock_tracepoints)) {
|
||||
pr_err("Initializing perf session tracepoint handlers failed\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return perf_session__process_events(session, &eops);
|
||||
}
|
||||
|
||||
|
|
@ -967,13 +915,6 @@ static const struct option lock_options[] = {
|
|||
OPT_END()
|
||||
};
|
||||
|
||||
static const char * const lock_tracepoints[] = {
|
||||
"lock:lock_acquire", /* CONFIG_LOCKDEP */
|
||||
"lock:lock_acquired", /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
|
||||
"lock:lock_contended", /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
|
||||
"lock:lock_release", /* CONFIG_LOCKDEP */
|
||||
};
|
||||
|
||||
static const char *record_args[] = {
|
||||
"record",
|
||||
"-R",
|
||||
|
|
@ -988,10 +929,10 @@ static int __cmd_record(int argc, const char **argv)
|
|||
const char **rec_argv;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(lock_tracepoints); i++) {
|
||||
if (!is_valid_tracepoint(lock_tracepoints[i])) {
|
||||
if (!is_valid_tracepoint(lock_tracepoints[i].name)) {
|
||||
pr_err("tracepoint %s is not enabled. "
|
||||
"Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n",
|
||||
lock_tracepoints[i]);
|
||||
lock_tracepoints[i].name);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
|
@ -1009,7 +950,7 @@ static int __cmd_record(int argc, const char **argv)
|
|||
|
||||
for (j = 0; j < ARRAY_SIZE(lock_tracepoints); j++) {
|
||||
rec_argv[i++] = "-e";
|
||||
rec_argv[i++] = strdup(lock_tracepoints[j]);
|
||||
rec_argv[i++] = strdup(lock_tracepoints[j].name);
|
||||
}
|
||||
|
||||
for (j = 1; j < (unsigned int)argc; j++, i++)
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче