Cách tính chênh lệch múi giờ trong C ++

Cách tốt nhất để tính chênh lệch múi giờ trong C ++ là gì? Tôi đang tính toán tốc độ thực thi của một chương trình, vì vậy tôi quan tâm đến mili giây. Tốt hơn nữa, giây. Mili giây ..

Câu trả lời được chấp nhận hoạt động, nhưng cần bao gồm ctime hoặc time.h như đã lưu ý trong các nhận xét.

Xem std::clock()chức năng.

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

Nếu bạn muốn tính toán thời gian thực hiện cho chính mình (không phải cho người dùng), tốt hơn nên làm điều này trong tích tắc đồng hồ (không phải giây).

CHỈNH SỬA:
các tệp tiêu đề có trách nhiệm - <ctime>hoặc<time.h>

nếu bạn đang sử dụng c ++ 11, đây là một trình bao bọc đơn giản (xem ý chính này ):

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

Hoặc đối với c ++ 03 trên * nix:

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

Ví dụ về cách sử dụng:

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

Tôi sẽ nghiêm túc xem xét việc sử dụng Boost, đặc biệt là boost :: posix_time :: ptime và boost :: posix_time :: time_duration (tại http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time .html ).

Nó đa nền tảng, dễ sử dụng và theo kinh nghiệm của tôi cung cấp độ phân giải thời gian cao nhất mà hệ điều hành cung cấp. Có thể cũng rất quan trọng; nó cung cấp một số toán tử IO rất hay.

Để sử dụng nó để tính toán sự khác biệt trong quá trình thực thi chương trình (đến micro giây; có thể là quá mức cần thiết), nó sẽ trông giống như sau [trình duyệt được viết, chưa được kiểm tra]:

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

Tôi đã thêm câu trả lời này để làm rõ rằng câu trả lời được chấp nhận hiển thị thời gian CPU có thể không phải là thời gian bạn muốn. Vì theo tham khảo thì có thời gian CPU và thời gian đồng hồ treo tường . Thời gian đồng hồ treo tường là thời gian hiển thị thời gian thực tế đã trôi qua bất kể điều kiện nào khác như CPU ​​được chia sẻ bởi các quy trình khác. Ví dụ: tôi đã sử dụng nhiều bộ xử lý để thực hiện một tác vụ nhất định và thời gian CPU cao là 18 giây, trong đó thời gian thực tế của đồng hồ treo tường mất 2 giây .

Để có được thời gian thực tế bạn làm,

#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 trở lên bao gồm thư viện Chrono :

lớp thread_clock cung cấp quyền truy cập vào đồng hồ treo tường của luồng thực, tức là đồng hồ thời gian CPU thực của luồng đang gọi. Thời gian hiện tại tương đối của luồng có thể được lấy bằng cách gọi 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";

Trong Windows: sử dụng GetTickCount

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

    DWORD dw1 = GetTickCount();

    //Do something 

    DWORD dw2 = GetTickCount();

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

}

Bạn cũng có thể sử dụng clock_gettime . Phương pháp này có thể được sử dụng để đo:

1. Đồng hồ thời gian thực trên toàn hệ thống
2. Hệ thống đồng hồ đơn âm rộng
3. Mỗi quy trình thời gian CPU
4. Mỗi quá trình Thời gian CPU luồng

Mã như sau:

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

`

chỉ trong trường hợp bạn đang sử dụng Unix, bạn có thể sử dụng timeđể lấy thời gian thực thi:

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

Chỉ một lưu ý nhỏ: nếu bạn đang chạy trên Windows và thực sự cần độ chính xác, bạn có thể sử dụng QueryPerformanceCounter . Nó cung cấp cho bạn thời gian (có thể là) nano giây.

Đối với tôi, cách dễ dàng nhất là:

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

bằng cách sử dụng đoạn mã này, bạn không cần phải làm theo cách cổ điển end - start.

Tận hưởng cách tiếp cận yêu thích của bạn.

Lấy thời gian của hệ thống tính bằng mili giây ở đầu và một lần nữa ở cuối và trừ đi.

Để có số mili giây kể từ năm 1970 trong POSIX, bạn sẽ viết:

struct timeval tv;

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

Để có số mili giây kể từ năm 1601 trên Windows, bạn sẽ viết:

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

Nếu bạn quan tâm đến việc chuẩn hóa câu trả lời của Windows để nó cũng trả về số mili giây kể từ năm 1970, thì bạn sẽ phải điều chỉnh câu trả lời của mình thêm 11644473600000 mili giây. Nhưng điều đó không cần thiết nếu tất cả những gì bạn quan tâm là thời gian đã trôi qua.

Nếu bạn đang sử dụng:

tstart = clock();

// ...do something...

tend = clock();

Sau đó, bạn sẽ cần những thứ sau để có thời gian tính bằng giây:

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

Điều này có vẻ hoạt động tốt đối với intel 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;