我希望能在C语言中测量时间，但是我很难弄清楚怎么做，我只想要类似以下这样的东西：
- 开始计时
- 运行一个方法
- 停止计时
- 报告所用时间（至少精确到微秒）
任何帮助都将不胜感激。
（我正在使用mingw编译windows系统）
7个回答
106
高分辨率定时器提供微秒级别的分辨率，但是由于其与系统相关，因此在不同的操作系统平台上需要使用不同的方法来实现。您可能会对查看以下文章感兴趣，该文章基于下面描述的函数实现了一个跨平台的C++定时器类：
- [宋浩安 - 高分辨率计时器][1]
Windows
Windows API提供了极高分辨率的计时器函数：QueryPerformanceCounter()，返回当前经过的滴答数，QueryPerformanceFrequency()，返回每秒钟的滴答数。
示例：
#include <stdio.h>
#include <windows.h> // for Windows APIs
int main(void)
{
LARGE_INTEGER frequency; // ticks per second
LARGE_INTEGER t1, t2; // ticks
double elapsedTime;
// get ticks per second
QueryPerformanceFrequency(&frequency);
// start timer
QueryPerformanceCounter(&t1);
// do something
// ...
// stop timer
QueryPerformanceCounter(&t2);
// compute and print the elapsed time in millisec
elapsedTime = (t2.QuadPart - t1.QuadPart) * 1000.0 / frequency.QuadPart;
printf("%f ms.\n", elapsedTime);
}
Linux、Unix和Mac
对于基于Unix或Linux的系统，您可以使用gettimeofday()。该函数在"sys/time.h"中声明。
示例：
#include <stdio.h>
#include <sys/time.h> // for gettimeofday()
int main(void)
{
struct timeval t1, t2;
double elapsedTime;
// start timer
gettimeofday(&t1, NULL);
// do something
// ...
// stop timer
gettimeofday(&t2, NULL);
// compute and print the elapsed time in millisec
elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0; // sec to ms
elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0; // us to ms
printf("%f ms.\n", elapsedTime);
}
- Daniel Vassallo
8
7我认为应该是"struct timeval"，而不仅仅是"timeval"。 - rightaway717
1
struct timeval 对我有用（某些GCC ARM编译器）。 - Micka6此解决方案适用于C++，但问题要求使用C语言。为什么这个被接受了呢？ - Ethan Yang
1我需要一个 C 版本。这可能吗？ - kame
1我使用C语言，这个解决方案在C语言中有效。@EthanYang - codemonkey
显示剩余3条评论
23
在Linux上，你可以使用clock_gettime()函数:
clock_gettime(CLOCK_REALTIME, &start); // get initial time-stamp
// ... do stuff ... //
clock_gettime(CLOCK_REALTIME, &end); // get final time-stamp
double t_ns = (double)(end.tv_sec - start.tv_sec) * 1.0e9 +
(double)(end.tv_nsec - start.tv_nsec);
// subtract time-stamps and
// multiply to get elapsed
// time in ns
- Paul R
3
1为什么会有负评？请参考http://linux.die.net/man/3/clock_gettime 了解更多关于clock_gettime的信息。 - Paul R
1
CLOCK_REALTIME 更合适吧？参见：https://stackoverflow.com/questions/23483261/using-clock-process-cputime-id-in-clock-gettime - Mahyar Mirrashed1@MahyarMirrashed：是的，在撰写本文时（2010年），
CLOCK_REALTIME并不普遍可用，但现在使用它可能是安全的。 - Paul R3
这是我编写的一个头文件，用于进行一些简单的性能分析（使用手动计时器）：
#ifndef __ZENTIMER_H__
#define __ZENTIMER_H__
#ifdef ENABLE_ZENTIMER
#include <stdio.h>
#ifdef WIN32
#include <windows.h>
#else
#include <sys/time.h>
#endif
#ifdef HAVE_STDINT_H
#include <stdint.h>
#elif HAVE_INTTYPES_H
#include <inttypes.h>
#else
typedef unsigned char uint8_t;
typedef unsigned long int uint32_t;
typedef unsigned long long uint64_t;
#endif
#ifdef __cplusplus
extern "C" {
#pragma }
#endif /* __cplusplus */
#define ZTIME_USEC_PER_SEC 1000000
/* ztime_t represents usec */
typedef uint64_t ztime_t;
#ifdef WIN32
static uint64_t ztimer_freq = 0;
#endif
static void
ztime (ztime_t *ztimep)
{
#ifdef WIN32
QueryPerformanceCounter ((LARGE_INTEGER *) ztimep);
#else
struct timeval tv;
gettimeofday (&tv, NULL);
*ztimep = ((uint64_t) tv.tv_sec * ZTIME_USEC_PER_SEC) + tv.tv_usec;
#endif
}
enum {
ZTIMER_INACTIVE = 0,
ZTIMER_ACTIVE = (1 << 0),
ZTIMER_PAUSED = (1 << 1),
};
typedef struct {
ztime_t start;
ztime_t stop;
int state;
} ztimer_t;
#define ZTIMER_INITIALIZER { 0, 0, 0 }
/* default timer */
static ztimer_t __ztimer = ZTIMER_INITIALIZER;
static void
ZenTimerStart (ztimer_t *ztimer)
{
ztimer = ztimer ? ztimer : &__ztimer;
ztimer->state = ZTIMER_ACTIVE;
ztime (&ztimer->start);
}
static void
ZenTimerStop (ztimer_t *ztimer)
{
ztimer = ztimer ? ztimer : &__ztimer;
ztime (&ztimer->stop);
ztimer->state = ZTIMER_INACTIVE;
}
static void
ZenTimerPause (ztimer_t *ztimer)
{
ztimer = ztimer ? ztimer : &__ztimer;
ztime (&ztimer->stop);
ztimer->state |= ZTIMER_PAUSED;
}
static void
ZenTimerResume (ztimer_t *ztimer)
{
ztime_t now, delta;
ztimer = ztimer ? ztimer : &__ztimer;
/* unpause */
ztimer->state &= ~ZTIMER_PAUSED;
ztime (&now);
/* calculate time since paused */
delta = now - ztimer->stop;
/* adjust start time to account for time elapsed since paused */
ztimer->start += delta;
}
static double
ZenTimerElapsed (ztimer_t *ztimer, uint64_t *usec)
{
#ifdef WIN32
static uint64_t freq = 0;
ztime_t delta, stop;
if (freq == 0)
QueryPerformanceFrequency ((LARGE_INTEGER *) &freq);
#else
#define freq ZTIME_USEC_PER_SEC
ztime_t delta, stop;
#endif
ztimer = ztimer ? ztimer : &__ztimer;
if (ztimer->state != ZTIMER_ACTIVE)
stop = ztimer->stop;
else
ztime (&stop);
delta = stop - ztimer->start;
if (usec != NULL)
*usec = (uint64_t) (delta * ((double) ZTIME_USEC_PER_SEC / (double) freq));
return (double) delta / (double) freq;
}
static void
ZenTimerReport (ztimer_t *ztimer, const char *oper)
{
fprintf (stderr, "ZenTimer: %s took %.6f seconds\n", oper, ZenTimerElapsed (ztimer, NULL));
}
#ifdef __cplusplus
}
#endif /* __cplusplus */
#else /* ! ENABLE_ZENTIMER */
#define ZenTimerStart(ztimerp)
#define ZenTimerStop(ztimerp)
#define ZenTimerPause(ztimerp)
#define ZenTimerResume(ztimerp)
#define ZenTimerElapsed(ztimerp, usec)
#define ZenTimerReport(ztimerp, oper)
#endif /* ENABLE_ZENTIMER */
#endif /* __ZENTIMER_H__ */
ztime()函数是您需要的主要逻辑——它获取当前时间并将其存储在一个以微秒为单位的64位无符号整数中。然后你可以通过简单的数学运算来找出经过的时间。
ZenTimer*()函数只是帮助函数，接受一个指向简单计时器结构体ztimer_t的指针，该结构体记录了开始时间和结束时间。 ZenTimerPause()/ZenTimerResume()函数允许您暂停和恢复计时器，以防您想打印一些不需要计时的调试信息，例如。您可以在http://www.gnome.org/~fejj/code/zentimer.h上找到原始头文件的副本，在极小的可能情况下我可能弄错了<'s等html转义字符。 它在MIT/X11下获得许可，因此请随意将其复制到任何项目中。
- jstedfast
2
以下是一组基于gettimeofday()系统调用的通用C函数，用于定时器管理。所有定时器属性都包含在一个单独的ticktimer结构体中 - 您想要的时间间隔，自计时器初始化以来的总运行时间，指向您想要调用的所需回调的指针，回调被调用的次数。回调函数看起来像这样：
要初始化并启动计时器，请调用ticktimer_init(your_timer, interval, TICKTIMER_RUN, your_timer_cb, 0)。
在程序的主循环中调用ticktimer_tick(your_timer)，它将决定是否已经过了适当的时间来调用回调函数。
要停止计时器，只需调用ticktimer_ctl(your_timer, TICKTIMER_STOP)。
ticktimer.h:
void your_timer_cb (struct ticktimer *t) {
/* do your stuff here */
}
要初始化并启动计时器，请调用ticktimer_init(your_timer, interval, TICKTIMER_RUN, your_timer_cb, 0)。
在程序的主循环中调用ticktimer_tick(your_timer)，它将决定是否已经过了适当的时间来调用回调函数。
要停止计时器，只需调用ticktimer_ctl(your_timer, TICKTIMER_STOP)。
ticktimer.h:
#ifndef __TICKTIMER_H
#define __TICKTIMER_H
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#define TICKTIMER_STOP 0x00
#define TICKTIMER_UNCOMPENSATE 0x00
#define TICKTIMER_RUN 0x01
#define TICKTIMER_COMPENSATE 0x02
struct ticktimer {
u_int64_t tm_tick_interval;
u_int64_t tm_last_ticked;
u_int64_t tm_total;
unsigned ticks_total;
void (*tick)(struct ticktimer *);
unsigned char flags;
int id;
};
void ticktimer_init (struct ticktimer *, u_int64_t, unsigned char, void (*)(struct ticktimer *), int);
unsigned ticktimer_tick (struct ticktimer *);
void ticktimer_ctl (struct ticktimer *, unsigned char);
struct ticktimer *ticktimer_alloc (void);
void ticktimer_free (struct ticktimer *);
void ticktimer_tick_all (void);
#endif
ticktimer.c:
#include "ticktimer.h"
#define TIMER_COUNT 100
static struct ticktimer timers[TIMER_COUNT];
static struct timeval tm;
/*!
@brief
Initializes/sets the ticktimer struct.
@param timer
Pointer to ticktimer struct.
@param interval
Ticking interval in microseconds.
@param flags
Flag bitmask. Use TICKTIMER_RUN | TICKTIMER_COMPENSATE
to start a compensating timer; TICKTIMER_RUN to start
a normal uncompensating timer.
@param tick
Ticking callback function.
@param id
Timer ID. Useful if you want to distinguish different
timers within the same callback function.
*/
void ticktimer_init (struct ticktimer *timer, u_int64_t interval, unsigned char flags, void (*tick)(struct ticktimer *), int id) {
gettimeofday(&tm, NULL);
timer->tm_tick_interval = interval;
timer->tm_last_ticked = tm.tv_sec * 1000000 + tm.tv_usec;
timer->tm_total = 0;
timer->ticks_total = 0;
timer->tick = tick;
timer->flags = flags;
timer->id = id;
}
/*!
@brief
Checks the status of a ticktimer and performs a tick(s) if
necessary.
@param timer
Pointer to ticktimer struct.
@return
The number of times the timer was ticked.
*/
unsigned ticktimer_tick (struct ticktimer *timer) {
register typeof(timer->tm_tick_interval) now;
register typeof(timer->ticks_total) nticks, i;
if (timer->flags & TICKTIMER_RUN) {
gettimeofday(&tm, NULL);
now = tm.tv_sec * 1000000 + tm.tv_usec;
if (now >= timer->tm_last_ticked + timer->tm_tick_interval) {
timer->tm_total += now - timer->tm_last_ticked;
if (timer->flags & TICKTIMER_COMPENSATE) {
nticks = (now - timer->tm_last_ticked) / timer->tm_tick_interval;
timer->tm_last_ticked = now - ((now - timer->tm_last_ticked) % timer->tm_tick_interval);
for (i = 0; i < nticks; i++) {
timer->tick(timer);
timer->ticks_total++;
if (timer->tick == NULL) {
break;
}
}
return nticks;
} else {
timer->tm_last_ticked = now;
timer->tick(timer);
timer->ticks_total++;
return 1;
}
}
}
return 0;
}
/*!
@brief
Controls the behaviour of a ticktimer.
@param timer
Pointer to ticktimer struct.
@param flags
Flag bitmask.
*/
inline void ticktimer_ctl (struct ticktimer *timer, unsigned char flags) {
timer->flags = flags;
}
/*!
@brief
Allocates a ticktimer struct from an internal
statically allocated list.
@return
Pointer to the newly allocated ticktimer struct
or NULL when no more space is available.
*/
struct ticktimer *ticktimer_alloc (void) {
register int i;
for (i = 0; i < TIMER_COUNT; i++) {
if (timers[i].tick == NULL) {
return timers + i;
}
}
return NULL;
}
/*!
@brief
Marks a previously allocated ticktimer struct as free.
@param timer
Pointer to ticktimer struct, usually returned by
ticktimer_alloc().
*/
inline void ticktimer_free (struct ticktimer *timer) {
timer->tick = NULL;
}
/*!
@brief
Checks the status of all allocated timers from the
internal list and performs ticks where necessary.
@note
Should be called in the main loop.
*/
inline void ticktimer_tick_all (void) {
register int i;
for (i = 0; i < TIMER_COUNT; i++) {
if (timers[i].tick != NULL) {
ticktimer_tick(timers + i);
}
}
}
- Blagovest Buyukliev
1
使用time.h库，可以尝试以下代码：
long start_time, end_time, elapsed;
start_time = clock();
// Do something
end_time = clock();
elapsed = (end_time - start_time) / CLOCKS_PER_SEC * 1000;
- Aaron
4
CLK_TCK已经过时，请使用CLOCKS_PER_SEC代替。 - Christoph4"clock()"函数无法实现1微秒的分辨率。有一份资料显示它的分辨率约为15毫秒：http://www.songho.ca/misc/timer/timer.html - Daniel Vassallo
1clock() 的粒度在不同的系统上有所不同。 - lyxera
clock() 返回程序使用的处理器时间。使用 sleep，usleep 等可能会在您的软件中引起问题。 - Bayou0
对于 GNU 环境上下的好答案都很棒...
但是...如果你不在操作系统上运行呢？（或者说你需要计时定时器中断本身，或者你不在 PC 上运行）？这里有一个解决方案，直接使用 x86 CPU 时间戳计数器...并不是因为这是好的实践，或者应该在操作系统下运行时做的事情...
- 注意：仅适用于禁用频率缩放的 x86。
- 在 Linux 下，仅适用于非无滴答内核。
rdtsc.c:
#include <sys/time.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef unsigned long long int64;
static __inline__ int64 getticks(void)
{
unsigned a, d;
asm volatile("rdtsc" : "=a" (a), "=d" (d));
return (((int64)a) | (((int64)d) << 32));
}
int main(){
int64 tick,tick1;
unsigned time=0,mt;
// mt is the divisor to give microseconds
FILE *pf;
int i,r,l,n=0;
char s[100];
// time how long it takes to get the divisors, as a test
tick = getticks();
// get the divisors - todo: for max performance this can
// output a new binary or library with these values hardcoded
// for the relevant CPU - if you use the equivalent assembler for
// that CPU
pf = fopen("/proc/cpuinfo","r");
do {
r=fscanf(pf,"%s",&s[0]);
if (r<0) {
n=5; break;
} else if (n==0) {
if (strcmp("MHz",s)==0) n=1;
} else if (n==1) {
if (strcmp(":",s)==0) n=2;
} else if (n==2) {
n=3;
};
} while (n<3);
fclose(pf);
s[9]=(char)0;
strcpy(&s[4],&s[5]);
mt=atoi(s);
printf("#define mt %u // (%s Hz) hardcode this for your a CPU-specific binary ;-)\n",mt,s);
tick1 = getticks();
time = (unsigned)((tick1-tick)/mt);
printf("%u ms\n",time);
// time the duration of sleep(1) - plus overheads ;-)
tick = getticks();
sleep(1);
tick1 = getticks();
time = (unsigned)((tick1-tick)/mt);
printf("%u ms\n",time);
return 0;
}
使用以下命令进行编译和运行
$ gcc rdtsc.c -o rdtsc && ./rdtsc
它从 /proc/cpuinfo 读取您 CPU 的除数，并显示读取该除数所需的微秒数，以及执行 sleep(1) 所需的时间... 假设 /proc/cpuinfo 中的 Mhz 评级始终包含 3 个小数点 :-o
- dagelf
2
待办事项：查看/proc/cpuinfo获取它的位置...但我猜测它会计时...所以你最好从内核保存它的更直接格式中读取... - dagelf
谁有兴趣更新此内容，直接从内核中读取？http://lxr.linux.no/linux+v3.8.1/arch/x86/kernel/cpu/proc.c
http://lxr.linux.no/linux+v3.8.1/drivers/cpufreq/cpufreq.c#L1217 -- 甚至可以让它在频率缩放设备上工作... - dagelf
0
如果您的 Linux 系统支持它，clock_gettime(CLOCK_MONOTONIC) 应该是一个高分辨率计时器，不受系统日期更改（例如 NTP 守护进程）的影响。
- Neil
1
1他说他在Windows上使用的是MinGW而不是Linux。 - Shedokan
网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接