4 ms·

* Compile with clang, link with mold or at least lld. mold can link gigabyte-sized binaries in, like, one second * Use ninja instead of make * Use PCH * -gsp

* Compile with clang, link with mold or at least lld. mold can link gigabyte-sized binaries in, like, one second * Use ninja instead of make * Use PCH * -gsplit-dwarf

techas 5y ago
Off topic. Could you recommend an ide to work with c++?
- ibobev 5y ago
  Microsoft Visual Studio for Windows and QtCreator for Linux.
  - CornCobs 5y ago
    I find visual studio to be absolutely horrendous for C++. Refactoring doesn't work (even a simple rename symbol!) The errors aren't accurate, autocomplete seems to suggest every symbol from the stdlib before the class defined in the file itself and can't tell when it should suggest classes vs functions/variables. Oh and of course compile errors are absolutely useless but I suppose that's a C++ thing in general. The error panel shows the (last? First?) Error in a chain of errors, which is always something deep in library code. E.g. accidentally tried to copy a non-copyable object using unique_ptr? You can't find the offending callsite, it just points you to xmemory and at best the class being wrongly used.
    - ncmncm 5y ago
      Compile errors will anyway be getting better as concept support gets built out.
- jll29 5y ago
  CLion from JetBrains and Microsoft Visual Code are the best commercial ones for Linux, NetBeans is a free (as in freedeom and open source) one (that also supports many other languages like Java and Python). What I don't recommend is Eclipse - it's complex and confusing for beginners (but a bit faster than some others).
  - MetricExpansion 5y ago
    I didn’t think NetBeans supported C++ anymore?
    - mdaniel 5y ago
      Yeah, at least according to the repo it seems they now delegate to the ccls language server and just do syntax highlighting via the textmate plist grammars that are so commonly paired with language servers * https://github.com/apache/netbeans/tree/12.3/cpplite#cpplite https://github.com/apache/netbeans/tree/12.3/cpplite#cpplite * https://github.com/apache/netbeans/blob/12.3/cpplite/cpplite.editor/src/org/netbeans/modules/cpplite/editor/file/resources/cpp.tmLanguage.json https://github.com/apache/netbeans/blob/12.3/cpplite/cpplite...
- jcelerier 5y ago
  I use Qt Creator on every platform
- dwrodri 5y ago
  I can testify to JetBrains products, they're quite good. I haven't used CLion in a few years because I don't like depending on a dev tooling that costs money. I use VSCode because I hop between Python, Bash, Go, C, and C++. That being said, CLion definitely offers a much better debugging experience, even when VSCode has all the right plugins.
- whimsicalism 5y ago
  CLion, VSCode, Vim - in order of decreasing tooling.
- mattgreenrocks 5y ago
  CLion is quite good IME. Visual Studio, historically, has been excellent, but I haven’t used Windows full time in a decade.
- harry8 5y ago
  vim with the YouCompleteMe plugin (which uses clang-complete) is pretty good. Contrary to a sibling post eclipse CDT is fine (especially with vim bindings). It depends what you want from your IDE maybe?
- mpreda 5y ago
  qt-creator is a nice open-source IDE: https://github.com/qt-creator/qt-creator https://github.com/qt-creator/qt-creator They offer binary releases, but it's also possible to compile from source without too much trouble. Written in C++, it's pretty snappy. Supports meson.
woodruffw 5y ago
This is all solid advice (particularly using a faster linker). IME, the single best way to reduce your C++ compile times is to compile less code: * Remove all unnecessary headers. Template expansion is slow, and preprocessing is even slower. Some of the standard includes (like `<regex>` and `<iostream>`) are notorious for slowing individual translation units to a crawl. `#pragma once` for your own headers also helps with cpp-time performance. * Forward-declare as much as you can. Forward type declarations mean that the compiler doesn't need to process all of `Foo` when it sees `Foo&` or `Foo`. Use pImpl wherever you can (and makes sense). Private implementations similarly reduce the amount of code the compiler needs to analyze. For better or worse, the current winds suggest that C++ compilation times will only continue to get worse (more constexpr/consteval, even more complex templating features/concepts, etc.).
- McKayDavis 5y ago
  > * Remove all unnecessary headers. Template expansion is slow, and preprocessing is even slower. Some of the standard includes (like `<regex>` and `<iostream>`) are notorious for slowing individual translation units to a crawl. `#pragma once` for your own headers also helps with cpp-time performance. > * Forward-declare as much as you can. Forward type declarations mean that the compiler doesn't need to process all of `Foo` when it sees `Foo&` or `Foo`. I've found the include-what-you-use (IWYU) tool [1][2] can help immensely with automating this process, especially on large code-bases. It uses LLVM/Clang to analyze a .cpp file / translation unit and produces the minimal subset of exactly which includes are necessary and what types can be forward declared. [1] https://include-what-you-use.org/ https://include-what-you-use.org/ [2] https://github.com/include-what-you-use/include-what-you-use https://github.com/include-what-you-use/include-what-you-use
