perf tools: Factor ordered samples queue
Jiri Olsa
reviewerv2 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.
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 (18):
perf tools: Always force PERF_RECORD_FINISHED_ROUND event perf tools: Fix accounting of ordered samples queue perf tools: Rename ordered_samples to ordered_events perf tools: Rename ordered_events_queue members perf tools: Add ordered_events_(get|put) 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_event_put function perf tools: Add ordered_events_queue_init function perf tools: Add ordered_events_queue_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: Limit the ordered events queue by default to 100MB 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 | 19 ++++- 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/ordered-events.c | 273 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/ordered-events.h | 55 +++++++++++++++ tools/perf/util/session.c | 213 +++++++++---------------------------------------------- tools/perf/util/session.h | 40 +++++------ tools/perf/util/tool.h | 2 +- 21 files changed, 444 insertions(+), 220 deletions(-) create mode 100644 tools/perf/util/ordered-events.c create mode 100644 tools/perf/util/ordered-events.h
Jiri Olsa
reviewerPATCH v2 1/18 perf tools: Always force PERF_RECORD_FINISHED_ROUND event
The 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 any time we finish the round and wrote at least one event.
--- tools/perf/builtin-record.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
tools/perf/builtin-record.c +6 -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,11 @@ static int record__mmap_read_all(struct record *rec) } } -if (perf_header__has_feat (&rec->session->header,HEADER_TRACING_DATA )) +/* +* 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:
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v2 2/18 perf tools: Fix accounting of ordered samples queue
In reply to Jiri OlsaProperly 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 v2 3/18 perf tools: Rename ordered_samples to ordered_events
In reply to Jiri OlsaThe time ordering is generic for all kinds of events, so using generic name 'ordered_events' for related struct.
--- 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 | 6 ++-- 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 | 64 +++++++++++++++++++++--------------------- tools/perf/util/session.h | 24 ++++++++-------- tools/perf/util/tool.h | 2 +- 15 files changed, 59 insertions(+), 59 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 +3 -3
@@ -955,7 +955,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)
@@ -1228,7 +1228,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,
@@ -1480,7 +1480,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
@@ -1660,7 +1660,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
@@ -1279,7 +1279,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, };
tools/perf/builtin-trace.c +1 -1
@@ -2068,7 +2068,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 +32 -32
182 lines not on this page · raw message
tools/perf/util/session.h +12 -12
@@ -12,32 +12,32 @@#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_queue {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; };struct perf_session { -struct perf_header header; -struct machines machines; -struct perf_evlist *evlist; -struct trace_event tevent; -struct events_stats stats; -bool repipe; -struct ordered_samples ordered_samples; -struct perf_data_file *file; +struct perf_header header; +struct machines machines; +struct perf_evlist *evlist; +struct trace_event tevent; +struct events_stats stats; +bool repipe; +struct ordered_events_queue ordered_events; +struct perf_data_file *file; };#define PRINT_IP_OPT_IP (1<<0)
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 v2 4/18 perf tools: Rename ordered_events_queue members
In reply to Jiri OlsaRename 'struct ordered_events_queue' members to better fit the ordered events pattern.
--- tools/perf/util/session.c | 108 +++++++++++++++++++++++----------------------- tools/perf/util/session.h | 12 +++--- 2 files changed, 59 insertions(+), 61 deletions(-)
tools/perf/util/session.c +53 -55
@@ -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);
@@ -455,12 +455,12 @@ struct ordered_event {static void perf_session_free_sample_buffers (struct perf_session *session) { -struct ordered_events_queue *os = &session->ordered_events; +struct ordered_events_queue *q = &session->ordered_events; -while (!list_empty (&os->to_free)) { +while (!list_empty (&q->to_free)) {struct ordered_event *sq; - sq = list_entry(os->to_free.next, struct ordered_event, list); + sq = list_entry(q->to_free.next, struct ordered_event, list);list_del (&sq->list);free (sq); }
@@ -475,12 +475,12 @@ static int perf_session_deliver_event(struct perf_session *session,static int ordered_events_flush (struct perf_session *s,struct perf_tool *tool) { -struct ordered_events_queue *os = &s->ordered_events; -struct list_head *head = &os->samples; +struct ordered_events_queue *q = &s->ordered_events; +struct list_head *head = &q->events;struct ordered_event *tmp, *iter;struct perf_sample sample; -u64 limit = os->next_flush; -u64 last_ts = os->last_sample ? os->last_sample->timestamp :0ULL ; +u64 limit = q->next_flush; +u64 last_ts = q->last ? q->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, os->nr_samples,"Processing time ordered events..." ); +ui_progress__init (&prog, q->nr_events,"Processing time ordered events..." );list_for_each_entry_safe (iter, tmp, head, list) {if (session_done ())
@@ -508,21 +508,19 @@ static int ordered_events_flush(struct perf_session *s,return ret; } - os->last_flush = iter->timestamp; + q->last_flush = iter->timestamp;list_del (&iter->list); -list_add (&iter->list, &os->sample_cache); - os->nr_samples--; +list_add (&iter->list, &q->cache); + q->nr_events--;if (show_progress)ui_progress__update (&prog,1 ); } -if (list_empty (head)) { - os->last_sample =NULL ; - }else if (last_ts <= limit) { - os->last_sample = - list_entry(head->prev, struct ordered_event, list); - } +if (list_empty (head)) + q->last =NULL ; +else if (last_ts <= limit) + q->last = list_entry(head->prev, struct ordered_event, list);return 0 ; }
@@ -580,46 +578,46 @@ static int process_finished_round(struct perf_tool *tool,/* The queue is ordered by time */ static void __queue_event (struct ordered_event *new,struct perf_session *s) { -struct ordered_events_queue *os = &s->ordered_events; -struct ordered_event *sample = os->last_sample; +struct ordered_events_queue *q = &s->ordered_events; +struct ordered_event *last = q->last;u64 timestamp = new->timestamp;struct list_head *p; - ++os->nr_samples; - os->last_sample = new; + ++q->nr_events; + q->last = new; -if (!sample) { -list_add (&new->list, &os->samples); - os->max_timestamp = timestamp; +if (!last) { +list_add (&new->list, &q->events); + q->max_timestamp = timestamp;return ; }/* -* last_sample 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 +* 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 clqe to * this. */ -if (sample->timestamp <= timestamp) { -while (sample->timestamp <= timestamp) { - p = sample->list.next; -if (p == &os->samples) { -list_add_tail (&new->list, &os->samples); - os->max_timestamp = timestamp; +if (last->timestamp <= timestamp) { +while (last->timestamp <= timestamp) { + p = last->list.next; +if (p == &q->events) { +list_add_tail (&new->list, &q->events); + q->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 == &os->samples) { -list_add (&new->list, &os->samples); +while (last->timestamp > timestamp) { + p = last->list.prev; +if (p == &q->events) { +list_add (&new->list, &q->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); } }
@@ -628,8 +626,8 @@ static void __queue_event(struct ordered_event *new, struct perf_session *s)int perf_session_queue_event (struct perf_session *s,union perf_event *event,struct perf_sample *sample,u64 file_offset) { -struct ordered_events_queue *os = &s->ordered_events; -struct list_head *sc = &os->sample_cache; +struct ordered_events_queue *q = &s->ordered_events; +struct list_head *cache = &q->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 (os->sample_buffer) { - new = os->sample_buffer + os->sample_buffer_idx; -if (++os->sample_buffer_idx ==MAX_SAMPLE_BUFFER ) - os->sample_buffer =NULL ; + }else if (q->buffer) { + new = q->buffer + q->buffer_idx; +if (++q->buffer_idx ==MAX_SAMPLE_BUFFER ) + q->buffer =NULL ; }else { - os->sample_buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); -if (!os->sample_buffer) + q->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); +if (!q->buffer)return -ENOMEM ; -list_add (&os->sample_buffer->list, &os->to_free); - os->sample_buffer_idx =2 ; - new = os->sample_buffer +1 ; +list_add (&q->buffer->list, &q->to_free); + q->buffer_idx =2 ; + new = q->buffer +1 ; } new->timestamp = timestamp;
tools/perf/util/session.h +6 -6
@@ -20,13 +20,13 @@ struct ordered_events_queue {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 v2 5/18 perf tools: Add ordered_events_(get|put) interface
In reply to Jiri OlsaAdding new ordered events interface to get|put event buffer:
ordered_events_get - allocate event buffer from the cache ordered_events_put - return event buffer to the cache
--- tools/perf/util/session.c | 170 +++++++++++++++++++++++++++------------------- 1 file changed, 99 insertions(+), 71 deletions(-)
tools/perf/util/session.c +99 -71
@@ -466,6 +466,101 @@ static void perf_session_free_sample_buffers(struct perf_session *session) } } +/* The queue is ordered by time */ +static void queue_event (struct ordered_events_queue *q,struct ordered_event *new) +{ +struct ordered_event *last = q->last; +u64 timestamp = new->timestamp; +struct list_head *p; + + ++q->nr_events; + q->last = new; + +if (!last) { +list_add (&new->list, &q->events); + q->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 clqe to +* this. +*/ +if (last->timestamp <= timestamp) { +while (last->timestamp <= timestamp) { + p = last->list.next; +if (p == &q->events) { +list_add_tail (&new->list, &q->events); + q->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 == &q->events) { +list_add (&new->list, &q->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_queue *q) +{ +struct list_head *cache = &q->cache; +struct ordered_event *new; + +if (!list_empty (cache)) { + new = list_entry(cache->next, struct ordered_event, list); +list_del (&new->list); + }else if (q->buffer) { + new = q->buffer + q->buffer_idx; +if (++q->buffer_idx ==MAX_SAMPLE_BUFFER ) + q->buffer =NULL ; + }else { + q->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); +if (!q->buffer) +return NULL ; +list_add (&q->buffer->list, &q->to_free); + +/* First entry is abused to maintain the to_free list. */ + q->buffer_idx =2 ; + new = q->buffer +1 ; + } + +return new; +} + +static struct ordered_event * +ordered_events_get (struct ordered_events_queue *q,u64 timestamp) +{ +struct ordered_event *new; + + new =alloc_event (q); +if (new) { + new->timestamp = timestamp; +queue_event (q, new); + } + +return new; +} + +static void +ordered_event_put (struct ordered_events_queue *q,struct ordered_event *iter) +{ +list_del (&iter->list); +list_add (&iter->list, &q->cache); + q->nr_events--; +} + + static int perf_session_deliver_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample,
@@ -508,10 +603,8 @@ static int ordered_events_flush(struct perf_session *s,return ret; } +ordered_event_put (q, iter); q->last_flush = iter->timestamp; -list_del (&iter->list); -list_add (&iter->list, &q->cache); - q->nr_events--;if (show_progress)ui_progress__update (&prog,1 );
@@ -575,59 +668,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_queue *q = &s->ordered_events; -struct ordered_event *last = q->last; -u64 timestamp = new->timestamp; -struct list_head *p; - - ++q->nr_events; - q->last = new; - -if (!last) { -list_add (&new->list, &q->events); - q->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 clqe to -* this. -*/ -if (last->timestamp <= timestamp) { -while (last->timestamp <= timestamp) { - p = last->list.next; -if (p == &q->events) { -list_add_tail (&new->list, &q->events); - q->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 == &q->events) { -list_add (&new->list, &q->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_queue *q = &s->ordered_events; -struct list_head *cache = &q->cache;u64 timestamp = sample->time;struct ordered_event *new;
@@ -639,28 +683,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 (q->buffer) { - new = q->buffer + q->buffer_idx; -if (++q->buffer_idx ==MAX_SAMPLE_BUFFER ) - q->buffer =NULL ; - }else { - q->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); -if (!q->buffer) -return -ENOMEM ; -list_add (&q->buffer->list, &q->to_free); - q->buffer_idx =2 ; - new = q->buffer +1 ; - } + new =ordered_events_get (q, 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
Re: [PATCH 05/18] perf tools: Add ordered_events_(get|put) interface
Quoted 4 lines · Jiri Olsa
tools/perf/util/session.c +3
-0+static struct ordered_event * +ordered_events_get (struct ordered_events_queue *q,u64 timestamp) +{
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 553
Quoted 10 lines
tools/perf/util/session.c +10
-0+struct ordered_event *new; + + new =alloc_event (q); +if (new) { + new->timestamp = timestamp; +queue_event (q, new); + } + +return new; +}
The _get name does not really correlate with what is happening -- ie., allocate a new event and add it to the queue. There is no reference taken either.
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 561
Quoted 8 lines
tools/perf/util/session.c +8
-0+ +static void +ordered_event_put (struct ordered_events_queue *q,struct ordered_event *iter) +{ +list_del (&iter->list); +list_add (&iter->list, &q->cache); + q->nr_events--; +}
Similarly here with the _put. In this case the function is moving the event from one list to another. And how about something else for the name besides iter -- oe, or oevent?
David
Re: [PATCH 05/18] perf tools: Add ordered_events_(get|put) interface
Quoted 11 lines · David Ahern
Quoted 10 lines · Jiri Olsa
tools/perf/util/session.c +9
-0+static struct ordered_event * +ordered_events_get (struct ordered_events_queue *q,u64 timestamp) +{ +struct ordered_event *new; + + new =alloc_event (q); +if (new) { + new->timestamp = timestamp; +queue_event (q, new);
Quoted 8 lines
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 539
Quoted 4 lines
tools/perf/util/session.c +4
-0+ } + +return new; +}The
_getname does not really correlate with what is happening -- ie., allocate a new event and add it to the queue. There is no reference taken either.
ook.. so how about ordered_events_alloc ordered_events_free
Quoted 13 lines
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 561
Quoted 9 lines
tools/perf/util/session.c +8
-0+ +static void +ordered_event_put (struct ordered_events_queue *q,struct ordered_event *iter) +{ +list_del (&iter->list); +list_add (&iter->list, &q->cache); + q->nr_events--; +}Similarly here with the
_put. In this case the function is moving the event from one list to another. And how about something else for the name besides iter -- oe, or oevent?
how about 'event' ?
jirka
Re: [PATCH 05/18] perf tools: Add ordered_events_(get|put) interface
Quoted 37 lines · Jiri Olsa
Quoted 11 lines · David Ahern
Quoted 10 lines · Jiri Olsa
tools/perf/util/session.c +9
-0+static struct ordered_event * +ordered_events_get (struct ordered_events_queue *q,u64 timestamp) +{ +struct ordered_event *new; + + new =alloc_event (q); +if (new) { + new->timestamp = timestamp; +queue_event (q, new);Quoted 8 lines
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 539
Quoted 4 lines
tools/perf/util/session.c +4
-0+ } + +return new; +}The
_getname does not really correlate with what is happening -- ie., allocate a new event and add it to the queue. There is no reference taken either.ook.. so how about
ordered_events_allocordered_events_freeQuoted 13 lines
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 561
Quoted 9 lines
tools/perf/util/session.c +8
-0+ +static void +ordered_event_put (struct ordered_events_queue *q,struct ordered_event *iter) +{ +list_del (&iter->list); +list_add (&iter->list, &q->cache); + q->nr_events--; +}Similarly here with the
_put. In this case the function is moving the event from one list to another. And how about something else for the name besides iter -- oe, or oevent?
Quoted 1 line
how about 'event' ?
Already a heavily used keyword in perf, that's why I was thinking oe or oevent -- besides it is a struct ordered_event not an event.
The bigger thing to me with this patch is the _get/_put names.
David
Arnaldo Carvalho de Melo
maintainerRe: [PATCH 05/18] perf tools: Add ordered_events_(get|put) interface
Em Sun, Jun 29, 2014 at 10:50:24AM -0600, David Ahern escreveu:
Quoted 21 lines · Jiri Olsa
Quoted 19 lines · David Ahern
Quoted 18 lines · Jiri Olsa
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 553
Quoted 13 lines
tools/perf/util/session.c +13
-0+static struct ordered_event * +ordered_events_get (struct ordered_events_queue *q,u64 timestamp) +{ +struct ordered_event *new; + + new =alloc_event (q); +if (new) { + new->timestamp = timestamp; +queue_event (q, new); + } + +return new; +}The
_getname does not really correlate with what is happening -- ie., allocate a new event and add it to the queue. There is no reference taken either.
Quoted 1 line
Quoted 1 line
ook.. so how about
ordered_events_allocordered_events_free
ordered_events__new() and ordered_events__delete(), to be consistent with general naming for constructors and destructors in tools/perf/ :-)
I would also not use "new" as the name of the new instance, as above, but would rather use 'oe', shortcut for ordered event, or even oevent, as elsewhere suggested in this thread.
Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 561
Quoted 7 lines
tools/perf/util/session.c +7
-0+static void +ordered_event_put (struct ordered_events_queue *q,struct ordered_event *iter) +{ +list_del (&iter->list); +list_add (&iter->list, &q->cache); + q->nr_events--; +}Similarly here with the
_put. In this case the function is moving the event from one list to another. And how about something else for the name besides iter -- oe, or oevent?
Quoted 4 lines
Quoted 1 line
how about 'event' ?
Already a heavily used keyword in perf, that's why I was thinking oe or oevent -- besides it is a struct
ordered_eventnot an event.
Agreed on all counts.
Quoted 1 line
The bigger thing to me with this patch is the _get/_put names.
Agreed, those are for reference counting.
- Arnaldo
Arnaldo Carvalho de Melo
maintainerRe: [PATCH 05/18] perf tools: Add ordered_events_(get|put) interface
In reply to Jiri OlsaEm Sun, Jun 29, 2014 at 06:39:33PM +0200, Jiri Olsa escreveu:
Quoted 4 lines · David Ahern
Quoted 3 lines · Jiri Olsa
tools/perf/util/session.c static void perf_session_free_sample_buffers(struct perf_session *session) · line 542
Quoted 2 lines
tools/perf/util/session.c +2
-0+static struct ordered_event * +ordered_events_get (struct ordered_events_queue *q,u64 timestamp)
Also I don't think that it matters that much to have explicit in the name above the data structure used to reorder events, i.e. I suggest renaming "struct ordered_events_queue" to just "struct ordered_events".
- Arnaldo
Jiri Olsa
reviewerPATCH v2 6/18 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 oeq_flush { +OEQ_FLUSH__FINAL , +OEQ_FLUSH__ROUND , +}; +static void perf_session_free_sample_buffers (struct perf_session *session) {struct ordered_events_queue *q = &session->ordered_events;
@@ -567,8 +572,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_queue *q = &s->ordered_events;struct list_head *head = &q->events;
@@ -618,6 +623,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 oeq_flush how) +{ +struct ordered_events_queue *q = &s->ordered_events; +int err; + +switch (how) { +case OEQ_FLUSH__FINAL : + q->next_flush =ULLONG_MAX ; +break ; + +case OEQ_FLUSH__ROUND : +default : +break ; + }; + + err =__ordered_events_flush (s, tool); + +if (!err) { +if (how ==OEQ_FLUSH__ROUND ) + q->next_flush = q->max_timestamp; + } + +return err; +} +/* * When perf record finishes a pass on every buffers, it records this pseudo * event.
@@ -661,11 +692,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, OEQ_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,OEQ_FLUSH__FINAL ); out_err:free (buf);perf_session__warn_about_errors (session, tool);
@@ -1383,8 +1409,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,OEQ_FLUSH__FINAL ); out_err:ui_progress__finish ();perf_session__warn_about_errors (session, tool);
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v2 7/18 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_queue *q, struct ordered_event *nestatic struct ordered_event *alloc_event (struct ordered_events_queue *q) {struct list_head *cache = &q->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_queue *q) new = q->buffer + q->buffer_idx;if (++q->buffer_idx ==MAX_SAMPLE_BUFFER ) q->buffer =NULL ; - }else { - q->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); + }else if (q->cur_alloc_size < q->max_alloc_size) { +size_t size =MAX_SAMPLE_BUFFER *sizeof (*new); + + q->buffer =malloc (size);if (!q->buffer)return NULL ; + + q->cur_alloc_size += size;list_add (&q->buffer->list, &q->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_queue {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
Re: [PATCH 07/18] perf tools: Limit ordered events queue size
Quoted 15 lines · Jiri Olsa
tools/perf/util/session.c +1
-3@@ -520,7 +522,7 @@ static void queue_event(struct ordered_events_queue *q, struct ordered_event *nestatic struct ordered_event *alloc_event (struct ordered_events_queue *q) {struct list_head *cache = &q->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_queue *q) new = q->buffer + q->buffer_idx;if (++q->buffer_idx ==MAX_SAMPLE_BUFFER ) q->buffer =NULL ; - }else { - q->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new));
tools/perf/util/session.c static struct ordered_event *alloc_event(struct ordered_events_queue *q) · line 543
Quoted 10 lines
tools/perf/util/session.c +6
-0+ }else if (q->cur_alloc_size < q->max_alloc_size) { +size_t size =MAX_SAMPLE_BUFFER *sizeof (*new); + + q->buffer =malloc (size);if (!q->buffer)return NULL ; + + q->cur_alloc_size += size;list_add (&q->buffer->list, &q->to_free);
When is cur_alloc_size decremented?
$ git checkout remotes/jolsa/perf/core_ordered_events
$ egrep -r cur_alloc_size tools/perf/
tools/perf//util/ordered-events.c: } else if (q->cur_alloc_size < q->max_alloc_size) {
tools/perf//util/ordered-events.c: q->cur_alloc_size, q->max_alloc_size);
tools/perf//util/ordered-events.c: q->cur_alloc_size += size;
tools/perf//util/ordered-events.c: q->cur_alloc_size = 0;
tools/perf//util/ordered-events.h: u64 cur_alloc_size;Does not appear to ever be decremented.
David
Re: [PATCH 07/18] perf tools: Limit ordered events queue size
Quoted 20 lines · David Ahern
Quoted 19 lines · Jiri Olsa
tools/perf/util/session.c +5
-3@@ -520,7 +522,7 @@ static void queue_event(struct ordered_events_queue *q, struct ordered_event *nestatic struct ordered_event *alloc_event (struct ordered_events_queue *q) {struct list_head *cache = &q->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_queue *q) new = q->buffer + q->buffer_idx;if (++q->buffer_idx ==MAX_SAMPLE_BUFFER ) q->buffer =NULL ; - }else { - q->buffer =malloc (MAX_SAMPLE_BUFFER *sizeof (*new)); + }else if (q->cur_alloc_size < q->max_alloc_size) { +size_t size =MAX_SAMPLE_BUFFER *sizeof (*new); + + q->buffer =malloc (size);
Quoted 8 lines
tools/perf/util/session.c static struct ordered_event *alloc_event(struct ordered_events_queue *q) · line 543
Quoted 6 lines
tools/perf/util/session.c +2
-0if (!q->buffer)return NULL ; + + q->cur_alloc_size += size;list_add (&q->buffer->list, &q->to_free);When is
cur_alloc_sizedecremented?
never, it get's incremented untiul we reach the limit, then it stays and the cache is used for new events.. and it's all released at the end
jirka
Jiri Olsa
reviewerPATCH v2 8/18 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 | 28 ++++++++++++++++++++++++++-- tools/perf/util/session.h | 3 ++- 3 files changed, 29 insertions(+), 4 deletions(-)
tools/perf/builtin-kvm.c +1 -1
@@ -902,7 +902,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 +26 -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 oeq_flush {OEQ_FLUSH__FINAL ,OEQ_FLUSH__ROUND , +OEQ_FLUSH__HALF , };static void perf_session_free_sample_buffers (struct perf_session *session)
@@ -640,6 +642,22 @@ static int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, q->next_flush =ULLONG_MAX ;break ; +case OEQ_FLUSH__HALF : + { +struct ordered_event *first, *last; +struct list_head *head = &q->events; + + first = list_entry(head->next, struct ordered_event, list); + last = q->last; + +if (WARN_ONCE (!last ||list_empty (head),"empty queue" )) +return 0 ; + + q->next_flush = first->timestamp; + q->next_flush += (last->timestamp - first->timestamp) /2 ; +break ; + } +case OEQ_FLUSH__ROUND :default :break ;
@@ -702,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_queue *q = &s->ordered_events;u64 timestamp = sample->time;
@@ -717,6 +736,11 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event, } new =ordered_events_get (q, timestamp); +if (!new) { +ordered_events_flush (s, tool,OEQ_FLUSH__HALF ); + new =ordered_events_get (q, timestamp); + } +if (!new)return -ENOMEM ;
@@ -1122,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
@@ -64,7 +64,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
Re: [PATCH 08/18] perf tools: Flush ordered events in case of allocation failure
tools/perf/util/session.c static int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, · line 654
Quoted 10 lines · Jiri Olsa
tools/perf/util/session.c +10
-0+case OEQ_FLUSH__HALF : + { +struct ordered_event *first, *last; +struct list_head *head = &q->events; + + first = list_entry(head->next, struct ordered_event, list); + last = q->last; + +if (WARN_ONCE (!last ||list_empty (head),"empty queue" )) +return 0 ;
Maybe a comment that the WARN_ONCE can only happen if perf can't allocate an ordered event the first time through?
tools/perf/util/session.c static int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, · line 660
Quoted 6 lines
tools/perf/util/session.c +6
-0+ + q->next_flush = first->timestamp; + q->next_flush += (last->timestamp - first->timestamp) /2 ; +break ; + } +
David
Re: [PATCH 08/18] perf tools: Flush ordered events in case of allocation failure
Quoted 14 lines · David Ahern
tools/perf/util/session.c static int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, · line 654
Quoted 10 lines · Jiri Olsa
tools/perf/util/session.c +10
-0+case OEQ_FLUSH__HALF : + { +struct ordered_event *first, *last; +struct list_head *head = &q->events; + + first = list_entry(head->next, struct ordered_event, list); + last = q->last; + +if (WARN_ONCE (!last ||list_empty (head),"empty queue" )) +return 0 ;Maybe a comment that the
WARN_ONCEcan only happen if perf can't allocate an ordered event the first time through?
ok, will do..
thanks,
jirka
Jiri Olsa
reviewerPATCH v2 9/18 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 | 17 +++++------------ tools/perf/util/session.h | 6 ++++++ 2 files changed, 11 insertions(+), 12 deletions(-)
tools/perf/util/session.c +5 -12
@@ -573,13 +573,6 @@ ordered_event_put(struct ordered_events_queue *q, struct ordered_event *iter) q->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 +998,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
@@ -69,6 +69,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 v2 10/18 perf tools: Create ordered-events object
In reply to Jiri OlsaMove ordered events code into separated object ordered-events.[ch].
--- tools/perf/Makefile.perf | 2 + tools/perf/util/ordered-events.c | 195 +++++++++++++++++++++++++++++++++++++ tools/perf/util/ordered-events.h | 43 ++++++++ tools/perf/util/session.c | 205 --------------------------------------- tools/perf/util/session.h | 17 +--- 5 files changed, 241 insertions(+), 221 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
@@ -345,6 +346,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 +195 -0
195 lines not on this page · raw message
tools/perf/util/ordered-events.h new file +43 -0
43 lines not on this page · raw message
tools/perf/util/session.c +0 -205
223 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_queue { -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 v2 11/18 perf tools: Use list_move in ordered_event_put function
In reply to Jiri OlsaAs Namhyung pointed out we can use list_move in ordered_event_put.
--- 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_get(struct ordered_events_queue *q, u64 timestamp)void ordered_event_put (struct ordered_events_queue *q,struct ordered_event *iter) { -list_del (&iter->list); -list_add (&iter->list, &q->cache); +list_move (&iter->list, &q->cache); q->nr_events--; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v2 12/18 perf tools: Add ordered_events_queue_init function
In reply to Jiri OlsaAdding ordered_events_queue_init function for struct ordered_events_queue 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
@@ -192,3 +192,12 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool,return err; } + +void ordered_events_queue_init (struct ordered_events_queue *q) +{ +INIT_LIST_HEAD (&q->events); +INIT_LIST_HEAD (&q->cache); +INIT_LIST_HEAD (&q->to_free); + q->max_alloc_size = (u64) -1 ; + q->cur_alloc_size =0 ; +}
tools/perf/util/ordered-events.h +1 -0
@@ -40,4 +40,5 @@ void ordered_event_put(struct ordered_events_queue *q, struct ordered_event *iter);int ordered_events_flush (struct perf_session *s,struct perf_tool *tool,enum oeq_flush how); +void ordered_events_queue_init (struct ordered_events_queue *q);#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_queue_init (&session->ordered_events);machines__init (&session->machines);if (file) {
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v2 13/18 perf tools: Add ordered_events_queue_free function
In reply to Jiri OlsaAdding ordered_events_queue_free function to release all the struct ordered_events_queue 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
@@ -201,3 +201,14 @@ void ordered_events_queue_init(struct ordered_events_queue *q) q->max_alloc_size = (u64) -1 ; q->cur_alloc_size =0 ; } + +void ordered_events_queue_free (struct ordered_events_queue *q) +{ +while (!list_empty (&q->to_free)) { +struct ordered_event *event; + + event = list_entry(q->to_free.next, struct ordered_event, list); +list_del (&event->list); +free (event); + } +}
tools/perf/util/ordered-events.h +1 -0
@@ -41,4 +41,5 @@ void ordered_event_put(struct ordered_events_queue *q,int ordered_events_flush (struct perf_session *s,struct perf_tool *tool,enum oeq_flush how);void ordered_events_queue_init (struct ordered_events_queue *q); +void ordered_events_queue_free (struct ordered_events_queue *q);#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_queue *q = &session->ordered_events; - -while (!list_empty (&q->to_free)) { -struct ordered_event *sq; - - sq = list_entry(q->to_free.next, struct ordered_event, list); -list_del (&sq->list); -free (sq); - } -} -/* * When perf record finishes a pass on every buffers, it records this pseudo * event.
@@ -1092,7 +1079,7 @@ done: out_err:free (buf);perf_session__warn_about_errors (session, tool); -perf_session_free_sample_buffers (session); +ordered_events_queue_free (&session->ordered_events);return err; }
@@ -1227,7 +1214,7 @@ out: out_err:ui_progress__finish ();perf_session__warn_about_errors (session, tool); -perf_session_free_sample_buffers (session); +ordered_events_queue_free (&session->ordered_events);return err; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v2 14/18 perf tools: Add perf_config_u64 function
In reply to Jiri OlsaFrom: Jiri Olsa <[email protected]>
Adding 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
Re: [PATCH 14/18] perf tools: Add perf_config_u64 function
tools/perf/util/config.c static void die_bad_config(const char *name) · line 331
Quoted 11 lines · Jiri Olsa
tools/perf/util/config.c +7
-0@@ -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;
Thought we were not using the die functions any longer?
David
Re: [PATCH 14/18] perf tools: Add perf_config_u64 function
Quoted 6 lines · David Ahern
Quoted 4 lines · Jiri Olsa
tools/perf/util/config.c +0
-0@@ -307,6 +322,15 @@ static void die_bad_config(const char *name)die ("bad config value for '%s'" , name); }
Quoted 10 lines
tools/perf/util/config.c static void die_bad_config(const char *name) · line 331
Quoted 7 lines
tools/perf/util/config.c +7
-0+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;Thought we were not using the die functions any longer?
seem like patchset removing that for config object will prepare separate change
jirka
Jiri Olsa
reviewerPATCH v2 15/18 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_queue_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
@@ -42,4 +42,10 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, enum oeq_flush how);void ordered_events_queue_init (struct ordered_events_queue *q);void ordered_events_queue_free (struct ordered_events_queue *q); + +static inline void +ordered_events_queue_alloc_size (struct ordered_events_queue *q,u64 size) +{ + q->max_alloc_size = size; +}#endif /* __ORDERED_EVENTS_H */
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v2 16/18 perf tools: Add debug prints for ordered events queue
In reply to Jiri OlsaAdding some prints for ordered events queue, to help debug issues.
--- tools/perf/builtin-report.c | 4 +++ tools/perf/util/ordered-events.c | 54 ++++++++++++++++++++++++++++++++++++++++ tools/perf/util/ordered-events.h | 2 ++ 3 files changed, 60 insertions(+)
tools/perf/builtin-report.c +4 -0
@@ -82,6 +82,10 @@ static int report__config(const char *var, const char *value, void *cb) rep->queue_size =perf_config_u64 (var, value);return 0 ; } +if (!strcmp (var,"report.queue-debug" )) { + debug_sample_queue =perf_config_int (var, value); +return 0 ; + }return perf_default_config (var, value, cb); }
tools/perf/util/ordered-events.c +54 -0
78 lines not on this page · raw message
tools/perf/util/ordered-events.h +2 -0
@@ -48,4 +48,6 @@ ordered_events_queue_alloc_size(struct ordered_events_queue *q, u64 size) { q->max_alloc_size = size; } + +extern int debug_sample_queue;#endif /* __ORDERED_EVENTS_H */
Signature · 1 line
1.8.3.1
Re: [PATCH 16/18] perf tools: Add debug prints for ordered events queue
Quoted 2 lines · Jiri Olsa
Adding some prints for ordered events queue, to help debug issues.
went to enable this and it is really odd to have to edit a config file to enable debugging. How about hooking it into verbose option? Maybe like multiple levels of -v or -v <val> or -v queue.
David
Re: [PATCH 16/18] perf tools: Add debug prints for ordered events queue
Quoted 7 lines · David Ahern
Quoted 2 lines · Jiri Olsa
Adding some prints for ordered events queue, to help debug issues.
went to enable this and it is really odd to have to edit a config file to enable debugging. How about hooking it into verbose option? Maybe like multiple levels of -v or -v <val> or -v queue.
seems like verbose option factoring.. in future ;-) I can live without this patch though.. it was mainly for testing my changes
thanks,
jirka
Re: [PATCH 16/18] perf tools: Add debug prints for ordered events queue
Quoted 11 lines · Jiri Olsa
Quoted 7 lines · David Ahern
Quoted 2 lines · Jiri Olsa
Adding some prints for ordered events queue, to help debug issues.
went to enable this and it is really odd to have to edit a config file to enable debugging. How about hooking it into verbose option? Maybe like multiple levels of -v or -v <val> or -v queue.
seems like verbose option factoring.. in future ;-) I can live without this patch though.. it was mainly for testing my changes
It was quite useful to see how various data sets were stressing the ordered samples queue. For example 'perf record -g' and a kernel build stressed it more than the record on the 'perf bench'.
David
Jiri Olsa
reviewerPATCH v2 17/18 perf tools: Limit the ordered events queue by default to 100MB
In reply to Jiri OlsaIt's still configurable by report.queue-size config option, but looks like 100MB limit is more sane than no limit at all.
There's some speedup for report on huge data files:
With the limit of 100 MB, I've got around 15% speedup on reporting of ~10GB perf.data file.
current code:
621,685,704,665 cycles ( +- 0.52% ) 873,397,467,969 instructions ( +- 0.00% )
286.133268732 seconds time elapsed ( +- 1.13% )
with patches:
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 there's lower memory consuption.
--- tools/perf/util/ordered-events.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
tools/perf/util/ordered-events.c +2 -1
@@ -252,7 +252,8 @@ void ordered_events_queue_init(struct ordered_events_queue *q)INIT_LIST_HEAD (&q->events);INIT_LIST_HEAD (&q->cache);INIT_LIST_HEAD (&q->to_free); - q->max_alloc_size = (u64) -1 ; +/* 100MB limitation by default */ + q->max_alloc_size =100 *1024 *1024 ; q->cur_alloc_size =0 ; }
Signature · 1 line
1.8.3.1
Jiri Olsa
reviewerPATCH v2 18/18 perf tools: Allow out of order messages in forced flush
In reply to Jiri OlsaIn forced flush (OEQ_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 and also 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 | 8 ++++++-- 3 files changed, 12 insertions(+), 2 deletions(-)
tools/perf/util/ordered-events.c +4 -0
@@ -213,12 +213,14 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool, }case OEQ_FLUSH__ROUND : +case OEQ_FLUSH__NONE :default :break ; };if (unlikely (debug_sample_queue)) {static const char *const str[] = { +"NONE" ,"FINAL" ,"ROUND" ,"HALF " ,
@@ -235,6 +237,8 @@ int ordered_events_flush(struct perf_session *s, struct perf_tool *tool,if (!err) {if (how ==OEQ_FLUSH__ROUND ) q->next_flush = q->max_timestamp; + + q->last_flush_type = how; }if (unlikely (debug_sample_queue)) {
tools/perf/util/ordered-events.h +2 -0
@@ -14,6 +14,7 @@ struct ordered_event { };enum oeq_flush { +OEQ_FLUSH__NONE ,OEQ_FLUSH__FINAL ,OEQ_FLUSH__ROUND ,OEQ_FLUSH__HALF ,
@@ -32,6 +33,7 @@ struct ordered_events_queue {struct ordered_event *last;int buffer_idx;unsigned int nr_events; +enum oeq_flush last_flush_type; }; struct ordered_event *ordered_events_get(struct ordered_events_queue *q,
tools/perf/util/session.c +6 -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) {
@@ -502,8 +503,11 @@ int perf_session_queue_event(struct perf_session *s, union perf_event *event,return -ETIME ;if (timestamp < s->ordered_events.last_flush) { -printf ("Warning: Timestamp below last timeslice flush\n" ); -return -EINVAL ; +WARN_ONCE (1 ,"Timestamp below last timeslice flush\n" ); + +/* We could get out of order messages after forced flush. */ +if (q->last_flush_type !=OEQ_FLUSH__HALF ) +return -EINVAL ; } new =ordered_events_get (q, timestamp);
Signature · 1 line
1.8.3.1
Quoted 57 lines · Jiri Olsa
hi,
this patchset factors session's ordered samples queue, and allows to limit the size of this queue.v2 changes:
- several small changes for review comments (Namhyung)The report command queues events till any of following conditions is reached:
-PERF_RECORD_FINISHED_ROUNDevent is processed
- end of the file is reachedAny of above conditions will force the queue to flush some events while keeping all allocated memory for next events.
If
PERF_RECORD_FINISHED_ROUNDis 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_faultwith patches:
1.45% 0.00% perf [kernel.kallsyms] [k] page_faultcurrent code (faults event):
6,643,807 faults ( +- 0.36% )with patches (faults event):
2,214,756 faults ( +- 3.03% )
Quoted 9 lines
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
I've skimmed through the patches. What happens if you are in the middle of a round and the max queue size is reached?
I need to find some time for a detailed review, and to run through some stress case scenarios. e.g., a couple that come to mind perf sched record -- perf bench sched pipe
perf kvm record while booting a nested VM which causes a lot of VMEXITs
David
On Wed, Jun 18, 2014 at 01:44:46PM -0600, David Ahern wrote:
SNIP
Quoted 6 lines
Quoted 6 lines
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.
Quoted 7 lines
Quoted 4 lines
Also reachable in here:
git://git.kernel.org/pub/scm/linux/kernel/git/jolsa/perf.git
perf/core_ordered_eventsI've skimmed through the patches. What happens if you are in the middle of a round and the max queue size is reached?
half of the queue (time half) is flushed to make some free space
Quoted 4 lines
I need to find some time for a detailed review, and to run through some stress case scenarios. e.g., a couple that come to mind
perf sched record -- perf bench sched pipe
perf kvm record while booting a nested VM which causes a lot of VMEXITs
will try.. at least the first one ;-)
thanks for looking on this,
jirka
Quoted 4 lines · Jiri Olsa
Quoted 2 lines
I've skimmed through the patches. What happens if you are in the middle of a round and the max queue size is reached?
half of the queue (time half) is flushed to make some free space
right, I believe there will be scenarios where that will cause failures with out of order timestamps.
David
Quoted 8 lines · David Ahern
Quoted 4 lines · Jiri Olsa
Quoted 2 lines
I've skimmed through the patches. What happens if you are in the middle of a round and the max queue size is reached?
half of the queue (time half) is flushed to make some free space
right, I believe there will be scenarios where that will cause failures with out of order timestamps.
yep, but I did not hit any so far.. thats why I added patch 18 - not to drop out of seq. event if it's found after this flush
jirka