Skip to contentSkip to conversation

perf bench: Add -t/--threads option to perf bench mem mmap

PATCH In review Namhyung Kim 3 participants 4 messages Dec 7, 2025 – Dec 16, 2025 perf events

lore
Share & tools
lore

Namhyung Kim

author maintainer
#0 lore raw

PATCH 1/1 perf bench: Add -t/--threads option to perf bench mem mmap

So that it can measure overhead of mmap_lock and/or per-VMA lock contention.

  $ perf bench mem mmap -f demand -l 1000 -t 1
  # Running 'mem/mmap' benchmark:
  # function 'demand' (Demand loaded mmap())
  # Copying 1MB bytes ...
         2.914503 GB/sec
  $ perf bench mem mmap -f demand -l 1000 -t 2
  # Running 'mem/mmap' benchmark:
  # function 'demand' (Demand loaded mmap())
  # Copying 1MB bytes ...
       888.769991 MB/sec
  $ perf bench mem mmap -f demand -l 1000 -t 3
  # Running 'mem/mmap' benchmark:
  # function 'demand' (Demand loaded mmap())
  # Copying 1MB bytes ...
       757.658220 MB/sec
  $ perf bench mem mmap -f demand -l 1000 -t 4
  # Running 'mem/mmap' benchmark:
  # function 'demand' (Demand loaded mmap())
  # Copying 1MB bytes ...
       316.410713 MB/sec
---
 tools/perf/Documentation/perf-bench.txt |  4 ++
 tools/perf/bench/mem-functions.c        | 74 +++++++++++++++++++++----
 2 files changed, 67 insertions(+), 11 deletions(-)
tools/perf/Documentation/perf-bench.txt +4 -0
index 1160224cb718392d..c5913cf59c988421 100644
@@ -274,6 +274,10 @@ Repeat mmap() invocation this number of times.
 --cycles::
 Use perf's cpu-cycles event instead of gettimeofday syscall.
 
+-t::
+--threads=<NUM>::
+Create multiple threads to call mmap/munmap concurrently.
+
 SUITES FOR 'numa'
 ~~~~~~~~~~~~~~~~~
 *mem*::
tools/perf/bench/mem-functions.c +63 -11

120 lines not on this page · raw message

Signature · 1 line
2.52.0.223.gf5cc29aaa4-goog
reviewer
#1 lore raw
Quoted 22 lines · Namhyung Kim

So that it can measure overhead of mmap_lock and/or per-VMA lock contention.

   $ perf bench mem mmap -f demand -l 1000 -t 1
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
          2.914503 GB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 2
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
        888.769991 MB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 3
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
Quoted 8 lines
        757.658220 MB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 4
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
        316.410713 MB/sec

Should this now say "MB/sec per thread" for nr_threads > 1? I think it could be interpreted either way without a label, but I see you divided by nr_threads in timeval2double().

Quoted 153 lines
---
  tools/perf/Documentation/perf-bench.txt |  4 ++
  tools/perf/bench/mem-functions.c        | 74 +++++++++++++++++++++----
  2 files changed, 67 insertions(+), 11 deletions(-)
tools/perf/Documentation/perf-bench.txt +4 -0
index 1160224cb718392d..c5913cf59c988421 100644
@@ -274,6 +274,10 @@ Repeat mmap() invocation this number of times.
  --cycles::
  Use perf's cpu-cycles event instead of gettimeofday syscall.
 
+-t::
+--threads=<NUM>::
+Create multiple threads to call mmap/munmap concurrently.
+
  SUITES FOR 'numa'
  ~~~~~~~~~~~~~~~~~
  *mem*::
tools/perf/bench/mem-functions.c +63 -11
index 2908a3a796c932d0..e7e7d0b41fc7720f 100644
@@ -26,6 +26,7 @@
  #include <errno.h>
  #include <linux/time64.h>
  #include <linux/log2.h>
+#include <pthread.h>
 
  #define K 1024
 
@@ -41,6 +42,7 @@ static unsigned int	nr_loops	= 1;
  static bool		use_cycles;
  static int		cycles_fd;
  static unsigned int	seed;
+static unsigned int	nr_threads	= 1;
 
  static const struct option bench_common_options[] = {
  	OPT_STRING('s', "size", &size_str, "1MB",
@@ -174,7 +176,7 @@ static void clock_accum(union bench_clock *a, union bench_clock *b)
 
  static double timeval2double(struct timeval *ts)
  {
-	return (double)ts->tv_sec + (double)ts->tv_usec / (double)USEC_PER_SEC;
+	return (double)ts->tv_sec + (double)ts->tv_usec / (double)USEC_PER_SEC / nr_threads;
  }
 
  #define print_bps(x) do {						\
@@ -494,16 +496,27 @@ static void mmap_page_touch(void *dst, size_t size, unsigned int page_shift, boo
  	}
  }
 
-static int do_mmap(const struct function *r, struct bench_params *p,
-		  void *src __maybe_unused, void *dst __maybe_unused,
-		  union bench_clock *accum)
+struct mmap_data {
+	pthread_t id;
+	const struct function *func;
+	struct bench_params *params;
+	union bench_clock result;
+	unsigned int seed;
+	int error;
+};
+
+static void *do_mmap_thread(void *arg)
  {
+	struct mmap_data *data = arg;
+	const struct function *r = data->func;
+	struct bench_params *p = data->params;
  	union bench_clock start, end, diff;
  	mmap_op_t fn = r->fn.mmap_op;
  	bool populate = strcmp(r->name, "populate") == 0;
+	void *dst;
 
-	if (p->seed)
-		srand(p->seed);
+	if (data->seed)
+		srand(data->seed);
 
  	for (unsigned int i = 0; i < p->nr_loops; i++) {
  		clock_get(&start);
@@ -514,16 +527,53 @@ static int do_mmap(const struct function *r, struct bench_params *p,
  		fn(dst, p->size, p->page_shift, p->seed);
  		clock_get(&end);
  		diff = clock_diff(&start, &end);
-		clock_accum(accum, &diff);
+		clock_accum(&data->result, &diff);
 
  		bench_munmap(dst, p->size);
  	}
 
-	return 0;
+	return data;
  out:
-	printf("# Memory allocation failed - maybe size (%s) %s?\n", size_str,
-			p->page_shift != PAGE_SHIFT_4KB ? "has insufficient hugepages" : "is too large");
-	return -1;
+	data->error = -ENOMEM;
+	return NULL;
+}
+
+static int do_mmap(const struct function *r, struct bench_params *p,
+		  void *src __maybe_unused, void *dst __maybe_unused,
+		  union bench_clock *accum)
+{
+	struct mmap_data *data;
+	int error = 0;
+
+	data = calloc(nr_threads, sizeof(*data));
+	if (!data) {
+		printf("# Failed to allocate thread resources\n");
+		return -1;
+	}
+
+	for (unsigned int i = 0; i < nr_threads; i++) {
+		data[i].func = r;
+		data[i].params = p;
+		if (p->seed)
+			data[i].seed = p->seed + i;
+
+		if (pthread_create(&data[i].id, NULL, do_mmap_thread, &data[i]) < 0)
+			data[i].error = -errno;
+	}
+
+	for (unsigned int i = 0; i < nr_threads; i++) {
+		pthread_join(data[i].id, NULL);
+
+		clock_accum(accum, &data[i].result);
+		error |= data[i].error;
+	}
+	free(data);
+
+	if (error) {
+		printf("# Memory allocation failed - maybe size (%s) %s?\n", size_str,
+		       p->page_shift != PAGE_SHIFT_4KB ? "has insufficient hugepages" : "is too large");
+	}
+	return error ? -1 : 0;
  }
 
  static const char * const bench_mem_mmap_usage[] = {
@@ -548,6 +598,8 @@ int bench_mem_mmap(int argc, const char **argv)
  	static const struct option bench_mmap_options[] = {
  		OPT_UINTEGER('r', "randomize", &seed,
  			    "Seed to randomize page access offset."),
+		OPT_UINTEGER('t', "threads", &nr_threads,
+			    "Number of threads to run concurrently (default: 1)."),
  		OPT_PARENT(bench_common_options),
  		OPT_END()
  	};
author maintainer
#2 lore raw

Hi James,

Quoted 32 lines · James Clark
Quoted 29 lines · Namhyung Kim

So that it can measure overhead of mmap_lock and/or per-VMA lock contention.

   $ perf bench mem mmap -f demand -l 1000 -t 1
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
          2.914503 GB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 2
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
        888.769991 MB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 3
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
        757.658220 MB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 4
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
Quoted 5 lines
Quoted 1 line
        316.410713 MB/sec

Should this now say "MB/sec per thread" for nr_threads > 1? I think it could be interpreted either way without a label, but I see you divided by nr_threads in timeval2double().

Right, thanks for the review. I think we can add it unconditionally.

Thanks,
Namhyung

Quoted 143 lines
Quoted 142 lines
---
  tools/perf/Documentation/perf-bench.txt |  4 ++
  tools/perf/bench/mem-functions.c        | 74 +++++++++++++++++++++----
  2 files changed, 67 insertions(+), 11 deletions(-)
tools/perf/Documentation/perf-bench.txt +4 -0
index 1160224cb718392d..c5913cf59c988421 100644
@@ -274,6 +274,10 @@ Repeat mmap() invocation this number of times.
  --cycles::
  Use perf's cpu-cycles event instead of gettimeofday syscall.
+-t::
+--threads=<NUM>::
+Create multiple threads to call mmap/munmap concurrently.
+
  SUITES FOR 'numa'
  ~~~~~~~~~~~~~~~~~
  *mem*::
tools/perf/bench/mem-functions.c +63 -11
index 2908a3a796c932d0..e7e7d0b41fc7720f 100644
@@ -26,6 +26,7 @@
  #include <errno.h>
  #include <linux/time64.h>
  #include <linux/log2.h>
+#include <pthread.h>
  #define K 1024
@@ -41,6 +42,7 @@ static unsigned int	nr_loops	= 1;
  static bool		use_cycles;
  static int		cycles_fd;
  static unsigned int	seed;
+static unsigned int	nr_threads	= 1;
  static const struct option bench_common_options[] = {
  	OPT_STRING('s', "size", &size_str, "1MB",
@@ -174,7 +176,7 @@ static void clock_accum(union bench_clock *a, union bench_clock *b)
  static double timeval2double(struct timeval *ts)
  {
-	return (double)ts->tv_sec + (double)ts->tv_usec / (double)USEC_PER_SEC;
+	return (double)ts->tv_sec + (double)ts->tv_usec / (double)USEC_PER_SEC / nr_threads;
  }
  #define print_bps(x) do {						\
@@ -494,16 +496,27 @@ static void mmap_page_touch(void *dst, size_t size, unsigned int page_shift, boo
  	}
  }
-static int do_mmap(const struct function *r, struct bench_params *p,
-		  void *src __maybe_unused, void *dst __maybe_unused,
-		  union bench_clock *accum)
+struct mmap_data {
+	pthread_t id;
+	const struct function *func;
+	struct bench_params *params;
+	union bench_clock result;
+	unsigned int seed;
+	int error;
+};
+
+static void *do_mmap_thread(void *arg)
  {
+	struct mmap_data *data = arg;
+	const struct function *r = data->func;
+	struct bench_params *p = data->params;
  	union bench_clock start, end, diff;
  	mmap_op_t fn = r->fn.mmap_op;
  	bool populate = strcmp(r->name, "populate") == 0;
+	void *dst;
-	if (p->seed)
-		srand(p->seed);
+	if (data->seed)
+		srand(data->seed);
  	for (unsigned int i = 0; i < p->nr_loops; i++) {
  		clock_get(&start);
@@ -514,16 +527,53 @@ static int do_mmap(const struct function *r, struct bench_params *p,
  		fn(dst, p->size, p->page_shift, p->seed);
  		clock_get(&end);
  		diff = clock_diff(&start, &end);
-		clock_accum(accum, &diff);
+		clock_accum(&data->result, &diff);
  		bench_munmap(dst, p->size);
  	}
-	return 0;
+	return data;
  out:
-	printf("# Memory allocation failed - maybe size (%s) %s?\n", size_str,
-			p->page_shift != PAGE_SHIFT_4KB ? "has insufficient hugepages" : "is too large");
-	return -1;
+	data->error = -ENOMEM;
+	return NULL;
+}
+
+static int do_mmap(const struct function *r, struct bench_params *p,
+		  void *src __maybe_unused, void *dst __maybe_unused,
+		  union bench_clock *accum)
+{
+	struct mmap_data *data;
+	int error = 0;
+
+	data = calloc(nr_threads, sizeof(*data));
+	if (!data) {
+		printf("# Failed to allocate thread resources\n");
+		return -1;
+	}
+
+	for (unsigned int i = 0; i < nr_threads; i++) {
+		data[i].func = r;
+		data[i].params = p;
+		if (p->seed)
+			data[i].seed = p->seed + i;
+
+		if (pthread_create(&data[i].id, NULL, do_mmap_thread, &data[i]) < 0)
+			data[i].error = -errno;
+	}
+
+	for (unsigned int i = 0; i < nr_threads; i++) {
+		pthread_join(data[i].id, NULL);
+
+		clock_accum(accum, &data[i].result);
+		error |= data[i].error;
+	}
+	free(data);
+
+	if (error) {
+		printf("# Memory allocation failed - maybe size (%s) %s?\n", size_str,
+		       p->page_shift != PAGE_SHIFT_4KB ? "has insufficient hugepages" : "is too large");
+	}
+	return error ? -1 : 0;
  }
  static const char * const bench_mem_mmap_usage[] = {
@@ -548,6 +598,8 @@ int bench_mem_mmap(int argc, const char **argv)
  	static const struct option bench_mmap_options[] = {
  		OPT_UINTEGER('r', "randomize", &seed,
  			    "Seed to randomize page access offset."),
+		OPT_UINTEGER('t', "threads", &nr_threads,
+			    "Number of threads to run concurrently (default: 1)."),
  		OPT_PARENT(bench_common_options),
  		OPT_END()
  	};
#3 lore raw
Quoted 35 lines · Namhyung Kim

Hi James,

Quoted 32 lines · James Clark
Quoted 29 lines · Namhyung Kim

So that it can measure overhead of mmap_lock and/or per-VMA lock contention.

   $ perf bench mem mmap -f demand -l 1000 -t 1
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
          2.914503 GB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 2
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
        888.769991 MB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 3
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
        757.658220 MB/sec
   $ perf bench mem mmap -f demand -l 1000 -t 4
   # Running 'mem/mmap' benchmark:
   # function 'demand' (Demand loaded mmap())
   # Copying 1MB bytes ...
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
        316.410713 MB/sec

Should this now say "MB/sec per thread" for nr_threads > 1? I think it could be interpreted either way without a label, but I see you divided by nr_threads in timeval2double().

Right, thanks for the review. I think we can add it unconditionally.

Seconding the MB/sec per thread thing. But how about also adding some kind of a variance indicator?

Maybe something like this:

   $ perf bench mem mmap -f demand -l 1000 -t 4
    # Running 'mem/mmap' benchmark:
    # function 'demand' (Demand loaded mmap())
    # Copying 1MB bytes ...
         316.410713 MB/sec/thread        ( +-  0.56% )

--
ankur