perf tools: Factor ordered samples queue
Jiri Olsa
reviewerv4 cover perf tools: Factor ordered samples queue
hi,
this patchset factors session's ordered samples queue, and allows to limit the size of this queue.
v4 changes:
- split patch 17 into 2 patches (17/18 now) (Arnaldo)
- omitted patch 18 which set default queue value to 100MB (Adrian)
- factor patch 16 to display better debug messages (Adrian)
v3 changes:
- rebased to latest tip/perf/core
- add comment for WARN in patch 8 (David)
- added ordered-events debug variable (David)
- renamed ordered_events_(get|put) to ordered_events_(new|delete)
- renamed struct ordered_events_queue to struct ordered_events
v2 changes:
- several small changes for review comments (Namhyung)
The report command queues events till any of following conditions is reached:
- PERF_RECORD_FINISHED_ROUND event is processed
- end of the file is reached
Any of above conditions will force the queue to flush some events while keeping all allocated memory for next events.
If PERF_RECORD_FINISHED_ROUND is missing the queue will allocate memory for every single event in the perf.data. This could lead to enormous memory consuption and speed degradation of report command for huge perf.data files.
With the quue allocation limit of 100 MB, I've got around 15% speedup on reporting of ~10GB perf.data file.
current code:
Performance counter stats for './perf.old report --stdio -i perf-test.data' (3 runs):
621,685,704,665 cycles ( +- 0.52% ) 873,397,467,969 instructions ( +- 0.00% )
286.133268732 seconds time elapsed ( +- 1.13% )
with patches:
Performance counter stats for './perf report --stdio -i perf-test.data' (3 runs):
603,933,987,185 cycles ( +- 0.45% ) 869,139,445,070 instructions ( +- 0.00% )
245.337510637 seconds time elapsed ( +- 0.49% )
The speed up seems to be mainly in less cycles spent in servicing page faults:
current code:
4.44% 0.01% perf.old [kernel.kallsyms] [k] page_fault
with patches:
1.45% 0.00% perf [kernel.kallsyms] [k] page_fault
current code (faults event):
6,643,807 faults ( +- 0.36% )
with patches (faults event):
2,214,756 faults ( +- 3.03% )
Also now we have one of our big memory spender under control and the ordered events queue code is put in separated object with clear interface ready to be used by another command like script.
Also reachable in here:
git://git.kernel.org/pub/scm/linux/kernel/git/jolsa/perf.git
perf/core_ordered_events
thanks,
jirka
---
Jiri Olsa (19):
perf tools: Fix accounting of ordered samples queue
perf tools: Rename ordered_samples bool to ordered_events perf tools: Rename ordered_samples struct to ordered_events perf tools: Rename ordered_events members
perf tools: Add ordered_events_(new|delete) interface perf tools: Factor ordered_events_flush to be more generic perf tools: Limit ordered events queue size
perf tools: Flush ordered events in case of allocation failure perf tools: Make perf_session_deliver_event global
perf tools: Create ordered-events object
perf tools: Use list_move in ordered_events_delete function perf tools: Add ordered_events_init function
perf tools: Add ordered_events_free function
perf tools: Add perf_config_u64 function
perf tools: Add report.queue-size config file option
perf tools: Add debug prints for ordered events queue perf tools: Always force PERF_RECORD_FINISHED_ROUND event perf tools: Store PERF_RECORD_FINISHED_ROUND only for nonempty rounds perf tools: Allow out of order messages in forced flush
tools/perf/Makefile.perf | 2 + tools/perf/builtin-annotate.c | 2 +- tools/perf/builtin-diff.c | 2 +- tools/perf/builtin-inject.c | 2 +- tools/perf/builtin-kmem.c | 2 +- tools/perf/builtin-kvm.c | 8 ++-- tools/perf/builtin-lock.c | 2 +- tools/perf/builtin-mem.c | 2 +- tools/perf/builtin-record.c | 7 ++- tools/perf/builtin-report.c | 15 +++++- tools/perf/builtin-sched.c | 2 +- tools/perf/builtin-script.c | 2 +- tools/perf/builtin-timechart.c | 2 +- tools/perf/builtin-trace.c | 2 +- tools/perf/util/cache.h | 1 + tools/perf/util/config.c | 24 ++++++++++ tools/perf/util/debug.c | 36 ++++++++++++++- tools/perf/util/debug.h | 8 ++++ tools/perf/util/ordered-events.c | 245 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/ordered-events.h | 51 +++++++++++++++++++++ tools/perf/util/session.c | 217 ++++++++++++++++---------------------------------------------------------------------- tools/perf/util/session.h | 26 ++++------- tools/perf/util/tool.h | 2 +- 23 files changed, 448 insertions(+), 214 deletions(-) create mode 100644 tools/perf/util/ordered-events.c create mode 100644 tools/perf/util/ordered-events.h
Jiri Olsa
reviewerPATCH v4 1/19 perf tools: Fix accounting of ordered samples queue
Properly account flushed samples within the ordered samples queue.
--- tools/perf/util/session.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
tools/perf/util/session.c +1 -2
@@ -511,6 +511,7 @@ static int flush_sample_queue(struct perf_session *s, os->last_flush = iter->timestamp;list_del (&iter->list);list_add (&iter->list, &os->sample_cache); + os->nr_samples--;if (show_progress)ui_progress__update (&prog,1 );
@@ -523,8 +524,6 @@ static int flush_sample_queue(struct perf_session *s, list_entry(head->prev, struct sample_queue, list); } - os->nr_samples =0 ; -return 0 ; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 2/19 perf tools: Rename ordered_samples bool to ordered_events
In reply to Jiri OlsaThe time ordering is generic for all kinds of events, so using generic name 'ordered_events' for ordered_samples bool in perf_tool struct.
No functional change was intended.
--- tools/perf/builtin-annotate.c | 2 +- tools/perf/builtin-diff.c | 2 +- tools/perf/builtin-inject.c | 2 +- tools/perf/builtin-kmem.c | 2 +- tools/perf/builtin-kvm.c | 4 ++-- tools/perf/builtin-lock.c | 2 +- tools/perf/builtin-mem.c | 2 +- tools/perf/builtin-report.c | 2 +- tools/perf/builtin-sched.c | 2 +- tools/perf/builtin-script.c | 2 +- tools/perf/builtin-timechart.c | 2 +- tools/perf/builtin-trace.c | 2 +- tools/perf/util/session.c | 10 +++++----- tools/perf/util/tool.h | 2 +- 14 files changed, 19 insertions(+), 19 deletions(-)
tools/perf/builtin-annotate.c +1 -1
@@ -297,7 +297,7 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused) .comm = perf_event__process_comm, .exit = perf_event__process_exit, .fork = perf_event__process_fork, - .ordered_samples = true, + .ordered_events = true, .ordering_requires_timestamps = true, }, };
tools/perf/builtin-diff.c +1 -1
@@ -360,7 +360,7 @@ static struct perf_tool tool = { .exit = perf_event__process_exit, .fork = perf_event__process_fork, .lost = perf_event__process_lost, - .ordered_samples = true, + .ordered_events = true, .ordering_requires_timestamps = true, };
tools/perf/builtin-inject.c +1 -1
@@ -366,7 +366,7 @@ static int __cmd_inject(struct perf_inject *inject) }else if (inject->sched_stat) {struct perf_evsel *evsel; - inject->tool.ordered_samples = true; + inject->tool.ordered_events = true;evlist__for_each (session->evlist, evsel) {const char *name =perf_evsel__name (evsel);
tools/perf/builtin-kmem.c +1 -1
@@ -256,7 +256,7 @@ static int process_sample_event(struct perf_tool *tool __maybe_unused,static struct perf_tool perf_kmem = { .sample = process_sample_event, .comm = perf_event__process_comm, - .ordered_samples = true, + .ordered_events = true, };static double fragmentation (unsigned long n_req,unsigned long n_alloc)
tools/perf/builtin-kvm.c +2 -2
@@ -1058,7 +1058,7 @@ static int read_events(struct perf_kvm_stat *kvm)struct perf_tool eops = { .sample = process_sample_event, .comm = perf_event__process_comm, - .ordered_samples = true, + .ordered_events = true, };struct perf_data_file file = { .path = kvm->file_name,
@@ -1311,7 +1311,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm, kvm->tool.exit = perf_event__process_exit; kvm->tool.fork = perf_event__process_fork; kvm->tool.lost = process_lost_event; - kvm->tool.ordered_samples = true; + kvm->tool.ordered_events = true;perf_tool__fill_defaults (&kvm->tool);/* set defaults */
tools/perf/builtin-lock.c +1 -1
@@ -852,7 +852,7 @@ static int __cmd_report(bool display_info)struct perf_tool eops = { .sample = process_sample_event, .comm = perf_event__process_comm, - .ordered_samples = true, + .ordered_events = true, };struct perf_data_file file = { .path = input_name,
tools/perf/builtin-mem.c +1 -1
@@ -194,7 +194,7 @@ int cmd_mem(int argc, const char **argv, const char *prefix __maybe_unused) .lost = perf_event__process_lost, .fork = perf_event__process_fork, .build_id = perf_event__process_build_id, - .ordered_samples = true, + .ordered_events = true, }, .input_name = "perf.data", };
tools/perf/builtin-report.c +1 -1
@@ -578,7 +578,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused) .attr = perf_event__process_attr, .tracing_data = perf_event__process_tracing_data, .build_id = perf_event__process_build_id, - .ordered_samples = true, + .ordered_events = true, .ordering_requires_timestamps = true, }, .max_stack = PERF_MAX_STACK_DEPTH,
tools/perf/builtin-sched.c +1 -1
@@ -1662,7 +1662,7 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused) .comm = perf_event__process_comm, .lost = perf_event__process_lost, .fork = perf_sched__process_fork_event, - .ordered_samples = true, + .ordered_events = true, }, .cmp_pid = LIST_HEAD_INIT(sched.cmp_pid), .sort_list = LIST_HEAD_INIT(sched.sort_list),
tools/perf/builtin-script.c +1 -1
@@ -1510,7 +1510,7 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused) .attr = process_attr, .tracing_data = perf_event__process_tracing_data, .build_id = perf_event__process_build_id, - .ordered_samples = true, + .ordered_events = true, .ordering_requires_timestamps = true, }, };
tools/perf/builtin-timechart.c +1 -1
@@ -1920,7 +1920,7 @@ int cmd_timechart(int argc, const char **argv, .fork = process_fork_event, .exit = process_exit_event, .sample = process_sample_event, - .ordered_samples = true, + .ordered_events = true, }, .proc_num = 15, .min_time = 1000000,
tools/perf/builtin-trace.c +1 -1
@@ -2209,7 +2209,7 @@ static int trace__replay(struct trace *trace) trace->tool.tracing_data = perf_event__process_tracing_data; trace->tool.build_id = perf_event__process_build_id; - trace->tool.ordered_samples = true; + trace->tool.ordered_events = true; trace->tool.ordering_requires_timestamps = true;/* add tid to output */
tools/perf/util/session.c +5 -5
@@ -105,9 +105,9 @@ struct perf_session *perf_session__new(struct perf_data_file *file, }if (tool && tool->ordering_requires_timestamps && - tool->ordered_samples && !perf_evlist__sample_id_all (session->evlist)) { + tool->ordered_events && !perf_evlist__sample_id_all (session->evlist)) {dump_printf ("WARNING: No sample_id_all support, falling back to unordered processing\n" ); - tool->ordered_samples = false; + tool->ordered_events = false; }return session;
@@ -240,7 +240,7 @@ void perf_tool__fill_defaults(struct perf_tool *tool)if (tool->build_id ==NULL ) tool->build_id = process_finished_round_stub;if (tool->finished_round ==NULL ) { -if (tool->ordered_samples) +if (tool->ordered_events) tool->finished_round = process_finished_round;else tool->finished_round = process_finished_round_stub;
@@ -485,7 +485,7 @@ static int flush_sample_queue(struct perf_session *s,struct ui_progress prog;int ret; -if (!tool->ordered_samples || !limit) +if (!tool->ordered_events || !limit)return 0 ;if (show_progress)
@@ -1062,7 +1062,7 @@ static int perf_session__process_event(struct perf_session *session,if (ret)return ret; -if (tool->ordered_samples) { +if (tool->ordered_events) { ret =perf_session_queue_event (session, event, &sample, file_offset);if (ret != -ETIME )
tools/perf/util/tool.h +1 -1
@@ -40,7 +40,7 @@ struct perf_tool {event_op2 tracing_data;event_op2 finished_round, build_id; -bool ordered_samples; +bool ordered_events;bool ordering_requires_timestamps; };
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 3/19 perf tools: Rename ordered_samples struct to ordered_events
In reply to Jiri OlsaFollowing up with ordered_samples rename for ordered_samples and sample_queue structs to ordered_events and ordered_event structs respectively.
Also changing flush_sample_queue function name to ordered_events_flush.
No functional change was intended.
--- tools/perf/builtin-kvm.c | 2 +- tools/perf/util/session.c | 116 +++++++++++++++++++++++----------------------- tools/perf/util/session.h | 10 ++-- 3 files changed, 64 insertions(+), 64 deletions(-)
tools/perf/builtin-kvm.c +1 -1
@@ -785,7 +785,7 @@ static int perf_kvm__mmap_read(struct perf_kvm_stat *kvm)/* flush queue after each round in which we processed events */ if (ntotal) { - kvm->session->ordered_samples.next_flush = flush_time; + kvm->session->ordered_events.next_flush = flush_time; err = kvm->tool.finished_round (&kvm->tool,NULL , kvm->session);if (err) {if (kvm->lost_events)
tools/perf/util/session.c +58 -58
232 lines not on this page · raw message
tools/perf/util/session.h +5 -5
@@ -12,19 +12,19 @@#include <linux/rbtree.h> #include <linux/perf_event.h> -struct sample_queue ; +struct ordered_event ;struct ip_callchain ;struct thread ; -struct ordered_samples { +struct ordered_events {u64 last_flush;u64 next_flush;u64 max_timestamp;struct list_head samples;struct list_head sample_cache;struct list_head to_free; -struct sample_queue *sample_buffer; -struct sample_queue *last_sample; +struct ordered_event *sample_buffer; +struct ordered_event *last_sample;int sample_buffer_idx;unsigned int nr_samples; };
@@ -39,7 +39,7 @@ struct perf_session {bool one_mmap;void *one_mmap_addr;u64 one_mmap_offset; -struct ordered_samples ordered_samples; +struct ordered_events ordered_events;struct perf_data_file *file; };
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 4/19 perf tools: Rename ordered_events members
In reply to Jiri OlsaRename 'struct ordered_events_queue' members to fit better the ordered events style.
No functional change was intended.
--- tools/perf/util/session.c | 86 +++++++++++++++++++++++------------------------ tools/perf/util/session.h | 12 +++---- 2 files changed, 48 insertions(+), 50 deletions(-)
tools/perf/util/session.c +42 -44
@@ -76,8 +76,8 @@ struct perf_session *perf_session__new(struct perf_data_file *file, goto out; session->repipe = repipe; -INIT_LIST_HEAD (&session->ordered_events.samples); -INIT_LIST_HEAD (&session->ordered_events.sample_cache); +INIT_LIST_HEAD (&session->ordered_events.events); +INIT_LIST_HEAD (&session->ordered_events.cache);INIT_LIST_HEAD (&session->ordered_events.to_free);machines__init (&session->machines);
@@ -476,11 +476,11 @@ static int ordered_events_flush(struct perf_session *s, struct perf_tool *tool) {struct ordered_events *oe = &s->ordered_events; -struct list_head *head = &oe->samples; +struct list_head *head = &oe->events;struct ordered_event *tmp, *iter;struct perf_sample sample;u64 limit = oe->next_flush; -u64 last_ts = oe->last_sample ? oe->last_sample->timestamp :0ULL ; +u64 last_ts = oe->last ? oe->last->timestamp :0ULL ;bool show_progress = limit ==ULLONG_MAX ;struct ui_progress prog;int ret;
@@ -489,7 +489,7 @@ static int ordered_events_flush(struct perf_session *s,return 0 ;if (show_progress) -ui_progress__init (&prog, oe->nr_samples,"Processing time ordered events..." ); +ui_progress__init (&prog, oe->nr_events,"Processing time ordered events..." );list_for_each_entry_safe (iter, tmp, head, list) {if (session_done ())
@@ -510,19 +510,17 @@ static int ordered_events_flush(struct perf_session *s, oe->last_flush = iter->timestamp;list_del (&iter->list); -list_add (&iter->list, &oe->sample_cache); - oe->nr_samples--; +list_add (&iter->list, &oe->cache); + oe->nr_events--;if (show_progress)ui_progress__update (&prog,1 ); } -if (list_empty (head)) { - oe->last_sample =NULL ; - }else if (last_ts <= limit) { - oe->last_sample = - list_entry(head->prev, struct ordered_event, list); - } +if (list_empty (head)) + oe->last =NULL ; +else if (last_ts <= limit) + oe->last = list_entry(head->prev, struct ordered_event, list);return 0 ; }
@@ -581,45 +579,45 @@ static int process_finished_round(struct perf_tool *tool,static void __queue_event (struct ordered_event *new,struct perf_session *s) {struct ordered_events *oe = &s->ordered_events; -struct ordered_event *sample = oe->last_sample; +struct ordered_event *last = oe->last;u64 timestamp = new->timestamp;struct list_head *p; - ++oe->nr_samples; - oe->last_sample = new; + ++oe->nr_events; + oe->last = new; -if (!sample) { -list_add (&new->list, &oe->samples); +if (!last) { +list_add (&new->list, &oe->events); oe->max_timestamp = timestamp;return ; }/* -* last_sample might point to some random place in the list as it's +* last event might point to some random place in the list as it's * the last queued event. We expect that the new event is close to * this. */ -if (sample->timestamp <= timestamp) { -while (sample->timestamp <= timestamp) { - p = sample->list.next; -if (p == &oe->samples) { -list_add_tail (&new->list, &oe->samples); +if (last->timestamp <= timestamp) { +while (last->timestamp <= timestamp) { + p = last->list.next; +if (p == &oe->events) { +list_add_tail (&new->list, &oe->events); oe->max_timestamp = timestamp;return ; } - sample = list_entry(p, struct ordered_event, list); + last = list_entry(p, struct ordered_event, list); } -list_add_tail (&new->list, &sample->list); +list_add_tail (&new->list, &last->list); }else { -while (sample->timestamp > timestamp) { - p = sample->list.prev; -if (p == &oe->samples) { -list_add (&new->list, &oe->samples); +while (last->timestamp > timestamp) { + p = last->list.prev; +if (p == &oe->events) { +list_add (&new->list, &oe->events);return ; } - sample = list_entry(p, struct ordered_event, list); + last = list_entry(p, struct ordered_event, list); } -list_add (&new->list, &sample->list); +list_add (&new->list, &last->list); } }
@@ -629,7 +627,7 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event, struct perf_sample *sample, u64 file_offset) {struct ordered_events *oe = &s->ordered_events; -struct list_head *sc = &oe->sample_cache; +struct list_head *cache = &oe->cache;u64 timestamp = sample->time;struct ordered_event *new;
@@ -641,20 +639,20 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event,return -EINVAL ; } -if (!list_empty (sc)) { - new = list_entry(sc->next, struct ordered_event, list); +if (!list_empty (cache)) { + new = list_entry(cache->next, struct ordered_event, list);list_del (&new->list); - }else if (oe->sample_buffer) { - new = oe->sample_buffer + oe->sample_buffer_idx; -if (++oe->sample_buffer_idx ==MAX_SAMPLE_BUFFER ) - oe->sample_buffer =NULL ; + }else if (oe->buffer) { + new = oe->buffer + oe->buffer_idx; +if (++oe->buffer_idx ==MAX_SAMPLE_BUFFER ) + oe->buffer =NULL ; }else { - oe->sample_buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); -if (!oe->sample_buffer) + oe->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); +if (!oe->buffer)return -ENOMEM ; -list_add (&oe->sample_buffer->list, &oe->to_free); - oe->sample_buffer_idx =2 ; - new = oe->sample_buffer +1 ; +list_add (&oe->buffer->list, &oe->to_free); + oe->buffer_idx =2 ; + new = oe->buffer +1 ; } new->timestamp = timestamp;
tools/perf/util/session.h +6 -6
@@ -20,13 +20,13 @@ struct ordered_events {u64 last_flush;u64 next_flush;u64 max_timestamp; -struct list_head samples; -struct list_head sample_cache; +struct list_head events; +struct list_head cache;struct list_head to_free; -struct ordered_event *sample_buffer; -struct ordered_event *last_sample; -int sample_buffer_idx; -unsigned int nr_samples; +struct ordered_event *buffer; +struct ordered_event *last; +int buffer_idx; +unsigned int nr_events; };struct perf_session {
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 5/19 perf tools: Add ordered_events_(new|delete) interface
In reply to Jiri OlsaAdding new ordered events interface to new|delete event buffer:
ordered_events_new - allocate event buffer from the cache
ordered_events_delete - return event buffer to the cache
--- tools/perf/util/session.c | 169 +++++++++++++++++++++++++++------------------- 1 file changed, 98 insertions(+), 71 deletions(-)
tools/perf/util/session.c +98 -71
@@ -466,6 +466,100 @@ static void perf_session_free_sample_buffers(struct perf_session *session) } } +/* The queue is ordered by time */ +static void queue_event (struct ordered_events *oe,struct ordered_event *new) +{ +struct ordered_event *last = oe->last; +u64 timestamp = new->timestamp; +struct list_head *p; + + ++oe->nr_events; + oe->last = new; + +if (!last) { +list_add (&new->list, &oe->events); + oe->max_timestamp = timestamp; +return ; + } + +/* +* last event might point to some random place in the list as it's +* the last queued event. We expect that the new event is close to +* this. +*/ +if (last->timestamp <= timestamp) { +while (last->timestamp <= timestamp) { + p = last->list.next; +if (p == &oe->events) { +list_add_tail (&new->list, &oe->events); + oe->max_timestamp = timestamp; +return ; + } + last = list_entry(p, struct ordered_event, list); + } +list_add_tail (&new->list, &last->list); + }else { +while (last->timestamp > timestamp) { + p = last->list.prev; +if (p == &oe->events) { +list_add (&new->list, &oe->events); +return ; + } + last = list_entry(p, struct ordered_event, list); + } +list_add (&new->list, &last->list); + } +} + +#define MAX_SAMPLE_BUFFER (64 * 1024 / sizeof(struct ordered_event)) +static struct ordered_event *alloc_event (struct ordered_events *oe) +{ +struct list_head *cache = &oe->cache; +struct ordered_event *new; + +if (!list_empty (cache)) { + new = list_entry(cache->next, struct ordered_event, list); +list_del (&new->list); + }else if (oe->buffer) { + new = oe->buffer + oe->buffer_idx; +if (++oe->buffer_idx ==MAX_SAMPLE_BUFFER ) + oe->buffer =NULL ; + }else { + oe->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); +if (!oe->buffer) +return NULL ; +list_add (&oe->buffer->list, &oe->to_free); + +/* First entry is abused to maintain the to_free list. */ + oe->buffer_idx =2 ; + new = oe->buffer +1 ; + } + +return new; +} + +static struct ordered_event * +ordered_events_new (struct ordered_events *oe,u64 timestamp) +{ +struct ordered_event *new; + + new =alloc_event (oe); +if (new) { + new->timestamp = timestamp; +queue_event (oe, new); + } + +return new; +} + +static void +ordered_events_delete (struct ordered_events *oe,struct ordered_event *event) +{ +list_del (&event->list); +list_add (&event->list, &oe->cache); + oe->nr_events--; +} + static int perf_session_deliver_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample,
@@ -508,10 +602,8 @@ static int ordered_events_flush(struct perf_session *s,return ret; } +ordered_events_delete (oe, iter); oe->last_flush = iter->timestamp; -list_del (&iter->list); -list_add (&iter->list, &oe->cache); - oe->nr_events--;if (show_progress)ui_progress__update (&prog,1 );
@@ -575,59 +667,10 @@ static int process_finished_round(struct perf_tool *tool,return ret; } -/* The queue is ordered by time */ -static void __queue_event (struct ordered_event *new,struct perf_session *s) -{ -struct ordered_events *oe = &s->ordered_events; -struct ordered_event *last = oe->last; -u64 timestamp = new->timestamp; -struct list_head *p; - - ++oe->nr_events; - oe->last = new; - -if (!last) { -list_add (&new->list, &oe->events); - oe->max_timestamp = timestamp; -return ; - } - -/* -* last event might point to some random place in the list as it's -* the last queued event. We expect that the new event is close to -* this. -*/ -if (last->timestamp <= timestamp) { -while (last->timestamp <= timestamp) { - p = last->list.next; -if (p == &oe->events) { -list_add_tail (&new->list, &oe->events); - oe->max_timestamp = timestamp; -return ; - } - last = list_entry(p, struct ordered_event, list); - } -list_add_tail (&new->list, &last->list); - }else { -while (last->timestamp > timestamp) { - p = last->list.prev; -if (p == &oe->events) { -list_add (&new->list, &oe->events); -return ; - } - last = list_entry(p, struct ordered_event, list); - } -list_add (&new->list, &last->list); - } -} - -#define MAX_SAMPLE_BUFFER (64 * 1024 / sizeof(struct ordered_event)) -int perf_session_queue_event (struct perf_session *s,union perf_event *event,struct perf_sample *sample,u64 file_offset) {struct ordered_events *oe = &s->ordered_events; -struct list_head *cache = &oe->cache;u64 timestamp = sample->time;struct ordered_event *new;
@@ -639,28 +682,12 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event,return -EINVAL ; } -if (!list_empty (cache)) { - new = list_entry(cache->next, struct ordered_event, list); -list_del (&new->list); - }else if (oe->buffer) { - new = oe->buffer + oe->buffer_idx; -if (++oe->buffer_idx ==MAX_SAMPLE_BUFFER ) - oe->buffer =NULL ; - }else { - oe->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); -if (!oe->buffer) -return -ENOMEM ; -list_add (&oe->buffer->list, &oe->to_free); - oe->buffer_idx =2 ; - new = oe->buffer +1 ; - } + new =ordered_events_new (oe, timestamp); +if (!new) +return -ENOMEM ; - new->timestamp = timestamp; new->file_offset = file_offset; new->event = event; - -__queue_event (new, s); -return 0 ; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 6/19 perf tools: Factor ordered_events_flush to be more generic
In reply to Jiri OlsaCentralizing the next_flush calculation under the ordered_events_flush function.
--- tools/perf/util/session.c | 47 ++++++++++++++++++++++++++++++++++++----------- 1 file changed, 36 insertions(+), 11 deletions(-)
tools/perf/util/session.c +36 -11
@@ -453,6 +453,11 @@ struct ordered_event {struct list_head list; }; +enum oe_flush { +OE_FLUSH__FINAL , +OE_FLUSH__ROUND , +}; +static void perf_session_free_sample_buffers (struct perf_session *session) {struct ordered_events *oe = &session->ordered_events;
@@ -566,8 +571,8 @@ static int perf_session_deliver_event(struct perf_session *session,struct perf_tool *tool, u64 file_offset); -static int ordered_events_flush (struct perf_session *s, -struct perf_tool *tool) +static int __ordered_events_flush (struct perf_session *s, +struct perf_tool *tool) {struct ordered_events *oe = &s->ordered_events;struct list_head *head = &oe->events;
@@ -617,6 +622,32 @@ static int ordered_events_flush(struct perf_session *s,return 0 ; } +static int ordered_events_flush (struct perf_session *s,struct perf_tool *tool, +enum oe_flush how) +{ +struct ordered_events *oe = &s->ordered_events; +int err; + +switch (how) { +case OE_FLUSH__FINAL : + oe->next_flush =ULLONG_MAX ; +break ; + +case OE_FLUSH__ROUND : +default : +break ; + }; + + err =__ordered_events_flush (s, tool); + +if (!err) { +if (how ==OE_FLUSH__ROUND ) + oe->next_flush = oe->max_timestamp; + } + +return err; +} +/* * When perf record finishes a pass on every buffers, it records this pseudo * event.
@@ -660,11 +691,7 @@ static int process_finished_round(struct perf_tool *tool,union perf_event *event__maybe_unused , struct perf_session *session) { - int ret = ordered_events_flush(session, tool); -if (!ret) - session->ordered_events.next_flush = session->ordered_events.max_timestamp; - -return ret; + return ordered_events_flush(session, tool, OE_FLUSH__ROUND); } int perf_session_queue_event(struct perf_session *s, union perf_event *event,
@@ -1247,8 +1274,7 @@ more: goto more; done:/* do the final flush for ordered samples */ - session->ordered_events.next_flush =ULLONG_MAX ; - err =ordered_events_flush (session, tool); + err =ordered_events_flush (session, tool,OE_FLUSH__FINAL ); out_err:free (buf);perf_session__warn_about_errors (session, tool);
@@ -1389,8 +1415,7 @@ more: out:/* do the final flush for ordered samples */ - session->ordered_events.next_flush =ULLONG_MAX ; - err =ordered_events_flush (session, tool); + err =ordered_events_flush (session, tool,OE_FLUSH__FINAL ); out_err:ui_progress__finish ();perf_session__warn_about_errors (session, tool);
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 7/19 perf tools: Limit ordered events queue size
In reply to Jiri OlsaAdd limit to the ordered events queue allocation. This way we will be able to control the size of the queue buffers.
There's no limit at the moment (it's set to (u64) -1). The config code will come in following patches.
--- tools/perf/util/session.c | 12 +++++++++--- tools/perf/util/session.h | 2 ++ 2 files changed, 11 insertions(+), 3 deletions(-)
tools/perf/util/session.c +9 -3
@@ -79,6 +79,8 @@ struct perf_session *perf_session__new(struct perf_data_file *file,INIT_LIST_HEAD (&session->ordered_events.events);INIT_LIST_HEAD (&session->ordered_events.cache);INIT_LIST_HEAD (&session->ordered_events.to_free); + session->ordered_events.max_alloc_size = (u64) -1 ; + session->ordered_events.cur_alloc_size =0 ;machines__init (&session->machines);if (file) {
@@ -520,7 +522,7 @@ static void queue_event(struct ordered_events *oe, struct ordered_event *new)static struct ordered_event *alloc_event (struct ordered_events *oe) {struct list_head *cache = &oe->cache; -struct ordered_event *new; +struct ordered_event *new =NULL ;if (!list_empty (cache)) { new = list_entry(cache->next, struct ordered_event, list);
@@ -529,10 +531,14 @@ static struct ordered_event *alloc_event(struct ordered_events *oe) new = oe->buffer + oe->buffer_idx;if (++oe->buffer_idx ==MAX_SAMPLE_BUFFER ) oe->buffer =NULL ; - }else { - oe->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); + }else if (oe->cur_alloc_size < oe->max_alloc_size) { +size_t size =MAX_SAMPLE_BUFFER *sizeof (*new); + + oe->buffer =malloc (size);if (!oe->buffer)return NULL ; + + oe->cur_alloc_size += size;list_add (&oe->buffer->list, &oe->to_free);/* First entry is abused to maintain the to_free list. */
tools/perf/util/session.h +2 -0
@@ -20,6 +20,8 @@ struct ordered_events {u64 last_flush;u64 next_flush;u64 max_timestamp; +u64 max_alloc_size; +u64 cur_alloc_size;struct list_head events;struct list_head cache;struct list_head to_free;
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 8/19 perf tools: Flush ordered events in case of allocation failure
In reply to Jiri OlsaIn previous patches we added a limit for ordered events queue allocation size. If we reach this size we need to flush (part of) the queue to get some free buffers.
The current functionality is not affected, because the limit is hard coded to (u64) -1. The configuration code for size will come in following patches.
--- tools/perf/builtin-kvm.c | 2 +- tools/perf/util/session.c | 29 +++++++++++++++++++++++++++-- tools/perf/util/session.h | 3 ++- 3 files changed, 30 insertions(+), 4 deletions(-)
tools/perf/builtin-kvm.c +1 -1
@@ -732,7 +732,7 @@ static s64 perf_kvm__mmap_read_idx(struct perf_kvm_stat *kvm, int idx,return -1 ; } - err =perf_session_queue_event (kvm->session, event, &sample,0 ); + err =perf_session_queue_event (kvm->session, event, &kvm->tool, &sample,0 );/* * FIXME: Here we can't consume the event, as perf_session_queue_event will * point to it, and it'll get possibly overwritten by the kernel.
tools/perf/util/session.c +27 -2
@@ -15,6 +15,7 @@#include "cpumap.h" #include "perf_regs.h" #include "vdso.h" +#include "asm/bug.h" static int perf_session__open (struct perf_session *session) {
@@ -458,6 +459,7 @@ struct ordered_event {enum oe_flush {OE_FLUSH__FINAL ,OE_FLUSH__ROUND , +OE_FLUSH__HALF , };static void perf_session_free_sample_buffers (struct perf_session *session)
@@ -639,6 +641,23 @@ static int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, oe->next_flush =ULLONG_MAX ;break ; +case OE_FLUSH__HALF : + { +struct ordered_event *first, *last; +struct list_head *head = &oe->events; + + first = list_entry(head->next, struct ordered_event, list); + last = oe->last; + +/* Warn if we are called before any event got allocated. */ +if (WARN_ONCE (!last ||list_empty (head),"empty queue" )) +return 0 ; + + oe->next_flush = first->timestamp; + oe->next_flush += (last->timestamp - first->timestamp) /2 ; +break ; + } +case OE_FLUSH__ROUND :default :break ;
@@ -701,7 +720,8 @@ static int process_finished_round(struct perf_tool *tool, }int perf_session_queue_event (struct perf_session *s,union perf_event *event, -struct perf_sample *sample,u64 file_offset) +struct perf_tool *tool,struct perf_sample *sample, +u64 file_offset) {struct ordered_events *oe = &s->ordered_events;u64 timestamp = sample->time;
@@ -716,6 +736,11 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event, } new =ordered_events_new (oe, timestamp); +if (!new) { +ordered_events_flush (s, tool,OE_FLUSH__HALF ); + new =ordered_events_new (oe, timestamp); + } +if (!new)return -ENOMEM ;
@@ -1121,7 +1146,7 @@ static int perf_session__process_event(struct perf_session *session,return ret;if (tool->ordered_events) { - ret =perf_session_queue_event (session, event, &sample, + ret =perf_session_queue_event (session, event, tool, &sample, file_offset);if (ret != -ETIME )return ret;
tools/perf/util/session.h +2 -1
@@ -67,7 +67,8 @@ int perf_session__process_events(struct perf_session *session, struct perf_tool *tool);int perf_session_queue_event (struct perf_session *s,union perf_event *event, -struct perf_sample *sample,u64 file_offset); +struct perf_tool *tool,struct perf_sample *sample, +u64 file_offset);void perf_tool__fill_defaults (struct perf_tool *tool);
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 9/19 perf tools: Make perf_session_deliver_event global
In reply to Jiri OlsaMaking perf_session_deliver_event global function, as it will be called from another object in following patch.
--- tools/perf/util/session.c | 16 +++++----------- tools/perf/util/session.h | 6 ++++++ 2 files changed, 11 insertions(+), 11 deletions(-)
tools/perf/util/session.c +5 -11
@@ -573,12 +573,6 @@ ordered_events_delete(struct ordered_events *oe, struct ordered_event *event) oe->nr_events--; } -static int perf_session_deliver_event (struct perf_session *session, -union perf_event *event, -struct perf_sample *sample, -struct perf_tool *tool, -u64 file_offset); -static int __ordered_events_flush (struct perf_session *s,struct perf_tool *tool) {
@@ -1005,11 +999,11 @@ perf_session__deliver_sample(struct perf_session *session, &sample->read.one, machine); } -static int perf_session_deliver_event (struct perf_session *session, -union perf_event *event, -struct perf_sample *sample, -struct perf_tool *tool, -u64 file_offset) +int perf_session_deliver_event (struct perf_session *session, +union perf_event *event, +struct perf_sample *sample, +struct perf_tool *tool, +u64 file_offset) {struct perf_evsel *evsel;struct machine *machine;
tools/perf/util/session.h +6 -0
@@ -72,6 +72,12 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event,void perf_tool__fill_defaults (struct perf_tool *tool); +int perf_session_deliver_event (struct perf_session *session, +union perf_event *event, +struct perf_sample *sample, +struct perf_tool *tool, +u64 file_offset); + int perf_session__resolve_callchain(struct perf_session *session, struct perf_evsel *evsel, struct thread *thread,
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 10/19 perf tools: Create ordered-events object
In reply to Jiri OlsaMove ordered events code into separated object ordered-events.[ch].
No functional change was intended.
--- tools/perf/Makefile.perf | 2 + tools/perf/util/ordered-events.c | 196 +++++++++++++++++++++++++++++++++++++ tools/perf/util/ordered-events.h | 41 ++++++++ tools/perf/util/session.c | 206 --------------------------------------- tools/perf/util/session.h | 17 +--- 5 files changed, 240 insertions(+), 222 deletions(-) create mode 100644 tools/perf/util/ordered-events.c create mode 100644 tools/perf/util/ordered-events.h
tools/perf/Makefile.perf +2 -0
@@ -263,6 +263,7 @@ LIB_H += util/xyarray.h LIB_H += util/header.h LIB_H += util/help.h LIB_H += util/session.h +LIB_H += util/ordered-events.h LIB_H += util/strbuf.h LIB_H += util/strlist.h LIB_H += util/strfilter.h
@@ -347,6 +348,7 @@ LIB_OBJS += $(OUTPUT)util/machine.o LIB_OBJS += $(OUTPUT)util/map.o LIB_OBJS += $(OUTPUT)util/pstack.o LIB_OBJS += $(OUTPUT)util/session.o +LIB_OBJS += $(OUTPUT)util/ordered-events.o LIB_OBJS += $(OUTPUT)util/comm.o LIB_OBJS += $(OUTPUT)util/thread.o LIB_OBJS += $(OUTPUT)util/thread_map.o
tools/perf/util/ordered-events.c new file +196 -0
196 lines not on this page · raw message
tools/perf/util/ordered-events.h new file +41 -0
41 lines not on this page · raw message
tools/perf/util/session.c +0 -206
224 lines not on this page · raw message
tools/perf/util/session.h +1 -16
@@ -9,28 +9,13 @@#include "symbol.h" #include "thread.h" #include "data.h" +#include "ordered-events.h" #include <linux/rbtree.h> #include <linux/perf_event.h> -struct ordered_event ;struct ip_callchain ;struct thread ; -struct ordered_events { -u64 last_flush; -u64 next_flush; -u64 max_timestamp; -u64 max_alloc_size; -u64 cur_alloc_size; -struct list_head events; -struct list_head cache; -struct list_head to_free; -struct ordered_event *buffer; -struct ordered_event *last; -int buffer_idx; -unsigned int nr_events; -}; -struct perf_session {struct perf_header header;struct machines machines;
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 11/19 perf tools: Use list_move in ordered_events_delete function
In reply to Jiri OlsaAs Namhyung pointed out we can use list_move in ordered_events_delete.
--- tools/perf/util/ordered-events.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
tools/perf/util/ordered-events.c +1 -2
@@ -96,8 +96,7 @@ ordered_events_new(struct ordered_events *oe, u64 timestamp)void ordered_events_delete (struct ordered_events *oe,struct ordered_event *event) { -list_del (&event->list); -list_add (&event->list, &oe->cache); +list_move (&event->list, &oe->cache); oe->nr_events--; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 12/19 perf tools: Add ordered_events_init function
In reply to Jiri OlsaAdding ordered_events_init function for struct ordered_events struct initialization.
--- tools/perf/util/ordered-events.c | 9 +++++++++ tools/perf/util/ordered-events.h | 1 + tools/perf/util/session.c | 6 +----- 3 files changed, 11 insertions(+), 5 deletions(-)
tools/perf/util/ordered-events.c +9 -0
@@ -193,3 +193,12 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool,return err; } + +void ordered_events_init (struct ordered_events *oe) +{ +INIT_LIST_HEAD (&oe->events); +INIT_LIST_HEAD (&oe->cache); +INIT_LIST_HEAD (&oe->to_free); + oe->max_alloc_size = (u64) -1 ; + oe->cur_alloc_size =0 ; +}
tools/perf/util/ordered-events.h +1 -0
@@ -38,4 +38,5 @@ struct ordered_event *ordered_events_new(struct ordered_events *oe, u64 timestamvoid ordered_events_delete (struct ordered_events *oe,struct ordered_event *event);int ordered_events_flush (struct perf_session *s,struct perf_tool *tool,enum oe_flush how); +void ordered_events_init (struct ordered_events *oe);#endif /* __ORDERED_EVENTS_H */
tools/perf/util/session.c +1 -5
@@ -76,11 +76,7 @@ struct perf_session *perf_session__new(struct perf_data_file *file, goto out; session->repipe = repipe; -INIT_LIST_HEAD (&session->ordered_events.events); -INIT_LIST_HEAD (&session->ordered_events.cache); -INIT_LIST_HEAD (&session->ordered_events.to_free); - session->ordered_events.max_alloc_size = (u64) -1 ; - session->ordered_events.cur_alloc_size =0 ; +ordered_events_init (&session->ordered_events);machines__init (&session->machines);if (file) {
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 13/19 perf tools: Add ordered_events_free function
In reply to Jiri OlsaAdding ordered_events_free function to release all the struct ordered_events data. It's replacement for former perf_session_free_sample_buffers function.
--- tools/perf/util/ordered-events.c | 11 +++++++++++ tools/perf/util/ordered-events.h | 1 + tools/perf/util/session.c | 17 ++--------------- 3 files changed, 14 insertions(+), 15 deletions(-)
tools/perf/util/ordered-events.c +11 -0
@@ -202,3 +202,14 @@ void ordered_events_init(struct ordered_events *oe) oe->max_alloc_size = (u64) -1 ; oe->cur_alloc_size =0 ; } + +void ordered_events_free (struct ordered_events *oe) +{ +while (!list_empty (&oe->to_free)) { +struct ordered_event *event; + + event = list_entry(oe->to_free.next, struct ordered_event, list); +list_del (&event->list); +free (event); + } +}
tools/perf/util/ordered-events.h +1 -0
@@ -39,4 +39,5 @@ void ordered_events_delete(struct ordered_events *oe, struct ordered_event *evenint ordered_events_flush (struct perf_session *s,struct perf_tool *tool,enum oe_flush how);void ordered_events_init (struct ordered_events *oe); +void ordered_events_free (struct ordered_events *oe);#endif /* __ORDERED_EVENTS_H */
tools/perf/util/session.c +2 -15
@@ -444,19 +444,6 @@ static perf_event__swap_op perf_event__swap_ops[] = { [PERF_RECORD_HEADER_MAX] = NULL, }; -static void perf_session_free_sample_buffers (struct perf_session *session) -{ -struct ordered_events *oe = &session->ordered_events; - -while (!list_empty (&oe->to_free)) { -struct ordered_event *event; - - event = list_entry(oe->to_free.next, struct ordered_event, list); -list_del (&event->list); -free (event); - } -} -/* * When perf record finishes a pass on every buffers, it records this pseudo * event.
@@ -1093,7 +1080,7 @@ done: out_err:free (buf);perf_session__warn_about_errors (session, tool); -perf_session_free_sample_buffers (session); +ordered_events_free (&session->ordered_events);return err; }
@@ -1234,7 +1221,7 @@ out: out_err:ui_progress__finish ();perf_session__warn_about_errors (session, tool); -perf_session_free_sample_buffers (session); +ordered_events_free (&session->ordered_events); session->one_mmap = false;return err; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 14/19 perf tools: Add perf_config_u64 function
In reply to Jiri OlsaAdding perf_config_u64 function to be able to parse 'llong' values out of config file.
--- tools/perf/util/cache.h | 1 + tools/perf/util/config.c | 24 ++++++++++++++++++++++++ 2 files changed, 25 insertions(+)
tools/perf/util/cache.h +1 -0
@@ -22,6 +22,7 @@ typedef int (*config_fn_t)(const char *, const char *, void *);extern int perf_default_config (const char *,const char *,void *);extern int perf_config (config_fn_t fn,void *);extern int perf_config_int (const char *,const char *); +extern u64 perf_config_u64 (const char *,const char *);extern int perf_config_bool (const char *,const char *);extern int config_error_nonbool (const char *);extern const char *perf_config_dirname (const char *,const char *);
tools/perf/util/config.c +24 -0
@@ -286,6 +286,21 @@ static int parse_unit_factor(const char *end, unsigned long *val)return 0 ; } +static int perf_parse_llong (const char *value,long long *ret) +{ +if (value && *value) { +char *end; +long long val =strtoll (value, &end,0 ); +unsigned long factor =1 ; + +if (!parse_unit_factor (end, &factor)) +return 0 ; + *ret = val * factor; +return 1 ; + } +return 0 ; +} +static int perf_parse_long (const char *value,long *ret) {if (value && *value) {
@@ -307,6 +322,15 @@ static void die_bad_config(const char *name)die ("bad config value for '%s'" , name); } +u64 perf_config_u64 (const char *name,const char *value) +{ +long long ret =0 ; + +if (!perf_parse_llong (value, &ret)) +die_bad_config (name); +return (u64 ) ret; +} +int perf_config_int (const char *name,const char *value) {long ret =0 ;
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 15/19 perf tools: Add report.queue-size config file option
In reply to Jiri OlsaAdding report.queue-size config file option to setup the maximum allocation size for session's struct ordered_events_queue object.
--- tools/perf/builtin-report.c | 13 ++++++++++++- tools/perf/util/ordered-events.h | 6 ++++++ 2 files changed, 18 insertions(+), 1 deletion(-)
tools/perf/builtin-report.c +12 -1
@@ -58,17 +58,19 @@ struct report {const char *symbol_filter_str;float min_percent;u64 nr_entries; +u64 queue_size;DECLARE_BITMAP (cpu_bitmap,MAX_NR_CPUS ); };static int report__config (const char *var,const char *value,void *cb) { +struct report *rep = cb; +if (!strcmp (var,"report.group" )) { symbol_conf.event_group =perf_config_bool (var, value);return 0 ; }if (!strcmp (var,"report.percent-limit" )) { -struct report *rep = cb; rep->min_percent =strtof (value,NULL );return 0 ; }
@@ -76,6 +78,10 @@ static int report__config(const char *var, const char *value, void *cb) symbol_conf.cumulate_callchain =perf_config_bool (var, value);return 0 ; } +if (!strcmp (var,"report.queue-size" )) { + rep->queue_size =perf_config_u64 (var, value); +return 0 ; + }return perf_default_config (var, value, cb); }
@@ -714,6 +720,11 @@ repeat:if (session ==NULL )return -ENOMEM ; +if (report.queue_size) { +ordered_events_alloc_size (&session->ordered_events, + report.queue_size); + } + report.session = session; has_br_stack = perf_header__has_feat(&session->header,
tools/perf/util/ordered-events.h +6 -0
@@ -40,4 +40,10 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, enum oe_flush how);void ordered_events_init (struct ordered_events *oe);void ordered_events_free (struct ordered_events *oe); + +static inline void +ordered_events_alloc_size (struct ordered_events *oe,u64 size) +{ + oe->max_alloc_size = size; +}#endif /* __ORDERED_EVENTS_H */
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 16/19 perf tools: Add debug prints for ordered events queue
In reply to Jiri OlsaAdding some prints for ordered events queue, to help debug issues.
Adding debug_ordered_events debug variable to be able to enable ordered events debug messages using:
$ perf --debug ordered-events=2 report ...
Also using oe pointer in perf_session_queue_event instead of chained session variable dereferencing.
--- tools/perf/util/debug.c | 36 +++++++++++++++++++++++++++++++++++- tools/perf/util/debug.h | 8 ++++++++ tools/perf/util/ordered-events.c | 26 ++++++++++++++++++++++++++ tools/perf/util/session.c | 4 +++- 4 files changed, 72 insertions(+), 2 deletions(-)
tools/perf/util/debug.c +35 -1
@@ -13,8 +13,12 @@#include "util.h" #include "target.h" +#define NSECS_PER_SEC 1000000000ULL +#define NSECS_PER_USEC 1000ULL +int verbose;bool dump_trace = false, quiet = false; +int debug_ordered_events;static int _eprintf (int level,int var,const char *fmt,va_list args) {
@@ -42,6 +46,35 @@ int eprintf(int level, int var, const char *fmt, ...)return ret; } +static int __eprintf_time (u64 t,const char *fmt,va_list args) +{ +int ret =0 ; +u64 secs, usecs, nsecs = t; + + secs = nsecs /NSECS_PER_SEC ; + nsecs -= secs *NSECS_PER_SEC ; + usecs = nsecs /NSECS_PER_USEC ; + + ret =fprintf (stderr,"[%13" PRIu64".%06" PRIu64"] " , + secs, usecs); + ret +=vfprintf (stderr, fmt, args); +return ret; +} + +int eprintf_time (int level,int var,u64 t,const char *fmt, ...) +{ +int ret =0 ; +va_list args; + +if (var >= level) { +va_start (args, fmt); + ret =__eprintf_time (t, fmt, args); +va_end (args); + } + +return ret; +} +/* * Overloading libtraceevent standard info print * function, display with -v in perf.
@@ -110,7 +143,8 @@ static struct debug_variable {const char *name;int *ptr; } debug_variables[] = { - { .name = "verbose", .ptr = &verbose }, + { .name = "verbose", .ptr = &verbose }, + { .name = "ordered-events", .ptr = &debug_ordered_events}, { .name = NULL, } };
tools/perf/util/debug.h +8 -0
@@ -10,6 +10,7 @@extern int verbose;extern bool quiet, dump_trace; +extern int debug_ordered_events;#ifndef pr_fmt#define pr_fmt (fmt) fmt
@@ -29,6 +30,12 @@ extern bool quiet, dump_trace;#define pr_debug3 (fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)#define pr_debug4 (fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__) +#define pr_time_N (n, var, t, fmt, ...) \ + eprintf_time(n, var, t, fmt, ##__VA_ARGS__) + +#define pr_oe_time (t, fmt, ...) pr_time_N(1, debug_ordered_events, t, pr_fmt(fmt), ##__VA_ARGS__) +#define pr_oe_time2 (t, fmt, ...) pr_time_N(2, debug_ordered_events, t, pr_fmt(fmt), ##__VA_ARGS__) +int dump_printf (const char *fmt, ...) __attribute__((format (printf,1 ,2 )));void trace_event (union perf_event *event);
@@ -38,6 +45,7 @@ int ui__warning(const char *format, ...) __attribute__((format(printf, 1, 2)));void pr_stat (const char *fmt, ...);int eprintf (int level,int var,const char *fmt, ...) __attribute__((format (printf,3 ,4 ))); +int eprintf_time (int level,int var,u64 t,const char *fmt, ...) __attribute__((format (printf,4 ,5 )));int perf_debug_option (const char *str);
tools/perf/util/ordered-events.c +26 -0
@@ -1,10 +1,16 @@#include <linux/list.h> +#include <linux/compiler.h> #include "ordered-events.h" #include "evlist.h" #include "session.h" #include "asm/bug.h" #include "debug.h" +#define pr_N (n, fmt, ...) \ + eprintf(n, debug_ordered_events, fmt, ##__VA_ARGS__) + +#define pr (fmt, ...) pr_N(1, pr_fmt(fmt), ##__VA_ARGS__) +static void queue_event (struct ordered_events *oe,struct ordered_event *new) {struct ordered_event *last = oe->last;
@@ -14,6 +20,8 @@ static void queue_event(struct ordered_events *oe, struct ordered_event *new) ++oe->nr_events; oe->last = new; +pr_oe_time2 (timestamp,"queue_event nr_events %u\n" , oe->nr_events); +if (!last) {list_add (&new->list, &oe->events); oe->max_timestamp = timestamp;
@@ -69,12 +77,17 @@ static struct ordered_event *alloc_event(struct ordered_events *oe)if (!oe->buffer)return NULL ; +pr ("alloc size %" PRIu64"B (+%zu), max %" PRIu64"B\n" , + oe->cur_alloc_size, size, oe->max_alloc_size); + oe->cur_alloc_size += size;list_add (&oe->buffer->list, &oe->to_free);/* First entry is abused to maintain the to_free list. */ oe->buffer_idx =2 ; new = oe->buffer +1 ; + }else { +pr ("allocation limit reached %" PRIu64"B\n" , oe->max_alloc_size); }return new;
@@ -155,6 +168,11 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, enum oe_flush how) {struct ordered_events *oe = &s->ordered_events; +static const char *const str[] = { +"FINAL" , +"ROUND" , +"HALF " , + };int err;switch (how) {
@@ -184,6 +202,10 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool,break ; }; +pr_oe_time (oe->next_flush,"next_flush - ordered_events_flush PRE %s, nr_events %u\n" , + str[how], oe->nr_events); +pr_oe_time (oe->max_timestamp,"max_timestamp\n" ); + err =__ordered_events_flush (s, tool);if (!err) {
@@ -191,6 +213,10 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, oe->next_flush = oe->max_timestamp; } +pr_oe_time (oe->next_flush,"next_flush - ordered_events_flush POST %s, nr_events %u\n" , + str[how], oe->nr_events); +pr_oe_time (oe->last_flush,"last_flush\n" ); +return err; }
tools/perf/util/session.c +3 -1
@@ -501,8 +501,10 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event,if (!timestamp || timestamp == ~0ULL )return -ETIME ; -if (timestamp < s->ordered_events.last_flush) { +if (timestamp < oe->last_flush) {printf ("Warning: Timestamp below last timeslice flush\n" ); +pr_oe_time (timestamp,"out of order event" ); +pr_oe_time (oe->last_flush,"last flush" );return -EINVAL ; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v4 17/19 perf tools: Always force PERF_RECORD_FINISHED_ROUND event
In reply to Jiri OlsaThe PERF_RECORD_FINISHED_ROUND governs queue flushing in reporting, so it needs to be stored for any kind of event.
Forcing the PERF_RECORD_FINISHED_ROUND event to be stored for all event types.
--- tools/perf/builtin-record.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
tools/perf/builtin-record.c +1 -2
@@ -250,8 +250,7 @@ static int record__mmap_read_all(struct record *rec) } } -if (perf_header__has_feat (&rec->session->header,HEADER_TRACING_DATA )) - rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); + rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); out:return rc;
Signature · 1 line
1.8.3.1
tip-bot for Jiri Olsa
merge bot[tip:perf/core] perf record: Always force PERF_RECORD_FINISHED_ROUND event
perf record: Always force PERF_RECORD_FINISHED_ROUND event
Commit-ID: 33bf7481971a622a2b8c8aaa0e5e61a6eaeecd71 Gitweb: http://git.kernel.org/tip/33bf7481971a622a2b8c8aaa0e5e61a6eaeecd71 Author: Jiri Olsa <[email protected]> AuthorDate: Fri, 25 Jul 2014 16:56:15 +0200 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Fri, 25 Jul 2014 12:13:05 -0300
perf record: Always force PERF_RECORD_FINISHED_ROUND event
The PERF_RECORD_FINISHED_ROUND synthetic record governs queue flushing in reporting, so it needs to be stored for any kind of event.
The lack of such periodic flushing made the tools use more memory than needed, as the reordering was being done only after processing all events. This was the case when no tracepoints were in the mix.
Forcing the PERF_RECORD_FINISHED_ROUND event to be stored for all event types.
--- tools/perf/builtin-record.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
tools/perf/builtin-record.c +1 -2
@@ -250,8 +250,7 @@ static int record__mmap_read_all(struct record *rec) } } -if (perf_header__has_feat (&rec->session->header,HEADER_TRACING_DATA )) - rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); + rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); out:return rc;
Jiri Olsa
reviewerPATCH v4 18/19 perf tools: Store PERF_RECORD_FINISHED_ROUND only for nonempty rounds
In reply to Jiri OlsaCurrently we store PERF_RECORD_FINISHED_ROUND event each time we go throught mmap buffers no matter if it contains any data, which is useless.
Forcing the PERF_RECORD_FINISHED_ROUND event to be stored any time we finished the round AND wrote at least one event.
--- tools/perf/builtin-record.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
tools/perf/builtin-record.c +7 -1
@@ -238,6 +238,7 @@ static struct perf_event_header finished_round_event = {static int record__mmap_read_all (struct record *rec) { +u64 bytes_written = rec->bytes_written;int i;int rc =0 ;
@@ -250,7 +251,12 @@ static int record__mmap_read_all(struct record *rec) } } - rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); +/* +* Mark the round finished in case we wrote +* at least one event. +*/ +if (bytes_written != rec->bytes_written) + rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); out:return rc;
Signature · 1 line
1.8.3.1
tip-bot for Jiri Olsa
merge bot[tip:perf/core] perf record: Store PERF_RECORD_FINISHED_ROUND only for nonempty rounds
perf record: Store PERF_RECORD_FINISHED_ROUND only for nonempty rounds
Commit-ID: dcabb507fd3a2b19aed6b4068e2a954f5fd8de45 Gitweb: http://git.kernel.org/tip/dcabb507fd3a2b19aed6b4068e2a954f5fd8de45 Author: Jiri Olsa <[email protected]> AuthorDate: Fri, 25 Jul 2014 16:56:16 +0200 Committer: Arnaldo Carvalho de Melo <[email protected]> CommitDate: Fri, 25 Jul 2014 12:17:36 -0300
perf record: Store PERF_RECORD_FINISHED_ROUND only for nonempty rounds
Currently we store PERF_RECORD_FINISHED_ROUND event each time we go throught mmap buffers no matter if it contains any data, which is useless.
Forcing the PERF_RECORD_FINISHED_ROUND event to be stored any time we finished the round AND wrote at least one event.
--- tools/perf/builtin-record.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
tools/perf/builtin-record.c +7 -1
@@ -238,6 +238,7 @@ static struct perf_event_header finished_round_event = {static int record__mmap_read_all (struct record *rec) { +u64 bytes_written = rec->bytes_written;int i;int rc =0 ;
@@ -250,7 +251,12 @@ static int record__mmap_read_all(struct record *rec) } } - rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); +/* +* Mark the round finished in case we wrote +* at least one event. +*/ +if (bytes_written != rec->bytes_written) + rc =record__write (rec, &finished_round_event,sizeof (finished_round_event)); out:return rc;
Jiri Olsa
reviewerPATCH v4 19/19 perf tools: Allow out of order messages in forced flush
In reply to Jiri OlsaIn forced flush (OE_FLUSH__HALF) we break the rules of the flush timestamp via PERF_RECORD_FINISHED_ROUND event, so we could get out of order event.
Do not force error in this case plus changing the
output warning to use WARN_ONCE.
--- tools/perf/util/ordered-events.c | 4 ++++ tools/perf/util/ordered-events.h | 2 ++ tools/perf/util/session.c | 12 +++++++++--- 3 files changed, 15 insertions(+), 3 deletions(-)
tools/perf/util/ordered-events.c +4 -0
@@ -169,6 +169,7 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, {struct ordered_events *oe = &s->ordered_events;static const char *const str[] = { +"NONE" ,"FINAL" ,"ROUND" ,"HALF " ,
@@ -198,6 +199,7 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, }case OE_FLUSH__ROUND : +case OE_FLUSH__NONE :default :break ; };
@@ -211,6 +213,8 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool,if (!err) {if (how ==OE_FLUSH__ROUND ) oe->next_flush = oe->max_timestamp; + + oe->last_flush_type = how; } pr_oe_time(oe->next_flush, "next_flush - ordered_events_flush POST %s, nr_events %u\n",
tools/perf/util/ordered-events.h +2 -0
@@ -14,6 +14,7 @@ struct ordered_event { };enum oe_flush { +OE_FLUSH__NONE ,OE_FLUSH__FINAL ,OE_FLUSH__ROUND ,OE_FLUSH__HALF ,
@@ -32,6 +33,7 @@ struct ordered_events {struct ordered_event *last;int buffer_idx;unsigned int nr_events; +enum oe_flush last_flush_type; };struct ordered_event *ordered_events_new (struct ordered_events *oe,u64 timestamp);
tools/perf/util/session.c +9 -3
@@ -15,6 +15,7 @@#include "cpumap.h" #include "perf_regs.h" #include "vdso.h" +#include "asm/bug.h" static int perf_session__open (struct perf_session *session) {
@@ -502,10 +503,15 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event,return -ETIME ;if (timestamp < oe->last_flush) { -printf ("Warning: Timestamp below last timeslice flush\n" ); +WARN_ONCE (1 ,"Timestamp below last timeslice flush\n" ); +pr_oe_time (timestamp,"out of order event" ); -pr_oe_time (oe->last_flush,"last flush" ); -return -EINVAL ; +pr_oe_time (oe->last_flush,"last flush, last_flush_type %d\n" , + oe->last_flush_type); + +/* We could get out of order messages after forced flush. */ +if (oe->last_flush_type !=OE_FLUSH__HALF ) +return -EINVAL ; } new =ordered_events_new (oe, timestamp);
Signature · 1 line
1.8.3.1