To debug a new backend, is there a way to just get the debug info for the
Target/Foo directory?
Is there a way to just build "llc"?
Any ideas to speed things up?
Thanks, brian
_______________________________________________
LLVM Developers mailing list
llvm...@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
On Tue, 26 Nov 2019 at 18:15, Bagel via llvm-dev
<llvm...@lists.llvm.org> wrote:
> Is there a way to just build "llc"?
"make llc" should do the trick (though ninja tends to be even faster).
> Any ideas to speed things up?
As you can imagine, this is an issue lots of people hit. Knobs you can
twist to make things better:
1. Use lld, for example with the LLVM_ENABLE_LLD CMake option
(assuming it's installed).
2. Lower the LLVM_PARALLEL_LINK_JOBS CMake option to something your
system can support.
3. The LLVM_USE_SPLIT_DWARF essentially leaves the DWARF info in the
.o files and avoids linking it properly until it's used. This speeds
up linking, at the cost of slower gdb/lldb load, and you need a quite
new version of lldb to debug at all.
4. You can skip building unnecessary targets with
LLVM_TARGETS_TO_BUILD, though that's more significant as a
compile-time saver than link-memory.
5. Even more-so for LLVM_OPTIMIZED_TABLEGEN.
6. There's some option to build .so files instead of .a, which saves
linker memory. But it slows down test runs significantly and is also
annoying for debug so I don't think people tend to use it these days.
I tend to run with the first three on Linux.
Cheers.
Tim.
Oh, and this one only works with ninja. So another good reason to
switch if you haven't already.
Throw hardware at it.
I believe it is pretty clear that the stock ld linker is basically unusable for our project without a sizable amount of hardware. I’ve typically found that using gold or lld fixes this problem entirely.
Perhaps we need to start having CMake detect the presence of lld and use that if possible, else check for ‘gold’ and use it if possible, and only THEN fall back on ld.
Additionally, it is pretty rare for someone to need to debug TableGen (at least in my experience), and if they DO need it, they would know enough to know how to change the cmake variable. I think we should have a serious discussion about making LLVM_OPTIMIZED_TABLEGEN=true be default.
> The linking state of a Debug build seems to require a humongous amount of
> memory. My poor little linux machine with 16G of ram swaps its brains out.
> Waiting for it to finish (if it ever does) is like the old days when you
> submitted your deck of cards and waited until the next day to see the results.
This actually something I've experienced myself when trying to build LLVM in
debug mode on a machine with 16G of memory. It really is annoying.
> Any ideas to speed things up?
Beside the obvious remark that a machine with more memory for frequent debug
builds is desirable, let me give some remarks:
1. Usually compiling itself is not the problem but linking is. Using a single
threaded build `ninja -j1` should make the build work but causes really
annoyingly long build times.
2. Depending on your host target using a different linker can really help. The
BFD linker didn't work well for me but replacing it with gold (ELF only) or lld
really helped. You can use e.g. the gold linker by setting
`LLVM_USE_LINKER=gold` in your CMake configuration.
3. You can specify the number of parallel link jobs explicitly by setting the
CMake option `LLVM_PARALLEL_LINK_JOBS`. Use a higher number of jobs for
compiling and a lower number for linking.
4. This is a general remark and not limited to a debug build: Use ccache! This
drastically improved build times for me. Enable the CMake option
`LLVM_CCACHE_BUILD` and make sure that ccache is installed and the max. cache
size is big enough (check by running `ccache -s`), I personally use 50G.
> Is there a way to just build "llc"?
Something I've never tested myself: Build e.g. llc in debug mode (`ninja llc`
in a cmake configuration where the build type is `Debug`), build another
toolchain in non-debug mode and simply replace the non-debug version of llc with
the debug version.
> To debug a new backend, is there a way to just get the debug info for the
> Target/Foo directory?
You could try to modify the step above by building llc for your desired target
only by setting the CMake option LLVM_TARGETS_TO_BUILD="your desired target"`.
> Thanks, brian
Cheers,
David
I believe it is pretty clear that the stock ld linker is basically unusable for our project without a sizable amount of hardware. I’ve typically found that using gold or lld fixes this problem entirely.
Perhaps we need to start having CMake detect the presence of lld and use that if possible, else check for ‘gold’ and use it if possible, and only THEN fall back on ld.
Additionally, it is pretty rare for someone to need to debug TableGen (at least in my experience), and if they DO need it, they would know enough to know how to change the cmake variable. I think we should have a serious discussion about making LLVM_OPTIMIZED_TABLEGEN=true be default.
I’d be perfectly OK with that. I only compile debug, so having my normal set of build flags be unnecessary would be wonderful. In addition to the two below, I only add -G “Ninja” (plus ‘LLVM_ENABLE_PROJECTS=…
From: Reid Kleckner <r...@google.com>
Sent: Tuesday, November 26, 2019 11:04 AM
To: Keane, Erich <erich...@intel.com>
Cc: llvm...@lists.llvm.org
Subject: Re: [llvm-dev] debug build busts memory
On Tue, Nov 26, 2019 at 10:46 AM Keane, Erich via llvm-dev <llvm...@lists.llvm.org> wrote:
These questions come up often enough maybe we should add a new section
about building with not enough memory to llvm/docs/CMake.rst. If 16gb
isn't enough then most people will have a hard time building. There
has been a lot of talk recently about making llvm development more
accessible to newcomers, being unable to even build has to be by far
the most egregious problem. How many people had a passing interest in
llvm but when their build failed didn't want to ask the mailing list
what other options they had and gave up?
Can we make LLVM_USE_SPLIT_DWARF=ON the default? This seems like the
easiest way to solve the memory usage issues, and we are already recommending
this whenever users hit this problem.
-Tom