- ncmncm 5y ago
  Constexpr improves compilation speed by the degree that it displaces template metaprogramming. Template metaprogramming runs at Python speed, where constexpr runs orders of magnitude faster. Anywhere you have a choice between them, choose constexpr. Substantial improvement in compilation speed might depend on use of JIT techniques, running generated code in the compiler to perform template evaluation. I.e., a template is not just a data structure, it is a compile-time function that, where used much, is compiled to optimized machine code, its run-time values being what we think of as types. Thus far, all these functions are run like an interpreter walking a syntax tree. Precompiled headers, or module intermediate files, could have this code in them already optimized.
pubby 5y ago
Is clang still faster? I thought it had slowed down in the past decade and was now worse than GCC.
- jcelerier 5y ago
  For my own projects at least it is, by 10-20%
  - gpderetta 5y ago
    Had the same experience. It is not a huge difference, but it is noticeable, especially in the incremental edit-build-test cycle.
  - jcelerier 5y ago
    to give a very flagrant example on a project that i am currently working on: - GCC 11 build: 4m20 (https://github.com/celtera/avendish/runs/5449993123?check_suite_focus=true https://github.com/celtera/avendish/runs/5449993123?check_su...) - Clang 14 build: 2m40 (https://github.com/celtera/avendish/runs/5449993033?check_suite_focus=true https://github.com/celtera/avendish/runs/5449993033?check_su...)
gpderetta 5y ago
All good suggestions. I might add: ccache and distcc to speed up full rebuilds.

* Compile with clang, link with mold or at least lld. mold can link gigabyte-sized binaries in, like, one second * Use ninja instead of make * Use PCH * -gsplit-dwarf

techas 5y ago

Off topic. Could you recommend an ide to work with c++?

ibobev 5y ago
Microsoft Visual Studio for Windows and QtCreator for Linux.
- CornCobs 5y ago
  I find visual studio to be absolutely horrendous for C++. Refactoring doesn't work (even a simple rename symbol!) The errors aren't accurate, autocomplete seems to suggest every symbol from the stdlib before the class defined in the file itself and can't tell when it should suggest classes vs functions/variables. Oh and of course compile errors are absolutely useless but I suppose that's a C++ thing in general. The error panel shows the (last? First?) Error in a chain of errors, which is always something deep in library code. E.g. accidentally tried to copy a non-copyable object using unique_ptr? You can't find the offending callsite, it just points you to xmemory and at best the class being wrongly used.
  - ncmncm 5y ago
    Compile errors will anyway be getting better as concept support gets built out.
jll29 5y ago
CLion from JetBrains and Microsoft Visual Code are the best commercial ones for Linux, NetBeans is a free (as in freedeom and open source) one (that also supports many other languages like Java and Python). What I don't recommend is Eclipse - it's complex and confusing for beginners (but a bit faster than some others).
- MetricExpansion 5y ago
  I didn’t think NetBeans supported C++ anymore?
  - mdaniel 5y ago
    Yeah, at least according to the repo it seems they now delegate to the ccls language server and just do syntax highlighting via the textmate plist grammars that are so commonly paired with language servers * https://github.com/apache/netbeans/tree/12.3/cpplite#cpplite https://github.com/apache/netbeans/tree/12.3/cpplite#cpplite * https://github.com/apache/netbeans/blob/12.3/cpplite/cpplite.editor/src/org/netbeans/modules/cpplite/editor/file/resources/cpp.tmLanguage.json https://github.com/apache/netbeans/blob/12.3/cpplite/cpplite...
jcelerier 5y ago
I use Qt Creator on every platform
dwrodri 5y ago
I can testify to JetBrains products, they're quite good. I haven't used CLion in a few years because I don't like depending on a dev tooling that costs money. I use VSCode because I hop between Python, Bash, Go, C, and C++. That being said, CLion definitely offers a much better debugging experience, even when VSCode has all the right plugins.
whimsicalism 5y ago
CLion, VSCode, Vim - in order of decreasing tooling.
mattgreenrocks 5y ago
CLion is quite good IME. Visual Studio, historically, has been excellent, but I haven’t used Windows full time in a decade.
harry8 5y ago
vim with the YouCompleteMe plugin (which uses clang-complete) is pretty good. Contrary to a sibling post eclipse CDT is fine (especially with vim bindings). It depends what you want from your IDE maybe?
mpreda 5y ago
qt-creator is a nice open-source IDE: https://github.com/qt-creator/qt-creator https://github.com/qt-creator/qt-creator They offer binary releases, but it's also possible to compile from source without too much trouble. Written in C++, it's pretty snappy. Supports meson.

woodruffw 5y ago

This is all solid advice (particularly using a faster linker). IME, the single best way to reduce your C++ compile times is to compile less code: * Remove all unnecessary headers. Template expansion is slow, and preprocessing is even slower. Some of the standard includes (like `<regex>` and `<iostream>`) are notorious for slowing individual translation units to a crawl. `#pragma once` for your own headers also helps with cpp-time performance. * Forward-declare as much as you can. Forward type declarations mean that the compiler doesn't need to process all of `Foo` when it sees `Foo&` or `Foo`. Use pImpl wherever you can (and makes sense). Private implementations similarly reduce the amount of code the compiler needs to analyze. For better or worse, the current winds suggest that C++ compilation times will only continue to get worse (more constexpr/consteval, even more complex templating features/concepts, etc.).

McKayDavis 5y ago
> * Remove all unnecessary headers. Template expansion is slow, and preprocessing is even slower. Some of the standard includes (like `<regex>` and `<iostream>`) are notorious for slowing individual translation units to a crawl. `#pragma once` for your own headers also helps with cpp-time performance. > * Forward-declare as much as you can. Forward type declarations mean that the compiler doesn't need to process all of `Foo` when it sees `Foo&` or `Foo`. I've found the include-what-you-use (IWYU) tool [1][2] can help immensely with automating this process, especially on large code-bases. It uses LLVM/Clang to analyze a .cpp file / translation unit and produces the minimal subset of exactly which includes are necessary and what types can be forward declared. [1] https://include-what-you-use.org/ https://include-what-you-use.org/ [2] https://github.com/include-what-you-use/include-what-you-use https://github.com/include-what-you-use/include-what-you-use
ncmncm 5y ago
Constexpr improves compilation speed by the degree that it displaces template metaprogramming. Template metaprogramming runs at Python speed, where constexpr runs orders of magnitude faster. Anywhere you have a choice between them, choose constexpr. Substantial improvement in compilation speed might depend on use of JIT techniques, running generated code in the compiler to perform template evaluation. I.e., a template is not just a data structure, it is a compile-time function that, where used much, is compiled to optimized machine code, its run-time values being what we think of as types. Thus far, all these functions are run like an interpreter walking a syntax tree. Precompiled headers, or module intermediate files, could have this code in them already optimized.

pubby 5y ago

Is clang still faster? I thought it had slowed down in the past decade and was now worse than GCC.

jcelerier 5y ago
For my own projects at least it is, by 10-20%
- gpderetta 5y ago
  Had the same experience. It is not a huge difference, but it is noticeable, especially in the incremental edit-build-test cycle.
- jcelerier 5y ago
  to give a very flagrant example on a project that i am currently working on: - GCC 11 build: 4m20 (https://github.com/celtera/avendish/runs/5449993123?check_suite_focus=true https://github.com/celtera/avendish/runs/5449993123?check_su...) - Clang 14 build: 2m40 (https://github.com/celtera/avendish/runs/5449993033?check_suite_focus=true https://github.com/celtera/avendish/runs/5449993033?check_su...)

gpderetta 5y ago

All good suggestions. I might add: ccache and distcc to speed up full rebuilds.