From 97b7a9cf7702371d5f9827f71b6daf7eafe890ec Mon Sep 17 00:00:00 2001
From: David Goldblatt <davidgoldblatt@fb.com>
Date: Mon, 11 May 2020 13:05:36 -0700
Subject: [PATCH] Add a fill/flush microbenchmark.

---
 Makefile.in              |  1 +
 test/stress/fill_flush.c | 77 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+)
 create mode 100644 test/stress/fill_flush.c

diff --git a/Makefile.in b/Makefile.in
index d35b74b3..e7666fb1 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -289,6 +289,7 @@ CPP_SRCS :=
 TESTS_INTEGRATION_CPP :=
 endif
 TESTS_STRESS := $(srcroot)test/stress/microbench.c \
+	$(srcroot)test/stress/fill_flush.c \
 	$(srcroot)test/stress/large_microbench.c \
 	$(srcroot)test/stress/hookbench.c
 
diff --git a/test/stress/fill_flush.c b/test/stress/fill_flush.c
new file mode 100644
index 00000000..6ea3ff96
--- /dev/null
+++ b/test/stress/fill_flush.c
@@ -0,0 +1,77 @@
+#include "test/jemalloc_test.h"
+#include "test/bench.h"
+
+#define SMALL_ALLOC_SIZE 128
+#define LARGE_ALLOC_SIZE SC_LARGE_MINCLASS
+#define NALLOCS 1000
+
+/*
+ * We make this volatile so the 1-at-a-time variants can't leave the allocation
+ * in a register, just to try to get the cache behavior closer.
+ */
+void *volatile allocs[NALLOCS];
+
+static void
+array_alloc_dalloc_small(void) {
+	for (int i = 0; i < NALLOCS; i++) {
+		void *p = mallocx(SMALL_ALLOC_SIZE, 0);
+		assert_ptr_not_null(p, "mallocx shouldn't fail");
+		allocs[i] = p;
+	}
+	for (int i = 0; i < NALLOCS; i++) {
+		sdallocx(allocs[i], SMALL_ALLOC_SIZE, 0);
+	}
+}
+
+static void
+item_alloc_dalloc_small(void) {
+	for (int i = 0; i < NALLOCS; i++) {
+		void *p = mallocx(SMALL_ALLOC_SIZE, 0);
+		assert_ptr_not_null(p, "mallocx shouldn't fail");
+		allocs[i] = p;
+		sdallocx(allocs[i], SMALL_ALLOC_SIZE, 0);
+	}
+}
+
+TEST_BEGIN(test_array_vs_item_small) {
+	compare_funcs(1 * 1000, 10 * 1000,
+	    "array of small allocations", array_alloc_dalloc_small,
+	    "small item allocation", item_alloc_dalloc_small);
+}
+TEST_END
+
+static void
+array_alloc_dalloc_large(void) {
+	for (int i = 0; i < NALLOCS; i++) {
+		void *p = mallocx(LARGE_ALLOC_SIZE, 0);
+		assert_ptr_not_null(p, "mallocx shouldn't fail");
+		allocs[i] = p;
+	}
+	for (int i = 0; i < NALLOCS; i++) {
+		sdallocx(allocs[i], LARGE_ALLOC_SIZE, 0);
+	}
+}
+
+static void
+item_alloc_dalloc_large(void) {
+	for (int i = 0; i < NALLOCS; i++) {
+		void *p = mallocx(LARGE_ALLOC_SIZE, 0);
+		assert_ptr_not_null(p, "mallocx shouldn't fail");
+		allocs[i] = p;
+		sdallocx(allocs[i], LARGE_ALLOC_SIZE, 0);
+	}
+}
+
+TEST_BEGIN(test_array_vs_item_large) {
+	compare_funcs(100, 1000,
+	    "array of large allocations", array_alloc_dalloc_large,
+	    "large item allocation", item_alloc_dalloc_large);
+}
+TEST_END
+
+
+int main(void) {
+	return test_no_reentrancy(
+	    test_array_vs_item_small,
+	    test_array_vs_item_large);
+}