Which C++ compiler is best?
I was was reading this long thread in the Graphics theory forum ( http://www.gamedev.net/community/forums/topic.asp?topic_id=437740 ) about a "Fast vector class" which incorporated some inline asm to speed up some functions.
Any way the thread went on and on and a lot was talked about which compiler would do what with specific code as far as efficiency went.
So I was wondering, what C or C++ compilers do you all use? Which ones produce generally faster code?
I'm using GCC b/c, well, it's free, easy to get a hold of, and I like to try to follow standards when I can. So as far as I know the MS compiler is out.
But what do you all think?
( why do I sense this starting a flame war... )
I *believe* the Visual Studio 2005 compiler is also free, i *think* it is just the IDE you pay for, though i'm not sure (maybe someone can confirm.) GCC is probably more standards compliant but i think the Microsoft compiler is catching up.
As for speed, i doubt there is much difference.
As for speed, i doubt there is much difference.
gcc and whatever compiler microsoft uses in VS2005 is pretty much equal when it comes to following the standard, as far as performance goes i wouldn't know but i wouldn't be suprised if microsoft has an edge there.
For high performance compilers you may want to take a look at Intels C++ compiler 9.1 which includes features such as Auto Parallelization and Profile Guided Optimization. (its not free and its not cheap, especially when you consider the fact that it doesn't include an IDE).
http://www.intel.com/cd/software/products/asmo-na/eng/compilers/284132.htm
For high performance compilers you may want to take a look at Intels C++ compiler 9.1 which includes features such as Auto Parallelization and Profile Guided Optimization. (its not free and its not cheap, especially when you consider the fact that it doesn't include an IDE).
http://www.intel.com/cd/software/products/asmo-na/eng/compilers/284132.htm
Quote:
Auto Parallelization improves application performance on multiprocessor systems by means of automatic threading of loops. This option detects parallel loops capable of being executed safely in parallel and automatically generates multi-threaded code.
Quote:
Profile-guided Optimization (PGO)
The Profile-guided optimization (PGO) compilation process enables the Intel C++ compiler to take better advantage of the processor microarchitecture, more effectively use instruction paging and cache memory, and make better branch predictions. It improves application performance by reorganizing code layout to reduce instruction-cache thrashing, shrinking code size and reducing branch mispredictions.
PGO is a three-stage process, as shown in Figure 2. Those steps include 1) a compile of the application with instrumentation added, 2) a profile-generation phase, where the application is executed and monitored, and 3) a recompile where the data collected during the first run aids optimization.
Unless I'm off the mark, GCC (G++) is 100% standards compliant.
I have not used the MSVC++ compiler, but do know for fact that there is a good deal of code that will compile in MSVC++ and not in GCC. Syntax aside, there are other glaring standards problems with MSVC++.
For example, there was a post on here or some where only a week or so ago with a line of code similar to:
Where GCC (4.1.2), following the standard for sequence points, produced 10 as the output while MSVC++ (not sure what version) produce 12 as the output.
But I digress. Does anyone have any hard figures on performance differences?
I have not used the MSVC++ compiler, but do know for fact that there is a good deal of code that will compile in MSVC++ and not in GCC. Syntax aside, there are other glaring standards problems with MSVC++.
For example, there was a post on here or some where only a week or so ago with a line of code similar to:
Quote:
int i = 1;
cout << ( ++i + ++i + ++i ) << endl;
Where GCC (4.1.2), following the standard for sequence points, produced 10 as the output while MSVC++ (not sure what version) produce 12 as the output.
But I digress. Does anyone have any hard figures on performance differences?
Quote:Where GCC (4.1.2), following the standard for sequence points, produced 10 as the output while MSVC++ (not sure what version) produce 12 as the output.
Well acording to this the expression ( ++i + ++i + ++i ) contains no sequence points and hence the result of such an expression is undefined so GCC and MSVC++ are both correct in producing 10 and 12 respectively.
Also I'm pretty sure GCC is not 100% standards compliant (though currently I can't find a source stating this), neither is MSVC++.
msvc is a "commercial" compiler (although the express versions are free), it has the best compiler available. It can optimize code better than the gcc.
but gcc has it advantages, too. it has a "intermediate layer" of compiling.
it compiles in 2 steps, the language to some kind of logic layer and then to executable. and it optimizes quite well, not as good as the msvc, but almost the same quality. and you can compile for many platforms, and it runs on many platforms.
i would say, ms has the best specialized compiler, and the gcc is the best generic compiler available.
but gcc has it advantages, too. it has a "intermediate layer" of compiling.
it compiles in 2 steps, the language to some kind of logic layer and then to executable. and it optimizes quite well, not as good as the msvc, but almost the same quality. and you can compile for many platforms, and it runs on many platforms.
i would say, ms has the best specialized compiler, and the gcc is the best generic compiler available.
The best compiler is one which:
- Produces code which works on your target platform (this is essential)
- Has a sufficient degree of correctness that you're happy with it
- Integrates with whatever other tools you plan to use (IDE, debugger, profiler, test cover etc)
AND
- Optionally, produces reasonably optimal code. This is not usually that important unless you are writing a major scientific or engineering application.
Last time I had any information on this (A seminar on scientific computing I attended), on Intel chips (ia32), the "Best" compiler for *SOME* tasks, was the Intel C++ compiler.
Microsoft's and GCC weren't bad but didn't produce such optimal code in *SOME CASES* as the Intel one.
I've no idea how well the Intel compiler's code performs on AMD chips.
In general, code from different compilers will perform differently in different cases, on different platforms (EVEN different CPUs from a compatible architecture), and maybe even different workloads (e.g. one compiler's may perform better on a smaller data set, another on a larger one, even with the exact same code being run).
Mark
- Produces code which works on your target platform (this is essential)
- Has a sufficient degree of correctness that you're happy with it
- Integrates with whatever other tools you plan to use (IDE, debugger, profiler, test cover etc)
AND
- Optionally, produces reasonably optimal code. This is not usually that important unless you are writing a major scientific or engineering application.
Last time I had any information on this (A seminar on scientific computing I attended), on Intel chips (ia32), the "Best" compiler for *SOME* tasks, was the Intel C++ compiler.
Microsoft's and GCC weren't bad but didn't produce such optimal code in *SOME CASES* as the Intel one.
I've no idea how well the Intel compiler's code performs on AMD chips.
In general, code from different compilers will perform differently in different cases, on different platforms (EVEN different CPUs from a compatible architecture), and maybe even different workloads (e.g. one compiler's may perform better on a smaller data set, another on a larger one, even with the exact same code being run).
Mark
Getting SSE intrinsics to work in the GNU c++ compiler is difficult, though some people (not me) have gotten them to work. Inline assembly is different as well, though it's just a different syntax. As far as speed goes, I've heard good things about gcc (or whatever comes with code::blocks) and the Intel compiler, so try to see what works best for you. The one issue I'd have to warn you about is that it can be difficult to port code from Visual C++ to the GNU compiler, there are things you can't get away with, and the Microsoft standard libraries support a lot of things out of the box, like cache-aligned data allocation (though if such a function comes with code::blocks someone let me know).
Neither GCC nor MSVC follow the standard 100%. For example, neither implement the export keyword.
Both compilers also support language extensions that are non-standard. For example gcc supports nested functions and MSVC, as mentioned, accepts some template code that shouldn't strictly compile.
So the differences are not so great.
Both compilers also support language extensions that are non-standard. For example gcc supports nested functions and MSVC, as mentioned, accepts some template code that shouldn't strictly compile.
So the differences are not so great.
Quote:Original post by WavesonicsYou can get the Visual C++ 2005 Express Edition as a free download from Microsoft. It's not 100% standards compliant and as usual implements some non-standard extensions, but it is actually pretty good. I can't comment on the efficiency of the code produced (although I believe it does a good job of optimising), but if you've been avoiding this one for the reasons you listed you might want to check it out if only for the very slick IDE/tools.
I'm using GCC b/c, well, it's free, easy to get a hold of, and I like to try to follow standards when I can. So as far as I know the MS compiler is out.
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement