c++ - 确定执行循环所需的 CPU 时间

Question

我做了一些 SO 搜索并找到了 this和 that概述计时方法。

我的问题是我需要确定执行以下循环所需的 CPU 时间(以毫秒为单位):

for (int i = 0, temp = 0; i < 10000; i++)
{
    if (i % 2 == 0)
    {
        temp = (i / 2) + 1;
    }
    else
    {
        temp = 2 * i;
    }
}

我看过两种方法，clock()和 stead_clock::now() .根据 docs ，我知道 clock()返回“滴答声”，因此我可以通过使用 CLOCKS_PER_SEC 除以差值在几秒钟内得到它. docs还要提到 steady_clock专为间隔计时而设计，但您必须调用duration_cast<milliseconds>更改其单位。

我为两者计时所做的事情(因为在同一次运行中同时进行两者可能会导致一个花费更长的时间，因为另一个被首先调用)是单独运行它们:

clock_t t = clock();
for (int i = 0, temp = 0; i < 10000; i++)
{
    if (i % 2 == 0)
    {
        temp = (i / 2) + 1;
    }
    else
    {
        temp = 2 * i;
    }
}
t = clock() - t;
cout << (float(t)/CLOCKS_PER_SEC) * 1000 << "ms taken" << endl;

chrono::steady_clock::time_point p1 = chrono::steady_clock::now();
for (int i = 0, temp = 0; i < 10000; i++)
{
    if (i % 2 == 0)
    {
        temp = (i / 2) + 1;
    }
    else
    {
        temp = 2 * i;
    }
}
chrono::steady_clock::time_point p2 = chrono::steady_clock::now();
cout << chrono::duration_cast<milliseconds>(p2-p1).count() << "ms taken" << endl;

输出:

0ms taken
0ms taken

这两种方法都能降低结果吗？肯定发生了一些毫秒分形？

那么对于确定执行循环所需的 CPU 时间来说，哪个是理想的(或者更合适的)？乍一看，我会赞成 clock()因为文档明确告诉我它用于确定 CPU 时间。

对于上下文，我的 CLOCKS_PER_SEC持有值(value) 1000 .

编辑/更新:

尝试了以下方法:

clock_t t = clock();
for (int j = 0; j < 1000000; j++) {
    volatile int temp = 0;
    for (int i = 0; i < 10000; i++)
    {
        if (i % 2 == 0)
        {
            temp = (i / 2) + 1;
        }
        else
        {
            temp = 2 * i;
        }
    }
}
t = clock() - t;
cout << (float(t) * 1000.0f / CLOCKS_PER_SEC / 1000000.0f) << "ms taken" << endl;

输出:0.019953 毫秒

clock_t start = clock();
volatile int temp = 0;
for (int i = 0; i < 10000; i++)
{
    if (i % 2 == 0)
    {
        temp = (i / 2) + 1;
    }
    else
    {
        temp = 2 * i;
    }
}
clock_t end = clock();
cout << fixed << setprecision(2) << 1000.0 * (end - start) / CLOCKS_PER_SEC << "ms taken" << endl;

输出:0.00 毫秒

chrono::high_resolution_clock::time_point p1 = chrono::high_resolution_clock::now();
volatile int temp = 0;
for (int i = 0; i < 10000; i++)
{
    if (i % 2 == 0)
    {
        temp = (i / 2) + 1;
    }
    else
    {
        temp = 2 * i;
    }
}
chrono::high_resolution_clock::time_point p2 = chrono::high_resolution_clock::now();
cout << (chrono::duration_cast<chrono::microseconds>(p2 - p1).count()) / 1000.0 << "ms taken" << endl;

输出:耗时 0.072 毫秒

chrono::steady_clock::time_point p1 = chrono::steady_clock::now();
volatile int temp = 0;
for (int i = 0; i < 10000; i++)
{
    if (i % 2 == 0)
    {
        temp = (i / 2) + 1;
    }
    else
    {
        temp = 2 * i;
    }
}
chrono::steady_clock::time_point p2 = chrono::steady_clock::now();
cout << (chrono::duration_cast<chrono::microseconds>(p2 - p1).count()) / 1000.0f << "ms taken" << endl;

输出:0.044ms

那么问题就变成了，哪个有效？第二种方法对我来说似乎无效，因为我认为循环完成的速度超过一毫秒。

我理解第一种方法(只是执行时间更长)，但后两种方法产生截然不同的结果。

我注意到的一件事是，在编译程序后，我第一次运行它时，一开始我可能会得到 0.073 毫秒(对于 high_resolution_clock )和 0.044 毫秒(对于 steady_clock )，但所有后续运行时间在 0.019 - 0.025 毫秒范围内。

Answer 1

你可以循环一百万次，然后除法。您还可以添加 volatile 关键字以避免某些编译器优化。

clock_t t = clock();
for (int j = 0, j < 1000000; j++) {
    volatile int temp = 0;
    for (int i = 0; i < 10000; i++)
    {
        if (i % 2 == 0)
        {
            temp = (i / 2) + 1;
        }
        else
        {
            temp = 2 * i;
        }
    }
}
t = clock() - t;
cout << (float(t) * 1000.0f / CLOCKS_PER_SEC / 1000000.0f) << "ms taken" << endl;