C ++ में घड़ी () का उपयोग कैसे करें

Question

मैं कैसे कहते हैं clock()मेंC++ ?

उदाहरण के लिए, मैं यह परखना चाहता हूं कि किसी सरणी में दिए गए तत्व को खोजने के लिए रैखिक खोज में कितना समय लगता है।

Comments

ध्यान दें कि दीवार-घड़ी का समय हमेशा माइक्रोबेनचर्च के लिए एक अच्छा तरीका नहीं है। लगातार परिणाम प्राप्त करने के लिए, आपको सीपीयू फ़्रीक्वेंसी-स्केलिंग (इंटेल टर्बो या एएमडी समतुल्य, जो कि आपके सीपीयू घड़ी को ऊष्मा / शक्ति सीमा की अनुमति देता है) के आसपास काम करना होगा। प्रदर्शन काउंटर के साथ प्रोफाइलिंग आपको कोर घड़ी चक्रों में माप दे सकती है (और यह भी विवरण है कि क्या एक अड़चन कैश मिसेज बनाम निर्देश थ्रूपुट बनाम विलंबता है, बस साइकिल के अलावा अन्य काउंटरों को देखकर)। लिनक्स पर,perf stat -d ./a.out

— पीटर कॉर्ड्स

Answer 1

#include <iostream>
#include <cstdio>
#include <ctime>

int main() {
    std::clock_t start;
    double duration;

    start = std::clock();

    /* Your algorithm here */

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;

    std::cout<<"printf: "<< duration <<'\n';
}

Comments

मैं यहां से जो भी देख सकता हूं वह cplusplus.com/reference/ctime/clock , आपको "std ::" नोटेशन का उपयोग करने की आवश्यकता नहीं है। बस "घड़ी ()" का उपयोग करें

— gromit190

@ बायर: सभी प्रोजेक्ट में मैंने अभी तक काम किया है, कोड शैली के लिए std :: हर std से पहले :: कॉल की आवश्यकता होती है।

— गु। थिलेमन

क्या यह सेकंड में जवाब लौटाता है?

— अर्नव बोरबोरह

@ अरनवबोरबाह हां, यह करता है।

— क्वांटुमोनीबे

@ Th.Thielemann दोनों clock()और clock_tके सी स्टैंडर्ड लाइब्रेरी के हेडर से हैं time.h, और इसलिए के उपयोग की जरूरत नहीं है stdउनके पुस्तकालयों के शामिल किए जाने के बाद नामस्थान उपसर्ग। नेमस्पेस के <ctime>साथ उस मूल्य और फ़ंक्शन को लपेटता है std, लेकिन इसका उपयोग करने की आवश्यकता नहीं है। कार्यान्वयन विवरणों के लिए यहां देखें: en.cppreference.com/w/cpp/header/ctime

— kayleeFrye_onDeck

Answer 2

एक वैकल्पिक समाधान, जो पोर्टेबल है और उच्च परिशुद्धता के साथ, C ++ 11 के बाद से उपलब्ध है, का उपयोग करना है std::chrono।

यहाँ एक उदाहरण है:

#include <iostream>
#include <chrono>
typedef std::chrono::high_resolution_clock Clock;

int main()
{
    auto t1 = Clock::now();
    auto t2 = Clock::now();
    std::cout << "Delta t2-t1: " 
              << std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count()
              << " nanoseconds" << std::endl;
}

Ideone.com पर इसने मुझे दिया:

Delta t2-t1: 282 nanoseconds

Comments

यदि आप C ++ 11 का उपयोग करने का सुझाव दे रहे हैं, तो आप बस लिख सकते हैं using Clock=std::chrono::high_resolution_clock;। प्रकार उपनाम देखें ।

— JHBonarius

std::chrono::high_resolution_clockसभी एसटीडी काम के कार्यान्वयन के लिए मोनोटोनिक नहीं है। Cppreference से - आम तौर पर किसी को सिर्फ std :: chrono :: स्थिर_clock या std :: chrono :: system_clock का उपयोग सीधे std के बजाय करना चाहिए :: chrono :: high_resolution_clock: stabil_lock का उपयोग अवधि माप के लिए, और system_clock दीवार-घड़ी के समय के लिए करें।

— क्रिस्टियानमितक

Answer 3

clock()आपका प्रोग्राम शुरू होने के बाद से घड़ी की टिक की संख्या लौटाता है। एक संबंधित स्थिरांक है, CLOCKS_PER_SECजो आपको बताता है कि एक सेकंड में कितने घड़ी टिक होते हैं। इस प्रकार, आप इस तरह के किसी भी ऑपरेशन का परीक्षण कर सकते हैं:

clock_t startTime = clock();
doSomeOperation();
clock_t endTime = clock();
clock_t clockTicksTaken = endTime - startTime;
double timeInSeconds = clockTicksTaken / (double) CLOCKS_PER_SEC;

Comments

timeInSecondsहमेशा 0.000000मेरे लिए आ रहा है। मैं इसे कैसे ठीक करूंगा?

— noufal

@noufal हो सकता है कि खर्च किया गया समय इतना कम हो कि यह 0. के रूप में दिखाई दे। आप long doubleअधिक सटीक होने के लिए ए का उपयोग करने की कोशिश कर सकते हैं ।

— गेरार्ड

