Delphi 6 compiler
Time elapsed for all tests: 35.38s
Delphi 7 compiler (with our enhanced RTL)
Time elapsed for all tests: 34.79s
Delphi 2007 compiler
Time elapsed for all tests: 36.04s
Delphi XE4 compiler
Time elapsed for all tests: 38.09s
Delphi XE6 compiler
Time elapsed for all tests: 37.53s
Delphi XE4 64 bit compiler
Time elapsed for all tests: 41.40s
Delphi XE6 64 bit compiler
Time elapsed for all tests: 40.87s
This is not a definitive answer.
In short, for most real process, the Delphi compiler did not improve the execution speed.
On the contrary, we may say that the generated executables are slightly slower with newer versions.
The compiler itself is perhaps not the main point during our tests, but the RTL, which was not modified with speed in mind since Delphi 2010.
Even if mORMot code by-passes the RTL for most of its process, we can still see some speed regressions when compared to pre-Unicode versions of Delphi.
In some cases, the generated asm is faster since Delphi 2007, mainly due to function inlining abilities.
But we can't say that the Delphi compiler do generate much better code in newer versions.
And we can assure you that the RTL is a true bottlenck: from our experiment, Win64 process is only slightly slower than Win32, due to the fact that we by-pass the RTL, and use our own set of low-level routines (including optimized x64 asm in
When testing the FreePascal
compiler, we found out that its generated code is slightly slower than
Floating-point is much faster with FreePascal than with Delphi, but for common code (like our framework regression tests), FreePascal is slightly less efficient than Delphi.
But still perfectly usable in production, generating smaller executables, and with better abilities to cross-platform support, and a tuned RTL.
So, is it worth upgrading?
Are newer versions of Delphi worth the price?
To be fair... Delphi compiler did not improve much since 10 years...
But just like GCC or other compilers!
The only dimension where performance did improve in order of magnitude is for floating-point process, and auto-vectorisation of the code, using SSE instructions. But for business code (like database or client-server process), the main point is definitively not the compiler, but the algorithm. The hardware did improve a lot (pipelining, cache, multi-core....), and is the main improvement axis.
Feedback is welcome on our forum, as usual.