scudo: Add a basic malloc/free benchmark.

[pcc]

• license header

[merge_guards_bot]

Build result: pass - 60541 tests passed, 0 failed and 726 were skipped.

Log files: console-log.txt, CMakeCache.txt

[merge_guards_bot]

Build result: pass - 60541 tests passed, 0 failed and 726 were skipped.

Log files: console-log.txt, CMakeCache.txt

[hctim]

compiler-rt/lib/scudo/standalone/benchmarks/malloc_benchmark.cpp

34

Can we instead do what bionic-benchmarks does on their malloc test, and touch each page to ensure residency (although we're only allocating 8-bytes at a time).

Similarly, they also bulk allocate -> bulk deallocate using a storage vector. Seems like a better solution - so we don't just hit the freelist 128 * 1024 times.

43

Missing DefaultConfig?

47

Can we make 128 * 1024 and 8 constants?

[hctim]

compiler-rt/lib/scudo/standalone/benchmarks/malloc_benchmark.cpp

34

I have absolutely no idea why I read this loop as memcpy, but please ignore the first point.

Bulk allocate/delete would still be great.

[pcc]

compiler-rt/lib/scudo/standalone/benchmarks/malloc_benchmark.cpp

34

Similarly, they also bulk allocate -> bulk deallocate using a storage vector.

Are we looking at different benchmarks? This is what I've been using:
https://android.googlesource.com/platform/bionic/+/master/benchmarks/stdlib_benchmark.cpp#41

I guess a storage vector would be more realistic, although it may end up conflating the speed of the allocator's main path with other things (e.g. mmap performance, reclaiming, cache (but maybe not because of the quarantine?)) so maybe it should be a separate benchmark?

we don't just hit the freelist 128 * 1024 times.

(that wouldn't happen, the number here is the number of *bytes* to allocate, not the number of iterations)

43

Testing with DefaultConfig caused crashes for me, I think it was a D70760 style problem with the exclusive TSD but I couldn't seem to solve it. I'll add a FIXME here.

47

Sure.

[hctim]

compiler-rt/lib/scudo/standalone/benchmarks/malloc_benchmark.cpp

34

BM_stdlib_malloc_multiple_8192_allocs_default - maybe it's worth doing both the retained/non-retained tests?

[cryptoad]

Could you please put a comment somewhere on how to use the benchmark?

compiler-rt/lib/scudo/standalone/benchmarks/malloc_benchmark.cpp

29

size_t maybe? getpagesize returns an int but that's awkward I feel, hence getPageSizeCached returning an uptr.

[pcc]

• Address review comments

[pcc]

In D71104#1773289, @cryptoad wrote:

Could you please put a comment somewhere on how to use the benchmark?

Added a comment at the top of the cmake file.

[merge_guards_bot]

Build result: pass - 60578 tests passed, 0 failed and 726 were skipped.

Log files: console-log.txt, CMakeCache.txt

[cryptoad]

Thanks!

compiler-rt/lib/scudo/standalone/CMakeLists.txt

if(COMPILER_RT_HAS_SCUDO_STANDALONE)
   add_compiler_rt_runtime(clang_rt.scudo_standalone_cxx
     STATIC
     ARCHS ${SCUDO_STANDALONE_SUPPORTED_ARCH}
     SOURCES ${SCUDO_SOURCES_CXX_WRAPPERS}
     ADDITIONAL_HEADERS ${SCUDO_HEADERS}
     CFLAGS ${SCUDO_CFLAGS}
     PARENT_TARGET scudo_standalone)
 
+  add_subdirectory(benchmarks)
   if(COMPILER_RT_INCLUDE_TESTS)
     add_subdirectory(tests)
   endif()
 endif()

compiler-rt/lib/scudo/standalone/allocator_config.h

#else
   // 64KB regions
   typedef SizeClassAllocator32<SizeClassMap, 16U> Primary;
 #endif
   typedef MapAllocator<0U> Secondary;
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 1U>; // Shared, only 1 TSD.
 };
 
+#if SCUDO_CAN_USE_PRIMARY64
 struct FuchsiaConfig {
   // 1GB Regions
   typedef SizeClassAllocator64<DefaultSizeClassMap, 30U> Primary;
   typedef MapAllocator<0U> Secondary;
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 8U>; // Shared, max 8 TSDs.
 };
+#endif
 
 #if SCUDO_ANDROID
 typedef AndroidConfig Config;
 #elif SCUDO_FUCHSIA
 typedef FuchsiaConfig Config;
 #else
 typedef DefaultConfig Config;
 #endif
 
 } // namespace scudo
 
 #endif // SCUDO_ALLOCATOR_CONFIG_H_

