जवाबों:
मुझे लगता है कि यह काम करना चाहिए:
#include <time.h>
clock_t start = clock(), diff;
ProcessIntenseFunction();
diff = clock() - start;
int msec = diff * 1000 / CLOCKS_PER_SEC;
printf("Time taken %d seconds %d milliseconds", msec/1000, msec%1000);
gettimeofday () शायद वही करेगा जो आप चाहते हैं।
यदि आप इंटेल हार्डवेयर पर हैं, तो यहां सीपीयू वास्तविक समय अनुदेश काउंटर को कैसे पढ़ा जाए। यह आपको बताएगा कि प्रोसेसर के बूट होने के बाद से निष्पादित सीपीयू चक्रों की संख्या। यह संभवतः सबसे अच्छा-दाने वाला है, सबसे कम ओवरहेड काउंटर जो आपको प्रदर्शन माप के लिए मिल सकता है।
ध्यान दें कि यह सीपीयू चक्रों की संख्या है। लिनक्स पर आप सीपीयू की गति / proc / cpuinfo से प्राप्त कर सकते हैं और सेकंड की संख्या प्राप्त करने के लिए विभाजित कर सकते हैं। इसे डबल में बदलना काफी आसान है।
जब मैं इसे अपने बॉक्स पर चलाता हूं, तो मुझे मिल जाता है
11867927879484732 है 11867927879692217 है इसे प्रिंटफ को कॉल करने में बहुत समय लगा: 207485
यहां इंटेल डेवलपर का गाइड है जो टन के बारे में विस्तार से बताता है।
#include <stdio.h>
#include <stdint.h>
inline uint64_t rdtsc() {
uint32_t lo, hi;
__asm__ __volatile__ (
"xorl %%eax, %%eax\n"
"cpuid\n"
"rdtsc\n"
: "=a" (lo), "=d" (hi)
:
: "%ebx", "%ecx");
return (uint64_t)hi << 32 | lo;
}
main()
{
unsigned long long x;
unsigned long long y;
x = rdtsc();
printf("%lld\n",x);
y = rdtsc();
printf("%lld\n",y);
printf("it took this long to call printf: %lld\n",y-x);
}
gettimeofday सिस्टम क्लॉक के रिज़ॉल्यूशन के भीतर माइक्रोसेकंड के लिए सही समय लौटाएगा। आप SourceForge पर हाई रेस टाइमर परियोजना की जांच भी कर सकते हैं ।
मैं SDL_GetTicks का उपयोग SDL लाइब्रेरी से करता हूं ।
यदि आप सीपीयू समय नहीं चाहते हैं, तो मुझे लगता है कि आप जो खोज रहे हैं वह टाइमवॉल संरचना है।
मैं निष्पादन समय की गणना के लिए नीचे का उपयोग करता हूं:
int timeval_subtract(struct timeval *result,
struct timeval end,
struct timeval start)
{
if (start.tv_usec < end.tv_usec) {
int nsec = (end.tv_usec - start.tv_usec) / 1000000 + 1;
end.tv_usec -= 1000000 * nsec;
end.tv_sec += nsec;
}
if (start.tv_usec - end.tv_usec > 1000000) {
int nsec = (end.tv_usec - start.tv_usec) / 1000000;
end.tv_usec += 1000000 * nsec;
end.tv_sec -= nsec;
}
result->tv_sec = end.tv_sec - start.tv_sec;
result->tv_usec = end.tv_usec - start.tv_usec;
return end.tv_sec < start.tv_sec;
}
void set_exec_time(int end)
{
static struct timeval time_start;
struct timeval time_end;
struct timeval time_diff;
if (end) {
gettimeofday(&time_end, NULL);
if (timeval_subtract(&time_diff, time_end, time_start) == 0) {
if (end == 1)
printf("\nexec time: %1.2fs\n",
time_diff.tv_sec + (time_diff.tv_usec / 1000000.0f));
else if (end == 2)
printf("%1.2fs",
time_diff.tv_sec + (time_diff.tv_usec / 1000000.0f));
}
return;
}
gettimeofday(&time_start, NULL);
}
void start_exec_timer()
{
set_exec_time(0);
}
void print_exec_timer()
{
set_exec_time(1);
}
उच्च संकल्प सापेक्ष है ... मैं उदाहरणों को देख रहा था और वे ज्यादातर मिलीसेकंड के लिए पूरा करते हैं। हालांकि मेरे लिए माइक्रोसेकंड को मापना महत्वपूर्ण है। मैंने माइक्रोसेकंड के लिए एक प्लेटफ़ॉर्म इंडिपेंडेंट सॉल्यूशन नहीं देखा है और सोचा है कि नीचे दिए गए कोड की तरह कुछ उपयोगी होगा। मैं केवल समय के लिए खिड़कियों पर टाइम कर रहा था और AIX / Linux पर ऐसा ही करते समय एक gettimeofday () कार्यान्वयन जोड़ देगा।
#ifdef WIN32
#ifndef PERFTIME
#include <windows.h>
#include <winbase.h>
#define PERFTIME_INIT unsigned __int64 freq; QueryPerformanceFrequency((LARGE_INTEGER*)&freq); double timerFrequency = (1.0/freq); unsigned __int64 startTime; unsigned __int64 endTime; double timeDifferenceInMilliseconds;
#define PERFTIME_START QueryPerformanceCounter((LARGE_INTEGER *)&startTime);
#define PERFTIME_END QueryPerformanceCounter((LARGE_INTEGER *)&endTime); timeDifferenceInMilliseconds = ((endTime-startTime) * timerFrequency); printf("Timing %fms\n",timeDifferenceInMilliseconds);
#define PERFTIME(funct) {unsigned __int64 freq; QueryPerformanceFrequency((LARGE_INTEGER*)&freq); double timerFrequency = (1.0/freq); unsigned __int64 startTime; QueryPerformanceCounter((LARGE_INTEGER *)&startTime); unsigned __int64 endTime; funct; QueryPerformanceCounter((LARGE_INTEGER *)&endTime); double timeDifferenceInMilliseconds = ((endTime-startTime) * timerFrequency); printf("Timing %fms\n",timeDifferenceInMilliseconds);}
#endif
#else
//AIX/Linux gettimeofday() implementation here
#endif
उपयोग:
PERFTIME(ProcessIntenseFunction());
or
PERFTIME_INIT
PERFTIME_START
ProcessIntenseFunction()
PERFTIME_END