C ++에서 시차를 계산하는 방법

C ++에서 시간차를 계산하는 가장 좋은 방법은 무엇입니까? 저는 프로그램의 실행 속도를 측정하고 있으므로 밀리 초에 관심이 있습니다. 더 좋은 것은 초. 밀리 초 ..

허용되는 답변은 작동하지만 주석에 명시된대로 ctime 또는 time.h를 포함해야합니다.

std::clock()기능을 참조하십시오 .

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

self (user가 아닌) 실행 시간을 계산하려면 시계 틱 (초 아님)에서 수행하는 것이 좋습니다.

편집 :
책임있는 헤더 파일- <ctime>또는<time.h>

C ++ 11을 사용하는 경우 다음은 간단한 래퍼입니다 (이 요점 참조 ).

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

또는 * nix의 C ++ 03의 경우 :

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

사용 예 :

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의 사용, 특히 boost :: posix_time :: ptime 및 boost :: posix_time :: time_duration ( http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time에서 .html ).

크로스 플랫폼이고 사용하기 쉬우 며 내 경험상 운영 체제가 제공하는 최고 수준의 시간 해상도를 제공합니다. 아마도 매우 중요 할 수도 있습니다. 매우 멋진 IO 연산자를 제공합니다.

이를 사용하여 프로그램 실행의 차이 (마이크로 초, 아마도 과잉)를 계산하려면 다음과 같이 보일 것입니다. [브라우저 작성, 테스트되지 않음] :

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

이 답변을 추가하여 수락 된 답변 이 원하는 시간이 아닐 수있는 CPU 시간을 보여줍니다. 참조 에 따르면 CPU 시간과 벽시계 시간 이 있기 때문 입니다. 벽시계 시간은 다른 프로세스가 공유하는 CPU와 같은 다른 조건에 관계없이 실제 경과 시간을 표시하는 시간입니다. 예를 들어, 특정 작업을 수행하기 위해 여러 프로세서를 사용 했는데 CPU 시간이 18 초로 높았고 실제 벽시계 시간에서 실제로 2 초가 걸렸 습니다.

실제 시간을 얻으려면

#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 이상에는 Chrono 라이브러리가 포함됩니다 .

thread_clock 클래스는 실제 스레드 벽시계, 즉 호출 스레드의 실제 CPU 시간 시계에 대한 액세스를 제공합니다. thread_clock :: now ()를 호출하여 스레드 상대 현재 시간을 얻을 수 있습니다.

#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 : GetTickCount 사용

//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을 사용할 수도 있습니다 . 이 방법은 다음을 측정하는 데 사용할 수 있습니다.

1. 시스템 전체 실시간 시계
2. 시스템 전체의 단조로운 시계
3. 프로세스 당 CPU 시간
4. 프로세스 당 스레드 CPU 시간

코드는 다음과 같습니다.

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

`

Unix를 사용 time하는 경우 실행 시간을 가져 오는 데 사용할 수 있습니다 .

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

참고 사항 : Windows에서 실행 중이고 정말 정밀도가 필요한 경우 QueryPerformanceCounter 를 사용할 수 있습니다 . (잠재적으로) 나노초 단위로 시간을 제공합니다 .

저에게 가장 쉬운 방법은 다음과 같습니다.

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

이 코드를 사용하면 고전적인 end - start.

좋아하는 접근 방식을 즐기십시오.

처음에는 시스템 시간을 밀리 초 단위로, 마지막에는 다시 한 번 빼십시오.

POSIX에서 1970 년 이후의 밀리 초 수를 얻으려면 다음과 같이 작성합니다.

struct timeval tv;

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

Windows에서 1601 이후의 밀리 초 수를 얻으려면 다음과 같이 작성합니다.

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

1970 년 이후 밀리 초 수를 반환하도록 Windows 응답을 정규화하려고했다면 응답을 11644473600000 밀리 초로 조정해야합니다. 그러나 당신이 신경 쓰는 모든 것이 경과 된 시간이라면 그것은 필요하지 않습니다.

사용중인 경우 :

tstart = clock();

// ...do something...

tend = clock();

그런 다음 초 단위로 시간을 얻으려면 다음이 필요합니다.

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

이것은 인텔 Mac 10.7에서 잘 작동하는 것 같습니다.

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