[XRay][test-suite] Update XRay microbenchmarks to use ranged for loops

[eizan]

Summary

This is slightly more efficient and is now supported by benchmark 1.3.0

[dberris]

LGTM

test-suite/trunk/MicroBenchmarks/XRay/FDRMode/fdrmode-bench.cc

[[clang::xray_never_instrument]] void TearDownXRayFDRMultiThreaded(
   }
 }
 
 [[clang::xray_never_instrument]] static void BM_XRayFDRMultiThreaded(
   benchmark::State& state) {
   if (state.thread_index == 0) {
     SetUpXRayFDRMultiThreaded(state);
   }
-  while (state.KeepRunning()) {
+  for (auto _ : state) {
     val = EmptyFunction();
     benchmark::DoNotOptimize(val);
   }
   if (state.thread_index == 0) {
     TearDownXRayFDRMultiThreaded(state);
   }
 }
 
 BENCHMARK(BM_XRayFDRMultiThreaded)
     ->ThreadRange(1, 32);  // Number of threads
 
 BENCHMARK_MAIN();

test-suite/trunk/MicroBenchmarks/XRay/ReturnReference/retref-bench.cc

 [[clang::xray_never_instrument]] __attribute__((noinline)) int
 neverInstrumented() {
   benchmark::ClobberMemory();
   return 0;
 }
 
 [[clang::xray_never_instrument]] static void BM_ReturnNeverInstrumented(
     benchmark::State& state) {
-  while (state.KeepRunning()) {
+  for (auto _ : state) {
     benchmark::DoNotOptimize(neverInstrumented());
   }
 }
 
 BENCHMARK(BM_ReturnNeverInstrumented);
 
 [[clang::xray_always_instrument]] __attribute__((noinline)) int
 alwaysInstrumented() {
   benchmark::ClobberMemory();
   return 0;
 }
 
 [[clang::xray_never_instrument]] static void BM_ReturnInstrumentedUnPatched(
     benchmark::State& state) {
   __xray_unpatch();
-  while (state.KeepRunning()) {
+  for (auto _ : state) {
     int x;
     benchmark::DoNotOptimize(x = alwaysInstrumented());
     benchmark::ClobberMemory();
   }
 }
 
 BENCHMARK(BM_ReturnInstrumentedUnPatched);
 
 
 [[clang::xray_never_instrument]] static void BM_ReturnInstrumentedPatchedThenUnpatched(
     benchmark::State& state) {
   __xray_patch();
   __xray_unpatch();
-  while (state.KeepRunning()) {
+  for (auto _ : state) {
     int x;
     benchmark::DoNotOptimize(x = alwaysInstrumented());
     benchmark::ClobberMemory();
   }
 }
 
 BENCHMARK(BM_ReturnInstrumentedPatchedThenUnpatched);
 
 
 [[clang::xray_never_instrument]] static void BM_ReturnInstrumentedPatched(
     benchmark::State& state) {
   __xray_patch();
-  while (state.KeepRunning()) {
+  for (auto _ : state) {
     int x;
     benchmark::DoNotOptimize(alwaysInstrumented());
     benchmark::ClobberMemory();
   }
 }
 
 BENCHMARK(BM_ReturnInstrumentedPatched);
 
 [[clang::xray_never_instrument]] static void BM_RDTSCP_Cost(
     benchmark::State& state) {
-  while (state.KeepRunning()) {
+  for (auto _ : state) {
     unsigned cpu;
     unsigned tsc;
     benchmark::DoNotOptimize(tsc = __rdtscp(&cpu));
     benchmark::ClobberMemory();
   }
 }
 
 volatile unsigned global_cpu;
 volatile unsigned tsc;
 [[clang::xray_never_instrument]] void benchmark_handler(int32_t,
                                                         XRayEntryType) {
   unsigned cpu;
   benchmark::DoNotOptimize(tsc = __rdtscp(&cpu));
   global_cpu = cpu;
   benchmark::ClobberMemory();
 }
 
 BENCHMARK(BM_RDTSCP_Cost);
 
 [[clang::xray_never_instrument]] static void
 BM_ReturnInstrumentedPatchedWithLogHandler(benchmark::State& state) {
   __xray_set_handler(benchmark_handler);
   __xray_patch();
   benchmark::ClobberMemory();
-  while (state.KeepRunning()) {
+  for (auto _ : state) {
     int x;
     benchmark::DoNotOptimize(x = alwaysInstrumented());
     benchmark::ClobberMemory();
   }
   __xray_remove_handler();
 }
 
 BENCHMARK(BM_ReturnInstrumentedPatchedWithLogHandler);
 
 BENCHMARK_MAIN();