• bearophile (7/7) Jul 24 2010 If CTFE gets used a lot, for example to parse a piece of D code at compi...

bearophile <bearophileHUGS lycos.com> writes:

If CTFE gets used a lot, for example to parse a piece of D code at compile-time
(as I am trying to do now), or it's used a lot, it can slow down the whole
compilation. To solve this some kind of Just In Time compilation can be used to
compile CTFE code and speed it up a lot.

There are several ways to do this. For example LLVM is designed to allow the
creation of JIT compilers too, so LDC can use LLVM to JIT the CTFE code. But
simpler solutions can be found, that can be used with DMD too.

DMD can keep an extra size_t state for each function run at compile-time. This
word keeps it total running time in microseconds, summed for all the calls, of
this function (this word is never present in the final binary). When this value
for a function becomes bigger (for example) than 0.3 seconds, dmd can use
itself to compile the function, so successive calls to it are run by the
compiled version of the function.

The disadvantage of such simple solution is that a function that takes a lot to
run the first time it is called will not be compiled. But I think this can be
acceptable in many situations.

I think DMD can generally compile a CTFE function in less than 0.5 seconds. A
possible optimization: I think compiling few functions doesn't take much more
time than compiling just one, so when one of such "nested compilations" gets
triggered, then CTFE functions that have more than 0.2 run time too can be
compiled in the same block of code.

Bye,
bearophile