mirror of
https://github.com/google/benchmark.git
synced 2025-03-05 06:40:09 +08:00
Merge branch 'master' into remove-check
This commit is contained in:
commit
e0441ef5d0
@ -44,7 +44,8 @@ static void BM_memcpy(benchmark::State& state) {
|
||||
memset(src, 'x', state.range_x());
|
||||
while (state.KeepRunning())
|
||||
memcpy(dst, src, state.range_x());
|
||||
state.SetBytesProcessed(int64_t(state.iterations) * int64_t(state.range_x()));
|
||||
state.SetBytesProcessed(int64_t(state.iterations()) *
|
||||
int64_t(state.range_x()));
|
||||
delete[] src;
|
||||
delete[] dst;
|
||||
}
|
||||
|
@ -42,7 +42,8 @@ static void BM_memcpy(benchmark::State& state) {
|
||||
memset(src, 'x', state.range_x());
|
||||
while (state.KeepRunning())
|
||||
memcpy(dst, src, state.range_x());
|
||||
state.SetBytesProcessed(int64_t_t(state.iterations) * int64(state.range_x()));
|
||||
state.SetBytesProcessed(int64_t(state.iterations()) *
|
||||
int64_t(state.range_x()));
|
||||
delete[] src; delete[] dst;
|
||||
}
|
||||
BENCHMARK(BM_memcpy)->Arg(8)->Arg(64)->Arg(512)->Arg(1<<10)->Arg(8<<10);
|
||||
@ -89,8 +90,7 @@ BENCHMARK(BM_SetInsert)->RangePair(1<<10, 8<<10, 1, 512);
|
||||
static void CustomArguments(benchmark::internal::Benchmark* b) {
|
||||
for (int i = 0; i <= 10; ++i)
|
||||
for (int j = 32; j <= 1024*1024; j *= 8)
|
||||
b = b->ArgPair(i, j);
|
||||
return b;
|
||||
b->ArgPair(i, j);
|
||||
}
|
||||
BENCHMARK(BM_SetInsert)->Apply(CustomArguments);
|
||||
|
||||
@ -151,7 +151,7 @@ BENCHMARK(BM_MultiThreaded)->Threads(4);
|
||||
namespace benchmark {
|
||||
class BenchmarkReporter;
|
||||
|
||||
void Initialize(int* argc, const char** argv);
|
||||
void Initialize(int* argc, char** argv);
|
||||
|
||||
// Otherwise, run all benchmarks specified by the --benchmark_filter flag,
|
||||
// and exit after running the benchmarks.
|
||||
@ -593,10 +593,10 @@ protected: \
|
||||
|
||||
|
||||
// Helper macro to create a main routine in a test that runs the benchmarks
|
||||
#define BENCHMARK_MAIN() \
|
||||
int main(int argc, const char** argv) { \
|
||||
::benchmark::Initialize(&argc, argv); \
|
||||
::benchmark::RunSpecifiedBenchmarks(); \
|
||||
#define BENCHMARK_MAIN() \
|
||||
int main(int argc, char** argv) { \
|
||||
::benchmark::Initialize(&argc, argv); \
|
||||
::benchmark::RunSpecifiedBenchmarks(); \
|
||||
}
|
||||
|
||||
#endif // BENCHMARK_BENCHMARK_API_H_
|
||||
|
@ -27,12 +27,16 @@
|
||||
#if defined(__GNUC__)
|
||||
# define BENCHMARK_UNUSED __attribute__((unused))
|
||||
# define BENCHMARK_ALWAYS_INLINE __attribute__((always_inline))
|
||||
# define BENCHMARK_NOEXCEPT noexcept
|
||||
#elif defined(_MSC_VER) && !defined(__clang__)
|
||||
# define BENCHMARK_UNUSED
|
||||
# define BENCHMARK_ALWAYS_INLINE __forceinline
|
||||
# define BENCHMARK_NOEXCEPT
|
||||
# define __func__ __FUNCTION__
|
||||
#else
|
||||
# define BENCHMARK_UNUSED
|
||||
# define BENCHMARK_ALWAYS_INLINE
|
||||
# define BENCHMARK_NOEXCEPT
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__)
|
||||
|
@ -49,7 +49,7 @@ class BenchmarkReporter {
|
||||
|
||||
std::string benchmark_name;
|
||||
std::string report_label; // Empty if not set by benchmark.
|
||||
size_t iterations;
|
||||
int64_t iterations;
|
||||
double real_accumulated_time;
|
||||
double cpu_accumulated_time;
|
||||
|
||||
|
@ -15,11 +15,11 @@
|
||||
#include "benchmark/benchmark.h"
|
||||
#include "internal_macros.h"
|
||||
|
||||
#include <sys/time.h>
|
||||
#ifndef OS_WINDOWS
|
||||
#include <sys/time.h>
|
||||
#include <sys/resource.h>
|
||||
#endif
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
@ -863,7 +863,7 @@ void PrintUsageAndExit() {
|
||||
exit(0);
|
||||
}
|
||||
|
||||
void ParseCommandLineFlags(int* argc, const char** argv) {
|
||||
void ParseCommandLineFlags(int* argc, char** argv) {
|
||||
using namespace benchmark;
|
||||
for (int i = 1; i < *argc; ++i) {
|
||||
if (
|
||||
@ -904,7 +904,7 @@ Benchmark* RegisterBenchmarkInternal(Benchmark* bench) {
|
||||
|
||||
} // end namespace internal
|
||||
|
||||
void Initialize(int* argc, const char** argv) {
|
||||
void Initialize(int* argc, char** argv) {
|
||||
internal::ParseCommandLineFlags(argc, argv);
|
||||
internal::SetLogLevel(FLAGS_v);
|
||||
// TODO remove this. It prints some output the first time it is called.
|
||||
|
@ -40,7 +40,10 @@
|
||||
extern "C" uint64_t __rdtsc();
|
||||
#pragma intrinsic(__rdtsc)
|
||||
#endif
|
||||
|
||||
#ifndef OS_WINDOWS
|
||||
#include <sys/time.h>
|
||||
#endif
|
||||
|
||||
namespace benchmark {
|
||||
// NOTE: only i386 and x86_64 have been well tested.
|
||||
|
@ -44,12 +44,6 @@ std::string FormatKV(std::string const& key, int64_t value) {
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string FormatKV(std::string const& key, std::size_t value) {
|
||||
std::stringstream ss;
|
||||
ss << '"' << key << "\": " << value;
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
int64_t RoundDouble(double v) {
|
||||
return static_cast<int64_t>(v + 0.5);
|
||||
}
|
||||
|
@ -33,7 +33,7 @@ void BenchmarkReporter::ComputeStats(
|
||||
Stat1_d items_per_second_stat;
|
||||
// All repetitions should be run with the same number of iterations so we
|
||||
// can take this information from the first benchmark.
|
||||
std::size_t const run_iterations = reports.front().iterations;
|
||||
int64_t const run_iterations = reports.front().iterations;
|
||||
|
||||
// Populate the accumulators.
|
||||
for (Run const& run : reports) {
|
||||
|
@ -4,6 +4,7 @@
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <utility>
|
||||
#include "internal_macros.h"
|
||||
|
||||
namespace benchmark {
|
||||
|
||||
@ -14,7 +15,7 @@ std::string HumanReadableNumber(double n);
|
||||
std::string StringPrintF(const char* format, ...);
|
||||
|
||||
inline std::ostream&
|
||||
StringCatImp(std::ostream& out) noexcept
|
||||
StringCatImp(std::ostream& out) BENCHMARK_NOEXCEPT
|
||||
{
|
||||
return out;
|
||||
}
|
||||
|
@ -305,7 +305,7 @@ static double MyCPUUsageRUsage() {
|
||||
user.HighPart = user_time.dwHighDateTime;
|
||||
user.LowPart = user_time.dwLowDateTime;
|
||||
return (static_cast<double>(kernel.QuadPart) +
|
||||
static_cast<double>(user.QuadPart)) / 1.0E-7;
|
||||
static_cast<double>(user.QuadPart)) * 1e-7;
|
||||
#endif // OS_WINDOWS
|
||||
}
|
||||
|
||||
@ -394,6 +394,7 @@ int NumCPUs(void) {
|
||||
: nullptr)
|
||||
|
||||
bool CpuScalingEnabled() {
|
||||
#ifndef OS_WINDOWS
|
||||
// On Linux, the CPUfreq subsystem exposes CPU information as files on the
|
||||
// local file system. If reading the exported files fails, then we may not be
|
||||
// running on Linux, so we silently ignore all the read errors.
|
||||
@ -407,6 +408,7 @@ bool CpuScalingEnabled() {
|
||||
fclose(file);
|
||||
if (memprefix(buff, bytes_read, "performance") == nullptr) return true;
|
||||
}
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -12,9 +12,16 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "benchmark/macros.h"
|
||||
#include "internal_macros.h"
|
||||
#include "walltime.h"
|
||||
|
||||
#if defined(OS_WINDOWS)
|
||||
#include <time.h>
|
||||
#include <winsock.h> // for timeval
|
||||
#else
|
||||
#include <sys/time.h>
|
||||
#endif
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdint>
|
||||
@ -50,7 +57,7 @@ struct ChooseSteadyClock<false> {
|
||||
|
||||
struct ChooseClockType {
|
||||
#if defined(HAVE_STEADY_CLOCK)
|
||||
typedef typename ChooseSteadyClock<>::type type;
|
||||
typedef ChooseSteadyClock<>::type type;
|
||||
#else
|
||||
typedef std::chrono::high_resolution_clock type;
|
||||
#endif
|
||||
@ -86,7 +93,22 @@ private:
|
||||
|
||||
WallTime Slow() const {
|
||||
struct timeval tv;
|
||||
#if defined(OS_WINDOWS)
|
||||
FILETIME file_time;
|
||||
SYSTEMTIME system_time;
|
||||
ULARGE_INTEGER ularge;
|
||||
const unsigned __int64 epoch = 116444736000000000LL;
|
||||
|
||||
GetSystemTime(&system_time);
|
||||
SystemTimeToFileTime(&system_time, &file_time);
|
||||
ularge.LowPart = file_time.dwLowDateTime;
|
||||
ularge.HighPart = file_time.dwHighDateTime;
|
||||
|
||||
tv.tv_sec = (long)((ularge.QuadPart - epoch) / (10L * 1000 * 1000));
|
||||
tv.tv_usec = (long)(system_time.wMilliseconds * 1000);
|
||||
#else
|
||||
gettimeofday(&tv, nullptr);
|
||||
#endif
|
||||
return tv.tv_sec + tv.tv_usec * 1e-6;
|
||||
}
|
||||
|
||||
@ -94,8 +116,6 @@ private:
|
||||
static_assert(sizeof(float) <= sizeof(int32_t),
|
||||
"type sizes don't allow the drift_adjust hack");
|
||||
|
||||
static constexpr double kMaxErrorInterval = 100e-6;
|
||||
|
||||
WallTime base_walltime_;
|
||||
int64_t base_cycletime_;
|
||||
int64_t cycles_per_second_;
|
||||
@ -141,6 +161,7 @@ WallTimeImp::WallTimeImp()
|
||||
cycles_per_second_(0), seconds_per_cycle_(0.0),
|
||||
last_adjust_time_(0), drift_adjust_(0),
|
||||
max_interval_cycles_(0) {
|
||||
const double kMaxErrorInterval = 100e-6;
|
||||
cycles_per_second_ = static_cast<int64_t>(CyclesPerSecond());
|
||||
CHECK(cycles_per_second_ != 0);
|
||||
seconds_per_cycle_ = 1.0 / cycles_per_second_;
|
||||
@ -207,15 +228,27 @@ std::string DateTimeString(bool local) {
|
||||
typedef std::chrono::system_clock Clock;
|
||||
std::time_t now = Clock::to_time_t(Clock::now());
|
||||
char storage[128];
|
||||
std::size_t written;
|
||||
|
||||
std::tm timeinfo;
|
||||
std::memset(&timeinfo, 0, sizeof(std::tm));
|
||||
if (local) {
|
||||
localtime_r(&now, &timeinfo);
|
||||
#if defined(OS_WINDOWS)
|
||||
written = std::strftime(storage, sizeof(storage), "%x %X", ::localtime(&now));
|
||||
#else
|
||||
std::tm timeinfo;
|
||||
std::memset(&timeinfo, 0, sizeof(std::tm));
|
||||
::localtime_r(&now, &timeinfo);
|
||||
written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
|
||||
#endif
|
||||
} else {
|
||||
gmtime_r(&now, &timeinfo);
|
||||
#if defined(OS_WINDOWS)
|
||||
written = std::strftime(storage, sizeof(storage), "%x %X", ::gmtime(&now));
|
||||
#else
|
||||
std::tm timeinfo;
|
||||
std::memset(&timeinfo, 0, sizeof(std::tm));
|
||||
::gmtime_r(&now, &timeinfo);
|
||||
written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
|
||||
#endif
|
||||
}
|
||||
std::size_t written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
|
||||
CHECK(written < arraysize(storage));
|
||||
((void)written); // prevent unused variable in optimized mode.
|
||||
return std::string(storage);
|
||||
|
@ -67,7 +67,7 @@ BENCHMARK(BM_FooBa);
|
||||
|
||||
|
||||
|
||||
int main(int argc, const char* argv[]) {
|
||||
int main(int argc, char* argv[]) {
|
||||
benchmark::Initialize(&argc, argv);
|
||||
|
||||
TestReporter test_reporter;
|
||||
@ -82,4 +82,3 @@ int main(int argc, const char* argv[]) {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -15,4 +15,12 @@ BENCHMARK(BM_basic)->UseRealTime();
|
||||
BENCHMARK(BM_basic)->ThreadRange(2, 4);
|
||||
BENCHMARK(BM_basic)->ThreadPerCpu();
|
||||
|
||||
void CustomArgs(benchmark::internal::Benchmark* b) {
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
b->Arg(i);
|
||||
}
|
||||
}
|
||||
|
||||
BENCHMARK(BM_basic)->Apply(CustomArgs);
|
||||
|
||||
BENCHMARK_MAIN()
|
||||
|
Loading…
Reference in New Issue
Block a user