C ++ में समय के अंतर की गणना कैसे करें

Question

C ++ में समय के अंतर की गणना करने का सबसे अच्छा तरीका क्या है? मैं एक कार्यक्रम के निष्पादन की गति को समय दे रहा हूं, इसलिए मुझे मिलीसेकंड में दिलचस्पी है। बेहतर अभी तक, सेकंड।

स्वीकृत उत्तर काम करता है, लेकिन टिप्पणी में नोट किए गए समय या समय को शामिल करने की आवश्यकता है।

Comments

डुप्लीकेट, लेकिन अभी लिंक नहीं कर सकते हैं

— रॉबर्ट गोल्ड

बंद होने वाला वोट बहुत कम था, बहुत देर से। मुझे काम का जवाब मिला। हालांकि, कोशिश अच्छी थी। Btw, मुझे कोई लिंक नहीं मिला।

— जैक बेइम्बल

इसकी खिड़कियों के लिए? तब GetTickCount (विंडोज एपीआई) का प्रयास करें

— ए.जे.

रॉबर्ट: सौभाग्य से, क्योंकि नई पोस्टिंग ने कई और उत्तरों की अनुमति दी, जिनमें से एक को मैंने चुना। गंभीरता से, मैं एक डुबकी पोस्ट को बंद करने के मूल्य पर सवाल उठाता हूं। क्या होगा अगर कुछ समाधान पहले एक में उल्लेख नहीं किए गए थे? नई तकनीकों का विकास हुआ? विभिन्न शीर्षकों के कारण इसे ढूँढ नहीं सकते?

— जैक बेइम्बल

@JackBeNimble कुछ "डुप्स" के प्राप्त होने वाले छोर पर रहा है जो वास्तव में ड्यूप्स नहीं थे (शायद लोग जो शायद प्रश्न को जल्दी से पढ़ते हैं और इसे चिह्नित करते हैं क्योंकि यह एक और प्रश्न के समान लगता है), मैं दृढ़ता से आपकी बात से सहमत हूं ... शायद मेटा स्टैक एक्सचेंज के लिए एक बिंदु: o

— code_fodder

Answer 1

std::clock()समारोह देखें ।

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

यदि आप स्वयं के लिए निष्पादन समय की गणना करना चाहते हैं (उपयोगकर्ता के लिए नहीं), तो घड़ी की टिक में यह करना बेहतर है (सेकंड नहीं)।

संपादित करें:
जिम्मेदार हेडर फाइलें - <ctime>या<time.h>

Comments

ध्यान रखें कि भले ही घड़ी () कई मिलीसेकंड लौटाती है, घड़ी की सटीकता () उससे बहुत अधिक खराब हो सकती है। विंडोज में फायर का उदाहरण घड़ी की शुद्धता () फ़ंक्शन 40 एमएस की तरह है।

— जॉन डिब्लिंग

मैंने मैक 10.7 पर यह कोशिश की। मेरा ऐप 15 सेकंड में 100 mb फ़ाइल निष्पादित करता है, लेकिन अलग-अलग समय 61 सेकंड की रिपोर्ट कर रहा है। ज्यादा इस्तेमाल नहीं। मुझे लगता है कि समय () शायद बेहतर है।

— मीक

clock()प्रोग्राम द्वारा खपत CPU समय देता है। इसलिए यदि कार्यक्रम समानांतर रूप से चलाया जाता है, तो फ़ंक्शन द्वारा लौटाए गए समय को सभी सीपीयू पर खर्च किए गए समय के संचय के बजाय, cplusplus.com/reference/ctime/clock

— Ameer Jewdaki

यह उत्तर भ्रामक है क्योंकि यह सीपीयू समय दिखाता है, वास्तविक दीवार घड़ी समय नहीं।

— पराबैंगनी

मुझे यहां पर अल्ट्रावायलेट से सहमत होना है, एक प्रोग्राम की गति को मापने के लिए सीपीयू समय का उपयोग करना गलत काम की तरह लगता है। ओपी को इसे सही जवाब के रूप में चिन्हित करना चाहिए। IMO में आपको std :: chrono :: स्थिर_clock :: now () का उपयोग निम्न सूत्र में कई उत्तरों द्वारा वर्णित किया गया है जैसे कि stackoverflow.com/questions/2808398/easily-measure-elapsed-time

