Page 2 of 10 FirstFirst 1234 ... LastLast
Results 11 to 20 of 94

Thread: FreeBSD 10 To Use Clang Compiler, Deprecate GCC

  1. #11
    Join Date
    Dec 2008
    Location
    Creve Coeur, Missouri
    Posts
    394

    Default

    Quote Originally Posted by XorEaxEax View Post
    Not unless I employ optimizations not available in Clang/LLVM, like profile guided optimization or openmp in which case yes GCC often runs circles around Clang/LLVM but it's a bit 'unfair' as these are rather 'exotic' optimizations not always in use and also that they will eventually make their way into Clang/LLVM.
    See, the thing is that Clang will pretty much always be years behind in performance. Is anybody drawing parallels between this and the open source graphics vs propriety graphics situation? LMFAO

  2. #12
    Join Date
    Feb 2012
    Posts
    111

    Default

    Well what all that tells me? I used to like FreeBSD but I see more and more value in the GPL. Pretty obviously being forced to choices by sponsors, aka by money, isn't really my vision of open source (yeah they're allowed to have that vision, but I find the free software one much more attractive).
    Sorry, but GPL-licensed projects are driven by money too (for example : http://lwn.net/Articles/395961/) ... the manpower difference between a full-time programmer and a hobbist is BIG and you see that when decisions are made

  3. #13

    Default

    Quote Originally Posted by LinuxID10T View Post
    Lets just forget for the second that X11 already has far, far more features than Wayland. Computers are getting faster all the time, if feature bloat is a problem, it shouldn't be now. I am sick of people that keep trying to reinvent the wheel. WHY?!? Yeah, X11 is old, but it works. The time can be better put into far more useful things. Just my opinion.
    Sadly, X11 is old and can't compete with Windows and OS X solutions. Wayland is big step forward unlike Clang/llvm which is big step backward for now.

  4. #14

    Default

    Quote Originally Posted by vertexSymphony View Post
    Sorry, but GPL-licensed projects are driven by money too (for example : http://lwn.net/Articles/395961/) ... the manpower difference between a full-time programmer and a hobbist is BIG and you see that when decisions are made
    Apples to oranges. Linux developers are being payed and he was talking about sponsors that seems to be deciding what's good for BSD.

  5. #15
    Join Date
    Oct 2009
    Posts
    845

    Default

    Quote Originally Posted by LinuxID10T View Post
    See, the thing is that Clang will pretty much always be years behind in performance.
    That's impossible to say, however yes I will say that it is currently quite a bit behind GCC. However those with agendas can always skew the statistics to their liking, one of which is the choice of optimization flags. For instance Micheal recently published a test between GCC 4.6/4.7 and LLVM-Clang 3.0/3.1 where he did a 7-zip benchmark with no optimization flags. That means that the compilers (atleast GCC) makes no attempts to optimize the code, hence from a benchmark standpoint it's worthless. However choosing this likely gave Micheal the statistic he wanted, which was a win for Clang/LLVM. Another thing is synthetic tests vs real-world tests, synthetic tests can be very misgiving, case in point:

    I made my own benchmark script for 7-zip which I ran on a core i7, comparing GCC 4.7 against Clang 3.0, I tested both the synthetic benchmark which is built into 7-zip and also did a real-world benchmark of actually compressing a file (in this case an arch linux ISO, I'm an arch guy, what can I say), here are the results at different optimization levels:

    Code:
    GCC    -O0 -march=corei7   1m2.420s  (real-world benchmark, less is better)
    GCC    -O0 -march=corei7   5354      (synthetic benchmark, more is better)
    Clang  -O0 -march=corei7   1m1.143s  (real-world benchmark, less is better)
    Clang  -O0 -march=corei7   5446      (synthetic benchmark, more is better)
    GCC    -O1 -march=corei7   0m32.008s (real-world benchmark, less is better)
    GCC    -O1 -march=corei7   11375     (synthetic benchmark, more is better)
    Clang  -O1 -march=corei7   0m35.316s (real-world benchmark, less is better)
    Clang  -O1 -march=corei7   11650     (synthetic benchmark, more is better)
    GCC    -O2 -march=corei7   0m31.076s (real-world benchmark, less is better)
    GCC    -O2 -march=corei7   11704     (synthetic benchmark, more is better)
    Clang  -O2 -march=corei7   0m34.550s (real-world benchmark, less is better)
    Clang  -O2 -march=corei7   11808     (synthetic benchmark, more is better)
    GCC    -O3 -march=corei7   0m29.432s (real-world benchmark, less is better)
    GCC    -O3 -march=corei7   11890     (synthetic benchmark, more is better)
    Clang  -O3 -march=corei7   0m34.335s (real-world benchmark, less is better)
    Clang  -O3 -march=corei7   11796     (synthetic benchmark, more is better)
    As we can see, on this synthetic benchmarks, Clang/LLVM wins up until -O3 where GCC wins, so by choosing -O0 up to -O2 and only using synthetic benchmarking Clang/LLVM would come out the winner. However given that -O3 is the option where the compiler is supposed to favour speed over anything else (like code size) then I can't see why someone, if they only test ONE option would test anything else, unless of course you want the results to reflect some agenda.

    And looking past the synthetic benchmark and at the real-world benchmark which is what actually reflects the REAL usage of 7-zip, GCC wins across the board, with a very noticeable performance increase.

    Here's the script I made (sorry for my poor bash script-fu), it will automatically download p7zip and an arch linux iso (just the first time, not every run!) which it will compress in the real-world test. There's also support for ICC (intel compiler) testing there but I didn't use it for this test. The results of the benchmarking is saved in p7zip-results.txt in the same directory from which you run the script:

    Code:
    #!/bin/bash
    name=p7zip_
    version=9.20.1
    dir=$name$version
    results=../p7zip-results.txt
    makefile=makefile.linux_amd64
    arg="./bin/7za a -mx9 -m0=LZMA2:d128m -mmt dummy.7z archlinux-2011.08.19-netinstall-i686.iso"
    arg2="./bin/7za b"
    
    # change flags according to the optimization settings you want to benchmark
    gccflags="-O3 -march=corei7"
    clangflags="-O3 -march=corei7"
    iccflags="-O3 -march=corei7"
    
    # uncomment compilers to be tested (obviously they need to have been installed)
    gcc=1
    clang=1
    #icc=1
    
    if [ ! -d $dir ]; then
    	echo "Downloading and extracting p7zip..."
    	wget -q http://downloads.sourceforge.net/project/p7zip/p7zip/${version}/p7zip_${version}_src_all.tar.bz2
    	bzip2 -q -d "$dir"_src_all.tar.bz2
    	tar xf "$dir"_src_all.tar
    fi
    
    cd $dir
    
    if [ ! -e archlinux-2011.08.19-netinstall-i686.iso ]; then
    	echo "Downloading iso..."
    	wget -q http://ftp.ds.hj.se/pub/os/linux/archlinux/iso/2011.08.19/archlinux-2011.08.19-netinstall-i686.iso
    fi
    
    # access the file for cache purposes else the first real-world test will likely suffer in disk read performance. 
    tar cvf dummy.tar archlinux-2011.08.19-netinstall-i686.iso
    rm dummy.tar
    
    
    if [ ! -z $gcc ]; then
    # GCC ----------------------------------------------------------------------------------------------------
    cp $makefile makefile.machine
    sed -i "s/OPTFLAGS=-O/OPTFLAGS=$gccflags/" makefile.machine
    make clean
    make -j5
    clear
    echo "Benchmarking..."
    bench=`{ time ${arg}; } 2>&1 | grep real | awk '{print $2}'`
    echo -e "GCC\t\t$gccflags\t\t$bench\t(real-world benchmark, less is better)" >> $results
    bench=`{ ${arg2}; } 2>&1 | grep Tot | awk '{printf $4}'`
    echo -e "GCC\t\t$gccflags\t\t$bench\t\t(synthetic benchmark, more is better)" >> $results
    rm dummy.7z
    fi
    
    if [ ! -z $clang ]; then
    # CLANG/LLVM ---------------------------------------------------------------------------------------------
    cp $makefile makefile.machine
    sed -i "s/OPTFLAGS=-O/OPTFLAGS=$clangflags/" makefile.machine
    sed -i 's/CXX=g++/CXX=clang++/' makefile.machine
    sed -i 's/CC=gcc/CC=clang/' makefile.machine
    make clean
    make -j5
    clear
    echo "Benchmarking..."
    bench=`{ time ${arg}; } 2>&1 | grep real | awk '{print $2}'`
    echo -e "Clang\t\t$clangflags\t\t$bench\t(real-world benchmark, less is better)" >> $results
    bench=`{ ${arg2}; } 2>&1 | grep Tot | awk '{printf $4}'`
    echo -e "Clang\t\t$clangflags\t\t$bench\t\t(synthetic benchmark, more is better)" >> $results
    rm dummy.7z
    fi
    
    
    if [ ! -z $icc ]; then
    # ICC ---------------------------------------------------------------------------------------------
    cp $makefile makefile.machine
    sed -i "s/OPTFLAGS=-O/OPTFLAGS=$iccflags/" makefile.machine
    sed -i 's/CXX=g++/CXX=icpc/' makefile.machine
    sed -i 's/CC=gcc/CC=icc/' makefile.machine
    make clean
    make -j5
    clear
    echo "Benchmarking..."
    bench=`{ time ${arg}; } 2>&1 | grep real | awk '{print $2}'`
    echo -e "ICC  \t\t$iccflags\t\t$bench\t(real-world benchmark, less is better)" >> $results
    bench=`{ ${arg2}; } 2>&1 | grep Tot | awk '{printf $4}'`
    echo -e "ICC  \t\t$iccflags\t\t$bench\t\t(synthetic benchmark, more is better)" >> $results
    rm dummy.7z
    fi
    
    echo "Done! Open '$results' to see the benchmark results."

  6. #16
    Join Date
    Oct 2009
    Location
    West Jordan, Utah, USA
    Posts
    53

    Default more free-libre compilers == good

    As a developer I am happy to see clang becoming robust enough to be considered a replacement for gcc.

    Competition is good, folks.
    gcc's only competetion (on *nix) for a long time has been proprietary compilers from the likes of intel and IBM.

    ...AND

    There is one area where clang kicks the crap out of gcc:

    COMPILER ERRORS

    No kidding. gcc sometimes gives you a useful error, but often it is meaningless or even misleading.
    I have at times installed clang just to recompile some c++ code where it was failing to compile under gcc and the error was completely incomprehensible.

    gcc is that bad.

    I am a big fan of the GPL, but NiH notwithstanding, clang is a welcome addition.

  7. #17
    Join Date
    Feb 2010
    Posts
    11

    Default

    Quote Originally Posted by XorEaxEax View Post
    I made my own benchmark script for 7-zip which I ran on a core i7, comparing GCC 4.7 against Clang 3.0, I tested both the synthetic benchmark which is built into 7-zip and also did a real-world benchmark of actually compressing a file (in this case an arch linux ISO, I'm an arch guy, what can I say), here are the results at different optimization levels:
    I suggest you try using profile guided optimization on the GCC build. In extreme cases I noticed a 50%~100% speedup when using PGO, and most people ignore this really great optimization.

  8. #18
    Join Date
    Oct 2009
    Posts
    845

    Default

    Quote Originally Posted by kiputnik View Post
    I suggest you try using profile guided optimization on the GCC build. In extreme cases I noticed a 50%~100% speedup when using PGO, and most people ignore this really great optimization.
    I know, and I do use it for my own code and sometimes even for benchmarking. However it's not a 'trivial' optimization as it's not just about adding a compiler flag but you also have to run the executable in a profiling stage and then compile again.

    This is also likely why most people don't use it, although of course it can be automated like done in Firefox, x264 etc. And yes it can seriously yield great results in cpu intensive code since it uses gathered runtime information which allows the optimizer to make much better choices concerning loop unrolling, branch prediction etc, of course as always sometimes the gains are big, sometimes barely noticeable which obviously depends on how good the optimizer was at correctly estimating without the benefit of runtime data.

    For this particular test I wanted the flags to be the same (Clang/LLVM doesn't have PGO), and also stick to the standard -Ox flags even though GCC could potentially be faster by enabling further optimizations.

  9. #19
    Join Date
    Oct 2011
    Location
    Toruń, Poland
    Posts
    160

    Default

    Quote Originally Posted by kiputnik View Post
    I suggest you try using profile guided optimization on the GCC build. In extreme cases I noticed a 50%~100% speedup when using PGO, and most people ignore this really great optimization.
    I remember my old Lunar Linux (source based distro) box, where only with PGO I was able to watch 720p YouTube videos. No over solution or distribution ever gave me this possiiibility on that machine. But that's not all, the responsiveness of Firefox alone was on a whole new level. I had to wait for 11 hours for the compilation to finish, but it payed back immediately. I just remembered that there was a problem with proprietary NVidia driver, so I had to stick with the nv driver (yes, that old and forgotten one), what makes PGO even that much more awesome.

  10. #20
    Join Date
    Jan 2012
    Posts
    16

    Thumbs down

    Who care?? this is so sad! FreeBSD just like a idiot crap !!! fortunately I am using Linux + GCC! I feel so welfare!
    Last edited by China_Guy; 05-13-2012 at 06:56 AM.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •