एएनएसआई सी का उपयोग कर मिलीसेकंड में समय कैसे मापें?

Question

केवल एएनएसआई सी का उपयोग करके, मिलीसेकंड परिशुद्धता या अधिक के साथ समय मापने का कोई तरीका है? मैं time.h ब्राउज़ कर रहा था लेकिन मुझे केवल दूसरे सटीक कार्यों को मिला।

Answer 1

कोई एएनएसआई सी फ़ंक्शन नहीं है जो 1 सेकंड के समय के रिज़ॉल्यूशन से बेहतर प्रदान करता है लेकिन POSIX फ़ंक्शन gettimeofday माइक्रोसॉन्ड रिज़ॉल्यूशन प्रदान करता है। घड़ी का कार्य केवल उस समय को मापता है जब एक प्रक्रिया ने निष्पादन में खर्च किया है और कई प्रणालियों पर सटीक नहीं है।

आप इस तरह इस सुविधा का उपयोग कर सकते हैं:

struct timeval tval_before, tval_after, tval_result; 

gettimeofday(&tval_before, NULL); 

// Some code you want to time, for example: 
sleep(1); 

gettimeofday(&tval_after, NULL); 

timersub(&tval_after, &tval_before, &tval_result); 

printf("Time elapsed: %ld.%06ld\n", (long int)tval_result.tv_sec, (long int)tval_result.tv_usec); 

यह मेरा मशीन पर Time elapsed: 1.000870 देता है।

Answer 2

सबसे अच्छी परिशुद्धता जिसे आप संभवतः प्राप्त कर सकते हैं वह x86- केवल "rdtsc" निर्देश के उपयोग के माध्यम से है, जो घड़ी-स्तर के संकल्प प्रदान कर सकता है (एन निश्चित रूप से rdtsc कॉल की लागत को ध्यान में रखना चाहिए, जो कि कर सकता है एप्लिकेशन स्टार्टअप पर आसानी से मापा जा सकता है)।

यहां मुख्य पकड़ प्रति सेकंड घड़ियों की संख्या को माप रहा है, जो बहुत कठिन नहीं होना चाहिए।

Answer 3

#include <time.h> 
clock_t uptime = clock()/(CLOCKS_PER_SEC/1000); 

Answer 4

मैं हमेशा घड़ी_gettime() फ़ंक्शन का उपयोग करता हूं, जो CLOCK_MONOTONIC घड़ी से समय लौटाता है। समय लौटाया गया समय, सेकेंड और नैनोसेकंड में, अतीत में कुछ अनिर्दिष्ट बिंदु, जैसे कि युग की प्रणाली स्टार्टअप।

#include <stdio.h> 
#include <stdint.h> 
#include <time.h> 

int64_t timespecDiff(struct timespec *timeA_p, struct timespec *timeB_p) 
{ 
    return ((timeA_p->tv_sec * 1000000000) + timeA_p->tv_nsec) - 
      ((timeB_p->tv_sec * 1000000000) + timeB_p->tv_nsec); 
} 

int main(int argc, char **argv) 
{ 
    struct timespec start, end; 
    clock_gettime(CLOCK_MONOTONIC, &start); 

    // Some code I am interested in measuring 

    clock_gettime(CLOCK_MONOTONIC, &end); 

    uint64_t timeElapsed = timespecDiff(&end, &start); 
} 

Answer 5

खिड़कियों के तहत:

SYSTEMTIME t; 
GetLocalTime(&t); 
swprintf_s(buff, L"[%02d:%02d:%02d:%d]\t", t.wHour, t.wMinute, t.wSecond, t.wMilliseconds); 

Answer 6

timespec_get सी 11 से नैनोसेकंड अप करने के लिए रिटर्न, कार्यान्वयन के समाधान के लिए गोल।

पॉज़िक्स 'clock_gettime से एएनएसआई रिपॉप की तरह दिखता है।

उदाहरण: एक printf उबंटू 15.10 पर हर 100ms किया जाता है:

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 

