Question

We have an assignment where we need to profile a ‘simple instruction’ (addition or bit-wise and for example). This means performing the same operation a large number of times (100K+) and measuring the average time in microseconds. The result should be presented in cycle-lengths: (totalTime/iterations)*cphMHz.

So, results may vary but all in all we were told that we should get a result close to 1 cycle-length. Actual result doesn’t matter as long as programming is correct.

My question is: what is a good operation to profile?
There are two points I need to concider:

1. I use loop unrolling to be a bit more accurate, so in each iteration I perform 10 simple instruction. This means I have to choose an operation to wouldn’t be performed only once due to compiler optimization (we can’t use -o0 flag as school staff does not).
   Bad example: var = i; – the compiler would only perform the last command.
2. What is a real ‘simple instruction’? How do I know the number of operations that are actually performed? I tried reading the assembly output, but I couldn’t understand it.

Hope I was clear enough, any idea would be great.

Thanks anyway

P.S don’t know if it matters but I write in CPP

Answer 1

1) This sounds (to me) like an impossible task, if optimizations are (or might be) enabled. You can never be sure on what the compiler will do during optimizations. I’d definitely do something like reusing the previous result. If allowed to/possible, I’d try to include a raw assembler snippet to be profiled (so you can be sure there’s no additional overhead; although it still could be optimized).

2) As for instructions: One assembler command is one instruction. E.g. a += i will – depending on available instruction set and stuff – most likely result in 4 instructions: read a, read i, add, write a. Reading assembly is pretty much straightforward. Depending on the instruction set/processor, there might be different “directions” for reading (i.e. “from -> to”). x86 assemblers (and those for most other common processors) will prefer instruction target, source, while DSPs prefer to use instruction source, target. Just important to know: moving data has to happen through registers. So even a single assignment like a = b will result in two instructions (b to register and register to a).

In general, if this answer goes into the wrong direction, try to elaborate a bit more on your specific task and its requirements (e.g. which compiler is to be used) and drop me a short comment.