lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

perf tools: Allow specifying proc-map-timeout in config file

Browse Source 
The default timeout of 500ms for parsing /proc/<pid>/maps files is too
short for profiling many of our services.

This can be overridden by passing --proc-map-timeout to the relevant
command but it'd be nice to globally increase our default value.

This patch permits setting a different default with the
core.proc-map-timeout config file parameter.

Signed-off-by: Mark Drayton <mbd@fb.com>
Acked-by: Song Liu <songliubraving@fb.com>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20181204203420.1683114-1-mbd@fb.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Mark Drayton 2018-12-04 12:34:20 -08:00 committed by Arnaldo Carvalho de Melo
parent 65c9fee2da
commit 3fcb10e496
14 changed files with 39 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tools/perf/Documentation/perf-config.txt
View File

@ -199,6 +199,12 @@ colors.*::
Colors for headers in the output of a sub-commands (top, report). Colors for headers in the output of a sub-commands (top, report).
Default values are 'white', 'blue'. Default values are 'white', 'blue'.
core.*::
core.proc-map-timeout::
Sets a timeout (in milliseconds) for parsing /proc/<pid>/maps files.
Can be overridden by the --proc-map-timeout option on supported
subcommands. The default timeout is 500ms.
tui.*, gtk.*:: tui.*, gtk.*::
Subcommands that can be configured here are 'top', 'report' and 'annotate'. Subcommands that can be configured here are 'top', 'report' and 'annotate'.
These values are booleans, for example: These values are booleans, for example:

6
tools/perf/builtin-kvm.c
View File

@ -1364,7 +1364,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
"show events other than" "show events other than"
" HLT (x86 only) or Wait state (s390 only)" " HLT (x86 only) or Wait state (s390 only)"
" that take longer than duration usecs"), " that take longer than duration usecs"),
OPT_UINTEGER(0, "proc-map-timeout", &kvm->opts.proc_map_timeout, OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
"per thread proc mmap processing timeout in ms"), "per thread proc mmap processing timeout in ms"),
OPT_END() OPT_END()
}; };
@ -1394,7 +1394,6 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
kvm->opts.target.uses_mmap = false; kvm->opts.target.uses_mmap = false;
kvm->opts.target.uid_str = NULL; kvm->opts.target.uid_str = NULL;
kvm->opts.target.uid = UINT_MAX; kvm->opts.target.uid = UINT_MAX;
kvm->opts.proc_map_timeout = 500;
symbol__init(NULL); symbol__init(NULL);
disable_buildid_cache(); disable_buildid_cache();
@ -1453,8 +1452,7 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
perf_session__set_id_hdr_size(kvm->session); perf_session__set_id_hdr_size(kvm->session);
ordered_events__set_copy_on_queue(&kvm->session->ordered_events, true); ordered_events__set_copy_on_queue(&kvm->session->ordered_events, true);
machine__synthesize_threads(&kvm->session->machines.host, &kvm->opts.target, machine__synthesize_threads(&kvm->session->machines.host, &kvm->opts.target,
kvm->evlist->threads, false, kvm->evlist->threads, false, 1);
kvm->opts.proc_map_timeout, 1);
err = kvm_live_open_events(kvm); err = kvm_live_open_events(kvm);
if (err) if (err)
goto out; goto out;

8
tools/perf/builtin-record.c
View File

@ -867,8 +867,7 @@ static int record__synthesize_workload(struct record *rec, bool tail)
err = perf_event__synthesize_thread_map(&rec->tool, thread_map, err = perf_event__synthesize_thread_map(&rec->tool, thread_map,
process_synthesized_event, process_synthesized_event,
&rec->session->machines.host, &rec->session->machines.host,
rec->opts.sample_address, rec->opts.sample_address);
rec->opts.proc_map_timeout);
thread_map__put(thread_map); thread_map__put(thread_map);
return err; return err;
} }
@ -1085,7 +1084,7 @@ static int record__synthesize(struct record *rec, bool tail)
err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads, err = __machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,
process_synthesized_event, opts->sample_address, process_synthesized_event, opts->sample_address,
opts->proc_map_timeout, 1); 1);
out: out:
return err; return err;
} }
@ -1783,7 +1782,6 @@ static struct record record = {
.uses_mmap = true, .uses_mmap = true,
.default_per_cpu = true, .default_per_cpu = true,
}, },
.proc_map_timeout = 500,
}, },
.tool = { .tool = {
.sample = process_sample_event, .sample = process_sample_event,
@ -1913,7 +1911,7 @@ static struct option __record_options[] = {
parse_clockid), parse_clockid),
OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts, OPT_STRING_OPTARG('S', "snapshot", &record.opts.auxtrace_snapshot_opts,
"opts", "AUX area tracing Snapshot Mode", ""), "opts", "AUX area tracing Snapshot Mode", ""),
OPT_UINTEGER(0, "proc-map-timeout", &record.opts.proc_map_timeout, OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
"per thread proc mmap processing timeout in ms"), "per thread proc mmap processing timeout in ms"),
OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces, OPT_BOOLEAN(0, "namespaces", &record.opts.record_namespaces,
"Record namespaces events"), "Record namespaces events"),

4
tools/perf/builtin-top.c
View File

@ -1096,7 +1096,6 @@ static int __cmd_top(struct perf_top *top)
machine__synthesize_threads(&top->session->machines.host, &opts->target, machine__synthesize_threads(&top->session->machines.host, &opts->target,
top->evlist->threads, false, top->evlist->threads, false,
opts->proc_map_timeout,
top->nr_threads_synthesize); top->nr_threads_synthesize);
if (top->nr_threads_synthesize > 1) if (top->nr_threads_synthesize > 1)
@ -1256,7 +1255,6 @@ int cmd_top(int argc, const char **argv)
.target = { .target = {
.uses_mmap = true, .uses_mmap = true,
}, },
.proc_map_timeout = 500,
/* /*
* FIXME: This will lose PERF_RECORD_MMAP and other metadata * FIXME: This will lose PERF_RECORD_MMAP and other metadata
* when we pause, fix that and reenable. Probably using a * when we pause, fix that and reenable. Probably using a
@ -1369,7 +1367,7 @@ int cmd_top(int argc, const char **argv)
OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str, OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
"width[,width...]", "width[,width...]",
"don't try to adjust column width, use these fixed values"), "don't try to adjust column width, use these fixed values"),
OPT_UINTEGER(0, "proc-map-timeout", &opts->proc_map_timeout, OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
"per thread proc mmap processing timeout in ms"), "per thread proc mmap processing timeout in ms"),
OPT_CALLBACK_NOOPT('b', "branch-any", &opts->branch_stack, OPT_CALLBACK_NOOPT('b', "branch-any", &opts->branch_stack,
"branch any", "sample any taken branches", "branch any", "sample any taken branches",

5
tools/perf/builtin-trace.c
View File

@ -1264,7 +1264,7 @@ static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target, err = __machine__synthesize_threads(trace->host, &trace->tool, &trace->opts.target,
evlist->threads, trace__tool_process, false, evlist->threads, trace__tool_process, false,
trace->opts.proc_map_timeout, 1); 1);
out: out:
if (err) if (err)
symbol__exit(); symbol__exit();
@ -3393,7 +3393,6 @@ int cmd_trace(int argc, const char **argv)
.user_interval = ULLONG_MAX, .user_interval = ULLONG_MAX,
.no_buffering = true, .no_buffering = true,
.mmap_pages = UINT_MAX, .mmap_pages = UINT_MAX,
.proc_map_timeout = 500,
}, },
.output = stderr, .output = stderr,
.show_comm = true, .show_comm = true,
@ -3464,7 +3463,7 @@ int cmd_trace(int argc, const char **argv)
"Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)), "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
OPT_BOOLEAN(0, "print-sample", &trace.print_sample, OPT_BOOLEAN(0, "print-sample", &trace.print_sample,
"print the PERF_RECORD_SAMPLE PERF_SAMPLE_ info, for debugging"), "print the PERF_RECORD_SAMPLE PERF_SAMPLE_ info, for debugging"),
OPT_UINTEGER(0, "proc-map-timeout", &trace.opts.proc_map_timeout, OPT_UINTEGER(0, "proc-map-timeout", &proc_map_timeout,
"per thread proc mmap processing timeout in ms"), "per thread proc mmap processing timeout in ms"),
OPT_CALLBACK('G', "cgroup", &trace, "name", "monitor event in cgroup name only", OPT_CALLBACK('G', "cgroup", &trace, "name", "monitor event in cgroup name only",
trace__parse_cgroups), trace__parse_cgroups),

1
tools/perf/perf.h
View File

@ -82,7 +82,6 @@ struct record_opts {
bool use_clockid; bool use_clockid;
clockid_t clockid; clockid_t clockid;
u64 clockid_res_ns; u64 clockid_res_ns;
unsigned int proc_map_timeout;
int nr_cblocks; int nr_cblocks;
}; };

2
tools/perf/tests/code-reading.c
View File

@ -599,7 +599,7 @@ static int do_test_code_reading(bool try_kcore)
} }
ret = perf_event__synthesize_thread_map(NULL, threads, ret = perf_event__synthesize_thread_map(NULL, threads,
perf_event__process, machine, false, 500); perf_event__process, machine, false);
if (ret < 0) { if (ret < 0) {
pr_debug("perf_event__synthesize_thread_map failed\n"); pr_debug("perf_event__synthesize_thread_map failed\n");
goto out_err; goto out_err;

2
tools/perf/tests/dwarf-unwind.c
View File

@ -34,7 +34,7 @@ static int init_live_machine(struct machine *machine)
pid_t pid = getpid(); pid_t pid = getpid();
return perf_event__synthesize_mmap_events(NULL, &event, pid, pid, return perf_event__synthesize_mmap_events(NULL, &event, pid, pid,
mmap_handler, machine, true, 500); mmap_handler, machine, true);
} }
/* /*

4
tools/perf/tests/mmap-thread-lookup.c
View File

@ -132,7 +132,7 @@ static int synth_all(struct machine *machine)
{ {
return perf_event__synthesize_threads(NULL, return perf_event__synthesize_threads(NULL,
perf_event__process, perf_event__process,
machine, 0, 500, 1); machine, 0, 1);
} }
static int synth_process(struct machine *machine) static int synth_process(struct machine *machine)
@ -144,7 +144,7 @@ static int synth_process(struct machine *machine)
err = perf_event__synthesize_thread_map(NULL, map, err = perf_event__synthesize_thread_map(NULL, map,
perf_event__process, perf_event__process,
machine, 0, 500); machine, 0);
thread_map__put(map); thread_map__put(map);
return err; return err;

4
tools/perf/util/config.c
View File

@ -14,6 +14,7 @@
#include "util.h" #include "util.h"
#include "cache.h" #include "cache.h"
#include <subcmd/exec-cmd.h> #include <subcmd/exec-cmd.h>
#include "util/event.h" /* proc_map_timeout */
#include "util/hist.h" /* perf_hist_config */ #include "util/hist.h" /* perf_hist_config */
#include "util/llvm-utils.h" /* perf_llvm_config */ #include "util/llvm-utils.h" /* perf_llvm_config */
#include "config.h" #include "config.h"
@ -419,6 +420,9 @@ static int perf_buildid_config(const char *var, const char *value)
static int perf_default_core_config(const char *var __maybe_unused, static int perf_default_core_config(const char *var __maybe_unused,
const char *value __maybe_unused) const char *value __maybe_unused)
{ {
if (!strcmp(var, "core.proc-map-timeout"))
proc_map_timeout = strtoul(value, NULL, 10);
/* Add other config variables here. */ /* Add other config variables here. */
return 0; return 0;
} }

32
tools/perf/util/event.c
View File

@ -25,6 +25,8 @@
#include "asm/bug.h" #include "asm/bug.h"
#include "stat.h" #include "stat.h"
#define DEFAULT_PROC_MAP_PARSE_TIMEOUT 500
static const char *perf_event__names[] = { static const char *perf_event__names[] = {
[0] = "TOTAL", [0] = "TOTAL",
[PERF_RECORD_MMAP] = "MMAP", [PERF_RECORD_MMAP] = "MMAP",
@ -72,6 +74,8 @@ static const char *perf_ns__names[] = {
[CGROUP_NS_INDEX] = "cgroup", [CGROUP_NS_INDEX] = "cgroup",
}; };
unsigned int proc_map_timeout = DEFAULT_PROC_MAP_PARSE_TIMEOUT;
const char *perf_event__name(unsigned int id) const char *perf_event__name(unsigned int id)
{ {
if (id >= ARRAY_SIZE(perf_event__names)) if (id >= ARRAY_SIZE(perf_event__names))
@ -323,8 +327,7 @@ int perf_event__synthesize_mmap_events(struct perf_tool *tool,
pid_t pid, pid_t tgid, pid_t pid, pid_t tgid,
perf_event__handler_t process, perf_event__handler_t process,
struct machine *machine, struct machine *machine,
bool mmap_data, bool mmap_data)
unsigned int proc_map_timeout)
{ {
char filename[PATH_MAX]; char filename[PATH_MAX];
FILE *fp; FILE *fp;
@ -521,8 +524,7 @@ static int __event__synthesize_thread(union perf_event *comm_event,
perf_event__handler_t process, perf_event__handler_t process,
struct perf_tool *tool, struct perf_tool *tool,
struct machine *machine, struct machine *machine,
bool mmap_data, bool mmap_data)
unsigned int proc_map_timeout)
{ {
char filename[PATH_MAX]; char filename[PATH_MAX];
DIR *tasks; DIR *tasks;
@ -548,8 +550,7 @@ static int __event__synthesize_thread(union perf_event *comm_event,
*/ */
if (pid == tgid && if (pid == tgid &&
perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid, perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
process, machine, mmap_data, process, machine, mmap_data))
proc_map_timeout))
return -1; return -1;
return 0; return 0;
@ -598,7 +599,7 @@ static int __event__synthesize_thread(union perf_event *comm_event,
if (_pid == pid) { if (_pid == pid) {
/* process the parent's maps too */ /* process the parent's maps too */
rc = perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid, rc = perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
process, machine, mmap_data, proc_map_timeout); process, machine, mmap_data);
if (rc) if (rc)
break; break;
} }
@ -612,8 +613,7 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
struct thread_map *threads, struct thread_map *threads,
perf_event__handler_t process, perf_event__handler_t process,
struct machine *machine, struct machine *machine,
bool mmap_data, bool mmap_data)
unsigned int proc_map_timeout)
{ {
union perf_event *comm_event, *mmap_event, *fork_event; union perf_event *comm_event, *mmap_event, *fork_event;
union perf_event *namespaces_event; union perf_event *namespaces_event;
@ -643,7 +643,7 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
fork_event, namespaces_event, fork_event, namespaces_event,
thread_map__pid(threads, thread), 0, thread_map__pid(threads, thread), 0,
process, tool, machine, process, tool, machine,
mmap_data, proc_map_timeout)) { mmap_data)) {
err = -1; err = -1;
break; break;
} }
@ -669,7 +669,7 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
fork_event, namespaces_event, fork_event, namespaces_event,
comm_event->comm.pid, 0, comm_event->comm.pid, 0,
process, tool, machine, process, tool, machine,
mmap_data, proc_map_timeout)) { mmap_data)) {
err = -1; err = -1;
break; break;
} }
@ -690,7 +690,6 @@ static int __perf_event__synthesize_threads(struct perf_tool *tool,
perf_event__handler_t process, perf_event__handler_t process,
struct machine *machine, struct machine *machine,
bool mmap_data, bool mmap_data,
unsigned int proc_map_timeout,
struct dirent **dirent, struct dirent **dirent,
int start, int start,
int num) int num)
@ -734,8 +733,7 @@ static int __perf_event__synthesize_threads(struct perf_tool *tool,
*/ */
__event__synthesize_thread(comm_event, mmap_event, fork_event, __event__synthesize_thread(comm_event, mmap_event, fork_event,
namespaces_event, pid, 1, process, namespaces_event, pid, 1, process,
tool, machine, mmap_data, tool, machine, mmap_data);
proc_map_timeout);
} }
err = 0; err = 0;
@ -755,7 +753,6 @@ struct synthesize_threads_arg {
perf_event__handler_t process; perf_event__handler_t process;
struct machine *machine; struct machine *machine;
bool mmap_data; bool mmap_data;
unsigned int proc_map_timeout;
struct dirent **dirent; struct dirent **dirent;
int num; int num;
int start; int start;
@ -767,7 +764,7 @@ static void *synthesize_threads_worker(void *arg)
__perf_event__synthesize_threads(args->tool, args->process, __perf_event__synthesize_threads(args->tool, args->process,
args->machine, args->mmap_data, args->machine, args->mmap_data,
args->proc_map_timeout, args->dirent, args->dirent,
args->start, args->num); args->start, args->num);
return NULL; return NULL;
} }
@ -776,7 +773,6 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
perf_event__handler_t process, perf_event__handler_t process,
struct machine *machine, struct machine *machine,
bool mmap_data, bool mmap_data,
unsigned int proc_map_timeout,
unsigned int nr_threads_synthesize) unsigned int nr_threads_synthesize)
{ {
struct synthesize_threads_arg *args = NULL; struct synthesize_threads_arg *args = NULL;
@ -806,7 +802,6 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
if (thread_nr <= 1) { if (thread_nr <= 1) {
err = __perf_event__synthesize_threads(tool, process, err = __perf_event__synthesize_threads(tool, process,
machine, mmap_data, machine, mmap_data,
proc_map_timeout,
dirent, base, n); dirent, base, n);
goto free_dirent; goto free_dirent;
} }
@ -828,7 +823,6 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
args[i].process = process; args[i].process = process;
args[i].machine = machine; args[i].machine = machine;
args[i].mmap_data = mmap_data; args[i].mmap_data = mmap_data;
args[i].proc_map_timeout = proc_map_timeout;
args[i].dirent = dirent; args[i].dirent = dirent;
} }
for (i = 0; i < m; i++) { for (i = 0; i < m; i++) {

8
tools/perf/util/event.h
View File

@ -669,8 +669,7 @@ typedef int (*perf_event__handler_t)(struct perf_tool *tool,
int perf_event__synthesize_thread_map(struct perf_tool *tool, int perf_event__synthesize_thread_map(struct perf_tool *tool,
struct thread_map *threads, struct thread_map *threads,
perf_event__handler_t process, perf_event__handler_t process,
struct machine *machine, bool mmap_data, struct machine *machine, bool mmap_data);
unsigned int proc_map_timeout);
int perf_event__synthesize_thread_map2(struct perf_tool *tool, int perf_event__synthesize_thread_map2(struct perf_tool *tool,
struct thread_map *threads, struct thread_map *threads,
perf_event__handler_t process, perf_event__handler_t process,
@ -682,7 +681,6 @@ int perf_event__synthesize_cpu_map(struct perf_tool *tool,
int perf_event__synthesize_threads(struct perf_tool *tool, int perf_event__synthesize_threads(struct perf_tool *tool,
perf_event__handler_t process, perf_event__handler_t process,
struct machine *machine, bool mmap_data, struct machine *machine, bool mmap_data,
unsigned int proc_map_timeout,
unsigned int nr_threads_synthesize); unsigned int nr_threads_synthesize);
int perf_event__synthesize_kernel_mmap(struct perf_tool *tool, int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
perf_event__handler_t process, perf_event__handler_t process,
@ -797,8 +795,7 @@ int perf_event__synthesize_mmap_events(struct perf_tool *tool,
pid_t pid, pid_t tgid, pid_t pid, pid_t tgid,
perf_event__handler_t process, perf_event__handler_t process,
struct machine *machine, struct machine *machine,
bool mmap_data, bool mmap_data);
unsigned int proc_map_timeout);
int perf_event__synthesize_extra_kmaps(struct perf_tool *tool, int perf_event__synthesize_extra_kmaps(struct perf_tool *tool,
perf_event__handler_t process, perf_event__handler_t process,
@ -829,5 +826,6 @@ int perf_event_paranoid(void);
extern int sysctl_perf_event_max_stack; extern int sysctl_perf_event_max_stack;
extern int sysctl_perf_event_max_contexts_per_stack; extern int sysctl_perf_event_max_contexts_per_stack;
extern unsigned int proc_map_timeout;
#endif /* __PERF_RECORD_H */ #endif /* __PERF_RECORD_H */

4
tools/perf/util/machine.c
View File

@ -2493,15 +2493,13 @@ int machines__for_each_thread(struct machines *machines,
int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool, int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
struct target *target, struct thread_map *threads, struct target *target, struct thread_map *threads,
perf_event__handler_t process, bool data_mmap, perf_event__handler_t process, bool data_mmap,
unsigned int proc_map_timeout,
unsigned int nr_threads_synthesize) unsigned int nr_threads_synthesize)
{ {
if (target__has_task(target)) if (target__has_task(target))
return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap, proc_map_timeout); return perf_event__synthesize_thread_map(tool, threads, process, machine, data_mmap);
else if (target__has_cpu(target)) else if (target__has_cpu(target))
return perf_event__synthesize_threads(tool, process, return perf_event__synthesize_threads(tool, process,
machine, data_mmap, machine, data_mmap,
proc_map_timeout,
nr_threads_synthesize); nr_threads_synthesize);
/* command specified */ /* command specified */
return 0; return 0;

3
tools/perf/util/machine.h
View File

@ -250,17 +250,14 @@ int machines__for_each_thread(struct machines *machines,
int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool, int __machine__synthesize_threads(struct machine *machine, struct perf_tool *tool,
struct target *target, struct thread_map *threads, struct target *target, struct thread_map *threads,
perf_event__handler_t process, bool data_mmap, perf_event__handler_t process, bool data_mmap,
unsigned int proc_map_timeout,
unsigned int nr_threads_synthesize); unsigned int nr_threads_synthesize);
static inline static inline
int machine__synthesize_threads(struct machine *machine, struct target *target, int machine__synthesize_threads(struct machine *machine, struct target *target,
struct thread_map *threads, bool data_mmap, struct thread_map *threads, bool data_mmap,
unsigned int proc_map_timeout,
unsigned int nr_threads_synthesize) unsigned int nr_threads_synthesize)
{ {
return __machine__synthesize_threads(machine, NULL, target, threads, return __machine__synthesize_threads(machine, NULL, target, threads,
perf_event__process, data_mmap, perf_event__process, data_mmap,
proc_map_timeout,
nr_threads_synthesize); nr_threads_synthesize);
} }