C प्रोग्राम का निष्पादन समय

Question

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

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

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

क्या C में भी कुछ ऐसा ही है? मुझे एक नज़र मिली है, लेकिन मैं एक दूसरे रिज़ॉल्यूशन से बेहतर कुछ पाने का तरीका नहीं ढूंढ सकता।

मुझे यह भी पता है कि एक प्रोफाइलर एक विकल्प होगा, लेकिन मैं खुद टाइमर लागू करना चाहता हूं।

धन्यवाद

Comments

क्या OS / API चौखटे आप उपयोग कर रहे हैं / उपलब्ध? बस सादा सी?

— typo.pl

यह एक छोटा सा कार्यक्रम है, सिर्फ सादे C

— रोजर

मैंने इस उत्तर में एक पोर्टेबल समाधान को लागू करने के बारे में विवरण में लिखा है: stackoverflow.com/questions/361363/…

— अलेक्जेंडर सैप्रीकिन

समय एक पूर्ण समारोह stackoverflow.com/a/40380118/6180077

— अब्दुल्ला फ़ार्वेज़

Answer 1

CLOCKS_PER_SECएक स्थिरांक है जिसे घोषित किया जाता है <time.h>। C अनुप्रयोग के अंतर्गत किसी कार्य द्वारा उपयोग किए जाने वाले 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 सेकंड मापते हैं)। परिशुद्धता वास्तुकला पर निर्भर करती है; आधुनिक प्रणालियों पर आपको आसानी से 10ms या उससे कम मिलता है, लेकिन पुराने विंडोज मशीनों पर (Win98 के युग से) यह 60ms के करीब था।

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

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

Comments

यह मुझे बहुत यादृच्छिक परिणाम देता है - मुझे कोड के समान टुकड़े पर बड़े / छोटे / नकारात्मक संख्या का मिश्रण मिलता है। GCC 4.7 Linux 3.2 AMD64

हाँ: clock()"घड़ियों" नामक कुछ आंतरिक पैमाने में एक समय देता है, और CLOCKS_PER_SECप्रति सेकंड घड़ियों की संख्या होती है, इसलिए CLOCKS_PER_SECसेकंड में एक समय पैदावार द्वारा विभाजित होता है। ऊपर दिए गए कोड में, मूल्य एक doubleऐसा तरीका है जिससे आप इसे अपनी इच्छानुसार माप सकते हैं।

— थॉमस पोर्निन

बड़ी चेतावनी: घड़ी () उस समय की राशि लौटाती है, जब ओएस ने आपकी प्रक्रिया को चलाने में खर्च किया है, और समय की वास्तविक राशि समाप्त नहीं हुई है। हालांकि, यह कोड के एक ब्लॉक को समय देने के लिए ठीक है, लेकिन वास्तविक दुनिया में समय को मापने के लिए नहीं।

उन्होंने कहा कि वह एक बहु-सूत्रीय कार्यक्रम को मापना चाहते हैं। मुझे यकीन नहीं है कि एक घड़ी () इसके लिए उपयुक्त है, क्योंकि यह सभी थ्रेड्स के चलने का समय तय करता है, इसलिए परिणाम ऐसा लगेगा जैसे कोड क्रमिक रूप से चलाया गया था। ऐसी चीजों के लिए मैं omp_get_wtime () का उपयोग करता हूं, लेकिन निश्चित रूप से मुझे यह सुनिश्चित करने की आवश्यकता है, सिस्टम अन्य प्रक्रियाओं के साथ व्यस्त नहीं है।

— Youda008

मैं कुछ चीजें भले ही इस सूत्र एक साल पहले अधिक प्रासंगिक थी उल्लेख करना चाहिए: CLOCKS_PER_SECएक है long intमूल्य के साथ 1000000, माइक्रोसेकंड में समय दे रही है जब विभाजित नहीं; सीपीयू घड़ी चक्र नहीं। इसलिए, इसे गतिशील आवृत्ति के लिए खाते की आवश्यकता नहीं है क्योंकि यहां घड़ी माइक्रोसेकंड में है (शायद 1 मेगाहर्ट्ज सीपीयू के लिए घड़ी चक्र?) मैंने उस मूल्य को मुद्रण करने वाला एक छोटा सी प्रोग्राम बनाया और यह मेरे i7-2640M लैपटॉप पर 1000000 था? गतिशील आवृत्ति के साथ 800 मेगाहर्ट्ज से 2.8 गीगाहर्ट्ज़ तक की अनुमति, यहां तक ​​कि टर्बो बूस्ट का उपयोग करने के लिए 3.5 गीगाहर्ट्ज़ जितना अधिक है।

