दिलचस्प पोस्ट
स्थिर कीवर्ड और इसके विभिन्न उपयोग सी ++ में कैसे सी में एक स्ट्रिंग के अंदर एक गतिशील सरणी शामिल करने के लिए? एक जावा एपीआई जावा स्रोत फ़ाइलों को उत्पन्न करने के लिए मुद्रण सामग्री के लिए जेएसपी सहायक वर्ग अजगर – ओमेस्केरस ~ मेरे रास्ते में नहीं समझते हैं? MySQL क्लाइंट को MySQLdb के साथ पुन: कनेक्ट करने के लिए कैसे सक्षम करें? कोर डेटा के लिए "स्वचालित हल्के प्रवासन" का कार्यान्वयन (आईफ़ोन) मजबूत पासवर्ड regex एंड्रॉइड: गतिविधि के जीवन चक्र के दौरान कहां पर क्रिएट ऑप्शन मेनू पर कॉल किया जाता है? json_encode फ़ंक्शन: विशेष वर्ण पारदर्शी खोखले या कट आउट सर्कल यह पता लगाने के लिए कि कोई दिए गए स्ट्रिंग palindrome है या नहीं है palindrome मैं अप्रचलित / पदावनत के रूप में एक विधि को कैसे चिह्नित करूं? ggplot2 – एक साजिश के शीर्ष पर माध्यमिक y- अक्ष जोड़ने क्या है यदि __name__ == "__main__": क्या करें?

विंडोज में सी + + उच्च परिशुद्धता समय माप

मैं विंडोज में सी + + का उपयोग कर नैनोसेकंड के लिए एक विशिष्ट बिंदु को मापने में दिलचस्पी है क्या यह संभव है? यदि ऐसा नहीं है, तो क्या कम से कम माइक्रोसेकेंड में विशिष्ट समय प्राप्त करना संभव है? कोई पुस्तकालय करना चाहिए, जब तक कि मुझे लगता है कि यह प्रबंधित कोड के साथ संभव है। धन्यवाद

Solutions Collecting From Web of "विंडोज में सी + + उच्च परिशुद्धता समय माप"

यदि आपके पास एक QueryPerformanceCounter संगत कंप्यूटर पर चलने वाला थ्रेडेड एप्लिकेशन है QueryPerformanceCounter कर सकते हैं (और होगा) विभिन्न मानों को वापस लौटा सकते हैं, जिस पर कोर पर कोड चल रहा है। इस एमएसडीएन लेख को देखें ( rdtsc एक ही समस्या है)

यह सिर्फ एक सैद्धांतिक समस्या नहीं है; हम अपने आवेदन के साथ इसमें भाग गए और यह निष्कर्ष निकालना था कि केवल विश्वसनीय समय स्रोत का समय timeGetTime जिसमें केवल एमएस सटीक है (जो हमारे मामले में सौभाग्य से पर्याप्त था)। हमने अपने धागे के लिए थ्रेड एनालिटी को तय करने की भी कोशिश की कि हर धागे को हमेशा QueryPerformanceCounter से लगातार मूल्य मिला, यह काम किया, लेकिन यह एप्लिकेशन में प्रदर्शन को पूरी तरह से मार डाला।

चीजों को जोड़ने के लिए खिड़कियों पर कोई विश्वसनीय टाइमर नहीं है जो कि सूक्ष्म परिशुद्धता के साथ समय के लिए इस्तेमाल किया जा सकता है (कम से कम एक मल्टीकोर कंप्यूटर पर चलते समय)।

विंडोज में एक उच्च-प्रदर्शन काउंटर एपीआई है ।

आपको QueryPerformanceCounter बनाते हैं और प्रोसेसर की आवृत्ति से विभाजित करने की आवश्यकता होती है, जो कि QueryPerformanceFrequency फ्रीक्वेंसी द्वारा प्रदान की जाती है।

 LARGE_INTEGER frequency; if (::QueryPerformanceFrequency(&frequency) == FALSE) throw "foo"; LARGE_INTEGER start; if (::QueryPerformanceCounter(&start) == FALSE) throw "foo"; // Calculation. LARGE_INTEGER end; if (::QueryPerformanceCounter(&end) == FALSE) throw "foo"; double interval = static_cast<double>(end.QuadPart - start.QuadPart) / frequency.QuadPart; 

यह interval सेकंड में होना चाहिए।

भविष्य में संदर्भ के लिए, Windows Vista, 2008 और उच्चतर के साथ, विंडोज को हार्डवेयर समर्थन "एचपीईटी" की आवश्यकता है यह सीपीयू और इसकी घड़ी और आवृत्ति से स्वतंत्र रूप से काम करता है। उप-माइक्रोसेंड के लिए गुणों के साथ समय प्राप्त करना संभव है