static long get_nanos(void) { 
    struct timespec ts; 
    timespec_get(&ts, TIME_UTC); 
    return (long)ts.tv_sec * 1000000000L + ts.tv_nsec; 
} 

int main(void) { 
    long nanos; 
    long last_nanos; 
    long start; 
    nanos = get_nanos(); 
    last_nanos = nanos; 
    start = nanos; 
    while (1) { 
     nanos = get_nanos(); 
     if (nanos - last_nanos > 100000000L) { 
      printf("current nanos: %ld\n", nanos - start); 
      last_nanos = nanos; 
     } 
    } 
    return EXIT_SUCCESS; 
} 

C11 N1570 standard draft7.27.2.5 timespec_get समारोह का कहना है:

तो आधार TIME_UTC, tv_sec सदस्य है कार्यान्वयन परिभाषित युग के बाद से सेकंड की संख्या पर सेट करें, पूरे मूल्य को छोटा कर दिया गया है और tv_nsec सदस्य नैनोसेकंड की अभिन्न संख्या पर सेट किया गया है, गोलाकार सिस्टम घड़ी के संकल्प के लिए। (321)

321) हालांकि एक स्ट्रक्चर टाइमपेक ऑब्जेक्ट नैनोसेकंद रिज़ॉल्यूशन के साथ समय का वर्णन करता है, उपलब्ध रिज़ॉल्यूशन सिस्टम निर्भर है और यह 1 सेकंड से भी अधिक हो सकता है। C++ Cross-Platform High-Resolution Timer

glibc 2:

सी ++ 11 भी std::chrono::high_resolution_clock मिला है।

int 
timespec_get (struct timespec *ts, int base) 
{ 
    switch (base) 
    { 
    case TIME_UTC: 
     if (__clock_gettime (CLOCK_REALTIME, ts) < 0) 
     return 0; 
     break; 

    default: 
     return 0; 
    } 

    return base; 
} 

इतनी स्पष्ट रूप से: 21 रूप sysdeps/posix/timespec_get.c के तहत यह लागू करता http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html

:

• केवल TIME_UTC वर्तमान में

• समर्थित है यह आगे __clock_gettime (CLOCK_REALTIME, ts) है, जो एक POSIX एपीआई है

  लिनक्स x86-64 में clock_gettime सिस्टम है कहते हैं।

  ध्यान दें कि यह एक असफल प्रूफ सूक्ष्म बेंच मार्किंग विधि वजह से नहीं है:

  • man clock_gettime कहते हैं इस उपाय discontinuities हो सकता है कि यदि आप करते समय अपने कार्यक्रम चलाता है स्थापित करने के लिए कुछ सिस्टम का समय बदल जाते हैं। यह पाठ्यक्रम की एक दुर्लभ घटना होनी चाहिए, और आप इसे अनदेखा कर सकते हैं।

  • यह माप दीवार समय है, इसलिए यदि शेड्यूलर आपके कार्य को भूलने का फैसला करता है, तो यह लंबे समय तक चलने वाला प्रतीत होता है।

  उन कारणों के लिए getrusage(), एक बेहतर बेहतर POSIX बेंच मार्किंग उपकरण हो सकता है के बावजूद यह कम माइक्रोसेकंड अधिकतम शुद्धता है। पर

  अधिक जानकारी: Measure time in Linux - time vs clock vs getrusage vs clock_gettime vs gettimeofday vs timespec_get?

Answer 7

एक पोर्टेबल समाधान

यह पहले से ही यहाँ उल्लेख किया गया था है कि वहाँ समय माप समस्या के लिए पर्याप्त परिशुद्धता के साथ कोई उचित एएनएसआई समाधान, मैं चाहता हूँ के रूप में लागू करना पोर्टेबल कैसे प्राप्त करें और यदि संभव हो, तो एक उच्च-रिज़ॉल्यूशन समय माप समाधान के तरीकों के बारे में लिखने के लिए।

Monotonic घड़ी बनाम समय टिकटों

सामान्यतया वहाँ समय माप के दो तरीके हैं:

• monotonic घड़ी;
• वर्तमान (दिनांक) समय टिकट।

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

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

तो समय अंतराल मापने का पहला नियम यदि संभव हो तो एक monotonic घड़ी का उपयोग करना है। यह आमतौर पर एक उच्च परिशुद्धता है, और यह डिजाइन द्वारा भरोसेमंद है।

निवर्तन रणनीति

जब एक पोर्टेबल समाधान यह एक fallback रणनीति पर विचार करने के लायक है को लागू करने: यदि उपलब्ध हो तो एक monotonic घड़ी का उपयोग करें और समय टिकटों दृष्टिकोण पर वापस आने अगर वहाँ प्रणाली में कोई monotonic घड़ी है।

विंडोज

जो सभी विवरण आप सॉफ्टवेयर और हार्डवेयर के समर्थन के बारे में पता करने के लिए आवश्यकता हो सकती है का वर्णन करता है जो शानदार लेख विंडोज पर समय माप के बारे में MSDN पर Acquiring high-resolution time stamps कहा जाता है। विंडोज पर एक उच्च परिशुद्धता समय स्टाम्प प्राप्त करने के लिए आपको:

• QueryPerformanceFrequency साथ क्वेरी एक टाइमर आवृत्ति प्रति सेकंड (टिक्स):

  LARGE_INTEGER tcounter; 
  LARGE_INTEGER freq;  
  
  if (QueryPerformanceFrequency (&tcounter) != 0) 
      freq = tcounter.QuadPart; 
  

  घड़ी आवृत्ति प्रणाली बूट ताकि आप की जरूरत है पर तय हो गई है इसे केवल एक बार प्राप्त करने के लिए।

• क्वेरी QueryPerformanceCounter के साथ वर्तमान टिक मूल्य: माइक्रोसेकंड को

  LARGE_INTEGER tcounter; 
  LARGE_INTEGER tick_value; 
  
  if (QueryPerformanceCounter (&tcounter) != 0) 
      tick_value = tcounter.QuadPart; 
  

• पैमाने बीता हुआ समय के लिए टिक, अर्थात्:

  LARGE_INTEGER usecs = (tick_value - prev_tick_value)/(freq/1000000); 
  

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

• GetTickCount मिलीसेकेंड कि बीते हैं के बाद से प्रणाली शुरू किया गया था की संख्या प्रदान करता है। यह हर 49.7 दिनों में लपेटता है, इसलिए लंबे अंतराल को मापने में सावधान रहें।
• GetTickCount64GetTickCount का 64-बिट संस्करण है, लेकिन यह विंडोज विस्टा और ऊपर से उपलब्ध है।

ओएस एक्स (MacOS)

ओएस एक्स (MacOS) का अपना मच पूर्ण समय इकाइयों जो एक monotonic घड़ी का प्रतिनिधित्व करते है। शुरू करने का सबसे अच्छा तरीका ऐप्पल का आलेख Technical Q&A QA1398: Mach Absolute Time Units है जो वर्णन करता है (कोड उदाहरणों के साथ) मोनोटोनिक टिक प्राप्त करने के लिए मैक-विशिष्ट API का उपयोग कैसे करें। इसके बारे में एक स्थानीय प्रश्न भी है जिसे clock_gettime alternative in Mac OS X कहा जाता है, जो अंत में आपको थोड़ा उलझन में डाल सकता है कि संभावित मूल्य ओवरफ़्लो के साथ क्या करना है क्योंकि काउंटर आवृत्ति संख्या और संप्रदाय के रूप में उपयोग की जाती है।

• घड़ी आवृत्ति अंश और हर मिलती है:: तो, एक छोटी उदाहरण कैसे बीता हुआ समय पाने के लिए

  #include <mach/mach_time.h> 
  #include <stdint.h> 
  
  static uint64_t freq_num = 0; 
  static uint64_t freq_denom = 0; 
  
  void init_clock_frequency() 
  { 
      mach_timebase_info_data_t tb; 
  
      if (mach_timebase_info (&tb) == KERN_SUCCESS && tb.denom != 0) { 
       freq_num = (uint64_t) tb.numer; 
       freq_denom = (uint64_t) tb.denom; 
      } 
  } 
  

  वैसा करने के लिए केवल एक बार की जरूरत है।

