दिलचस्प पोस्ट
एक बंद करने के बिना एक JFrame बंद करें? जांचें कि क्या PHP सत्र पहले से शुरू हो चुका है पिछले फ़ंक्शन के पूरा होने के बाद फ़ंक्शन को कॉल करें एक जार में पैकेजिंग फेसलेट फ़ाइलें (टेम्पलेट्स, शामिल हैं, कंपोजिट) क्रोम एक्सटेंशन: कैसे पृष्ठ इनपुट के 'keydown' घटना भेजने के लिए? कैसे कॉन को केवल संख्याएं लेना चाहिए कोई शब्द नहीं है जिसमें एक शब्द का मिलान करने के लिए नियमित अभिव्यक्ति है? सी में "बैकस्पेस" एस्केप वर्ण '\ b', अप्रत्याशित व्यवहार? एक जेफ्राम और उसके घटकों को छपाई रिंगटोन प्रबंधक के साथ रिंगटोन कैसे सेट करें। ACT_RINGTONE_PICKER? किसी दिए गए यूआरएल के लिए फेसबुक की पसंद / शेयर गिनती जेएसन का उपयोग करते हुए उद्देश्य सी में डेटा पोस्ट करें पृष्ठ लोड पर ब्राउज़र ज़ूम स्तर कैसे बढ़ाएं? कम से कम 1 नंबर और 1 वर्ण के साथ अल्फ़ान्यूमेरिक के लिए रेगेक्स बीएफएस द्वारा प्राप्त वास्तविक पथ को मैं कैसे प्राप्त करूं?

सी कार्यक्रम का निष्पादन समय

मेरे पास एक सी प्रोग्राम है जिसका लक्ष्य है कि कई प्रोसेसर पर समानांतर में चलाना। मुझे निष्पादन समय (जो कि कहीं 1 सेकंड से कई मिनट तक हो सकता है) को रिकॉर्ड करने में सक्षम होना चाहिए। मैंने उत्तरों की खोज की है, लेकिन वे सभी clock() फ़ंक्शन का उपयोग करने के लिए सुझाव देते हैं, जो तब घड़ियों की संख्या की गणना करता है जो प्रोग्राम को Clocks_per_second मान से विभाजित करता है।

मुझे यकीन नहीं है कि Clocks_per_second मान की गणना कैसे की जाती है?

जावा में, मैं निष्पादन से पहले और बाद में मिलीसेकंड में वर्तमान समय लेता हूं।

क्या सी में ऐसी कोई चीज है? मैंने एक नज़र लिया है, लेकिन मुझे दूसरे संकल्प के मुकाबले कुछ भी बेहतर करने का एक तरीका नहीं मिल सकता है

मैं यह भी जानता हूं कि एक प्रोफाइलर एक विकल्प होगा, लेकिन एक टाइमर को स्वयं लागू करना चाहता हूं

धन्यवाद

वेब के समाधान से एकत्रित समाधान "सी कार्यक्रम का निष्पादन समय"

CLOCKS_PER_SEC एक निरंतर है जिसे <time.h> में घोषित किया गया है। किसी सी एप्लिकेशन के अंतर्गत कार्य द्वारा उपयोग किए गए CPU समय प्राप्त करने के लिए, इसका उपयोग करें:

 clock_t begin = clock(); /* here, do your time-consuming job */ clock_t end = clock(); double time_spent = (double)(end - begin) / CLOCKS_PER_SEC; 

ध्यान दें कि यह समय एक फ्लोटिंग प्वाइंट प्रकार के रूप में देता है। यह एक सेकंड से अधिक सटीक हो सकता है (उदाहरण के लिए आप 4.52 सेकेंड का अनुमान लगाते हैं)। प्रेसिजन आर्किटेक्चर पर निर्भर करता है; आधुनिक सिस्टम पर आप आसानी से 10 एमएमएस या उससे कम मिलता है, लेकिन पुराने विंडोज मशीनों पर (Win98 युग से) यह 60 एमएमएस के करीब था।

clock() मानक सी है; यह "हर जगह" काम करता है सिस्टम-विशिष्ट फ़ंक्शन हैं, जैसे यूनिक्स-जैसी सिस्टम पर getrusage()