इसे लागू करने के लिए, आपको QPC / QPF का उपयोग करने की आवश्यकता है समस्या यह है कि QPF (आवृत्ति) एक नाममात्र मान है, इसलिए कच्चे कॉल का उपयोग प्रतिदिन मिनटों से अधिक हो सकता है, जो समयबद्धता का कारण होगा। इसके लिए आकस्मिक कार्रवाई करने के लिए, आपको वास्तविक आवृत्ति को मापना होगा और समय के साथ इसकी बहाव की जांच करना होगा क्योंकि गर्मी और अन्य भौतिक ऑपरेटिंग परिस्थितियों पर इसका असर होगा।

यह आलेख बताता है कि इस लिंक पर एमएसडीएन (लगभग 2004!) पर पाया जा सकता है http://msdn.microsoft.com/en-us/magazine/cc163996.aspx

मैंने अपने आप से कुछ इसी तरह लागू किया था (और सिर्फ आज ही उपरोक्त लिंक मिला है!), लेकिन "माइक्रोसकंड समय" का उपयोग नहीं करना पसंद करता है क्योंकि क्यूपीसी कॉल ही अन्य विंडोज कॉल्स जैसे कि GetSystemTimeAsFileTime के मुकाबले काफी लंबा है, और सिंक्रनाइज़ेशन और ओवरहेड जोड़ता है। इसलिए मैं मिलीसेकंड का टाइमस्टैम्प (लगभग 70% कम समय का उपयोग क्यूपीसी के उपयोग से) करना चाहता हूं, खासकर जब मैं प्रति सेकंड हजारों बार सैकड़ों बार प्राप्त करने की कोशिश कर रहा हूं।

सबसे अच्छी पसंद QueryPerformanceCounter और QueryPerformanceFrequency

माइक्रोसॉफ्ट ने हाल ही में (2014) रिलीज़ किया है QueryPerformanceCounter के बारे में अधिक विस्तृत जानकारी:

विवरण के लिए उच्च-रिज़ॉल्यूशन टाइम स्टाम्प (एमएसडीएन 2014) प्राप्त करना देखें।

यह बहुत सारे उदाहरण और विस्तृत विवरण के साथ एक व्यापक लेख है। ए क्यूपीसी के उपयोगकर्ताओं के लिए पढ़ना आवश्यक है

एमएसडीएन का दावा है कि –

एक परिदृश्य ऑब्जेक्ट एक अत्यधिक-सटीक टाइमर है जो ETW ईवेंट (Windows के लिए ईवेंट ट्रेसिंग) लॉग करता है, जब आप इसे प्रारंभ करते हैं और रोकते हैं यह प्रदर्शन इंस्ट्रूमेंटेशन और बेंचमार्किंग के लिए उपयोग करने के लिए डिज़ाइन किया गया है, और C # और C ++ दोनों संस्करणों में आता है। … आधुनिक हार्डवेयर पर अंगूठे का एक नियम के रूप में, आरंभ करने के लिए एक कॉल () या एंड () एक माइक्रोसेकेंड के क्रम पर ले जाता है, और परिणामी टाइमस्टैम्प 100ns (यानी 0.1 माइक्रोसॉन्ड्स) के लिए सटीक होते हैं। … संस्करण दोनों .NET 3.5 (सी # में लिखे गए) और मूल सी ++ के लिए उपलब्ध हैं, और दोनों x86 और x64 प्लेटफार्मों पर चलते हैं। परिदृश्य वर्ग मूल रूप से Visual Studio 2008 का उपयोग करके विकसित किया गया था, लेकिन अब Visual Studio 2010 के उपयोग से डेवलपर्स को लक्षित किया गया है।]

परिदृश्य होम पेज से जहां तक ​​मुझे पता है, यह पीपीएल के समान लोगों द्वारा प्रदान किया गया था।

Addionaly आप Windows में प्रदर्शन मापन के लिए इस उच्च संकल्प घड़ियों और टाइमर पढ़ सकते हैं।

कॉनराड रूडोल्फ ने प्रस्तावित के रूप में आप परफॉर्मेंस काउंटर एपीआई का उपयोग कर सकते हैं, लेकिन चेतावनी दी जानी चाहिए कि यह सीपीयू फ़्रीक्वेंसी पर आधारित है। यह आवृत्ति स्थिर नहीं होती है, उदाहरण के लिए, जब एक पावर सेव मोड सक्षम होता है। यदि आप इस एपीआई का उपयोग करना चाहते हैं, तो सुनिश्चित करें कि सीपीयू निरंतर आवृत्ति पर है।

अन्यथा, आप कुछ प्रकार की 'सांख्यिकीय' प्रणाली बना सकते हैं, जो पीसी की BIOS घड़ी में सीपीयू टिकों को सम्मिलित करते हैं। बाद वाला रास्ता कम सटीक है, लेकिन स्थिरांक