— DDPWNAGE

Answer 2

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

करते हुए

$ time ./a.out

a.out को निष्पादन योग्य मानने से आपको इसे चलाने में लगने वाला समय मिलेगा

Comments

@acgtyrant लेकिन केवल सरल कार्यक्रमों के लिए, क्योंकि इसमें इनपुट, आउटपुट आदि सहित पूरे कार्यक्रम का समय लगेगा

— phuclv

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

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

Answer 3

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

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

Comments

सर्वोत्तम चर नाम जो मैंने थोड़ी देर में देखे हैं। tic = "घड़ी में समय", toc = "घड़ी के समय"। लेकिन टिक-टो = "टिक-टॉक" भी। इस तरह से मैं यहाँ से टाइम ग्रैब लेबल कर रहा हूँ।

— लोगन स्केलीly

Answer 4

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

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

ध्यान दें कि यह केवल सेकंड में नहीं, माइक्रोसेकंड में मापता है।

Comments

MinGW संकलक GCC आधारित है। तो इस पर काम होगा। लेकिन अगर आप Visual C कंपाइलर का उपयोग करते हैं, तो आपको त्रुटि मिलेगी।

— user2550754

हाँ, यह एसी लाइब्रेरी के साथ विंडोज़ पर काम करेगा जो गेटटाइमऑफडे कॉल का समर्थन करता है। यह वास्तव में कोई फर्क नहीं पड़ता कि संकलक क्या है, आपको बस इसे एक सभ्य लिबास लाइब्रेरी के खिलाफ लिंक करना होगा। जो, मिंगव के मामले में, डिफ़ॉल्ट विंडोज़ एक नहीं है।

— वेस हार्डेकर

यह मेरे लिए साइबर एक्सपी और लिनक्स उबंटू के साथ विंडोज एक्सपी पर काम करता है। यह वही है जो मैं चाहता था।

— प्यार और शांति - जो कोड्सवेल

gettimeofdayअप्रचलित है और नए कोड के लिए अनुशंसित नहीं है। इसका POSIX मैन पेज इसके बजाय घड़ी_गेटाइम की सिफारिश करता है , जो आपको CLOCK_MONOTONICसिस्टम घड़ी में बदलाव से प्रभावित नहीं होने के लिए कहता है, और इस तरह यह अंतराल समय के रूप में बेहतर है। ( JohnSll का उत्तर देखें )। आधुनिक लिनक्स सिस्टम पर, उदाहरण के लिए, गेटटाइमऑफ मूल रूप से घड़ी_गेटाइम के लिए एक आवरण है जो नैनोसेकंड को माइक्रोसेकंड में परिवर्तित करता है।

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

Answer 5

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

#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

Comments

विंडोज में कम से कम कारक कम से कम 100 है, लेकिन 1000 नहीं है और यह सटीक नहीं है

— बोक्टुलस

यह उत्तर कुछ भी नहीं जोड़ता है जो दो साल पहले से अलेक्जेंड्रे सी के उत्तर में नहीं था।

— जोनाथन लेफ़लर

@boctulus: 1s हमेशा 1000ms पर होता है, खिड़कियों पर भी।

— एल्क

Answer 6

बहुत सारे जवाब सुझाए गए हैं 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 के रूप में परिभाषित किया जा सकता है, इस बात पर निर्भर करता है कि आप किन विकल्पों का संकलन करते हैं, और इस तरह यह एक अच्छा समाधान नहीं लगता है।

Comments

जानकारी के लिए धन्यवाद, लेकिन क्या अभी तक कोई बेहतर विकल्प है?

— ११

