From patchwork Tue Jul 12 10:00:09 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Nan X-Patchwork-Id: 71809 Delivered-To: patch@linaro.org Received: by 10.140.29.52 with SMTP id a49csp385181qga; Tue, 12 Jul 2016 03:03:20 -0700 (PDT) X-Received: by 10.98.35.27 with SMTP id j27mr43407498pfj.10.1468317788931; Tue, 12 Jul 2016 03:03:08 -0700 (PDT) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b6si3187478pay.102.2016.07.12.03.03.08; Tue, 12 Jul 2016 03:03:08 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932808AbcGLKDC (ORCPT + 30 others); Tue, 12 Jul 2016 06:03:02 -0400 Received: from szxga03-in.huawei.com ([119.145.14.66]:63855 "EHLO szxga03-in.huawei.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932503AbcGLKA5 (ORCPT ); Tue, 12 Jul 2016 06:00:57 -0400 Received: from 172.24.1.47 (EHLO szxeml425-hub.china.huawei.com) ([172.24.1.47]) by szxrg03-dlp.huawei.com (MOS 4.4.3-GA FastPath queued) with ESMTP id CEQ51181; Tue, 12 Jul 2016 18:00:34 +0800 (CST) Received: from linux-4hy3.site (10.107.193.248) by szxeml425-hub.china.huawei.com (10.82.67.180) with Microsoft SMTP Server id 14.3.235.1; Tue, 12 Jul 2016 18:00:24 +0800 From: Wang Nan To: , CC: , , , Wang Nan , He Kuang , "Arnaldo Carvalho de Melo" , Jiri Olsa , "Masami Hiramatsu" , Namhyung Kim , "Nilay Vaish" Subject: [PATCH v15 09/12] perf record: Read from overwritable ring buffer Date: Tue, 12 Jul 2016 10:00:09 +0000 Message-ID: <1468317612-11598-10-git-send-email-wangnan0@huawei.com> X-Mailer: git-send-email 1.8.3.4 In-Reply-To: <1468317612-11598-1-git-send-email-wangnan0@huawei.com> References: <1468317612-11598-1-git-send-email-wangnan0@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.107.193.248] X-CFilter-Loop: Reflected X-Mirapoint-Virus-RAPID-Raw: score=unknown(0), refid=str=0001.0A020205.5784BFC3.0156, ss=1, re=0.000, recu=0.000, reip=0.000, cl=1, cld=1, fgs=0, ip=0.0.0.0, so=2013-05-26 15:14:31, dmn=2013-03-21 17:37:32 X-Mirapoint-Loop-Id: 8b37c8eddbe16f7acb176c77b4cf5d8a Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org overwrite_evt_state is introduced to reflect the state of overwritable ring buffers. It is a state machine with following states: .________________(forbid)_____________. | V RUNNING --(1)--> DATA_PENDING --(2)--> EMPTY ^ ^ | ^ | | |__(forbid)____/ |___(forbid)___/| | | \_________________(3)_______________/ RUNNING : Overwritable ring buffers are recording DATA_PENDING : We are required to collect overwritable ring buffers EMPTY : We have collected data from those ring buffers. (1): Pause ring buffers for reading (2): Read from ring buffers (3): Resume ring buffers for recording We can't avoid this complexity. Since we deliberately drop records from overwritable ring buffer, there's no way for us to check remaining from ring buffer itself (by checking head and old pointers). Therefore, we need DATA_PENDING and EMPTY state to help us recording what we have done to the ring buffer. With the above state machine, this patch improves record__mmap_read_all(), read from overwritable ring buffer when DATA_PENDING state is observed. Signed-off-by: Wang Nan Signed-off-by: He Kuang Cc: Arnaldo Carvalho de Melo Cc: Jiri Olsa Cc: Masami Hiramatsu Cc: Namhyung Kim Cc: Zefan Li Cc: Nilay Vaish Cc: pi3orama@163.com --- tools/perf/builtin-record.c | 157 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 146 insertions(+), 11 deletions(-) -- 1.8.3.4 diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c index f89a4a6..b395e89 100644 --- a/tools/perf/builtin-record.c +++ b/tools/perf/builtin-record.c @@ -43,6 +43,30 @@ #include #include +/* + * State machine of overwrite_evt_state: + * + * .________________(forbid)_____________. + * | V + * RUNNING --(1)--> DATA_PENDING --(2)--> EMPTY + * ^ ^ | ^ | + * | |__(forbid)____/ |___(forbid)___/| + * | | + * \_________________(3)_______________/ + * + * RUNNING : Overwritable ring buffers are recording + * DATA_PENDING : We are required to collect overwritable ring buffers + * EMPTY : We have collected data from those ring buffers. + * + * (1): Pause ring buffers for reading + * (2): Read from ring buffers + * (3): Resume ring buffers for recording + */ +enum overwrite_evt_state { + OVERWRITE_EVT_RUNNING, + OVERWRITE_EVT_DATA_PENDING, + OVERWRITE_EVT_EMPTY, +}; struct record { struct perf_tool tool; @@ -61,6 +85,7 @@ struct record { bool buildid_all; bool timestamp_filename; bool switch_output; + enum overwrite_evt_state overwrite_evt_state; unsigned long long samples; }; @@ -131,9 +156,10 @@ rb_find_range(void *data, int mask, u64 head, u64 old, return backward_rb_find_range(data, mask, head, start, end); } -static int record__mmap_read(struct record *rec, struct perf_evlist *evlist, int idx) +static int +record__mmap_read(struct record *rec, struct perf_mmap *md, + bool overwrite, bool backward) { - struct perf_mmap *md = &evlist->mmap[idx]; u64 head = perf_mmap__read_head(md); u64 old = md->prev; u64 end = head, start = old; @@ -143,7 +169,7 @@ static int record__mmap_read(struct record *rec, struct perf_evlist *evlist, int int rc = 0; if (rb_find_range(data, md->mask, head, - old, &start, &end, false)) + old, &start, &end, backward)) return -1; if (start == end) @@ -156,7 +182,7 @@ static int record__mmap_read(struct record *rec, struct perf_evlist *evlist, int WARN_ONCE(1, "failed to keep up with mmap data. (warn only once)\n"); md->prev = head; - perf_evlist__mmap_consume(evlist, idx); + perf_mmap__consume(md, overwrite || backward); return 0; } @@ -181,7 +207,7 @@ static int record__mmap_read(struct record *rec, struct perf_evlist *evlist, int } md->prev = head; - perf_evlist__mmap_consume(evlist, idx); + perf_mmap__consume(md, overwrite || backward); out: return rc; } @@ -341,6 +367,75 @@ int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused) #endif +static void +record__toggle_overwrite_evlist(struct record *rec, + enum overwrite_evt_state state) +{ + enum overwrite_evt_state old_state = rec->overwrite_evt_state; + enum action { + NONE, + PAUSE, + RESUME, + } action = NONE; + + switch (old_state) { + case OVERWRITE_EVT_RUNNING: { + switch (state) { + case OVERWRITE_EVT_DATA_PENDING: + action = PAUSE; + break; + case OVERWRITE_EVT_RUNNING: + case OVERWRITE_EVT_EMPTY: + default: + goto state_err; + } + break; + } + case OVERWRITE_EVT_DATA_PENDING: { + switch (state) { + case OVERWRITE_EVT_EMPTY: + break; + case OVERWRITE_EVT_RUNNING: + case OVERWRITE_EVT_DATA_PENDING: + default: + goto state_err; + } + break; + } + case OVERWRITE_EVT_EMPTY: { + switch (state) { + case OVERWRITE_EVT_RUNNING: + action = RESUME; + break; + case OVERWRITE_EVT_EMPTY: + case OVERWRITE_EVT_DATA_PENDING: + default: + goto state_err; + } + break; + } + default: + WARN_ONCE(1, "Shouldn't get there\n"); + } + + rec->overwrite_evt_state = state; + + switch (action) { + case PAUSE: + perf_evlist__pause(rec->evlist); + break; + case RESUME: + perf_evlist__resume(rec->evlist); + break; + case NONE: + default: + break; + } + +state_err: + return; +} + static int record__mmap_evlist(struct record *rec, struct perf_evlist *evlist) { @@ -417,6 +512,7 @@ try_again: session->evlist = evlist; perf_session__set_id_hdr_size(session); + rec->overwrite_evt_state = OVERWRITE_EVT_RUNNING; out: return rc; } @@ -497,20 +593,23 @@ static struct perf_event_header finished_round_event = { .type = PERF_RECORD_FINISHED_ROUND, }; -static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist) +static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist, + bool backward) { u64 bytes_written = rec->bytes_written; int i; int rc = 0; + struct perf_mmap *maps = backward ? evlist->backward_mmap : evlist->mmap; if (!evlist) return 0; for (i = 0; i < evlist->nr_mmaps; i++) { - struct auxtrace_mmap *mm = &evlist->mmap[i].auxtrace_mmap; + struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap; - if (evlist->mmap[i].base) { - if (record__mmap_read(rec, evlist, i) != 0) { + if (maps[i].base) { + if (record__mmap_read(rec, &maps[i], + evlist->overwrite, backward) != 0) { rc = -1; goto out; } @@ -538,11 +637,17 @@ static int record__mmap_read_all(struct record *rec) { int err; - err = record__mmap_read_evlist(rec, rec->evlist); + err = record__mmap_read_evlist(rec, rec->evlist, false); if (err) return err; - return err; + if (rec->overwrite_evt_state == OVERWRITE_EVT_DATA_PENDING) { + err = record__mmap_read_evlist(rec, rec->evlist, true); + if (err) + return err; + record__toggle_overwrite_evlist(rec, OVERWRITE_EVT_EMPTY); + } + return 0; } static void record__init_features(struct record *rec) @@ -936,6 +1041,17 @@ static int __cmd_record(struct record *rec, int argc, const char **argv) for (;;) { unsigned long long hits = rec->samples; + /* + * rec->overwrite_evt_state is possible to be + * OVERWRITE_EVT_EMPTY here: when done == true and + * hits != rec->samples in previous round. + * + * record__toggle_overwrite_evlist ensure we never + * convert OVERWRITE_EVT_EMPTY to OVERWRITE_EVT_DATA_PENDING. + */ + if (trigger_is_hit(&switch_output_trigger) || done || draining) + record__toggle_overwrite_evlist(rec, OVERWRITE_EVT_DATA_PENDING); + if (record__mmap_read_all(rec) < 0) { trigger_error(&auxtrace_snapshot_trigger); trigger_error(&switch_output_trigger); @@ -955,8 +1071,27 @@ static int __cmd_record(struct record *rec, int argc, const char **argv) } if (trigger_is_hit(&switch_output_trigger)) { + /* + * If switch_output_trigger is hit, the data in + * overwritable ring buffer should have been collected, + * so overwrite_evt_state should be set to + * OVERWRITE_EVT_EMPTY. + * + * If SIGUSR2 raise after or during record__mmap_read_all(), + * record__mmap_read_all() didn't collect data from + * overwritable ring buffer. Read again. + */ + if (rec->overwrite_evt_state == OVERWRITE_EVT_RUNNING) + continue; trigger_ready(&switch_output_trigger); + /* + * Reenable events in overwrite ring buffer after + * record__mmap_read_all(): we should have collected + * data from it. + */ + record__toggle_overwrite_evlist(rec, OVERWRITE_EVT_RUNNING); + if (!quiet) fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n", waking);