Namespaces | Macros | Typedefs | Functions | Variables
bloaty/third_party/re2/re2/testing/regexp_benchmark.cc File Reference
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include "util/test.h"
#include "util/logging.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"
Include dependency graph for bloaty/third_party/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 FANOUT   "(?:[\\x{80}-\\x{10FFFF}]?){100}[\\x{80}-\\x{10FFFF}]"
 
#define HARD   "[ -~]*ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
 
#define MEDIUM   "[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$"
 
#define PARENS
 

Typedefs

typedef testing::MallocCounter MallocCounter
 
typedef void re2::ParseImpl(int iters, const char *regexp, const StringPiece &text)
 
typedef void re2::SearchImpl(int iters, const char *regexp, const StringPiece &text, Prog::Anchor anchor, bool expect_match)
 

Functions

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

Variables

static std::string re2::http_text
 
ParseImpl re2::Parse1Backtrack
 
ParseImpl re2::Parse1BitState
 
ParseImpl re2::Parse1CachedBacktrack
 
ParseImpl re2::Parse1CachedBitState
 
ParseImpl re2::Parse1CachedNFA
 
ParseImpl re2::Parse1CachedOnePass
 
ParseImpl re2::Parse1CachedPCRE
 
ParseImpl re2::Parse1CachedRE2
 
ParseImpl re2::Parse1NFA
 
ParseImpl re2::Parse1OnePass
 
ParseImpl re2::Parse1PCRE
 
ParseImpl re2::Parse1RE2
 
ParseImpl re2::Parse3Backtrack
 
ParseImpl re2::Parse3BitState
 
ParseImpl re2::Parse3CachedBacktrack
 
ParseImpl re2::Parse3CachedBitState
 
ParseImpl re2::Parse3CachedNFA
 
ParseImpl re2::Parse3CachedOnePass
 
ParseImpl re2::Parse3CachedPCRE
 
ParseImpl re2::Parse3CachedRE2
 
ParseImpl re2::Parse3NFA
 
ParseImpl re2::Parse3OnePass
 
ParseImpl re2::Parse3PCRE
 
ParseImpl re2::Parse3RE2
 
SearchImpl re2::SearchBitState
 
SearchImpl re2::SearchCachedBitState
 
SearchImpl re2::SearchCachedDFA
 
SearchImpl re2::SearchCachedNFA
 
SearchImpl re2::SearchCachedOnePass
 
SearchImpl re2::SearchCachedPCRE
 
SearchImpl re2::SearchCachedRE2
 
SearchImpl re2::SearchDFA
 
SearchImpl re2::SearchNFA
 
SearchImpl re2::SearchOnePass
 
ParseImpl re2::SearchParse1CachedPCRE
 
ParseImpl re2::SearchParse1CachedRE2
 
ParseImpl re2::SearchParse2CachedPCRE
 
ParseImpl re2::SearchParse2CachedRE2
 
SearchImpl re2::SearchPCRE
 
SearchImpl re2::SearchRE2
 
static std::string re2::smallhttp_text
 

Macro Definition Documentation

◆ EASY0

#define EASY0   "ABCDEFGHIJKLMNOPQRSTUVWXYZ$"

Definition at line 171 of file bloaty/third_party/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 172 of file bloaty/third_party/re2/re2/testing/regexp_benchmark.cc.

◆ FANOUT

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

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

◆ HARD

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

Definition at line 182 of file bloaty/third_party/re2/re2/testing/regexp_benchmark.cc.

◆ MEDIUM

#define MEDIUM   "[XYZ]ABCDEFGHIJKLMNOPQRSTUVWXYZ$"

Definition at line 177 of file bloaty/third_party/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 189 of file bloaty/third_party/re2/re2/testing/regexp_benchmark.cc.

Typedef Documentation

◆ MallocCounter

typedef testing::MallocCounter MallocCounter

Definition at line 27 of file bloaty/third_party/re2/re2/testing/regexp_benchmark.cc.

Function Documentation

◆ DEFINE_string()

DEFINE_string ( compile_regexp  ,
"(.*)-(\\d+)-of-(\\d+)"  ,
"regexp for compile benchmarks"   
)

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