यह एक व्यावहारिक समस्या नहीं है: हाँ पॉज़िक्स सिस्टम हमेशा होता है CLOCK_PER_SEC==1000000, लेकिन एक ही समय में, वे सभी अपनी घड़ी के लिए 1-(s परिशुद्धता का उपयोग करते हैं () कार्यान्वयन; वैसे, इसके पास साझा समस्याओं को कम करने के लिए अच्छी संपत्ति है। यदि आप संभावित रूप से बहुत त्वरित घटनाओं को मापना चाहते हैं, तो 1 एमएस से नीचे का कहना है, तो आपको पहले घड़ी () फ़ंक्शन की सटीकता (या रिज़ॉल्यूशन) के बारे में चिंता करनी चाहिए, जो कि आवश्यक रूप से पॉज़िक्स में 1µs की तुलना में मोटे है, लेकिन अक्सर बहुत मोटे भी होते हैं ; सामान्य समाधान कई बार परीक्षण चलाने के लिए है; प्रश्न के रूप में पूछा गया, हालांकि इसकी आवश्यकता नहीं थी।

— एंटोनील

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

— ज़फी

Answer 7

मैक्रों के रूप में थॉमस पोर्निन का जवाब:

#define TICK(X) clock_t X = clock()
#define TOCK(X) printf("time %s: %g sec.\n", (#X), (double)(clock() - (X)) / CLOCKS_PER_SEC)

इसे इस तरह उपयोग करें:

TICK(TIME_A);
functionA();
TOCK(TIME_A);

TICK(TIME_B);
functionB();
TOCK(TIME_B);

आउटपुट:

time TIME_A: 0.001652 sec.
time TIME_B: 0.004028 sec.

Answer 8

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

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

#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));
}

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

सादर!

Answer 9

(यहां सभी जवाबों की कमी है, यदि आपके सिस्मैडिन ने सिस्टमटाइम को बदल दिया है, या आपके टाइमज़ोन में अलग-अलग सर्दी है और सोमैमर-टाइम। इसलिए ...)

लिनक्स के उपयोग पर: 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
              (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP.

Comments

क्या आप उस गणना की व्याख्या कर सकते हैं जिसका उपयोग आप सेकंड की संख्या प्राप्त करने के लिए करते थे? यह स्पष्ट नहीं है कि क्या चल रहा है।

— कॉलिन कीनन

यह (end.tv_nsec - begin.tv_nsec) / 1000000000.0परिणाम 0हमेशा नहीं होगा ?

— एल्क

@alk: नहीं, एक से विभाजित doubleशाब्दिक चलाता int या longकरने के लिए doubleरूपांतरण से पहले विभाजन। बेशक आप सिर्फ पूर्णांक से चिपक सकते हैं और tv_secभाग को प्रिंट कर सकते हैं और फिर शून्य के साथ आंशिक भाग को पसंद कर सकते हैं %ld.%09ld, लेकिन डबल में परिवर्तित करना आसान है और 53 बिट्स सटीक आमतौर पर बेंचमार्क समय के लिए बहुत हैं।

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

(उफ़, नैनोसेकंड भाग के घटाव को सेकंड भाग में ले जाने की आवश्यकता हो सकती है, इसलिए डबल का उपयोग करना और इसे नकारात्मक समस्या से बचना चाहिए। शुद्ध पूर्णांक प्रारूप स्ट्रिंग का उपयोग करने के लिए, आपको glibc मैनुअल में सुझाए गए एक timespec_subtractजैसे की आवश्यकता होगी timeval_subtract। : gnu.org/software/libc/manual/html_node/Elapsed-Time.html )

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

Answer 10

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

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

Comments

आईएसओ सी स्टैंडर्ड (यह मानते हुए कि एएनएसआई सी का मतलब क्या है) जानबूझकर समय कार्यों की शुद्धता को निर्दिष्ट नहीं करता है । फिर विशेष रूप से एक POSIX कार्यान्वयन, या विंडोज पर, दीवार-घड़ी की शुद्धता (थॉमस का जवाब देखें) फ़ंक्शन सेकंड में हैं। लेकिन घड़ी () की सटीकता आमतौर पर अधिक होती है, और हमेशा

— पॉसिक्स में

Answer 11

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

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

#include <time.h>

double difftime(time_t time1, time_t time0);

Comments

यह दो time_tमूल्यों के बीच एक डबल के रूप में अंतर देता है । चूंकि time_tमान केवल एक सेकंड के लिए सटीक होते हैं, इसलिए यह छोटे चलने वाले कार्यक्रमों द्वारा लिए गए समय को प्रिंट करने में सीमित मूल्य का होता है, हालांकि यह लंबे समय तक चलने वाले कार्यक्रमों के लिए उपयोगी हो सकता है।

— जोनाथन लेफलर

जो भी कारण के लिए, clock_tएस की एक जोड़ी में गुजर रहा है difftimeमेरे लिए सेकंड के सौवें हिस्से के लिए सटीक काम करना प्रतीत होता है। यह linux x86 पर है। मैं भी काट नहीं मिल सकता है stopऔर startकाम करने के लिए।

— ragerdl

@ragerdl: आपको difftime() clock() / CLOCKS_PER_SECसेकंड पास करने की आवश्यकता है ।

— एल्क

Answer 12

    #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);
}

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

