Hi!
I make some test last minutes to present on class an example of how assembly code runs faster than any other code. I try fasm ELF code like:

Against that C code:

But... SURPRISELY!!! the C program is wide faster than assembly one. Why is this happening? Which kind of optimization is performed by gcc? How I can optimize de fasm code to achive at least equal performance than C code. Thanks in advance

Get a disassembly listing of the C generated code. I expect you will find that the loop is completely eliminated from the code since it produces no output.

Try using something like this: You might also need to mark r or pi as volatile to force the compiler to generate the loop code.

Still, I'm quite sure the C compiler is very likely to do better job than the assembly version, I don't think that, for instance, "area" won't gonna be registered, pi will be reloaded always and pi*r*r will be recalculated in each iteration instead of moving it at for "prolog". At least one of those inefficiencies GCC will optimize out.

PS: What I've said above is only valid for the case of consuming the for-loop output, using volatile variables could indeed make the compiler be beaten by the Assembly version (for instance, GCC may be forced to access R twice from before when multiplying instead of once as the Assembly code)

PS2: (last I hope) The Assembly version is using two fp registers per iteration but releasing only one. After enough iterations, the result will be just a NaN and the processor probably will take more time executing the FPU instructions because of that (besides the before mentioned inefficiencies). Note that you have to fix this for correctness sake as you are not producing a valid result.

I don't know how you've compiled your c-file with gcc, but depending whether you use any optimization switches or not the result can be very different. For instance if you apply -O2 then nothing will be computed in run-time since "pi" and "r" are assumed to be constants (they don't change), thus the compiler eliminates the whole loop and the computation.

If you want to see what gcc generates then just use objdump -S my_file | less

On the other hand if you don't apply any optimization switch then it shan't be quicker than your assembly program.
If you really want to demonstrate how faster your assembly program is then try writing a c-code which makes the compiler believe that it is really a sane c-program and cannot be optimized to zero (as the compiler did with your current c-program).