Using `0` as a null pointer is illegal when `-Wzero-as-null-pointer-constant`
is given to G++. To avoid the warning `zero-as-null-pointer-constant`,
`nullptr` (C++11 keyword) instead of `0` is used in the `sysctl` invocation.
When the library is created as a *.dll on Windows it is treated like a
runtime object so we must proivde the destination for the runtime
objects in our install command
For cross platform and cross compiler portability we use the
standard integer type for a 64-bit integer. MinGW on Windows doesn't
have the definition for `int64`.
We use the SHGetValueA on Windows to retrieve the MHz of the processor
but this requires the shlwapi library. Previous to this patch the
library was linked with a MSVC specific pragma but there is no
guarantee that on Windows we will be using MSVC. Therefore, it is much
compile agnostic to use the standard CMAKE library linking mechanism
to provide the definition of SHGetValueA
This patch adopts a new internal structure for how timings are performed.
Currently every iteration of a benchmark checks to see if it has been running
for an appropriate amount of time. Checking the clock introduces noise into
the timings and this can cause inconsistent output from each benchmark.
Now every iteration of a benchmark only checks an iteration count to see if it
should stop running. The iteration count is determined before hand by testing
the benchmark on a series of increasing iteration counts until a suitable count
is found. This increases the amount of time it takes to run the actual benchmarks
but it also greatly increases the accuracy of the results.
This patch introduces some breaking changes. The notable breaking changes are:
1. Benchmarks run on multiple threads no generate a report per thread. Instead
only a single report is generated.
2. ::benchmark::UseRealTime() was removed and replaced with State::UseRealTime().
Fixes#89
UseRealTime was defined in the internal namespace by mistake.
Similarly, documentation suggested that benchmark::SetLabel should be
used to set a label, and a function was declared but not defined, while
actually the call should be 'state.SetLabel'.
This patch does two things:
1. It overhalls the static initialization in Walltime to be simplier. It uses
a static variable inside WallTime::Now() to initialize the timer.
2. Add a logging mechanism so that the -v flag actually has meaning and
reimplement the CHECK macros to allow extra messages to be streamed in.
This patch cleans up our use of generic macros and also merges changes in the
build system.
It adds options -DBENCHMARK_ENABLE_TESTING and -DBENCHMARK_ENABLE_SHARED.
InitType should hold a lock before storing to approx_time_, which is later
read by the background worker. When the worker is actively running (i.e., not
blocked on bg_cond_) it holds bg_mutex_.
InitType is called during benchmark setup only, so any contention induced for
the mutex should not have performance/accuracy consequences.
The multithreaded API for benchmarks provides that teardown can happen in
thread 0. For this to be safe, all other threads executing the benchmark
function need to have exited. Otherwise, thread 0 may begin to teardown shared
resources before the other threads have stopped using these resources as they
are in their last loop of while (KeepRunning()) { ... }.
This change creates a single exit point for KeepRunning() to return false.
When running a multithreaded benchmark, thread 0 blocks on KeepRunning() until
all other threads have exited. This approach allows for there to be no change
to the user-facing API exemplified in the BM_MultiThreaded example.