• क्वेरी mach_absolute_time के साथ वर्तमान टिक मूल्य:

  uint64_t value_diff = tick_value - prev_tick_value; 
  
  /* To prevent overflow */ 
  value_diff /= 1000; 
  
  value_diff *= freq_num; 
  value_diff /= freq_denom; 
  

  मुख्य विचार करने के लिए: यानी माइक्रोसेकंड, पहले से पूछे अंश और हर का उपयोग करने के

  uint64_t tick_value = mach_absolute_time(); 
  

• पैमाने बीता हुआ समय के लिए टिक, एक अतिप्रवाह को रोकने के लिए संख्याओं और denominator का उपयोग करने से पहले वांछित सटीकता के लिए टिक को स्केल करना है। प्रारंभिक टाइमर रिज़ॉल्यूशन नैनोसेकंड में है, इसलिए हम माइक्रोसॉंड प्राप्त करने के लिए इसे 1000 से विभाजित करते हैं। आप क्रोमियम के time_mac.c में उपयोग किए गए समान दृष्टिकोण को पा सकते हैं। यदि आपको वास्तव में How can I use mach_absolute_time without overflowing? पढ़ने पर विचार करने के लिए नैनोसेकंद सटीकता की आवश्यकता है।

Linux और UNIX

clock_gettime कॉल किसी भी POSIX के अनुकूल प्रणाली पर अपने सबसे अच्छा तरीका है। यह विभिन्न घड़ी स्रोतों से समय पूछताछ कर सकता है, और हमें जिसकी आवश्यकता है CLOCK_MONOTONIC है। नहीं सभी प्रणालियों जो, clock_gettime समर्थन CLOCK_MONOTONIC है तो पहली बात करने की ज़रूरत है इसकी उपलब्धता की जांच करने के लिए है:

• अगर _POSIX_MONOTONIC_CLOCK एक मूल्य के परिभाषित किया गया है >= 0 इसका मतलब है कि CLOCK_MONOTONIC तो उपलब्ध है,

• अगर _POSIX_MONOTONIC_CLOCK0 को परिभाषित इसका मतलब है कि आप अतिरिक्त जाँच करनी चाहिए अगर यह क्रम पर काम करता है, मैं का उपयोग करने का सुझाव देते हैं sysconf:

  #include <unistd.h> 
  
  #ifdef _SC_MONOTONIC_CLOCK 
  if (sysconf (_SC_MONOTONIC_CLOCK) > 0) { 
      /* A monotonic clock presents */ 
  } 
  #endif 
  

• अन्यथा एक monotonic घड़ी समर्थित नहीं है और आप एक fallback रणनीति का उपयोग करना चाहिए (निचे देखो)।

clock_gettime का उपयोग बहुत सीधे आगे है:

#include <time.h> 
#include <sys/time.h> 
#include <stdint.h> 

uint64_t get_posix_clock_time() 
{ 
    struct timespec ts; 

    if (clock_gettime (CLOCK_MONOTONIC, &ts) == 0) 
     return (uint64_t) (ts.tv_sec * 1000000 + ts.tv_nsec/1000); 
    else 
     return 0; 
} 

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

• समय मूल्य मिलता है।

• calculate पिछले समय मूल्य के साथ अंतर उसी तरह प्राप्त किया:

  uint64_t prev_time_value, time_value; 
  uint64_t time_diff; 
  
  /* Initial time */ 
  prev_time_value = get_posix_clock_time(); 
  
  /* Do some work here */ 
  
  /* Final time */ 
  time_value = get_posix_clock_time(); 
  
  /* Time difference */ 
  time_diff = time_value - prev_time_value; 
  

सबसे अच्छा वापस आने रणनीति gettimeofday कॉल उपयोग करने के लिए है: यह एक monotonic नहीं है, लेकिन यह काफी एक प्रदान करता है अच्छा संकल्प।विचार clock_gettime साथ के रूप में ही है, लेकिन एक समय मूल्य आपको चाहिए पाने के लिए:

