
<html><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; line-break: after-white-space;" class="">Hi Dwight,<br class=""><div><br class=""></div><div>Can your share the profile (stack trace for instance) you’ve observed?</div><div><br class=""></div><div>As far as I remember the fast regalloc (the one that runs at O0 by default) shouldn’t call hasOneNonDBGUse and the only potential quadratic behavior in that allocator is when we scan for the live out (<span style="font-family: Menlo; font-size: 11px;" class="">RegAllocFast::mayLiveOut</span>) and even that part shouldn’t cause significant problems because we limit the number of checks by an upper bound of 8 per variable (hard coded limit).</div><div><br class=""></div><div>If <span style="font-family: Menlo; font-size: 11px;" class="">RegAllocFast::mayLiveOut</span> turns out to be problematic, we could start to cache its results.</div><div><br class=""></div><div>Anyhow, I’ll need more information to be able to help you.</div><div><br class=""></div><div>Cheers,</div><div>-Quentin</div><div><br class=""></div><div><blockquote type="cite" class=""><div class="">On Feb 22, 2021, at 12:17 PM, David Blaikie via llvm-dev <<a href="mailto:llvm-dev@lists.llvm.org" class="">llvm-dev@lists.llvm.org</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><div dir="ltr" class="">+Lang who might still have some register allocation knowledge kicking around (but his responses may be a bit delayed)<br class=""><br class="">Generally there's a bunch of algorithms that don't scale really well on especially large function - and I'd encourage users to modify any code generators to chunk up functions, or they'll be chasing down these sort of issues indefinitely, really.<br class=""><br class="">But improvements are certainly appreciated - though I don't have any particular knowledge or pointers regarding how to improve the register allocator. (my gut reaction would be that probably a lot of people have looked and haven't found better tradeoffs - but I'm a bit of a pessimist, fresh eyes can often help :) )</div><br class=""><div class="gmail_quote"><div dir="ltr" class="gmail_attr">On Wed, Feb 10, 2021 at 10:48 AM Dwight Guth via llvm-dev <<a href="mailto:llvm-dev@lists.llvm.org" class="">llvm-dev@lists.llvm.org</a>> wrote:<br class=""></div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">Hi,<br class="">

<br class="">

I am the maintainer of an open source compiler that makes use of the<br class="">

LLVM toolchain to perform code generation. A user of our compiler, who<br class="">

is working on a proprietary project, recently shared with me an<br class="">

example where our toolchain was invoking `llc -O0` on a file with a<br class="">

rather large function in it, and the register allocation pass was<br class="">

taking upwards of 5 minutes. This seemed unusual to me, so I<br class="">

downloaded the debug symbols for LLVM (this was with LLVM 11.0.0), and<br class="">

I found that slightly over 50% of the runtime of LLC was spent within<br class="">

a very small loop within llvm::MachineRegisterInfo::hasOneNonDBGUse. I<br class="">

believe this loop to correspond to the while loop in<br class="">

llvm::MachineRegisterInfo::defusechain_iterator::advance.<br class="">

<br class="">

It looks like this function is just scanning through all the defs and<br class="">

uses of a register in the function until it finds one that it<br class="">

considers satisfactory? That seems like it would be introducing<br class="">

behavior that is quadratic in the size of the function to me. Am I<br class="">

missing something? Is there some other, more sensible reason why the<br class="">

profile seems so dependent on this one loop of code? Did I<br class="">

misunderstand something?<br class="">

<br class="">

My end goal here would be to submit a patch that might optimize this<br class="">

case, since it seems to me something that might be able to be computed<br class="">

more efficiently. But I don't understand the code or the algorithm<br class="">

hugely well, so I was hoping someone could give me some pointers on<br class="">

where to get started with something like this.<br class="">

<br class="">

Does anyone have any suggestions on what I could do to make register<br class="">

allocation run faster on quite large functions?<br class="">

<br class="">

Thanks,<br class="">

<br class="">

--<br class="">

Dwight Guth<br class="">

<br class="">

Chief Information Officer<br class="">

Runtime Verification, Inc.<br class="">

Email: <a href="mailto:dwight.guth@runtimeverification.com" target="_blank" class="">dwight.guth@runtimeverification.com</a><br class="">

_______________________________________________<br class="">

LLVM Developers mailing list<br class="">

<a href="mailto:llvm-dev@lists.llvm.org" target="_blank" class="">llvm-dev@lists.llvm.org</a><br class="">

<a href="https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev" rel="noreferrer" target="_blank" class="">https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev</a><br class="">

</blockquote></div>

_______________________________________________<br class="">LLVM Developers mailing list<br class=""><a href="mailto:llvm-dev@lists.llvm.org" class="">llvm-dev@lists.llvm.org</a><br class="">https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev<br class=""></div></blockquote></div><br class=""></body></html>