C ++ 'da bir zaman farkı nasıl hesaplanır

C ++ 'da bir saat farkını hesaplamanın en iyi yolu nedir? Bir programın yürütme hızını zamanlıyorum, bu yüzden milisaniyelerle ilgileniyorum. Daha da iyisi, saniye. Milisaniye ..

Kabul edilen cevap işe yarıyor, ancak yorumlarda belirtildiği gibi ctime veya time.h'yi içermesi gerekiyor.

İşleve bakın std::clock().

const clock_t begin_time = clock();
// do something
std::cout << float( clock () - begin_time ) /  CLOCKS_PER_SEC;

Kendi için yürütme süresini hesaplamak istiyorsanız (kullanıcı için değil), bunu saat tiklerinde (saniye değil) yapmak daha iyidir.

DÜZENLEME:
sorumlu başlık dosyaları - <ctime>veya<time.h>

c ++ 11 kullanıyorsanız, işte basit bir sarmalayıcı (bu özete bakın ):

#include <iostream>
#include <chrono>

class Timer
{
public:
    Timer() : beg_(clock_::now()) {}
    void reset() { beg_ = clock_::now(); }
    double elapsed() const { 
        return std::chrono::duration_cast<second_>
            (clock_::now() - beg_).count(); }

private:
    typedef std::chrono::high_resolution_clock clock_;
    typedef std::chrono::duration<double, std::ratio<1> > second_;
    std::chrono::time_point<clock_> beg_;
};

Veya * nix üzerinde c ++ 03 için:

#include <iostream>
#include <ctime>

class Timer
{
public:
    Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }

    double elapsed() {
        clock_gettime(CLOCK_REALTIME, &end_);
        return end_.tv_sec - beg_.tv_sec +
            (end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
    }

    void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }

private:
    timespec beg_, end_;
};

Kullanım örneği:

int main()
{
    Timer tmr;
    double t = tmr.elapsed();
    std::cout << t << std::endl;

    tmr.reset();
    t = tmr.elapsed();
    std::cout << t << std::endl;
    return 0;
}

Boost kullanımını, özellikle boost :: posix_time :: ptime ve boost :: posix_time :: time_duration ( http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time adresinde) ciddi şekilde düşünürdüm. .html ).

Çapraz platformdur, kullanımı kolaydır ve tecrübelerime göre bir işletim sisteminin sağladığı en yüksek zaman çözünürlüğünü sağlar. Muhtemelen aynı zamanda çok önemli; bazı çok güzel IO operatörleri sağlar.

Programın çalıştırılmasındaki farkı hesaplamak için kullanmak için (mikrosaniyelere; muhtemelen aşırıya kaçma), şöyle bir şeye benzeyecektir [tarayıcı yazılmış, test edilmemiş]:

ptime time_start(microsec_clock::local_time());
//... execution goes here ...
ptime time_end(microsec_clock::local_time());
time_duration duration(time_end - time_start);
cout << duration << '\n';

Bu cevabı, kabul edilen cevabın istediğiniz zaman olmayabilecek CPU zamanını gösterdiğini açıklığa kavuşturmak için ekledim . Uygun için referans vardır işlemci zamanı ve duvar saati . Duvar saati zamanı, diğer işlemler tarafından paylaşılan CPU gibi diğer koşullardan bağımsız olarak gerçek geçen zamanı gösteren zamandır. Örneğin, belirli bir görevi yerine getirmek için birden fazla işlemci kullandım ve CPU süresi yüksek 18 saniyeydi ve gerçek duvar saati süresinde 2 saniye sürdü .

Yaptığınız gerçek zamanı elde etmek için

#include <chrono>

auto t_start = std::chrono::high_resolution_clock::now();
// the work...
auto t_end = std::chrono::high_resolution_clock::now();

double elapsed_time_ms = std::chrono::duration<double, std::milli>(t_end-t_start).count();

boost 1.46.0 ve üstü Chrono kitaplığını içerir :

thread_clock sınıfı gerçek evre duvar saatine, yani çağıran evrenin gerçek CPU-zaman saatine erişim sağlar. Evre göreceli güncel zaman, thread_clock :: now () çağrısı ile elde edilebilir

