[libc] add benchmarks for memcmp and bzero

[gchatelet]

• Fix missing newline at EOF, uncomment no-builtin

[courbet]

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

131

Can you please add a comment for why no memset for the casual reader ?

libc/src/string/CMakeLists.txt

306

?

[gchatelet]

• Remove unneeded no-builtin
• Use memset instead of for-loop

[gchatelet]

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

131

We can use memset actually (during benchmark the llvm-libc functions are only provided through the __llvm_libc namespace.

libc/benchmarks/CMakeLists.txt

foreach(fq_config_name IN LISTS fq_implementations)
     else()
       message(STATUS "Skipping benchmark for '${fq_config_name}' insufficient host cpu features '${required_cpu_features}'")
     endif()
   endforeach()
 endfunction()
 
 add_libc_multi_impl_benchmark(memcpy)
 add_libc_multi_impl_benchmark(memset)
+add_libc_multi_impl_benchmark(bzero)
+add_libc_multi_impl_benchmark(memcmp)

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace __llvm_libc {
 
 extern void *memcpy(void *__restrict, const void *__restrict, size_t);
 extern void *memset(void *, int, size_t);
+extern void bzero(void *, size_t);
+extern int memcmp(const void *, const void *, size_t);
 
 } // namespace __llvm_libc
 
 namespace llvm {
 namespace libc_benchmarks {
 
 static cl::opt<std::string>
     StudyName("study-name", cl::desc("The name for this study"), cl::Required);
struct Benchmark {
 
   Benchmark(const size_t BufferSize)
       : SrcBuffer(BufferSize), DstBuffer(BufferSize) {}
 
   inline auto functor() {
     return [this](ParameterType P) {
       __llvm_libc::memcpy(DstBuffer + P.OffsetBytes, SrcBuffer + P.OffsetBytes,
                           P.SizeBytes);
-      return DstBuffer + P.OffsetBytes;
+      return DstBuffer[P.OffsetBytes];
     };
   }
 
   AlignedBuffer SrcBuffer;
   AlignedBuffer DstBuffer;
 };
 #elif defined(LIBC_BENCHMARK_FUNCTION_MEMSET)
 struct Benchmark {
   static constexpr auto GetDistributions = &getMemsetSizeDistributions;
   static constexpr size_t BufferCount = 1;
 
   Benchmark(const size_t BufferSize) : DstBuffer(BufferSize) {}
 
   inline auto functor() {
     return [this](ParameterType P) {
       __llvm_libc::memset(DstBuffer + P.OffsetBytes, P.OffsetBytes & 0xFF,
                           P.SizeBytes);
-      return DstBuffer + P.OffsetBytes;
+      return DstBuffer[P.OffsetBytes];
     };
   }
 
   AlignedBuffer DstBuffer;
 };
+#elif defined(LIBC_BENCHMARK_FUNCTION_BZERO)
+struct Benchmark {
+  static constexpr auto GetDistributions = &getMemsetSizeDistributions;
+  static constexpr size_t BufferCount = 1;
+
+  Benchmark(const size_t BufferSize) : DstBuffer(BufferSize) {}
+
+  inline auto functor() {
+    return [this](ParameterType P) {
+      __llvm_libc::bzero(DstBuffer + P.OffsetBytes, P.SizeBytes);
+      return DstBuffer[P.OffsetBytes];
+    };
+  }
+
+  AlignedBuffer DstBuffer;
+};
+#elif defined(LIBC_BENCHMARK_FUNCTION_MEMCMP)
+struct Benchmark {
+  static constexpr auto GetDistributions = &getMemcmpSizeDistributions;
+  static constexpr size_t BufferCount = 2;
+
+  Benchmark(const size_t BufferSize)
+      : BufferA(BufferSize), BufferB(BufferSize) {
+    for (size_t I = 0; I < BufferSize; ++I) {
+      BufferA[I] = 0x7f;
+      BufferB[I] = 0x7f;
+    }
+  }
+
+  inline auto functor() {
+    return [this](ParameterType P) {
+      return __llvm_libc::memcmp(BufferA + P.OffsetBytes,
+                                 BufferB + P.OffsetBytes, P.SizeBytes);
+    };
+  }
+
+  AlignedBuffer BufferA;
+  AlignedBuffer BufferB;
+};
 #else
 #error "Missing LIBC_BENCHMARK_FUNCTION_XXX definition"
 #endif
 
 struct Harness : Benchmark {
-
   Harness(const size_t BufferSize, size_t BatchParameterCount,
           std::function<unsigned()> SizeSampler,
           std::function<unsigned()> OffsetSampler)
       : Benchmark(BufferSize), BufferSize(BufferSize),
         Parameters(BatchParameterCount), SizeSampler(SizeSampler),
         OffsetSampler(OffsetSampler) {}
 
   CircularArrayRef<ParameterType> generateBatch(size_t Iterations) {

libc/src/string/CMakeLists.txt

SRCS
     memchr.cpp
   HDRS
     memchr.h
   DEPENDS
     .string_utils
 )
 
 add_entrypoint_object(
-  memcmp
-  SRCS
-    memcmp.cpp
-  HDRS
-    memcmp.h
-)
-
-add_entrypoint_object(
   memmove
   SRCS
     memmove.cpp
   HDRS
     memmove.h
   DEPENDS
     libc.src.__support.integer_operations
     libc.src.string.memcpy
if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
   add_bzero(bzero_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)
   add_bzero(bzero_x86_64_opt_avx512 COMPILE_OPTIONS -march=skylake-avx512 REQUIRE AVX512F)
   add_bzero(bzero_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_bzero(bzero)
 else()
   add_bzero(bzero_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
   add_bzero(bzero)
 endif()
+
+# ------------------------------------------------------------------------------
+# memcmp
+# ------------------------------------------------------------------------------
+
+function(add_memcmp memcmp_name)
+  add_implementation(memcmp ${memcmp_name}
+    SRCS ${LIBC_SOURCE_DIR}/src/string/memcmp.cpp
+    HDRS ${LIBC_SOURCE_DIR}/src/string/memcmp.h
+    DEPENDS
+      .memory_utils.memory_utils
+      libc.include.string
+    COMPILE_OPTIONS
+      -fno-builtin-memset
+      -fno-builtin-memcmp
+    ${ARGN}
+  )
+endfunction()
+
+if(${LIBC_TARGET_ARCHITECTURE_IS_X86})
+  add_memcmp(memcmp_x86_64_opt_sse2   COMPILE_OPTIONS -march=k8             REQUIRE SSE2)
+  add_memcmp(memcmp_x86_64_opt_sse4   COMPILE_OPTIONS -march=nehalem        REQUIRE SSE4_2)
+  add_memcmp(memcmp_x86_64_opt_avx2   COMPILE_OPTIONS -march=haswell        REQUIRE AVX2)
+  add_memcmp(memcmp_x86_64_opt_avx512 COMPILE_OPTIONS -march=skylake-avx512 REQUIRE AVX512F)
+  add_memcmp(memcmp_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_memcmp(memcmp)
+else()
+  add_memcmp(memcmp_opt_host          COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_NATIVE})
+  add_memcmp(memcmp)
+endif()