Inside Bitcoin

2001            throw std::runtime_error("unknown list '" + std::string(n.begin, n.end) + "'");
2002
2003        case templates::Node::Type::section:
2004            if (n == "result") {
2005                const size_t nbResults = results.size();
2006                for (size_t i = 0; i < nbResults; ++i) {
2007                    generateResult(n.children, i, results, out);
2008                }
2009            } else if (n == "measurement") {
2010                if (results.size() != 1) {
2011                    throw std::runtime_error(
2012                        "render: can only use section 'measurement' here if there is a single result, but there are " +
2013                        detail::fmt::to_s(results.size()));
2014                }
2015                // when we only have a single result, we can immediately go into its measurement.
2016                auto const& r = results.front();
2017                for (size_t i = 0; i < r.size(); ++i) {
2018                    generateResultMeasurement(n.children, i, r, out);
2019                }
2020            } else {
2021                throw std::runtime_error("render: unknown section '" + std::string(n.begin, n.end) + "'");
2022            }
2023            break;
2024
2025        case templates::Node::Type::tag:
2026            if (results.size() == 1) {
2027                // result & config are both supported there
2028                generateResultTag(n, results.front(), out);
2029            } else {
2030                // This just uses the last result's config.
2031                if (!generateConfigTag(n, results.back().config(), out)) {
2032                    throw std::runtime_error("unknown tag '" + std::string(n.begin, n.end) + "'");
2033                }
2034            }
2035            break;
2036        }
2037    }
2038}
2039
2040void render(std::string const& mustacheTemplate, std::vector<Result> const& results, std::ostream& out) {
2041    render(mustacheTemplate.c_str(), results, out);
2042}
2043
2044void render(char const* mustacheTemplate, const Bench& bench, std::ostream& out) {
2045    render(mustacheTemplate, bench.results(), out);
2046}
2047
2048void render(std::string const& mustacheTemplate, const Bench& bench, std::ostream& out) {
2049    render(mustacheTemplate.c_str(), bench.results(), out);
2050}
2051
2052namespace detail {
2053
2054PerformanceCounters& performanceCounters() {
2055#    if defined(__clang__)
2056#        pragma clang diagnostic push
2057#        pragma clang diagnostic ignored "-Wexit-time-destructors"
2058#    endif
2059    static PerformanceCounters pc;
2060#    if defined(__clang__)
2061#        pragma clang diagnostic pop
2062#    endif
2063    return pc;
2064}
2065
2066// Windows version of doNotOptimizeAway
2067// see https://github.com/google/benchmark/blob/v1.7.1/include/benchmark/benchmark.h#L514
2068// see https://github.com/facebook/folly/blob/v2023.01.30.00/folly/lang/Hint-inl.h#L54-L58
2069// see https://learn.microsoft.com/en-us/cpp/preprocessor/optimize
2070#    if defined(_MSC_VER)
2071#        pragma optimize("", off)
2072void doNotOptimizeAwaySink(void const*) {}
2073#        pragma optimize("", on)
2074#    endif
2075
2076template <typename T>
2077T parseFile(std::string const& filename, bool* fail) {
2078    std::ifstream fin(filename); // NOLINT(misc-const-correctness)
2079    T num{};
2080    fin >> num;
2081    if (fail != nullptr) {
2082        *fail = fin.fail();
2083    }
2084    return num;
2085}
2086
2087char const* getEnv(char const* name) {
2088#    if defined(_MSC_VER)
2089#        pragma warning(push)
2090#        pragma warning(disable : 4996) // getenv': This function or variable may be unsafe.
2091#    endif
2092    return std::getenv(name); // NOLINT(concurrency-mt-unsafe)
2093#    if defined(_MSC_VER)
2094#        pragma warning(pop)
2095#    endif
2096}
2097
2098bool isEndlessRunning(std::string const& name) {
2099    auto const* const endless = getEnv("NANOBENCH_ENDLESS");
2100    return nullptr != endless && endless == name;
2101}
2102
2103// True when environment variable NANOBENCH_SUPPRESS_WARNINGS is either not set at all, or set to "0"
2104bool isWarningsEnabled() {
2105    auto const* const suppression = getEnv("NANOBENCH_SUPPRESS_WARNINGS");
2106    return nullptr == suppression || suppression == std::string("0");
2107}
2108
2109void gatherStabilityInformation(std::vector<std::string>& warnings, std::vector<std::string>& recommendations) {
2110    warnings.clear();
2111    recommendations.clear();
2112
2113#    if defined(DEBUG)
2114    warnings.emplace_back("DEBUG defined");
2115    bool const recommendCheckFlags = true;
2116#    else
2117    bool const recommendCheckFlags = false;
2118#    endif
2119
2120    bool recommendPyPerf = false;
2121#    if defined(__linux__)
2122    auto nprocs = sysconf(_SC_NPROCESSORS_CONF);
2123    if (nprocs <= 0) {
2124        warnings.emplace_back("couldn't figure out number of processors - no governor, turbo check possible");
2125    } else {
2126        // check frequency scaling
2127        for (long id = 0; id < nprocs; ++id) {
2128            auto idStr = detail::fmt::to_s(static_cast<uint64_t>(id));
2129            auto sysCpu = "/sys/devices/system/cpu/cpu" + idStr;
2130            auto minFreq = parseFile<int64_t>(sysCpu + "/cpufreq/scaling_min_freq", nullptr);
2131            auto maxFreq = parseFile<int64_t>(sysCpu + "/cpufreq/scaling_max_freq", nullptr);
2132            if (minFreq != maxFreq) {
2133                auto minMHz = d(minFreq) / 1000.0;
2134                auto maxMHz = d(maxFreq) / 1000.0;
2135                warnings.emplace_back("CPU frequency scaling enabled: CPU " + idStr + " between " +
2136                                      detail::fmt::Number(1, 1, minMHz).to_s() + " and " + detail::fmt::Number(1, 1, maxMHz).to_s() +
2137                                      " MHz");
2138                recommendPyPerf = true;
2139                break;
2140            }
2141        }
2142
2143        auto fail = false;
2144        auto currentGovernor = parseFile<std::string>("/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor", &fail);
2145        if (!fail && "performance" != currentGovernor) {
2146            warnings.emplace_back("CPU governor is '" + currentGovernor + "' but should be 'performance'");
2147            recommendPyPerf = true;
2148        }
2149
2150        auto noTurbo = parseFile<int>("/sys/devices/system/cpu/intel_pstate/no_turbo", &fail);
2151        if (!fail && noTurbo == 0) {
2152            warnings.emplace_back("Turbo is enabled, CPU frequency will fluctuate");
2153            recommendPyPerf = true;
2154        }
2155    }
2156#    endif
2157
2158    if (recommendCheckFlags) {
2159        recommendations.emplace_back("Make sure you compile for Release");
2160    }
2161    if (recommendPyPerf) {
2162        recommendations.emplace_back("Use 'pyperf system tune' before benchmarking. See https://github.com/psf/pyperf");
2163    }
2164}
2165
2166void printStabilityInformationOnce(std::ostream* outStream) {
2167    static bool shouldPrint = true;
2168    if (shouldPrint && (nullptr != outStream) && isWarningsEnabled()) {
2169        auto& os = *outStream;
2170        shouldPrint = false;
2171        std::vector<std::string> warnings;
2172        std::vector<std::string> recommendations;
2173        gatherStabilityInformation(warnings, recommendations);
2174        if (warnings.empty()) {
2175            return;
2176        }
2177
2178        os << "Warning, results might be unstable:" << std::endl;
2179        for (auto const& w : warnings) {
2180            os << "* " << w << std::endl;
2181        }
2182
2183        os << std::endl << "Recommendations" << std::endl;
2184        for (auto const& r : recommendations) {
2185            os << "* " << r << std::endl;
2186        }
2187    }
2188}
2189
2190// remembers the last table settings used. When it changes, a new table header is automatically written for the new entry.
2191uint64_t& singletonHeaderHash() noexcept {
2192    static uint64_t sHeaderHash{};
2193    return sHeaderHash;
2194}
2195
2196ANKERL_NANOBENCH_NO_SANITIZE("integer", "undefined")
2197inline uint64_t hash_combine(uint64_t seed, uint64_t val) {
2198    return seed ^ (val + UINT64_C(0x9e3779b9) + (seed << 6U) + (seed >> 2U));
2199}
2200
2201// determines resolution of the given clock. This is done by measuring multiple times and returning the minimum time difference.
2202Clock::duration calcClockResolution(size_t numEvaluations) noexcept {
2203    auto bestDuration = Clock::duration::max();
2204    Clock::time_point tBegin;
2205    Clock::time_point tEnd;
2206    for (size_t i = 0; i < numEvaluations; ++i) {
2207        tBegin = Clock::now();
2208        do {
2209            tEnd = Clock::now();
2210        } while (tBegin == tEnd);
2211        bestDuration = (std::min)(bestDuration, tEnd - tBegin);
2212    }
2213    return bestDuration;
2214}
2215
2216// Calculates clock resolution once, and remembers the result
2217Clock::duration clockResolution() noexcept {
2218    static Clock::duration const sResolution = calcClockResolution(20);
2219    return sResolution;
2220}
2221
2222ANKERL_NANOBENCH(IGNORE_PADDED_PUSH)
2223struct IterationLogic::Impl {
2224    enum class State { warmup, upscaling_runtime, measuring, endless };
2225
2226    explicit Impl(Bench const& bench)
2227        : mBench(bench)
2228        , mResult(bench.config()) {
2229        printStabilityInformationOnce(mBench.output());
2230
2231        // determine target runtime per epoch
2232        mTargetRuntimePerEpoch = detail::clockResolution() * mBench.clockResolutionMultiple();
2233        if (mTargetRuntimePerEpoch > mBench.maxEpochTime()) {
2234            mTargetRuntimePerEpoch = mBench.maxEpochTime();
2235        }
2236        if (mTargetRuntimePerEpoch < mBench.minEpochTime()) {
2237            mTargetRuntimePerEpoch = mBench.minEpochTime();
2238        }
2239
2240        if (isEndlessRunning(mBench.name())) {
2241            std::cerr << "NANOBENCH_ENDLESS set: running '" << mBench.name() << "' endlessly" << std::endl;
2242            mNumIters = (std::numeric_limits<uint64_t>::max)();
2243            mState = State::endless;
2244        } else if (0 != mBench.warmup()) {
2245            mNumIters = mBench.warmup();
2246            mState = State::warmup;
2247        } else if (0 != mBench.epochIterations()) {
2248            // exact number of iterations
2249            mNumIters = mBench.epochIterations();
2250            mState = State::measuring;