From: Jiri Olsa <jolsa@kernel.org>
To: Arnaldo Carvalho de Melo <acme@kernel.org>
Cc: Frederic Weisbecker <fweisbec@gmail.com>,
lkml <linux-kernel@vger.kernel.org>,
Ingo Molnar <mingo@kernel.org>,
Namhyung Kim <namhyung@kernel.org>,
David Ahern <dsahern@gmail.com>, Andi Kleen <ak@linux.intel.com>,
Alexander Shishkin <alexander.shishkin@linux.intel.com>,
Peter Zijlstra <a.p.zijlstra@chello.nl>
Subject: [PATCH 21/49] perf tools: Maintain map groups list in a leader thread
Date: Tue, 9 Jan 2018 16:34:54 +0100 [thread overview]
Message-ID: <20180109153522.14116-22-jolsa@kernel.org> (raw)
In-Reply-To: <20180109153522.14116-1-jolsa@kernel.org>
From: Namhyung Kim <namhyung@kernel.org>
To support multi-threaded perf report, we need to maintain time-sorted
map groups. Add ->mg_list member to struct thread and sort the list
by time. Now leader threads have one more refcnt for map groups in
the list so also update the thread-mg-share test case.
Currently only add a new map groups when an exec (comm) event is
received.
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Link: http://lkml.kernel.org/n/tip-xj6w1y6nwhkatvo1dcd5t6sk@git.kernel.org
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
---
tools/perf/tests/thread-mg-share.c | 7 ++-
tools/perf/util/event.c | 2 +
tools/perf/util/machine.c | 15 ++++-
tools/perf/util/map.c | 3 +
tools/perf/util/map.h | 2 +
tools/perf/util/thread.c | 117 ++++++++++++++++++++++++++++++++++++-
tools/perf/util/thread.h | 3 +
7 files changed, 142 insertions(+), 7 deletions(-)
diff --git a/tools/perf/tests/thread-mg-share.c b/tools/perf/tests/thread-mg-share.c
index b1d1bbafe7ae..44a63d7961c8 100644
--- a/tools/perf/tests/thread-mg-share.c
+++ b/tools/perf/tests/thread-mg-share.c
@@ -24,6 +24,9 @@ int test__thread_mg_share(struct test *test __maybe_unused, int subtest __maybe_
* with several threads and checks they properly share and
* maintain map groups info (struct map_groups).
*
+ * Note that a leader thread has one more refcnt for its
+ * (current) map groups.
+ *
* thread group (pid: 0, tids: 0, 1, 2, 3)
* other group (pid: 4, tids: 4, 5)
*/
@@ -44,7 +47,7 @@ int test__thread_mg_share(struct test *test __maybe_unused, int subtest __maybe_
leader && t1 && t2 && t3 && other);
mg = leader->mg;
- TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&mg->refcnt), 4);
+ TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&mg->refcnt), 5);
/* test the map groups pointer is shared */
TEST_ASSERT_VAL("map groups don't match", mg == t1->mg);
@@ -72,7 +75,7 @@ int test__thread_mg_share(struct test *test __maybe_unused, int subtest __maybe_
machine__remove_thread(machine, other_leader);
other_mg = other->mg;
- TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&other_mg->refcnt), 2);
+ TEST_ASSERT_EQUAL("wrong refcnt", refcount_read(&other_mg->refcnt), 3);
TEST_ASSERT_VAL("map groups don't match", other_mg == other_leader->mg);
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 14c4cf5cd707..79cc3c34cde2 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -1510,6 +1510,8 @@ void thread__find_addr_map(struct thread *thread, u8 cpumode,
return;
}
+ BUG_ON(mg == NULL);
+
if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
al->level = 'k';
mg = &machine->kmaps;
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index ab79c2797a3c..6349ea11753b 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -395,8 +395,19 @@ static void machine__update_thread_pid(struct machine *machine,
if (!leader)
goto out_err;
- if (!leader->mg)
- leader->mg = map_groups__new(machine);
+ if (!leader->mg) {
+ struct map_groups *mg = map_groups__new(machine);
+
+ if (mg == NULL) {
+ pr_err("Not enough memory for map groups\n");
+ return;
+ }
+
+ if (thread__set_map_groups(leader, mg, 0) < 0) {
+ map_groups__put(mg);
+ goto out_err;
+ }
+ }
if (!leader->mg)
goto out_err;
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 8fe57031e1a8..dbd8c2c3d712 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -500,6 +500,8 @@ void map_groups__init(struct map_groups *mg, struct machine *machine)
}
mg->machine = machine;
refcount_set(&mg->refcnt, 1);
+ mg->timestamp = 0;
+ INIT_LIST_HEAD(&mg->list);
}
static void __maps__purge(struct maps *maps)
@@ -556,6 +558,7 @@ struct map_groups *map_groups__new(struct machine *machine)
void map_groups__delete(struct map_groups *mg)
{
map_groups__exit(mg);
+ list_del(&mg->list);
free(mg);
}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index edeb7291c8e1..38d5954771e8 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -70,6 +70,8 @@ struct map_groups {
struct maps maps[MAP__NR_TYPES];
struct machine *machine;
refcount_t refcnt;
+ u64 timestamp;
+ struct list_head list;
};
struct map_groups *map_groups__new(struct machine *machine);
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 38510a40c898..6ad32879440d 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -16,12 +16,78 @@
#include <api/fs/fs.h>
+struct map_groups *thread__get_map_groups(struct thread *thread, u64 timestamp)
+{
+ struct map_groups *mg;
+ struct thread *leader = thread;
+
+ BUG_ON(thread->mg == NULL);
+
+ if (thread->tid != thread->pid_) {
+ leader = machine__find_thread_by_time(thread->mg->machine,
+ thread->pid_, thread->pid_,
+ timestamp);
+ if (leader == NULL)
+ goto out;
+ }
+
+ list_for_each_entry(mg, &leader->mg_list, list)
+ if (timestamp >= mg->timestamp)
+ return mg;
+
+out:
+ return thread->mg;
+}
+
+int thread__set_map_groups(struct thread *thread, struct map_groups *mg,
+ u64 timestamp)
+{
+ struct list_head *pos;
+ struct map_groups *old;
+
+ if (mg == NULL)
+ return -ENOMEM;
+
+ /*
+ * Only a leader thread can have map groups list - others
+ * reference it through map_groups__get. This means the
+ * leader thread will have one more refcnt than others.
+ */
+ if (thread->tid != thread->pid_)
+ return -EINVAL;
+
+ if (thread->mg) {
+ BUG_ON(refcount_read(&thread->mg->refcnt) <= 1);
+ map_groups__put(thread->mg);
+ }
+
+ /* sort by time */
+ list_for_each(pos, &thread->mg_list) {
+ old = list_entry(pos, struct map_groups, list);
+ if (timestamp > old->timestamp)
+ break;
+ }
+
+ list_add_tail(&mg->list, pos);
+ mg->timestamp = timestamp;
+
+ /* set current ->mg to most recent one */
+ thread->mg = list_first_entry(&thread->mg_list, struct map_groups, list);
+ /* increase one more refcnt for current */
+ map_groups__get(thread->mg);
+
+ return 0;
+}
+
int thread__init_map_groups(struct thread *thread, struct machine *machine)
{
pid_t pid = thread->pid_;
if (pid == thread->tid || pid == -1) {
- thread->mg = map_groups__new(machine);
+ struct map_groups *mg = map_groups__new(machine);
+
+ if (thread__set_map_groups(thread, mg, 0) < 0)
+ map_groups__put(mg);
} else {
struct thread *leader = __machine__findnew_thread(machine, pid, pid);
if (leader) {
@@ -48,6 +114,7 @@ struct thread *thread__new(pid_t pid, pid_t tid)
INIT_LIST_HEAD(&thread->comm_list);
init_rwsem(&thread->namespaces_lock);
init_rwsem(&thread->comm_lock);
+ INIT_LIST_HEAD(&thread->mg_list);
comm_str = malloc(32);
if (!comm_str)
@@ -77,7 +144,8 @@ struct thread *thread__new(pid_t pid, pid_t tid)
void thread__delete(struct thread *thread)
{
struct namespaces *namespaces, *tmp_namespaces;
- struct comm *comm, *tmp_comm;
+ struct comm *comm, *tmp;
+ struct map_groups *mg, *tmp_mg;
BUG_ON(!RB_EMPTY_NODE(&thread->rb_node));
BUG_ON(!list_empty(&thread->tid_list));
@@ -89,6 +157,7 @@ void thread__delete(struct thread *thread)
thread->mg = NULL;
}
down_write(&thread->namespaces_lock);
+
list_for_each_entry_safe(namespaces, tmp_namespaces,
&thread->namespaces_list, list) {
list_del(&namespaces->list);
@@ -97,7 +166,12 @@ void thread__delete(struct thread *thread)
up_write(&thread->namespaces_lock);
down_write(&thread->comm_lock);
- list_for_each_entry_safe(comm, tmp_comm, &thread->comm_list, list) {
+
+ /* only leader threads have mg list */
+ list_for_each_entry_safe(mg, tmp_mg, &thread->mg_list, list)
+ map_groups__put(mg);
+
+ list_for_each_entry_safe(comm, tmp, &thread->comm_list, list) {
list_del(&comm->list);
comm__free(comm);
}
@@ -217,6 +291,9 @@ struct comm *thread__comm_by_time(const struct thread *thread, u64 timestamp)
return list_last_entry(&thread->comm_list, struct comm, list);
}
+static int thread__clone_map_groups(struct thread *thread,
+ struct thread *parent);
+
static int ____thread__set_comm(struct thread *thread, const char *str,
u64 timestamp, bool exec)
{
@@ -247,6 +324,40 @@ static int ____thread__set_comm(struct thread *thread, const char *str,
unwind__flush_access(thread);
}
+ if (exec) {
+ struct machine *machine;
+
+ BUG_ON(thread->mg == NULL || thread->mg->machine == NULL);
+
+ machine = thread->mg->machine;
+
+ if (thread->tid != thread->pid_) {
+ struct map_groups *old = thread->mg;
+ struct thread *leader;
+
+ leader = machine__findnew_thread(machine, thread->pid_,
+ thread->pid_);
+
+ /* now it'll be a new leader */
+ thread->pid_ = thread->tid;
+
+ thread->mg = map_groups__new(old->machine);
+ if (thread->mg == NULL)
+ return -ENOMEM;
+
+ /* save current mg in the new leader */
+ thread__clone_map_groups(thread, leader);
+
+ /* current mg of leader thread needs one more refcnt */
+ map_groups__get(thread->mg);
+
+ thread__set_map_groups(thread, thread->mg, old->timestamp);
+ }
+
+ /* create a new mg for newly executed binary */
+ thread__set_map_groups(thread, map_groups__new(machine), timestamp);
+ }
+
thread->comm_set = true;
return 0;
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 5ca81f29afa8..81995cb7102d 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -19,6 +19,7 @@ struct thread {
struct rb_node rb_node;
struct list_head tid_list;
struct map_groups *mg;
+ struct list_head mg_list;
pid_t pid_; /* Not all tools update this */
pid_t tid;
pid_t ppid;
@@ -90,6 +91,8 @@ struct comm *thread__comm_by_time(const struct thread *thread, u64 timestamp);
const char *thread__comm_str(const struct thread *thread);
int thread__insert_map(struct thread *thread, struct map *map);
const char *thread__comm_str_by_time(const struct thread *thread, u64 timestamp);
+struct map_groups *thread__get_map_groups(struct thread *thread, u64 timestamp);
+int thread__set_map_groups(struct thread *thread, struct map_groups *mg, u64 timestamp);
int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp);
size_t thread__fprintf(struct thread *thread, FILE *fp);
--
2.13.6
next prev parent reply other threads:[~2018-01-09 15:36 UTC|newest]
Thread overview: 51+ messages / expand[flat|nested] mbox.gz Atom feed top
2018-01-09 15:34 [RFC 00/49] perf tools: Add threads to record command Jiri Olsa
2018-01-09 15:34 ` [PATCH 01/49] perf tools: Remove perf_tool from event_op2 Jiri Olsa
2018-01-09 15:34 ` [PATCH 02/49] perf tools: Remove perf_tool from event_op3 Jiri Olsa
2018-01-09 15:34 ` [PATCH 03/49] perf tools: Pass struct perf_mmap into auxtrace_mmap__read* functions Jiri Olsa
2018-01-09 15:34 ` [PATCH 04/49] perf tools: Add struct perf_mmap arg into record__write Jiri Olsa
2018-01-09 15:34 ` [PATCH 05/49] perf tools: Use a software dummy event to track task/mmap events Jiri Olsa
2018-01-09 15:34 ` [PATCH 06/49] perf tools: Create separate mmap for dummy tracking event Jiri Olsa
2018-01-09 15:34 ` [PATCH 07/49] perf tools: Extend perf_evlist__mmap_ex() to use track mmap Jiri Olsa
2018-01-09 15:34 ` [PATCH 08/49] perf report: Skip dummy tracking event Jiri Olsa
2018-01-09 15:34 ` [PATCH 09/49] perf tools: Make copyfile_offset global Jiri Olsa
2018-01-09 15:34 ` [PATCH 10/49] perf tools: Add HEADER_DATA_INDEX feature Jiri Olsa
2018-01-09 15:34 ` [PATCH 11/49] perf tools: Handle indexed data file properly Jiri Olsa
2018-01-09 15:34 ` [PATCH 12/49] perf tools: Add perf_data__create_index function Jiri Olsa
2018-01-09 15:34 ` [PATCH 13/49] perf record: Add --index option for building index table Jiri Olsa
2018-01-09 15:34 ` [PATCH 14/49] perf tools: Introduce thread__comm(_str)_by_time() helpers Jiri Olsa
2018-01-09 15:34 ` [PATCH 15/49] perf tools: Add a test case for thread comm handling Jiri Olsa
2018-01-09 15:34 ` [PATCH 16/49] perf tools: Use thread__comm_by_time() when adding hist entries Jiri Olsa
2018-01-09 15:34 ` [PATCH 17/49] perf tools: Convert dead thread list into rbtree Jiri Olsa
2018-01-09 15:34 ` [PATCH 18/49] perf tools: Introduce machine__find*_thread_by_time() Jiri Olsa
2018-01-09 15:34 ` [PATCH 19/49] perf tools: Add thread::exited flag Jiri Olsa
2018-01-09 15:34 ` [PATCH 20/49] perf tools: Add a test case for timed thread handling Jiri Olsa
2018-01-09 15:34 ` Jiri Olsa [this message]
2018-01-09 15:34 ` [PATCH 22/49] perf tools: Introduce thread__find_addr_location_by_time() and friends Jiri Olsa
2018-01-09 15:34 ` [PATCH 23/49] perf callchain: Use " Jiri Olsa
2018-01-09 15:34 ` [PATCH 24/49] perf tools: Add a test case for timed map groups handling Jiri Olsa
2018-01-09 15:34 ` [PATCH 25/49] perf tools: Save timestamp of a map creation Jiri Olsa
2018-01-09 15:34 ` [PATCH 26/49] perf tools: Introduce map_groups__{insert,find}_by_time() Jiri Olsa
2018-01-09 15:35 ` [PATCH 27/49] perf tools: Use map_groups__find_addr_by_time() Jiri Olsa
2018-01-09 15:35 ` [PATCH 28/49] perf tools: Add testcase for managing maps with time Jiri Olsa
2018-01-09 15:35 ` [PATCH 29/49] perf callchain: Maintain libunwind's address space in map_groups Jiri Olsa
2018-01-09 15:35 ` [PATCH 30/49] perf tools: Rename perf_evlist__munmap_filtered to perf_mmap__put_filtered Jiri Olsa
2018-01-09 15:35 ` [PATCH 31/49] tools lib fd array: Introduce fdarray__add_clone function Jiri Olsa
2018-01-09 15:35 ` [PATCH 32/49] tools lib subcmd: Add OPT_INTEGER_OPTARG|_SET options Jiri Olsa
2018-01-09 15:35 ` [PATCH 33/49] perf tools: Move __perf_session__process_events args into struct Jiri Olsa
2018-01-09 15:35 ` [PATCH 34/49] perf ui progress: Fix index progress display Jiri Olsa
2018-01-09 15:35 ` [PATCH 35/49] perf tools: Add threads debug variable Jiri Olsa
2018-01-09 15:35 ` [PATCH 36/49] perf tools: Add cpu into struct perf_mmap Jiri Olsa
2018-01-09 15:35 ` [PATCH 37/49] perf tools: Add perf_mmap__read_tail function Jiri Olsa
2018-01-09 15:35 ` [PATCH 38/49] perf record: Introduce struct record_thread Jiri Olsa
2018-01-09 15:35 ` [PATCH 39/49] perf record: Read record thread's mmaps Jiri Olsa
2018-01-09 15:35 ` [PATCH 40/49] perf record: Move waking into struct record Jiri Olsa
2018-01-09 15:35 ` [PATCH 41/49] perf record: Move samples into struct record_thread Jiri Olsa
2018-01-09 15:35 ` [PATCH 42/49] perf record: Move bytes_written " Jiri Olsa
2018-01-09 15:35 ` [PATCH 43/49] perf record: Add record_thread start/stop/process functions Jiri Olsa
2018-01-09 15:35 ` [PATCH 44/49] perf record: Wait for all threads being started Jiri Olsa
2018-01-09 15:35 ` [PATCH 45/49] perf record: Add --threads option Jiri Olsa
2018-01-09 15:35 ` [PATCH 46/49] perf record: Add --thread-stats option support Jiri Olsa
2018-01-09 15:35 ` [PATCH 47/49] perf record: Add maps to --thread-stats output Jiri Olsa
2018-01-09 15:35 ` [PATCH 48/49] perf record: Spread maps for --threads option Jiri Olsa
2018-01-09 15:35 ` [PATCH 49/49] perf record: Spread maps for --threads=X option Jiri Olsa
2018-03-07 14:10 ` [RFC 00/49] perf tools: Add threads to record command Jiri Olsa
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20180109153522.14116-22-jolsa@kernel.org \
--to=jolsa@kernel.org \
--cc=a.p.zijlstra@chello.nl \
--cc=acme@kernel.org \
--cc=ak@linux.intel.com \
--cc=alexander.shishkin@linux.intel.com \
--cc=dsahern@gmail.com \
--cc=fweisbec@gmail.com \
--cc=linux-kernel@vger.kernel.org \
--cc=mingo@kernel.org \
--cc=namhyung@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).