Đo thời gian thực hiện của một chức năng trong C ++

Tôi muốn tìm hiểu xem một chức năng nhất định mất bao nhiêu thời gian trong chương trình C ++ của tôi để thực thi trên Linux . Sau đó, tôi muốn làm một so sánh tốc độ. Tôi đã thấy một số chức năng thời gian nhưng kết thúc với điều này từ boost. Biên niên sử:

process_user_cpu_clock, captures user-CPU time spent by the current process

Bây giờ, tôi không rõ nếu tôi sử dụng chức năng trên, tôi sẽ có được thời gian duy nhất mà CPU dành cho chức năng đó không?

Thứ hai, tôi không thể tìm thấy bất kỳ ví dụ về việc sử dụng chức năng trên. Có ai có thể giúp tôi làm thế nào để sử dụng các chức năng trên?

PS: Hiện tại, tôi đang sử dụng std::chrono::system_clock::now()để có thời gian tính bằng giây nhưng điều này mang lại cho tôi kết quả khác nhau do tải CPU khác nhau mỗi lần.

Đây là một phương pháp rất dễ sử dụng trong C ++ 11. Bạn phải sử dụng std::chrono::high_resolution_clocktừ <chrono>tiêu đề.

Sử dụng nó như vậy:

#include <iostream>
#include <chrono>

void function()
{
    long long number = 0;

    for( long long i = 0; i != 2000000; ++i )
    {
       number += 5;
    }
}

int main()
{
    auto t1 = std::chrono::high_resolution_clock::now();
    function();
    auto t2 = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::microseconds>( t2 - t1 ).count();

    std::cout << duration;
    return 0;
}

Điều này sẽ đo thời gian của chức năng.

LƯU Ý: Bạn sẽ không luôn luôn có cùng thời gian cho một chức năng. Điều này là do CPU của máy của bạn có thể được sử dụng ít hơn hoặc nhiều hơn bởi các quá trình khác đang chạy trên máy tính của bạn, giống như tâm trí của bạn có thể tập trung ít nhiều khi bạn giải bài tập toán. Trong tâm trí con người, chúng ta có thể nhớ giải pháp của một vấn đề toán học, nhưng đối với một máy tính, quy trình tương tự sẽ luôn là một điều gì đó mới mẻ; do đó, như tôi đã nói, bạn sẽ không luôn nhận được kết quả tương tự!

Đây là một hàm sẽ đo thời gian thực hiện của bất kỳ hàm nào được truyền dưới dạng đối số:

#include <chrono>
#include <utility>

typedef std::chrono::high_resolution_clock::time_point TimeVar;

#define duration(a) std::chrono::duration_cast<std::chrono::nanoseconds>(a).count()
#define timeNow() std::chrono::high_resolution_clock::now()

template<typename F, typename... Args>
double funcTime(F func, Args&&... args){
    TimeVar t1=timeNow();
    func(std::forward<Args>(args)...);
    return duration(timeNow()-t1);
}

Ví dụ sử dụng:

#include <iostream>
#include <algorithm>

typedef std::string String;

//first test function doing something
int countCharInString(String s, char delim){
    int count=0;
    String::size_type pos = s.find_first_of(delim);
    while ((pos = s.find_first_of(delim, pos)) != String::npos){
        count++;pos++;
    }
    return count;
}

//second test function doing the same thing in different way
int countWithAlgorithm(String s, char delim){
    return std::count(s.begin(),s.end(),delim);
}


int main(){
    std::cout<<"norm: "<<funcTime(countCharInString,"precision=10",'=')<<"\n";
    std::cout<<"algo: "<<funcTime(countWithAlgorithm,"precision=10",'=');
    return 0;
}

Đầu ra:

norm: 15555
algo: 2976

chương trình đơn giản để tìm một thời gian thực hiện chức năng thực hiện.

#include <iostream>
#include <ctime> // time_t
#include <cstdio>

void function()
{
     for(long int i=0;i<1000000000;i++)
     {
        // do nothing
     }
}

int main()
{

time_t begin,end; // time_t is a datatype to store time values.

time (&begin); // note time before execution
function();
time (&end); // note time after execution

double difference = difftime (end,begin);
printf ("time taken for function() %.2lf seconds.\n", difference );

return 0;
}

Trong cuốn sách Scott Meyers tôi đã tìm thấy một ví dụ về biểu thức lambda chung có thể được sử dụng để đo thời gian thực hiện chức năng. (C ++ 14)

auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = std::chrono::high_resolution_clock::now();
        // function invocation using perfect forwarding
        std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        // get time after function invocation
        const auto& stop = std::chrono::high_resolution_clock::now();
        return stop - start;
     };

Vấn đề là bạn chỉ đo một lần thực hiện nên kết quả có thể rất khác nhau. Để có được kết quả đáng tin cậy, bạn nên đo một số lượng lớn thực hiện. Theo bài giảng của Andrei Alexandrescu tại code :: hội nghị dive 2015 - Viết mã nhanh I:

Thời gian đo: tm = t + tq + tn + to

Ở đâu:

tm - thời gian đo (quan sát)

t - thời gian thực sự quan tâm

tq - thời gian được thêm bởi tiếng ồn lượng tử hóa

tn - thời gian được thêm vào bởi các nguồn tiếng ồn khác nhau

đến - thời gian trên không (đo, lặp, chức năng gọi)

Theo những gì ông nói sau trong bài giảng, bạn nên lấy tối thiểu số lượng lớn thực hiện này làm kết quả của bạn. Tôi khuyến khích bạn nhìn vào bài giảng mà anh ấy giải thích tại sao.

Ngoài ra còn có một thư viện rất tốt từ google - https://github.com/google/benchmark . Thư viện này rất đơn giản để sử dụng và mạnh mẽ. Bạn có thể kiểm tra một số bài giảng của Chandler Carruth trên youtube nơi anh ấy đang sử dụng thư viện này trong thực tế. Ví dụ: CppCon 2017: Chandler Carruth Di Đi đâu nhanh hơn;

Ví dụ sử dụng:

#include <iostream>
#include <chrono>
#include <vector>
auto timeFuncInvocation = 
    [](auto&& func, auto&&... params) {
        // get time before function invocation
        const auto& start = high_resolution_clock::now();
        // function invocation using perfect forwarding
        for(auto i = 0; i < 100000/*largeNumber*/; ++i) {
            std::forward<decltype(func)>(func)(std::forward<decltype(params)>(params)...);
        }
        // get time after function invocation
        const auto& stop = high_resolution_clock::now();
        return (stop - start)/100000/*largeNumber*/;
     };

void f(std::vector<int>& vec) {
    vec.push_back(1);
}

void f2(std::vector<int>& vec) {
    vec.emplace_back(1);
}
int main()
{
    std::vector<int> vec;
    std::vector<int> vec2;
    std::cout << timeFuncInvocation(f, vec).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec2).count() << std::endl;
    std::vector<int> vec3;
    vec3.reserve(100000);
    std::vector<int> vec4;
    vec4.reserve(100000);
    std::cout << timeFuncInvocation(f, vec3).count() << std::endl;
    std::cout << timeFuncInvocation(f2, vec4).count() << std::endl;
    return 0;
}

EDIT: Tất nhiên bạn luôn cần nhớ rằng trình biên dịch của bạn có thể tối ưu hóa một cái gì đó hay không. Các công cụ như perf có thể hữu ích trong những trường hợp như vậy.

Cách dễ dàng cho C ++ cũ hơn hoặc C:

#include <time.h> // includes clock_t and CLOCKS_PER_SEC

int main() {

    clock_t start, end;

    start = clock();
    // ...code to measure...
    end = clock();

    double duration_sec = double(end-start)/CLOCKS_PER_SEC;
    return 0;
}

Thời gian chính xác tính bằng giây là 1.0/CLOCKS_PER_SEC

• Đây là một phương thức rất dễ sử dụng trong C ++ 11.
• Chúng tôi có thể sử dụng std :: chrono :: high_resolution_clock từ tiêu đề
• Chúng ta có thể viết một phương thức để in thời gian thực hiện phương thức ở dạng dễ đọc hơn.

Ví dụ: để tìm tất cả các số nguyên tố trong khoảng từ 1 đến 100 triệu, phải mất khoảng 1 phút đến 40 giây. Vì vậy, thời gian thực hiện được in là:

Execution Time: 1 Minutes, 40 Seconds, 715 MicroSeconds, 715000 NanoSeconds

Mã ở đây:

#include <iostream>
#include <chrono>

using namespace std;
using namespace std::chrono;

typedef high_resolution_clock Clock;
typedef Clock::time_point ClockTime;

void findPrime(long n, string file);
void printExecutionTime(ClockTime start_time, ClockTime end_time);

int main()
{
    long n = long(1E+8);  // N = 100 million

    ClockTime start_time = Clock::now();

    // Write all the prime numbers from 1 to N to the file "prime.txt"
    findPrime(n, "C:\\prime.txt"); 

    ClockTime end_time = Clock::now();

    printExecutionTime(start_time, end_time);
}

void printExecutionTime(ClockTime start_time, ClockTime end_time)
{
    auto execution_time_ns = duration_cast<nanoseconds>(end_time - start_time).count();
    auto execution_time_ms = duration_cast<microseconds>(end_time - start_time).count();
    auto execution_time_sec = duration_cast<seconds>(end_time - start_time).count();
    auto execution_time_min = duration_cast<minutes>(end_time - start_time).count();
    auto execution_time_hour = duration_cast<hours>(end_time - start_time).count();

    cout << "\nExecution Time: ";
    if(execution_time_hour > 0)
    cout << "" << execution_time_hour << " Hours, ";
    if(execution_time_min > 0)
    cout << "" << execution_time_min % 60 << " Minutes, ";
    if(execution_time_sec > 0)
    cout << "" << execution_time_sec % 60 << " Seconds, ";
    if(execution_time_ms > 0)
    cout << "" << execution_time_ms % long(1E+3) << " MicroSeconds, ";
    if(execution_time_ns > 0)
    cout << "" << execution_time_ns % long(1E+6) << " NanoSeconds, ";
}

Dưới đây là một mẫu lớp chỉ tiêu đề xuất sắc để đo thời gian đã trôi qua của một hàm hoặc bất kỳ khối mã nào:

#ifndef EXECUTION_TIMER_H
#define EXECUTION_TIMER_H

template<class Resolution = std::chrono::milliseconds>
class ExecutionTimer {
public:
    using Clock = std::conditional_t<std::chrono::high_resolution_clock::is_steady,
                                     std::chrono::high_resolution_clock,
                                     std::chrono::steady_clock>;
private:
    const Clock::time_point mStart = Clock::now();

public:
    ExecutionTimer() = default;
    ~ExecutionTimer() {
        const auto end = Clock::now();
        std::ostringstream strStream;
        strStream << "Destructor Elapsed: "
                  << std::chrono::duration_cast<Resolution>( end - mStart ).count()
                  << std::endl;
        std::cout << strStream.str() << std::endl;
    }    

    inline void stop() {
        const auto end = Clock::now();
        std::ostringstream strStream;
        strStream << "Stop Elapsed: "
                  << std::chrono::duration_cast<Resolution>(end - mStart).count()
                  << std::endl;
        std::cout << strStream.str() << std::endl;
    }

}; // ExecutionTimer

#endif // EXECUTION_TIMER_H

Dưới đây là một số công dụng của nó:

int main() {
    { // empty scope to display ExecutionTimer's destructor's message
         // displayed in milliseconds
         ExecutionTimer<std::chrono::milliseconds> timer;

         // function or code block here

         timer.stop();

    } 

    { // same as above
        ExecutionTimer<std::chrono::microseconds> timer;

        // code block here...

        timer.stop();
    }

    {  // same as above
       ExecutionTimer<std::chrono::nanoseconds> timer;

       // code block here...

       timer.stop();

    }

    {  // same as above
       ExecutionTimer<std::chrono::seconds> timer;

       // code block here...

       timer.stop();

    }              

    return 0;
}

Vì lớp là một mẫu nên chúng ta có thể chỉ định thực dễ dàng theo cách chúng ta muốn đo thời gian và hiển thị. Đây là một mẫu lớp tiện ích rất tiện dụng để thực hiện đánh dấu băng ghế và rất dễ sử dụng.

Tôi khuyên bạn nên sử dụng steady_clockguarunteed là đơn điệu, không giống như high_resolution_clock.

#include <iostream>
#include <chrono>

using namespace std;

unsigned int stopwatch()
{
    static auto start_time = chrono::steady_clock::now();

    auto end_time = chrono::steady_clock::now();
    auto delta    = chrono::duration_cast<chrono::microseconds>(end_time - start_time);

    start_time = end_time;

    return delta.count();
}

int main() {
  stopwatch(); //Start stopwatch
  std::cout << "Hello World!\n";
  cout << stopwatch() << endl; //Time to execute last line
  for (int i=0; i<1000000; i++)
      string s = "ASDFAD";
  cout << stopwatch() << endl; //Time to execute for loop
}

Đầu ra:

Hello World!
62
163514

Bạn có thể có một lớp đơn giản có thể được sử dụng cho loại phép đo này.

class duration_printer {
public:
    duration_printer() : __start(std::chrono::high_resolution_clock::now()) {}
    ~duration_printer() {
        using namespace std::chrono;
        high_resolution_clock::time_point end = high_resolution_clock::now();
        duration<double> dur = duration_cast<duration<double>>(end - __start);
        std::cout << dur.count() << " seconds" << std::endl;
    }
private:
    std::chrono::high_resolution_clock::time_point __start;
};

Điều duy nhất cần làm là tạo một đối tượng trong hàm của bạn ở đầu hàm đó

void veryLongExecutingFunction() {
    duration_calculator dc;
    for(int i = 0; i < 100000; ++i) std::cout << "Hello world" << std::endl;
}

int main() {
    veryLongExecutingFunction();
    return 0;
}

và đó là nó. Các lớp học có thể được sửa đổi để phù hợp với yêu cầu của bạn.

Vì không có câu trả lời nào được cung cấp là rất chính xác hoặc cho kết quả có thể lặp lại, tôi quyết định thêm một liên kết đến mã của tôi có độ chính xác dưới nano giây và thống kê khoa học.

Lưu ý rằng điều này sẽ chỉ hoạt động để đo mã mất một thời gian ngắn (rất) để chạy (hay còn gọi là một vài chu kỳ đồng hồ đến vài nghìn): nếu chúng chạy quá lâu đến mức chúng có khả năng bị gián đoạn bởi một số -heh- bị gián đoạn , sau đó rõ ràng là không thể đưa ra một kết quả có thể lặp lại và chính xác; hậu quả của việc đo lường là không bao giờ kết thúc: cụ thể là nó tiếp tục đo cho đến khi chắc chắn 99,9% chắc chắn rằng nó có câu trả lời đúng không bao giờ xảy ra trên một máy có các quá trình khác chạy khi mã quá lâu.

https://github.com/CarloWood/cwds/blob/master/benchmark.h#L40

Nếu bạn muốn an toàn thời gian và dòng mã, bạn có thể thực hiện đo thời gian thực hiện chức năng theo macro một dòng:

a) Thực hiện lớp đo thời gian như đã đề xuất ở trên (đây là cách triển khai của tôi cho Android):

class MeasureExecutionTime{
private:
    const std::chrono::steady_clock::time_point begin;
    const std::string caller;
public:
    MeasureExecutionTime(const std::string& caller):caller(caller),begin(std::chrono::steady_clock::now()){}
    ~MeasureExecutionTime(){
        const auto duration=std::chrono::steady_clock::now()-begin;
        LOGD("ExecutionTime")<<"For "<<caller<<" is "<<std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()<<"ms";
    }
};

b) Thêm một macro thuận tiện sử dụng tên hàm hiện tại là TAG (sử dụng macro ở đây rất quan trọng, người khác __FUNCTION__sẽ đánh giá MeasureExecutionTimethay vì hàm bạn muốn đo

#ifndef MEASURE_FUNCTION_EXECUTION_TIME
#define MEASURE_FUNCTION_EXECUTION_TIME const MeasureExecutionTime measureExecutionTime(__FUNCTION__);
#endif

c) Viết macro của bạn khi bắt đầu chức năng bạn muốn đo. Thí dụ:

 void DecodeMJPEGtoANativeWindowBuffer(uvc_frame_t* frame_mjpeg,const ANativeWindow_Buffer& nativeWindowBuffer){
        MEASURE_FUNCTION_EXECUTION_TIME
        // Do some time-critical stuff 
}

Điều này sẽ dẫn đến kết quả đầu ra sau đây:

ExecutionTime: For DecodeMJPEGtoANativeWindowBuffer is 54ms

Lưu ý rằng điều này (như tất cả các giải pháp được đề xuất khác) sẽ đo thời gian giữa khi chức năng của bạn được gọi và khi nó được trả về, không nhất thiết là thời gian CPU của bạn đang thực thi chức năng. Tuy nhiên, nếu bạn không cung cấp cho người lập lịch bất kỳ thay đổi nào để tạm dừng mã đang chạy của bạn bằng cách gọi chế độ ngủ () hoặc tương tự thì không có sự khác biệt giữa.