#include <boost/chrono/thread_clock.hpp>
{
...
    using namespace boost::chrono;
    thread_clock::time_point start = thread_clock::now();
    ...
    thread_clock::time_point stop = thread_clock::now();  
    std::cout << "duration: " << duration_cast<milliseconds>(stop - start).count() << " ms\n";

Windows'ta: GetTickCount'u kullanın

//GetTickCount defintition
#include <windows.h>
int main()
{

    DWORD dw1 = GetTickCount();

    //Do something 

    DWORD dw2 = GetTickCount();

    cout<<"Time difference is "<<(dw2-dw1)<<" milliSeconds"<<endl;

}

Clock_gettime özelliğini de kullanabilirsiniz . Bu yöntem şunları ölçmek için kullanılabilir:

1. Sistem genelinde gerçek zamanlı saat
2. Sistem geniş monotonik saat
3. İşlem Başına CPU süresi
4. İşlem İş Parçacığı başına CPU süresi

Kod aşağıdaki gibidir:

#include < time.h >
#include <iostream>
int main(){
  timespec ts_beg, ts_end;
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_beg);
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts_end);
  std::cout << (ts_end.tv_sec - ts_beg.tv_sec) + (ts_end.tv_nsec - ts_beg.tv_nsec) / 1e9 << " sec";
}

'

Her ihtimale karşı Unix'te iseniz time, yürütme zamanını almak için kullanabilirsiniz :

$ g++ myprog.cpp -o myprog
$ time ./myprog

Sadece bir yan not: Windows üzerinde çalışıyorsanız ve gerçekten hassasiyete ihtiyacınız varsa, QueryPerformanceCounter'ı kullanabilirsiniz . Size (potansiyel olarak) nano saniye cinsinden zaman verir .

Benim için en kolay yol:

#include <boost/timer.hpp>

boost::timer t;
double duration;

t.restart();
/* DO SOMETHING HERE... */
duration = t.elapsed();

t.restart();
/* DO OTHER STUFF HERE... */
duration = t.elapsed();

bu kod parçasını kullanarak klasik yapmak zorunda değilsiniz end - start.

En sevdiğiniz yaklaşımın tadını çıkarın.

Başlangıçta ve sonunda milisaniye cinsinden sistem saatini alın ve çıkarın.

POSIX'te 1970'ten bu yana geçen milisaniye sayısını elde etmek için şunu yazarsınız:

struct timeval tv;

gettimeofday(&tv, NULL);
return ((((unsigned long long)tv.tv_sec) * 1000) +
        (((unsigned long long)tv.tv_usec) / 1000));

Windows'ta 1601'den beri geçen milisaniye sayısını almak için şunu yazarsınız:

SYSTEMTIME systime;
FILETIME filetime;

GetSystemTime(&systime);
if (!SystemTimeToFileTime(&systime, &filetime))
    return 0;

unsigned long long ns_since_1601;
ULARGE_INTEGER* ptr = (ULARGE_INTEGER*)&ns_since_1601;

// copy the result into the ULARGE_INTEGER; this is actually
// copying the result into the ns_since_1601 unsigned long long.
ptr->u.LowPart = filetime.dwLowDateTime;
ptr->u.HighPart = filetime.dwHighDateTime;

// Compute the number of milliseconds since 1601; we have to
// divide by 10,000, since the current value is the number of 100ns
// intervals since 1601, not ms.
return (ns_since_1601 / 10000);

Windows yanıtını, 1970'ten bu yana geçen milisaniye sayısını da döndürecek şekilde normalleştirmeye özen gösterdiyseniz, yanıtınızı 11644473600000 milisaniye olarak ayarlamanız gerekir. Ancak tüm ilgilendiğiniz geçen zaman ise bu gerekli değildir.

Eğer kullanıyorsanız:

tstart = clock();

// ...do something...

tend = clock();

O zaman saniyeler içinde zaman almak için aşağıdakilere ihtiyacınız olacak:

time = (tend - tstart) / (double) CLOCKS_PER_SEC;

Bu, intel Mac 10.7 için iyi çalışıyor gibi görünüyor:

#include <time.h>

time_t start = time(NULL);


    //Do your work


time_t end = time(NULL);
std::cout<<"Execution Time: "<< (double)(end-start)<<" Seconds"<<std::endl;