Add a couple of new benchmarks.
Add a calloc benchmark to make sure that a native allocator isn't
doing anything incorrectly when zero'ing memory.
Also add a fork call benchmark to verify that the time to make a
fork call isn't increasing.
Test: Ran benchmarks on walleye and verified that the numbers are not
Test: too variable between runs.
Change-Id: I61d289d277f85ac432a315e539cf6391ea036866
diff --git a/benchmarks/stdlib_benchmark.cpp b/benchmarks/stdlib_benchmark.cpp
index 61b51fa..45b953f 100644
--- a/benchmarks/stdlib_benchmark.cpp
+++ b/benchmarks/stdlib_benchmark.cpp
@@ -59,6 +59,41 @@
BIONIC_BENCHMARK_WITH_ARG(BM_stdlib_malloc_free_decay1, "AT_COMMON_SIZES");
#endif
+static void CallocFree(benchmark::State& state) {
+ const size_t nbytes = state.range(0);
+ int pagesize = getpagesize();
+
+ for (auto _ : state) {
+ void* ptr;
+ benchmark::DoNotOptimize(ptr = calloc(1, nbytes));
+ MakeAllocationResident(ptr, nbytes, pagesize);
+ free(ptr);
+ }
+
+ state.SetBytesProcessed(uint64_t(state.iterations()) * uint64_t(nbytes));
+}
+
+static void BM_stdlib_calloc_free_default(benchmark::State& state) {
+#if defined(__BIONIC__)
+ // The default is expected to be a zero decay time.
+ mallopt(M_DECAY_TIME, 0);
+#endif
+
+ CallocFree(state);
+}
+BIONIC_BENCHMARK_WITH_ARG(BM_stdlib_calloc_free_default, "AT_COMMON_SIZES");
+
+#if defined(__BIONIC__)
+static void BM_stdlib_calloc_free_decay1(benchmark::State& state) {
+ mallopt(M_DECAY_TIME, 1);
+
+ CallocFree(state);
+
+ mallopt(M_DECAY_TIME, 0);
+}
+BIONIC_BENCHMARK_WITH_ARG(BM_stdlib_calloc_free_decay1, "AT_COMMON_SIZES");
+#endif
+
static void MallocMultiple(benchmark::State& state, size_t nbytes, size_t numAllocs) {
int pagesize = getpagesize();
void* ptrs[numAllocs];
diff --git a/benchmarks/unistd_benchmark.cpp b/benchmarks/unistd_benchmark.cpp
index d697dfd..f0a3089 100644
--- a/benchmarks/unistd_benchmark.cpp
+++ b/benchmarks/unistd_benchmark.cpp
@@ -14,9 +14,16 @@
* limitations under the License.
*/
+#include <errno.h>
+#include <string.h>
#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/wait.h>
#include <unistd.h>
+#include <string>
+
+#include <android-base/stringprintf.h>
#include <benchmark/benchmark.h>
#include "util.h"
@@ -28,3 +35,35 @@
BIONIC_TRIVIAL_BENCHMARK(BM_unistd_gettid, gettid());
#endif
BIONIC_TRIVIAL_BENCHMARK(BM_unistd_gettid_syscall, syscall(__NR_gettid));
+
+// Many native allocators have custom prefork and postfork functions.
+// Measure the fork call to make sure nothing takes too long.
+void BM_unistd_fork_call(benchmark::State& state) {
+ for (auto _ : state) {
+ pid_t pid;
+ if ((pid = fork()) == 0) {
+ // Sleep for a little while so that the parent is not interrupted
+ // right away when the process exits.
+ usleep(100);
+ _exit(1);
+ }
+ state.PauseTiming();
+ if (pid == -1) {
+ std::string err = android::base::StringPrintf("Fork failed: %s", strerror(errno));
+ state.SkipWithError(err.c_str());
+ }
+ pid_t wait_pid = waitpid(pid, 0, 0);
+ if (wait_pid != pid) {
+ if (wait_pid == -1) {
+ std::string err = android::base::StringPrintf("waitpid call failed: %s", strerror(errno));
+ state.SkipWithError(err.c_str());
+ } else {
+ std::string err = android::base::StringPrintf(
+ "waitpid return an unknown pid, expected %d, actual %d", pid, wait_pid);
+ state.SkipWithError(err.c_str());
+ }
+ }
+ state.ResumeTiming();
+ }
+}
+BIONIC_BENCHMARK(BM_unistd_fork_call);