From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-11.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 74B62C844FB for ; Mon, 16 Nov 2020 12:38:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 481FF22265 for ; Mon, 16 Nov 2020 12:38:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729931AbgKPMPs (ORCPT ); Mon, 16 Nov 2020 07:15:48 -0500 Received: from mga02.intel.com ([134.134.136.20]:13482 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727895AbgKPMPr (ORCPT ); Mon, 16 Nov 2020 07:15:47 -0500 IronPort-SDR: vinVxnR0ERlxNbEi1nM/+VssYK6n8VTWLuyz44W2mk5caQi4t6VM4SeS6wkS7KTvoSICiivHJ4 TOYDwBmigzrg== X-IronPort-AV: E=McAfee;i="6000,8403,9806"; a="157761439" X-IronPort-AV: E=Sophos;i="5.77,482,1596524400"; d="scan'208";a="157761439" X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga005.jf.intel.com ([10.7.209.41]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Nov 2020 04:15:47 -0800 IronPort-SDR: BwWJi5BeWiWZeKQVuJCxOzEXA5Q+cmEQEmTUCfHHgfdQTiBBCTbJ4HcgZ++OCbB6V9JKodZ4AY N3f2xwsxK78w== X-IronPort-AV: E=Sophos;i="5.77,482,1596524400"; d="scan'208";a="543582461" Received: from abudanko-mobl.ccr.corp.intel.com (HELO [10.249.228.209]) ([10.249.228.209]) by orsmga005-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 16 Nov 2020 04:15:44 -0800 Subject: [PATCH v3 02/12] perf record: introduce thread specific data array From: Alexey Budankov To: Arnaldo Carvalho de Melo Cc: Jiri Olsa , Namhyung Kim , Alexander Shishkin , Peter Zijlstra , Ingo Molnar , linux-kernel , Andi Kleen , Adrian Hunter , Alexey Bayduraev , Alexander Antonov References: <7d197a2d-56e2-896d-bf96-6de0a4db1fb8@linux.intel.com> Organization: Intel Corp. Message-ID: <6ad03a01-a3a4-5df4-7cf5-cbc768764e75@linux.intel.com> Date: Mon, 16 Nov 2020 15:15:42 +0300 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.4.3 MIME-Version: 1.0 In-Reply-To: <7d197a2d-56e2-896d-bf96-6de0a4db1fb8@linux.intel.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Introduce thread specific data object and array of such objects to store and manage thread local data. Implement functions to allocate, initialize, finalize and release thread specific data. Thread local maps and overwrite_maps arrays keep pointers to mmap buffer objects to serve according to maps thread mask. Thread local pollfd array keeps event fds connected to mmaps buffers according to maps thread mask. Thread control commands are delivered via thread local comm pipes and ctlfd_pos fd. External control commands (--control option) are delivered via evlist ctlfd_pos fd and handled by the main tool thread. Signed-off-by: Alexey Budankov --- tools/lib/api/fd/array.c | 17 ++++ tools/lib/api/fd/array.h | 1 + tools/perf/builtin-record.c | 191 +++++++++++++++++++++++++++++++++++- 3 files changed, 206 insertions(+), 3 deletions(-) diff --git a/tools/lib/api/fd/array.c b/tools/lib/api/fd/array.c index 5e6cb9debe37..de8bcbaea3f1 100644 --- a/tools/lib/api/fd/array.c +++ b/tools/lib/api/fd/array.c @@ -88,6 +88,23 @@ int fdarray__add(struct fdarray *fda, int fd, short revents, enum fdarray_flags return pos; } +int fdarray__clone(struct fdarray *fda, int pos, struct fdarray *base) +{ + struct pollfd *entry; + int npos; + + if (pos >= base->nr) + return -EINVAL; + + entry = &base->entries[pos]; + + npos = fdarray__add(fda, entry->fd, entry->events, base->priv[pos].flags); + if (npos >= 0) + fda->priv[npos] = base->priv[pos]; + + return npos; +} + int fdarray__filter(struct fdarray *fda, short revents, void (*entry_destructor)(struct fdarray *fda, int fd, void *arg), void *arg) diff --git a/tools/lib/api/fd/array.h b/tools/lib/api/fd/array.h index 7fcf21a33c0c..4a03da7f1fc1 100644 --- a/tools/lib/api/fd/array.h +++ b/tools/lib/api/fd/array.h @@ -42,6 +42,7 @@ struct fdarray *fdarray__new(int nr_alloc, int nr_autogrow); void fdarray__delete(struct fdarray *fda); int fdarray__add(struct fdarray *fda, int fd, short revents, enum fdarray_flags flags); +int fdarray__clone(struct fdarray *fda, int pos, struct fdarray *base); int fdarray__poll(struct fdarray *fda, int timeout); int fdarray__filter(struct fdarray *fda, short revents, void (*entry_destructor)(struct fdarray *fda, int fd, void *arg), diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c index 82f009703ad7..765a90e38f69 100644 --- a/tools/perf/builtin-record.c +++ b/tools/perf/builtin-record.c @@ -56,6 +56,7 @@ #include #include #include +#include #include #include #ifdef HAVE_EVENTFD_SUPPORT @@ -90,6 +91,24 @@ struct thread_mask { struct mmap_cpu_mask affinity; }; +struct thread_data { + pid_t tid; + struct thread_mask *mask; + struct { + int msg[2]; + int ack[2]; + } comm; + struct fdarray pollfd; + int ctlfd_pos; + struct mmap **maps; + struct mmap **overwrite_maps; + int nr_mmaps; + struct record *rec; + unsigned long long samples; + unsigned long waking; + u64 bytes_written; +}; + struct record { struct perf_tool tool; struct record_opts opts; @@ -114,6 +133,7 @@ struct record { struct mmap_cpu_mask affinity_mask; unsigned long output_max_size; /* = 0: unlimited */ struct thread_mask *thread_masks; + struct thread_data *thread_data; int nr_threads; }; @@ -842,9 +862,168 @@ static int record__kcore_copy(struct machine *machine, struct perf_data *data) return kcore_copy(from_dir, kcore_dir); } +static int record__thread_data_init_comm(struct thread_data *thread_data) +{ + if (pipe(thread_data->comm.msg) || pipe(thread_data->comm.ack)) { + pr_err("Failed to create thread comm pipes, error %m\n"); + return -ENOMEM; + } + + pr_debug("thread_data[%p]: msg=[%d,%d], ack=[%d,%d]\n", thread_data, + thread_data->comm.msg[0], thread_data->comm.msg[1], + thread_data->comm.ack[0], thread_data->comm.ack[1]); + + return 0; +} + +static int record__thread_data_init_maps(struct thread_data *thread_data, struct evlist *evlist) +{ + int m, tm, nr_mmaps = evlist->core.nr_mmaps; + struct mmap *mmap = evlist->mmap; + struct mmap *overwrite_mmap = evlist->overwrite_mmap; + struct perf_cpu_map *cpus = evlist->core.cpus; + + thread_data->nr_mmaps = bitmap_weight(thread_data->mask->maps.bits, thread_data->mask->maps.nbits); + if (mmap) { + thread_data->maps = zalloc(thread_data->nr_mmaps * sizeof(struct mmap *)); + if (!thread_data->maps) { + pr_err("Failed to allocate maps thread data\n"); + return -ENOMEM; + } + } + if (overwrite_mmap) { + thread_data->overwrite_maps = zalloc(thread_data->nr_mmaps * sizeof(struct mmap *)); + if (!thread_data->overwrite_maps) { + pr_err("Failed to allocate overwrite maps thread data\n"); + return -ENOMEM; + } + } + pr_debug("thread_data[%p]: nr_mmaps=%d, maps=%p, overwrite_maps=%p\n", thread_data, + thread_data->nr_mmaps, thread_data->maps, thread_data->overwrite_maps); + + for (m = 0, tm = 0; m < nr_mmaps && tm < thread_data->nr_mmaps; m++) { + if (test_bit(cpus->map[m], thread_data->mask->maps.bits)) { + if (thread_data->maps) { + thread_data->maps[tm] = &mmap[m]; + pr_debug("thread_data[%p]: maps[%d] -> mmap[%d], cpus[%d]\n", + thread_data, tm, m, cpus->map[m]); + } + if (thread_data->overwrite_maps) { + thread_data->overwrite_maps[tm] = &overwrite_mmap[m]; + pr_debug("thread_data[%p]: overwrite_maps[%d] -> overwrite_mmap[%d], cpus[%d]\n", + thread_data, tm, m, cpus->map[m]); + } + tm++; + } + } + + return 0; +} + +static int record__thread_data_init_pollfd(struct thread_data *thread_data, struct evlist *evlist) +{ + int f, tm, pos; + struct mmap *map, *overwrite_map; + + fdarray__init(&thread_data->pollfd, 64); + + for (tm = 0; tm < thread_data->nr_mmaps; tm++) { + map = thread_data->maps ? thread_data->maps[tm] : NULL; + overwrite_map = thread_data->overwrite_maps ? thread_data->overwrite_maps[tm] : NULL; + + for (f = 0; f < evlist->core.pollfd.nr; f++) { + void *ptr = evlist->core.pollfd.priv[f].ptr; + + if ((map && ptr == map) || (overwrite_map && ptr == overwrite_map)) { + pos = fdarray__clone(&thread_data->pollfd, f, &evlist->core.pollfd); + if (pos < 0) + return pos; + pr_debug("thread_data[%p]: pollfd[%d] <- event_fd=%d\n", + thread_data, pos, evlist->core.pollfd.entries[f].fd); + } + } + } + + return 0; +} + +static int record__alloc_thread_data(struct record *rec, struct evlist *evlist) +{ + int t, ret; + struct thread_data *thread_data; + + thread_data = zalloc(rec->nr_threads * sizeof(*(rec->thread_data))); + if (!thread_data) { + pr_err("Failed to allocate thread data\n"); + return -ENOMEM; + } + + for (t = 0; t < rec->nr_threads; t++) { + thread_data[t].rec = rec; + thread_data[t].mask = &rec->thread_masks[t]; + ret = record__thread_data_init_maps(&thread_data[t], evlist); + if (ret) + return ret; + ret = record__thread_data_init_pollfd(&thread_data[t], evlist); + if (ret) + return ret; + if (t) { + thread_data[t].tid = -1; + ret = record__thread_data_init_comm(&thread_data[t]); + if (ret) + return ret; + thread_data[t].ctlfd_pos = fdarray__add(&thread_data[t].pollfd, + thread_data[t].comm.msg[0], + POLLIN | POLLERR | POLLHUP, + fdarray_flag__nonfilterable); + if (thread_data[t].ctlfd_pos < 0) + return -ENOMEM; + pr_debug("thread_data[%p]: pollfd[%d] <- ctl_fd=%d\n", + thread_data, thread_data[t].ctlfd_pos, + thread_data[t].comm.msg[0]); + } else { + thread_data[t].tid = syscall(SYS_gettid); + if (evlist->ctl_fd.pos == -1) + continue; + thread_data[t].ctlfd_pos = fdarray__clone(&thread_data[t].pollfd, + evlist->ctl_fd.pos, + &evlist->core.pollfd); + if (ret < 0) + return ret; + pr_debug("thread_data[%p]: pollfd[%d] <- ctl_fd=%d\n", + thread_data, thread_data[t].ctlfd_pos, + evlist->core.pollfd.entries[evlist->ctl_fd.pos].fd); + } + } + + rec->thread_data = thread_data; + + return 0; +} + +static int record__free_thread_data(struct record *rec) +{ + int t; + + for (t = 0; t < rec->nr_threads; t++) { + close(rec->thread_data[t].comm.msg[0]); + close(rec->thread_data[t].comm.msg[1]); + close(rec->thread_data[t].comm.ack[0]); + close(rec->thread_data[t].comm.ack[1]); + zfree(&rec->thread_data[t].maps); + zfree(&rec->thread_data[t].overwrite_maps); + fdarray__exit(&rec->thread_data[t].pollfd); + } + + zfree(&rec->thread_data); + + return 0; +} + static int record__mmap_evlist(struct record *rec, struct evlist *evlist) { + int ret; struct record_opts *opts = &rec->opts; bool auxtrace_overwrite = opts->auxtrace_snapshot_mode || opts->auxtrace_sample_mode; @@ -875,6 +1054,14 @@ static int record__mmap_evlist(struct record *rec, return -EINVAL; } } + + if (evlist__initialize_ctlfd(evlist, opts->ctl_fd, opts->ctl_fd_ack)) + return -1; + + ret = record__alloc_thread_data(rec, evlist); + if (ret) + return ret; + return 0; } @@ -1845,9 +2032,6 @@ static int __cmd_record(struct record *rec, int argc, const char **argv) perf_evlist__start_workload(rec->evlist); } - if (evlist__initialize_ctlfd(rec->evlist, opts->ctl_fd, opts->ctl_fd_ack)) - goto out_child; - if (opts->initial_delay) { pr_info(EVLIST_DISABLED_MSG); if (opts->initial_delay > 0) { @@ -1998,6 +2182,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv) record__synthesize_workload(rec, true); out_child: + record__free_thread_data(rec); evlist__finalize_ctlfd(rec->evlist); record__mmap_read_all(rec, true); record__aio_mmap_read_sync(rec); -- 2.24.1