Add relational benchmark against a string constant.

[sbenza]

Summary

Add relational benchmark against a string constant.
These can potentially trigger inlining of the operations. We want to
benchmark that.

[EricWF]

libcxx/benchmarks/string.bench.cpp

272 ↗

(On Diff #191171)

We want this switch to be optimized away, right?

[sbenza]

libcxx/benchmarks/string.bench.cpp

272 ↗

(On Diff #191171)

Rel() returns a constexpr value, so the switch is optimized away.

benchmarks/string.bench.cpp

 };
 
 enum class DiffType { Control, ChangeFirst, ChangeMiddle, ChangeLast };
 struct AllDiffTypes : EnumValuesAsTuple<AllDiffTypes, DiffType, 4> {
   static constexpr const char* Names[] = {"Control", "ChangeFirst",
                                           "ChangeMiddle", "ChangeLast"};
 };
 
+static constexpr char kSmallStringLiteral[] = "012345678";
+
 TEST_ALWAYS_INLINE const char* getSmallString(DiffType D) {
   switch (D) {
     case DiffType::Control:
-      return "0123456";
+      return kSmallStringLiteral;
     case DiffType::ChangeFirst:
-      return "-123456";
+      return "-12345678";
     case DiffType::ChangeMiddle:
-      return "012-456";
+      return "0123-5678";
     case DiffType::ChangeLast:
-      return "012345-";
+      return "01234567-";
   }
 }
 
 TEST_ALWAYS_INLINE const char* getLargeString(DiffType D) {
 #define LARGE_STRING_FIRST "123456789012345678901234567890"
 #define LARGE_STRING_SECOND "234567890123456789012345678901"
   switch (D) {
     case DiffType::Control:
struct StringRelational {
   }
 
   static std::string name() {
     return "BM_StringRelational" + Rel::name() + LHLength::name() +
            RHLength::name() + DiffType::name();
   }
 };
 
+template <class Rel, class LHLength, class DiffType>
+struct StringRelationalLiteral {
+  static void run(benchmark::State& state) {
+    auto Lhs = makeString(LHLength(), DiffType());
+    for (auto _ : state) {
+      benchmark::DoNotOptimize(Lhs);
+      switch (Rel()) {
+      case Relation::Eq:
+        benchmark::DoNotOptimize(Lhs == kSmallStringLiteral);
+        break;
+      case Relation::Less:
+        benchmark::DoNotOptimize(Lhs < kSmallStringLiteral);
+        break;
+      case Relation::Compare:
+        benchmark::DoNotOptimize(Lhs.compare(kSmallStringLiteral));
+        break;
+      }
+    }
+  }
+
+  static bool skip() {
+    // Doesn't matter how they differ if they have different size.
+    if (LHLength() != Length::Small && DiffType() != ::DiffType::Control)
+      return true;
+    // We don't need huge. Doensn't give anything different than Large.
+    if (LHLength() == Length::Huge)
+      return true;
+    return false;
+  }
+
+  static std::string name() {
+    return "BM_StringRelationalLiteral" + Rel::name() + LHLength::name() +
+           DiffType::name();
+  }
+};
+
 enum class Depth { Shallow, Deep };
 struct AllDepths : EnumValuesAsTuple<AllDepths, Depth, 2> {
   static constexpr const char* Names[] = {"Shallow", "Deep"};
 };
 
 enum class Temperature { Hot, Cold };
 struct AllTemperatures : EnumValuesAsTuple<AllTemperatures, Temperature, 2> {
   static constexpr const char* Names[] = {"Hot", "Cold"};
int main(int argc, char** argv) {
 
   makeCartesianProductBenchmark<StringConstructDestroyCStr, AllLengths,
                                 AllOpacity>();
   makeCartesianProductBenchmark<StringCopy, AllLengths>();
   makeCartesianProductBenchmark<StringMove, AllLengths>();
   makeCartesianProductBenchmark<StringDestroy, AllLengths>();
   makeCartesianProductBenchmark<StringRelational, AllRelations, AllLengths,
                                 AllLengths, AllDiffTypes>();
+  makeCartesianProductBenchmark<StringRelationalLiteral, AllRelations,
+                                AllLengths, AllDiffTypes>();
   makeCartesianProductBenchmark<StringRead, AllTemperatures, AllDepths,
                                 AllLengths>();
   benchmark::RunSpecifiedBenchmarks();
 }