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

2 files changed, 74 insertions, 0 deletions

diff --git a/benchmarks/stdlib_benchmark.cpp b/benchmarks/stdlib_benchmark.cpp
index 61b51fa54..45b953f61 100644
--- a/benchmarks/stdlib_benchmark.cpp
+++ b/benchmarks/stdlib_benchmark.cpp
@@ -59,6 +59,41 @@ static void BM_stdlib_malloc_free_decay1(benchmark::State& state) {
 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 d697dfd52..f0a308959 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_getpid_syscall, syscall(__NR_getpid));
 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);