जावा की System.currentTimeMillis() एक ही बात को मापने नहीं है यह एक "दीवार घड़ी" है: यह आपको यह निष्पादित करने में मदद कर सकता है कि वह प्रोग्राम को निष्पादित करने के लिए कितना समय लेता है, लेकिन यह आपको बताता नहीं है कि CPU समय कितना उपयोग किया गया था। एक मल्टीटास्किंग सिस्टम (यानी सभी) पर, ये व्यापक रूप से भिन्न हो सकते हैं

यदि आप चलाने के लिए यूनिक्स शेल का उपयोग कर रहे हैं, तो आप समय कमांड का उपयोग कर सकते हैं।

करते हुए

 $ time ./a.out 

निष्पादन योग्य के रूप में a.out मानते समय इसे चलाने के लिए लिया गया समय

सादे वेनिला में सी:

 #include <time.h> #include <stdio.h> int main() { clock_t tic = clock(); my_expensive_function_which_can_spawn_threads(); clock_t toc = clock(); printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC); return 0; } 

आप कार्यात्मक रूप से यह चाहते हैं:

 #include <sys/time.h> struct timeval tv1, tv2; gettimeofday(&tv1, NULL); /* stuff to do! */ gettimeofday(&tv2, NULL); printf ("Total time = %f seconds\n", (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 + (double) (tv2.tv_sec - tv1.tv_sec)); 

ध्यान दें कि यह उपाय माइक्रोसॉन्ड्स में, न सिर्फ सेकंड

अधिकांश साधारण कार्यक्रमों में मिली-सेकंड में गणना समय है तो, मुझे लगता है, आपको यह उपयोगी मिलेगा।

 #include <time.h> #include <stdio.h> int main(){ clock_t start = clock(); // Execuatable code clock_t stop = clock(); double elapsed = (double)(stop - start) * 1000.0 / CLOCKS_PER_SEC; printf("Time elapsed in ms: %f", elapsed); } 

यदि आप पूरे प्रोग्राम की रनटाइम की गणना करना चाहते हैं और आप यूनिक्स सिस्टम पर हैं, तो इस time ./a.out तरह समय कमांड का उपयोग करके अपना प्रोग्राम time ./a.out

बहुत सारे उत्तर clock() सुझाव दे रहे clock() और फिर CLOCKS_PER_SEC से time.h । शायद यह एक बुरा विचार है, क्योंकि यह मेरा /bits/time.h फ़ाइल कहता है:

 /* ISO/IEC 9899:1990 7.12.1: <time.h> The macro `CLOCKS_PER_SEC' is the number per second of the value returned by the `clock' function. */ /* CAE XSH, Issue 4, Version 2: <time.h> The value of CLOCKS_PER_SEC is required to be 1 million on all XSI-conformant systems. */ # define CLOCKS_PER_SEC 1000000l # if !defined __STRICT_ANSI__ && !defined __USE_XOPEN2K /* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK presents the real value for clock ticks per second for the system. */ # include <bits/types.h> extern long int __sysconf (int); # define CLK_TCK ((__clock_t) __sysconf (2)) /* 2 is _SC_CLK_TCK */ # endif 

तो CLOCKS_PER_SEC को 1000000 के रूप में परिभाषित किया जा सकता है, आप संकलन करने के लिए कौन से विकल्प उपयोग करते हैं, और इस प्रकार यह एक अच्छा समाधान जैसा नहीं लगता

आपको इस बात को ध्यान में रखना होगा कि जिस प्रोग्राम को निष्पादित करने के लिए एक प्रोग्राम लिया गया है, उस माप को मापने के लिए मशीन पर उस विशिष्ट पल में लोड पर बहुत कुछ निर्भर करता है।

यह जानने के लिए, सी में वर्तमान समय प्राप्त करने का तरीका अलग-अलग तरीकों से प्राप्त किया जा सकता है, यह आसान है:

 #include <time.h> #define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec + \ ruse.ru_stime.tv_sec + 1e-6 * \ (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec)) int main(void) { time_t start, end; double first, second; // Save user and CPU start time time(&start); first = CPU_TIME; // Perform operations ... // Save end time time(&end); second = CPU_TIME; printf("cpu : %.2f secs\n", second - first); printf("user : %d secs\n", (int)(end - start)); } 

आशा करता हूँ की ये काम करेगा।

सादर!

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

