Add benchmarks for string assign methods

[mvels]

Summary

string.assign() heavily contributes to application's CPU usage.

This change adds benchmarks for the assign(const basic_string&) and assign(const char*) methods to be used to benchmark current usage and potential optimizations.

[EricWF]

LGTM.

libcxx/benchmarks/string.bench.cpp

267

Escape this memory with DoNotOptimize before entering the loop.

289

constexpr Opaque O{};?

[mvels]

Resolved comments

[mvels]

libcxx/benchmarks/string.bench.cpp

267

This is done already per batch right after the batch is cleared, unless I miss something?

[mvels]

• Optimize operator=(const basic_string&) for tail call.

[mvels]

• Merge branch 'master' of https://github.com/llvm/llvm-project into add-benchmarks

[EricWF]

Committed as 0c5102bd939131b27105b74e73fc25b90207ef36.

libcxx/benchmarks/string.bench.cpp

case DiffType::ChangeFirst:
       return "-123456789" HUGE_STRING4 "0123456789" HUGE_STRING4 "0123456789";
     case DiffType::ChangeMiddle:
       return "0123456789" HUGE_STRING4 "01234-6789" HUGE_STRING4 "0123456789";
     case DiffType::ChangeLast:
       return "0123456789" HUGE_STRING4 "0123456789" HUGE_STRING4 "012345678-";
   }
 }
 
+TEST_ALWAYS_INLINE const char* getString(Length L,
+                                         DiffType D = DiffType::Control) {
+  switch (L) {
+  case Length::Empty:
+    return "";
+  case Length::Small:
+    return getSmallString(D);
+  case Length::Large:
+    return getLargeString(D);
+  case Length::Huge:
+    return getHugeString(D);
+  }
+}
+
 TEST_ALWAYS_INLINE std::string makeString(Length L,
                                           DiffType D = DiffType::Control,
                                           Opacity O = Opacity::Transparent) {
   switch (L) {
   case Length::Empty:
     return maybeOpaque("", O == Opacity::Opaque);
   case Length::Small:
     return maybeOpaque(getSmallString(D), O == Opacity::Opaque);
for (auto _ : state) {
       newS = tmpS;
     }
     newS->~S();
   }
 
   static std::string name() { return "BM_StringMove" + Length::name(); }
 };
 
+template <class Length, class Opaque>
+struct StringAssignStr {
+  static void run(benchmark::State& state) {
+    constexpr bool opaque = Opaque{} == Opacity::Opaque;
+    constexpr size_t kNumStrings = 4 << 10;
+    std::string src = makeString(Length());
+    std::string strings[kNumStrings];
+    while (state.KeepRunningBatch(kNumStrings)) {
+      state.PauseTiming();
+      for (int i = 0; i < kNumStrings; ++i) {
+        std::string().swap(strings[i]);
+      }
+      benchmark::DoNotOptimize(strings);
+      state.ResumeTiming();
+      for (int i = 0; i < kNumStrings; ++i) {
+        strings[i] = *maybeOpaque(&src, opaque);
+      }
+    }
+  }
+
+  static std::string name() {
+    return "BM_StringAssignStr" + Length::name() + Opaque::name();
+  }
+};
+
+template <class Length, class Opaque>
+struct StringAssignAsciiz {
+  static void run(benchmark::State& state) {
+    constexpr bool opaque = Opaque{} == Opacity::Opaque;
+    constexpr size_t kNumStrings = 4 << 10;
+    std::string strings[kNumStrings];
+    while (state.KeepRunningBatch(kNumStrings)) {
+      state.PauseTiming();
+      for (int i = 0; i < kNumStrings; ++i) {
+        std::string().swap(strings[i]);
+      }
+      benchmark::DoNotOptimize(strings);
+      state.ResumeTiming();
+      for (int i = 0; i < kNumStrings; ++i) {
+        strings[i] = maybeOpaque(getString(Length()), opaque);
+      }
+    }
+  }
+
+  static std::string name() {
+    return "BM_StringAssignAsciiz" + Length::name() + Opaque::name();
+  }
+};
+
+template <class Opaque>
+struct StringAssignAsciizMix {
+  static void run(benchmark::State& state) {
+    constexpr auto O = Opaque{};
+    constexpr auto D = DiffType::Control;
+    constexpr size_t kNumStrings = 4 << 10;
+    std::string strings[kNumStrings];
+    while (state.KeepRunningBatch(kNumStrings)) {
+      state.PauseTiming();
+      for (int i = 0; i < kNumStrings; ++i) {
+        std::string().swap(strings[i]);
+      }
+      benchmark::DoNotOptimize(strings);
+      state.ResumeTiming();
+      for (int i = 0; i < kNumStrings - 7; i += 8) {
+        strings[i + 0] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
+        strings[i + 1] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
+        strings[i + 2] = maybeOpaque(getLargeString(D), O == Opacity::Opaque);
+        strings[i + 3] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
+        strings[i + 4] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
+        strings[i + 5] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
+        strings[i + 6] = maybeOpaque(getLargeString(D), O == Opacity::Opaque);
+        strings[i + 7] = maybeOpaque(getSmallString(D), O == Opacity::Opaque);
+      }
+    }
+  }
+
+  static std::string name() {
+    return "BM_StringAssignAsciizMix" + Opaque::name();
+  }
+};
+
 enum class Relation { Eq, Less, Compare };
 struct AllRelations : EnumValuesAsTuple<AllRelations, Relation, 3> {
   static constexpr const char* Names[] = {"Eq", "Less", "Compare"};
 };
 
 template <class Rel, class LHLength, class RHLength, class DiffType>
 struct StringRelational {
   static void run(benchmark::State& state) {
int main(int argc, char** argv) {
   benchmark::Initialize(&argc, argv);
   if (benchmark::ReportUnrecognizedArguments(argc, argv))
     return 1;
 
   sanityCheckGeneratedStrings();
 
   makeCartesianProductBenchmark<StringConstructDestroyCStr, AllLengths,
                                 AllOpacity>();
+
+  makeCartesianProductBenchmark<StringAssignStr, AllLengths, AllOpacity>();
+  makeCartesianProductBenchmark<StringAssignAsciiz, AllLengths, AllOpacity>();
+  makeCartesianProductBenchmark<StringAssignAsciizMix, AllOpacity>();
+
   makeCartesianProductBenchmark<StringCopy, AllLengths>();
   makeCartesianProductBenchmark<StringMove, AllLengths>();
   makeCartesianProductBenchmark<StringDestroy, AllLengths>();
   makeCartesianProductBenchmark<StringRelational, AllRelations, AllLengths,
                                 AllLengths, AllDiffTypes>();
   makeCartesianProductBenchmark<StringRelationalLiteral, AllRelations,
                                 AllLengths, AllLengths, AllDiffTypes>();
   makeCartesianProductBenchmark<StringRead, AllTemperatures, AllDepths,