Problem - Kevin Tafuro

On Windows machines, you can read the same thing using
QueryPerformanceCounter( ), which takes a pointer to a 64-bit integer (the LARGE_
INTEGER or __int64 type).
You can get fairly accurate timing just by subtracting two subsequent calls to
current_stamp( ). For example, you can time how long an empty for loop with
10,000 iterations takes:
#include
int main(int argc, char *argv[ ]) {
spc_uint64_t start, finish, diff;
volatile int i;
current_stamp(&start);
for (i = 0; i < 10000; i++);
current_stamp(&finish);
diff = finish - start;
printf("That loop took %lld cycles.\n", diff);
return 0;
}
On an Athlon XP, compiling with GCC 2.95.4, the previous code will consistently
give 43–44 cycles without optimization turned on and 37–38 cycles with optimization
turned on. Generally, if i is declared volatile, the compiler won’t eliminate the
loop, even when it can figure out that there are no side effects.
Note that you can expect some minimal overhead in gathering the timestamp to
begin with. You can calculate the fixed timing overhead by timing nothing:
int main(int argc, char *argv[ ]) {
spc_uint64_t start, finish, diff;
current_stamp(&start);
current_stamp(&finish);
diff = finish - start;
printf("Timing overhead takes %lld cycles.\n", diff);
return 0;
}
On an Athlon XP, the overhead is usually reported as 0 cycles and occasionally as 1
cycle. This isn’t really accurate, because the two store operations in the first timestamp
call take about 2 to 4 cycles. The problem is largely due to pipelining and
other complex architectural issues, and it is hard to work around. You can explicitly
introduce pipeline stalls, but we’ve found that doesn’t always work as well as
expected. One thing to do is to time the processing of a large amount of data. Even
then, you will get variances in timing because of things not under your control, such
as context switches. In short, you can get within a few cycles of the truth, and
beyond that you’ll probably have to take some sort of average.
152 | Chapter 4: Symmetric Cryptography Fundamentals
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.