compiler-rt/lib/scudo/standalone/benchmarks/CMakeLists.txt

+# To build these benchmarks, build the target "ScudoBenchmarks.$ARCH", where
+# $ARCH is the name of the target architecture. For example,
+# ScudoBenchmarks.x86_64 for 64-bit x86. The benchmark executable is then
+# available under projects/compiler-rt/lib/scudo/standalone/benchmarks/ in the
+# build directory.
+
+include(AddLLVM)
+
+set(SCUDO_BENCHMARK_CFLAGS -I${COMPILER_RT_SOURCE_DIR}/lib/scudo/standalone)
+if(ANDROID)
+  list(APPEND SCUDO_BENCHMARK_CFLAGS -fno-emulated-tls)
+endif()
+string(REPLACE ";" " " SCUDO_BENCHMARK_CFLAGS " ${SCUDO_BENCHMARK_CFLAGS}")
+
+foreach(arch ${SCUDO_STANDALONE_SUPPORTED_ARCH})
+  add_benchmark(ScudoBenchmarks.${arch}
+                malloc_benchmark.cpp
+                $<TARGET_OBJECTS:RTScudoStandalone.${arch}>)
+  set_property(TARGET ScudoBenchmarks.${arch} APPEND_STRING PROPERTY
+               COMPILE_FLAGS "${SCUDO_BENCHMARK_CFLAGS}")
+endforeach()

compiler-rt/lib/scudo/standalone/benchmarks/malloc_benchmark.cpp

+//===-- malloc_benchmark.cpp ------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "allocator_config.h"
+#include "combined.h"
+#include "common.h"
+
+#include "benchmark/benchmark.h"
+
+#include <memory>
+
+template <typename Config> static void BM_malloc_free(benchmark::State &State) {
+  using AllocatorT = scudo::Allocator<Config>;
+  auto Deleter = [](AllocatorT *A) {
+    A->unmapTestOnly();
+    delete A;
+  };
+  std::unique_ptr<AllocatorT, decltype(Deleter)> Allocator(new AllocatorT,
+                                                           Deleter);
+  Allocator->reset();
+
+  const size_t NBytes = State.range(0);
+  size_t PageSize = scudo::getPageSizeCached();
+
+  for (auto _ : State) {
+    void *Ptr = Allocator->allocate(NBytes, scudo::Chunk::Origin::Malloc);
+    auto *Data = reinterpret_cast<uint8_t *>(Ptr);
+    for (size_t I = 0; I < NBytes; I += PageSize)
+      Data[I] = 1;
+    benchmark::DoNotOptimize(Ptr);
+    Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc);
+  }
+
+  State.SetBytesProcessed(uint64_t(State.iterations()) * uint64_t(NBytes));
+}
+
+static const size_t MinSize = 8;
+static const size_t MaxSize = 128 * 1024;
+
+// FIXME: Add DefaultConfig here once we can tear down the exclusive TSD
+// cleanly.
+BENCHMARK_TEMPLATE(BM_malloc_free, scudo::AndroidConfig)
+    ->Range(MinSize, MaxSize);
+BENCHMARK_TEMPLATE(BM_malloc_free, scudo::AndroidSvelteConfig)
+    ->Range(MinSize, MaxSize);
+#if SCUDO_CAN_USE_PRIMARY64
+BENCHMARK_TEMPLATE(BM_malloc_free, scudo::FuchsiaConfig)
+    ->Range(MinSize, MaxSize);
+#endif
+
+template <typename Config>
+static void BM_malloc_free_loop(benchmark::State &State) {
+  using AllocatorT = scudo::Allocator<Config>;
+  auto Deleter = [](AllocatorT *A) {
+    A->unmapTestOnly();
+    delete A;
+  };
+  std::unique_ptr<AllocatorT, decltype(Deleter)> Allocator(new AllocatorT,
+                                                           Deleter);
+  Allocator->reset();
+
+  const size_t NumIters = State.range(0);
+  size_t PageSize = scudo::getPageSizeCached();
+  void *Ptrs[NumIters];
+
+  for (auto _ : State) {
+    for (void *&Ptr : Ptrs) {
+      Ptr = Allocator->allocate(8192, scudo::Chunk::Origin::Malloc);
+      auto *Data = reinterpret_cast<uint8_t *>(Ptr);
+      for (size_t I = 0; I < 8192; I += PageSize)
+        Data[I] = 1;
+      benchmark::DoNotOptimize(Ptr);
+    }
+    for (void *&Ptr : Ptrs)
+      Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc);
+  }
+
+  State.SetBytesProcessed(uint64_t(State.iterations()) * uint64_t(NumIters) *
+                          8192);
+}
+
+static const size_t MinIters = 8;
+static const size_t MaxIters = 32 * 1024;
+
+// FIXME: Add DefaultConfig here once we can tear down the exclusive TSD
+// cleanly.
+BENCHMARK_TEMPLATE(BM_malloc_free_loop, scudo::AndroidConfig)
+    ->Range(MinIters, MaxIters);
+BENCHMARK_TEMPLATE(BM_malloc_free_loop, scudo::AndroidSvelteConfig)
+    ->Range(MinIters, MaxIters);
+#if SCUDO_CAN_USE_PRIMARY64
+BENCHMARK_TEMPLATE(BM_malloc_free_loop, scudo::FuchsiaConfig)
+    ->Range(MinIters, MaxIters);
+#endif
+
+BENCHMARK_MAIN();

