Question

我正在并行运行几个线程。我想测量执行一个线程所需的时间以及执行整个程序所需的时间。我在Windows 7上使用VC ++。

我尝试在调试时测量它但后来我看到了这个问题：https://stackoverflow.com/questions/38971267/improving-performance-using-parallelism-in-c?noredirect=1#comment65299718_38971267并且在Schnien给出的答案中说：

while

这是真的吗？如果是，我怎么能以其他方式衡量时间

由于

Answer 1

该声明确实如此，只有遇到断点的线程才会被暂停。

但是，要测量执行时间，您根本不必使用调试。有关测量执行时间的更多信息，请参见以下问题：

Measure execution time in C (on Windows)

你想要做的是衡量线程内部的时间＆＃39;函数（通过减去函数开头和结尾的时间）。您可以对程序执行相同的操作，您可以使用thread.join确保所有线程执行在最后一次测量时间之前结束。

Answer 2

使用简单的计时器类创建秒表功能，然后捕获每个线程中的时间。此外，创建系统线程比使用std::async慢，后者可以返回值并传播异常，使用线程导致程序终止，除非在线程中捕获。

#include <thread>
#include <iostream>
#include <atomic>
#include <chrono>
#include <future>

// stopwatch. Returns time in seconds
class timer {
public:
    std::chrono::time_point<std::chrono::high_resolution_clock> lastTime;
    timer() : lastTime(std::chrono::high_resolution_clock::now()) {}
    inline double elapsed() {
        std::chrono::time_point<std::chrono::high_resolution_clock> thisTime=std::chrono::high_resolution_clock::now();
        double deltaTime = std::chrono::duration<double>(thisTime-lastTime).count();
        lastTime = thisTime;
        return deltaTime;
    }
};

// for exposition clarity, generally avoid global varaibles.
const int count = 1000000;

double timerResult1;
double timerResult2;

void f1() {
    volatile int i = 0; // volatile eliminates optimization removal
    timer stopwatch;
    while (i++ < count);
    timerResult1=stopwatch.elapsed();
}
void f2() {
    volatile int i = 0; // volatile eliminates optimization removal
    timer stopwatch;
    while (i++ < count);
    timerResult2=stopwatch.elapsed();
}

int main()
{
    std::cout.precision(6); std::cout << std::fixed;
    f1(); std::cout << "f1 execution time " << timerResult1 << std::endl;
    timer stopwatch;
    {
        std::thread thread1(f1);
        std::thread thread2(f2);
        thread1.join();
        thread2.join();
    }
    double elapsed = stopwatch.elapsed();
    std::cout << "f1 with f2 execution time " << elapsed << std::endl;
    std::cout << "thread f1 execution time " << timerResult1 << std::endl;
    std::cout << "thread f1 execution time " << timerResult2 << std::endl;
    {
        stopwatch.elapsed();    // reset stopwatch
        auto future1 = std::async(std::launch::async, f1); // spins a thread and descturctor automatically joins
        auto future2 = std::async(std::launch::async, f2);
    }
    elapsed = stopwatch.elapsed();
    std::cout << "async f1 with f2 execution time " <<  elapsed << std::endl;
    std::cout << "async thread f1 execution time " << timerResult1 << std::endl;
    std::cout << "async thread f1 execution time " << timerResult2 << std::endl;
}

在我的机器上创建线程每个线程增加大约0.3毫秒，而异步每个线程只有大约0.05毫秒，因为它是用线程池实现的。

f1 execution time 0.002076
f1 with f2 execution time 0.002791
thread f1 execution time 0.002018
thread f1 execution time 0.002035
async f1 with f2 execution time 0.002131
async thread f1 execution time 0.002028
async thread f1 execution time 0.002018

[编辑]在陈述前面有不正确的f调用（剪切和过去的错误）

如何衡量一个线程的执行时间？

2 个答案: