Announcement

Collapse
No announcement yet.

Compiler Benchmarks Of GCC, LLVM-GCC, DragonEgg, Clang

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • Compiler Benchmarks Of GCC, LLVM-GCC, DragonEgg, Clang

    Phoronix: Compiler Benchmarks Of GCC, LLVM-GCC, DragonEgg, Clang

    LLVM 2.8 was released last month with the Clang compiler having feature-complete C++ support, enhancements to the DragonEgg GCC plug-in, a near feature-complete alternative to libstdc++, a drop-in system assembler, ARM code-generation improvements, and many other changes. With there being great interest in the Low-Level Virtual Machine, we have conducted a large LLVM-focused compiler comparison at Phoronix of GCC with versions 4.2.1 through 4.6-20101030, GCC 4.5.1 using the DragonEgg 2.8 plug-in, LLVM-GCC with LLVM 2.8 and GCC 4.2, and lastly with Clang on LLVM 2.8.

    http://www.phoronix.com/vr.php?view=15422

  • #2
    What happened there at graphics magic tests? Do the newer gccs utilize OpenMP that much better?

    Comment


    • #3
      While LLVM/Clang is not yet decisively faster than GCC, it is continuing to make great progress and does boast a different feature-set and focus from the GNU Compiler Collection.
      this template footer found in nearly every phoronix article, sounds like "please disregard this article, it's going to be obsolete soon"

      Comment


      • #4
        quite nice.
        it seems llvm likes c-ray but no chess.
        what id like to see now is a linux kernel (compiled with these different compilers) performance benchmark.

        a thing that bothers me aswell is the fact that there are being "regressions found" on intel cpu whereas there is a huge performance improvement on AMD (or vice versa). maybe one should take this into account when looking for regressions. as far as i remember there have only been benchmarks with intel hardware...
        and as the graphs show there really are some interesting splits in performance with different hardware

        Comment


        • #5
          Originally posted by jakubo View Post
          quite nice.
          it seems llvm likes c-ray but no chess.
          what id like to see now is a linux kernel (compiled with these different compilers) performance benchmark.
          Last I heard, can't be done with llvm.

          Comment


          • #6
            Sorry, that was ambiguous. As in, Linux kernel compiling can't be done with llvm.

            Comment


            • #7
              I may have missed it but what optimizations were used for these tests (especially for gcc)?

              Code:
              -march=native -mtune=native -fomit-frame-pointer -O3
              More, less?

              Comment


              • #8
                -mtune=native is redundant if you're using -march=native.
                -fomit-frame-pointer breaks debuggability in x86.
                -O3 has bugs and might slow down run-time in many cases.

                Comment


                • #9
                  Good article, nice graphs and happy bday!

                  I'd bet with time that LLVM using compilers will catch up to GCC in the rest of the tests.

                  Comment


                  • #10
                    What compiler flags were used to build each package? These benchmarks are out of context without that information.

                    Comment


                    • #11
                      I wish, there was and latest intel C++ compiler benchmark alongside these.

                      Comment


                      • #12
                        The last sentence of the The John the Ripper test analysis:

                        Originally posted by Phoronix
                        DragonEgg and Clang both lagged behind in performance miserably compared to GCC.
                        I think you meant LLVM-GCC and Clang. Because DragonEgg is basically competitive with the older versions of GCC, only falling marginally behind on the Opteron.

                        Comment


                        • #13
                          Originally posted by Tgui View Post
                          Good article, nice graphs and happy bday!

                          I'd bet with time that LLVM using compilers will catch up to GCC in the rest of the tests.
                          Possibly, but nether compiler is standing still in development so only the future will tell.

                          Comment


                          • #14
                            Originally posted by nanonyme View Post
                            -mtune=native is redundant if you're using -march=native.
                            -fomit-frame-pointer breaks debuggability in x86.
                            -O3 has bugs and might slow down run-time in many cases.
                            -O3 has been stable to compile with for ages, I can't recall having encountered any program that compiles with -O2 which has problems with -O3 in years. Also I haven't encountered any cases where -O3 is slower than -O2 in ages, so obviously these tests should be done with -O3, especially since that's where most of the new optimizations will end up.

                            Comment


                            • #15
                              Originally posted by Drago View Post
                              I wish, there was and latest intel C++ compiler benchmark alongside these.
                              Yes that would be really interesting, sadly from my past experience it has alot compability problems.

                              Comment

                              Working...
                              X