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的值为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.019953ms

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.073ms（对于high_resolution_clock）和0.044ms（对于steady_clock），但所有后续运行都在0.019-0.025ms范围内。

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;

Answer 2

好吧，我希望使用GetTickCount（）似乎是解决方案

double start_s = GetTickCount();
for (int i = 0, temp = 0; i < 10000000; i++)
{
    if (i % 2 == 0)
    {
        temp = (i / 2) + 1;
    }
    else
    {
        temp = 2 * i;
    }
}
double stop_s = GetTickCount();
cout << (stop_s - start_s) / double(CLOCKS_PER_SEC) * 1000 << "ms taken" << endl;

对我来说，返回时间为16-31ms

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

2 个答案: