<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=""><br class=""><div><br class=""><blockquote type="cite" class=""><div class="">On Mar 4, 2021, at 5:34 PM, Arthur O'Dwyer <<a href="mailto:arthur.j.odwyer@gmail.com" class="">arthur.j.odwyer@gmail.com</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><div dir="ltr" class=""><div dir="ltr" class="">On Thu, Mar 4, 2021 at 3:25 PM David Rector via cfe-dev <<a href="mailto:cfe-dev@lists.llvm.org" class="">cfe-dev@lists.llvm.org</a>> wrote:</div><div class="gmail_quote"><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div style="overflow-wrap: break-word;" class=""><div class=""><blockquote type="cite" class=""><div class="">On Mar 4, 2021, at 2:26 PM, Balázs Benics <<a href="mailto:benicsbalazs@gmail.com" target="_blank" class="">benicsbalazs@gmail.com</a>> wrote:</div><br class=""><div class=""><div dir="ltr" class=""><div class="">I don't think you can easily substitute constexpr evaluation with simply calling a compiled counterpart. [...]</div></div></div></blockquote><div class=""><br class=""></div><div class="">Thanks for this input, you’re right — e.g. `constexpr void f(A *a)` might or might not be able to handle `f(nullptr)`; it would require proof, and there things probably get too complex. </div></div></div></blockquote><div class=""><br class=""></div><div class="">The other thing you have to keep in mind is cross-compilers. JIT interpreters do not have to deal with cross-compilation.</div><div class="">Clang could certainly invest in JIT-compiled codepaths for its constexpr evaluation, and that might make the <i class="">usual</i> desktop-compilation path blazing fast... but then you'd be in this weird situation where Boost-or-whatever compiled in a reasonable amount of time for x86-64, but building an ARM binary would take days. (Until you bought an M1 Mac, I guess, and then the situation would flip-flop.)</div><div class=""><br class=""></div><div class="">my $.02,</div><div class="">Arthur</div></div></div>
</div></blockquote><br class=""></div><div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">Yes, cross-compiling would be another complexity of such an approach; I suppose you would probably need to separately build your "constexpr binaries" for the current machine in addition to whatever building you do for the target platform</div><div style="margin: 0px; font-stretch: normal; line-height: normal; min-height: 14px;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">Even with these complexities, I can’t quite let the possibility go. A user might run a single expensive constexpr metafunction might be run millions or billions of times on different inputs. If we could analyze it just a single time, and guarantee it safely handles its inputs, or some subset of possible inputs that could be encoded along with it, it is tantalizing to consider how fast builds could get if we could call the binary version of it, bypassing all those expensive checks and the interpreter infrastructure during those calls. </div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">Whether these static analysis challenges are surmountable is of course well beyond my depth.</div><div style="margin: 0px; font-stretch: normal; line-height: normal; min-height: 14px;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">And there are other problems with the approach; e.g. anything absolutely requiring constant evaluation, e.g. reflected meta::infos, or injection statements, could not directly be compiled to binary, or at least would require a lot of additional thought. </div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">And, perhaps a JIT approach would not be far off in performance anyway. Perhaps the interpreter alone will ultimately prove sufficient. </div><div style="margin: 0px; font-stretch: normal; line-height: normal; min-height: 14px;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">Concluding thought:</div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">C++ allows lightning fast run time performance…at the expense of expertise, labor, and maintenance.</div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">Reflection + injection can solve these issues, allowing the user to delegate that expertise, labor, and maintenance to metafunctions/metaclasses…but at the expense of increases in build time due the challenges of constexpr evaluation.</div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class=""><br class=""></div><div style="margin: 0px; font-stretch: normal; line-height: normal;" class="">This last issue may require additional focus in the medium/long term.</div></div><br class=""><div class="">Thanks all,</div><div class=""><br class=""></div><div class="">Dave</div></body></html>