• Home
  • History
  • Annotate
  • Raw
  • Download

Lines Matching +full:method +full:- +full:complexity

7 //     http://www.apache.org/licenses/LICENSE-2.0
37 // via the --benchmarks command line flag. E.g.,
38 // my_unittest --benchmark_filter=all
39 // my_unittest --benchmark_filter=BM_StringCreation
40 // my_unittest --benchmark_filter=String
41 // my_unittest --benchmark_filter='Copy|Creation'
62 BENCHMARK(BM_memcpy)->Arg(8)->Arg(64)->Arg(512)->Arg(1<<10)->Arg(8<<10);
65 // following short-hand. The following invocation will pick a few
68 BENCHMARK(BM_memcpy)->Range(8, 8<<10);
84 ->Args({1<<10, 128})
85 ->Args({2<<10, 128})
86 ->Args({4<<10, 128})
87 ->Args({8<<10, 128})
88 ->Args({1<<10, 512})
89 ->Args({2<<10, 512})
90 ->Args({4<<10, 512})
91 ->Args({8<<10, 512});
94 // the following short-hand. The following macro will pick a few
97 BENCHMARK(BM_SetInsert)->Ranges({{1<<10, 8<<10}, {128, 512}});
107 b->Args({i, j});
109 BENCHMARK(BM_SetInsert)->Apply(CustomArguments);
118 for (int i = state.range(0); i--; )
120 for (int e = state.range(0); e--; )
126 BENCHMARK_TEMPLATE(BM_Sequential, WaitQueue<int>)->Range(1<<0, 1<<10);
134 BENCHMARK(BM_test)->MinTime(2.0); // Run for at least 2 seconds.
152 BENCHMARK(BM_MultiThreaded)->Threads(4);
159 BENCHMARK(BM_test)->Unit(benchmark::kMillisecond);
265 // Generate a list of benchmarks matching the specified --benchmark_filter flag
266 // and if --benchmark_list_tests is specified return after printing the name
273 // by '--benchmark_output'. If '--benchmark_output' is not given the
345 // FIXME Add ClobberMemory() for non-gnu and non-msvc compilers
348 // This class is used for user-defined counters.
356 // Mark the counter as a thread-average quantity. It will be
359 // Mark the counter as a thread-average rate. See above.
368 // Mark the counter as a iteration-average quantity.
371 // Mark the counter as a iteration-average rate. See above.
405 // This is the container for the user-defined counters.
414 // complexity for the benchmark. In case oAuto is selected, complexity will be
421 // computational complexity for the benchmark.
449 // The mode is user-specified.
450 // This may or may not be set when the following bit-flags are set.
471 // C++11 ranged-based for loop. These functions should not be called directly.
505 // NOTE: The "real time" measurement is per-thread. If different threads
529 // If the ranged-for style of benchmark loop is used, the user must explicitly
575 // If this routine is called with complexity_n > 0 and complexity report is
620 this->SetLabel(str.c_str()); in SetLabel()
641 return max_iterations - total_iterations_ + batch_leftover_; in iterations()
669 // Container for user-defined counters.
708 total_iterations_ -= n; in KeepRunningInternal()
714 total_iterations_ -= n; in KeepRunningInternal()
718 // For non-batch runs, total_iterations_ must be 0 by now. in KeepRunningInternal()
720 batch_leftover_ = n - total_iterations_; in KeepRunningInternal()
743 : cached_(st->error_occurred_ ? 0 : st->max_iterations), parent_(st) {} in StateIterator()
752 --cached_;
759 parent_->FinishKeepRunning();
780 // ------------------------------------------------------
784 // Each method returns "this" so that multiple method calls can
791 // method calls can be chained together in one expression.
858 // Set the range multiplier for non-dense range. If not called, the range
872 // `--benchmark_min_time=N` or `MinTime(...)` should be used instead.
897 // total CPU usage of the benchmark), call this method. If called, the elapsed
905 // measured), call this method. If called, each benchmark iteration should
912 // Set the asymptotic computational complexity for the benchmark. If called
913 // the asymptotic computational complexity will be shown on the output.
914 Benchmark* Complexity(BigO complexity = benchmark::oAuto);
916 // Set the asymptotic computational complexity for the benchmark. If called
917 // the asymptotic computational complexity will be shown on the output.
918 Benchmark* Complexity(BigOFunc* complexity);
935 // BENCHMARK(Foo)->ThreadRange(1,16);
1074 this->SetUp(st); in Run()
1075 this->BenchmarkCase(st); in Run()
1076 this->TearDown(st); in Run()
1092 // ------------------------------------------------------
1110 #define BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method) \ argument
1111 BaseClass##_##Method##_Benchmark
1122 // Old-style macros
1123 #define BENCHMARK_WITH_ARG(n, a) BENCHMARK(n)->Arg((a))
1124 #define BENCHMARK_WITH_ARG2(n, a1, a2) BENCHMARK(n)->Args({(a1), (a2)})
1125 #define BENCHMARK_WITH_UNIT(n, t) BENCHMARK(n)->Unit((t))
1126 #define BENCHMARK_RANGE(n, lo, hi) BENCHMARK(n)->Range((lo), (hi))
1128 BENCHMARK(n)->RangePair({{(l1), (h1)}, {(l2), (h2)}})
1181 #define BENCHMARK_PRIVATE_DECLARE_F(BaseClass, Method) \ argument
1182 class BaseClass##_##Method##_Benchmark : public BaseClass { \
1184 BaseClass##_##Method##_Benchmark() : BaseClass() { \
1185 this->SetName(#BaseClass "/" #Method); \
1192 #define BENCHMARK_TEMPLATE1_PRIVATE_DECLARE_F(BaseClass, Method, a) \ argument
1193 class BaseClass##_##Method##_Benchmark : public BaseClass<a> { \
1195 BaseClass##_##Method##_Benchmark() : BaseClass<a>() { \
1196 this->SetName(#BaseClass "<" #a ">/" #Method); \
1203 #define BENCHMARK_TEMPLATE2_PRIVATE_DECLARE_F(BaseClass, Method, a, b) \ argument
1204 class BaseClass##_##Method##_Benchmark : public BaseClass<a, b> { \
1206 BaseClass##_##Method##_Benchmark() : BaseClass<a, b>() { \
1207 this->SetName(#BaseClass "<" #a "," #b ">/" #Method); \
1215 #define BENCHMARK_TEMPLATE_PRIVATE_DECLARE_F(BaseClass, Method, ...) \ argument
1216 class BaseClass##_##Method##_Benchmark : public BaseClass<__VA_ARGS__> { \
1218 BaseClass##_##Method##_Benchmark() : BaseClass<__VA_ARGS__>() { \
1219 this->SetName(#BaseClass "<" #__VA_ARGS__ ">/" #Method); \
1230 #define BENCHMARK_DEFINE_F(BaseClass, Method) \ argument
1231 BENCHMARK_PRIVATE_DECLARE_F(BaseClass, Method) \
1232 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1234 #define BENCHMARK_TEMPLATE1_DEFINE_F(BaseClass, Method, a) \ argument
1235 BENCHMARK_TEMPLATE1_PRIVATE_DECLARE_F(BaseClass, Method, a) \
1236 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1238 #define BENCHMARK_TEMPLATE2_DEFINE_F(BaseClass, Method, a, b) \ argument
1239 BENCHMARK_TEMPLATE2_PRIVATE_DECLARE_F(BaseClass, Method, a, b) \
1240 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1243 #define BENCHMARK_TEMPLATE_DEFINE_F(BaseClass, Method, ...) \ argument
1244 BENCHMARK_TEMPLATE_PRIVATE_DECLARE_F(BaseClass, Method, __VA_ARGS__) \
1245 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1247 #define BENCHMARK_TEMPLATE_DEFINE_F(BaseClass, Method, a) \ argument
1248 BENCHMARK_TEMPLATE1_DEFINE_F(BaseClass, Method, a)
1251 #define BENCHMARK_REGISTER_F(BaseClass, Method) \ argument
1252 BENCHMARK_PRIVATE_REGISTER_F(BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method))
1259 #define BENCHMARK_F(BaseClass, Method) \ argument
1260 BENCHMARK_PRIVATE_DECLARE_F(BaseClass, Method) \
1261 BENCHMARK_REGISTER_F(BaseClass, Method); \
1262 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1264 #define BENCHMARK_TEMPLATE1_F(BaseClass, Method, a) \ argument
1265 BENCHMARK_TEMPLATE1_PRIVATE_DECLARE_F(BaseClass, Method, a) \
1266 BENCHMARK_REGISTER_F(BaseClass, Method); \
1267 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1269 #define BENCHMARK_TEMPLATE2_F(BaseClass, Method, a, b) \ argument
1270 BENCHMARK_TEMPLATE2_PRIVATE_DECLARE_F(BaseClass, Method, a, b) \
1271 BENCHMARK_REGISTER_F(BaseClass, Method); \
1272 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1275 #define BENCHMARK_TEMPLATE_F(BaseClass, Method, ...) \ argument
1276 BENCHMARK_TEMPLATE_PRIVATE_DECLARE_F(BaseClass, Method, __VA_ARGS__) \
1277 BENCHMARK_REGISTER_F(BaseClass, Method); \
1278 void BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method)::BenchmarkCase
1280 #define BENCHMARK_TEMPLATE_F(BaseClass, Method, a) \ argument
1281 BENCHMARK_TEMPLATE1_F(BaseClass, Method, a)
1293 // ------------------------------------------------------
1347 // Return the full name of the benchmark with each non-empty
1369 static const int64_t no_repetition_index = -1;
1381 complexity(oNone), in Run()
1422 // Keep track of arguments to compute asymptotic complexity
1423 BigO complexity; member
1430 // Inform print function whether the current run is a complexity report
1455 // cpu-time and heap memory usage during the benchmark run. If the group
1460 // complexity and RMS of that benchmark family.
1489 // REQUIRES: 'out' is non-null.