मुझे लगता है कि माइक्रोसेकेंड थोड़ा अनुचित है (बिना हार्डवेयर सहायता)। मिलिसेकंड संभव है, लेकिन फिर भी विभिन्न नापाक काउंटर रिज़ॉल्यूशन मुद्दों के कारण सटीक नहीं है। भले ही, मैं आपके विचार के लिए अपना स्वयं का टाइमर वर्ग (std :: chrono पर आधारित) को शामिल करता हूं:

 #include <type_traits> #include <chrono> class Stopwatch final { public: using elapsed_resolution = std::chrono::milliseconds; Stopwatch() { Reset(); } void Reset() { reset_time = clock.now(); } elapsed_resolution Elapsed() { return std::chrono::duration_cast<elapsed_resolution>(clock.now() - reset_time); } private: std::chrono::high_resolution_clock clock; std::chrono::high_resolution_clock::time_point reset_time; }; 

ध्यान दें कि Windows std :: chrono :: high_resolution_clock पर हुड के अंतर्गत QueryPerformanceCounter का उपयोग कर रहा है, इसलिए यह केवल एक समान लेकिन पोर्टेबल है।

नए विंडोज संस्करणों में आप शायद GetSystemTimePreciseAsFileTime चाहते हैं उच्च संकल्प टाइमस्टैम्प प्राप्त करना देखें

इसके बहुत सारे हार्डवेयर और ओएस संस्करण के आधार पर एक बहुत ही दुर्भाग्यपूर्ण मात्रा में भिन्नता है।

यदि आप विजुअल स्टूडियो संकलक 2012 या उच्चतर का उपयोग कर सकते हैं, तो आप अच्छी तरह std :: chrono मानक पुस्तकालय का उपयोग कर सकते हैं।

 #include <chrono> ::std::chrono::steady_clock::time_point time = std::chrono::steady_clock::now(); 

ध्यान दें कि MSVC 2012 संस्करण केवल 1 एमएमएस सटीक हो सकता है नए संस्करणों को माइक्रोसेकेंड तक सटीक होना चाहिए।

QueryPerformanceCounter (विंडो के लिए) का उपयोग कर

कोनराड रूडोल्फ के जवाब के संबंध में, ध्यान दें कि मेरे अनुभव में प्रदर्शन काउंटर की आवृत्ति लगभग 3.7 मेगाहर्टज है, इसलिए उप माइक्रोसेंड, लेकिन निश्चित रूप से नैनोसेकंड परिशुद्धता नहीं है। वास्तविक आवृत्ति हार्डवेयर (और पावर-सेव मोड) निर्भर है। किसी भी मामले में नैनोसेकंड परिशुद्धता कुछ अनुचित है क्योंकि लचीलापन और प्रक्रिया / थ्रेड संदर्भ स्विचन समय को बीच में आता है, और यह अलग-अलग मशीन निर्देशों के परिमाण का क्रम भी है।

rdtsc निर्देश सबसे सटीक है

यहां टाइमर क्लास है जो कि विंडोज और लिनक्स दोनों के लिए काम करेगा:

 #ifndef INCLUDE_CTIMER_HPP_ #define INCLUDE_CTIMER_HPP_ #if defined(_MSC_VER) # define NOMINMAX // workaround a bug in windows.h # include <windows.h> #else # include <sys/time.h> #endif namespace Utils { class CTimer { private: # if defined(_MSC_VER) LARGE_INTEGER m_depart; # else timeval m_depart; # endif public: inline void start() { # if defined(_MSC_VER) QueryPerformanceCounter(&m_depart); # else gettimeofday(&m_depart, 0); # endif }; inline float GetSecondes() const { # if defined(_MSC_VER) LARGE_INTEGER now; LARGE_INTEGER freq; QueryPerformanceCounter(&now); QueryPerformanceFrequency(&freq); return (now.QuadPart - m_depart.QuadPart) / static_cast<float>(freq.QuadPart); # else timeval now; gettimeofday(&now, 0); return now.tv_sec - m_depart.tv_sec + (now.tv_usec - m_depart.tv_usec) / 1000000.0f; # endif }; }; } #endif // INCLUDE_CTIMER_HPP_ 

इनपुट के लिए धन्यवाद … यद्यपि मैं नैनो नहीं मिल सका, या माइक्रोसेकन्ड रेज़ोल्यूशन जो अच्छा होता, मैं इसके साथ आने में सक्षम था … शायद किसी और को यह उपयोगी होगा।

  class N_Script_Timer { public: N_Script_Timer() { running = false; milliseconds = 0; seconds = 0; start_t = 0; end_t = 0; } void Start() { if(running)return; running = true; start_t = timeGetTime(); } void End() { if(!running)return; running = false; end_t = timeGetTime(); milliseconds = end_t - start_t; seconds = milliseconds / (float)1000; } float milliseconds; float seconds; private: unsigned long start_t; unsigned long end_t; bool running; };