C++ inline 指定がパフォーマンスに与える影響を MSVC で検証する

#pragma once

#define _CRT_SECURE_NO_WARNINGS

#include <chrono>
#include <cstdio>
#include <string>
#include <vector>

struct BenchResult {
    std::string config;
    std::string function;
    std::string inline_type;
    std::string call_type;
    int iterations;
    double time_ms;
};

// RUN_BENCH: direct call macro (avoids function pointer to preserve inlining)
// - Warmup: 1,000,000 iterations
// - Measurement: `iters` iterations
// - volatile sink prevents dead-code elimination
#define RUN_BENCH(results, cfg, func, itype, ctype, iters, call_expr) \
    do {                                                              \
        volatile int sink = 0;                                        \
        for (int i = 0; i < 1000000; ++i) {                           \
            sink += (call_expr);                                      \
        }                                                             \
        auto start = std::chrono::high_resolution_clock::now();       \
        sink = 0;                                                     \
        for (int i = 0; i < (iters); ++i) {                           \
            sink += (call_expr);                                      \
        }                                                             \
        auto end = std::chrono::high_resolution_clock::now();         \
        double ms = std::chrono::duration<double, std::milli>(        \
            end - start).count();                                     \
        BenchResult r;                                                \
        r.config = (cfg);                                             \
        r.function = (func);                                          \
        r.inline_type = (itype);                                      \
        r.call_type = (ctype);                                        \
        r.iterations = (iters);                                       \
        r.time_ms = ms;                                               \
        (results).push_back(r);                                       \
    } while (0)

inline void write_csv(const std::vector<BenchResult>& results,
                      const std::string& filename) {
    FILE* fp = fopen(filename.c_str(), "w");
    if (!fp) return;
    fprintf(fp, "config,function,inline_type,call_type,iterations,time_ms\n");
    for (const auto& r : results) {
        fprintf(fp, "%s,%s,%s,%s,%d,%.3f\n",
                r.config.c_str(), r.function.c_str(),
                r.inline_type.c_str(), r.call_type.c_str(),
                r.iterations, r.time_ms);
    }
    fclose(fp);
}

inline void print_results(const std::vector<BenchResult>& results) {
    printf("%-14s %-24s %-14s %-10s %12s %10s\n",
           "config", "function", "inline_type", "call_type",
           "iterations", "time_ms");
    printf("----------------------------------------------------"
           "-------------------------------------------\n");
    for (const auto& r : results) {
        printf("%-14s %-24s %-14s %-10s %12d %10.3f\n",
               r.config.c_str(), r.function.c_str(),
               r.inline_type.c_str(), r.call_type.c_str(),
               r.iterations, r.time_ms);
    }
}

int main() {
    std::vector<BenchResult> results;
    const char* cfg = BENCH_CONFIG;

    const int ADD_ITERS   = 100000000; // 1 億回
    const int CLAMP_ITERS = 100000000; // 1 億回
    const int HEAVY_ITERS =  10000000; // 1,000 万回

    // --- same-TU: add ---
    RUN_BENCH(results, cfg, "add_plain",  "plain",        "same_tu", ADD_ITERS,
              add_plain_same_tu(i, i + 1));
    RUN_BENCH(results, cfg, "add_inline", "inline",       "same_tu", ADD_ITERS,
              add_inlined_same_tu(i, i + 1));
    RUN_BENCH(results, cfg, "add_forced", "__forceinline", "same_tu", ADD_ITERS,
              add_forced_same_tu(i, i + 1));

    // --- same-TU: clamp ---
    RUN_BENCH(results, cfg, "clamp_plain",  "plain",        "same_tu", CLAMP_ITERS,
              clamp_plain_same_tu(i, 0, 1000));
    RUN_BENCH(results, cfg, "clamp_inline", "inline",       "same_tu", CLAMP_ITERS,
              clamp_inlined_same_tu(i, 0, 1000));
    RUN_BENCH(results, cfg, "clamp_forced", "__forceinline", "same_tu", CLAMP_ITERS,
              clamp_forced_same_tu(i, 0, 1000));

    // --- same-TU: heavy ---
    RUN_BENCH(results, cfg, "heavy_plain",  "plain",        "same_tu", HEAVY_ITERS,
              heavy_plain_same_tu(i % 50 + 1));
    RUN_BENCH(results, cfg, "heavy_inline", "inline",       "same_tu", HEAVY_ITERS,
              heavy_inlined_same_tu(i % 50 + 1));
    RUN_BENCH(results, cfg, "heavy_forced", "__forceinline", "same_tu", HEAVY_ITERS,
              heavy_forced_same_tu(i % 50 + 1));

    // --- cross-TU ---
    RUN_BENCH(results, cfg, "add_plain",   "plain", "cross_tu", ADD_ITERS,
              add_plain_cross_tu(i, i + 1));
    RUN_BENCH(results, cfg, "clamp_plain", "plain", "cross_tu", CLAMP_ITERS,
              clamp_plain_cross_tu(i, 0, 1000));
    RUN_BENCH(results, cfg, "heavy_plain", "plain", "cross_tu", HEAVY_ITERS,
              heavy_plain_cross_tu(i % 50 + 1));

    // --- Output ---
    print_results(results);

    std::string csv_name = std::string("results_") + cfg + ".csv";
    write_csv(results, csv_name);
    printf("\nResults written to %s\n", csv_name.c_str());

    return 0;
}