Answer 13

मैंने पाया है कि सामान्य घड़ी (), हर कोई यहाँ सलाह देता है, किसी कारणवश बेतहाशा रन से भाग जाता है, यहां तक ​​कि बिना किसी साइड इफेक्ट के स्टैटिक कोड के लिए भी, जैसे कि स्क्रीन पर ड्राइंग या फाइल पढ़ना। ऐसा इसलिए हो सकता है क्योंकि सीपीयू बिजली की खपत के तरीके, ओएस को अलग-अलग प्राथमिकताएं दे रहा है, आदि ...

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

पर्याप्त नमूने एक सरणी में एकत्र किए जाने के बाद, उस सरणी को एक प्रकार, और मध्य तत्व लेता है, जिसे माध्य कहा जाता है। मेडियन औसत से बेहतर है, क्योंकि यह चरम विचलन को दूर फेंकता है, जैसे कि एंटीवायरस सभी सीपीयू को ऊपर ले जाता है या ओएस कुछ अपडेट कर रहा है।

यहां सी / सी ++ कोड के निष्पादन प्रदर्शन को मापने के लिए एक सरल उपयोगिता है, औसत के पास मूल्यों का औसत: https://github.com/san// गेज

मैं अब भी कोड को मापने के लिए एक अधिक मजबूत और तेज़ तरीके की तलाश में हूं। कोई शायद बिना किसी OS के नंगे धातु पर नियंत्रित स्थितियों में कोड चलाने की कोशिश कर सकता है, लेकिन यह अवास्तविक परिणाम देगा, क्योंकि वास्तव में ओएस इसमें शामिल नहीं होता है।

