Problem - Kevin Tafuro

time by subtracting the start from the end. Here’s a function to do both, which
requires you to define a constant with your clock speed in gigahertz:
#define MY_GHZ 1.6666666666666667 /* We're using an Athlon XP 2000 */
spc_uint64_t get_cycle_count(spc_uint64_t start, spc_uint64_t end) {
return (spc_uint64_t)((end - start) / (doublt)MY_GHZ);
}
Timing cryptographic code
When timing cryptographic primitives, you’ll generally want to know how many
cycles it takes to process a byte, on average. That’s easy: just divide the number of
bytes you process by the number of cycles it takes to process. If you wish, you can
remove overhead from the cycle count, such as timing overhead (e.g., a loop).
One important thing to note about timing cryptographic code is that some types of
algorithms have different performance characteristics as they process more data.
That is, they can be dominated by per-message overhead costs for small message
sizes. For example, most hash functions such as SHA1 are significantly slower (per
byte) for small messages than they are for large messages.
You need to figure out whether you care about optimal performance or average-case
performance. Most often, it will be the latter. For example, if you are comparing the
speeds of SHA1 and some other cryptographic hash function such as RIPEMD-160,
you should ask yourself what range of message sizes you expect to see and test for
values sampled throughout that range.
154 | Chapter 4: Symmetric Cryptography Fundamentals
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.