Namespaces | Macros | Typedefs | Functions | Variables
re2/re2/testing/regexp_benchmark.cc File Reference
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <thread>
#include <unordered_map>
#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/mutex.h"
#include "util/pcre.h"
Include dependency graph for re2/re2/testing/regexp_benchmark.cc:

Go to the source code of this file.

Namespaces

 re2
 

Macros

#define EASY0   "ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
 
#define EASY1   "A[AB]B[BC]C[CD]D[DE]E[EF]F[FG]G[GH]H[HI]I[IJ]J$"
 
#define EASY2   "(?i)" EASY0
 
#define FANOUT   "(?:[\\x{80}-\\x{10FFFF}]?){100}[\\x{80}-\\x{10FFFF}]"
 
#define HARD   "[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
 
#define MEDIUM   "[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
 
#define PARENS
 

Typedefs

typedef testing::MallocCounter MallocCounter
 

Functions

void re2::ASCIIMatchPCRE (benchmark::State &state)
 
void re2::ASCIIMatchRE2 (benchmark::State &state)
 
 re2::BENCHMARK (ASCIIMatchRE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_CompileByteMap) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_CompileToProg) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_RE2_Compile) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_Regexp_Compile) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_Regexp_NullWalk) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_Regexp_Parse) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_Regexp_Simplify) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (BM_Regexp_SimplifyCompile) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (DotMatchRE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (EmptyPartialMatchRE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (HTTPPartialMatchRE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigitDs_Backtrack) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigitDs_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigitDs_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigitDs_OnePass) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigitDs_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigits_Backtrack) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigits_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigits_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigits_OnePass) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedDigits_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplit_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplit_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplit_OnePass) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplit_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplitBig1_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplitBig2_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplitHard_Backtrack) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplitHard_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplitHard_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_CachedSplitHard_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_DigitDs_Backtrack) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_DigitDs_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_DigitDs_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_DigitDs_OnePass) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_DigitDs_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Digits_Backtrack) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Digits_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Digits_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Digits_OnePass) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Digits_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Split_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Split_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Split_OnePass) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_Split_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_SplitHard_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_SplitHard_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Parse_SplitHard_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (PossibleMatchRange_Complex)
 
 re2::BENCHMARK (PossibleMatchRange_NoProg)
 
 re2::BENCHMARK (PossibleMatchRange_Prefix)
 
 re2::BENCHMARK (PossibleMatchRange_Trivial)
 
 re2::BENCHMARK (Search_Digits_BitState) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Search_Digits_DFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Search_Digits_NFA) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Search_Digits_OnePass) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (Search_Digits_RE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (SimplePartialMatchRE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK (SmallHTTPPartialMatchRE2) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (FindAndConsume, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (FullMatch_DotStar_CachedRE2, 8, 2<< 20)
 
 re2::BENCHMARK_RANGE (FullMatch_DotStarCapture_CachedRE2, 8, 2<< 20)
 
 re2::BENCHMARK_RANGE (FullMatch_DotStarDollar_CachedRE2, 8, 2<< 20)
 
 re2::BENCHMARK_RANGE (Search_AltMatch_BitState, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_CachedBitState, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_CachedNFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_CachedOnePass, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_DFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_NFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_OnePass, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_AltMatch_RE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_BigFixed_CachedDFA, 8, 1<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_BigFixed_CachedNFA, 8, 32<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_BigFixed_CachedRE2, 8, 1<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy0_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy0_CachedNFA, 8, 256<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy0_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy1_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy1_CachedNFA, 8, 256<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy1_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy2_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy2_CachedNFA, 8, 256<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Easy2_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Fanout_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Fanout_CachedNFA, 8, 256<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Fanout_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Hard_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Hard_CachedNFA, 8, 256<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Hard_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Medium_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Medium_CachedNFA, 8, 256<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Medium_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Parens_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Parens_CachedNFA, 8, 256<< 10) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Parens_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_BitState, 8, 2<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_CachedBitState, 8, 2<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_CachedNFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_DFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_NFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success1_RE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_CachedDFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_CachedNFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_CachedOnePass, 8, 2<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_DFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_NFA, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_OnePass, 8, 2<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (Search_Success_RE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
 re2::BENCHMARK_RANGE (SearchPhone_CachedRE2, 8, 16<< 20) -> ThreadRange(1, NumCPUs())
 
void re2::BM_CompileByteMap (benchmark::State &state)
 
void re2::BM_CompileToProg (benchmark::State &state)
 
void re2::BM_PCRE_Compile (benchmark::State &state)
 
void re2::BM_RE2_Compile (benchmark::State &state)
 
void re2::BM_Regexp_Compile (benchmark::State &state)
 
void re2::BM_Regexp_NullWalk (benchmark::State &state)
 
void re2::BM_Regexp_Parse (benchmark::State &state)
 
void re2::BM_Regexp_Simplify (benchmark::State &state)
 
void re2::BM_Regexp_SimplifyCompile (benchmark::State &state)
 
void re2::CompileByteMap (benchmark::State &state, const std::string &regexp)
 
void re2::CompilePCRE (benchmark::State &state, const std::string &regexp)
 
void re2::CompileRE2 (benchmark::State &state, const std::string &regexp)
 
void re2::CompileRegexp (benchmark::State &state, const std::string &regexp)
 
void re2::CompileToProg (benchmark::State &state, const std::string &regexp)
 
 DEFINE_FLAG (std::string, compile_regexp, "(.*)-(\\d+)-of-(\\d+)", "regexp for compile benchmarks")
 
void re2::DotMatchPCRE (benchmark::State &state)
 
void re2::DotMatchRE2 (benchmark::State &state)
 
void re2::EmptyPartialMatchPCRE (benchmark::State &state)
 
void re2::EmptyPartialMatchRE2 (benchmark::State &state)
 
void re2::FindAndConsume (benchmark::State &state)
 
void re2::FullMatch_DotStar_CachedPCRE (benchmark::State &state)
 
void re2::FullMatch_DotStar_CachedRE2 (benchmark::State &state)
 
void re2::FullMatch_DotStarCapture_CachedPCRE (benchmark::State &state)
 
void re2::FullMatch_DotStarCapture_CachedRE2 (benchmark::State &state)
 
void re2::FullMatch_DotStarDollar_CachedPCRE (benchmark::State &state)
 
void re2::FullMatch_DotStarDollar_CachedRE2 (benchmark::State &state)
 
void re2::FullMatchPCRE (benchmark::State &state, const char *regexp)
 
void re2::FullMatchRE2 (benchmark::State &state, const char *regexp)
 
PCRE * re2::GetCachedPCRE (const char *regexp)
 
Prog * re2::GetCachedProg (const char *regexp)
 
RE2 * re2::GetCachedRE2 (const char *regexp)
 
void re2::HTTPPartialMatchPCRE (benchmark::State &state)
 
void re2::HTTPPartialMatchRE2 (benchmark::State &state)
 
void re2::MemoryUsage ()
 
void re2::NullWalkRegexp (benchmark::State &state, const std::string &regexp)
 
int re2::NumCPUs ()
 
void re2::Parse1BitState (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1CachedBacktrack (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1CachedBitState (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1CachedNFA (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1CachedOnePass (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1CachedPCRE (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1CachedRE2 (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1NFA (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1OnePass (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1PCRE (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1RE2 (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse1Split (benchmark::State &state, void(*parse1)(benchmark::State &, const char *, const StringPiece &))
 
void re2::Parse1SplitBig1 (benchmark::State &state, void(*run)(benchmark::State &, const char *, const StringPiece &))
 
void re2::Parse1SplitBig2 (benchmark::State &state, void(*run)(benchmark::State &, const char *, const StringPiece &))
 
void re2::Parse1SplitHard (benchmark::State &state, void(*run)(benchmark::State &, const char *, const StringPiece &))
 
void re2::Parse3Backtrack (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3BitState (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3CachedBacktrack (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3CachedBitState (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3CachedNFA (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3CachedOnePass (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3CachedPCRE (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3CachedRE2 (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3DigitDs (benchmark::State &state, void(*parse3)(benchmark::State &, const char *, const StringPiece &))
 
void re2::Parse3Digits (benchmark::State &state, void(*parse3)(benchmark::State &, const char *, const StringPiece &))
 
void re2::Parse3NFA (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3OnePass (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3PCRE (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse3RE2 (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::Parse_CachedDigitDs_Backtrack (benchmark::State &state)
 
void re2::Parse_CachedDigitDs_BitState (benchmark::State &state)
 
void re2::Parse_CachedDigitDs_NFA (benchmark::State &state)
 
void re2::Parse_CachedDigitDs_OnePass (benchmark::State &state)
 
void re2::Parse_CachedDigitDs_PCRE (benchmark::State &state)
 
void re2::Parse_CachedDigitDs_RE2 (benchmark::State &state)
 
void re2::Parse_CachedDigits_Backtrack (benchmark::State &state)
 
void re2::Parse_CachedDigits_BitState (benchmark::State &state)
 
void re2::Parse_CachedDigits_NFA (benchmark::State &state)
 
void re2::Parse_CachedDigits_OnePass (benchmark::State &state)
 
void re2::Parse_CachedDigits_PCRE (benchmark::State &state)
 
void re2::Parse_CachedDigits_RE2 (benchmark::State &state)
 
void re2::Parse_CachedSplit_BitState (benchmark::State &state)
 
void re2::Parse_CachedSplit_NFA (benchmark::State &state)
 
void re2::Parse_CachedSplit_OnePass (benchmark::State &state)
 
void re2::Parse_CachedSplit_PCRE (benchmark::State &state)
 
void re2::Parse_CachedSplit_RE2 (benchmark::State &state)
 
void re2::Parse_CachedSplitBig1_PCRE (benchmark::State &state)
 
void re2::Parse_CachedSplitBig1_RE2 (benchmark::State &state)
 
void re2::Parse_CachedSplitBig2_PCRE (benchmark::State &state)
 
void re2::Parse_CachedSplitBig2_RE2 (benchmark::State &state)
 
void re2::Parse_CachedSplitHard_Backtrack (benchmark::State &state)
 
void re2::Parse_CachedSplitHard_BitState (benchmark::State &state)
 
void re2::Parse_CachedSplitHard_NFA (benchmark::State &state)
 
void re2::Parse_CachedSplitHard_PCRE (benchmark::State &state)
 
void re2::Parse_CachedSplitHard_RE2 (benchmark::State &state)
 
void re2::Parse_DigitDs_Backtrack (benchmark::State &state)
 
void re2::Parse_DigitDs_BitState (benchmark::State &state)
 
void re2::Parse_DigitDs_NFA (benchmark::State &state)
 
void re2::Parse_DigitDs_OnePass (benchmark::State &state)
 
void re2::Parse_DigitDs_PCRE (benchmark::State &state)
 
void re2::Parse_DigitDs_RE2 (benchmark::State &state)
 
void re2::Parse_Digits_Backtrack (benchmark::State &state)
 
void re2::Parse_Digits_BitState (benchmark::State &state)
 
void re2::Parse_Digits_NFA (benchmark::State &state)
 
void re2::Parse_Digits_OnePass (benchmark::State &state)
 
void re2::Parse_Digits_PCRE (benchmark::State &state)
 
void re2::Parse_Digits_RE2 (benchmark::State &state)
 
void re2::Parse_Split_BitState (benchmark::State &state)
 
void re2::Parse_Split_NFA (benchmark::State &state)
 
void re2::Parse_Split_OnePass (benchmark::State &state)
 
void re2::Parse_Split_PCRE (benchmark::State &state)
 
void re2::Parse_Split_RE2 (benchmark::State &state)
 
void re2::Parse_SplitHard_BitState (benchmark::State &state)
 
void re2::Parse_SplitHard_NFA (benchmark::State &state)
 
void re2::Parse_SplitHard_PCRE (benchmark::State &state)
 
void re2::Parse_SplitHard_RE2 (benchmark::State &state)
 
void re2::ParseRegexp (benchmark::State &state, const std::string &regexp)
 
void re2::PossibleMatchRange_Complex (benchmark::State &state)
 
void re2::PossibleMatchRange_NoProg (benchmark::State &state)
 
void re2::PossibleMatchRange_Prefix (benchmark::State &state)
 
void re2::PossibleMatchRange_Trivial (benchmark::State &state)
 
void re2::PossibleMatchRangeCommon (benchmark::State &state, const char *regexp)
 
std::string re2::RandomText (int64_t nbytes)
 
void re2::RunBuild (benchmark::State &state, const std::string &regexp, void(*run)(benchmark::State &, const std::string &))
 
void re2::Search (benchmark::State &state, const char *regexp, SearchImpl *search)
 
void re2::Search_AltMatch_BitState (benchmark::State &state)
 
void re2::Search_AltMatch_CachedBitState (benchmark::State &state)
 
void re2::Search_AltMatch_CachedDFA (benchmark::State &state)
 
void re2::Search_AltMatch_CachedNFA (benchmark::State &state)
 
void re2::Search_AltMatch_CachedOnePass (benchmark::State &state)
 
void re2::Search_AltMatch_CachedPCRE (benchmark::State &state)
 
void re2::Search_AltMatch_CachedRE2 (benchmark::State &state)
 
void re2::Search_AltMatch_DFA (benchmark::State &state)
 
void re2::Search_AltMatch_NFA (benchmark::State &state)
 
void re2::Search_AltMatch_OnePass (benchmark::State &state)
 
void re2::Search_AltMatch_PCRE (benchmark::State &state)
 
void re2::Search_AltMatch_RE2 (benchmark::State &state)
 
void re2::Search_BigFixed_CachedDFA (benchmark::State &state)
 
void re2::Search_BigFixed_CachedNFA (benchmark::State &state)
 
void re2::Search_BigFixed_CachedPCRE (benchmark::State &state)
 
void re2::Search_BigFixed_CachedRE2 (benchmark::State &state)
 
void re2::Search_Digits_BitState (benchmark::State &state)
 
void re2::Search_Digits_DFA (benchmark::State &state)
 
void re2::Search_Digits_NFA (benchmark::State &state)
 
void re2::Search_Digits_OnePass (benchmark::State &state)
 
void re2::Search_Digits_PCRE (benchmark::State &state)
 
void re2::Search_Digits_RE2 (benchmark::State &state)
 
void re2::Search_Easy0_CachedDFA (benchmark::State &state)
 
void re2::Search_Easy0_CachedNFA (benchmark::State &state)
 
void re2::Search_Easy0_CachedPCRE (benchmark::State &state)
 
void re2::Search_Easy0_CachedRE2 (benchmark::State &state)
 
void re2::Search_Easy1_CachedDFA (benchmark::State &state)
 
void re2::Search_Easy1_CachedNFA (benchmark::State &state)
 
void re2::Search_Easy1_CachedPCRE (benchmark::State &state)
 
void re2::Search_Easy1_CachedRE2 (benchmark::State &state)
 
void re2::Search_Easy2_CachedDFA (benchmark::State &state)
 
void re2::Search_Easy2_CachedNFA (benchmark::State &state)
 
void re2::Search_Easy2_CachedPCRE (benchmark::State &state)
 
void re2::Search_Easy2_CachedRE2 (benchmark::State &state)
 
void re2::Search_Fanout_CachedDFA (benchmark::State &state)
 
void re2::Search_Fanout_CachedNFA (benchmark::State &state)
 
void re2::Search_Fanout_CachedPCRE (benchmark::State &state)
 
void re2::Search_Fanout_CachedRE2 (benchmark::State &state)
 
void re2::Search_Hard_CachedDFA (benchmark::State &state)
 
void re2::Search_Hard_CachedNFA (benchmark::State &state)
 
void re2::Search_Hard_CachedPCRE (benchmark::State &state)
 
void re2::Search_Hard_CachedRE2 (benchmark::State &state)
 
void re2::Search_Medium_CachedDFA (benchmark::State &state)
 
void re2::Search_Medium_CachedNFA (benchmark::State &state)
 
void re2::Search_Medium_CachedPCRE (benchmark::State &state)
 
void re2::Search_Medium_CachedRE2 (benchmark::State &state)
 
void re2::Search_Parens_CachedDFA (benchmark::State &state)
 
void re2::Search_Parens_CachedNFA (benchmark::State &state)
 
void re2::Search_Parens_CachedPCRE (benchmark::State &state)
 
void re2::Search_Parens_CachedRE2 (benchmark::State &state)
 
void re2::Search_Success1_BitState (benchmark::State &state)
 
void re2::Search_Success1_CachedBitState (benchmark::State &state)
 
void re2::Search_Success1_CachedDFA (benchmark::State &state)
 
void re2::Search_Success1_CachedNFA (benchmark::State &state)
 
void re2::Search_Success1_CachedPCRE (benchmark::State &state)
 
void re2::Search_Success1_CachedRE2 (benchmark::State &state)
 
void re2::Search_Success1_DFA (benchmark::State &state)
 
void re2::Search_Success1_NFA (benchmark::State &state)
 
void re2::Search_Success1_PCRE (benchmark::State &state)
 
void re2::Search_Success1_RE2 (benchmark::State &state)
 
void re2::Search_Success_CachedDFA (benchmark::State &state)
 
void re2::Search_Success_CachedNFA (benchmark::State &state)
 
void re2::Search_Success_CachedOnePass (benchmark::State &state)
 
void re2::Search_Success_CachedPCRE (benchmark::State &state)
 
void re2::Search_Success_CachedRE2 (benchmark::State &state)
 
void re2::Search_Success_DFA (benchmark::State &state)
 
void re2::Search_Success_NFA (benchmark::State &state)
 
void re2::Search_Success_OnePass (benchmark::State &state)
 
void re2::Search_Success_PCRE (benchmark::State &state)
 
void re2::Search_Success_RE2 (benchmark::State &state)
 
void re2::SearchAltMatch (benchmark::State &state, SearchImpl *search)
 
void re2::SearchBigFixed (benchmark::State &state, SearchImpl *search)
 
void re2::SearchBitState (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchCachedBitState (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchCachedDFA (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchCachedNFA (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchCachedOnePass (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchCachedPCRE (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchCachedRE2 (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchDFA (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchDigits (benchmark::State &state, SearchImpl *search)
 
void re2::SearchNFA (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchOnePass (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchParse1CachedPCRE (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::SearchParse1CachedRE2 (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::SearchParse2CachedPCRE (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::SearchParse2CachedRE2 (benchmark::State &state, const char *regexp, const StringPiece &text)
 
void re2::SearchPCRE (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchPhone (benchmark::State &state, ParseImpl *search)
 
void re2::SearchPhone_CachedPCRE (benchmark::State &state)
 
void re2::SearchPhone_CachedRE2 (benchmark::State &state)
 
void re2::SearchRE2 (benchmark::State &state, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 
void re2::SearchSuccess (benchmark::State &state, const char *regexp, SearchImpl *search)
 
void re2::SimplePartialMatchPCRE (benchmark::State &state)
 
void re2::SimplePartialMatchRE2 (benchmark::State &state)
 
void re2::SimplifyCompileRegexp (benchmark::State &state, const std::string &regexp)
 
void re2::SimplifyRegexp (benchmark::State &state, const std::string &regexp)
 
void re2::SmallHTTPPartialMatchPCRE (benchmark::State &state)
 
void re2::SmallHTTPPartialMatchRE2 (benchmark::State &state)
 
void re2::Test ()
 

Variables

static std::string re2::http_text
 
static std::string re2::smallhttp_text
 

Macro Definition Documentation

◆ EASY0

#define EASY0   "ABCDEFGHIJKLMNOPQRSTUVWXYZ$"

Definition at line 186 of file re2/re2/testing/regexp_benchmark.cc.

◆ EASY1

#define EASY1   "A[AB]B[BC]C[CD]D[DE]E[EF]F[FG]G[GH]H[HI]I[IJ]J$"

Definition at line 187 of file re2/re2/testing/regexp_benchmark.cc.

◆ EASY2

#define EASY2   "(?i)" EASY0

Definition at line 188 of file re2/re2/testing/regexp_benchmark.cc.

◆ FANOUT

#define FANOUT   "(?:[\\x{80}-\\x{10FFFF}]?){100}[\\x{80}-\\x{10FFFF}]"

Definition at line 202 of file re2/re2/testing/regexp_benchmark.cc.

◆ HARD

#define HARD   "[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ$"

Definition at line 198 of file re2/re2/testing/regexp_benchmark.cc.

◆ MEDIUM

#define MEDIUM   "[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$"

Definition at line 193 of file re2/re2/testing/regexp_benchmark.cc.

◆ PARENS

#define PARENS
Value:
"([ -~])*(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)$"

Definition at line 205 of file re2/re2/testing/regexp_benchmark.cc.

Typedef Documentation

◆ MallocCounter

typedef testing::MallocCounter MallocCounter

Definition at line 32 of file re2/re2/testing/regexp_benchmark.cc.

Function Documentation

◆ DEFINE_FLAG()

DEFINE_FLAG ( std::string  ,
compile_regexp  ,
"(.*)-(\\d+)-of-(\\d+)"  ,
"regexp for compile benchmarks"   
)

grpc
Author(s):
autogenerated on Fri May 16 2025 03:01:28