Update re2

third_party/re2/re2/testing/regexp_benchmark.cc

 // Copyright 2006-2008 The RE2 Authors.  All Rights Reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // Benchmarks for regular expression implementations.
 
 #include "util/test.h"
 #include "re2/prog.h"
 #include "re2/re2.h"
 #include "re2/regexp.h"
@@ skipping 117 matching lines @@
 
 ParseImpl SearchParse2CachedPCRE, SearchParse2CachedRE2;
 
 ParseImpl SearchParse1CachedPCRE, SearchParse1CachedRE2;
 
 // Benchmark: failed search for regexp in random text.
 
 // Generate random text that won't contain the search string,
 // to test worst-case search behavior.
 void MakeText(string* text, int nbytes) {
+  srand(1);
   text->resize(nbytes);
-  srand(0);
   for (int i = 0; i < nbytes; i++) {
-    if (!rand()%30)
-      (*text)[i] = '\n';
-    else
-      (*text)[i] = rand()%(0x7E + 1 - 0x20)+0x20;
+    // 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;
+    if (byte < 0x20)
+      byte = 0x20;
+    (*text)[i] = byte;
   }
 }
 
 // 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();
   string s;
   MakeText(&s, nbytes);
   BenchmarkMemoryUsage();
@@ skipping 101 matching lines @@
 void Search_BigFixed_CachedRE2(int i, int n)     { SearchBigFixed(i, n, SearchCachedRE2); }
 
 BENCHMARK_RANGE(Search_BigFixed_CachedDFA,     8, 1<<20)->ThreadRange(1, NumCPUs());
 BENCHMARK_RANGE(Search_BigFixed_CachedNFA,     8, 32<<10)->ThreadRange(1, NumCPUs());
 #ifdef USEPCRE
 BENCHMARK_RANGE(Search_BigFixed_CachedPCRE,    8, 32<<10)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK_RANGE(Search_BigFixed_CachedRE2,     8, 1<<20)->ThreadRange(1, NumCPUs());
 
 // Benchmark: FindAndConsume
+
 void FindAndConsume(int iters, int nbytes) {
   StopBenchmarkTiming();
   string s;
   MakeText(&s, nbytes);
   s.append("Hello World");
   StartBenchmarkTiming();
   RE2 re("((Hello World))");
   for (int i = 0; i < iters; i++) {
     StringPiece t = s;
     StringPiece u;
     CHECK(RE2::FindAndConsume(&t, re, &u));
     CHECK_EQ(u, "Hello World");
   }
   SetBenchmarkBytesProcessed(static_cast<int64>(iters)*nbytes);
 }
 
 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();
   string s;
   MakeText(&s, nbytes);
   BenchmarkMemoryUsage();
+  StartBenchmarkTiming();
   search(iters, regexp, s, Prog::kAnchored, true);
   SetBenchmarkBytesProcessed(static_cast<int64>(iters)*nbytes);
 }
 
 // Unambiguous search (RE2 can use OnePass).
 
 void Search_Success_DFA(int i, int n)     { SearchSuccess(i, n, ".*$", SearchDFA); }
 void Search_Success_OnePass(int i, int n) { SearchSuccess(i, n, ".*$", SearchOnePass); }
 void Search_Success_PCRE(int i, int n)    { SearchSuccess(i, n, ".*$", SearchPCRE); }
 void Search_Success_RE2(int i, int n)     { SearchSuccess(i, n, ".*$", SearchRE2); }
@@ skipping 37 matching lines @@
 
 BENCHMARK_RANGE(Search_Success1_Cached_DFA,     8, 16<<20)->ThreadRange(1, NumCPUs());
 #ifdef USEPCRE
 BENCHMARK_RANGE(Search_Success1_Cached_PCRE,    8, 16<<20)->ThreadRange(1, NumCPUs());
 #endif
 BENCHMARK_RANGE(Search_Success1_Cached_RE2,     8, 16<<20)->ThreadRange(1, NumCPUs());
 
 // Benchmark: use regexp to find phone number.
 
 void SearchDigits(int iters, SearchImpl* search) {
-  const char *text = "650-253-0001";
-  int len = strlen(text);
+  StringPiece s("650-253-0001");
   BenchmarkMemoryUsage();
-  search(iters, "([0-9]+)-([0-9]+)-([0-9]+)",
-         StringPiece(text, len), Prog::kAnchored, true);
+  search(iters, "([0-9]+)-([0-9]+)-([0-9]+)", s, Prog::kAnchored, true);
   SetBenchmarkItemsProcessed(iters);
 }
 
 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); }
 
@@ skipping 317 matching lines @@
 #endif
 BENCHMARK(BM_Regexp_Parse)->ThreadRange(1, NumCPUs());
 BENCHMARK(BM_Regexp_Simplify)->ThreadRange(1, NumCPUs());
 BENCHMARK(BM_CompileToProg)->ThreadRange(1, NumCPUs());
 BENCHMARK(BM_CompileByteMap)->ThreadRange(1, NumCPUs());
 BENCHMARK(BM_Regexp_Compile)->ThreadRange(1, NumCPUs());
 BENCHMARK(BM_Regexp_SimplifyCompile)->ThreadRange(1, NumCPUs());
 BENCHMARK(BM_Regexp_NullWalk)->ThreadRange(1, NumCPUs());
 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();
   string s;
   MakeText(&s, nbytes);
   s.append("(650) 253-0001");
   BenchmarkMemoryUsage();
   StartBenchmarkTiming();
   search(iters, "(\\d{3}-|\\(\\d{3}\\)\\s+)(\\d{3}-\\d{4})", s);
@@ skipping 752 matching lines @@
 BENCHMARK_RANGE(FullMatch_DotStarDollar_CachedPCRE, 8, 2<<20);
 #endif
 BENCHMARK_RANGE(FullMatch_DotStarDollar_CachedRE2,  8, 2<<20);
 
 #ifdef USEPCRE
 BENCHMARK_RANGE(FullMatch_DotStarCapture_CachedPCRE, 8, 2<<20);
 #endif
 BENCHMARK_RANGE(FullMatch_DotStarCapture_CachedRE2,  8, 2<<20);
 
 }  // namespace re2