compiler-rt/lib/scudo/standalone/tsd_shared.h

void init(Allocator *Instance) {
     memset(this, 0, sizeof(*this));
     initLinkerInitialized(Instance);
   }
 
   void unmapTestOnly() {
     unmap(reinterpret_cast<void *>(TSDs),
           sizeof(TSD<Allocator>) * NumberOfTSDs);
     setCurrentTSD(nullptr);
+    pthread_key_delete(PThreadKey);
   }
 
   ALWAYS_INLINE void initThreadMaybe(Allocator *Instance,
                                      UNUSED bool MinimalInit) {
     if (LIKELY(getCurrentTSD()))
       return;
     initThread(Instance);
   }

llvm/utils/gn/secondary/compiler-rt/lib/scudo/BUILD.gn

supported_toolchains += [
     "//llvm/utils/gn/build/toolchain:stage2_android_arm",
   ]
 }
 
 group("scudo") {
   deps = []
   foreach(toolchain, supported_toolchains) {
     deps += [
+      "standalone/benchmarks:ScudoBenchmarks($toolchain)",
       "standalone/tests:ScudoCUnitTest($toolchain)",
       "standalone/tests:ScudoCxxUnitTest($toolchain)",
       "standalone/tests:ScudoUnitTest($toolchain)",
     ]
   }
   testonly = true
 }
 

llvm/utils/gn/secondary/compiler-rt/lib/scudo/standalone/benchmarks/BUILD.gn

+executable("ScudoBenchmarks") {
+  configs += [ "//llvm/utils/gn/build:crt_code" ]
+  sources = [
+    "malloc_benchmark.cpp",
+  ]
+  deps = [
+    "//compiler-rt/lib/scudo/standalone:sources",
+    "//llvm/utils/benchmark",
+  ]
+}

llvm/utils/gn/secondary/llvm/utils/benchmark/BUILD.gn

+static_library("benchmark") {
+  sources = [
+    "src/benchmark.cc",
+    "src/benchmark_register.cc",
+    "src/colorprint.cc",
+    "src/commandlineflags.cc",
+    "src/complexity.cc",
+    "src/console_reporter.cc",
+    "src/counter.cc",
+    "src/csv_reporter.cc",
+    "src/json_reporter.cc",
+    "src/reporter.cc",
+    "src/sleep.cc",
+    "src/statistics.cc",
+    "src/string_util.cc",
+    "src/sysinfo.cc",
+    "src/timers.cc",
+  ]
+  deps = [ "//llvm/utils/gn/build/libs/pthread" ]
+  public_configs = [ ":benchmark_config" ]
+}
+
+config("benchmark_config") {
+  include_dirs = [ "include" ]
+}