How to shorten time quantum in measuring time difference? - c

Question

I'm trying to measure user reaction time. My code looks like this:
int clocks2ms(clock_t range) {
return (int)((double)range*1000/CLOCKS_PER_SEC);
}
clock_t start = clock(); // start measuring
while(!kbhit()); // wait for keypress
int reaction = clocks2ms(clock()-start); // measure reaction
The reaction time is 186ms (+-1ms), 201ms, 216ms etc, so there are equal 15ms gaps. Is there any way to shorten the gaps? I tried to run it with realtime priority
start "test" /Realtime "test.exe"
but nothing changed. I'd like to get 1ms accurancy.

Answer 1

You'll have to use a timer with a higher precision like GetPerformanceCounter() (ref):
LARGE_INTEGER StartCounter;
LARGE_INTEGER EndCounter;
LARGE_INTEGER Frequency;
QueryPerformanceCounter(&StartCounter);
QueryPerformanceFrequency(&Frequency);
// Do stuff...
QueryPerformanceCounter(&EndCounter);
double TimeDelta = (EndCounter.QuadPart - StartCounter.QuadPart) / (double) Frequency.QuadPart;
Note that I've omitted error checking for the Query... functions in the example code above.

Answer 2

2 approaches to gain more precise answers.
Synchronize the start. Rather than start someplace within a clock tick, start just after a change. This will typically reduce the "jitter" of the start. This idea is the better of the 2 - it does not gain a more precise answer but does improve accuracy.
clock_t prestart = clock();
clock_t start,end;
while((start = clock()) == prestart); //
puts("Hit Any Key");
fflush(stdout);
while(!kbhit()); // wait for keypress
end = clock();
int reaction = clocks2ms(end-start);
Clock cycles after end sample. This potentially improves precision, but depends on the stability of the system - that is how much other processing is going on.
unsigned count = 0;
...
while(!kbhit()); // wait for keypress
end = clock();
while(end == clock()) count++;
int reaction = clocks2ms(end + (max_cnt_per_tck-count)/max_cnt_per_tck - start);
Of course neither of these methods are better than access to a higher precision clock as suggest by #uesp. They suffer from real time aspects of systems such as the inconsistency in the time to print() or interrupts that may occur between this thread's code. But they do offer some improvement when a more precise time source is not available.

Answer 3

If the time resolution of kbhit() is the problem here, then there are a few alternatives you could try:
Since the kbhit() function is actually deprecated, you might get better results using the _kbhit() function instead.
If you are able to compile your project with ncurses, there is a getch() function that fetches characters without waiting for the return key.
This question at the C FAQ lists a few other ways of fetching characters from the console that might give better results.