[libc] Memory function benchmarks: rename MemcmpConfiguration in MemcmpOrBcmpConfiguration

[gchatelet]

Summary

This will help make sense of the double use of the same type in https://reviews.llvm.org/D111622#inline-1065560.

libc/benchmarks/LibcDefaultImplementations.cpp

 extern int memcmp(const void *, const void *, size_t);
 extern int bcmp(const void *, const void *, size_t);
 
 } // namespace __llvm_libc
 
 // List of implementations to test.
 
 using llvm::libc_benchmarks::BzeroConfiguration;
-using llvm::libc_benchmarks::MemcmpConfiguration;
+using llvm::libc_benchmarks::MemcmpOrBcmpConfiguration;
 using llvm::libc_benchmarks::MemcpyConfiguration;
 using llvm::libc_benchmarks::MemsetConfiguration;
 
 llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations() {
   static constexpr MemcpyConfiguration kMemcpyConfigurations[] = {
       {__llvm_libc::memcpy, "__llvm_libc::memcpy"}};
   return llvm::makeArrayRef(kMemcpyConfigurations);
 }
-llvm::ArrayRef<MemcmpConfiguration> getMemcmpConfigurations() {
-  static constexpr MemcmpConfiguration kMemcmpConfigurations[] = {
+llvm::ArrayRef<MemcmpOrBcmpConfiguration> getMemcmpConfigurations() {
+  static constexpr MemcmpOrBcmpConfiguration kMemcmpConfiguration[] = {
       {__llvm_libc::memcmp, "__llvm_libc::memcmp"}};
-  return llvm::makeArrayRef(kMemcmpConfigurations);
+  return llvm::makeArrayRef(kMemcmpConfiguration);
 }
-llvm::ArrayRef<MemcmpConfiguration> getBcmpConfigurations() {
-  static constexpr MemcmpConfiguration kBcmpConfigurations[] = {
+llvm::ArrayRef<MemcmpOrBcmpConfiguration> getBcmpConfigurations() {
+  static constexpr MemcmpOrBcmpConfiguration kBcmpConfigurations[] = {
       {__llvm_libc::bcmp, "__llvm_libc::bcmp"}};
   return llvm::makeArrayRef(kBcmpConfigurations);
 }
 llvm::ArrayRef<MemsetConfiguration> getMemsetConfigurations() {
   static constexpr MemsetConfiguration kMemsetConfigurations[] = {
       {__llvm_libc::memset, "__llvm_libc::memset"}};
   return llvm::makeArrayRef(kMemsetConfigurations);
 }
 llvm::ArrayRef<BzeroConfiguration> getBzeroConfigurations() {
   static constexpr BzeroConfiguration kBzeroConfigurations[] = {
       {__llvm_libc::bzero, "__llvm_libc::bzero"}};
   return llvm::makeArrayRef(kBzeroConfigurations);
-}
+}
 

libc/benchmarks/LibcFunctionPrototypes.h

 };
 
 using BzeroFunction = void (*)(void *, size_t);
 struct BzeroConfiguration {
   BzeroFunction Function;
   llvm::StringRef Name;
 };
 
-using MemcmpFunction = int (*)(const void *, const void *, size_t);
-struct MemcmpConfiguration {
-  MemcmpFunction Function;
+using MemcmpOrBcmpFunction = int (*)(const void *, const void *, size_t);
+struct MemcmpOrBcmpConfiguration {
+  MemcmpOrBcmpFunction Function;
   llvm::StringRef Name;
 };
 
 } // namespace libc_benchmarks
 } // namespace llvm
 
 #endif /* LLVM_LIBC_BENCHMARKS_LIBC_FUNCTION_PROTOTYPES_H */

libc/benchmarks/LibcMemoryBenchmark.h

 /// associated size distributions.
 struct ComparisonSetup : public ParameterBatch {
   ComparisonSetup();
 
   inline static const ArrayRef<MemorySizeDistribution> getDistributions() {
     return getMemcmpSizeDistributions();
   }
 
-  inline int Call(ParameterType Parameter, MemcmpFunction Memcmp) {
-    return Memcmp(LhsBuffer + Parameter.OffsetBytes,
+  inline int Call(ParameterType Parameter, MemcmpOrBcmpFunction MemcmpOrBcmp) {
+    return MemcmpOrBcmp(LhsBuffer + Parameter.OffsetBytes,
                         RhsBuffer + Parameter.OffsetBytes, Parameter.SizeBytes);
   }
 
 private:
   AlignedBuffer LhsBuffer;
   AlignedBuffer RhsBuffer;
 };
 
 } // namespace libc_benchmarks
 } // namespace llvm
 
 #endif // LLVM_LIBC_UTILS_BENCHMARK_MEMORY_BENCHMARK_H

libc/benchmarks/LibcMemoryGoogleBenchmarkMain.cpp

 #include <vector>
 
 using llvm::Align;
 using llvm::ArrayRef;
 using llvm::Twine;
 using llvm::libc_benchmarks::BzeroConfiguration;
 using llvm::libc_benchmarks::ComparisonSetup;
 using llvm::libc_benchmarks::CopySetup;
-using llvm::libc_benchmarks::MemcmpConfiguration;
+using llvm::libc_benchmarks::MemcmpOrBcmpConfiguration;
 using llvm::libc_benchmarks::MemcpyConfiguration;
 using llvm::libc_benchmarks::MemorySizeDistribution;
 using llvm::libc_benchmarks::MemsetConfiguration;
 using llvm::libc_benchmarks::OffsetDistribution;
 using llvm::libc_benchmarks::SetSetup;
 
 // Alignment to use for when accessing the buffers.
 static constexpr Align kBenchmarkAlignment = Align::Constant<1>();
for (int64_t DistIndex = 0; DistIndex < DistributionSize; ++DistIndex)     \
       for (int64_t ConfIndex = 0; ConfIndex < ConfigurationSize; ++ConfIndex)  \
         benchmark->Args({DistIndex, ConfIndex});                               \
   })
 
 extern llvm::ArrayRef<MemcpyConfiguration> getMemcpyConfigurations();
 BENCHMARK_MEMORY_FUNCTION(BM_Memcpy, CopySetup, MemcpyConfiguration,
                           getMemcpyConfigurations());
 
