217 lines
7.1 KiB
C++
Executable file
217 lines
7.1 KiB
C++
Executable file
// Copyright 2015 Google Inc. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "timers.h"
|
|
#include "internal_macros.h"
|
|
|
|
#ifdef BENCHMARK_OS_WINDOWS
|
|
#include <Shlwapi.h>
|
|
#undef StrCat // Don't let StrCat in string_util.h be renamed to lstrcatA
|
|
#include <VersionHelpers.h>
|
|
#include <Windows.h>
|
|
#else
|
|
#include <fcntl.h>
|
|
#ifndef BENCHMARK_OS_FUCHSIA
|
|
#include <sys/resource.h>
|
|
#endif
|
|
#include <sys/time.h>
|
|
#include <sys/types.h> // this header must be included before 'sys/sysctl.h' to avoid compilation error on FreeBSD
|
|
#include <unistd.h>
|
|
#if defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX
|
|
#include <sys/sysctl.h>
|
|
#endif
|
|
#if defined(BENCHMARK_OS_MACOSX)
|
|
#include <mach/mach_init.h>
|
|
#include <mach/mach_port.h>
|
|
#include <mach/thread_act.h>
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef BENCHMARK_OS_EMSCRIPTEN
|
|
#include <emscripten.h>
|
|
#endif
|
|
|
|
#include <cerrno>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <ctime>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <mutex>
|
|
|
|
#include "check.h"
|
|
#include "log.h"
|
|
#include "sleep.h"
|
|
#include "string_util.h"
|
|
|
|
namespace benchmark {
|
|
|
|
// Suppress unused warnings on helper functions.
|
|
#if defined(__GNUC__)
|
|
#pragma GCC diagnostic ignored "-Wunused-function"
|
|
#endif
|
|
|
|
namespace {
|
|
#if defined(BENCHMARK_OS_WINDOWS)
|
|
double MakeTime(FILETIME const& kernel_time, FILETIME const& user_time) {
|
|
ULARGE_INTEGER kernel;
|
|
ULARGE_INTEGER user;
|
|
kernel.HighPart = kernel_time.dwHighDateTime;
|
|
kernel.LowPart = kernel_time.dwLowDateTime;
|
|
user.HighPart = user_time.dwHighDateTime;
|
|
user.LowPart = user_time.dwLowDateTime;
|
|
return (static_cast<double>(kernel.QuadPart) +
|
|
static_cast<double>(user.QuadPart)) *
|
|
1e-7;
|
|
}
|
|
#elif !defined(BENCHMARK_OS_FUCHSIA)
|
|
double MakeTime(struct rusage const& ru) {
|
|
return (static_cast<double>(ru.ru_utime.tv_sec) +
|
|
static_cast<double>(ru.ru_utime.tv_usec) * 1e-6 +
|
|
static_cast<double>(ru.ru_stime.tv_sec) +
|
|
static_cast<double>(ru.ru_stime.tv_usec) * 1e-6);
|
|
}
|
|
#endif
|
|
#if defined(BENCHMARK_OS_MACOSX)
|
|
double MakeTime(thread_basic_info_data_t const& info) {
|
|
return (static_cast<double>(info.user_time.seconds) +
|
|
static_cast<double>(info.user_time.microseconds) * 1e-6 +
|
|
static_cast<double>(info.system_time.seconds) +
|
|
static_cast<double>(info.system_time.microseconds) * 1e-6);
|
|
}
|
|
#endif
|
|
#if defined(CLOCK_PROCESS_CPUTIME_ID) || defined(CLOCK_THREAD_CPUTIME_ID)
|
|
double MakeTime(struct timespec const& ts) {
|
|
return ts.tv_sec + (static_cast<double>(ts.tv_nsec) * 1e-9);
|
|
}
|
|
#endif
|
|
|
|
BENCHMARK_NORETURN static void DiagnoseAndExit(const char* msg) {
|
|
std::cerr << "ERROR: " << msg << std::endl;
|
|
std::exit(EXIT_FAILURE);
|
|
}
|
|
|
|
} // end namespace
|
|
|
|
double ProcessCPUUsage() {
|
|
#if defined(BENCHMARK_OS_WINDOWS)
|
|
HANDLE proc = GetCurrentProcess();
|
|
FILETIME creation_time;
|
|
FILETIME exit_time;
|
|
FILETIME kernel_time;
|
|
FILETIME user_time;
|
|
if (GetProcessTimes(proc, &creation_time, &exit_time, &kernel_time,
|
|
&user_time))
|
|
return MakeTime(kernel_time, user_time);
|
|
DiagnoseAndExit("GetProccessTimes() failed");
|
|
#elif defined(BENCHMARK_OS_EMSCRIPTEN)
|
|
// clock_gettime(CLOCK_PROCESS_CPUTIME_ID, ...) returns 0 on Emscripten.
|
|
// Use Emscripten-specific API. Reported CPU time would be exactly the
|
|
// same as total time, but this is ok because there aren't long-latency
|
|
// syncronous system calls in Emscripten.
|
|
return emscripten_get_now() * 1e-3;
|
|
#elif defined(CLOCK_PROCESS_CPUTIME_ID) && !defined(BENCHMARK_OS_MACOSX)
|
|
// FIXME We want to use clock_gettime, but its not available in MacOS 10.11. See
|
|
// https://github.com/google/benchmark/pull/292
|
|
struct timespec spec;
|
|
if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &spec) == 0)
|
|
return MakeTime(spec);
|
|
DiagnoseAndExit("clock_gettime(CLOCK_PROCESS_CPUTIME_ID, ...) failed");
|
|
#else
|
|
struct rusage ru;
|
|
if (getrusage(RUSAGE_SELF, &ru) == 0) return MakeTime(ru);
|
|
DiagnoseAndExit("getrusage(RUSAGE_SELF, ...) failed");
|
|
#endif
|
|
}
|
|
|
|
double ThreadCPUUsage() {
|
|
#if defined(BENCHMARK_OS_WINDOWS)
|
|
HANDLE this_thread = GetCurrentThread();
|
|
FILETIME creation_time;
|
|
FILETIME exit_time;
|
|
FILETIME kernel_time;
|
|
FILETIME user_time;
|
|
GetThreadTimes(this_thread, &creation_time, &exit_time, &kernel_time,
|
|
&user_time);
|
|
return MakeTime(kernel_time, user_time);
|
|
#elif defined(BENCHMARK_OS_MACOSX)
|
|
// FIXME We want to use clock_gettime, but its not available in MacOS 10.11. See
|
|
// https://github.com/google/benchmark/pull/292
|
|
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
|
|
thread_basic_info_data_t info;
|
|
mach_port_t thread = pthread_mach_thread_np(pthread_self());
|
|
if (thread_info(thread, THREAD_BASIC_INFO, (thread_info_t)&info, &count) ==
|
|
KERN_SUCCESS) {
|
|
return MakeTime(info);
|
|
}
|
|
DiagnoseAndExit("ThreadCPUUsage() failed when evaluating thread_info");
|
|
#elif defined(BENCHMARK_OS_EMSCRIPTEN)
|
|
// Emscripten doesn't support traditional threads
|
|
return ProcessCPUUsage();
|
|
#elif defined(BENCHMARK_OS_RTEMS)
|
|
// RTEMS doesn't support CLOCK_THREAD_CPUTIME_ID. See
|
|
// https://github.com/RTEMS/rtems/blob/master/cpukit/posix/src/clockgettime.c
|
|
return ProcessCPUUsage();
|
|
#elif defined(BENCHMARK_OS_SOLARIS)
|
|
struct rusage ru;
|
|
if (getrusage(RUSAGE_LWP, &ru) == 0) return MakeTime(ru);
|
|
DiagnoseAndExit("getrusage(RUSAGE_LWP, ...) failed");
|
|
#elif defined(CLOCK_THREAD_CPUTIME_ID)
|
|
struct timespec ts;
|
|
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) == 0) return MakeTime(ts);
|
|
DiagnoseAndExit("clock_gettime(CLOCK_THREAD_CPUTIME_ID, ...) failed");
|
|
#else
|
|
#error Per-thread timing is not available on your system.
|
|
#endif
|
|
}
|
|
|
|
namespace {
|
|
|
|
std::string DateTimeString(bool local) {
|
|
typedef std::chrono::system_clock Clock;
|
|
std::time_t now = Clock::to_time_t(Clock::now());
|
|
const std::size_t kStorageSize = 128;
|
|
char storage[kStorageSize];
|
|
std::size_t written;
|
|
|
|
if (local) {
|
|
#if defined(BENCHMARK_OS_WINDOWS)
|
|
written =
|
|
std::strftime(storage, sizeof(storage), "%x %X", ::localtime(&now));
|
|
#else
|
|
std::tm timeinfo;
|
|
::localtime_r(&now, &timeinfo);
|
|
written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
|
|
#endif
|
|
} else {
|
|
#if defined(BENCHMARK_OS_WINDOWS)
|
|
written = std::strftime(storage, sizeof(storage), "%x %X", ::gmtime(&now));
|
|
#else
|
|
std::tm timeinfo;
|
|
::gmtime_r(&now, &timeinfo);
|
|
written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
|
|
#endif
|
|
}
|
|
CHECK(written < kStorageSize);
|
|
((void)written); // prevent unused variable in optimized mode.
|
|
return std::string(storage);
|
|
}
|
|
|
|
} // end namespace
|
|
|
|
std::string LocalDateTimeString() { return DateTimeString(true); }
|
|
|
|
} // end namespace benchmark
|