एक तरफ नोट के रूप में, मैं घड़ी () का उपयोग करने की अनुशंसा नहीं करता, क्योंकि यह बहुत से (यदि सभी नहीं?) सिस्टम पर सही तरीके से लागू किया गया है और सटीक नहीं है, इसके अलावा यह केवल यह दर्शाता है कि आपका प्रोग्राम CPU पर कितना समय बिता चुका है और प्रोग्राम का कुल जीवनकाल नहीं, जो आपके प्रश्न के मुताबिक मुझे लगता है कि आप उपाय करना चाहते हैं।

हर समाधान मेरे सिस्टम में काम नहीं कर रहे हैं

मैं का उपयोग कर प्राप्त कर सकते हैं

 #include <time.h> double difftime(time_t time1, time_t time0); 
  #include<time.h> #include<stdio.h> int main(){ clock_t begin=clock(); int i; for(i=0;i<100000;i++){ printf("%d",i); } clock_t end=clock(); printf("Time taken:%lf",(double)(end-begin)/CLOCKS_PER_SEC); } 

यह कार्यक्रम आकर्षण की तरह काम करेगा

(यहां सभी उत्तर की कमी है, यदि आपके सिस्टम-सिस्टम सिस्टम सिस्टम को बदलता है, या आपके समयक्षेत्र में सर्दियों में भिन्नता है- और सोमर बार। इसलिए …)

Linux उपयोग पर: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); यदि सिस्टम-व्यवस्थापक समय को बदलता है, या आप किसी देश में गर्मियों के समय से अलग सर्दियों के समय के साथ रहते हैं तो यह प्रभावित नहीं होता है।

 #include <stdio.h> #include <time.h> #include <unistd.h> /* for sleep() */ int main() { struct timespec begin, end; clock_gettime(CLOCK_MONOTONIC_RAW, &begin); sleep(1); // waste some time clock_gettime(CLOCK_MONOTONIC_RAW, &end); printf ("Total time = %f seconds\n", (end.tv_nsec - begin.tv_nsec) / 1000000000.0 + (end.tv_sec - begin.tv_sec)); } 

man clock_gettime राज्यों:

 CLOCK_MONOTONIC Clock that cannot be set and represents monotonic time since some unspecified starting point. This clock is not affected by discontinuous jumps in the system time (eg, if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP. 

बुलबुले सॉर्ट और चयन सॉर्ट के निष्पादन समय की तुलना में मेरे पास एक प्रोग्राम है जो बुलबुले सॉर्ट और चयन सॉर्ट के निष्पादन समय की तुलना करता है। कोड के ब्लॉक के निष्पादन का समय जानने के लिए, ब्लॉक के पहले और बाद के समय की गणना करें

  clock_t start=clock(); … clock_t end=clock(); CLOCKS_PER_SEC is constant in time.h library 

उदाहरण कोड:

 #include <stdio.h> #include <stdlib.h> #include <time.h> int main() { int a[10000],i,j,min,temp; for(i=0;i<10000;i++) { a[i]=rand()%10000; } //The bubble Sort clock_t start,end; start=clock(); for(i=0;i<10000;i++) { for(j=i+1;j<10000;j++) { if(a[i]>a[j]) { int temp=a[i]; a[i]=a[j]; a[j]=temp; } } } end=clock(); double extime=(double) (end-start)/CLOCKS_PER_SEC; printf("\n\tExecution time for the bubble sort is %f seconds\n ",extime); for(i=0;i<10000;i++) { a[i]=rand()%10000; } clock_t start1,end1; start1=clock(); // The Selection Sort for(i=0;i<10000;i++) { min=i; for(j=i+1;j<10000;j++) { if(a[min]>a[j]) { min=j; } } temp=a[min]; a[min]=a[i]; a[i]=temp; } end1=clock(); double extime1=(double) (end1-start1)/CLOCKS_PER_SEC; printf("\n"); printf("\tExecution time for the selection sort is %f seconds\n\n", extime1); if(extime1<extime) printf("\tSelection sort is faster than Bubble sort by %f seconds\n\n", extime - extime1); else if(extime1>extime) printf("\tBubble sort is faster than Selection sort by %f seconds\n\n", extime1 - extime); else printf("\tBoth algorithms have the same execution time\n\n"); }