— arvsun

Answer 2

यदि आप 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_;
};

या सी + 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;
}

Comments

एक और विकल्प बढ़ावा देने के लिए होगा :: C ++ 11 STL std :: chrono नाम स्थान के बजाय क्रोनो। आपके कोड के लिए धन्यवाद।

— दीदेक पेरेज़ पररा

सावधान: यह उपयोगकर्ता के बीच अपने समय को परिवर्तित करता है काम नहीं करेगा Timer()और करने के लिए कॉल elapsed()करता है, तो !std::chrono::high_resolution_clock::is_steady- जो लिनक्स पर मामला है!

— jhasse

Answer 3

मैं 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';

Comments

लेकिन स्थानीय_टाइम को बढ़ावा दें () मोनोटोनिक नहीं है, इसलिए इसका उपयोग समय के अंतराल को मापने के लिए नहीं किया जाना चाहिए। मुझे बूस्ट से मोनोटोनिक समय तक पहुंचने का कोई रास्ता नहीं मिला है।

— गैटोपिच

Answer 4

मैंने इस उत्तर को स्पष्ट करने के लिए जोड़ा कि स्वीकृत उत्तर 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();

Comments

मैं इस उत्तर के बिना std :: chrono का उपयोग करने में सक्षम नहीं होता, धन्यवाद!

— जाइल्स

Answer 5

1.46.0 और बूस्ट में क्रोनो लाइब्रेरी शामिल है:

थ्रेड_ क्लॉक क्लास वास्तविक थ्रेड वॉल-घड़ी, यानी कॉलिंग थ्रेड के वास्तविक सीपीयू-टाइम घड़ी तक पहुंच प्रदान करती है। थ्रेड के सापेक्ष वर्तमान समय थ्रेड को कॉल करके प्राप्त किया जा सकता है :: अब ()

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

Comments

इसके अलावा, C ++ 11 में std::chronoलगभग समान सामग्री के साथ नाम स्थान है।

— 14

Answer 6

विंडोज में: GetTickCount का उपयोग करें

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

    DWORD dw1 = GetTickCount();

    //Do something 

    DWORD dw2 = GetTickCount();

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

}

Answer 7

आप clock_gettime का भी उपयोग कर सकते हैं । इस विधि का उपयोग मापने के लिए किया जा सकता है:

1. सिस्टम वाइड वास्तविक समय घड़ी
2. सिस्टम वाइड मोनोटोनिक क्लॉक
3. सीपीयू समय प्रति प्रक्रिया
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";
}

`

Answer 8

यदि आप यूनिक्स पर हैं, तो आप timeनिष्पादन समय प्राप्त करने के लिए उपयोग कर सकते हैं :

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

Answer 9

बस एक पक्ष ध्यान दें: यदि आप विंडोज पर चल रहे हैं, और आपको वास्तव में सटीकता की आवश्यकता है, तो आप QueryPerformanceCounter का उपयोग कर सकते हैं । यह आपको (संभावित) नैनो सेकंड में समय देता है ।

Answer 10

मेरे लिए, सबसे आसान तरीका है:

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

अपने पसंदीदा दृष्टिकोण का आनंद लें।

Comments

t.elapsed () sec या mili-sec में है?

— एमकेयू

Answer 11

शुरुआत में, और फिर अंत में मिलीसेकंड में सिस्टम समय प्राप्त करें, और घटाएं।

POSIX में 1970 से मिलीसेकंड की संख्या प्राप्त करने के लिए आप लिखेंगे:

struct timeval tv;

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

विंडोज पर 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 के बाद से मिलीसेकंड की संख्या भी लौटाए, तो आपको अपना जवाब 11644473600000 मिलिसेकंड से समायोजित करना होगा। लेकिन यह आवश्यक नहीं है अगर आप सभी के बारे में परवाह करते हैं तो बीता हुआ समय है।

Answer 12

यदि आप उपयोग कर रहे हैं:

tstart = clock();

// ...do something...

tend = clock();

फिर आपको सेकंड में समय पाने के लिए निम्नलिखित की आवश्यकता होगी:

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

Answer 13

यह इंटेल मैक 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;