शायद आपका क्लॉक रिज़ॉल्यूशन पर्याप्त उच्च नहीं है, इसलिए समय समाप्त नहीं हुआ।

— मार्को फ्रायडेनबर्गर

Answer 4

कम से कम विंडोज पर, केवल व्यावहारिक रूप से सटीक माप तंत्र QueryPerformanceCounter (QPC) है। std :: chrono का उपयोग कर इसे लागू किया जाता है (VS2015 के बाद से, यदि आप इसका उपयोग करते हैं), लेकिन यह सीधे QueryPerformanceCounter का उपयोग करने के समान डिग्री के लिए सटीक नहीं है । विशेष रूप से यह 1 नैनोसेकंड ग्रैन्युलैरिटी पर रिपोर्ट करने का दावा करता है, बिल्कुल सही नहीं है। इसलिए, यदि आप कुछ ऐसा उपाय कर रहे हैं, जिसमें बहुत कम समय लगता है (और आपका मामला ऐसा ही मामला हो सकता है), तो आपको QPC का उपयोग करना चाहिए, या अपने OS के बराबर होना चाहिए। कैश लेटेंसी को मापने के दौरान मैं इसके खिलाफ आया था, और मैंने कुछ नोट नीचे दिए थे जो आपको उपयोगी लग सकते हैं, यहाँ; https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md

Answer 5

#include <iostream>
#include <ctime>
#include <cstdlib> //_sleep()  --- just a function that waits a certain amount of milliseconds

using namespace std;

int main()
{

    clock_t cl;     //initializing a clock type

    cl = clock();   //starting time of clock

    _sleep(5167);   //insert code here

    cl = clock() - cl;  //end point of clock

    _sleep(1000);   //testing to see if it actually stops at the end point

    cout << cl/(double)CLOCKS_PER_SEC << endl;  //prints the determined ticks per second (seconds passed)


    return 0;
}

//outputs "5.17"

Comments

यह पहले से ही उत्तर दिए गए प्रश्न को नहीं जोड़ता है। सीएल = घड़ी के बाद नींद () - सीएल की जरूरत नहीं है। और cout प्रिंट सेकंड प्रति सेकंड टिक नहीं करता है। cl घड़ी की टिक को संग्रहीत करता है।

— डॉ। यूंके

Answer 6

संभवत: आप इस तरह के टाइमर में दिलचस्पी ले सकते हैं: एच: एम: एस। Msec।

लिनक्स ओएस में कोड:

#include <iostream>
#include <unistd.h>

using namespace std;
void newline(); 

int main() {

int msec = 0;
int sec = 0;
int min = 0;
int hr = 0;


//cout << "Press any key to start:";
//char start = _gtech();

for (;;)
{
        newline();
                if(msec == 1000)
                {
                        ++sec;
                        msec = 0;
                }
                if(sec == 60)
                {
                        ++min;
                        sec = 0; 
                }
                if(min == 60)
                {
                        ++hr;
                        min = 0;
                }
        cout << hr << " : " << min << " : " << sec << " . " << msec << endl;
        ++msec;
        usleep(100000); 

}

    return 0;
}

void newline()
{
        cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
}

Comments

आप पहली शर्त ... 10 मिसे = 1 सेकंड की जांच करना चाहते हैं?

— डॉ। यूंके

यह उस समय में सापेक्ष त्रुटि जमा करेगा क्योंकि आप इसमें प्रिंट होने में लगने वाले समय को शामिल नहीं करते हैं, और usleepआपके द्वारा मांगी गई राशि के बाद हमेशा वापस नहीं आएंगे। कभी-कभी यह लंबे समय तक रहेगा। आपको प्रारंभ में वर्तमान समय की जांच करनी चाहिए, फिर वर्तमान समय की जांच करें और लूप के माध्यम से हर बार शुरू करने के बाद से पूर्ण समय प्राप्त करने के लिए घटाएं।

— पीटर कॉर्डेस

Answer 7

आप माप सकते हैं कि आपका कार्यक्रम कितने समय तक काम करता है। निम्नलिखित कार्य कार्यक्रम की शुरुआत से सीपीयू समय को मापने में मदद करते हैं:

• C ++ में C ++ (डबल) क्लॉक () / CLOCKS प्रति सेकंड शामिल है।
• python time.clock () सेकंड में फ्लोटिंग-पॉइंट वैल्यू देता है।
• Java System.nanoTime () नैनोसेकंड्स में लंबे समय का मान देता है।

मेरा संदर्भ : कैलिफ़ोर्निया विश्वविद्यालय सैन डिएगो और नेशनल रिसर्च यूनिवर्सिटी हायर इकोनॉमिक्स द्वारा एल्गोरिदम टूलबॉक्स सप्ताह 1 पाठ्यक्रम डेटा संरचनाओं और एल्गोरिदम विशेषज्ञता का हिस्सा है

इसलिए आप अपने एल्गोरिथ्म के बाद कोड की इस पंक्ति को जोड़ सकते हैं

cout << (double)clock() / CLOCKS_PER_SEC ;

अपेक्षित आउटपुट: की संख्या का प्रतिनिधित्व करने वाला आउटपुट clock ticks per second

Comments

सवाल केवल सी ++ के लिए पूछा जाता है। इसलिए यह अन्य प्रोग्रामिंग भाषाओं / लिपियों के संदर्भ में अच्छा है, लेकिन यह विषय से बाहर है।

— dboy