C ++ 'da bir işlevin yürütme süresini ölçme

C ++ programımda belirli bir işlevin Linux'ta çalıştırılmasının ne kadar zaman aldığını öğrenmek istiyorum . Daha sonra bir hız karşılaştırması yapmak istiyorum. Birkaç zaman işlevi gördüm ama bunu desteklemeden aldım. Chrono:

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

Şimdi, yukarıdaki işlevi kullanıp kullanmadığımdan emin değilim, CPU'nun bu işlev için harcadığı tek zamanı alacak mıyım?

İkinci olarak, yukarıdaki işlevi kullanmanın herhangi bir örneğini bulamadım. Herhangi biri yukarıdaki işlevi nasıl kullanacağım konusunda bana yardım edebilir mi?

Not: Şu anda std::chrono::system_clock::now()saniyeler içinde zaman almak için kullanıyorum ama bu bana her seferinde farklı CPU yükü nedeniyle farklı sonuçlar veriyor.

C ++ 11'de kullanımı çok kolay bir yöntemdir. Sen kullanmak zorunda std::chrono::high_resolution_clockdan <chrono>başlığındaki.

Bunu şu şekilde kullanın:

#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;
}

Bu, işlevin süresini ölçecektir.

NOT: Bir işlev için her zaman aynı zamanlamayı elde edemezsiniz. Bunun nedeni, makinenizin CPU'sunun bilgisayarınızda çalışan diğer işlemler tarafından daha az veya daha fazla kullanılabilmesidir, tıpkı bir matematik alıştırmasını çözdüğünüzde zihninizin az çok konsantre olması gibi. İnsan zihninde bir matematik probleminin çözümünü hatırlayabiliriz, ancak bir bilgisayar için aynı süreç her zaman yeni bir şey olacaktır; böylece, dediğim gibi, her zaman aynı sonucu alamayacaksınız!

Bağımsız değişken olarak iletilen herhangi bir işlevin yürütme süresini ölçecek bir işlev:

#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);
}

Örnek kullanım:

#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;
}

Çıktı:

norm: 15555
algo: 2976

basit bir program, alınan bir işlevi yürütme süresini bulmak için.

#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;
}

Scott Meyers kitabında, fonksiyon yürütme süresini ölçmek için kullanılabilecek evrensel bir genel lambda ifadesi örneği buldum. (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;
     };

Sorun, yalnızca bir yürütmeyi ölçmenizdir, bu nedenle sonuçlar çok farklı olabilir. Güvenilir bir sonuç elde etmek için çok sayıda yürütmeyi ölçmelisiniz. Andrei Alexandrescu'nun code :: dive 2015 konferansındaki konuşmasına göre - Hızlı Kod Yazma I:

Ölçülen zaman: tm = t + tq + tn + to

nerede:

tm - ölçülen (gözlemlenen) zaman

t - gerçek ilgi zamanı

tq - niceleme gürültüsü tarafından eklenen zaman

tn - çeşitli gürültü kaynakları tarafından eklenen zaman

to - genel gider süresi (ölçüm, döngü, fonksiyon çağırma)

Daha sonra konferansta söylediklerine göre, sonuç olarak bu kadar çok sayıda infazı asgari düzeyde almalısınız. Nedenini açıkladığı derse bakmanızı tavsiye ederim.

Ayrıca google'dan çok iyi bir kitaplık var - https://github.com/google/benchmark . Bu kitaplığın kullanımı çok basit ve güçlüdür. Chandler Carruth'un bu kütüphaneyi pratikte kullandığı youtube'daki bazı derslerine göz atabilirsiniz. Örneğin CppCon 2017: Chandler Carruth "Hiçbir Yere Daha Hızlı Gitmiyor";

Örnek kullanım:

#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;
}

DÜZENLEME: Elbette, derleyicinizin bir şeyi optimize edip edemeyeceğini her zaman hatırlamanız gerekir. Perf gibi araçlar bu gibi durumlarda faydalı olabilir.

Eski C ++ veya C için kolay yol:

#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;
}

Saniyeler içinde zamanlama hassasiyeti 1.0/CLOCKS_PER_SEC

• C ++ 11'de kullanımı çok kolay bir yöntemdir.
• Başlıktan std :: chrono :: high_resolution_clock kullanabiliriz
• Yöntem çalıştırma zamanını çok okunabilir bir biçimde yazdırmak için bir yöntem yazabiliriz.

Örneğin, 1 ile 100 milyon arasındaki tüm asal sayıları bulmak yaklaşık 1 dakika 40 saniye sürer. Böylece uygulama süresi şu şekilde yazdırılır:

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

Kod burada:

#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, ";
}

İşte bir fonksiyonun veya herhangi bir kod bloğunun geçen süresini ölçmek için mükemmel bir yalnızca başlık sınıf şablonu:

#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

İşte bunun bazı kullanımları:

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;
}

Sınıf bir şablon olduğundan, zamanımızın nasıl ölçülmesini ve görüntülenmesini istediğimizi kolayca belirleyebiliriz. Bu, kıyaslama yapmak için çok kullanışlı bir yardımcı program sınıfı şablondur ve kullanımı çok kolaydır.

steady_clockAksine, monoton olması garantili olanı kullanmanızı tavsiye ederim 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
}

Çıktı:

Hello World!
62
163514

Bu tür ölçümler için kullanılabilecek basit bir sınıfa sahip olabilirsiniz.

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;
};

Yapmanız gereken tek şey, o işlevin başında işlevinizde bir nesne oluşturmaktır.

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

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

ve bu kadar. Sınıf, gereksinimlerinize uyacak şekilde değiştirilebilir.

Sağlanan yanıtların hiçbiri çok doğru olmadığından veya tekrarlanabilir sonuçlar vermediğinden, koduma nanosaniyenin altında hassasiyete ve bilimsel istatistiklere sahip bir bağlantı eklemeye karar verdim.

Bunun yalnızca çalıştırılması (çok) kısa bir süre (diğer bir deyişle, birkaç bine kadar birkaç saat döngüsü) alan kodu ölçmek için işe yarayacağını unutmayın: eğer o kadar uzun çalışırlarsa, bir -heh- kesinti ile kesintiye uğrayacaklardır. o zaman tekrarlanabilir ve doğru bir sonuç vermek kesinlikle mümkün değildir; Bunun sonucu, ölçüm asla bitmez: yani, istatistiksel olarak% 99,9 emin olana kadar ölçmeye devam eder ve bu, kod çok uzun sürdüğünde başka işlemlerin çalıştığı bir makinede asla gerçekleşmez.

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

Zamanı ve kod satırlarını güvence altına almak istiyorsanız, işlev yürütme süresinin ölçülmesini tek satırlık bir makro yapabilirsiniz:

a) Yukarıda önerildiği gibi bir zaman ölçme sınıfı uygulayın (işte benim android için uygulamam):

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) Mevcut fonksiyon adını TAG olarak kullanan uygun bir makro ekleyin (burada bir makro kullanmak önemlidir, aksi __FUNCTION__takdirde MeasureExecutionTimeölçmek istediğiniz fonksiyon yerine değerlendirecektir.

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

c) Ölçmek istediğiniz fonksiyonun başlangıcına makronuzu yazın. Misal:

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

Bu, aşağıdaki çıktıyla sonuçlanacaktır:

ExecutionTime: For DecodeMJPEGtoANativeWindowBuffer is 54ms

Bunun (önerilen diğer çözümlerin tümü gibi), CPU'nuzun işlevi yürüttüğü zamanı değil, işlevinizin çağrıldığı ve geri döndüğü zaman arasındaki zamanı ölçeceğini unutmayın. Bununla birlikte, programlayıcıya uyku () veya benzerini çağırarak çalışan kodunuzu askıya alması için herhangi bir değişiklik yapmazsanız, arasında fark yoktur.