testing::Benchmark Class Reference

#include <benchmark.h>

Public Member Functions
	Benchmark (const char *name, void(*fn)(int))
	Benchmark (const char *name, void(*fn_range)(int, int))
Benchmark *	Arg (int x)
Benchmark *	Range (int lo, int hi)
const char *	Name ()
bool	ShouldRun (int argc, char *argv[])
void	Run ()

Private Member Functions
void	Register (const char *name, void(*fn)(int), void(*fn_range)(int, int))
void	RunRepeatedlyWithArg (int iterations, int arg)
void	RunWithArg (int arg)

Private Attributes
const char *	name_
void(*	fn_ )(int)
void(*	fn_range_ )(int, int)
std::vector< int >	args_

Constructor & Destructor Documentation

Benchmark() [1/2]

testing::Benchmark::Benchmark ( const char *  name, void(*)(int)  fn  )

inline

{ Register(name, fn, NULL); }

References plotDoE::name, and Register().

Benchmark() [2/2]

testing::Benchmark::Benchmark ( const char *  name, void(*)(int, int)  fn_range  )

inline

{ Register(name, NULL, fn_range); }

References plotDoE::name, and Register().

Member Function Documentation

Arg()

Benchmark * testing::Benchmark::Arg

(

int

x

)

                                 {
  args_.push_back(arg);
  return this;
}

References args_.

Name()

const char * testing::Benchmark::Name

(

)

{ return name_; }

References name_.

Range()

Benchmark * testing::Benchmark::Range	(	int	lo,
		int	hi
	)

                                          {
  const int kRangeMultiplier = 8;
  if (hi < lo) {
    int temp = hi;
    hi = lo;
    lo = temp;
  }
  while (lo < hi) {
    args_.push_back(lo);
    lo *= kRangeMultiplier;
  }
  // We always run the hi number.
  args_.push_back(hi);
  return this;
}

References args_.

Register()

void testing::Benchmark::Register ( const char *  name, void(*)(int)  fn, void(*)(int, int)  fn_range  )

private

                                                                                      {
  name_ = name;
  fn_ = fn;
  fn_range_ = fn_range;
  if (fn_ == NULL && fn_range_ == NULL) {
    fprintf(stderr, "%s: missing function\n", name_);
    exit(EXIT_FAILURE);
  }
  gBenchmarks().insert(std::make_pair(name, this));
}

References fn_, fn_range_, gBenchmarks(), plotDoE::name, and name_.

Referenced by Benchmark().

Run()

void testing::Benchmark::Run

(

)

                    {
  if (fn_ != NULL) {
    RunWithArg(0);
  } else {
    if (args_.empty()) {
      fprintf(stderr, "%s: no args!\n", name_);
      exit(EXIT_FAILURE);
    }
    for (size_t i = 0; i < args_.size(); ++i) {
      RunWithArg(args_[i]);
    }
  }
}

References args_, fn_, i, name_, and RunWithArg().

RunRepeatedlyWithArg()

void testing::Benchmark::RunRepeatedlyWithArg ( int  iterations, int  arg  )

private

                                                            {
  g_flops_processed = 0;
  g_benchmark_total_time_ns = 0;
  g_benchmark_start_time_ns = NanoTime();
  if (fn_ != NULL) {
    fn_(iterations);
  } else {
    fn_range_(iterations, arg);
  }
  if (g_benchmark_start_time_ns != 0) {
    g_benchmark_total_time_ns += NanoTime() - g_benchmark_start_time_ns;
  }
}

References fn_, fn_range_, g_benchmark_start_time_ns, g_benchmark_total_time_ns, g_flops_processed, and NanoTime().

Referenced by RunWithArg().

RunWithArg()

void testing::Benchmark::RunWithArg ( int  arg )

private

                                  {
  // run once in case it's expensive
  int iterations = 1;
  RunRepeatedlyWithArg(iterations, arg);
  while (g_benchmark_total_time_ns < 1e9 && iterations < 1e9) {
    int last = iterations;
    if (g_benchmark_total_time_ns / iterations == 0) {
      iterations = 1e9;
    } else {
      iterations = 1e9 / (g_benchmark_total_time_ns / iterations);
    }
    iterations = std::max(last + 1, std::min(iterations + iterations / 2, 100 * last));
    iterations = Round(iterations);
    RunRepeatedlyWithArg(iterations, arg);
  }
  char throughput[100];
  throughput[0] = '\0';
  if (g_benchmark_total_time_ns > 0 && g_flops_processed > 0) {
    double mflops_processed = static_cast<double>(g_flops_processed) / 1e6;
    double seconds = static_cast<double>(g_benchmark_total_time_ns) / 1e9;
    snprintf(throughput, sizeof(throughput), " %8.2f MFlops/s", mflops_processed / seconds);
  }
  char full_name[100];
  if (fn_range_ != NULL) {
    if (arg >= (1 << 20)) {
      snprintf(full_name, sizeof(full_name), "%s/%dM", name_, arg / (1 << 20));
    } else if (arg >= (1 << 10)) {
      snprintf(full_name, sizeof(full_name), "%s/%dK", name_, arg / (1 << 10));
    } else {
      snprintf(full_name, sizeof(full_name), "%s/%d", name_, arg);
    }
  } else {
    snprintf(full_name, sizeof(full_name), "%s", name_);
  }
  printf("%-*s %10d %10" PRId64 "%s\n", g_name_column_width, full_name, iterations,
         g_benchmark_total_time_ns / iterations, throughput);
  fflush(stdout);
}

References fn_range_, g_benchmark_total_time_ns, g_flops_processed, g_name_column_width, Eigen::placeholders::last, max, min, name_, Round(), RunRepeatedlyWithArg(), seconds(), and fix_broken_doxygen_formulae::stdout.

Referenced by Run().

ShouldRun()

bool testing::Benchmark::ShouldRun	(	int	argc,
		char *	argv[]
	)

                                                {
  if (argc == 1) {
    return true;  // With no arguments, we run all benchmarks.
  }
  // Otherwise, we interpret each argument as a regular expression and
  // see if any of our benchmarks match.
  for (int i = 1; i < argc; i++) {
    regex_t re;
    if (regcomp(&re, argv[i], 0) != 0) {
      fprintf(stderr, "couldn't compile \"%s\" as a regular expression!\n", argv[i]);
      exit(EXIT_FAILURE);
    }
    int match = regexec(&re, name_, 0, NULL, 0);
    regfree(&re);
    if (match != REG_NOMATCH) {
      return true;
    }
  }
  return false;
}

References i, match(), and name_.

Member Data Documentation

args_

std::vector<int> testing::Benchmark::args_

private

Referenced by Arg(), Range(), and Run().

fn_

void(* testing::Benchmark::fn_) (int)

private

Referenced by Register(), Run(), and RunRepeatedlyWithArg().

fn_range_

void(* testing::Benchmark::fn_range_) (int, int)

private

Referenced by Register(), RunRepeatedlyWithArg(), and RunWithArg().

name_

const char* testing::Benchmark::name_

private

Referenced by Name(), Register(), Run(), RunWithArg(), and ShouldRun().

---

The documentation for this class was generated from the following files:

• benchmark.h
• benchmark_main.cc