From: Wilco Dijkstra <Wilco.Dijkstra@arm.com>
To: "libc-alpha@sourceware.org" <libc-alpha@sourceware.org>
Cc: nd <nd@arm.com>
Subject: [PATCH] Add malloc micro benchmark
Date: Fri, 1 Dec 2017 13:51:13 +0000 [thread overview]
Message-ID: <DB6PR0801MB205334E9F59632F30A17202683390@DB6PR0801MB2053.eurprd08.prod.outlook.com> (raw)
Add a malloc micro benchmark to enable accurate testing of the
various paths in malloc and free. The benchmark does a varying
number of allocations of a given block size, then frees them again.
It does so for several block sizes and number of allocated blocks.
Although the test is single-threaded, it also tests what happens
when you disable single-threaded fast paths (ie. SINGLE_THREAD_P
is false).
OK for commit?
Typical output on an x64 box:
{
"timing_type": "hp_timing",
"functions": {
"malloc": {
"malloc_block_size_0016": {
"st_num_allocs_0025_time": 53.5486,
"st_num_allocs_0100_time": 57.2553,
"st_num_allocs_0400_time": 57.3204,
"st_num_allocs_1000_time": 57.2059,
"mt_num_allocs_0025_time": 87.7903,
"mt_num_allocs_0100_time": 100.772,
"mt_num_allocs_0400_time": 103.827,
"mt_num_allocs_1000_time": 104.812
},
"malloc_block_size_0256": {
"st_num_allocs_0025_time": 78.3056,
"st_num_allocs_0100_time": 85.6392,
"st_num_allocs_0400_time": 91.5187,
"st_num_allocs_1000_time": 163.458,
"mt_num_allocs_0025_time": 115.925,
"mt_num_allocs_0100_time": 140.735,
"mt_num_allocs_0400_time": 152.044,
"mt_num_allocs_1000_time": 225.118
},
"malloc_block_size_1024": {
"st_num_allocs_0025_time": 113.705,
"st_num_allocs_0100_time": 103.79,
"st_num_allocs_0400_time": 479.029,
"st_num_allocs_1000_time": 634.228,
"mt_num_allocs_0025_time": 145.807,
"mt_num_allocs_0100_time": 151.157,
"mt_num_allocs_0400_time": 526.499,
"mt_num_allocs_1000_time": 687.357
},
"malloc_block_size_4096": {
"st_num_allocs_0025_time": 105.101,
"st_num_allocs_0100_time": 1640.23,
"st_num_allocs_0400_time": 2411.26,
"st_num_allocs_1000_time": 2641.56,
"mt_num_allocs_0025_time": 156.323,
"mt_num_allocs_0100_time": 1702.94,
"mt_num_allocs_0400_time": 2453,
"mt_num_allocs_1000_time": 2676.75
}
}
}
}
Note something very bad happens for the larger allocations, there
is a 25x slowdown from 25 to 400 allocations of 4KB blocks...
ChangeLog:
2017-12-01 Wilco Dijkstra <wdijkstr@arm.com>
* benchtests/Makefile: Add malloc-simple benchmark.
* benchtests/bench-malloc-simple.c: New benchmark.
--
diff --git a/benchtests/Makefile b/benchtests/Makefile
index d8681fce8cf399bc655f3f6a7717897eb9c30619..a4b2573cfa706bd6369063a995d512e0947c7bd5 100644
--- a/benchtests/Makefile
+++ b/benchtests/Makefile
@@ -67,8 +67,10 @@ stdio-common-benchset := sprintf
math-benchset := math-inlines
+malloc-benchset := malloc-simple
+
benchset := $(string-benchset-all) $(stdlib-benchset) $(stdio-common-benchset) \
- $(math-benchset)
+ $(math-benchset) $(malloc-benchset)
CFLAGS-bench-ffs.c += -fno-builtin
CFLAGS-bench-ffsll.c += -fno-builtin
@@ -86,6 +88,7 @@ $(addprefix $(objpfx)bench-,$(bench-math)): $(libm)
$(addprefix $(objpfx)bench-,$(math-benchset)): $(libm)
$(addprefix $(objpfx)bench-,$(bench-pthread)): $(shared-thread-library)
$(objpfx)bench-malloc-thread: $(shared-thread-library)
+$(objpfx)bench-malloc-simple: $(shared-thread-library)
\f
diff --git a/benchtests/bench-malloc-simple.c b/benchtests/bench-malloc-simple.c
new file mode 100644
index 0000000000000000000000000000000000000000..e786ddd9635f835b2f01b00a80f3cf0d2de82d48
--- /dev/null
+++ b/benchtests/bench-malloc-simple.c
@@ -0,0 +1,152 @@
+/* Benchmark malloc and free functions.
+ Copyright (C) 2017 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, see
+ <http://www.gnu.org/licenses/>. */
+
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "bench-timing.h"
+#include "json-lib.h"
+
+#define NUM_ITERS 1000000
+#define NUM_ALLOCS 4
+#define NUM_SIZES 4
+#define MAX_ALLOCS 1000
+
+typedef struct
+{
+ size_t iters;
+ size_t size;
+ int n;
+ timing_t elapsed;
+} malloc_args;
+
+static void
+do_benchmark (malloc_args *args, int **arr)
+{
+ timing_t start, stop;
+ size_t iters = args->iters;
+ size_t size = args->size;
+ int n = args->n;
+
+ TIMING_NOW (start);
+
+ for (int j = 0; j < iters; j++)
+ {
+ for (int i = 0; i < n; i++)
+ arr[i] = malloc (size);
+
+ for (int i = 0; i < n; i++)
+ free (arr[i]);
+ }
+
+ TIMING_NOW (stop);
+
+ TIMING_DIFF (args->elapsed, start, stop);
+}
+
+static malloc_args tests[2][NUM_SIZES][NUM_ALLOCS];
+static int allocs[NUM_ALLOCS] = { 25, 100, 400, MAX_ALLOCS };
+static size_t sizes[NUM_SIZES] = { 16, 256, 1024, 4096 };
+
+static void *
+dummy (void *p)
+{
+ return p;
+}
+
+int
+main (int argc, char **argv)
+{
+ size_t iters = NUM_ITERS;
+ int **arr = (int**) malloc (MAX_ALLOCS * sizeof (void*));
+ unsigned long res;
+
+ TIMING_INIT (res);
+ (void) res;
+
+ for (int t = 0; t < 2; t++)
+ for (int j = 0; j < NUM_SIZES; j++)
+ for (int i = 0; i < NUM_ALLOCS; i++)
+ {
+ tests[t][j][i].n = allocs[i];
+ tests[t][j][i].size = sizes[j];
+ tests[t][j][i].iters = iters / allocs[i];
+
+ /* Do a quick warmup run. */
+ if (t == 0)
+ do_benchmark (&tests[0][j][i], arr);
+ }
+
+ /* Run benchmark single threaded. */
+ for (int j = 0; j < NUM_SIZES; j++)
+ for (int i = 0; i < NUM_ALLOCS; i++)
+ do_benchmark (&tests[0][j][i], arr);
+
+ /* Create an empty thread so SINGLE_THREAD_P becomes false. */
+ pthread_t t;
+ pthread_create(&t, NULL, dummy, NULL);
+ pthread_join(t, NULL);
+
+ /* Repeat benchmark with SINGLE_THREAD_P == false. */
+ for (int j = 0; j < NUM_SIZES; j++)
+ for (int i = 0; i < NUM_ALLOCS; i++)
+ do_benchmark (&tests[1][j][i], arr);
+
+ free (arr);
+
+ json_ctx_t json_ctx;
+
+ json_init (&json_ctx, 0, stdout);
+
+ json_document_begin (&json_ctx);
+
+ json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);
+
+ json_attr_object_begin (&json_ctx, "functions");
+
+ json_attr_object_begin (&json_ctx, "malloc");
+
+ for (int j = 0; j < NUM_SIZES; j++)
+ {
+ char s[100];
+ double iters2 = iters;
+ sprintf (s, "malloc_block_size_%04ld", sizes[j]);
+ json_attr_object_begin (&json_ctx, s);
+
+ for (int i = 0; i < NUM_ALLOCS; i++)
+ {
+ sprintf (s, "st_num_allocs_%04d_time", allocs[i]);
+ json_attr_double (&json_ctx, s, tests[0][j][i].elapsed / iters2);
+ }
+
+ for (int i = 0; i < NUM_ALLOCS; i++)
+ {
+ sprintf (s, "mt_num_allocs_%04d_time", allocs[i]);
+ json_attr_double (&json_ctx, s, tests[1][j][i].elapsed / iters2);
+ }
+
+ json_attr_object_end (&json_ctx);
+ }
+
+ json_attr_object_end (&json_ctx);
+
+ json_attr_object_end (&json_ctx);
+
+ json_document_end (&json_ctx);
+ return 0;
+}
next reply other threads:[~2017-12-01 13:51 UTC|newest]
Thread overview: 40+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-12-01 13:51 Wilco Dijkstra [this message]
2017-12-01 16:13 ` [PATCH] Add malloc micro benchmark Carlos O'Donell
2017-12-18 15:18 ` Wilco Dijkstra
2017-12-18 16:32 ` Carlos O'Donell
2018-01-02 18:20 ` [PATCH v2] " Wilco Dijkstra
2018-01-02 18:45 ` DJ Delorie
2018-01-03 12:12 ` Wilco Dijkstra
2018-01-03 15:07 ` Carlos O'Donell
2018-01-04 13:48 ` Wilco Dijkstra
2018-01-04 16:37 ` Adhemerval Zanella
2018-01-05 14:32 ` Carlos O'Donell
2018-01-05 15:50 ` Adhemerval Zanella
2018-01-05 16:17 ` Carlos O'Donell
2018-01-05 16:46 ` Adhemerval Zanella
2018-01-05 17:27 ` Carlos O'Donell
2018-01-05 14:33 ` Carlos O'Donell
2018-01-05 16:28 ` Joseph Myers
2018-01-05 17:26 ` Carlos O'Donell
2018-02-28 12:40 ` Florian Weimer
2018-02-28 14:11 ` Ondřej Bílka
2018-02-28 14:16 ` Florian Weimer
2018-02-28 16:16 ` Carlos O'Donell
2018-02-28 20:17 ` Ondřej Bílka
2018-02-28 16:46 ` Ondřej Bílka
2018-02-28 17:01 ` Wilco Dijkstra
2018-02-28 18:21 ` Carlos O'Donell
2018-02-28 19:56 ` Ondřej Bílka
2018-02-28 21:56 ` DJ Delorie
2018-03-01 11:24 ` Ondřej Bílka
2017-12-18 23:02 ` [PATCH] " DJ Delorie
2017-12-28 14:09 ` Wilco Dijkstra
2017-12-28 19:01 ` DJ Delorie
-- strict thread matches above, loose matches on Subject: below --
2019-02-01 16:27 Wilco Dijkstra
2019-02-08 19:37 ` DJ Delorie
2019-02-14 16:38 ` Wilco Dijkstra
2019-02-14 20:42 ` DJ Delorie
2019-02-28 4:52 ` Carlos O'Donell
2019-03-04 17:35 ` Wilco Dijkstra
2019-03-18 17:16 ` Wilco Dijkstra
2019-04-09 5:25 ` Carlos O'Donell
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
List information: https://www.gnu.org/software/libc/involved.html
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=DB6PR0801MB205334E9F59632F30A17202683390@DB6PR0801MB2053.eurprd08.prod.outlook.com \
--to=wilco.dijkstra@arm.com \
--cc=libc-alpha@sourceware.org \
--cc=nd@arm.com \
/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 read-only IMAP folder(s) and NNTP newsgroup(s).