CODEWITHSUNDEEP
c++optimization
Pouya
Pouya

Reputation: 1276

Does building the compiler from source result in better optimization?

Consider this simple case scenario:

I download the pre-built binaries of a C++ compiler (say CLang or GCC or anything else) for my generic OS (that is not windows). I compile my code which consists of some computationally expensive mathematical calculation with optimization flag -O3 and I have an execution time of T1.

On a different attempt, this time instead of using pre-built binaries I download the source code and build the compiler by myself on my generic machine. I compile the same code with the same optimization flag, achieving execution time T2?

Will T2 < T1 or they will be more or less the same?

In other words, is the execution time independent from the way that compiler is built?

Upvotes: 2

Views: 318

Answers (4)

Arne Mertz
Arne Mertz

Reputation: 24626

That depends on how that compiler is implemented and on your platform, but the answer will be most likely "no".

If your platform provides specific functionality that can improve the performance of your program, the optimizer in your compiler might use that functionality to produce a faster program. The optimizer can do so only if the compiler writer was aware of the functionality and has implemented special treatment for your platform in the optimizer. If that is the case, the detection might be done dynamically in the optimizer, meaning any build of the optimizer can detect the platform and optimize your code. Only if the detection has to occur at compiletime of the optimizer for some reason, recompiling it on your platform could give that advantage. But if such a better build for your plaform exists, the compiler vendor most likely has provided binaries for it.

So, with all these ifs, it's unlikely that your program will be any faster when you recompile the compiler on your platform. There is a chance, however, that the compiler will be a bit faster if it is optimized to your platform rather than a generic binary, resulting on shorter compiletimes.

Upvotes: 1

PlasmaHH
PlasmaHH

Reputation: 16046

Generally the same compiler version should generate the same assembler code given the same C or C++ code input. However there are certain things that might further affect the code that is being execute when you run the compiler.

  • A distro might have backported (or even created own) patches from other versions.
  • Modern compilers often have library depenencies (e.g. cloog) that may have different behaviour in different versions, causing the compiler to make code generation decisions based on essentially other data
  • These libraries may (in some compiler versions) be optional at compile time (might need to give --enable switches to configure, or configure tries to autodetect them).
  • Compiler switches like -march=native will look on what hardware you compile and try to optimize accordingly.
  • a time limit in the compilers optimizer triggers, essentially making better optimizations on better machines; or the same for memory (I don't think thats to be found in modern compilers anymore though)

That said, even the same assembler might perform different on yours and their machine, e.g. because one is optimized for AMD, the other for intel.

Upvotes: 2

ikh
ikh

Reputation: 10427

In my opinion, and in theory, compilation speed can be faster, since you can say to "compiler which compile the compiler", "please target to my computer, and you can use my computer's processor's own machine code to optimize".

But I think compiler's optimization cannot be faster.. To make compiler's optimization faster, I think we need put something like new technology into compiler, not just re-compile.

Upvotes: 1

tenfour
tenfour

Reputation: 36896

The compiler's optimization of your code is the result of the behavior of the compiler, not the performance of the compiler.

As long as the compiler has the same behavioral design, it will produce exactly the same output.

Upvotes: 7

Related Questions