perf inject --jit: Remove //anon mmap events
PATCH 3/4 perf inject --jit: Remove //anon mmap events
From: Steve MacLean <[email protected]>
While a JIT is jitting code it will eventually need to commit more pages and change these pages to executable permissions.
Typically the JIT will want these colocated to minimize branch displacements.
The kernel will coalesce these anonymous mapping with identical permissions before sending an MMAP event for the new pages. This means the mmap event for the new pages will include the older pages.
These anonymous mmap events will obscure the jitdump injected pseudo events. This means that the jitdump generated symbols, machine code, debugging info, and unwind info will no longer be used.
Observations:
When a process emits a jit dump marker and a jitdump file, the perf-xxx.map file represents inferior information which has been superseded by the jitdump jit-xxx.dump file.
Further the '//anon*' mmap events are only required for the legacy perf-xxx.map mapping.
Summary:
Add rbtree to track which pids have successfully injected a jitdump file.
During "perf inject --jit", discard "//anon*" mmap events for any pid which has successfully processed a jitdump file.
Committer testing:
// jitdump case
perf record <app with jitdump>
perf inject --jit --input perf.data --output perfjit.data
// verify mmap "//anon" events present initially
perf script --input perf.data --show-mmap-events | grep '//anon' // verify mmap "//anon" events removed
perf script --input perfjit.data --show-mmap-events | grep '//anon'
// no jitdump case
perf record <app without jitdump>
perf inject --jit --input perf.data --output perfjit.data
// verify mmap "//anon" events present initially
perf script --input perf.data --show-mmap-events | grep '//anon' // verify mmap "//anon" events not removed
perf script --input perfjit.data --show-mmap-events | grep '//anon'
Repro:
This issue was discovered while testing the initial CoreCLR jitdump implementation. https://github.com/dotnet/coreclr/pull/26897.
--- tools/perf/builtin-inject.c | 4 +-- tools/perf/util/jitdump.c | 63 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+), 2 deletions(-)
tools/perf/builtin-inject.c +2 -2
@@ -261,7 +261,7 @@ static int perf_event__jit_repipe_mmap(struct perf_tool *tool,* if jit marker, then inject jit mmaps and generate ELF images */ ret =jit_process (inject->session, &inject->output, machine, - event->mmap.filename, sample->pid, &n); + event->mmap.filename, event->mmap.pid, &n);if (ret <0 )return ret;if (ret) {
@@ -299,7 +299,7 @@ static int perf_event__jit_repipe_mmap2(struct perf_tool *tool,* if jit marker, then inject jit mmaps and generate ELF images */ ret =jit_process (inject->session, &inject->output, machine, - event->mmap2.filename, sample->pid, &n); + event->mmap2.filename, event->mmap2.pid, &n);if (ret <0 )return ret;if (ret) {
tools/perf/util/jitdump.c +63 -0
87 lines not on this page · raw message
Signature · 1 line
1.8.3.1
Quoted 15 lines · Steve MacLean
From: Steve MacLean <[email protected]>
While a JIT is jitting code it will eventually need to commit more pages and change these pages to executable permissions.
Typically the JIT will want these colocated to minimize branch displacements.
The kernel will coalesce these anonymous mapping with identical permissions before sending an MMAP event for the new pages. This means the mmap event for the new pages will include the older pages.
These anonymous mmap events will obscure the jitdump injected pseudo events. This means that the jitdump generated symbols, machine code, debugging info, and unwind info will no longer be used.
Quoted 8 lines
Observations:
When a process emits a jit dump marker and a jitdump file, the perf-xxx.map file represents inferior information which has been superseded by the jitdump jit-xxx.dump file.
Further the '//anon*' mmap events are only required for the legacy perf-xxx.map mapping.
it's been some time I saw the code, Stephane?
I added some comments below
Quoted 77 lines
Summary:
Add rbtree to track which pids have successfully injected a jitdump file.
During "perf inject --jit", discard "//anon*" mmap events for any pid which has successfully processed a jitdump file.
Committer testing:
// jitdump case
perf record <app with jitdump>
perf inject --jit --input perf.data --output perfjit.data// verify mmap "//anon" events present initially
perf script --input perf.data --show-mmap-events | grep '//anon' // verify mmap "//anon" events removed
perf script --input perfjit.data --show-mmap-events | grep '//anon'// no jitdump case
perf record <app without jitdump>
perf inject --jit --input perf.data --output perfjit.data// verify mmap "//anon" events present initially
perf script --input perf.data --show-mmap-events | grep '//anon' // verify mmap "//anon" events not removed
perf script --input perfjit.data --show-mmap-events | grep '//anon'Repro:
This issue was discovered while testing the initial CoreCLR jitdump implementation. https://github.com/dotnet/coreclr/pull/26897.
Cc Peter Zijlstra <[email protected]>Cc Ingo Molnar <[email protected]>Cc Arnaldo Carvalho de Melo <[email protected]>Cc Mark Rutland <[email protected]>Cc Alexander Shishkin <[email protected]>Cc Jiri Olsa <[email protected]>Cc Namhyung Kim <[email protected]>Cc Stephane Eranian <[email protected]>Signed-off-by Steve MacLean <[email protected]>--- tools/perf/builtin-inject.c | 4 +-- tools/perf/util/jitdump.c | 63 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+), 2 deletions(-)tools/perf/builtin-inject.c +2
-2@@ -261,7 +261,7 @@ static int perf_event__jit_repipe_mmap(struct perf_tool *tool,* if jit marker, then inject jit mmaps and generate ELF images */ ret =jit_process (inject->session, &inject->output, machine, - event->mmap.filename, sample->pid, &n); + event->mmap.filename, event->mmap.pid, &n);if (ret <0 )return ret;if (ret) {@@ -299,7 +299,7 @@ static int perf_event__jit_repipe_mmap2(struct perf_tool *tool,* if jit marker, then inject jit mmaps and generate ELF images */ ret =jit_process (inject->session, &inject->output, machine, - event->mmap2.filename, sample->pid, &n); + event->mmap2.filename, event->mmap2.pid, &n);if (ret <0 )return ret;if (ret) {tools/perf/util/jitdump.c +0
-0@@ -751,6 +751,59 @@ static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr)return 0 ; }
tools/perf/util/jitdump.c static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 762
Quoted 10 lines
tools/perf/util/jitdump.c +9
-0+struct pid_rbtree +{ +struct rb_node node; +pid_t pid; +}; + +static void jit_add_pid (struct rb_root *root,pid_t pid) +{ +struct rb_node **new = &(root->rb_node), *parent =NULL ;
we don't use the parenthesis like that
tools/perf/util/jitdump.c static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 767
Quoted 5 lines
tools/perf/util/jitdump.c +5
-0+struct pid_rbtree * data =NULL ; + +/* Figure out where to put new node */ +while (*new) { + struct pid_rbtree *this = container_of(*new, struct pid_rbtree, node);
there's rb_entry macro for this
tools/perf/util/jitdump.c static int jit_repipe_debug_info(struct jit_buf_desc *jd, union jr_entry *jr) · line 779
Quoted 12 lines
tools/perf/util/jitdump.c +12
-0+pid_t nodePid = this->pid; + + parent = *new; +if (pid < nodePid) + new = &((*new)->rb_left); +else if (pid > nodePid) + new = &((*new)->rb_right); +else +return ; + } + + data =malloc (sizeof (struct pid_rbtree ));
plz check every allocation
anyway, I wonder if you could just use thread::priv flag for that, like:
thread = machine__findnew_thread(machine, pid, pid);
if (!thread)
bad
(int) thread->priv = 1;and check on thread->priv when ruling the pid out, should be faster then maintain rb tree
thanks,
jirka
Quoted 6 lines
anyway, I wonder if you could just use
thread::privflag for that, like:thread =
machine__findnew_thread(machine, pid, pid); if (!thread)
bad
Quoted 6 lines
(int)
thread->priv= 1;and check on
thread->privwhen ruling the pid out, should be faster then maintain rb treethanks,
jirka
I agree reusing the existing data structure is a better approach. I have drafted a change reusing the void* priv field. It seems looks like it is currently safe to use during perf inject.
I will test it tomorrow then send the new patch