re2 1.10.2 → 1.11.0

package/vendor/re2/testing/regexp_benchmark.cc

@@ -8,16 +8,19 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string>
+#include <thread>
 #include <utility>
 
+#include "util/benchmark.h"
 #include "util/test.h"
+#include "util/flags.h"
 #include "util/logging.h"
+#include "util/malloc_counter.h"
 #include "util/strutil.h"
 #include "re2/prog.h"
 #include "re2/re2.h"
 #include "re2/regexp.h"
 #include "util/pcre.h"
-#include "util/benchmark.h"
 
 namespace re2 {
 void Test();
@@ -56,19 +59,22 @@ void MemoryUsage() {
     CHECK(re);
     // Can't pass mc.HeapGrowth() and mc.PeakHeapGrowth() to LOG(INFO) directly,
     // because LOG(INFO) might do a big allocation before they get evaluated.
-    fprintf(stderr, "Regexp: %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "Regexp: %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
     mc.Reset();
 
     Prog* prog = re->CompileToProg(0);
     CHECK(prog);
     CHECK(prog->IsOnePass());
     CHECK(prog->CanBitState());
-    fprintf(stderr, "Prog:   %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "Prog:   %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
     mc.Reset();
 
     StringPiece sp[4];
     CHECK(prog->SearchOnePass(text, text, Prog::kAnchored, Prog::kFullMatch, sp, 4));
-    fprintf(stderr, "Search: %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "Search: %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
     delete prog;
     re->Decref();
   }
@@ -77,18 +83,22 @@ void MemoryUsage() {
     MallocCounter mc(MallocCounter::THIS_THREAD_ONLY);
 
     PCRE re(regexp, PCRE::UTF8);
-    fprintf(stderr, "RE:     %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "RE:     %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
     PCRE::FullMatch(text, re);
-    fprintf(stderr, "RE:     %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "RE:     %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
   }
 
   {
     MallocCounter mc(MallocCounter::THIS_THREAD_ONLY);
 
     PCRE* re = new PCRE(regexp, PCRE::UTF8);
-    fprintf(stderr, "PCRE*:  %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "PCRE*:  %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
     PCRE::FullMatch(text, *re);
-    fprintf(stderr, "PCRE*:  %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "PCRE*:  %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
     delete re;
   }
 
@@ -96,42 +106,43 @@ void MemoryUsage() {
     MallocCounter mc(MallocCounter::THIS_THREAD_ONLY);
 
     RE2 re(regexp);
-    fprintf(stderr, "RE2:    %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "RE2:    %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
     RE2::FullMatch(text, re);
-    fprintf(stderr, "RE2:    %7lld bytes (peak=%lld)\n", mc.HeapGrowth(), mc.PeakHeapGrowth());
+    fprintf(stderr, "RE2:    %7lld bytes (peak=%lld)\n",
+            mc.HeapGrowth(), mc.PeakHeapGrowth());
   }
 
   fprintf(stderr, "sizeof: PCRE=%zd RE2=%zd Prog=%zd Inst=%zd\n",
           sizeof(PCRE), sizeof(RE2), sizeof(Prog), sizeof(Prog::Inst));
 }
 
+int NumCPUs() {
+  return static_cast<int>(std::thread::hardware_concurrency());
+}
+
 // Regular expression implementation wrappers.
 // Defined at bottom of file, but they are repetitive
 // and not interesting.
 
-typedef void SearchImpl(int iters, const char* regexp, const StringPiece& text,
-             Prog::Anchor anchor, bool expect_match);
+typedef void SearchImpl(benchmark::State& state, const char* regexp,
+                        const StringPiece& text, Prog::Anchor anchor,
+                        bool expect_match);
 
-SearchImpl SearchDFA, SearchNFA, SearchOnePass, SearchBitState,
-           SearchPCRE, SearchRE2,
-           SearchCachedDFA, SearchCachedNFA, SearchCachedOnePass, SearchCachedBitState,
-           SearchCachedPCRE, SearchCachedRE2;
+SearchImpl SearchDFA, SearchNFA, SearchOnePass, SearchBitState, SearchPCRE,
+    SearchRE2, SearchCachedDFA, SearchCachedNFA, SearchCachedOnePass,
+    SearchCachedBitState, SearchCachedPCRE, SearchCachedRE2;
 
-typedef void ParseImpl(int iters, const char* regexp, const StringPiece& text);
+typedef void ParseImpl(benchmark::State& state, const char* regexp,
+                       const StringPiece& text);
 
-ParseImpl Parse1NFA, Parse1OnePass, Parse1BitState,
-          Parse1PCRE, Parse1RE2,
-          Parse1Backtrack,
-          Parse1CachedNFA, Parse1CachedOnePass, Parse1CachedBitState,
-          Parse1CachedPCRE, Parse1CachedRE2,
-          Parse1CachedBacktrack;
+ParseImpl Parse1NFA, Parse1OnePass, Parse1BitState, Parse1PCRE, Parse1RE2,
+    Parse1Backtrack, Parse1CachedNFA, Parse1CachedOnePass, Parse1CachedBitState,
+    Parse1CachedPCRE, Parse1CachedRE2, Parse1CachedBacktrack;
 
-ParseImpl Parse3NFA, Parse3OnePass, Parse3BitState,
-          Parse3PCRE, Parse3RE2,
-          Parse3Backtrack,
-          Parse3CachedNFA, Parse3CachedOnePass, Parse3CachedBitState,
-          Parse3CachedPCRE, Parse3CachedRE2,
-          Parse3CachedBacktrack;
+ParseImpl Parse3NFA, Parse3OnePass, Parse3BitState, Parse3PCRE, Parse3RE2,
+    Parse3Backtrack, Parse3CachedNFA, Parse3CachedOnePass, Parse3CachedBitState,
+    Parse3CachedPCRE, Parse3CachedRE2, Parse3CachedBacktrack;
 
 ParseImpl SearchParse2CachedPCRE, SearchParse2CachedRE2;
 
@@ -141,10 +152,10 @@ ParseImpl SearchParse1CachedPCRE, SearchParse1CachedRE2;
 
 // Generate random text that won't contain the search string,
 // to test worst-case search behavior.
-void MakeText(std::string* text, int nbytes) {
+void MakeText(std::string* text, int64_t nbytes) {
   srand(1);
   text->resize(nbytes);
-  for (int i = 0; i < nbytes; i++) {
+  for (int64_t i = 0; i < nbytes; i++) {
     // Generate a one-byte rune that isn't a control character (e.g. '\n').
     // Clipping to 0x20 introduces some bias, but we don't need uniformity.
     int byte = rand() & 0x7F;
@@ -156,14 +167,11 @@ void MakeText(std::string* text, int nbytes) {
 
 // Makes text of size nbytes, then calls run to search
 // the text for regexp iters times.
-void Search(int iters, int nbytes, const char* regexp, SearchImpl* search) {
-  StopBenchmarkTiming();
+void Search(benchmark::State& state, const char* regexp, SearchImpl* search) {
   std::string s;
-  MakeText(&s, nbytes);
-  BenchmarkMemoryUsage();
-  StartBenchmarkTiming();
-  search(iters, regexp, s, Prog::kUnanchored, false);
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iters)*nbytes);
+  MakeText(&s, state.range(0));
+  search(state, regexp, s, Prog::kUnanchored, false);
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
 // These two are easy because they start with an A,
@@ -189,10 +197,10 @@ void Search(int iters, int nbytes, const char* regexp, SearchImpl* search) {
 #define PARENS     "([ -~])*(A)(B)(C)(D)(E)(F)(G)(H)(I)(J)(K)(L)(M)" \
                    "(N)(O)(P)(Q)(R)(S)(T)(U)(V)(W)(X)(Y)(Z)$"
 
-void Search_Easy0_CachedDFA(int i, int n)     { Search(i, n, EASY0, SearchCachedDFA); }
-void Search_Easy0_CachedNFA(int i, int n)     { Search(i, n, EASY0, SearchCachedNFA); }
-void Search_Easy0_CachedPCRE(int i, int n)    { Search(i, n, EASY0, SearchCachedPCRE); }
-void Search_Easy0_CachedRE2(int i, int n)     { Search(i, n, EASY0, SearchCachedRE2); }
+void Search_Easy0_CachedDFA(benchmark::State& state)     { Search(state, EASY0, SearchCachedDFA); }
+void Search_Easy0_CachedNFA(benchmark::State& state)     { Search(state, EASY0, SearchCachedNFA); }
+void Search_Easy0_CachedPCRE(benchmark::State& state)    { Search(state, EASY0, SearchCachedPCRE); }
+void Search_Easy0_CachedRE2(benchmark::State& state)     { Search(state, EASY0, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_Easy0_CachedDFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Easy0_CachedNFA,     8, 256<<10)->ThreadRange(1, NumCPUs());
@@ -201,10 +209,10 @@ BENCHMARK_RANGE(Search_Easy0_CachedPCRE,    8, 16<<20)->ThreadRange(1, NumCPUs()
 #endif
 BENCHMARK_RANGE(Search_Easy0_CachedRE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 
-void Search_Easy1_CachedDFA(int i, int n)     { Search(i, n, EASY1, SearchCachedDFA); }
-void Search_Easy1_CachedNFA(int i, int n)     { Search(i, n, EASY1, SearchCachedNFA); }
-void Search_Easy1_CachedPCRE(int i, int n)    { Search(i, n, EASY1, SearchCachedPCRE); }
-void Search_Easy1_CachedRE2(int i, int n)     { Search(i, n, EASY1, SearchCachedRE2); }
+void Search_Easy1_CachedDFA(benchmark::State& state)     { Search(state, EASY1, SearchCachedDFA); }
+void Search_Easy1_CachedNFA(benchmark::State& state)     { Search(state, EASY1, SearchCachedNFA); }
+void Search_Easy1_CachedPCRE(benchmark::State& state)    { Search(state, EASY1, SearchCachedPCRE); }
+void Search_Easy1_CachedRE2(benchmark::State& state)     { Search(state, EASY1, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_Easy1_CachedDFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Easy1_CachedNFA,     8, 256<<10)->ThreadRange(1, NumCPUs());
@@ -213,10 +221,10 @@ BENCHMARK_RANGE(Search_Easy1_CachedPCRE,    8, 16<<20)->ThreadRange(1, NumCPUs()
 #endif
 BENCHMARK_RANGE(Search_Easy1_CachedRE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 
-void Search_Medium_CachedDFA(int i, int n)     { Search(i, n, MEDIUM, SearchCachedDFA); }
-void Search_Medium_CachedNFA(int i, int n)     { Search(i, n, MEDIUM, SearchCachedNFA); }
-void Search_Medium_CachedPCRE(int i, int n)    { Search(i, n, MEDIUM, SearchCachedPCRE); }
-void Search_Medium_CachedRE2(int i, int n)     { Search(i, n, MEDIUM, SearchCachedRE2); }
+void Search_Medium_CachedDFA(benchmark::State& state)     { Search(state, MEDIUM, SearchCachedDFA); }
+void Search_Medium_CachedNFA(benchmark::State& state)     { Search(state, MEDIUM, SearchCachedNFA); }
+void Search_Medium_CachedPCRE(benchmark::State& state)    { Search(state, MEDIUM, SearchCachedPCRE); }
+void Search_Medium_CachedRE2(benchmark::State& state)     { Search(state, MEDIUM, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_Medium_CachedDFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Medium_CachedNFA,     8, 256<<10)->ThreadRange(1, NumCPUs());
@@ -225,10 +233,10 @@ BENCHMARK_RANGE(Search_Medium_CachedPCRE,    8, 256<<10)->ThreadRange(1, NumCPUs
 #endif
 BENCHMARK_RANGE(Search_Medium_CachedRE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 
-void Search_Hard_CachedDFA(int i, int n)     { Search(i, n, HARD, SearchCachedDFA); }
-void Search_Hard_CachedNFA(int i, int n)     { Search(i, n, HARD, SearchCachedNFA); }
-void Search_Hard_CachedPCRE(int i, int n)    { Search(i, n, HARD, SearchCachedPCRE); }
-void Search_Hard_CachedRE2(int i, int n)     { Search(i, n, HARD, SearchCachedRE2); }
+void Search_Hard_CachedDFA(benchmark::State& state)     { Search(state, HARD, SearchCachedDFA); }
+void Search_Hard_CachedNFA(benchmark::State& state)     { Search(state, HARD, SearchCachedNFA); }
+void Search_Hard_CachedPCRE(benchmark::State& state)    { Search(state, HARD, SearchCachedPCRE); }
+void Search_Hard_CachedRE2(benchmark::State& state)     { Search(state, HARD, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_Hard_CachedDFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Hard_CachedNFA,     8, 256<<10)->ThreadRange(1, NumCPUs());
@@ -237,10 +245,10 @@ BENCHMARK_RANGE(Search_Hard_CachedPCRE,    8, 4<<10)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK_RANGE(Search_Hard_CachedRE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 
-void Search_Fanout_CachedDFA(int i, int n)     { Search(i, n, FANOUT, SearchCachedDFA); }
-void Search_Fanout_CachedNFA(int i, int n)     { Search(i, n, FANOUT, SearchCachedNFA); }
-void Search_Fanout_CachedPCRE(int i, int n)    { Search(i, n, FANOUT, SearchCachedPCRE); }
-void Search_Fanout_CachedRE2(int i, int n)     { Search(i, n, FANOUT, SearchCachedRE2); }
+void Search_Fanout_CachedDFA(benchmark::State& state)     { Search(state, FANOUT, SearchCachedDFA); }
+void Search_Fanout_CachedNFA(benchmark::State& state)     { Search(state, FANOUT, SearchCachedNFA); }
+void Search_Fanout_CachedPCRE(benchmark::State& state)    { Search(state, FANOUT, SearchCachedPCRE); }
+void Search_Fanout_CachedRE2(benchmark::State& state)     { Search(state, FANOUT, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_Fanout_CachedDFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Fanout_CachedNFA,     8, 256<<10)->ThreadRange(1, NumCPUs());
@@ -249,10 +257,10 @@ BENCHMARK_RANGE(Search_Fanout_CachedPCRE,    8, 4<<10)->ThreadRange(1, NumCPUs()
 #endif
 BENCHMARK_RANGE(Search_Fanout_CachedRE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 
-void Search_Parens_CachedDFA(int i, int n)     { Search(i, n, PARENS, SearchCachedDFA); }
-void Search_Parens_CachedNFA(int i, int n)     { Search(i, n, PARENS, SearchCachedNFA); }
-void Search_Parens_CachedPCRE(int i, int n)    { Search(i, n, PARENS, SearchCachedPCRE); }
-void Search_Parens_CachedRE2(int i, int n)     { Search(i, n, PARENS, SearchCachedRE2); }
+void Search_Parens_CachedDFA(benchmark::State& state)     { Search(state, PARENS, SearchCachedDFA); }
+void Search_Parens_CachedNFA(benchmark::State& state)     { Search(state, PARENS, SearchCachedNFA); }
+void Search_Parens_CachedPCRE(benchmark::State& state)    { Search(state, PARENS, SearchCachedPCRE); }
+void Search_Parens_CachedRE2(benchmark::State& state)     { Search(state, PARENS, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_Parens_CachedDFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Parens_CachedNFA,     8, 256<<10)->ThreadRange(1, NumCPUs());
@@ -261,24 +269,21 @@ BENCHMARK_RANGE(Search_Parens_CachedPCRE,    8, 8)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK_RANGE(Search_Parens_CachedRE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 
-void SearchBigFixed(int iters, int nbytes, SearchImpl* search) {
-  StopBenchmarkTiming();
+void SearchBigFixed(benchmark::State& state, SearchImpl* search) {
   std::string s;
-  s.append(nbytes/2, 'x');
+  s.append(state.range(0)/2, 'x');
   std::string regexp = "^" + s + ".*$";
   std::string t;
-  MakeText(&t, nbytes/2);
+  MakeText(&t, state.range(0)/2);
   s += t;
-  BenchmarkMemoryUsage();
-  StartBenchmarkTiming();
-  search(iters, regexp.c_str(), s, Prog::kUnanchored, true);
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iters)*nbytes);
+  search(state, regexp.c_str(), s, Prog::kUnanchored, true);
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
-void Search_BigFixed_CachedDFA(int i, int n)     { SearchBigFixed(i, n, SearchCachedDFA); }
-void Search_BigFixed_CachedNFA(int i, int n)     { SearchBigFixed(i, n, SearchCachedNFA); }
-void Search_BigFixed_CachedPCRE(int i, int n)    { SearchBigFixed(i, n, SearchCachedPCRE); }
-void Search_BigFixed_CachedRE2(int i, int n)     { SearchBigFixed(i, n, SearchCachedRE2); }
+void Search_BigFixed_CachedDFA(benchmark::State& state)     { SearchBigFixed(state, SearchCachedDFA); }
+void Search_BigFixed_CachedNFA(benchmark::State& state)     { SearchBigFixed(state, SearchCachedNFA); }
+void Search_BigFixed_CachedPCRE(benchmark::State& state)    { SearchBigFixed(state, SearchCachedPCRE); }
+void Search_BigFixed_CachedRE2(benchmark::State& state)     { SearchBigFixed(state, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_BigFixed_CachedDFA,     8, 1<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_BigFixed_CachedNFA,     8, 32<<10)->ThreadRange(1, NumCPUs());
@@ -289,43 +294,39 @@ BENCHMARK_RANGE(Search_BigFixed_CachedRE2,     8, 1<<20)->ThreadRange(1, NumCPUs
 
 // Benchmark: FindAndConsume
 
-void FindAndConsume(int iters, int nbytes) {
-  StopBenchmarkTiming();
+void FindAndConsume(benchmark::State& state) {
   std::string s;
-  MakeText(&s, nbytes);
+  MakeText(&s, state.range(0));
   s.append("Hello World");
-  StartBenchmarkTiming();
   RE2 re("((Hello World))");
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     StringPiece t = s;
     StringPiece u;
     CHECK(RE2::FindAndConsume(&t, re, &u));
     CHECK_EQ(u, "Hello World");
   }
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iters)*nbytes);
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
 BENCHMARK_RANGE(FindAndConsume, 8, 16<<20)->ThreadRange(1, NumCPUs());
 
 // Benchmark: successful anchored search.
 
-void SearchSuccess(int iters, int nbytes, const char* regexp, SearchImpl* search) {
-  StopBenchmarkTiming();
+void SearchSuccess(benchmark::State& state, const char* regexp,
+                   SearchImpl* search) {
   std::string s;
-  MakeText(&s, nbytes);
-  BenchmarkMemoryUsage();
-  StartBenchmarkTiming();
-  search(iters, regexp, s, Prog::kAnchored, true);
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iters)*nbytes);
+  MakeText(&s, state.range(0));
+  search(state, regexp, s, Prog::kAnchored, true);
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
 // Unambiguous search (RE2 can use OnePass).
 
-void Search_Success_DFA(int i, int n)     { SearchSuccess(i, n, ".*$", SearchDFA); }
-void Search_Success_NFA(int i, int n)     { SearchSuccess(i, n, ".*$", SearchNFA); }
-void Search_Success_PCRE(int i, int n)    { SearchSuccess(i, n, ".*$", SearchPCRE); }
-void Search_Success_RE2(int i, int n)     { SearchSuccess(i, n, ".*$", SearchRE2); }
-void Search_Success_OnePass(int i, int n) { SearchSuccess(i, n, ".*$", SearchOnePass); }
+void Search_Success_DFA(benchmark::State& state)     { SearchSuccess(state, ".*$", SearchDFA); }
+void Search_Success_NFA(benchmark::State& state)     { SearchSuccess(state, ".*$", SearchNFA); }
+void Search_Success_PCRE(benchmark::State& state)    { SearchSuccess(state, ".*$", SearchPCRE); }
+void Search_Success_RE2(benchmark::State& state)     { SearchSuccess(state, ".*$", SearchRE2); }
+void Search_Success_OnePass(benchmark::State& state) { SearchSuccess(state, ".*$", SearchOnePass); }
 
 BENCHMARK_RANGE(Search_Success_DFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success_NFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
@@ -335,11 +336,11 @@ BENCHMARK_RANGE(Search_Success_PCRE,    8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success_RE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success_OnePass, 8, 2<<20)->ThreadRange(1, NumCPUs());
 
-void Search_Success_CachedDFA(int i, int n)     { SearchSuccess(i, n, ".*$", SearchCachedDFA); }
-void Search_Success_CachedNFA(int i, int n)     { SearchSuccess(i, n, ".*$", SearchCachedNFA); }
-void Search_Success_CachedPCRE(int i, int n)    { SearchSuccess(i, n, ".*$", SearchCachedPCRE); }
-void Search_Success_CachedRE2(int i, int n)     { SearchSuccess(i, n, ".*$", SearchCachedRE2); }
-void Search_Success_CachedOnePass(int i, int n) { SearchSuccess(i, n, ".*$", SearchCachedOnePass); }
+void Search_Success_CachedDFA(benchmark::State& state)     { SearchSuccess(state, ".*$", SearchCachedDFA); }
+void Search_Success_CachedNFA(benchmark::State& state)     { SearchSuccess(state, ".*$", SearchCachedNFA); }
+void Search_Success_CachedPCRE(benchmark::State& state)    { SearchSuccess(state, ".*$", SearchCachedPCRE); }
+void Search_Success_CachedRE2(benchmark::State& state)     { SearchSuccess(state, ".*$", SearchCachedRE2); }
+void Search_Success_CachedOnePass(benchmark::State& state) { SearchSuccess(state, ".*$", SearchCachedOnePass); }
 
 BENCHMARK_RANGE(Search_Success_CachedDFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success_CachedNFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
@@ -352,11 +353,11 @@ BENCHMARK_RANGE(Search_Success_CachedOnePass, 8, 2<<20)->ThreadRange(1, NumCPUs(
 // Ambiguous search (RE2 cannot use OnePass).
 // Used to be ".*.$", but that is coalesced to ".+$" these days.
 
-void Search_Success1_DFA(int i, int n)      { SearchSuccess(i, n, ".*\\C$", SearchDFA); }
-void Search_Success1_NFA(int i, int n)      { SearchSuccess(i, n, ".*\\C$", SearchNFA); }
-void Search_Success1_PCRE(int i, int n)     { SearchSuccess(i, n, ".*\\C$", SearchPCRE); }
-void Search_Success1_RE2(int i, int n)      { SearchSuccess(i, n, ".*\\C$", SearchRE2); }
-void Search_Success1_BitState(int i, int n) { SearchSuccess(i, n, ".*\\C$", SearchBitState); }
+void Search_Success1_DFA(benchmark::State& state)      { SearchSuccess(state, ".*\\C$", SearchDFA); }
+void Search_Success1_NFA(benchmark::State& state)      { SearchSuccess(state, ".*\\C$", SearchNFA); }
+void Search_Success1_PCRE(benchmark::State& state)     { SearchSuccess(state, ".*\\C$", SearchPCRE); }
+void Search_Success1_RE2(benchmark::State& state)      { SearchSuccess(state, ".*\\C$", SearchRE2); }
+void Search_Success1_BitState(benchmark::State& state) { SearchSuccess(state, ".*\\C$", SearchBitState); }
 
 BENCHMARK_RANGE(Search_Success1_DFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success1_NFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
@@ -366,11 +367,11 @@ BENCHMARK_RANGE(Search_Success1_PCRE,     8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success1_RE2,      8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success1_BitState, 8, 2<<20)->ThreadRange(1, NumCPUs());
 
-void Search_Success1_CachedDFA(int i, int n)      { SearchSuccess(i, n, ".*\\C$", SearchCachedDFA); }
-void Search_Success1_CachedNFA(int i, int n)      { SearchSuccess(i, n, ".*\\C$", SearchCachedNFA); }
-void Search_Success1_CachedPCRE(int i, int n)     { SearchSuccess(i, n, ".*\\C$", SearchCachedPCRE); }
-void Search_Success1_CachedRE2(int i, int n)      { SearchSuccess(i, n, ".*\\C$", SearchCachedRE2); }
-void Search_Success1_CachedBitState(int i, int n) { SearchSuccess(i, n, ".*\\C$", SearchCachedBitState); }
+void Search_Success1_CachedDFA(benchmark::State& state)      { SearchSuccess(state, ".*\\C$", SearchCachedDFA); }
+void Search_Success1_CachedNFA(benchmark::State& state)      { SearchSuccess(state, ".*\\C$", SearchCachedNFA); }
+void Search_Success1_CachedPCRE(benchmark::State& state)     { SearchSuccess(state, ".*\\C$", SearchCachedPCRE); }
+void Search_Success1_CachedRE2(benchmark::State& state)      { SearchSuccess(state, ".*\\C$", SearchCachedRE2); }
+void Search_Success1_CachedBitState(benchmark::State& state) { SearchSuccess(state, ".*\\C$", SearchCachedBitState); }
 
 BENCHMARK_RANGE(Search_Success1_CachedDFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_Success1_CachedNFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
@@ -383,22 +384,19 @@ BENCHMARK_RANGE(Search_Success1_CachedBitState, 8, 2<<20)->ThreadRange(1, NumCPU
 // Benchmark: AltMatch optimisation (just to verify that it works)
 // Note that OnePass doesn't implement it!
 
-void SearchAltMatch(int iters, int nbytes, SearchImpl* search) {
-  StopBenchmarkTiming();
+void SearchAltMatch(benchmark::State& state, SearchImpl* search) {
   std::string s;
-  MakeText(&s, nbytes);
-  BenchmarkMemoryUsage();
-  StartBenchmarkTiming();
-  search(iters, "\\C*", s, Prog::kAnchored, true);
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iters)*nbytes);
+  MakeText(&s, state.range(0));
+  search(state, "\\C*", s, Prog::kAnchored, true);
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
-void Search_AltMatch_DFA(int i, int n)      { SearchAltMatch(i, n, SearchDFA); }
-void Search_AltMatch_NFA(int i, int n)      { SearchAltMatch(i, n, SearchNFA); }
-void Search_AltMatch_OnePass(int i, int n)  { SearchAltMatch(i, n, SearchOnePass); }
-void Search_AltMatch_BitState(int i, int n) { SearchAltMatch(i, n, SearchBitState); }
-void Search_AltMatch_PCRE(int i, int n)     { SearchAltMatch(i, n, SearchPCRE); }
-void Search_AltMatch_RE2(int i, int n)      { SearchAltMatch(i, n, SearchRE2); }
+void Search_AltMatch_DFA(benchmark::State& state)      { SearchAltMatch(state, SearchDFA); }
+void Search_AltMatch_NFA(benchmark::State& state)      { SearchAltMatch(state, SearchNFA); }
+void Search_AltMatch_OnePass(benchmark::State& state)  { SearchAltMatch(state, SearchOnePass); }
+void Search_AltMatch_BitState(benchmark::State& state) { SearchAltMatch(state, SearchBitState); }
+void Search_AltMatch_PCRE(benchmark::State& state)     { SearchAltMatch(state, SearchPCRE); }
+void Search_AltMatch_RE2(benchmark::State& state)      { SearchAltMatch(state, SearchRE2); }
 
 BENCHMARK_RANGE(Search_AltMatch_DFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_AltMatch_NFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
@@ -409,12 +407,12 @@ BENCHMARK_RANGE(Search_AltMatch_PCRE,     8, 16<<20)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK_RANGE(Search_AltMatch_RE2,      8, 16<<20)->ThreadRange(1, NumCPUs());
 
-void Search_AltMatch_CachedDFA(int i, int n)      { SearchAltMatch(i, n, SearchCachedDFA); }
-void Search_AltMatch_CachedNFA(int i, int n)      { SearchAltMatch(i, n, SearchCachedNFA); }
-void Search_AltMatch_CachedOnePass(int i, int n)  { SearchAltMatch(i, n, SearchCachedOnePass); }
-void Search_AltMatch_CachedBitState(int i, int n) { SearchAltMatch(i, n, SearchCachedBitState); }
-void Search_AltMatch_CachedPCRE(int i, int n)     { SearchAltMatch(i, n, SearchCachedPCRE); }
-void Search_AltMatch_CachedRE2(int i, int n)      { SearchAltMatch(i, n, SearchCachedRE2); }
+void Search_AltMatch_CachedDFA(benchmark::State& state)      { SearchAltMatch(state, SearchCachedDFA); }
+void Search_AltMatch_CachedNFA(benchmark::State& state)      { SearchAltMatch(state, SearchCachedNFA); }
+void Search_AltMatch_CachedOnePass(benchmark::State& state)  { SearchAltMatch(state, SearchCachedOnePass); }
+void Search_AltMatch_CachedBitState(benchmark::State& state) { SearchAltMatch(state, SearchCachedBitState); }
+void Search_AltMatch_CachedPCRE(benchmark::State& state)     { SearchAltMatch(state, SearchCachedPCRE); }
+void Search_AltMatch_CachedRE2(benchmark::State& state)      { SearchAltMatch(state, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_AltMatch_CachedDFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_AltMatch_CachedNFA,      8, 16<<20)->ThreadRange(1, NumCPUs());
@@ -427,19 +425,18 @@ BENCHMARK_RANGE(Search_AltMatch_CachedRE2,      8, 16<<20)->ThreadRange(1, NumCP
 
 // Benchmark: use regexp to find phone number.
 
-void SearchDigits(int iters, SearchImpl* search) {
+void SearchDigits(benchmark::State& state, SearchImpl* search) {
   StringPiece s("650-253-0001");
-  BenchmarkMemoryUsage();
-  search(iters, "([0-9]+)-([0-9]+)-([0-9]+)", s, Prog::kAnchored, true);
-  SetBenchmarkItemsProcessed(iters);
+  search(state, "([0-9]+)-([0-9]+)-([0-9]+)", s, Prog::kAnchored, true);
+  state.SetItemsProcessed(state.iterations());
 }
 
-void Search_Digits_DFA(int i)         { SearchDigits(i, SearchDFA); }
-void Search_Digits_NFA(int i)         { SearchDigits(i, SearchNFA); }
-void Search_Digits_OnePass(int i)     { SearchDigits(i, SearchOnePass); }
-void Search_Digits_PCRE(int i)        { SearchDigits(i, SearchPCRE); }
-void Search_Digits_RE2(int i)         { SearchDigits(i, SearchRE2); }
-void Search_Digits_BitState(int i)         { SearchDigits(i, SearchBitState); }
+void Search_Digits_DFA(benchmark::State& state)         { SearchDigits(state, SearchDFA); }
+void Search_Digits_NFA(benchmark::State& state)         { SearchDigits(state, SearchNFA); }
+void Search_Digits_OnePass(benchmark::State& state)     { SearchDigits(state, SearchOnePass); }
+void Search_Digits_PCRE(benchmark::State& state)        { SearchDigits(state, SearchPCRE); }
+void Search_Digits_RE2(benchmark::State& state)         { SearchDigits(state, SearchRE2); }
+void Search_Digits_BitState(benchmark::State& state)    { SearchDigits(state, SearchBitState); }
 
 BENCHMARK(Search_Digits_DFA)->ThreadRange(1, NumCPUs());
 BENCHMARK(Search_Digits_NFA)->ThreadRange(1, NumCPUs());
@@ -452,19 +449,19 @@ BENCHMARK(Search_Digits_BitState)->ThreadRange(1, NumCPUs());
 
 // Benchmark: use regexp to parse digit fields in phone number.
 
-void Parse3Digits(int iters,
-               void (*parse3)(int, const char*, const StringPiece&)) {
-  BenchmarkMemoryUsage();
-  parse3(iters, "([0-9]+)-([0-9]+)-([0-9]+)", "650-253-0001");
-  SetBenchmarkItemsProcessed(iters);
+void Parse3Digits(benchmark::State& state,
+                  void (*parse3)(benchmark::State&, const char*,
+                                 const StringPiece&)) {
+  parse3(state, "([0-9]+)-([0-9]+)-([0-9]+)", "650-253-0001");
+  state.SetItemsProcessed(state.iterations());
 }
 
-void Parse_Digits_NFA(int i)         { Parse3Digits(i, Parse3NFA); }
-void Parse_Digits_OnePass(int i)     { Parse3Digits(i, Parse3OnePass); }
-void Parse_Digits_PCRE(int i)        { Parse3Digits(i, Parse3PCRE); }
-void Parse_Digits_RE2(int i)         { Parse3Digits(i, Parse3RE2); }
-void Parse_Digits_Backtrack(int i)   { Parse3Digits(i, Parse3Backtrack); }
-void Parse_Digits_BitState(int i)   { Parse3Digits(i, Parse3BitState); }
+void Parse_Digits_NFA(benchmark::State& state)         { Parse3Digits(state, Parse3NFA); }
+void Parse_Digits_OnePass(benchmark::State& state)     { Parse3Digits(state, Parse3OnePass); }
+void Parse_Digits_PCRE(benchmark::State& state)        { Parse3Digits(state, Parse3PCRE); }
+void Parse_Digits_RE2(benchmark::State& state)         { Parse3Digits(state, Parse3RE2); }
+void Parse_Digits_Backtrack(benchmark::State& state)   { Parse3Digits(state, Parse3Backtrack); }
+void Parse_Digits_BitState(benchmark::State& state)    { Parse3Digits(state, Parse3BitState); }
 
 BENCHMARK(Parse_Digits_NFA)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_Digits_OnePass)->ThreadRange(1, NumCPUs());
@@ -475,12 +472,12 @@ BENCHMARK(Parse_Digits_RE2)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_Digits_Backtrack)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_Digits_BitState)->ThreadRange(1, NumCPUs());
 
-void Parse_CachedDigits_NFA(int i)         { Parse3Digits(i, Parse3CachedNFA); }
-void Parse_CachedDigits_OnePass(int i)     { Parse3Digits(i, Parse3CachedOnePass); }
-void Parse_CachedDigits_PCRE(int i)        { Parse3Digits(i, Parse3CachedPCRE); }
-void Parse_CachedDigits_RE2(int i)         { Parse3Digits(i, Parse3CachedRE2); }
-void Parse_CachedDigits_Backtrack(int i)   { Parse3Digits(i, Parse3CachedBacktrack); }
-void Parse_CachedDigits_BitState(int i)   { Parse3Digits(i, Parse3CachedBitState); }
+void Parse_CachedDigits_NFA(benchmark::State& state)         { Parse3Digits(state, Parse3CachedNFA); }
+void Parse_CachedDigits_OnePass(benchmark::State& state)     { Parse3Digits(state, Parse3CachedOnePass); }
+void Parse_CachedDigits_PCRE(benchmark::State& state)        { Parse3Digits(state, Parse3CachedPCRE); }
+void Parse_CachedDigits_RE2(benchmark::State& state)         { Parse3Digits(state, Parse3CachedRE2); }
+void Parse_CachedDigits_Backtrack(benchmark::State& state)   { Parse3Digits(state, Parse3CachedBacktrack); }
+void Parse_CachedDigits_BitState(benchmark::State& state)    { Parse3Digits(state, Parse3CachedBitState); }
 
 BENCHMARK(Parse_CachedDigits_NFA)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_CachedDigits_OnePass)->ThreadRange(1, NumCPUs());
@@ -491,19 +488,19 @@ BENCHMARK(Parse_CachedDigits_Backtrack)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_CachedDigits_RE2)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_CachedDigits_BitState)->ThreadRange(1, NumCPUs());
 
-void Parse3DigitDs(int iters,
-               void (*parse3)(int, const char*, const StringPiece&)) {
-  BenchmarkMemoryUsage();
-  parse3(iters, "(\\d+)-(\\d+)-(\\d+)", "650-253-0001");
-  SetBenchmarkItemsProcessed(iters);
+void Parse3DigitDs(benchmark::State& state,
+                   void (*parse3)(benchmark::State&, const char*,
+                                  const StringPiece&)) {
+  parse3(state, "(\\d+)-(\\d+)-(\\d+)", "650-253-0001");
+  state.SetItemsProcessed(state.iterations());
 }
 
-void Parse_DigitDs_NFA(int i)         { Parse3DigitDs(i, Parse3NFA); }
-void Parse_DigitDs_OnePass(int i)     { Parse3DigitDs(i, Parse3OnePass); }
-void Parse_DigitDs_PCRE(int i)        { Parse3DigitDs(i, Parse3PCRE); }
-void Parse_DigitDs_RE2(int i)         { Parse3DigitDs(i, Parse3RE2); }
-void Parse_DigitDs_Backtrack(int i)   { Parse3DigitDs(i, Parse3CachedBacktrack); }
-void Parse_DigitDs_BitState(int i)   { Parse3DigitDs(i, Parse3CachedBitState); }
+void Parse_DigitDs_NFA(benchmark::State& state)         { Parse3DigitDs(state, Parse3NFA); }
+void Parse_DigitDs_OnePass(benchmark::State& state)     { Parse3DigitDs(state, Parse3OnePass); }
+void Parse_DigitDs_PCRE(benchmark::State& state)        { Parse3DigitDs(state, Parse3PCRE); }
+void Parse_DigitDs_RE2(benchmark::State& state)         { Parse3DigitDs(state, Parse3RE2); }
+void Parse_DigitDs_Backtrack(benchmark::State& state)   { Parse3DigitDs(state, Parse3CachedBacktrack); }
+void Parse_DigitDs_BitState(benchmark::State& state)    { Parse3DigitDs(state, Parse3CachedBitState); }
 
 BENCHMARK(Parse_DigitDs_NFA)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_DigitDs_OnePass)->ThreadRange(1, NumCPUs());
@@ -514,12 +511,12 @@ BENCHMARK(Parse_DigitDs_RE2)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_DigitDs_Backtrack)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_DigitDs_BitState)->ThreadRange(1, NumCPUs());
 
-void Parse_CachedDigitDs_NFA(int i)         { Parse3DigitDs(i, Parse3CachedNFA); }
-void Parse_CachedDigitDs_OnePass(int i)     { Parse3DigitDs(i, Parse3CachedOnePass); }
-void Parse_CachedDigitDs_PCRE(int i)        { Parse3DigitDs(i, Parse3CachedPCRE); }
-void Parse_CachedDigitDs_RE2(int i)         { Parse3DigitDs(i, Parse3CachedRE2); }
-void Parse_CachedDigitDs_Backtrack(int i)   { Parse3DigitDs(i, Parse3CachedBacktrack); }
-void Parse_CachedDigitDs_BitState(int i)   { Parse3DigitDs(i, Parse3CachedBitState); }
+void Parse_CachedDigitDs_NFA(benchmark::State& state)         { Parse3DigitDs(state, Parse3CachedNFA); }
+void Parse_CachedDigitDs_OnePass(benchmark::State& state)     { Parse3DigitDs(state, Parse3CachedOnePass); }
+void Parse_CachedDigitDs_PCRE(benchmark::State& state)        { Parse3DigitDs(state, Parse3CachedPCRE); }
+void Parse_CachedDigitDs_RE2(benchmark::State& state)         { Parse3DigitDs(state, Parse3CachedRE2); }
+void Parse_CachedDigitDs_Backtrack(benchmark::State& state)   { Parse3DigitDs(state, Parse3CachedBacktrack); }
+void Parse_CachedDigitDs_BitState(benchmark::State& state)    { Parse3DigitDs(state, Parse3CachedBitState); }
 
 BENCHMARK(Parse_CachedDigitDs_NFA)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_CachedDigitDs_OnePass)->ThreadRange(1, NumCPUs());
@@ -532,18 +529,18 @@ BENCHMARK(Parse_CachedDigitDs_BitState)->ThreadRange(1, NumCPUs());
 
 // Benchmark: splitting off leading number field.
 
-void Parse1Split(int iters,
-              void (*parse1)(int, const char*, const StringPiece&)) {
-  BenchmarkMemoryUsage();
-  parse1(iters, "[0-9]+-(.*)", "650-253-0001");
-  SetBenchmarkItemsProcessed(iters);
+void Parse1Split(benchmark::State& state,
+                 void (*parse1)(benchmark::State&, const char*,
+                                const StringPiece&)) {
+  parse1(state, "[0-9]+-(.*)", "650-253-0001");
+  state.SetItemsProcessed(state.iterations());
 }
 
-void Parse_Split_NFA(int i)         { Parse1Split(i, Parse1NFA); }
-void Parse_Split_OnePass(int i)     { Parse1Split(i, Parse1OnePass); }
-void Parse_Split_PCRE(int i)        { Parse1Split(i, Parse1PCRE); }
-void Parse_Split_RE2(int i)         { Parse1Split(i, Parse1RE2); }
-void Parse_Split_BitState(int i)         { Parse1Split(i, Parse1BitState); }
+void Parse_Split_NFA(benchmark::State& state)         { Parse1Split(state, Parse1NFA); }
+void Parse_Split_OnePass(benchmark::State& state)     { Parse1Split(state, Parse1OnePass); }
+void Parse_Split_PCRE(benchmark::State& state)        { Parse1Split(state, Parse1PCRE); }
+void Parse_Split_RE2(benchmark::State& state)         { Parse1Split(state, Parse1RE2); }
+void Parse_Split_BitState(benchmark::State& state)    { Parse1Split(state, Parse1BitState); }
 
 BENCHMARK(Parse_Split_NFA)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_Split_OnePass)->ThreadRange(1, NumCPUs());
@@ -553,11 +550,11 @@ BENCHMARK(Parse_Split_PCRE)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_Split_RE2)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_Split_BitState)->ThreadRange(1, NumCPUs());
 
-void Parse_CachedSplit_NFA(int i)         { Parse1Split(i, Parse1CachedNFA); }
-void Parse_CachedSplit_OnePass(int i)     { Parse1Split(i, Parse1CachedOnePass); }
-void Parse_CachedSplit_PCRE(int i)        { Parse1Split(i, Parse1CachedPCRE); }
-void Parse_CachedSplit_RE2(int i)         { Parse1Split(i, Parse1CachedRE2); }
-void Parse_CachedSplit_BitState(int i)         { Parse1Split(i, Parse1CachedBitState); }
+void Parse_CachedSplit_NFA(benchmark::State& state)         { Parse1Split(state, Parse1CachedNFA); }
+void Parse_CachedSplit_OnePass(benchmark::State& state)     { Parse1Split(state, Parse1CachedOnePass); }
+void Parse_CachedSplit_PCRE(benchmark::State& state)        { Parse1Split(state, Parse1CachedPCRE); }
+void Parse_CachedSplit_RE2(benchmark::State& state)         { Parse1Split(state, Parse1CachedRE2); }
+void Parse_CachedSplit_BitState(benchmark::State& state)    { Parse1Split(state, Parse1CachedBitState); }
 
 BENCHMARK(Parse_CachedSplit_NFA)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_CachedSplit_OnePass)->ThreadRange(1, NumCPUs());
@@ -569,17 +566,17 @@ BENCHMARK(Parse_CachedSplit_BitState)->ThreadRange(1, NumCPUs());
 
 // Benchmark: splitting off leading number field but harder (ambiguous regexp).
 
-void Parse1SplitHard(int iters,
-                  void (*run)(int, const char*, const StringPiece&)) {
-  BenchmarkMemoryUsage();
-  run(iters, "[0-9]+.(.*)", "650-253-0001");
-  SetBenchmarkItemsProcessed(iters);
+void Parse1SplitHard(benchmark::State& state,
+                     void (*run)(benchmark::State&, const char*,
+                                 const StringPiece&)) {
+  run(state, "[0-9]+.(.*)", "650-253-0001");
+  state.SetItemsProcessed(state.iterations());
 }
 
-void Parse_SplitHard_NFA(int i)         { Parse1SplitHard(i, Parse1NFA); }
-void Parse_SplitHard_PCRE(int i)        { Parse1SplitHard(i, Parse1PCRE); }
-void Parse_SplitHard_RE2(int i)         { Parse1SplitHard(i, Parse1RE2); }
-void Parse_SplitHard_BitState(int i)         { Parse1SplitHard(i, Parse1BitState); }
+void Parse_SplitHard_NFA(benchmark::State& state)         { Parse1SplitHard(state, Parse1NFA); }
+void Parse_SplitHard_PCRE(benchmark::State& state)        { Parse1SplitHard(state, Parse1PCRE); }
+void Parse_SplitHard_RE2(benchmark::State& state)         { Parse1SplitHard(state, Parse1RE2); }
+void Parse_SplitHard_BitState(benchmark::State& state)    { Parse1SplitHard(state, Parse1BitState); }
 
 #ifdef USEPCRE
 BENCHMARK(Parse_SplitHard_PCRE)->ThreadRange(1, NumCPUs());
@@ -588,11 +585,11 @@ BENCHMARK(Parse_SplitHard_RE2)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_SplitHard_BitState)->ThreadRange(1, NumCPUs());
 BENCHMARK(Parse_SplitHard_NFA)->ThreadRange(1, NumCPUs());
 
-void Parse_CachedSplitHard_NFA(int i)       { Parse1SplitHard(i, Parse1CachedNFA); }
-void Parse_CachedSplitHard_PCRE(int i)      { Parse1SplitHard(i, Parse1CachedPCRE); }
-void Parse_CachedSplitHard_RE2(int i)       { Parse1SplitHard(i, Parse1CachedRE2); }
-void Parse_CachedSplitHard_BitState(int i)       { Parse1SplitHard(i, Parse1CachedBitState); }
-void Parse_CachedSplitHard_Backtrack(int i)       { Parse1SplitHard(i, Parse1CachedBacktrack); }
+void Parse_CachedSplitHard_NFA(benchmark::State& state)       { Parse1SplitHard(state, Parse1CachedNFA); }
+void Parse_CachedSplitHard_PCRE(benchmark::State& state)      { Parse1SplitHard(state, Parse1CachedPCRE); }
+void Parse_CachedSplitHard_RE2(benchmark::State& state)       { Parse1SplitHard(state, Parse1CachedRE2); }
+void Parse_CachedSplitHard_BitState(benchmark::State& state)  { Parse1SplitHard(state, Parse1CachedBitState); }
+void Parse_CachedSplitHard_Backtrack(benchmark::State& state) { Parse1SplitHard(state, Parse1CachedBacktrack); }
 
 #ifdef USEPCRE
 BENCHMARK(Parse_CachedSplitHard_PCRE)->ThreadRange(1, NumCPUs());
@@ -604,18 +601,18 @@ BENCHMARK(Parse_CachedSplitHard_Backtrack)->ThreadRange(1, NumCPUs());
 
 // Benchmark: Parse1SplitHard, big text, small match.
 
-void Parse1SplitBig1(int iters,
-                  void (*run)(int, const char*, const StringPiece&)) {
+void Parse1SplitBig1(benchmark::State& state,
+                     void (*run)(benchmark::State&, const char*,
+                                 const StringPiece&)) {
   std::string s;
   s.append(100000, 'x');
   s.append("650-253-0001");
-  BenchmarkMemoryUsage();
-  run(iters, "[0-9]+.(.*)", s);
-  SetBenchmarkItemsProcessed(iters);
+  run(state, "[0-9]+.(.*)", s);
+  state.SetItemsProcessed(state.iterations());
 }
 
-void Parse_CachedSplitBig1_PCRE(int i)      { Parse1SplitBig1(i, SearchParse1CachedPCRE); }
-void Parse_CachedSplitBig1_RE2(int i)       { Parse1SplitBig1(i, SearchParse1CachedRE2); }
+void Parse_CachedSplitBig1_PCRE(benchmark::State& state)      { Parse1SplitBig1(state, SearchParse1CachedPCRE); }
+void Parse_CachedSplitBig1_RE2(benchmark::State& state)       { Parse1SplitBig1(state, SearchParse1CachedRE2); }
 
 #ifdef USEPCRE
 BENCHMARK(Parse_CachedSplitBig1_PCRE)->ThreadRange(1, NumCPUs());
@@ -624,18 +621,18 @@ BENCHMARK(Parse_CachedSplitBig1_RE2)->ThreadRange(1, NumCPUs());
 
 // Benchmark: Parse1SplitHard, big text, big match.
 
-void Parse1SplitBig2(int iters,
-                  void (*run)(int, const char*, const StringPiece&)) {
+void Parse1SplitBig2(benchmark::State& state,
+                     void (*run)(benchmark::State&, const char*,
+                                 const StringPiece&)) {
   std::string s;
   s.append("650-253-");
   s.append(100000, '0');
-  BenchmarkMemoryUsage();
-  run(iters, "[0-9]+.(.*)", s);
-  SetBenchmarkItemsProcessed(iters);
+  run(state, "[0-9]+.(.*)", s);
+  state.SetItemsProcessed(state.iterations());
 }
 
-void Parse_CachedSplitBig2_PCRE(int i)      { Parse1SplitBig2(i, SearchParse1CachedPCRE); }
-void Parse_CachedSplitBig2_RE2(int i)       { Parse1SplitBig2(i, SearchParse1CachedRE2); }
+void Parse_CachedSplitBig2_PCRE(benchmark::State& state)      { Parse1SplitBig2(state, SearchParse1CachedPCRE); }
+void Parse_CachedSplitBig2_RE2(benchmark::State& state)       { Parse1SplitBig2(state, SearchParse1CachedRE2); }
 
 #ifdef USEPCRE
 BENCHMARK(Parse_CachedSplitBig2_PCRE)->ThreadRange(1, NumCPUs());
@@ -645,16 +642,16 @@ BENCHMARK(Parse_CachedSplitBig2_RE2)->ThreadRange(1, NumCPUs());
 // Benchmark: measure time required to parse (but not execute)
 // a simple regular expression.
 
-void ParseRegexp(int iters, const std::string& regexp) {
-  for (int i = 0; i < iters; i++) {
+void ParseRegexp(benchmark::State& state, const std::string& regexp) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     re->Decref();
   }
 }
 
-void SimplifyRegexp(int iters, const std::string& regexp) {
-  for (int i = 0; i < iters; i++) {
+void SimplifyRegexp(benchmark::State& state, const std::string& regexp) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Regexp* sre = re->Simplify();
@@ -664,17 +661,17 @@ void SimplifyRegexp(int iters, const std::string& regexp) {
   }
 }
 
-void NullWalkRegexp(int iters, const std::string& regexp) {
+void NullWalkRegexp(benchmark::State& state, const std::string& regexp) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     re->NullWalk();
   }
   re->Decref();
 }
 
-void SimplifyCompileRegexp(int iters, const std::string& regexp) {
-  for (int i = 0; i < iters; i++) {
+void SimplifyCompileRegexp(benchmark::State& state, const std::string& regexp) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Regexp* sre = re->Simplify();
@@ -687,8 +684,8 @@ void SimplifyCompileRegexp(int iters, const std::string& regexp) {
   }
 }
 
-void CompileRegexp(int iters, const std::string& regexp) {
-  for (int i = 0; i < iters; i++) {
+void CompileRegexp(benchmark::State& state, const std::string& regexp) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -698,10 +695,10 @@ void CompileRegexp(int iters, const std::string& regexp) {
   }
 }
 
-void CompileToProg(int iters, const std::string& regexp) {
+void CompileToProg(benchmark::State& state, const std::string& regexp) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     Prog* prog = re->CompileToProg(0);
     CHECK(prog);
     delete prog;
@@ -709,53 +706,54 @@ void CompileToProg(int iters, const std::string& regexp) {
   re->Decref();
 }
 
-void CompileByteMap(int iters, const std::string& regexp) {
+void CompileByteMap(benchmark::State& state, const std::string& regexp) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     prog->ComputeByteMap();
   }
   delete prog;
   re->Decref();
 }
 
-void CompilePCRE(int iters, const std::string& regexp) {
-  for (int i = 0; i < iters; i++) {
+void CompilePCRE(benchmark::State& state, const std::string& regexp) {
+  for (auto _ : state) {
     PCRE re(regexp, PCRE::UTF8);
     CHECK_EQ(re.error(), "");
   }
 }
 
-void CompileRE2(int iters, const std::string& regexp) {
-  for (int i = 0; i < iters; i++) {
+void CompileRE2(benchmark::State& state, const std::string& regexp) {
+  for (auto _ : state) {
     RE2 re(regexp);
     CHECK_EQ(re.error(), "");
   }
 }
 
-void RunBuild(int iters, const std::string& regexp,
-              void (*run)(int, const std::string&)) {
-  run(iters, regexp);
-  SetBenchmarkItemsProcessed(iters);
+void RunBuild(benchmark::State& state, const std::string& regexp,
+              void (*run)(benchmark::State&, const std::string&)) {
+  run(state, regexp);
+  state.SetItemsProcessed(state.iterations());
 }
 
 }  // namespace re2
 
-DEFINE_string(compile_regexp, "(.*)-(\\d+)-of-(\\d+)", "regexp for compile benchmarks");
+DEFINE_FLAG(std::string, compile_regexp, "(.*)-(\\d+)-of-(\\d+)",
+            "regexp for compile benchmarks");
 
 namespace re2 {
 
-void BM_PCRE_Compile(int i)      { RunBuild(i, FLAGS_compile_regexp, CompilePCRE); }
-void BM_Regexp_Parse(int i)      { RunBuild(i, FLAGS_compile_regexp, ParseRegexp); }
-void BM_Regexp_Simplify(int i)   { RunBuild(i, FLAGS_compile_regexp, SimplifyRegexp); }
-void BM_CompileToProg(int i)     { RunBuild(i, FLAGS_compile_regexp, CompileToProg); }
-void BM_CompileByteMap(int i)     { RunBuild(i, FLAGS_compile_regexp, CompileByteMap); }
-void BM_Regexp_Compile(int i)    { RunBuild(i, FLAGS_compile_regexp, CompileRegexp); }
-void BM_Regexp_SimplifyCompile(int i)   { RunBuild(i, FLAGS_compile_regexp, SimplifyCompileRegexp); }
-void BM_Regexp_NullWalk(int i)   { RunBuild(i, FLAGS_compile_regexp, NullWalkRegexp); }
-void BM_RE2_Compile(int i)       { RunBuild(i, FLAGS_compile_regexp, CompileRE2); }
+void BM_PCRE_Compile(benchmark::State& state)             { RunBuild(state, GetFlag(FLAGS_compile_regexp), CompilePCRE); }
+void BM_Regexp_Parse(benchmark::State& state)             { RunBuild(state, GetFlag(FLAGS_compile_regexp), ParseRegexp); }
+void BM_Regexp_Simplify(benchmark::State& state)          { RunBuild(state, GetFlag(FLAGS_compile_regexp), SimplifyRegexp); }
+void BM_CompileToProg(benchmark::State& state)            { RunBuild(state, GetFlag(FLAGS_compile_regexp), CompileToProg); }
+void BM_CompileByteMap(benchmark::State& state)           { RunBuild(state, GetFlag(FLAGS_compile_regexp), CompileByteMap); }
+void BM_Regexp_Compile(benchmark::State& state)           { RunBuild(state, GetFlag(FLAGS_compile_regexp), CompileRegexp); }
+void BM_Regexp_SimplifyCompile(benchmark::State& state)   { RunBuild(state, GetFlag(FLAGS_compile_regexp), SimplifyCompileRegexp); }
+void BM_Regexp_NullWalk(benchmark::State& state)          { RunBuild(state, GetFlag(FLAGS_compile_regexp), NullWalkRegexp); }
+void BM_RE2_Compile(benchmark::State& state)              { RunBuild(state, GetFlag(FLAGS_compile_regexp), CompileRE2); }
 
 #ifdef USEPCRE
 BENCHMARK(BM_PCRE_Compile)->ThreadRange(1, NumCPUs());
@@ -771,22 +769,20 @@ BENCHMARK(BM_RE2_Compile)->ThreadRange(1, NumCPUs());
 
 // Makes text of size nbytes, then calls run to search
 // the text for regexp iters times.
-void SearchPhone(int iters, int nbytes, ParseImpl* search) {
-  StopBenchmarkTiming();
+void SearchPhone(benchmark::State& state, ParseImpl* search) {
   std::string s;
-  MakeText(&s, nbytes);
+  MakeText(&s, state.range(0));
   s.append("(650) 253-0001");
-  BenchmarkMemoryUsage();
-  StartBenchmarkTiming();
-  search(iters, "(\\d{3}-|\\(\\d{3}\\)\\s+)(\\d{3}-\\d{4})", s);
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iters)*nbytes);
+  search(state, "(\\d{3}-|\\(\\d{3}\\)\\s+)(\\d{3}-\\d{4})", s);
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
-void SearchPhone_CachedPCRE(int i, int n) {
-  SearchPhone(i, n, SearchParse2CachedPCRE);
+void SearchPhone_CachedPCRE(benchmark::State& state) {
+  SearchPhone(state, SearchParse2CachedPCRE);
 }
-void SearchPhone_CachedRE2(int i, int n) {
-  SearchPhone(i, n, SearchParse2CachedRE2);
+
+void SearchPhone_CachedRE2(benchmark::State& state) {
+  SearchPhone(state, SearchParse2CachedRE2);
 }
 
 #ifdef USEPCRE
@@ -881,9 +877,10 @@ DO24(MY_BENCHMARK_WITH_ARG, CacheFillDFA)
 // Expect_match says whether the regexp should be found.
 // Anchored says whether to run an anchored search.
 
-void SearchDFA(int iters, const char* regexp, const StringPiece& text,
-            Prog::Anchor anchor, bool expect_match) {
-  for (int i = 0; i < iters; i++) {
+void SearchDFA(benchmark::State& state, const char* regexp,
+               const StringPiece& text, Prog::Anchor anchor,
+               bool expect_match) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -898,9 +895,10 @@ void SearchDFA(int iters, const char* regexp, const StringPiece& text,
   }
 }
 
-void SearchNFA(int iters, const char* regexp, const StringPiece& text,
-            Prog::Anchor anchor, bool expect_match) {
-  for (int i = 0; i < iters; i++) {
+void SearchNFA(benchmark::State& state, const char* regexp,
+               const StringPiece& text, Prog::Anchor anchor,
+               bool expect_match) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -913,9 +911,10 @@ void SearchNFA(int iters, const char* regexp, const StringPiece& text,
   }
 }
 
-void SearchOnePass(int iters, const char* regexp, const StringPiece& text,
-            Prog::Anchor anchor, bool expect_match) {
-  for (int i = 0; i < iters; i++) {
+void SearchOnePass(benchmark::State& state, const char* regexp,
+                   const StringPiece& text, Prog::Anchor anchor,
+                   bool expect_match) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -928,9 +927,10 @@ void SearchOnePass(int iters, const char* regexp, const StringPiece& text,
   }
 }
 
-void SearchBitState(int iters, const char* regexp, const StringPiece& text,
-            Prog::Anchor anchor, bool expect_match) {
-  for (int i = 0; i < iters; i++) {
+void SearchBitState(benchmark::State& state, const char* regexp,
+                    const StringPiece& text, Prog::Anchor anchor,
+                    bool expect_match) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -943,9 +943,10 @@ void SearchBitState(int iters, const char* regexp, const StringPiece& text,
   }
 }
 
-void SearchPCRE(int iters, const char* regexp, const StringPiece& text,
-                Prog::Anchor anchor, bool expect_match) {
-  for (int i = 0; i < iters; i++) {
+void SearchPCRE(benchmark::State& state, const char* regexp,
+                const StringPiece& text, Prog::Anchor anchor,
+                bool expect_match) {
+  for (auto _ : state) {
     PCRE re(regexp, PCRE::UTF8);
     CHECK_EQ(re.error(), "");
     if (anchor == Prog::kAnchored)
@@ -955,9 +956,10 @@ void SearchPCRE(int iters, const char* regexp, const StringPiece& text,
   }
 }
 
-void SearchRE2(int iters, const char* regexp, const StringPiece& text,
-               Prog::Anchor anchor, bool expect_match) {
-  for (int i = 0; i < iters; i++) {
+void SearchRE2(benchmark::State& state, const char* regexp,
+               const StringPiece& text, Prog::Anchor anchor,
+               bool expect_match) {
+  for (auto _ : state) {
     RE2 re(regexp);
     CHECK_EQ(re.error(), "");
     if (anchor == Prog::kAnchored)
@@ -971,13 +973,14 @@ void SearchRE2(int iters, const char* regexp, const StringPiece& text,
 // regexp parsing and compiling once.  This lets us measure
 // search time without the per-regexp overhead.
 
-void SearchCachedDFA(int iters, const char* regexp, const StringPiece& text,
-                     Prog::Anchor anchor, bool expect_match) {
+void SearchCachedDFA(benchmark::State& state, const char* regexp,
+                     const StringPiece& text, Prog::Anchor anchor,
+                     bool expect_match) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(1LL<<31);
   CHECK(prog);
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     bool failed = false;
     CHECK_EQ(prog->SearchDFA(text, StringPiece(), anchor, Prog::kFirstMatch,
                              NULL, &failed, NULL),
@@ -988,13 +991,14 @@ void SearchCachedDFA(int iters, const char* regexp, const StringPiece& text,
   re->Decref();
 }
 
-void SearchCachedNFA(int iters, const char* regexp, const StringPiece& text,
-                     Prog::Anchor anchor, bool expect_match) {
+void SearchCachedNFA(benchmark::State& state, const char* regexp,
+                     const StringPiece& text, Prog::Anchor anchor,
+                     bool expect_match) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     CHECK_EQ(prog->SearchNFA(text, StringPiece(), anchor, Prog::kFirstMatch,
                              NULL, 0),
              expect_match);
@@ -1003,39 +1007,44 @@ void SearchCachedNFA(int iters, const char* regexp, const StringPiece& text,
   re->Decref();
 }
 
-void SearchCachedOnePass(int iters, const char* regexp, const StringPiece& text,
-                     Prog::Anchor anchor, bool expect_match) {
+void SearchCachedOnePass(benchmark::State& state, const char* regexp,
+                         const StringPiece& text, Prog::Anchor anchor,
+                         bool expect_match) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   CHECK(prog->IsOnePass());
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK_EQ(prog->SearchOnePass(text, text, anchor, Prog::kFirstMatch, NULL, 0),
              expect_match);
+  }
   delete prog;
   re->Decref();
 }
 
-void SearchCachedBitState(int iters, const char* regexp, const StringPiece& text,
-                     Prog::Anchor anchor, bool expect_match) {
+void SearchCachedBitState(benchmark::State& state, const char* regexp,
+                          const StringPiece& text, Prog::Anchor anchor,
+                          bool expect_match) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   CHECK(prog->CanBitState());
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK_EQ(prog->SearchBitState(text, text, anchor, Prog::kFirstMatch, NULL, 0),
              expect_match);
+  }
   delete prog;
   re->Decref();
 }
 
-void SearchCachedPCRE(int iters, const char* regexp, const StringPiece& text,
-                     Prog::Anchor anchor, bool expect_match) {
+void SearchCachedPCRE(benchmark::State& state, const char* regexp,
+                      const StringPiece& text, Prog::Anchor anchor,
+                      bool expect_match) {
   PCRE re(regexp, PCRE::UTF8);
   CHECK_EQ(re.error(), "");
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     if (anchor == Prog::kAnchored)
       CHECK_EQ(PCRE::FullMatch(text, re), expect_match);
     else
@@ -1043,11 +1052,12 @@ void SearchCachedPCRE(int iters, const char* regexp, const StringPiece& text,
   }
 }
 
-void SearchCachedRE2(int iters, const char* regexp, const StringPiece& text,
-                     Prog::Anchor anchor, bool expect_match) {
+void SearchCachedRE2(benchmark::State& state, const char* regexp,
+                     const StringPiece& text, Prog::Anchor anchor,
+                     bool expect_match) {
   RE2 re(regexp);
   CHECK_EQ(re.error(), "");
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     if (anchor == Prog::kAnchored)
       CHECK_EQ(RE2::FullMatch(text, re), expect_match);
     else
@@ -1055,12 +1065,12 @@ void SearchCachedRE2(int iters, const char* regexp, const StringPiece& text,
   }
 }
 
-
 // Runs implementation to full match regexp against text,
 // extracting three submatches.  Expects match always.
 
-void Parse3NFA(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse3NFA(benchmark::State& state, const char* regexp,
+               const StringPiece& text) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -1073,8 +1083,9 @@ void Parse3NFA(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse3OnePass(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse3OnePass(benchmark::State& state, const char* regexp,
+                   const StringPiece& text) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -1087,8 +1098,9 @@ void Parse3OnePass(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse3BitState(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse3BitState(benchmark::State& state, const char* regexp,
+                    const StringPiece& text) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -1101,8 +1113,9 @@ void Parse3BitState(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse3Backtrack(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse3Backtrack(benchmark::State& state, const char* regexp,
+                     const StringPiece& text) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -1114,8 +1127,9 @@ void Parse3Backtrack(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse3PCRE(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse3PCRE(benchmark::State& state, const char* regexp,
+                const StringPiece& text) {
+  for (auto _ : state) {
     PCRE re(regexp, PCRE::UTF8);
     CHECK_EQ(re.error(), "");
     StringPiece sp1, sp2, sp3;
@@ -1123,8 +1137,9 @@ void Parse3PCRE(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse3RE2(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse3RE2(benchmark::State& state, const char* regexp,
+               const StringPiece& text) {
+  for (auto _ : state) {
     RE2 re(regexp);
     CHECK_EQ(re.error(), "");
     StringPiece sp1, sp2, sp3;
@@ -1132,13 +1147,14 @@ void Parse3RE2(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse3CachedNFA(int iters, const char* regexp, const StringPiece& text) {
+void Parse3CachedNFA(benchmark::State& state, const char* regexp,
+                     const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   StringPiece sp[4];  // 4 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     CHECK(prog->SearchNFA(text, StringPiece(), Prog::kAnchored,
                           Prog::kFullMatch, sp, 4));
   }
@@ -1146,68 +1162,76 @@ void Parse3CachedNFA(int iters, const char* regexp, const StringPiece& text) {
   re->Decref();
 }
 
-void Parse3CachedOnePass(int iters, const char* regexp, const StringPiece& text) {
+void Parse3CachedOnePass(benchmark::State& state, const char* regexp,
+                         const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   CHECK(prog->IsOnePass());
   StringPiece sp[4];  // 4 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK(prog->SearchOnePass(text, text, Prog::kAnchored, Prog::kFullMatch, sp, 4));
+  }
   delete prog;
   re->Decref();
 }
 
-void Parse3CachedBitState(int iters, const char* regexp, const StringPiece& text) {
+void Parse3CachedBitState(benchmark::State& state, const char* regexp,
+                          const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   CHECK(prog->CanBitState());
   StringPiece sp[4];  // 4 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK(prog->SearchBitState(text, text, Prog::kAnchored, Prog::kFullMatch, sp, 4));
+  }
   delete prog;
   re->Decref();
 }
 
-void Parse3CachedBacktrack(int iters, const char* regexp, const StringPiece& text) {
+void Parse3CachedBacktrack(benchmark::State& state, const char* regexp,
+                           const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   StringPiece sp[4];  // 4 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK(prog->UnsafeSearchBacktrack(text, text, Prog::kAnchored, Prog::kFullMatch, sp, 4));
+  }
   delete prog;
   re->Decref();
 }
 
-void Parse3CachedPCRE(int iters, const char* regexp, const StringPiece& text) {
+void Parse3CachedPCRE(benchmark::State& state, const char* regexp,
+                      const StringPiece& text) {
   PCRE re(regexp, PCRE::UTF8);
   CHECK_EQ(re.error(), "");
   StringPiece sp1, sp2, sp3;
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     CHECK(PCRE::FullMatch(text, re, &sp1, &sp2, &sp3));
   }
 }
 
-void Parse3CachedRE2(int iters, const char* regexp, const StringPiece& text) {
+void Parse3CachedRE2(benchmark::State& state, const char* regexp,
+                     const StringPiece& text) {
   RE2 re(regexp);
   CHECK_EQ(re.error(), "");
   StringPiece sp1, sp2, sp3;
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     CHECK(RE2::FullMatch(text, re, &sp1, &sp2, &sp3));
   }
 }
 
-
 // Runs implementation to full match regexp against text,
 // extracting three submatches.  Expects match always.
 
-void Parse1NFA(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse1NFA(benchmark::State& state, const char* regexp,
+               const StringPiece& text) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -1220,8 +1244,9 @@ void Parse1NFA(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse1OnePass(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse1OnePass(benchmark::State& state, const char* regexp,
+                   const StringPiece& text) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -1234,8 +1259,9 @@ void Parse1OnePass(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse1BitState(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse1BitState(benchmark::State& state, const char* regexp,
+                    const StringPiece& text) {
+  for (auto _ : state) {
     Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
     CHECK(re);
     Prog* prog = re->CompileToProg(0);
@@ -1248,8 +1274,9 @@ void Parse1BitState(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse1PCRE(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse1PCRE(benchmark::State& state, const char* regexp,
+                const StringPiece& text) {
+  for (auto _ : state) {
     PCRE re(regexp, PCRE::UTF8);
     CHECK_EQ(re.error(), "");
     StringPiece sp1;
@@ -1257,8 +1284,9 @@ void Parse1PCRE(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse1RE2(int iters, const char* regexp, const StringPiece& text) {
-  for (int i = 0; i < iters; i++) {
+void Parse1RE2(benchmark::State& state, const char* regexp,
+               const StringPiece& text) {
+  for (auto _ : state) {
     RE2 re(regexp);
     CHECK_EQ(re.error(), "");
     StringPiece sp1;
@@ -1266,13 +1294,14 @@ void Parse1RE2(int iters, const char* regexp, const StringPiece& text) {
   }
 }
 
-void Parse1CachedNFA(int iters, const char* regexp, const StringPiece& text) {
+void Parse1CachedNFA(benchmark::State& state, const char* regexp,
+                     const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   StringPiece sp[2];  // 2 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     CHECK(prog->SearchNFA(text, StringPiece(), Prog::kAnchored,
                           Prog::kFullMatch, sp, 2));
   }
@@ -1280,112 +1309,120 @@ void Parse1CachedNFA(int iters, const char* regexp, const StringPiece& text) {
   re->Decref();
 }
 
-void Parse1CachedOnePass(int iters, const char* regexp, const StringPiece& text) {
+void Parse1CachedOnePass(benchmark::State& state, const char* regexp,
+                         const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   CHECK(prog->IsOnePass());
   StringPiece sp[2];  // 2 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK(prog->SearchOnePass(text, text, Prog::kAnchored, Prog::kFullMatch, sp, 2));
+  }
   delete prog;
   re->Decref();
 }
 
-void Parse1CachedBitState(int iters, const char* regexp, const StringPiece& text) {
+void Parse1CachedBitState(benchmark::State& state, const char* regexp,
+                          const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   CHECK(prog->CanBitState());
   StringPiece sp[2];  // 2 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK(prog->SearchBitState(text, text, Prog::kAnchored, Prog::kFullMatch, sp, 2));
+  }
   delete prog;
   re->Decref();
 }
 
-void Parse1CachedBacktrack(int iters, const char* regexp, const StringPiece& text) {
+void Parse1CachedBacktrack(benchmark::State& state, const char* regexp,
+                           const StringPiece& text) {
   Regexp* re = Regexp::Parse(regexp, Regexp::LikePerl, NULL);
   CHECK(re);
   Prog* prog = re->CompileToProg(0);
   CHECK(prog);
   StringPiece sp[2];  // 2 because sp[0] is whole match.
-  for (int i = 0; i < iters; i++)
+  for (auto _ : state) {
     CHECK(prog->UnsafeSearchBacktrack(text, text, Prog::kAnchored, Prog::kFullMatch, sp, 2));
+  }
   delete prog;
   re->Decref();
 }
 
-void Parse1CachedPCRE(int iters, const char* regexp, const StringPiece& text) {
+void Parse1CachedPCRE(benchmark::State& state, const char* regexp,
+                      const StringPiece& text) {
   PCRE re(regexp, PCRE::UTF8);
   CHECK_EQ(re.error(), "");
   StringPiece sp1;
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     CHECK(PCRE::FullMatch(text, re, &sp1));
   }
 }
 
-void Parse1CachedRE2(int iters, const char* regexp, const StringPiece& text) {
+void Parse1CachedRE2(benchmark::State& state, const char* regexp,
+                     const StringPiece& text) {
   RE2 re(regexp);
   CHECK_EQ(re.error(), "");
   StringPiece sp1;
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     CHECK(RE2::FullMatch(text, re, &sp1));
   }
 }
 
-void SearchParse2CachedPCRE(int iters, const char* regexp,
+void SearchParse2CachedPCRE(benchmark::State& state, const char* regexp,
                             const StringPiece& text) {
   PCRE re(regexp, PCRE::UTF8);
   CHECK_EQ(re.error(), "");
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     StringPiece sp1, sp2;
     CHECK(PCRE::PartialMatch(text, re, &sp1, &sp2));
   }
 }
 
-void SearchParse2CachedRE2(int iters, const char* regexp,
+void SearchParse2CachedRE2(benchmark::State& state, const char* regexp,
                            const StringPiece& text) {
   RE2 re(regexp);
   CHECK_EQ(re.error(), "");
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     StringPiece sp1, sp2;
     CHECK(RE2::PartialMatch(text, re, &sp1, &sp2));
   }
 }
 
-void SearchParse1CachedPCRE(int iters, const char* regexp,
+void SearchParse1CachedPCRE(benchmark::State& state, const char* regexp,
                             const StringPiece& text) {
   PCRE re(regexp, PCRE::UTF8);
   CHECK_EQ(re.error(), "");
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     StringPiece sp1;
     CHECK(PCRE::PartialMatch(text, re, &sp1));
   }
 }
 
-void SearchParse1CachedRE2(int iters, const char* regexp,
+void SearchParse1CachedRE2(benchmark::State& state, const char* regexp,
                            const StringPiece& text) {
   RE2 re(regexp);
   CHECK_EQ(re.error(), "");
-  for (int i = 0; i < iters; i++) {
+  for (auto _ : state) {
     StringPiece sp1;
     CHECK(RE2::PartialMatch(text, re, &sp1));
   }
 }
 
-void EmptyPartialMatchPCRE(int n) {
+void EmptyPartialMatchPCRE(benchmark::State& state) {
   PCRE re("");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     PCRE::PartialMatch("", re);
   }
 }
 
-void EmptyPartialMatchRE2(int n) {
+void EmptyPartialMatchRE2(benchmark::State& state) {
   RE2 re("");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     RE2::PartialMatch("", re);
   }
 }
@@ -1394,16 +1431,16 @@ BENCHMARK(EmptyPartialMatchPCRE)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK(EmptyPartialMatchRE2)->ThreadRange(1, NumCPUs());
 
-void SimplePartialMatchPCRE(int n) {
+void SimplePartialMatchPCRE(benchmark::State& state) {
   PCRE re("abcdefg");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     PCRE::PartialMatch("abcdefg", re);
   }
 }
 
-void SimplePartialMatchRE2(int n) {
+void SimplePartialMatchRE2(benchmark::State& state) {
   RE2 re("abcdefg");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     RE2::PartialMatch("abcdefg", re);
   }
 }
@@ -1416,18 +1453,18 @@ static std::string http_text =
   "GET /asdfhjasdhfasdlfhasdflkjasdfkljasdhflaskdjhf"
   "alksdjfhasdlkfhasdlkjfhasdljkfhadsjklf HTTP/1.1";
 
-void HTTPPartialMatchPCRE(int n) {
+void HTTPPartialMatchPCRE(benchmark::State& state) {
   StringPiece a;
   PCRE re("(?-s)^(?:GET|POST) +([^ ]+) HTTP");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     PCRE::PartialMatch(http_text, re, &a);
   }
 }
 
-void HTTPPartialMatchRE2(int n) {
+void HTTPPartialMatchRE2(benchmark::State& state) {
   StringPiece a;
   RE2 re("(?-s)^(?:GET|POST) +([^ ]+) HTTP");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     RE2::PartialMatch(http_text, re, &a);
   }
 }
@@ -1440,18 +1477,18 @@ BENCHMARK(HTTPPartialMatchRE2)->ThreadRange(1, NumCPUs());
 static std::string smallhttp_text =
   "GET /abc HTTP/1.1";
 
-void SmallHTTPPartialMatchPCRE(int n) {
+void SmallHTTPPartialMatchPCRE(benchmark::State& state) {
   StringPiece a;
   PCRE re("(?-s)^(?:GET|POST) +([^ ]+) HTTP");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     PCRE::PartialMatch(smallhttp_text, re, &a);
   }
 }
 
-void SmallHTTPPartialMatchRE2(int n) {
+void SmallHTTPPartialMatchRE2(benchmark::State& state) {
   StringPiece a;
   RE2 re("(?-s)^(?:GET|POST) +([^ ]+) HTTP");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     RE2::PartialMatch(smallhttp_text, re, &a);
   }
 }
@@ -1461,18 +1498,18 @@ BENCHMARK(SmallHTTPPartialMatchPCRE)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK(SmallHTTPPartialMatchRE2)->ThreadRange(1, NumCPUs());
 
-void DotMatchPCRE(int n) {
+void DotMatchPCRE(benchmark::State& state) {
   StringPiece a;
   PCRE re("(?-s)^(.+)");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     PCRE::PartialMatch(http_text, re, &a);
   }
 }
 
-void DotMatchRE2(int n) {
+void DotMatchRE2(benchmark::State& state) {
   StringPiece a;
   RE2 re("(?-s)^(.+)");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     RE2::PartialMatch(http_text, re, &a);
   }
 }
@@ -1482,18 +1519,18 @@ BENCHMARK(DotMatchPCRE)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK(DotMatchRE2)->ThreadRange(1, NumCPUs());
 
-void ASCIIMatchPCRE(int n) {
+void ASCIIMatchPCRE(benchmark::State& state) {
   StringPiece a;
   PCRE re("(?-s)^([ -~]+)");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     PCRE::PartialMatch(http_text, re, &a);
   }
 }
 
-void ASCIIMatchRE2(int n) {
+void ASCIIMatchRE2(benchmark::State& state) {
   StringPiece a;
   RE2 re("(?-s)^([ -~]+)");
-  for (int i = 0; i < n; i++) {
+  for (auto _ : state) {
     RE2::PartialMatch(http_text, re, &a);
   }
 }
@@ -1503,40 +1540,36 @@ BENCHMARK(ASCIIMatchPCRE)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK(ASCIIMatchRE2)->ThreadRange(1, NumCPUs());
 
-void FullMatchPCRE(int iter, int n, const char *regexp) {
-  StopBenchmarkTiming();
+void FullMatchPCRE(benchmark::State& state, const char *regexp) {
   std::string s;
-  MakeText(&s, n);
+  MakeText(&s, state.range(0));
   s += "ABCDEFGHIJ";
-  BenchmarkMemoryUsage();
   PCRE re(regexp);
-  StartBenchmarkTiming();
-  for (int i = 0; i < iter; i++)
+  for (auto _ : state) {
     CHECK(PCRE::FullMatch(s, re));
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iter)*n);
+  }
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
-void FullMatchRE2(int iter, int n, const char *regexp) {
-  StopBenchmarkTiming();
+void FullMatchRE2(benchmark::State& state, const char *regexp) {
   std::string s;
-  MakeText(&s, n);
+  MakeText(&s, state.range(0));
   s += "ABCDEFGHIJ";
-  BenchmarkMemoryUsage();
   RE2 re(regexp, RE2::Latin1);
-  StartBenchmarkTiming();
-  for (int i = 0; i < iter; i++)
+  for (auto _ : state) {
     CHECK(RE2::FullMatch(s, re));
-  SetBenchmarkBytesProcessed(static_cast<int64_t>(iter)*n);
+  }
+  state.SetBytesProcessed(state.iterations() * state.range(0));
 }
 
-void FullMatch_DotStar_CachedPCRE(int i, int n) { FullMatchPCRE(i, n, "(?s).*"); }
-void FullMatch_DotStar_CachedRE2(int i, int n)  { FullMatchRE2(i, n, "(?s).*"); }
+void FullMatch_DotStar_CachedPCRE(benchmark::State& state) { FullMatchPCRE(state, "(?s).*"); }
+void FullMatch_DotStar_CachedRE2(benchmark::State& state)  { FullMatchRE2(state, "(?s).*"); }
 
-void FullMatch_DotStarDollar_CachedPCRE(int i, int n) { FullMatchPCRE(i, n, "(?s).*$"); }
-void FullMatch_DotStarDollar_CachedRE2(int i, int n)  { FullMatchRE2(i, n, "(?s).*$"); }
+void FullMatch_DotStarDollar_CachedPCRE(benchmark::State& state) { FullMatchPCRE(state, "(?s).*$"); }
+void FullMatch_DotStarDollar_CachedRE2(benchmark::State& state)  { FullMatchRE2(state, "(?s).*$"); }
 
-void FullMatch_DotStarCapture_CachedPCRE(int i, int n) { FullMatchPCRE(i, n, "(?s)((.*)()()($))"); }
-void FullMatch_DotStarCapture_CachedRE2(int i, int n)  { FullMatchRE2(i, n, "(?s)((.*)()()($))"); }
+void FullMatch_DotStarCapture_CachedPCRE(benchmark::State& state) { FullMatchPCRE(state, "(?s)((.*)()()($))"); }
+void FullMatch_DotStarCapture_CachedRE2(benchmark::State& state)  { FullMatchRE2(state, "(?s)((.*)()()($))"); }
 
 #ifdef USEPCRE
 BENCHMARK_RANGE(FullMatch_DotStar_CachedPCRE, 8, 2<<20);
@@ -1553,29 +1586,27 @@ BENCHMARK_RANGE(FullMatch_DotStarCapture_CachedPCRE, 8, 2<<20);
 #endif
 BENCHMARK_RANGE(FullMatch_DotStarCapture_CachedRE2,  8, 2<<20);
 
-void PossibleMatchRangeCommon(int iter, const char* regexp) {
-  StopBenchmarkTiming();
+void PossibleMatchRangeCommon(benchmark::State& state, const char* regexp) {
   RE2 re(regexp);
-  StartBenchmarkTiming();
   std::string min;
   std::string max;
   const int kMaxLen = 16;
-  for (int i = 0; i < iter; i++) {
+  for (auto _ : state) {
     CHECK(re.PossibleMatchRange(&min, &max, kMaxLen));
   }
 }
 
-void PossibleMatchRange_Trivial(int i) {
-  PossibleMatchRangeCommon(i, ".*");
+void PossibleMatchRange_Trivial(benchmark::State& state) {
+  PossibleMatchRangeCommon(state, ".*");
 }
-void PossibleMatchRange_Complex(int i) {
-  PossibleMatchRangeCommon(i, "^abc[def]?[gh]{1,2}.*");
+void PossibleMatchRange_Complex(benchmark::State& state) {
+  PossibleMatchRangeCommon(state, "^abc[def]?[gh]{1,2}.*");
 }
-void PossibleMatchRange_Prefix(int i) {
-  PossibleMatchRangeCommon(i, "^some_random_prefix.*");
+void PossibleMatchRange_Prefix(benchmark::State& state) {
+  PossibleMatchRangeCommon(state, "^some_random_prefix.*");
 }
-void PossibleMatchRange_NoProg(int i) {
-  PossibleMatchRangeCommon(i, "^some_random_string$");
+void PossibleMatchRange_NoProg(benchmark::State& state) {
+  PossibleMatchRangeCommon(state, "^some_random_string$");
 }
 
 BENCHMARK(PossibleMatchRange_Trivial);