#include <time.h> 
#include <sys/time.h> 
#include <stdint.h> 

uint64_t get_gtod_clock_time() 
{ 
    struct timeval tv; 

    if (gettimeofday (&tv, NULL) == 0) 
     return (uint64_t) (tv.tv_sec * 1000000 + tv.tv_usec); 
    else 
     return 0; 
} 

फिर, समय मूल्य माइक्रोसेकंड तक कम कर दिया है।

एसजीआई IRIX

IRIXclock_gettime कॉल है, लेकिन यह CLOCK_MONOTONIC का अभाव है। इसके बजाए इसका अपना मोनोटोनिक घड़ी स्रोत CLOCK_SGI_CYCLE के रूप में परिभाषित किया गया है जिसे आपको के साथ CLOCK_MONOTONIC के बजाय उपयोग करना चाहिए।

सोलारिस और HP-UX

सोलारिस अपने स्वयं के उच्च संकल्प टाइमर इंटरफ़ेस gethrtime जो नैनोसेकंड में वर्तमान टाइमर मान देता है। हालांकि सोलारिस के नए संस्करणों में clock_gettime हो सकता है, यदि आप पुराने सोलारिस संस्करणों का समर्थन करने की आवश्यकता है तो आप gethrtime पर चिपके रह सकते हैं।

प्रयोग सरल है:

#include <sys/time.h> 

void time_measure_example() 
{ 
    hrtime_t prev_time_value, time_value; 
    hrtime_t time_diff; 

    /* Initial time */ 
    prev_time_value = gethrtime(); 

    /* Do some work here */ 

    /* Final time */ 
    time_value = gethrtime(); 

    /* Time difference */ 
    time_diff = time_value - prev_time_value; 
} 

HP-UX का अभाव clock_gettime, लेकिन यह gethrtime जो आप सोलारिस के रूप में एक ही तरीके से उपयोग करना चाहिए समर्थन करता है।

BeOS

BeOS भी अपने स्वयं के उच्च संकल्प टाइमर इंटरफ़ेस system_time जो रिटर्न माइक्रोसेकंड की संख्या नहीं बीते हैं जब से कंप्यूटर हटा दिया गया था है।

उदाहरण उपयोग:

#include <kernel/OS.h> 

void time_measure_example() 
{ 
    bigtime_t prev_time_value, time_value; 
    bigtime_t time_diff; 

    /* Initial time */ 
    prev_time_value = system_time(); 

    /* Do some work here */ 

    /* Final time */ 
    time_value = system_time(); 

    /* Time difference */ 
    time_diff = time_value - prev_time_value; 
} 

ओएस/2

OS/2 उच्च परिशुद्धता समय टिकटों को पुनः प्राप्त करने के लिए अपने स्वयं एपीआई है:

• क्वेरी एक टाइमर आवृत्ति (प्रति टिक्स यूनिट) DosTmrQueryFreq (जीसीसी कंपाइलर के लिए):

  #define INCL_DOSPROFILE 
  #define INCL_DOSERRORS 
  #include <os2.h> 
  #include <stdint.h> 
  
  ULONG freq; 
  
  DosTmrQueryFreq (&freq); 
  

• क्वेरी DosTmrQueryTime के साथ वर्तमान टिक मूल्य: माइक्रोसेकंड को

  QWORD tcounter; 
  unit64_t time_low; 
  unit64_t time_high; 
  unit64_t timestamp; 
  
  if (DosTmrQueryTime (&tcounter) == NO_ERROR) { 
      time_low = (unit64_t) tcounter.ulLo; 
      time_high = (unit64_t) tcounter.ulHi; 
  
      timestamp = (time_high << 32) | time_low; 
  } 
  

• पैमाने बीता हुआ समय के लिए टिक, अर्थात्:

  uint64_t usecs = (prev_timestamp - timestamp)/(freq/1000000); 
  

उदाहरण कार्यान्वयन

आप plibsys लाइब्रेरी पर एक नज़र डालें जो उपर्युक्त सभी रणनीतियों को लागू करता है (विवरण के लिए ptimeprofiler * .c देखें)।