C言語のclock()でCPU時間を計測する方法

#include <stdio.h>
#include <time.h>

int main(void) {
    // 測定開始時刻(クロックティック)
    clock_t start = clock();
    if (start == (clock_t)-1) {
        // 値が取得できない場合の早期終了
        fprintf(stderr, "clock() failed at start\n");
        return 1;
    }

    // 計測対象: 単純な加算ループ(最適化で消されないようにvolatileを使う)
    volatile unsigned long long sink = 0; // 結果を外に出すことで最適化抑止
    for (unsigned long long i = 0; i < 100000000ULL; ++i) {
        sink += i; // 軽いCPU負荷
    }

    // 測定終了時刻(クロックティック)
    clock_t end = clock();
    if (end == (clock_t)-1) {
        fprintf(stderr, "clock() failed at end\n");
        return 1;
    }

    // 差分(ティック数)と秒への変換
    clock_t diff = end - start;
    double seconds = (double)diff / CLOCKS_PER_SEC;

    printf("CLOCKS_PER_SEC: %ld\n", (long)CLOCKS_PER_SEC);
    printf("ticks: %ld\n", (long)diff);
    printf("CPU time: %.6f s\n", seconds);
    // sink を参照して最適化をさらに抑止
    printf("sink: %llu\n", (unsigned long long)sink);
    return 0;
}

#include <stdio.h>
#include <time.h>

// 測定ユーティリティ: エラー処理付きclock()ラッパ
static int get_clock(clock_t* out) {
    clock_t t = clock();
    if (t == (clock_t)-1) return 0;
    *out = t;
    return 1;
}

int main(void) {
    volatile unsigned long long sink = 0;

    const unsigned long long N1 = 30000000ULL;  // 3千万回
    const unsigned long long N2 = 90000000ULL;  // 9千万回(3倍の負荷)

    // 測定1
    clock_t s1, e1;
    if (!get_clock(&s1)) return 1;
    for (unsigned long long i = 0; i < N1; ++i) sink += i;
    if (!get_clock(&e1)) return 1;

    // 測定2
    clock_t s2, e2;
    if (!get_clock(&s2)) return 1;
    for (unsigned long long i = 0; i < N2; ++i) sink += i;
    if (!get_clock(&e2)) return 1;

    double t1 = (double)(e1 - s1) / CLOCKS_PER_SEC;
    double t2 = (double)(e2 - s2) / CLOCKS_PER_SEC;

    printf("N1=%llu: CPU time = %.6f s\n", (unsigned long long)N1, t1);
    printf("N2=%llu: CPU time = %.6f s\n", (unsigned long long)N2, t2);
    printf("ratio(N2/N1) ≈ %.2f\n", (t2 > 0.0) ? (t2 / t1) : 0.0);
    printf("sink=%llu\n", (unsigned long long)sink);
    return 0;
}

#include <stdio.h>
#include <time.h>

static void busy_loop(volatile unsigned long long* sink, unsigned long long n) {
    for (unsigned long long i = 0; i < n; ++i) {
        *sink += i ^ (*sink); // 多少重い演算にする
    }
}

int main(void) {
    volatile unsigned long long sink = 0;
    clock_t total_ticks = 0;

    const unsigned long long N[] = { 20000000ULL, 25000000ULL, 30000000ULL };

    for (int k = 0; k < 3; ++k) {
        clock_t s = clock();
        if (s == (clock_t)-1) { fprintf(stderr, "clock() failed\n"); return 1; }

        busy_loop(&sink, N[k]);

        clock_t e = clock();
        if (e == (clock_t)-1) { fprintf(stderr, "clock() failed\n"); return 1; }

        clock_t diff = e - s;
        total_ticks += diff;

        printf("Section %d: ticks=%ld (%.6f s)\n",
               k + 1, (long)diff, (double)diff / CLOCKS_PER_SEC);
    }

    double total_sec = (double)total_ticks / CLOCKS_PER_SEC;
    printf("Total CPU time: %.6f s\n", total_sec);
    printf("sink=%llu\n", (unsigned long long)sink);
    return 0;
}

#include <stdio.h>
#include <time.h>

static double ticks_to_ms(clock_t ticks) {
    // ティック数からミリ秒に変換
    return 1000.0 * (double)ticks / CLOCKS_PER_SEC;
}

int main(void) {
    volatile unsigned long long sink = 0;

    clock_t s = clock();
    if (s == (clock_t)-1) { fprintf(stderr, "clock() failed\n"); return 1; }

    for (unsigned long long i = 0; i < 40000000ULL; ++i) {
        sink += i;
    }

    clock_t e = clock();
    if (e == (clock_t)-1) { fprintf(stderr, "clock() failed\n"); return 1; }

    clock_t diff = e - s;
    printf("CPU time: %.3f ms\n", ticks_to_ms(diff));
    printf("sink=%llu\n", (unsigned long long)sink);
    return 0;
}

#include <stdio.h>
#include <time.h>

// 計測対象の軽いワークロード(単純な整数演算)
// volatileを介して最適化で消えないようにする
static void workload(unsigned long long n) {
    volatile unsigned long long acc = 1;
    for (unsigned long long i = 1; i <= n; ++i) {
        acc = (acc * 1469598103934665603ULL) ^ i; // 適当な混合
    }
    // accはわざと使わない(volatileにより外部可視)
}

int main(void) {
    const unsigned long long N = 1000000ULL; // 1回分の仕事量
    size_t reps = 1;

    // 目標の最小計測時間(秒)。短いと分解能の影響が大きい
    const double target_seconds = 0.05; // 50ms

    double elapsed = 0.0;
    clock_t diff = 0;

    // 繰り返し回数を自動調整(最大は安全のため制限)
    while (reps < 1u << 26) {
        clock_t s = clock();
        if (s == (clock_t)-1) { fprintf(stderr, "clock() failed\n"); return 1; }

        for (size_t r = 0; r < reps; ++r) {
            workload(N);
        }

        clock_t e = clock();
        if (e == (clock_t)-1) { fprintf(stderr, "clock() failed\n"); return 1; }

        diff = e - s;
        elapsed = (double)diff / CLOCKS_PER_SEC;
        if (elapsed >= target_seconds) break;

        // 達しない場合は回数を倍増
        reps *= 2;
    }

    double per_rep_sec = (reps > 0) ? elapsed / (double)reps : 0.0;
    double per_rep_ms  = per_rep_sec * 1000.0;

    printf("CLOCKS_PER_SEC: %ld\n", (long)CLOCKS_PER_SEC);
    printf("reps: %zu, total CPU time: %.3f ms\n", reps, elapsed * 1000.0);
    printf("avg per iteration: %.6f ms\n", per_rep_ms);
    return 0;
}