dolysis
/
benchmark
mirror of https://github.com/google/benchmark.git
3
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

benchmark_min_time now works as expected

This commit is contained in:
Dominic Hamon 2013-12-19 17:16:40 -08:00
parent a94b0a6741
commit b3f0d71e50
4 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/benchmark/benchmark.h
View File

@ -233,7 +233,6 @@ class State {
bool MaybeStop();
void NewInterval();
bool AllStarting();
bool RunAnotherInterval() const;
void Run();

83
src/benchmark.cc
View File

@ -29,11 +29,9 @@ DEFINE_string(benchmark_filter, ".",
"If this flag is the string \"all\", all benchmarks linked "
"into the process are run.");
DEFINE_int32(benchmark_min_iters, 100,
"Minimum number of iterations per benchmark");
DEFINE_int32(benchmark_max_iters, 1000000000,
"Maximum number of iterations per benchmark");
DEFINE_int32(benchmark_iterations, 0,
"Total number of iterations per benchmark. 0 means the benchmarks "
"are time-based.");
DEFINE_double(benchmark_min_time, 0.5,
"Minimum number of seconds we should run benchmark before "
@ -69,15 +67,13 @@ DECLARE_string(heap_check);
: NULL )
namespace benchmark {
namespace {
// kilo, Mega, Giga, Tera, Peta, Exa, Zetta, Yotta.
static const char kBigSIUnits[] = "kMGTPEZY";
const char kBigSIUnits[] = "kMGTPEZY";
// Kibi, Mebi, Gibi, Tebi, Pebi, Exbi, Zebi, Yobi.
static const char kBigIECUnits[] = "KMGTPEZY";
const char kBigIECUnits[] = "KMGTPEZY";
// milli, micro, nano, pico, femto, atto, zepto, yocto.
static const char kSmallSIUnits[] = "munpfazy";
const char kSmallSIUnits[] = "munpfazy";
// We require that all three arrays have the same size.
static_assert(arraysize(kBigSIUnits) == arraysize(kBigIECUnits),
@ -427,9 +423,8 @@ void UseRealTime() {
void PrintUsageAndExit() {
fprintf(stdout, "benchmark [--benchmark_filter=<regex>]\n"
// TODO " [--benchmark_min_iters=<min_iters>]\n"
// TODO " [--benchmark_max_iters=<max_iters>]\n"
// TODO " [--benchmark_min_time=<min_time>]\n"
// TODO " [--benchmark_iterations=<iterations>]\n"
" [--benchmark_min_time=<min_time>]\n"
// " [--benchmark_memory_usage]\n"
// TODO " [--benchmark_repetitions=<num_repetitions>]\n"
" [--color_print={true|false}]\n"
@ -441,16 +436,16 @@ void ParseCommandLineFlags(int* argc, const char** argv) {
for (int i = 1; i < *argc; ++i) {
if (ParseStringFlag(argv[i], "benchmark_filter",
&FLAGS_benchmark_filter) ||
/* TODO(dominic)
ParseInt32Flag(argv[i], "benchmark_min_iters",
&FLAGS_benchmark_min_iters) ||
ParseInt32Flag(argv[i], "benchmark_max_iters",
&FLAGS_benchmark_max_iters) ||
/* TODO
ParseInt32Flag(argv[i], "benchmark_iterations",
&FLAGS_benchmark_iterations) ||
*/
ParseDoubleFlag(argv[i], "benchmark_min_time",
&FLAGS_benchmark_min_time) ||
// TODO(dominic)
// ParseBoolFlag(argv[i], "gbenchmark_memory_usage",
// &FLAGS_gbenchmark_memory_usage) ||
/*
ParseInt32Flag(argv[i], "benchmark_repetitions",
&FLAGS_benchmark_repetitions) ||
*/
@ -504,7 +499,7 @@ class State::FastClock {
t = MyCPUUsage() + ChildrenCPUUsage();
break;
}
return static_cast<int64_t>(t * 1e6);
return static_cast<int64_t>(t * kNumMicrosPerSecond);
}
// Reinitialize if necessary (since clock type may be change once benchmark
@ -577,6 +572,10 @@ struct State::SharedState {
SharedState(const internal::Benchmark::Instance* b, int t)
: instance(b), starting(0), stopping(0), threads(t) {
pthread_mutex_init(&mu, nullptr);
}
~SharedState() {
pthread_mutex_destroy(&mu);
}
DISALLOW_COPY_AND_ASSIGN(SharedState);
};
@ -907,13 +906,17 @@ State::State(FastClock* clock, SharedState* s, int t)
pause_time_(0.0),
total_iterations_(0),
interval_micros_(
static_cast<int64_t>(1e6 * FLAGS_benchmark_min_time /
static_cast<int64_t>(kNumMicrosPerSecond * FLAGS_benchmark_min_time /
FLAGS_benchmark_repetitions)) {
CHECK(clock != nullptr);
CHECK(s != nullptr);
}
bool State::KeepRunning() {
// Fast path
if (!clock_->HasReached(stop_time_micros_ + pause_time_)) {
if ((FLAGS_benchmark_iterations == 0 &&
!clock_->HasReached(stop_time_micros_ + pause_time_)) ||
iterations_ < FLAGS_benchmark_iterations) {
++iterations_;
return true;
}
@ -1029,12 +1032,12 @@ void State::NewInterval() {
}
bool State::FinishInterval() {
if (iterations_ < FLAGS_benchmark_min_iters / FLAGS_benchmark_repetitions &&
interval_micros_ < 5000000) {
if (FLAGS_benchmark_iterations != 0 &&
iterations_ < FLAGS_benchmark_iterations / FLAGS_benchmark_repetitions) {
interval_micros_ *= 2;
#ifdef DEBUG
std::cout << "Interval was too short; trying again for "
<< interval_micros_ << " useconds.\n";
std::cout << "Not enough iterations in interval; "
<< "Trying again for " << interval_micros_ << " useconds.\n";
#endif
is_continuation_ = false;
NewInterval();
@ -1058,11 +1061,25 @@ bool State::FinishInterval() {
bool keep_going = false;
{
mutex_lock l(&shared_->mu);
// Either replace the last or add a new data point.
if (is_continuation_)
shared_->runs.back() = data;
else
shared_->runs.push_back(data);
keep_going = RunAnotherInterval();
if (FLAGS_benchmark_iterations != 0) {
// If we need more iterations, run another interval as a continuation.
keep_going = total_iterations_ < FLAGS_benchmark_iterations;
is_continuation_ = keep_going;
} else {
// If this is a repetition, run another interval as a new data point.
keep_going =
shared_->runs.size() <
static_cast<size_t>(FLAGS_benchmark_repetitions);
is_continuation_ = !keep_going;
}
if (!keep_going) {
++shared_->stopping;
if (shared_->stopping < shared_->threads) {
@ -1076,23 +1093,11 @@ bool State::FinishInterval() {
}
}
if (state_ == STATE_RUNNING) {
is_continuation_ = true;
if (state_ == STATE_RUNNING)
NewInterval();
}
return keep_going;
}
bool State::RunAnotherInterval() const {
if (total_iterations_ < FLAGS_benchmark_min_iters)
return true;
if (total_iterations_ > FLAGS_benchmark_max_iters)
return false;
if (static_cast<int>(shared_->runs.size()) >= FLAGS_benchmark_repetitions)
return false;
return true;
}
bool State::MaybeStop() {
mutex_lock l(&shared_->mu);
if (shared_->stopping < shared_->threads) {

11
src/sleep.cc
View File

@ -5,22 +5,14 @@
namespace benchmark {
#ifdef OS_WINDOWS
// Window's _sleep takes milliseconds argument.
void SleepForMilliseconds(int milliseconds) {
_sleep(milliseconds);
}
void SleepForSeconds(double seconds) {
SleepForMilliseconds(static_cast<int>(seconds * 1000));
SleepForMilliseconds(static_cast<int>(kNumMillisPerSecond * seconds));
}
#else // OS_WINDOWS
static const int64_t kNumMillisPerSecond = 1000LL;
static const int64_t kNumMicrosPerMilli = 1000LL;
static const int64_t kNumMicrosPerSecond = kNumMillisPerSecond * 1000LL;
static const int64_t kNumNanosPerMicro = 1000LL;
void SleepForMicroseconds(int64_t microseconds) {
struct timespec sleep_time;
sleep_time.tv_sec = microseconds / kNumMicrosPerSecond;
@ -36,7 +28,6 @@ void SleepForMilliseconds(int milliseconds) {
void SleepForSeconds(double seconds) {
SleepForMicroseconds(static_cast<int64_t>(seconds * kNumMicrosPerSecond));
}
#endif // OS_WINDOWS
} // end namespace benchmark

5
src/sleep.h
View File

@ -4,6 +4,11 @@
#include <stdint.h>
namespace benchmark {
const int64_t kNumMillisPerSecond = 1000LL;
const int64_t kNumMicrosPerMilli = 1000LL;
const int64_t kNumMicrosPerSecond = kNumMillisPerSecond * 1000LL;
const int64_t kNumNanosPerMicro = 1000LL;
void SleepForMicroseconds(int64_t microseconds);
void SleepForMilliseconds(int milliseconds);
void SleepForSeconds(double seconds);