Merged main:fd784726db70 into amd-gfx:1c4d2a5930bb

Local branch amd-gfx 1c4d2a5 Merged main:e072cffe3b63 into amd-gfx:c0b9c269979b
Remote branch main fd78472 [libc++] Rewrite minmax_element benchmark

Author: SC llvm team

libcxx/test/benchmarks/algorithms/min_max_element.bench.cpp

@@ -6,33 +6,42 @@
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <algorithm>
+#include <vector>
 
-#include "common.h"
+#include <benchmark/benchmark.h>
 
-namespace {
-template <class ValueType, class Order>
-struct MinMaxElement {
-  size_t Quantity;
+void run_sizes(auto benchmark) {
+  benchmark->Arg(1)
+      ->Arg(2)
+      ->Arg(3)
+      ->Arg(4)
+      ->Arg(64)
+      ->Arg(512)
+      ->Arg(1024)
+      ->Arg(4000)
+      ->Arg(4096)
+      ->Arg(5500)
+      ->Arg(64000)
+      ->Arg(65536)
+      ->Arg(70000);
+}
 
-  void run(benchmark::State& state) const {
-    runOpOnCopies<ValueType>(state, Quantity, Order(), BatchSize::CountElements, [](auto& Copy) {
-      benchmark::DoNotOptimize(std::minmax_element(Copy.begin(), Copy.end()));
-    });
-  }
+template <class T>
+void BM_std_minmax_element(benchmark::State& state) {
+  std::vector<T> vec(state.range(), 3);
 
-  std::string name() const {
-    return "BM_MinMaxElement" + ValueType::name() + Order::name() + "_" + std::to_string(Quantity);
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(vec);
+    benchmark::DoNotOptimize(std::minmax_element(vec.begin(), vec.end()));
   }
-};
-} // namespace
-
-int main(int argc, char** argv) {
-  benchmark::Initialize(&argc, argv);
-  if (benchmark::ReportUnrecognizedArguments(argc, argv))
-    return 1;
-  makeCartesianProductBenchmark<MinMaxElement, AllValueTypes, AllOrders>(Quantities);
-  benchmark::RunSpecifiedBenchmarks();
 }
+
+BENCHMARK(BM_std_minmax_element<char>)->Apply(run_sizes);
+BENCHMARK(BM_std_minmax_element<short>)->Apply(run_sizes);
+BENCHMARK(BM_std_minmax_element<int>)->Apply(run_sizes);
+BENCHMARK(BM_std_minmax_element<long long>)->Apply(run_sizes);
+
+BENCHMARK_MAIN();

llvm/include/llvm/Config/llvm-config.h.cmake

@@ -16,7 +16,7 @@
 
 /* Indicate that this is LLVM compiled from the amd-gfx branch. */
 #define LLVM_HAVE_BRANCH_AMD_GFX
-#define LLVM_MAIN_REVISION 522213
+#define LLVM_MAIN_REVISION 522215
 
 /* Define if LLVM_ENABLE_DUMP is enabled */
 #cmakedefine LLVM_ENABLE_DUMP

llvm/lib/Transforms/Scalar/StraightLineStrengthReduce.cpp

@@ -78,6 +78,7 @@
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/DebugCounter.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/Local.h"
@@ -93,6 +94,9 @@ using namespace PatternMatch;
 static const unsigned UnknownAddressSpace =
     std::numeric_limits<unsigned>::max();
 
+DEBUG_COUNTER(StraightLineStrengthReduceCounter, "slsr-counter",
+              "Controls whether rewriteCandidateWithBasis is executed.");
+
 namespace {
 
 class StraightLineStrengthReduceLegacyPass : public FunctionPass {
@@ -268,8 +272,8 @@ FunctionPass *llvm::createStraightLineStrengthReducePass() {
 bool StraightLineStrengthReduce::isBasisFor(const Candidate &Basis,
                                             const Candidate &C) {
   return (Basis.Ins != C.Ins && // skip the same instruction
-          // They must have the same type too. Basis.Base == C.Base doesn't
-          // guarantee their types are the same (PR23975).
+          // They must have the same type too. Basis.Base == C.Base
+          // doesn't guarantee their types are the same (PR23975).
           Basis.Ins->getType() == C.Ins->getType() &&
           // Basis must dominate C in order to rewrite C with respect to Basis.
           DT->dominates(Basis.Ins->getParent(), C.Ins->getParent()) &&
@@ -610,6 +614,9 @@ Value *StraightLineStrengthReduce::emitBump(const Candidate &Basis,
 
 void StraightLineStrengthReduce::rewriteCandidateWithBasis(
     const Candidate &C, const Candidate &Basis) {
+  if (!DebugCounter::shouldExecute(StraightLineStrengthReduceCounter))
+    return;
+
   assert(C.CandidateKind == Basis.CandidateKind && C.Base == Basis.Base &&
          C.Stride == Basis.Stride);
   // We run rewriteCandidateWithBasis on all candidates in a post-order, so the

llvm/test/Other/debugcounter-slsr.ll

@@ -0,0 +1,26 @@
+; REQUIRES: asserts
+; RUN: opt -passes=slsr -S -debug-counter=slsr-counter=1  < %s | FileCheck %s
+
+; Test that, with debug counters on, we will skip the first slsr opportunity.
+
+define void @stride_is_2s(i32 %b, i32 %s) {
+; CHECK-LABEL: @stride_is_2s(
+; CHECK-NEXT: %s2 = shl i32 %s, 1
+; CHECK-NEXT: %t1 = add i32 %b, %s2
+; CHECK-NEXT: call void @foo(i32 %t1)
+; CHECK-NEXT: %s4 = shl i32 %s, 2
+; CHECK-NEXT: %t2 = add i32 %b, %s4
+; CHECK-NEXT: call void @foo(i32 %t2)
+; CHECK-NEXT: ret void
+;
+  %s2 = shl i32 %s, 1
+  %t1 = add i32 %b, %s2
+  call void @foo(i32 %t1)
+  %s4 = shl i32 %s, 2
+  %t2 = add i32 %b, %s4
+  call void @foo(i32 %t2)
+  ret void
+}
+
+declare void @foo(i32)
+