SYMBOL INDEX (893 symbols across 115 files)

FILE: .ycm_extra_conf.py
  function DirectoryOfThisScript (line 47) | def DirectoryOfThisScript():
  function MakeRelativePathsInFlagsAbsolute (line 51) | def MakeRelativePathsInFlagsAbsolute(flags, working_directory):
  function IsHeaderFile (line 80) | def IsHeaderFile(filename):
  function GetCompilationInfoForFile (line 85) | def GetCompilationInfoForFile(filename):
  function FlagsForFile (line 104) | def FlagsForFile(filename, **kwargs):

FILE: bindings/python/google_benchmark/__init__.py
  class __OptionMaker (line 54) | class __OptionMaker:
    class Options (line 60) | class Options:
      method __init__ (line 64) | def __init__(self, func):
    method make (line 69) | def make(cls, func_or_options):
    method __getattr__ (line 75) | def __getattr__(self, builder_name):
  function register (line 100) | def register(undefined=None, *, name=None):
  function main (line 123) | def main(argv: list[str] | None = None) -> None:

FILE: bindings/python/google_benchmark/benchmark.cc
  function Initialize (line 16) | std::vector<std::string> Initialize(const std::vector<std::string>& argv) {
  function NB_MODULE (line 45) | NB_MODULE(_benchmark, m) {

FILE: bindings/python/google_benchmark/example.py
  function empty (line 33) | def empty(state):
  function sum_million (line 39) | def sum_million(state):
  function pause_timing (line 45) | def pause_timing(state):
  function skipped (line 57) | def skipped(state):
  function manual_timing (line 67) | def manual_timing(state):
  function custom_counters (line 78) | def custom_counters(state):
  function with_options (line 103) | def with_options(state):
  function with_options2 (line 110) | def with_options2(state):
  function passing_argument (line 118) | def passing_argument(state):
  function using_range (line 125) | def using_range(state):
  function computing_complexity (line 134) | def computing_complexity(state):

FILE: cmake/gnu_posix_regex.cpp
  function main (line 3) | int main() {

FILE: cmake/posix_regex.cpp
  function main (line 3) | int main() {

FILE: cmake/pthread_affinity.cpp
  function main (line 5) | int main() {

FILE: cmake/std_regex.cpp
  function main (line 3) | int main() {

FILE: cmake/steady_clock.cpp
  function main (line 3) | int main() {

FILE: cmake/thread_safety_attributes.cpp
  function main (line 4) | int main() {}

FILE: include/benchmark/benchmark_api.h
  function namespace (line 35) | namespace benchmark {
  function class (line 263) | class Fixture : public Benchmark {

FILE: include/benchmark/counter.h
  function namespace (line 29) | namespace benchmark {
  function namespace (line 67) | namespace internal {

FILE: include/benchmark/managers.h
  function class (line 27) | class MemoryManager {

FILE: include/benchmark/reporter.h
  function BenchmarkName (line 39) | struct BENCHMARK_EXPORT BenchmarkName {
  type Context (line 54) | struct Context {
  function Run (line 62) | struct BENCHMARK_EXPORT Run {

FILE: include/benchmark/state.h
  function namespace (line 32) | namespace benchmark {
  function BENCHMARK_ALWAYS_INLINE (line 123) | BENCHMARK_ALWAYS_INLINE
  function StateIterator (line 211) | struct State::StateIterator {

FILE: include/benchmark/statistics.h
  type BigO (line 25) | enum BigO { oNone, o1, oN, oNSquared, oNCubed, oLogN, oNLogN, oAuto, oLa...
  type ComplexityN (line 27) | typedef int64_t ComplexityN;
  type StatisticUnit (line 29) | enum StatisticUnit { kTime, kPercentage }
  function namespace (line 35) | namespace internal {

FILE: include/benchmark/sysinfo.h
  function CPUInfo (line 30) | struct BENCHMARK_EXPORT CPUInfo {
  function SystemInfo (line 53) | struct BENCHMARK_EXPORT SystemInfo {

FILE: include/benchmark/types.h
  function namespace (line 26) | namespace benchmark {

FILE: include/benchmark/utils.h
  function namespace (line 24) | namespace benchmark {

FILE: setup.py
  function is_cibuildwheel (line 24) | def is_cibuildwheel() -> bool:
  function _maybe_patch_toolchains (line 29) | def _maybe_patch_toolchains() -> Generator[None, None, None]:
  class BazelExtension (line 64) | class BazelExtension(setuptools.Extension):
    method __init__ (line 67) | def __init__(self, name: str, bazel_target: str, **kwargs: Any):
  class BuildBazelExtension (line 75) | class BuildBazelExtension(build_ext.build_ext):
    method run (line 78) | def run(self):
    method copy_extensions_to_source (line 84) | def copy_extensions_to_source(self):
    method bazel_build (line 91) | def bazel_build(self, ext: BazelExtension) -> None:  # noqa: C901

FILE: src/arraysize.h
  function namespace (line 6) | namespace benchmark {

FILE: src/benchmark.cc
  type benchmark (line 66) | namespace benchmark {
    type internal (line 159) | namespace internal {
      function BENCHMARK_EXPORT (line 164) | BENCHMARK_EXPORT std::map<std::string, std::string>*& GetGlobalConte...
      function UseCharPointer (line 174) | void UseCharPointer(char const volatile* const v) {
      function FlushStreams (line 355) | void FlushStreams(BenchmarkReporter* reporter) {
      function Report (line 364) | void Report(BenchmarkReporter* display_reporter,
      function RunBenchmarks (line 390) | void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
      function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 529) | BENCHMARK_DISABLE_DEPRECATED_WARNING
      function IsZero (line 552) | bool IsZero(double n) {
      function GetOutputOptions (line 556) | ConsoleReporter::OutputOptions GetOutputOptions(bool force_no_color) {
      function PrintUsageAndExit (line 731) | void PrintUsageAndExit() {
      function SetDefaultTimeUnitFromFlag (line 738) | void SetDefaultTimeUnitFromFlag(const std::string& time_unit_flag) {
      function ParseCommandLineFlags (line 756) | void ParseCommandLineFlags(int* argc, char** argv) {
      function InitializeStreams (line 821) | int InitializeStreams() {
      function get_as_unsigned (line 827) | std::make_unsigned_t<T> get_as_unsigned(T v) {
    type internal (line 350) | namespace internal {
      function BENCHMARK_EXPORT (line 164) | BENCHMARK_EXPORT std::map<std::string, std::string>*& GetGlobalConte...
      function UseCharPointer (line 174) | void UseCharPointer(char const volatile* const v) {
      function FlushStreams (line 355) | void FlushStreams(BenchmarkReporter* reporter) {
      function Report (line 364) | void Report(BenchmarkReporter* display_reporter,
      function RunBenchmarks (line 390) | void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
      function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 529) | BENCHMARK_DISABLE_DEPRECATED_WARNING
      function IsZero (line 552) | bool IsZero(double n) {
      function GetOutputOptions (line 556) | ConsoleReporter::OutputOptions GetOutputOptions(bool force_no_color) {
      function PrintUsageAndExit (line 731) | void PrintUsageAndExit() {
      function SetDefaultTimeUnitFromFlag (line 738) | void SetDefaultTimeUnitFromFlag(const std::string& time_unit_flag) {
      function ParseCommandLineFlags (line 756) | void ParseCommandLineFlags(int* argc, char** argv) {
      function InitializeStreams (line 821) | int InitializeStreams() {
      function get_as_unsigned (line 827) | std::make_unsigned_t<T> get_as_unsigned(T v) {
    function BenchmarkReporter (line 582) | BenchmarkReporter* CreateDefaultDisplayReporter() {
    function RunSpecifiedBenchmarks (line 590) | size_t RunSpecifiedBenchmarks() {
    function RunSpecifiedBenchmarks (line 594) | size_t RunSpecifiedBenchmarks(std::string spec) {
    function RunSpecifiedBenchmarks (line 598) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter) {
    function RunSpecifiedBenchmarks (line 603) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter,
    function RunSpecifiedBenchmarks (line 608) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter,
    function RunSpecifiedBenchmarks (line 614) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter,
    function TimeUnit (line 691) | TimeUnit GetDefaultTimeUnit() { return default_time_unit; }
    function SetDefaultTimeUnit (line 693) | void SetDefaultTimeUnit(TimeUnit unit) { default_time_unit = unit; }
    function GetBenchmarkFilter (line 695) | std::string GetBenchmarkFilter() { return FLAGS_benchmark_filter; }
    function SetBenchmarkFilter (line 697) | void SetBenchmarkFilter(std::string value) {
    function GetBenchmarkVerbosity (line 701) | int32_t GetBenchmarkVerbosity() { return FLAGS_v; }
    function RegisterMemoryManager (line 703) | void RegisterMemoryManager(MemoryManager* manager) {
    function RegisterProfilerManager (line 707) | void RegisterProfilerManager(ProfilerManager* manager) {
    function AddCustomContext (line 715) | void AddCustomContext(std::string key, std::string value) {
    type internal (line 726) | namespace internal {
      function BENCHMARK_EXPORT (line 164) | BENCHMARK_EXPORT std::map<std::string, std::string>*& GetGlobalConte...
      function UseCharPointer (line 174) | void UseCharPointer(char const volatile* const v) {
      function FlushStreams (line 355) | void FlushStreams(BenchmarkReporter* reporter) {
      function Report (line 364) | void Report(BenchmarkReporter* display_reporter,
      function RunBenchmarks (line 390) | void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
      function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 529) | BENCHMARK_DISABLE_DEPRECATED_WARNING
      function IsZero (line 552) | bool IsZero(double n) {
      function GetOutputOptions (line 556) | ConsoleReporter::OutputOptions GetOutputOptions(bool force_no_color) {
      function PrintUsageAndExit (line 731) | void PrintUsageAndExit() {
      function SetDefaultTimeUnitFromFlag (line 738) | void SetDefaultTimeUnitFromFlag(const std::string& time_unit_flag) {
      function ParseCommandLineFlags (line 756) | void ParseCommandLineFlags(int* argc, char** argv) {
      function InitializeStreams (line 821) | int InitializeStreams() {
      function get_as_unsigned (line 827) | std::make_unsigned_t<T> get_as_unsigned(T v) {
    function MaybeReenterWithoutASLR (line 834) | void MaybeReenterWithoutASLR(int /*argc*/, char** argv) {
    function GetBenchmarkVersion (line 871) | std::string GetBenchmarkVersion() {
    function PrintDefaultHelp (line 879) | void PrintDefaultHelp() {
    function Initialize (line 904) | void Initialize(int* argc, char** argv, void (*HelperPrintf)()) {
    function Shutdown (line 910) | void Shutdown() { delete internal::global_context; }
    function ReportUnrecognizedArguments (line 912) | bool ReportUnrecognizedArguments(int argc, char** argv) {

FILE: src/benchmark_api_internal.cc
  type benchmark (line 7) | namespace benchmark {
    type internal (line 8) | namespace internal {
      function State (line 92) | State BenchmarkInstance::Run(

FILE: src/benchmark_api_internal.h
  function namespace (line 17) | namespace internal {

FILE: src/benchmark_name.cc
  type benchmark (line 18) | namespace benchmark {
    function size_impl (line 23) | size_t size_impl() { return 0; }
    function size_impl (line 26) | size_t size_impl(const Head& head, const Tail&... tail) {
    function join_impl (line 32) | void join_impl(std::string& /*unused*/, char /*unused*/) {}
    function join_impl (line 35) | void join_impl(std::string& s, const char delimiter, const Head& head,
    function join (line 47) | std::string join(char delimiter, const Ts&... ts) {
    function BENCHMARK_EXPORT (line 55) | BENCHMARK_EXPORT

FILE: src/benchmark_register.cc
  type benchmark (line 57) | namespace benchmark {
    type internal (line 70) | namespace internal {
      class BenchmarkFamilies (line 78) | class BenchmarkFamilies {
        method BenchmarkFamilies (line 95) | BenchmarkFamilies() {}
      function BenchmarkFamilies (line 101) | BenchmarkFamilies* BenchmarkFamilies::GetInstance() {
        method BenchmarkFamilies (line 95) | BenchmarkFamilies() {}
      function FindBenchmarksInternal (line 210) | bool FindBenchmarksInternal(const std::string& re,
    function Benchmark (line 245) | Benchmark* Benchmark::Name(const std::string& name) {
    function Benchmark (line 250) | Benchmark* Benchmark::Arg(int64_t x) {
    function Benchmark (line 256) | Benchmark* Benchmark::Unit(TimeUnit unit) {
    function Benchmark (line 262) | Benchmark* Benchmark::Range(int64_t start, int64_t limit) {
    function Benchmark (line 273) | Benchmark* Benchmark::Ranges(
    function Benchmark (line 287) | Benchmark* Benchmark::ArgsProduct(
    function Benchmark (line 315) | Benchmark* Benchmark::ArgName(const std::string& name) {
    function Benchmark (line 321) | Benchmark* Benchmark::ArgNames(const std::vector<std::string>& names) {
    function Benchmark (line 327) | Benchmark* Benchmark::DenseRange(int64_t start, int64_t limit, int ste...
    function Benchmark (line 336) | Benchmark* Benchmark::Args(const std::vector<int64_t>& args) {
    function Benchmark (line 342) | Benchmark* Benchmark::Apply(
    function Benchmark (line 348) | Benchmark* Benchmark::Setup(callback_function&& setup) {
    function Benchmark (line 354) | Benchmark* Benchmark::Setup(const callback_function& setup) {
    function Benchmark (line 360) | Benchmark* Benchmark::Teardown(callback_function&& teardown) {
    function Benchmark (line 366) | Benchmark* Benchmark::Teardown(const callback_function& teardown) {
    function Benchmark (line 372) | Benchmark* Benchmark::RangeMultiplier(int multiplier) {
    function Benchmark (line 378) | Benchmark* Benchmark::MinTime(double t) {
    function Benchmark (line 385) | Benchmark* Benchmark::MinWarmUpTime(double t) {
    function Benchmark (line 392) | Benchmark* Benchmark::Iterations(IterationCount n) {
    function Benchmark (line 400) | Benchmark* Benchmark::Repetitions(int n) {
    function Benchmark (line 406) | Benchmark* Benchmark::ReportAggregatesOnly(bool value) {
    function Benchmark (line 412) | Benchmark* Benchmark::DisplayAggregatesOnly(bool value) {
    function Benchmark (line 429) | Benchmark* Benchmark::MeasureProcessCPUTime() {
    function Benchmark (line 435) | Benchmark* Benchmark::UseRealTime() {
    function Benchmark (line 442) | Benchmark* Benchmark::UseManualTime() {
    function Benchmark (line 449) | Benchmark* Benchmark::Complexity(BigO complexity) {
    function Benchmark (line 454) | Benchmark* Benchmark::Complexity(BigOFunc* complexity) {
    function Benchmark (line 460) | Benchmark* Benchmark::ComputeStatistics(const std::string& name,
    function Benchmark (line 467) | Benchmark* Benchmark::Threads(int t) {
    function Benchmark (line 473) | Benchmark* Benchmark::ThreadRange(int min_threads, int max_threads) {
    function Benchmark (line 481) | Benchmark* Benchmark::DenseThreadRange(int min_threads, int max_threads,
    function Benchmark (line 494) | Benchmark* Benchmark::ThreadPerCpu() {
    function Benchmark (line 499) | Benchmark* Benchmark::ThreadRunner(threadrunner_factory&& factory) {
    function TimeUnit (line 525) | TimeUnit Benchmark::GetTimeUnit() const {
    type internal (line 529) | namespace internal {
      class BenchmarkFamilies (line 78) | class BenchmarkFamilies {
        method BenchmarkFamilies (line 95) | BenchmarkFamilies() {}
      function BenchmarkFamilies (line 101) | BenchmarkFamilies* BenchmarkFamilies::GetInstance() {
        method BenchmarkFamilies (line 95) | BenchmarkFamilies() {}
      function FindBenchmarksInternal (line 210) | bool FindBenchmarksInternal(const std::string& re,
    function ClearRegisteredBenchmarks (line 539) | void ClearRegisteredBenchmarks() {
    function CreateRange (line 543) | std::vector<int64_t> CreateRange(int64_t lo, int64_t hi, int multi) {
    function CreateDenseRange (line 549) | std::vector<int64_t> CreateDenseRange(int64_t start, int64_t limit, in...

FILE: src/benchmark_register.h
  function namespace (line 11) | namespace benchmark {

FILE: src/benchmark_runner.cc
  type benchmark (line 64) | namespace benchmark {
    type internal (line 74) | namespace internal {
      function CreateRunReport (line 86) | BenchmarkReporter::Run CreateRunReport(
      function RunInThread (line 144) | void RunInThread(const BenchmarkInstance* b, IterationCount iters,
      function ComputeMinTime (line 173) | double ComputeMinTime(const benchmark::internal::BenchmarkInstance& b,
      function IterationCount (line 187) | IterationCount ComputeIters(const benchmark::internal::BenchmarkInst...
      class ThreadRunnerDefault (line 199) | class ThreadRunnerDefault : public ThreadRunnerBase {
        method ThreadRunnerDefault (line 201) | explicit ThreadRunnerDefault(int num_threads)
        method RunThreads (line 204) | void RunThreads(const std::function<void(int)>& fn) override final {
      function GetThreadRunner (line 224) | std::unique_ptr<ThreadRunnerBase> GetThreadRunner(
      function BenchTimeType (line 234) | BenchTimeType ParseBenchMinTime(const std::string& value) {
      function IterationCount (line 373) | IterationCount BenchmarkRunner::PredictNumItersNeeded(
      function RunResults (line 573) | RunResults&& BenchmarkRunner::GetResults() {

FILE: src/benchmark_runner.h
  function namespace (line 26) | namespace benchmark {

FILE: src/check.cc
  type benchmark (line 3) | namespace benchmark {
    type internal (line 4) | namespace internal {
      function BENCHMARK_EXPORT (line 11) | BENCHMARK_EXPORT AbortHandlerT*& GetAbortHandler() { return handler; }

FILE: src/check.h
  function namespace (line 30) | namespace benchmark {

FILE: src/colorprint.cc
  type benchmark (line 34) | namespace benchmark {
    function PlatformColorCode (line 42) | PlatformColorCode GetPlatformColorCode(LogColor color) {
    function FormatString (line 85) | std::string FormatString(const char* msg, va_list args) {
    function FormatString (line 116) | std::string FormatString(const char* msg, ...) {
    function ColorPrintf (line 124) | void ColorPrintf(std::ostream& out, LogColor color, const char* fmt, ....
    function ColorPrintf (line 131) | void ColorPrintf(std::ostream& out, LogColor color, const char* fmt,
    function IsColorTerminal (line 169) | bool IsColorTerminal() {

FILE: src/colorprint.h
  function namespace (line 10) | namespace benchmark {

FILE: src/commandlineflags.cc
  type benchmark (line 28) | namespace benchmark {
    function ParseInt32 (line 34) | bool ParseInt32(const std::string& src_text, const char* str, int32_t*...
    function ParseDouble (line 68) | bool ParseDouble(const std::string& src_text, const char* str, double*...
    function ParseKvPairs (line 87) | bool ParseKvPairs(const std::string& src_text, const char* str,
    function FlagToEnvVar (line 112) | std::string FlagToEnvVar(const char* flag) {
    function BENCHMARK_EXPORT (line 125) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 132) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 145) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 158) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 165) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 224) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 239) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 254) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 269) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 283) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 303) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 308) | BENCHMARK_EXPORT

FILE: src/commandlineflags.h
  function namespace (line 41) | namespace benchmark {

FILE: src/complexity.cc
  type benchmark (line 27) | namespace benchmark {
    function BigOFunc (line 32) | BigOFunc* FittingCurve(BigO complexity) {
    function GetBigOString (line 57) | std::string GetBigOString(BigO complexity) {
    function LeastSq (line 88) | LeastSq MinimalLeastSq(const std::vector<ComplexityN>& n,
    function LeastSq (line 130) | LeastSq MinimalLeastSq(const std::vector<ComplexityN>& n,
    function ComputeBigO (line 164) | std::vector<BenchmarkReporter::Run> ComputeBigO(

FILE: src/console_reporter.cc
  type benchmark (line 36) | namespace benchmark {
    function BENCHMARK_EXPORT (line 38) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 62) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 80) | BENCHMARK_EXPORT
    function IgnoreColorPrint (line 103) | static void IgnoreColorPrint(std::ostream& out, LogColor /*unused*/,
    function FormatTime (line 111) | static std::string FormatTime(double time) {
    function BENCHMARK_EXPORT (line 133) | BENCHMARK_EXPORT

FILE: src/counter.cc
  type benchmark (line 17) | namespace benchmark {
    type internal (line 18) | namespace internal {
      function Finish (line 22) | double Finish(Counter const& c, IterationCount iterations, double cp...
      function Finish (line 46) | void Finish(UserCounters* l, IterationCount iterations, double cpu_t...
      function Increment (line 53) | void Increment(UserCounters* l, UserCounters const& r) {
      function SameNames (line 70) | bool SameNames(UserCounters const& l, UserCounters const& r) {

FILE: src/counter.h
  function namespace (line 22) | namespace benchmark {

FILE: src/csv_reporter.cc
  type benchmark (line 26) | namespace benchmark {
    function CsvEscape (line 34) | std::string CsvEscape(const std::string& s) {
    function BENCHMARK_EXPORT (line 51) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 57) | BENCHMARK_EXPORT
    function BENCHMARK_EXPORT (line 110) | BENCHMARK_EXPORT

FILE: src/cycleclock.h
  function namespace (line 57) | namespace benchmark {

FILE: src/json_reporter.cc
  type benchmark (line 33) | namespace benchmark {
    function StrEscape (line 36) | std::string StrEscape(const std::string& s) {
    function FormatKV (line 70) | std::string FormatKV(std::string const& key, std::string const& value) {
    function FormatKV (line 75) | std::string FormatKV(std::string const& key, const char* value) {
    function FormatKV (line 80) | std::string FormatKV(std::string const& key, bool value) {
    function FormatKV (line 85) | std::string FormatKV(std::string const& key, int64_t value) {
    function FormatKV (line 93) | std::string FormatKV(std::string const& key, int value) {
    function FormatKV (line 97) | std::string FormatKV(std::string const& key, double value) {
    function RoundDouble (line 115) | int64_t RoundDouble(double v) { return std::lround(v); }

FILE: src/log.h
  function namespace (line 7) | namespace benchmark {

FILE: src/mutex.h
  function namespace (line 67) | namespace benchmark {

FILE: src/perf_counters.cc
  type benchmark (line 32) | namespace benchmark {
    type internal (line 33) | namespace internal {
      function QueryCPUPMUTypes (line 88) | static std::optional<std::vector<uint64_t>> QueryCPUPMUTypes() {
      function GetPMUTypesForEvent (line 127) | static std::vector<uint64_t> GetPMUTypesForEvent(const perf_event_at...
      function PerfCounters (line 137) | PerfCounters PerfCounters::Create(
      function PerfCounters (line 313) | PerfCounters PerfCounters::Create(
      function PerfCounters (line 330) | PerfCounters& PerfCounters::operator=(PerfCounters&& other) noexcept {

FILE: src/perf_counters.h
  function namespace (line 42) | namespace benchmark {

FILE: src/re.h
  function class (line 63) | class Regex {
  function Init (line 92) | inline bool Regex::Init(const std::string& spec, std::string* error) {

FILE: src/reporter.cc
  type benchmark (line 30) | namespace benchmark {

FILE: src/statistics.cc
  type benchmark (line 29) | namespace benchmark {
    function StatisticsMean (line 35) | double StatisticsMean(const std::vector<double>& v) {
    function StatisticsMedian (line 42) | double StatisticsMedian(const std::vector<double>& v) {
    function StatisticsStdDev (line 77) | double StatisticsStdDev(const std::vector<double>& v) {
    function StatisticsCV (line 95) | double StatisticsCV(const std::vector<double>& v) {
    function ComputeStats (line 110) | std::vector<BenchmarkReporter::Run> ComputeStats(

FILE: src/statistics.h
  function namespace (line 24) | namespace benchmark {

FILE: src/string_util.cc
  type benchmark (line 16) | namespace benchmark {
    function ToExponentAndMantissa (line 34) | std::pair<std::string, int64_t> ToExponentAndMantissa(double val, int ...
    function ExponentToPrefix (line 95) | std::string ExponentToPrefix(int64_t exponent, bool iec) {
    function ToBinaryStringFullySpecified (line 111) | std::string ToBinaryStringFullySpecified(double value, int precision,
    function StrFormatImp (line 119) | std::string StrFormatImp(const char* msg, va_list args) {
    function HumanReadableNumber (line 157) | std::string HumanReadableNumber(double n, Counter::OneK one_k) {
    function StrFormat (line 161) | std::string StrFormat(const char* format, ...) {
    function StrSplit (line 169) | std::vector<std::string> StrSplit(const std::string& str, char delim) {
    function stoul (line 191) | unsigned long stoul(const std::string& str, size_t* pos, int base) {
    function stoi (line 217) | int stoi(const std::string& str, size_t* pos, int base) {
    function stod (line 243) | double stod(const std::string& str, size_t* pos) {

FILE: src/string_util.h
  function namespace (line 13) | namespace benchmark {

FILE: src/sysinfo.cc
  type benchmark (line 93) | namespace benchmark {
    function PrintImp (line 96) | void PrintImp(std::ostream& out) { out << '\n'; }
    function PrintImp (line 99) | void PrintImp(std::ostream& out, First&& f, Rest&&... rest) {
    function BENCHMARK_NORETURN (line 105) | BENCHMARK_NORETURN void PrintErrorAndDie(Args&&... args) {
    type ValueUnion (line 115) | struct ValueUnion {
      method ValueUnion (line 129) | ValueUnion() : size(0), buff(nullptr, &std::free) {}
      method ValueUnion (line 131) | explicit ValueUnion(std::size_t buff_size)
      method ValueUnion (line 135) | ValueUnion(ValueUnion&& other) = default;
      method GetAsString (line 141) | std::string GetAsString() const { return std::string(data()); }
      method GetAsInteger (line 143) | int64_t GetAsInteger() const {
      method GetAsArray (line 152) | std::array<T, N> GetAsArray() {
    function ValueUnion (line 161) | ValueUnion GetSysctlImp(std::string const& name) {
      method ValueUnion (line 129) | ValueUnion() : size(0), buff(nullptr, &std::free) {}
      method ValueUnion (line 131) | explicit ValueUnion(std::size_t buff_size)
      method ValueUnion (line 135) | ValueUnion(ValueUnion&& other) = default;
      method GetAsString (line 141) | std::string GetAsString() const { return std::string(data()); }
      method GetAsInteger (line 143) | int64_t GetAsInteger() const {
      method GetAsArray (line 152) | std::array<T, N> GetAsArray() {
    function BENCHMARK_MAYBE_UNUSED (line 193) | BENCHMARK_MAYBE_UNUSED
    function GetSysctl (line 204) | bool GetSysctl(std::string const& name, Tp* out) {
    function GetSysctl (line 213) | bool GetSysctl(std::string const& name, std::array<Tp, N>* out) {
    function ReadFromFile (line 222) | bool ReadFromFile(std::string const& fname, ArgT* arg) {
    function CpuScaling (line 232) | CPUInfo::Scaling CpuScaling(int num_cpus) {
    function CountSetBitsInCPUMap (line 257) | int CountSetBitsInCPUMap(std::string val) {
    function BENCHMARK_MAYBE_UNUSED (line 276) | BENCHMARK_MAYBE_UNUSED
    function GetCacheSizesMacOSX (line 322) | std::vector<CPUInfo::CacheInfo> GetCacheSizesMacOSX() {
    function GetCacheSizesWindows (line 349) | std::vector<CPUInfo::CacheInfo> GetCacheSizesWindows() {
    function GetCacheSizesQNX (line 404) | std::vector<CPUInfo::CacheInfo> GetCacheSizesQNX() {
    function GetCacheSizes (line 441) | std::vector<CPUInfo::CacheInfo> GetCacheSizes() {
    function GetSystemName (line 456) | std::string GetSystemName() {
    function GetASLR (line 509) | SystemInfo::ASLR GetASLR() {
    function GetNumCPUsImpl (line 520) | int GetNumCPUsImpl() {
    function GetNumCPUs (line 566) | int GetNumCPUs() {
    class ThreadAffinityGuard (line 576) | class ThreadAffinityGuard final {
      method ThreadAffinityGuard (line 578) | ThreadAffinityGuard() : reset_affinity(SetAffinity()) {
      method ThreadAffinityGuard (line 605) | ThreadAffinityGuard(ThreadAffinityGuard&&) = delete;
      method ThreadAffinityGuard (line 606) | ThreadAffinityGuard(const ThreadAffinityGuard&) = delete;
      method ThreadAffinityGuard (line 607) | ThreadAffinityGuard& operator=(ThreadAffinityGuard&&) = delete;
      method ThreadAffinityGuard (line 608) | ThreadAffinityGuard& operator=(const ThreadAffinityGuard&) = delete;
      method SetAffinity (line 611) | bool SetAffinity() {
    function GetCPUCyclesPerSecond (line 662) | double GetCPUCyclesPerSecond(CPUInfo::Scaling scaling) {
    function GetLoadAvg (line 870) | std::vector<double> GetLoadAvg() {
    function CPUInfo (line 891) | const CPUInfo& CPUInfo::Get() {
    function SystemInfo (line 903) | const SystemInfo& SystemInfo::Get() {

FILE: src/thread_manager.h
  function namespace (line 11) | namespace benchmark {

FILE: src/thread_timer.h
  function namespace (line 7) | namespace benchmark {

FILE: src/timers.cc
  type benchmark (line 65) | namespace benchmark {
    function MakeTime (line 77) | double MakeTime(FILETIME const& kernel_time, FILETIME const& user_time) {
    function MakeTime (line 90) | double MakeTime(struct rusage const& ru) {
    function MakeTime (line 98) | double MakeTime(thread_basic_info_data_t const& info) {
    function MakeTime (line 106) | double MakeTime(struct timespec const& ts) {
    function BENCHMARK_NORETURN (line 112) | BENCHMARK_NORETURN void DiagnoseAndExit(const char* msg) {
    function ProcessCPUUsage (line 120) | double ProcessCPUUsage() {
    function ThreadCPUUsage (line 168) | double ThreadCPUUsage() {
    function LocalDateTimeString (line 226) | std::string LocalDateTimeString() {

FILE: src/timers.h
  function namespace (line 7) | namespace benchmark {

FILE: test/args_product_test.cc
  class ArgsProductFixture (line 11) | class ArgsProductFixture : public ::benchmark::Fixture {
    method ArgsProductFixture (line 13) | ArgsProductFixture()
    method SetUp (line 29) | void SetUp(const ::benchmark::State& state) override {

FILE: test/basic_test.cc
  function BM_empty (line 10) | void BM_empty(benchmark::State& state) {
  function BM_spin_empty (line 20) | void BM_spin_empty(benchmark::State& state) {
  function BM_spin_pause_before (line 30) | void BM_spin_pause_before(benchmark::State& state) {
  function BM_spin_pause_during (line 43) | void BM_spin_pause_during(benchmark::State& state) {
  function BM_pause_during (line 58) | void BM_pause_during(benchmark::State& state) {
  function BM_spin_pause_after (line 69) | void BM_spin_pause_after(benchmark::State& state) {
  function BM_spin_pause_before_and_after (line 82) | void BM_spin_pause_before_and_after(benchmark::State& state) {
  function BM_empty_stop_start (line 98) | void BM_empty_stop_start(benchmark::State& state) {
  function BM_KeepRunning (line 105) | void BM_KeepRunning(benchmark::State& state) {
  function BM_KeepRunningBatch (line 115) | void BM_KeepRunningBatch(benchmark::State& state) {
  function BM_RangedFor (line 141) | void BM_RangedFor(benchmark::State& state) {
  function BM_OneTemplateFunc (line 151) | void BM_OneTemplateFunc(benchmark::State& state) {
  function BM_TwoTemplateFunc (line 162) | void BM_TwoTemplateFunc(benchmark::State& state) {

FILE: test/benchmark_gtest.cc
  type benchmark (line 10) | namespace benchmark {
    type internal (line 11) | namespace internal {
      function TEST (line 15) | TEST(AddRangeTest, Simple) {
      function TEST (line 21) | TEST(AddRangeTest, Simple64) {
      function TEST (line 27) | TEST(AddRangeTest, Advanced) {
      function TEST (line 33) | TEST(AddRangeTest, Advanced64) {
      function TEST (line 39) | TEST(AddRangeTest, FullRange8) {
      function TEST (line 46) | TEST(AddRangeTest, FullRange64) {
      function TEST (line 55) | TEST(AddRangeTest, NegativeRanges) {
      function TEST (line 61) | TEST(AddRangeTest, StrictlyNegative) {
      function TEST (line 67) | TEST(AddRangeTest, SymmetricNegativeRanges) {
      function TEST (line 73) | TEST(AddRangeTest, SymmetricNegativeRangesOddMult) {
      function TEST (line 79) | TEST(AddRangeTest, NegativeRangesAsymmetric) {
      function TEST (line 85) | TEST(AddRangeTest, NegativeRangesLargeStep) {
      function TEST (line 92) | TEST(AddRangeTest, ZeroOnlyRange) {
      function TEST (line 98) | TEST(AddRangeTest, ZeroStartingRange) {
      function TEST (line 104) | TEST(AddRangeTest, NegativeRange64) {
      function TEST (line 110) | TEST(AddRangeTest, NegativeRangePreservesExistingOrder) {
      function TEST (line 118) | TEST(AddRangeTest, FullNegativeRange64) {
      function TEST (line 131) | TEST(AddRangeTest, Simple8) {
      function TEST (line 138) | TEST(AddCustomContext, Simple) {
      function TEST (line 153) | TEST(AddCustomContext, DuplicateKey) {

FILE: test/benchmark_min_time_flag_iters_test.cc
  class TestReporter (line 16) | class TestReporter : public benchmark::ConsoleReporter {
    method ReportContext (line 18) | bool ReportContext(const Context& context) override {
    method ReportRuns (line 22) | void ReportRuns(const std::vector<Run>& report) override {
    method TestReporter (line 28) | TestReporter() {}
  function BM_MyBench (line 40) | void BM_MyBench(benchmark::State& state) {
  function main (line 48) | int main(int argc, char** argv) {

FILE: test/benchmark_min_time_flag_time_test.cc
  class TestReporter (line 23) | class TestReporter : public benchmark::ConsoleReporter {
    method ReportContext (line 25) | bool ReportContext(const Context& context) override {
    method ReportRuns (line 29) | void ReportRuns(const std::vector<Run>& report) override {
    method ReportRunsConfig (line 34) | void ReportRunsConfig(double min_time, bool /* has_explicit_iters */,
    method TestReporter (line 39) | TestReporter() {}
  function AlmostEqual (line 49) | bool AlmostEqual(double a, double b) {
  function DoTestHelper (line 53) | void DoTestHelper(int* argc, const char** argv, double expected) {
  function BM_MyBench (line 66) | void BM_MyBench(benchmark::State& state) {
  function main (line 74) | int main(int argc, char** argv) {

FILE: test/benchmark_name_gtest.cc
  function TEST (line 9) | TEST(BenchmarkNameTest, Empty) {
  function TEST (line 14) | TEST(BenchmarkNameTest, FunctionName) {
  function TEST (line 20) | TEST(BenchmarkNameTest, FunctionNameAndArgs) {
  function TEST (line 27) | TEST(BenchmarkNameTest, MinTime) {
  function TEST (line 35) | TEST(BenchmarkNameTest, MinWarmUpTime) {
  function TEST (line 43) | TEST(BenchmarkNameTest, Iterations) {
  function TEST (line 51) | TEST(BenchmarkNameTest, Repetitions) {
  function TEST (line 59) | TEST(BenchmarkNameTest, TimeType) {
  function TEST (line 67) | TEST(BenchmarkNameTest, Threads) {
  function TEST (line 75) | TEST(BenchmarkNameTest, TestEmptyFunctionName) {

FILE: test/benchmark_random_interleaving_gtest.cc
  type benchmark (line 14) | namespace benchmark {
    type internal (line 20) | namespace internal {
      class EventQueue (line 23) | class EventQueue : public std::queue<std::string> {
        method Put (line 25) | void Put(const std::string& event) { push(event); }
        method Clear (line 27) | void Clear() {
        method Get (line 33) | std::string Get() {
      class NullReporter (line 43) | class NullReporter : public BenchmarkReporter {
        method ReportContext (line 45) | bool ReportContext(const Context& /*context*/) override { return t...
        method ReportRuns (line 46) | void ReportRuns(const std::vector<Run>& /* report */) override {}
      class BenchmarkTest (line 49) | class BenchmarkTest : public testing::Test {
        method SetupHook (line 51) | static void SetupHook(int /* num_threads */) { queue->push("Setup"...
        method TeardownHook (line 53) | static void TeardownHook(int /* num_threads */) { queue->push("Tea...
        method Execute (line 55) | static void Execute(const std::string& pattern) {
      function BM_Match1 (line 66) | void BM_Match1(benchmark::State& state) {
      function TEST_F (line 82) | TEST_F(BenchmarkTest, Match1) {
      function TEST_F (line 95) | TEST_F(BenchmarkTest, Match1WithRepetition) {
      function TEST_F (line 106) | TEST_F(BenchmarkTest, Match1WithRandomInterleaving) {

FILE: test/benchmark_setup_teardown_cb_types_gtest.cc
  type Functor (line 16) | struct Functor {
  class NullReporter (line 20) | class NullReporter : public BenchmarkReporter {
    method ReportContext (line 22) | bool ReportContext(const Context& /*context*/) override { return true; }
    method ReportRuns (line 23) | void ReportRuns(const std::vector<Run>& /* report */) override {}
  class BenchmarkTest (line 26) | class BenchmarkTest : public testing::Test {
    method SetUp (line 34) | void SetUp() override {
    method TearDown (line 46) | void TearDown() override { ClearRegisteredBenchmarks(); }
  function TEST_F (line 50) | TEST_F(BenchmarkTest, LambdaTestCopy) {
  function TEST_F (line 61) | TEST_F(BenchmarkTest, LambdaTestMove) {
  function TEST_F (line 72) | TEST_F(BenchmarkTest, CallbackFunctionCopy) {
  function TEST_F (line 85) | TEST_F(BenchmarkTest, CallbackFunctionMove) {
  function TEST_F (line 98) | TEST_F(BenchmarkTest, FunctorCopy) {
  function TEST_F (line 107) | TEST_F(BenchmarkTest, FunctorMove) {
  function TEST_F (line 117) | TEST_F(BenchmarkTest, NullptrTest) {

FILE: test/benchmark_setup_teardown_test.cc
  type singlethreaded (line 14) | namespace singlethreaded {
  function DoSetup1 (line 19) | static void DoSetup1(const benchmark::State& state) {
  function DoTeardown1 (line 26) | static void DoTeardown1(const benchmark::State& state) {
  function BM_with_setup (line 31) | static void BM_with_setup(benchmark::State& state) {
  type concurrent (line 46) | namespace concurrent {
  function DoSetup2 (line 52) | void DoSetup2(const benchmark::State& state) {
  function DoTeardown2 (line 57) | void DoTeardown2(const benchmark::State& state) {
  function BM_concurrent (line 62) | void BM_concurrent(benchmark::State& state) {
  type fixture_interaction (line 77) | namespace fixture_interaction {
  class FIXTURE_BECHMARK_NAME (line 84) | class FIXTURE_BECHMARK_NAME : public ::benchmark::Fixture {
    method SetUp (line 86) | void SetUp(const ::benchmark::State& /*unused*/) override {
  function DoSetupWithFixture (line 98) | void DoSetupWithFixture(const benchmark::State& /*unused*/) {
  type repetitions (line 112) | namespace repetitions {
  function DoSetupWithRepetitions (line 116) | void DoSetupWithRepetitions(const benchmark::State& /*unused*/) {
  function BM_WithRep (line 119) | void BM_WithRep(benchmark::State& state) {
  function main (line 134) | int main(int argc, char** argv) {

FILE: test/benchmark_test.cc
  function CalculatePi (line 36) | double CalculatePi(int depth) {
  function ConstructRandomSet (line 46) | std::set<int64_t> ConstructRandomSet(int64_t size) {
  function BM_Factorial (line 59) | void BM_Factorial(benchmark::State& state) {
  function BM_CalculatePiRange (line 72) | void BM_CalculatePiRange(benchmark::State& state) {
  function BM_CalculatePi (line 83) | void BM_CalculatePi(benchmark::State& state) {
  function BM_SetInsert (line 94) | void BM_SetInsert(benchmark::State& state) {
  function BM_Sequential (line 116) | void BM_Sequential(benchmark::State& state) {
  function BM_StringCompare (line 134) | void BM_StringCompare(benchmark::State& state) {
  function BM_SetupTeardown (line 145) | void BM_SetupTeardown(benchmark::State& state) {
  function BM_LongTest (line 166) | void BM_LongTest(benchmark::State& state) {
  function BM_ParallelMemset (line 176) | void BM_ParallelMemset(benchmark::State& state) {
  function BM_ManualTiming (line 200) | void BM_ManualTiming(benchmark::State& state) {
  function BM_with_args (line 225) | void BM_with_args(benchmark::State& state, Args&&...) {
  function BM_non_template_args (line 233) | void BM_non_template_args(benchmark::State& state, int, double) {
  function BM_template2_capture (line 240) | void BM_template2_capture(benchmark::State& state, ExtraArgs&&... extra_...
  function BENCHMARK_TEMPLATE2_CAPTURE (line 249) | BENCHMARK_TEMPLATE2_CAPTURE(BM_template2_capture, void, char*, foo, 42U);

FILE: test/clobber_memory_assembly_test.cc
  function test_basic (line 17) | void test_basic() {
  function test_redundant_store (line 28) | void test_redundant_store() {
  function test_redundant_read (line 38) | void test_redundant_read() {
  function test_redundant_read2 (line 52) | void test_redundant_read2() {

FILE: test/commandlineflags_gtest.cc
  type benchmark (line 8) | namespace benchmark {
    function setenv (line 12) | int setenv(const char* name, const char* value, int overwrite) {
    function unsetenv (line 23) | int unsetenv(const char* name) { return _putenv_s(name, ""); }
    function TEST (line 27) | TEST(BoolFromEnv, Default) {
    function TEST (line 32) | TEST(BoolFromEnv, False) {
    function TEST (line 90) | TEST(BoolFromEnv, True) {
    function TEST (line 154) | TEST(Int32FromEnv, NotInEnv) {
    function TEST (line 159) | TEST(Int32FromEnv, InvalidInteger) {
    function TEST (line 165) | TEST(Int32FromEnv, ValidInteger) {
    function TEST (line 171) | TEST(DoubleFromEnv, NotInEnv) {
    function TEST (line 176) | TEST(DoubleFromEnv, InvalidReal) {
    function TEST (line 182) | TEST(DoubleFromEnv, ValidReal) {
    function TEST (line 188) | TEST(StringFromEnv, Default) {
    function TEST (line 193) | TEST(StringFromEnv, Valid) {
    function TEST (line 199) | TEST(KvPairsFromEnv, Default) {
    function TEST (line 205) | TEST(KvPairsFromEnv, MalformedReturnsDefault) {
    function TEST (line 212) | TEST(KvPairsFromEnv, Single) {
    function TEST (line 219) | TEST(KvPairsFromEnv, Multiple) {

FILE: test/complexity_test.cc
  function AddComplexityTest (line 20) | int AddComplexityTest(const std::string& test_name,
  function BM_Complexity_O1 (line 72) | void BM_Complexity_O1(benchmark::State& state) {
  function BM_Complexity_O_N (line 121) | void BM_Complexity_O_N(benchmark::State& state) {
  function BM_Complexity_O_N_log_N (line 179) | void BM_Complexity_O_N_log_N(benchmark::State& state) {
  function BM_ComplexityCaptureArgs (line 241) | void BM_ComplexityCaptureArgs(benchmark::State& state, int n) {
  function main (line 275) | int main(int argc, char* argv[]) {

FILE: test/diagnostics_test.cc
  function TestHandler (line 24) | void TestHandler() {
  function try_invalid_pause_resume (line 32) | void try_invalid_pause_resume(benchmark::State& state) {
  function BM_diagnostic_test (line 50) | void BM_diagnostic_test(benchmark::State& state) {
  function BM_diagnostic_test_keep_running (line 71) | void BM_diagnostic_test_keep_running(benchmark::State& state) {
  function main (line 93) | int main(int argc, char* argv[]) {

FILE: test/display_aggregates_only_test.cc
  function BM_SummaryRepeat (line 16) | void BM_SummaryRepeat(benchmark::State& state) {
  function main (line 23) | int main(int argc, char* argv[]) {

FILE: test/donotoptimize_assembly_test.cc
  function Add42 (line 19) | inline int Add42(int x) { return x + 42; }
  type NotTriviallyCopyable (line 21) | struct NotTriviallyCopyable {
    method NotTriviallyCopyable (line 23) | explicit NotTriviallyCopyable(int x) : value(x) {}
  type Large (line 28) | struct Large {
  type ExtraLarge (line 33) | struct ExtraLarge {
  function test_with_rvalue (line 42) | void test_with_rvalue() {
  function test_with_large_rvalue (line 49) | void test_with_large_rvalue() {
  function test_with_non_trivial_rvalue (line 59) | void test_with_non_trivial_rvalue() {
  function test_with_lvalue (line 66) | void test_with_lvalue() {
  function test_with_large_lvalue (line 75) | void test_with_large_lvalue() {
  function test_with_extra_large_lvalue_with_op (line 86) | void test_with_extra_large_lvalue_with_op() {
  function test_with_big_array_with_op (line 94) | void test_with_big_array_with_op() {
  function test_with_non_trivial_lvalue (line 102) | void test_with_non_trivial_lvalue() {
  function test_with_const_lvalue (line 111) | void test_with_const_lvalue() {
  function test_with_large_const_lvalue (line 119) | void test_with_large_const_lvalue() {
  function test_with_const_extra_large_obj (line 130) | void test_with_const_extra_large_obj() {
  function test_with_const_big_array (line 136) | void test_with_const_big_array() {
  function test_with_non_trivial_const_lvalue (line 142) | void test_with_non_trivial_const_lvalue() {
  function test_div_by_two (line 150) | int test_div_by_two(int input) {
  function test_inc_integer (line 160) | int test_inc_integer() {
  function test_pointer_rvalue (line 174) | void test_pointer_rvalue() {
  function test_pointer_const_lvalue (line 184) | void test_pointer_const_lvalue() {
  function test_pointer_lvalue (line 195) | void test_pointer_lvalue() {

FILE: test/donotoptimize_test.cc
  function double_up (line 10) | std::int64_t double_up(const std::int64_t x) { return x * 2; }
  type BitRef (line 15) | struct BitRef {
    method BitRef (line 20) | static BitRef Make() {
    method BitRef (line 27) | BitRef(int i, unsigned char& b) : index(i), byte(b) {}
  function main (line 30) | int main(int argc, char* argv[]) {

FILE: test/filter_test.cc
  class TestReporter (line 18) | class TestReporter : public benchmark::ConsoleReporter {
    method ReportContext (line 20) | bool ReportContext(const Context& context) override {
    method ReportRuns (line 24) | void ReportRuns(const std::vector<Run>& report) override {
    method TestReporter (line 30) | TestReporter() : count_(0), max_family_index_(0) {}
    method GetCount (line 34) | int GetCount() const { return count_; }
    method GetMaxFamilyIndex (line 36) | int64_t GetMaxFamilyIndex() const { return max_family_index_; }
  function NoPrefix (line 43) | void NoPrefix(benchmark::State& state) {
  function BM_Foo (line 49) | void BM_Foo(benchmark::State& state) {
  function BM_Bar (line 55) | void BM_Bar(benchmark::State& state) {
  function BM_FooBar (line 61) | void BM_FooBar(benchmark::State& state) {
  function BM_FooBa (line 67) | void BM_FooBa(benchmark::State& state) {
  function main (line 74) | int main(int argc, char** argv) {

FILE: test/fixture_test.cc
  class FIXTURE_BECHMARK_NAME (line 11) | class FIXTURE_BECHMARK_NAME : public ::benchmark::Fixture {
    method SetUp (line 13) | void SetUp(const ::benchmark::State& state) override {
    method TearDown (line 20) | void TearDown(const ::benchmark::State& state) override {

FILE: test/internal_threading_test.cc
  function MyBusySpinwait (line 21) | void MyBusySpinwait() {
  function BM_MainThread (line 42) | void BM_MainThread(benchmark::State& state) {
  function BM_WorkerThread (line 84) | void BM_WorkerThread(benchmark::State& state) {
  function BM_MainThreadAndWorkerThread (line 127) | void BM_MainThreadAndWorkerThread(benchmark::State& state) {
  function main (line 191) | int main(int argc, char* argv[]) {

FILE: test/link_main_test.cc
  function BM_empty (line 6) | void BM_empty(benchmark::State& state) {

FILE: test/locale_impermeability_test.cc
  function BM_ostream (line 12) | void BM_ostream(benchmark::State& state) {
  function main (line 46) | int main(int argc, char* argv[]) {

FILE: test/manual_threading_test.cc
  function MyBusySpinwait (line 22) | void MyBusySpinwait() {
  class ManualThreadRunner (line 38) | class ManualThreadRunner : public benchmark::ThreadRunnerBase {
    method ManualThreadRunner (line 40) | explicit ManualThreadRunner(int num_threads)
    method RunThreads (line 43) | void RunThreads(const std::function<void(int)>& fn) final {
  function BM_ManualThreading (line 69) | void BM_ManualThreading(benchmark::State& state) {
  function main (line 172) | int main(int argc, char* argv[]) {

FILE: test/map_test.cc
  function ConstructRandomMap (line 11) | std::map<int, int> ConstructRandomMap(int size) {
  function BM_MapLookup (line 20) | void BM_MapLookup(benchmark::State& state) {
  class MapFixture (line 38) | class MapFixture : public ::benchmark::Fixture {
    method SetUp (line 40) | void SetUp(const ::benchmark::State& st) override {
    method TearDown (line 44) | void TearDown(const ::benchmark::State& /*unused*/) override { m.clear...

FILE: test/memory_manager_test.cc
  class TestMemoryManager (line 11) | class TestMemoryManager : public benchmark::MemoryManager {
    method Start (line 12) | void Start() override {}
    method Stop (line 13) | void Stop(Result& result) override {
  function BM_empty (line 19) | void BM_empty(benchmark::State& state) {
  function main (line 47) | int main(int argc, char* argv[]) {

FILE: test/memory_results_gtest.cc
  function reset (line 27) | void reset() {
  class TestMemoryManager (line 33) | class TestMemoryManager : public MemoryManager {
    method Start (line 34) | void Start() override {}
    method Stop (line 35) | void Stop(Result& result) override {
  class TestReporter (line 48) | class TestReporter : public ConsoleReporter {
    method TestReporter (line 50) | TestReporter() = default;
    method ReportContext (line 53) | bool ReportContext(const Context& /*unused*/) override { return true; }
    method PrintHeader (line 55) | void PrintHeader(const Run&) override {}
    method PrintRunData (line 56) | void PrintRunData(const Run& run) override {
  class MemoryResultsTest (line 66) | class MemoryResultsTest : public testing::Test {
    method SetUp (line 71) | void SetUp() override {
    method TearDown (line 80) | void TearDown() override { ClearRegisteredBenchmarks(); }
  function TEST_F (line 83) | TEST_F(MemoryResultsTest, NoMMTest) {
  function TEST_F (line 88) | TEST_F(MemoryResultsTest, ResultsTest) {

FILE: test/min_time_parse_gtest.cc
  function TEST (line 6) | TEST(ParseMinTimeTest, InvalidInput) {

FILE: test/multiple_ranges_test.cc
  class MultipleRangesFixture (line 12) | class MultipleRangesFixture : public ::benchmark::Fixture {
    method MultipleRangesFixture (line 14) | MultipleRangesFixture()
    method SetUp (line 35) | void SetUp(const ::benchmark::State& state) override {
  function BM_CheckDefaultArgument (line 85) | void BM_CheckDefaultArgument(benchmark::State& state) {
  function BM_MultipleRanges (line 94) | void BM_MultipleRanges(benchmark::State& st) {

FILE: test/options_test.cc
  function BM_basic (line 15) | void BM_basic(benchmark::State& state) {
  function BM_basic_slow (line 20) | void BM_basic_slow(benchmark::State& state) {
  function CustomArgs (line 57) | void CustomArgs(benchmark::Benchmark* b) {
  function BM_explicit_iteration_count (line 65) | void BM_explicit_iteration_count(benchmark::State& state) {

FILE: test/output_test.h
  type MatchRules (line 25) | enum MatchRules : uint8_t {
  type TestCase (line 32) | struct TestCase {
  type TestCaseID (line 41) | enum TestCaseID : uint8_t {
  type Results (line 87) | struct Results
  type std (line 88) | typedef std::function<void(Results const&)> ResultsCheckFn;
  function NumThreads (line 94) | struct Results {
  function std (line 122) | const std::string* Get(const std::string& entry_name) const {

FILE: test/output_test_helper.cc
  type internal (line 20) | namespace internal {
    function TestCaseList (line 32) | TestCaseList& GetTestCaseList(TestCaseID ID) {
    function SubMap (line 39) | SubMap& GetSubstitutions() {
    function PerformSubstitutions (line 82) | std::string PerformSubstitutions(std::string source) {
    function CheckCase (line 96) | void CheckCase(std::stringstream& remaining_output, TestCase const& TC,
    function CheckCases (line 131) | void CheckCases(TestCaseList const& checks, std::stringstream& output) {
    class TestReporter (line 144) | class TestReporter : public benchmark::BenchmarkReporter {
      method TestReporter (line 146) | TestReporter(std::vector<benchmark::BenchmarkReporter*> reps)
      method ReportContext (line 149) | bool ReportContext(const Context& context) override {
      method ReportRuns (line 163) | void ReportRuns(const std::vector<Run>& report) override {
      method Finalize (line 168) | void Finalize() override {
    class ResultsChecker (line 189) | class ResultsChecker {
      type PatternAndFn (line 191) | struct PatternAndFn : public TestCase {  // reusing TestCase for its...
        method PatternAndFn (line 192) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
    function ResultsChecker (line 215) | ResultsChecker& GetResultsChecker() {
      type PatternAndFn (line 191) | struct PatternAndFn : public TestCase {  // reusing TestCase for its...
        method PatternAndFn (line 192) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
  type internal (line 185) | namespace internal {
    function TestCaseList (line 32) | TestCaseList& GetTestCaseList(TestCaseID ID) {
    function SubMap (line 39) | SubMap& GetSubstitutions() {
    function PerformSubstitutions (line 82) | std::string PerformSubstitutions(std::string source) {
    function CheckCase (line 96) | void CheckCase(std::stringstream& remaining_output, TestCase const& TC,
    function CheckCases (line 131) | void CheckCases(TestCaseList const& checks, std::stringstream& output) {
    class TestReporter (line 144) | class TestReporter : public benchmark::BenchmarkReporter {
      method TestReporter (line 146) | TestReporter(std::vector<benchmark::BenchmarkReporter*> reps)
      method ReportContext (line 149) | bool ReportContext(const Context& context) override {
      method ReportRuns (line 163) | void ReportRuns(const std::vector<Run>& report) override {
      method Finalize (line 168) | void Finalize() override {
    class ResultsChecker (line 189) | class ResultsChecker {
      type PatternAndFn (line 191) | struct PatternAndFn : public TestCase {  // reusing TestCase for its...
        method PatternAndFn (line 192) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
    function ResultsChecker (line 215) | ResultsChecker& GetResultsChecker() {
      type PatternAndFn (line 191) | struct PatternAndFn : public TestCase {  // reusing TestCase for its...
        method PatternAndFn (line 192) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
  function AddChecker (line 330) | size_t AddChecker(const std::string& bm_name, const ResultsCheckFn& fn) {
  function AddCases (line 391) | int AddCases(TestCaseID ID, std::initializer_list<TestCase> il) {
  function SetSubstitutions (line 397) | int SetSubstitutions(
  function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 419) | BENCHMARK_DISABLE_DEPRECATED_WARNING
  function BENCHMARK_RESTORE_DEPRECATED_WARNING (line 480) | BENCHMARK_RESTORE_DEPRECATED_WARNING
  function ToHex (line 495) | char ToHex(int ch) {
  function RandomHexChar (line 500) | char RandomHexChar() {
  function GetRandomFileName (line 506) | std::string GetRandomFileName() {
  function FileExists (line 516) | bool FileExists(std::string const& name) {
  function GetTempFileName (line 521) | std::string GetTempFileName() {
  function GetFileReporterOutput (line 538) | std::string GetFileReporterOutput(int argc, char* argv[]) {

FILE: test/overload_test.cc
  function BENCHMARK_UNUSED (line 9) | BENCHMARK_UNUSED void MyOverloadedBenchmark() {}
  function MyOverloadedBenchmark (line 13) | void MyOverloadedBenchmark(benchmark::State& state) {
  function MyTemplatedOverloadedBenchmark (line 26) | void MyTemplatedOverloadedBenchmark() {}
  function MyTemplatedOverloadedBenchmark (line 29) | void MyTemplatedOverloadedBenchmark(benchmark::State& state) {

FILE: test/perf_counters_gtest.cc
  type MsgHandler (line 9) | struct MsgHandler {
  function TEST (line 26) | TEST(PerfCountersTest, Init) {
  function UniqueCounterNames (line 34) | static std::set<std::string> UniqueCounterNames(const PerfCounters& pc) {
  function TEST (line 39) | TEST(PerfCountersTest, OneCounter) {
  function TEST (line 48) | TEST(PerfCountersTest, NegativeTest) {
  function SnapshotAndCombine (line 98) | static std::map<std::string, uint64_t> SnapshotAndCombine(
  function TEST (line 111) | TEST(PerfCountersTest, Read1Counter) {
  function TEST (line 126) | TEST(PerfCountersTest, Read1CounterEachCPU) {
  function TEST (line 163) | TEST(PerfCountersTest, Read2Counters) {
  function TEST (line 183) | TEST(PerfCountersTest, ReopenExistingCounters) {
  function TEST (line 200) | TEST(PerfCountersTest, CreateExistingMeasurements) {
  function BENCHMARK_DONT_OPTIMIZE (line 269) | BENCHMARK_DONT_OPTIMIZE size_t do_work() {
  function measure (line 281) | void measure(size_t threadcount, std::map<std::string, uint64_t>* before,
  function TEST (line 305) | TEST(PerfCountersTest, MultiThreaded) {
  function TEST (line 342) | TEST(PerfCountersTest, HardwareLimits) {

FILE: test/perf_counters_test.cc
  type benchmark (line 12) | namespace benchmark {
  function BM_Simple (line 19) | void BM_Simple(benchmark::State& state) {
  function BM_WithoutPauseResume (line 30) | void BM_WithoutPauseResume(benchmark::State& state) {
  function BM_WithPauseResume (line 44) | void BM_WithPauseResume(benchmark::State& state) {
  function CheckSimple (line 66) | static void CheckSimple(Results const& e) {
  function SaveInstrCountWithoutResume (line 73) | void SaveInstrCountWithoutResume(Results const& e) {
  function SaveInstrCountWithResume (line 77) | void SaveInstrCountWithResume(Results const& e) {
  function main (line 86) | int main(int argc, char* argv[]) {

FILE: test/profiler_manager_gtest.cc
  class TestProfilerManager (line 11) | class TestProfilerManager : public benchmark::ProfilerManager {
    method AfterSetupStart (line 13) | void AfterSetupStart() override { ++start_called; }
    method BeforeTeardownStop (line 14) | void BeforeTeardownStop() override { ++stop_called; }
  function BM_empty (line 20) | void BM_empty(benchmark::State& state) {
  function TEST (line 28) | TEST(ProfilerManager, ReregisterManager) {

FILE: test/profiler_manager_iterations_test.cc
  class TestProfilerManager (line 19) | class TestProfilerManager : public benchmark::ProfilerManager {
    method AfterSetupStart (line 20) | void AfterSetupStart() override { iteration_count = 0; }
    method BeforeTeardownStop (line 21) | void BeforeTeardownStop() override {
  class NullReporter (line 26) | class NullReporter : public benchmark::BenchmarkReporter {
    method ReportContext (line 28) | bool ReportContext(const Context& /*context*/) override { return true; }
    method ReportRuns (line 29) | void ReportRuns(const std::vector<Run>& /* report */) override {}
  function BM_MyBench (line 32) | void BM_MyBench(benchmark::State& state) {
  function main (line 40) | int main(int argc, char** argv) {

FILE: test/profiler_manager_test.cc
  class TestProfilerManager (line 14) | class TestProfilerManager : public benchmark::ProfilerManager {
    method AfterSetupStart (line 16) | void AfterSetupStart() override { ++start_called; }
    method BeforeTeardownStop (line 17) | void BeforeTeardownStop() override { ++stop_called; }
  function BM_empty (line 23) | void BM_empty(benchmark::State& state) {
  function main (line 48) | int main(int argc, char* argv[]) {

FILE: test/register_benchmark_test.cc
  class TestReporter (line 14) | class TestReporter : public benchmark::ConsoleReporter {
    method ReportRuns (line 16) | void ReportRuns(const std::vector<Run>& report) override {
  type TestCase (line 24) | struct TestCase {
    method TestCase (line 28) | TestCase(const std::string& xname) : TestCase(xname, "") {}
    method TestCase (line 29) | TestCase(const std::string& xname, const std::string& xlabel)
    method CheckRun (line 34) | void CheckRun(Run const& run) const {
  function AddCases (line 50) | int AddCases(std::initializer_list<TestCase> const& v) {
  function BM_function (line 67) | void BM_function(benchmark::State& state) {
  function BM_extra_args (line 82) | void BM_extra_args(benchmark::State& st, const char* label) {
  function RegisterFromFunction (line 87) | int RegisterFromFunction() {
  function DISABLED_BM_function (line 101) | void DISABLED_BM_function(benchmark::State& state) {
  function BM_named (line 114) | void BM_named(benchmark::State& state) {
  type CustomFixture (line 128) | struct CustomFixture {
  function TestRegistrationAtRuntime (line 135) | void TestRegistrationAtRuntime() {
  function RunTestOne (line 155) | void RunTestOne() {
  function RunTestTwo (line 175) | void RunTestTwo() {
  function main (line 202) | int main(int argc, char* argv[]) {

FILE: test/repetitions_test.cc
  function BM_ExplicitRepetitions (line 12) | void BM_ExplicitRepetitions(benchmark::State& state) {
  function BM_ImplicitRepetitions (line 114) | void BM_ImplicitRepetitions(benchmark::State& state) {
  function main (line 218) | int main(int argc, char* argv[]) {

FILE: test/report_aggregates_only_test.cc
  function BM_SummaryRepeat (line 16) | void BM_SummaryRepeat(benchmark::State& state) {
  function main (line 23) | int main(int argc, char* argv[]) {

FILE: test/reporter_output_test.cc
  function AddContextCases (line 20) | int AddContextCases() {
  function BM_basic (line 74) | void BM_basic(benchmark::State& state) {
  function BM_bytes_per_second (line 100) | void BM_bytes_per_second(benchmark::State& state) {
  function BM_items_per_second (line 133) | void BM_items_per_second(benchmark::State& state) {
  function BM_label (line 166) | void BM_label(benchmark::State& state) {
  function BM_time_label_nanosecond (line 195) | void BM_time_label_nanosecond(benchmark::State& state) {
  function BM_time_label_microsecond (line 218) | void BM_time_label_microsecond(benchmark::State& state) {
  function BM_time_label_millisecond (line 241) | void BM_time_label_millisecond(benchmark::State& state) {
  function BM_time_label_second (line 264) | void BM_time_label_second(benchmark::State& state) {
  function BM_error (line 290) | void BM_error(benchmark::State& state) {
  function BM_no_arg_name (line 315) | void BM_no_arg_name(benchmark::State& state) {
  function BM_arg_name (line 335) | void BM_arg_name(benchmark::State& state) {
  function BM_arg_names (line 355) | void BM_arg_names(benchmark::State& state) {
  function BM_name (line 377) | void BM_name(benchmark::State& state) {
  function BM_BigArgs (line 403) | void BM_BigArgs(benchmark::State& state) {
  function BM_Complexity_O1 (line 415) | void BM_Complexity_O1(benchmark::State& state) {
  function BM_Repeat (line 435) | void BM_Repeat(benchmark::State& state) {
  function BM_RepeatOnce (line 649) | void BM_RepeatOnce(benchmark::State& state) {
  function BM_SummaryRepeat (line 666) | void BM_SummaryRepeat(benchmark::State& state) {
  function BM_SummaryDisplay (line 717) | void BM_SummaryDisplay(benchmark::State& state) {
  function BM_RepeatTimeUnit (line 767) | void BM_RepeatTimeUnit(benchmark::State& state) {
  function BM_UserStats (line 831) | void BM_UserStats(benchmark::State& state) {
  function BM_UserPercentStats (line 962) | void BM_UserPercentStats(benchmark::State& state) {
  function BM_JSON_Format (line 1107) | void BM_JSON_Format(benchmark::State& state) {
  function BM_CSV_Format (line 1128) | void BM_CSV_Format(benchmark::State& state) {
  function main (line 1141) | int main(int argc, char* argv[]) {

FILE: test/skip_with_error_test.cc
  class TestReporter (line 15) | class TestReporter : public benchmark::ConsoleReporter {
    method ReportContext (line 17) | bool ReportContext(const Context& context) override {
    method ReportRuns (line 21) | void ReportRuns(const std::vector<Run>& report) override {
    method TestReporter (line 26) | TestReporter() {}
  type TestCase (line 32) | struct TestCase {
    method CheckRun (line 39) | void CheckRun(Run const& run) const {
  function AddCases (line 56) | int AddCases(const std::string& base_name,
  function BM_error_no_running (line 69) | void BM_error_no_running(benchmark::State& state) {
  function BM_error_before_running (line 75) | void BM_error_before_running(benchmark::State& state) {
  function BM_error_before_running_batch (line 84) | void BM_error_before_running_batch(benchmark::State& state) {
  function BM_error_before_running_range_for (line 93) | void BM_error_before_running_range_for(benchmark::State& state) {
  function BM_error_during_running (line 102) | void BM_error_during_running(benchmark::State& state) {
  function BM_error_during_running_ranged_for (line 125) | void BM_error_during_running_ranged_for(benchmark::State& state) {
  function BM_error_after_running (line 147) | void BM_error_after_running(benchmark::State& state) {
  function BM_error_while_paused (line 163) | void BM_error_while_paused(benchmark::State& state) {
  function BM_malformed (line 187) | void BM_malformed(benchmark::State& /*unused*/) {
  function main (line 197) | int main(int argc, char* argv[]) {

FILE: test/spec_arg_test.cc
  class TestReporter (line 21) | class TestReporter : public benchmark::ConsoleReporter {
    method ReportContext (line 23) | bool ReportContext(const Context& context) override {
    method ReportRuns (line 27) | void ReportRuns(const std::vector<Run>& report) override {
    method TestReporter (line 33) | TestReporter() {}
  function BM_NotChosen (line 45) | void BM_NotChosen(benchmark::State& state) {
  function BM_Chosen (line 52) | void BM_Chosen(benchmark::State& state) {
  function main (line 60) | int main(int argc, char** argv) {

FILE: test/spec_arg_verbosity_test.cc
  function BM_Verbosity (line 11) | void BM_Verbosity(benchmark::State& state) {
  function main (line 18) | int main(int argc, char** argv) {

FILE: test/state_assembly_test.cc
  function test_for_auto_loop (line 20) | int test_for_auto_loop() {
  function test_while_loop (line 43) | int test_while_loop() {

FILE: test/statistics_gtest.cc
  function TEST (line 9) | TEST(StatisticsTest, Mean) {
  function TEST (line 15) | TEST(StatisticsTest, Median) {
  function TEST (line 21) | TEST(StatisticsTest, StdDev) {
  function TEST (line 28) | TEST(StatisticsTest, CV) {

FILE: test/string_util_gtest.cc
  function TEST (line 13) | TEST(StringUtilTest, stoul) {
  function TEST (line 76) | TEST(StringUtilTest, stoi) {
  function TEST (line 125) | TEST(StringUtilTest, stod) {
  function TEST (line 160) | TEST(StringUtilTest, StrSplit) {
  function TEST_P (line 197) | TEST_P(HumanReadableFixture, HumanReadableNumber) {

FILE: test/templated_fixture_method_test.cc
  class MyFixture (line 10) | class MyFixture : public ::benchmark::Fixture {
    method MyFixture (line 12) | MyFixture() : data(0) {}

FILE: test/templated_fixture_test.cc
  class MyFixture (line 10) | class MyFixture : public ::benchmark::Fixture {
    method MyFixture (line 12) | MyFixture() : data(0) {}

FILE: test/time_unit_gtest.cc
  type benchmark (line 5) | namespace benchmark {
    type internal (line 6) | namespace internal {
      class DummyBenchmark (line 10) | class DummyBenchmark : public benchmark::Benchmark {
        method DummyBenchmark (line 12) | DummyBenchmark() : Benchmark("dummy") {}
        method Run (line 13) | void Run(State& /*state*/) override {}
      function TEST (line 16) | TEST(DefaultTimeUnitTest, TimeUnitIsNotSet) {
      function TEST (line 21) | TEST(DefaultTimeUnitTest, DefaultIsSet) {
      function TEST (line 28) | TEST(DefaultTimeUnitTest, DefaultAndExplicitUnitIsSet) {

FILE: test/user_counters_tabular_test.cc
  function BM_Counters_Tabular (line 69) | void BM_Counters_Tabular(benchmark::State& state) {
  function CheckTabular (line 364) | void CheckTabular(Results const& e) {
  function BM_CounterRates_Tabular (line 381) | void BM_CounterRates_Tabular(benchmark::State& state) {
  function CheckTabularRate (line 424) | void CheckTabularRate(Results const& e) {
  function BM_CounterSet0_Tabular (line 441) | void BM_CounterSet0_Tabular(benchmark::State& state) {
  function CheckSet0 (line 473) | void CheckSet0(Results const& e) {
  function BM_CounterSet1_Tabular (line 481) | void BM_CounterSet1_Tabular(benchmark::State& state) {
  function CheckSet1 (line 513) | void CheckSet1(Results const& e) {
  function BM_CounterSet2_Tabular (line 525) | void BM_CounterSet2_Tabular(benchmark::State& state) {
  function CheckSet2 (line 557) | void CheckSet2(Results const& e) {
  function main (line 569) | int main(int argc, char* argv[]) {

FILE: test/user_counters_test.cc
  function BM_Counters_Simple (line 29) | void BM_Counters_Simple(benchmark::State& state) {
  function CheckSimple (line 56) | void CheckSimple(Results const& e) {
  function BM_Counters_WithBytesAndItemsPSec (line 71) | void BM_Counters_WithBytesAndItemsPSec(benchmark::State& state) {
  function CheckBytesAndItemsPSec (line 109) | void CheckBytesAndItemsPSec(Results const& e) {
  function BM_Counters_Rate (line 125) | void BM_Counters_Rate(benchmark::State& state) {
  function CheckRate (line 158) | void CheckRate(Results const& e) {
  function BM_Invert (line 172) | void BM_Invert(benchmark::State& state) {
  function CheckInvert (line 204) | void CheckInvert(Results const& e) {
  function BM_Counters_InvertedRate (line 216) | void BM_Counters_InvertedRate(benchmark::State& state) {
  function CheckInvertedRate (line 252) | void CheckInvertedRate(Results const& e) {
  function BM_Counters_Threads (line 266) | void BM_Counters_Threads(benchmark::State& state) {
  function CheckThreads (line 296) | void CheckThreads(Results const& e) {
  function BM_Counters_AvgThreads (line 308) | void BM_Counters_AvgThreads(benchmark::State& state) {
  function CheckAvgThreads (line 339) | void CheckAvgThreads(Results const& e) {
  function BM_Counters_AvgThreadsRate (line 352) | void BM_Counters_AvgThreadsRate(benchmark::State& state) {
  function CheckAvgThreadsRate (line 387) | void CheckAvgThreadsRate(Results const& e) {
  function BM_Counters_IterationInvariant (line 402) | void BM_Counters_IterationInvariant(benchmark::State& state) {
  function CheckIterationInvariant (line 432) | void CheckIterationInvariant(Results const& e) {
  function BM_Counters_kIsIterationInvariantRate (line 447) | void BM_Counters_kIsIterationInvariantRate(benchmark::State& state) {
  function CheckIsIterationInvariantRate (line 484) | void CheckIsIterationInvariantRate(Results const& e) {
  function BM_Counters_AvgIterations (line 500) | void BM_Counters_AvgIterations(benchmark::State& state) {
  function CheckAvgIterations (line 530) | void CheckAvgIterations(Results const& e) {
  function BM_Counters_kAvgIterationsRate (line 544) | void BM_Counters_kAvgIterationsRate(benchmark::State& state) {
  function CheckAvgIterationsRate (line 579) | void CheckAvgIterationsRate(Results const& e) {
  function main (line 594) | int main(int argc, char* argv[]) {

FILE: test/user_counters_thousands_test.cc
  function BM_Counters_Thousands (line 15) | void BM_Counters_Thousands(benchmark::State& state) {
  function CheckThousands (line 172) | void CheckThousands(Results const& e) {
  function main (line 192) | int main(int argc, char* argv[]) {

FILE: test/user_counters_threads_test.cc
  function BM_Counters_Simple (line 29) | void BM_Counters_Simple(benchmark::State& state) {
  function CheckSimple (line 59) | void CheckSimple(Results const& e) {
  function BM_Counters_WithBytesAndItemsPSec (line 73) | void BM_Counters_WithBytesAndItemsPSec(benchmark::State& state) {
  function CheckBytesAndItemsPSec (line 112) | void CheckBytesAndItemsPSec(Results const& e) {
  function BM_Counters_Rate (line 130) | void BM_Counters_Rate(benchmark::State& state) {
  function CheckRate (line 164) | void CheckRate(Results const& e) {
  function BM_Invert (line 179) | void BM_Invert(benchmark::State& state) {
  function CheckInvert (line 213) | void CheckInvert(Results const& e) {
  function BM_Counters_InvertedRate (line 227) | void BM_Counters_InvertedRate(benchmark::State& state) {
  function CheckInvertedRate (line 265) | void CheckInvertedRate(Results const& e) {
  function BM_Counters_Threads (line 281) | void BM_Counters_Threads(benchmark::State& state) {
  function CheckThreads (line 311) | void CheckThreads(Results const& e) {
  function BM_Counters_AvgThreads (line 323) | void BM_Counters_AvgThreads(benchmark::State& state) {
  function CheckAvgThreads (line 354) | void CheckAvgThreads(Results const& e) {
  function BM_Counters_AvgThreadsRate (line 367) | void BM_Counters_AvgThreadsRate(benchmark::State& state) {
  function CheckAvgThreadsRate (line 402) | void CheckAvgThreadsRate(Results const& e) {
  function BM_Counters_IterationInvariant (line 417) | void BM_Counters_IterationInvariant(benchmark::State& state) {
  function CheckIterationInvariant (line 449) | void CheckIterationInvariant(Results const& e) {
  function BM_Counters_kIsIterationInvariantRate (line 464) | void BM_Counters_kIsIterationInvariantRate(benchmark::State& state) {
  function CheckIsIterationInvariantRate (line 505) | void CheckIsIterationInvariantRate(Results const& e) {
  function BM_Counters_AvgIterations (line 522) | void BM_Counters_AvgIterations(benchmark::State& state) {
  function CheckAvgIterations (line 554) | void CheckAvgIterations(Results const& e) {
  function BM_Counters_kAvgIterationsRate (line 569) | void BM_Counters_kAvgIterationsRate(benchmark::State& state) {
  function CheckAvgIterationsRate (line 606) | void CheckAvgIterationsRate(Results const& e) {
  function main (line 622) | int main(int argc, char* argv[]) {

FILE: tools/compare.py
  function check_inputs (line 20) | def check_inputs(in1, in2, flags):
  function create_parser (line 59) | def create_parser():
  function main (line 248) | def main():
  class TestParser (line 354) | class TestParser(unittest.TestCase):
    method setUp (line 355) | def setUp(self):
    method test_benchmarks_basic (line 363) | def test_benchmarks_basic(self):
    method test_benchmarks_basic_without_utest (line 374) | def test_benchmarks_basic_without_utest(self):
    method test_benchmarks_basic_display_aggregates_only (line 386) | def test_benchmarks_basic_display_aggregates_only(self):
    method test_benchmarks_basic_with_utest_alpha (line 397) | def test_benchmarks_basic_with_utest_alpha(self):
    method test_benchmarks_basic_without_utest_with_utest_alpha (line 409) | def test_benchmarks_basic_without_utest_with_utest_alpha(self):
    method test_benchmarks_with_remainder (line 427) | def test_benchmarks_with_remainder(self):
    method test_benchmarks_with_remainder_after_doubleminus (line 438) | def test_benchmarks_with_remainder_after_doubleminus(self):
    method test_filters_basic (line 449) | def test_filters_basic(self):
    method test_filters_with_remainder (line 459) | def test_filters_with_remainder(self):
    method test_filters_with_remainder_after_doubleminus (line 471) | def test_filters_with_remainder_after_doubleminus(self):
    method test_benchmarksfiltered_basic (line 483) | def test_benchmarksfiltered_basic(self):
    method test_benchmarksfiltered_with_remainder (line 496) | def test_benchmarksfiltered_with_remainder(self):
    method test_benchmarksfiltered_with_remainder_after_doubleminus (line 516) | def test_benchmarksfiltered_with_remainder_after_doubleminus(self):

FILE: tools/gbench/report.py
  class BenchmarkColor (line 17) | class BenchmarkColor:
    method __init__ (line 18) | def __init__(self, name, code):
    method __repr__ (line 22) | def __repr__(self):
    method __format__ (line 25) | def __format__(self, format):
  function color_format (line 55) | def color_format(use_color, fmt_str, *args, **kwargs):
  function find_longest_name (line 75) | def find_longest_name(benchmark_list):
  function calculate_change (line 87) | def calculate_change(old_val, new_val):
  function filter_benchmark (line 98) | def filter_benchmark(json_orig, family, replacement=""):
  function get_unique_benchmark_names (line 114) | def get_unique_benchmark_names(json):
  function intersect (line 127) | def intersect(list1, list2):
  function is_potentially_comparable_benchmark (line 135) | def is_potentially_comparable_benchmark(x):
  function partition_benchmarks (line 139) | def partition_benchmarks(json1, json2):
  function get_timedelta_field_as_seconds (line 175) | def get_timedelta_field_as_seconds(benchmark, field_name):
  function calculate_geomean (line 185) | def calculate_geomean(json):
  function extract_field (line 203) | def extract_field(partition, field_name):
  function calc_utest (line 210) | def calc_utest(timings_cpu, timings_time):
  function print_utest (line 232) | def print_utest(bc_name, utest, utest_alpha, first_col_width, use_color=...
  function get_difference_report (line 277) | def get_difference_report(json1, json2, utest=False):
  function print_difference_report (line 379) | def print_difference_report(
  class TestGetUniqueBenchmarkNames (line 461) | class TestGetUniqueBenchmarkNames(unittest.TestCase):
    method load_results (line 462) | def load_results(self):
    method test_basic (line 473) | def test_basic(self):
  class TestReportDifference (line 489) | class TestReportDifference(unittest.TestCase):
    method setUpClass (line 491) | def setUpClass(cls):
    method test_json_diff_report_pretty_printing (line 509) | def test_json_diff_report_pretty_printing(self):
    method test_json_diff_report_output (line 594) | def test_json_diff_report_output(self):
  class TestReportDifferenceBetweenFamilies (line 834) | class TestReportDifferenceBetweenFamilies(unittest.TestCase):
    method setUpClass (line 836) | def setUpClass(cls):
    method test_json_diff_report_pretty_printing (line 853) | def test_json_diff_report_pretty_printing(self):
    method test_json_diff_report (line 873) | def test_json_diff_report(self):
  class TestReportDifferenceWithUTest (line 963) | class TestReportDifferenceWithUTest(unittest.TestCase):
    method setUpClass (line 965) | def setUpClass(cls):
    method test_json_diff_report_pretty_printing (line 983) | def test_json_diff_report_pretty_printing(self):
    method test_json_diff_report_pretty_printing_aggregates_only (line 1038) | def test_json_diff_report_pretty_printing_aggregates_only(self):
    method test_json_diff_report (line 1094) | def test_json_diff_report(self):
  class TestReportDifferenceWithUTestWhileDisplayingAggregatesOnly (line 1208) | class TestReportDifferenceWithUTestWhileDisplayingAggregatesOnly(
    method setUpClass (line 1212) | def setUpClass(cls):
    method test_json_diff_report_pretty_printing (line 1230) | def test_json_diff_report_pretty_printing(self):
    method test_json_diff_report (line 1285) | def test_json_diff_report(self):
  class TestReportDifferenceForPercentageAggregates (line 1400) | class TestReportDifferenceForPercentageAggregates(unittest.TestCase):
    method setUpClass (line 1402) | def setUpClass(cls):
    method test_json_diff_report_pretty_printing (line 1420) | def test_json_diff_report_pretty_printing(self):
    method test_json_diff_report (line 1433) | def test_json_diff_report(self):
  class TestReportSorting (line 1461) | class TestReportSorting(unittest.TestCase):
    method setUpClass (line 1463) | def setUpClass(cls):
    method test_json_diff_report_pretty_printing (line 1477) | def test_json_diff_report_pretty_printing(self):
  class TestReportDifferenceWithUTestWhileDisplayingAggregatesOnly2 (line 1507) | class TestReportDifferenceWithUTestWhileDisplayingAggregatesOnly2(
    method setUpClass (line 1511) | def setUpClass(cls):
    method test_json_diff_report_pretty_printing (line 1535) | def test_json_diff_report_pretty_printing(self):
    method test_json_diff_report (line 1559) | def test_json_diff_report(self):
  function assert_utest (line 1603) | def assert_utest(unittest_instance, lhs, rhs):
  function assert_measurements (line 1620) | def assert_measurements(unittest_instance, lhs, rhs):

FILE: tools/gbench/util.py
  function is_executable_file (line 20) | def is_executable_file(filename):
  function is_json_file (line 45) | def is_json_file(filename):
  function classify_input_file (line 59) | def classify_input_file(filename):
  function check_input_file (line 83) | def check_input_file(filename):
  function find_benchmark_flag (line 96) | def find_benchmark_flag(prefix, benchmark_flags):
  function remove_benchmark_flags (line 111) | def remove_benchmark_flags(prefix, benchmark_flags):
  function load_benchmark_results (line 121) | def load_benchmark_results(fname, benchmark_filter):
  function sort_benchmark_results (line 157) | def sort_benchmark_results(result):
  function run_benchmark (line 184) | def run_benchmark(exe_name, benchmark_flags):
  function run_or_load_benchmark (line 214) | def run_or_load_benchmark(filename, benchmark_flags):

FILE: tools/strip_asm.py
  function find_used_labels (line 13) | def find_used_labels(asm):
  function normalize_labels (line 23) | def normalize_labels(asm):
  function transform_labels (line 40) | def transform_labels(asm):
  function is_identifier (line 53) | def is_identifier(tk):
  function process_identifiers (line 66) | def process_identifiers(line):
  function process_asm (line 90) | def process_asm(asm):
  function main (line 132) | def main():