3 ms·
Some people have asked about how these optimizations fare with different compilers. Do the "optimizations" hurt as one changes compilers? Do they help? Do any
by nkurz 13y ago
Some people have asked about how these optimizations fare with different compilers. Do the "optimizations" hurt as one changes compilers? Do they help? Do any of them manage to vectorize?
Here's some data:
http://lolengine.net/attachment/blog/2011/9/17/playing-with-the-cpu-pipeline/poly.cpp http://lolengine.net/attachment/blog/2011/9/17/playing-with-...
Intel(R) Xeon(R) CPU E5-1620 0 @ 3.60GHz stepping 07
uname -a: Linux 3.5.0-41-generic #64-Ubuntu SMP
clang++ -v: clang version 3.2
icpc -v: icpc version 14.0.1
g++ -v: gcc version 4.7.2:
Compiled with "-std=c++11" plus the options mentioned in the names. At a glance, all versions produced the same results to reasonable precision (no gross errors). "-ffast-math" only worked with g++, and did not offer substantial improvement, so I've omitted it from the tests.
g++_O3 icpc_O3 clang++_O3
sin: 18.193 ns 7.0174 ns 14.6862 ns
sin1: 22.5272 ns 8.0225 ns 9.6777 ns
sin2: 14.9128 ns 4.7247 ns 7.1016 ns
sin3: 18.943 ns 5.1121 ns 6.169 ns
sin4: 13.9225 ns 4.8979 ns 5.6666 ns
sin5: 14.2042 ns 5.0435 ns 6.3257 ns
sin6: 12.2543 ns 4.2955 ns 5.2681 ns
sin7: 11.6969 ns 5.0538 ns 5.5793 ns
So yes, these optimizations can still have a positive effect, but generally less than that of using a better compiler. In this case, that means if you care about performance use Intel, or if not possible, use CLang.
But what about vectorization? Perhaps the compiler can do a better job if you let it make full use of modern SIMD:
g++_O3_mavx icpc_O3_mavx clang++_O3_mavx
sin: 18.1148 ns 3.7879 ns 14.1987 ns
sin1: 22.3675 ns 6.4376 ns 9.2589 ns
sin2: 14.5665 ns 3.2823 ns 6.2089 ns
sin3: 18.3841 ns 3.6652 ns 5.2409 ns
sin4: 13.0917 ns 3.0374 ns 4.9839 ns
sin5: 13.1144 ns 3.598 ns 5.177 ns
sin6: 11.7605 ns 2.8766 ns 4.2239 ns
sin7: 11.4222 ns 3.3261 ns 4.612 ns
Yes, it looks like Intel gains quite a bit from vectorizing the result with 256-bit AVX (4-wide for doubles). If you care about autovectorization, use Intel.
This performance here generally matched my expectations. I have no affiliation with Intel other than having a free academic license, but find that in general their compiler offers better performance than GCC or CLang. In this case, Intel's best (sin6 with AVX) is 4x faster than GCC's best. I'd usually expect something more like a 20%-40% improvement, but vectorization is one of Intel's strong suits.
For those who wish to explore the reasons for the difference in performance, here are the results of 'objdump -C -d' for the functions in question:
g++_O3: http://pastebin.com/VstqvcHJ http://pastebin.com/VstqvcHJ
icpc_O3: http://pastebin.com/3LjtXAhS http://pastebin.com/3LjtXAhS
clang++_O3: http://pastebin.com/aSyCyULh http://pastebin.com/aSyCyULh
g++_O3_mavx: http://pastebin.com/81vYueEp http://pastebin.com/81vYueEp
icpc_O3_mavx: http://pastebin.com/XRdCuusV http://pastebin.com/XRdCuusV
clang++_O3_mavx: http://pastebin.com/KJqUpUBE http://pastebin.com/KJqUpUBE
Personally, I'd be very interested to see what an experienced x64 SIMD programmer could do to improve these further. My usual estimate is a further 2x, but I don't know how well that applies to this case. I'd also welcome analysis of the code produced by the compilers.
- Lockal 13y agoYour GCC and Clang are outdated and results are VERY UNFAIR in many aspects. Intel compiler violates IEEE 754 by reassociating multiplication and addition. It you want to compare icc with other compilers, you should use -Ofast option with other compilers. Also, if you compile this code with Clang 3.3, you will get the same assembly as with ICC. And with GCC 4.8 you will get even more optimal assembly. Check http://gcc.godbolt.org/ http://gcc.godbolt.org/ to see the result with different compilers (permalink to code: http://bit.ly/1euyjXZ http://bit.ly/1euyjXZ)
- nkurz 13y agoI appreciate your comment. The machine I ran this on has some strange issues that require us to keep around older versions of GCC and Clang, but I was able to install recent ICC. I hadn't known about the online compiler. That said, perhaps you could provide some numbers to back up what you are saying? I'd love to see what you think they should be. Seeing as the article is about providing rough faster estimations using series expansions, I'm OK with Intel's choice of optimizations. For GCC, does "-Ofast" do anything that "-O3 -ffast-math" doesn't? Because I tried that and it did not help. CLang threw up error messages when I tried, and since it wasn't my code I didn't bother deciphering. [Does godbolt.org give you any way to download the executable, or do you have to cut and paste the output and assemble that? I can't find a download feature, but it would seem very useful and I don't immediately see any security reasons that they wouldn't offer it.]
- nkurz 13y agoOK, I just tried on the same machine with GCC 4.8.0. Same results: ICC clobbers GCC. nate@fastpfor:~/lolengine$ g++-4.8.0 -std=c++11 poly.cpp -Ofast -march=corei7-avx -o g++-4.8.0_Ofast_march=corei7-avx nate@fastpfor:~/lolengine$ g++-4.8.0_Ofast_march\=corei7-avx sin: 18.373 ns sin1: 17.0716 ns sin2: 11.0505 ns sin3: 18.3832 ns sin4: 13.244 ns sin5: 12.8103 ns sin6: 12.0091 ns sin7: 11.4129 ns Entirely possible I'm doing something wrong. Maybe ICPC is inlining things into main() and not using the assembly I put on pastebin? But in any case, I think the ball is in your court. And with GCC 4.8 you will get even more optimal assembly. Please prove it. Is it optimal because you tested it and it ran faster, or because you believe it should be? I used to have faith in GCC, but having looked at a fair amount of generated SIMD x64 assembly, I now believe that ICC generates better code in most cases.