x86 में ये हार्डवेयर प्रदर्शन काउंटर हैं, जिनमें निष्पादित निर्देशों की वास्तविक संख्या शामिल है, लेकिन वे बिना ओएस की मदद के उपयोग करने के लिए मुश्किल हैं, व्याख्या करना मुश्किल है और अपने स्वयं के मुद्दे हैं ( http://archive.gamedev.net/archive/reference/articles /article213.html )। फिर भी वे बोतल की गर्दन की प्रकृति (उस डेटा पर डेटा एक्सेस या वास्तविक गणना) की जांच करने में सहायक हो सकते हैं।

Comments

हां, आधुनिक x86 सीपीयू अधिकतम टर्बो की तुलना में बहुत धीमा है। "गवर्नर" सेटिंग्स के आधार पर, अधिकतम घड़ी की गति तक रैंप एक मिलीसेकंड ले सकता है (हार्डवेयर पी-राज्य प्रबंधन के साथ स्काईलेक, विशेष रूप से ऊर्जा_परफॉर्मेंस_पहचान सेट के साथ performance) या कई दसियों मिलीसेकंड। en.wikipedia.org/wiki/Dynamic_frequency_scaling । और हां, मंझला प्रदर्शन आमतौर पर एक अच्छा विकल्प है; उच्च अंत में आमतौर पर हस्तक्षेप से कुछ स्पाइक्स होते हैं।

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

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

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

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

— स्मग्लिस्पेविनी

यदि आपका कोड-अंडर-टेस्ट एक अलग फ़ाइल में है और आप लिंक-टाइम ऑप्टिमाइज़ेशन का उपयोग नहीं करते हैं, तो ऐसा कोई तरीका नहीं है कि कंपाइलर CSE को कॉल के बीच ऑप्टिमाइज़ करने के लिए कर सके। कॉल करने वाले को कोई भी दिखाई देने वाले दुष्प्रभाव के बारे में कुछ भी नहीं मान सकता है। यह आपको केवल कॉल / रिटेल ओवरहेड के साथ इसे लंबे समय तक करने के लिए एक दोहराने लूप के अंदर कुछ अपेक्षाकृत कम करने देता है । यदि आप इसे इनलाइन करते हैं, तो आपको यह सुनिश्चित करने के लिए कि यह कहते हैं कि यह लूप के बाहर एक संगणना नहीं फहराता है, जैसा कि आप कहते हैं कि उत्पन्न आसम को जांचना होगा।

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

संकलक-विशिष्ट तरीका है (उदाहरण के लिए) GNU C इनलाइन asm का उपयोग करने के लिए एक संकलक को एक रजिस्टर में परिणाम को उत्प्रेरित करने के लिए मजबूर करना, और / या यह भूलने के लिए कि यह चर के मूल्य के बारे में क्या जानता है, वास्तव में अतिरिक्त निर्देशों को प्रस्तुत किए बिना। "एस्केप" और "क्लोबर" एमएसवीसी में प्रोफाइलिंग और माइक्रोबेनचर्चिंग के बारे में एक वीडियो के लिंक के बराबर है (क्लैंग डेवलपर चांडलर कारुथ के कैप्पन 2015 की बात) कोई एमएसवीसी समकक्ष नहीं है, लेकिन सवाल स्वयं जीएनयू सी फ़ंक्शन और उनका उपयोग करने के तरीके को दर्शाता है।

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

Answer 14

कुछ अलग तरह के इनपुट उपयोगी हो सकते हैं: मुझे एनवीआईडीआईए क्यूडा ( पाठ्यक्रम विवरण ) के साथ जीपीजीपीयू-प्रोग्रामिंग पर एक विश्वविद्यालय पाठ्यक्रम के हिस्से के रूप में समय को मापने का यह तरीका दिया गया था । यह पहले के पोस्ट में देखे गए तरीकों को जोड़ती है, और मैं इसे केवल इसलिए पोस्ट करता हूं क्योंकि आवश्यकताएं इसे विश्वसनीयता देती हैं:

unsigned long int elapsed;
struct timeval t_start, t_end, t_diff;
gettimeofday(&t_start, NULL);

// perform computations ...

gettimeofday(&t_end, NULL);
timeval_subtract(&t_diff, &t_end, &t_start);
elapsed = (t_diff.tv_sec*1e6 + t_diff.tv_usec);
printf("GPU version runs in: %lu microsecs\n", elapsed);

मुझे लगता है कि आप 1.0 / 1000.0अपनी आवश्यकताओं के अनुरूप माप की इकाई प्राप्त करने के लिए उदाहरण के साथ गुणा कर सकते हैं।

Comments

gettimeofday अप्रचलित है और अनुशंसित नहीं है। इसके POSIX मैन पेज के clock_gettimeबजाय सिफारिश करता है, जो आपको CLOCK_MONOTONICसिस्टम घड़ी में बदलाव से प्रभावित नहीं होने के लिए कहता है, और इस तरह यह अंतराल टाइमर के रूप में बेहतर है। उदाहरण के लिए, आधुनिक लिनक्स सिस्टम, gettimeofdayमूल रूप से एक रैपर clock_gettimeहै जो नैनोसेकंड को माइक्रोसेकंड में परिवर्तित करता है। (JohnSll का उत्तर देखें)।

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

इस विधि को @Wes हार्डकर द्वारा जोड़ा गया था, मुख्य अंतर उपयोग कर रहा है timeval_subtract।

— ワ き ワ ワ

ठीक है, इसलिए आपके उत्तर का एकमात्र उपयोगी हिस्सा एक फ़ंक्शन का नाम है जिसे आप परिभाषित नहीं करते हैं, और यह मानक पुस्तकालय में नहीं है। (केवल glibc मैनुअल में: gnu.org/software/libc/manual/html_node/Elapsed-Time.html )।

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

Answer 15

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

 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");
}

Comments

यह वास्तव में adimoh के उत्तर की तुलना में कुछ भी नया नहीं जोड़ता है , सिवाय इसके कि यह कुछ वास्तविक कोड के साथ 'निष्पादन योग्य कोड' ब्लॉक (या उनमें से दो) को भरता है। और वह इस सवाल का जवाब कुछ भी है कि में नहीं था नहीं जोड़ता है एलेक्जेंडर सी के जवाब दो साल के पहले से।

— जोनाथन लेफ़लर