-extern llvm::ArrayRef<MemcmpConfiguration> getMemcmpConfigurations();
-BENCHMARK_MEMORY_FUNCTION(BM_Memcmp, ComparisonSetup, MemcmpConfiguration,
+extern llvm::ArrayRef<MemcmpOrBcmpConfiguration> getMemcmpConfigurations();
+BENCHMARK_MEMORY_FUNCTION(BM_Memcmp, ComparisonSetup, MemcmpOrBcmpConfiguration,
                           getMemcmpConfigurations());
 
-extern llvm::ArrayRef<MemcmpConfiguration> getBcmpConfigurations();
-BENCHMARK_MEMORY_FUNCTION(BM_Bcmp, ComparisonSetup, MemcmpConfiguration,
+extern llvm::ArrayRef<MemcmpOrBcmpConfiguration> getBcmpConfigurations();
+BENCHMARK_MEMORY_FUNCTION(BM_Bcmp, ComparisonSetup, MemcmpOrBcmpConfiguration,
                           getBcmpConfigurations());
 
 extern llvm::ArrayRef<MemsetConfiguration> getMemsetConfigurations();
 BENCHMARK_MEMORY_FUNCTION(BM_Memset, SetSetup, MemsetConfiguration,
                           getMemsetConfigurations());
 
 extern llvm::ArrayRef<BzeroConfiguration> getBzeroConfigurations();
 BENCHMARK_MEMORY_FUNCTION(BM_Bzero, SetSetup, BzeroConfiguration,
                           getBzeroConfigurations());