C++性能测试工具

使用示例main.cpp

// g++-13  -O3  -std=c++17  main.cpp  profile.cpp
#include <iostream>
#include <chrono>
#include <stdint.h>
#include <mutex>       // std::mutex#include "profile.h"
#include "profile_rdtsc.h"std::mutex mutex;uint64_t getTimeHighResolutionClock() {return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock().now().time_since_epoch()).count();
}void batchMeasureClockOverhead(){constexpr int kLoops = 1000;uint64_t t1 = rdtsc();for (int i = 0; i < kLoops; ++i) {getTimeHighResolutionClock();}uint64_t t2 = rdtsc();std::cout << "Batch test, std::chrono::high_resolution_clock() takes " << (t2 - t1) / kLoops << " cycles on average.\n";
}PROFILE_REGISTER(single_measure_clock_overhead);
void singleMeasureClockOverhead(){PROFILE_CHECK(single_measure_clock_overhead);getTimeHighResolutionClock();
}int main() {std::cout << "===Begin of main!===\n";getTimeHighResolutionClock();   // warm upbatchMeasureClockOverhead();constexpr int kLoops = 1000;for (int i = 0; i < kLoops; ++i) {// 这里加锁保护，在多线程中使用此工具需更加注意std::lock_guard guard{mutex};singleMeasureClockOverhead();}std::cout << "===End of main!===\n";
}

profile.h

#ifndef PROFILER_PROFILE_H
#define PROFILER_PROFILE_H#include <iostream>
#include <vector>
#include <set>
#include <string>
#include <string_view>
#include <format>
#include <assert.h>#include "profile_rdtsc.h"#define PF_DEBUG  // open performance test or notnamespace pf {struct ProfileInfo {int id_;int call_count_;uint64_t call_duration_;std::string func_name_;};class Profile {private:Profile() {
#ifdef PF_DEBUGconstexpr int kTimes = 16;for (int i = 0; i < kTimes; ++i) {uint64_t begin = rdtsc_benchmark_begin();uint64_t end = rdtsc_benchmark_end();if (overhead_ > end - begin) {overhead_ = end - begin;   // maybe not the smallest}}
#endif//std::cout << "Profile ctor called.\n";}~Profile() {
#ifdef PF_DEBUGstd::cout << "---> Performance details begin: <---\n";std::cout << "Attention, overhead is " << overhead_<< " cycles, and it is removed from average duration.\n";for (const auto &item: info_) {if (!item.call_count_) {continue;}double average = static_cast<double>(item.call_duration_) / static_cast<double>(item.call_count_) -static_cast<double>(overhead_);if (average < 0) {average = 0.0;  // time cost is smaller than overhead_, because the overhead_ is not accuracy.}std::cout << "[" << item.func_name_ << ", called " << item.call_count_ << " times, total duration cycle is "<< item.call_duration_ << ", average duration cycle is " << average << ".]" << std::endl;}std::cout << "---> Performance details end. <---\n";
#endif}Profile(const Profile &) = delete;Profile &operator=(const Profile &) = delete;public:static Profile &getInstance();void addInfo(int id, uint64_t duration) {assert(id >= 0 && id < static_cast<int>(info_.size()));++info_[id].call_count_;info_[id].call_duration_ += duration;}int registerFunc(const std::string_view func_name) {auto [iter, success] = func_name_.insert(std::string(func_name));assert(success && "One function can only be registered once!");int func_id = static_cast<int>(info_.size());info_.push_back({func_id, 0, 0, *iter});return func_id;}private:std::set<std::string> func_name_;std::vector<ProfileInfo> info_;uint64_t overhead_{~0UL};};class ProfilingChecker {public:ProfilingChecker(int id) : id_(id), start_time_(rdtsc_benchmark_begin()) {//std::cout << "ProfilingChecker ctor called.\n";}~ProfilingChecker() {uint64_t end_time = rdtsc_benchmark_end();uint64_t duration = end_time - start_time_;Profile::getInstance().addInfo(id_, duration);//std::cout << "ProfilingChecker dtor called.\n";}ProfilingChecker(const ProfilingChecker &) = delete;ProfilingChecker &operator=(const ProfilingChecker &) = delete;private:int id_;uint64_t start_time_;};int doProfileRegister(const std::string_view func_name);#ifdef PF_DEBUG
#define PROFILE_REGISTER(func) static const int _pf_id_##func = pf::doProfileRegister(#func);
#define PROFILE_CHECK(func) pf::ProfilingChecker _checker(_pf_id_##func);
#else#define PROFILE_REGISTER(func)
#define PROFILE_CHECK(func)
#endif#ifdef _MSC_VER
#define PROFILE_NOINLINE __declspec(noinline)
#else
#define PROFILE_NOINLINE __attribute__((noinline))
#endif
}#endif //PROFILER_PROFILE_H

profile.cpp

#include "profile.h"
#include <iostream>namespace pf {Profile &Profile::getInstance() {static Profile instance;return instance;}int doProfileRegister(const std::string_view func_name){return Profile::getInstance().registerFunc(func_name);}
}

profile_rdtsc.h


#ifndef PROFILE_PROFILE_RDTSC_H
#define PROFILE_PROFILE_RDTSC_H#include <stdint.h>         // uint64_t#ifndef HAS_HW_RDTSC
#if defined(_M_X64) || defined(_M_IX86) || defined(__x86_64) || defined(__i386)
#define HAS_HW_RDTSC 1
#else
#define HAS_HW_RDTSC 0
#endif
#endif#if HAS_HW_RDTSC
#ifdef _WIN32
#include <intrin.h>        // __rdtsc/_mm_lfence/_mm_mfence
#elif __has_include(<x86intrin.h>)
#include <x86intrin.h>     // __rdtsc/_mm_lfence/_mm_mfence
#endif
#else
#include <chrono>          // std::chrono::steady_clock/nanoseconds
#endif// Macro to forbid the compiler from reordering instructions
#ifdef _MSC_VER
#define RDTSC_MEM_BARRIER() _ReadWriteBarrier()
#else
#define RDTSC_MEM_BARRIER() __asm__ __volatile__("" : : : "memory")
#endifinline uint64_t rdtsc()
{RDTSC_MEM_BARRIER();#if HAS_HW_RDTSCuint64_t result = __rdtsc();
#elseuint64_t result = std::chrono::steady_clock::now().time_since_epoch() /std::chrono::nanoseconds(1);//uint64_t result = std::chrono::high_resolution_clock::now().time_since_epoch() ///                  std::chrono::nanoseconds(1);
#endifRDTSC_MEM_BARRIER();return result;
}#if HAS_HW_RDTSCinline uint64_t rdtsc_benchmark_begin()
{// memory fence, according to x86 architecture，保障开始测试之前让CPU将之前未执行完的指令执行完_mm_mfence();_mm_lfence();uint64_t result = __rdtsc();RDTSC_MEM_BARRIER();return result;
}inline uint64_t rdtsc_benchmark_end()
{_mm_lfence();uint64_t result = __rdtsc();RDTSC_MEM_BARRIER();return result;
}#elseinline uint64_t rdtsc_benchmark_begin()
{return rdtsc();
}inline uint64_t rdtsc_benchmark_end()
{return rdtsc();
}#endif#endif //PROFILE_PROFILE_RDTSC_H