www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Compile time code paths

reply Jeremie Pelletier <jeremiep gmail.com> writes:
If a function has both an asm and D implementations inside its body, and the D
version can be executed at compile time, but the asm one is much faster at
runtime. Is it possible to have the compiler use the D code path at compile
time (ie to fill in enums and whatnot), and have the asm version available at
runtime.
Aug 08 2009
parent reply Daniel Keep <daniel.keep.lists gmail.com> writes:
Jeremie Pelletier wrote:
 If a function has both an asm and D implementations inside its body, and the D
version can be executed at compile time, but the asm one is much faster at
runtime. Is it possible to have the compiler use the D code path at compile
time (ie to fill in enums and whatnot), and have the asm version available at
runtime.

Not that I know of. There's no way to switch based on run time/compile time. This was going to be solved, at least in part, using static arguments, but that got dropped. As it stands, you just have to use a suffix or prefix or something to distinguish CTFE methods from runtime methods.
Aug 08 2009
parent reply David Gileadi <foo bar.com> writes:
Daniel Keep wrote:
 Jeremie Pelletier wrote:
 If a function has both an asm and D implementations inside its body, and the D
version can be executed at compile time, but the asm one is much faster at
runtime. Is it possible to have the compiler use the D code path at compile
time (ie to fill in enums and whatnot), and have the asm version available at
runtime.

Not that I know of. There's no way to switch based on run time/compile time. This was going to be solved, at least in part, using static arguments, but that got dropped. As it stands, you just have to use a suffix or prefix or something to distinguish CTFE methods from runtime methods.

Is this a case for version(CompileTime){}?
Aug 10 2009
parent reply Jeremie Pelletier <jeremiep gmail.com> writes:
David Gileadi Wrote:

 Daniel Keep wrote:
 Jeremie Pelletier wrote:
 If a function has both an asm and D implementations inside its body, and the D
version can be executed at compile time, but the asm one is much faster at
runtime. Is it possible to have the compiler use the D code path at compile
time (ie to fill in enums and whatnot), and have the asm version available at
runtime.

Not that I know of. There's no way to switch based on run time/compile time. This was going to be solved, at least in part, using static arguments, but that got dropped. As it stands, you just have to use a suffix or prefix or something to distinguish CTFE methods from runtime methods.

Is this a case for version(CompileTime){}?

No because it would also compile this block into the binary. The easy way is of course to have different symbols for compile-time and run-time. But this doesn't go well with generic programming where the function needing such a check can be deep in the compile-time call stack. For example: int foo() { return bar + 1; } int bar() { return foobar * 2; } int foobar() { static if(isCompileTime) return ...; /// asm cannot execute at compile time, needed to keep foo and bar able to do CTFE else asm { ...; } /// asm optimized for runtime }
Aug 10 2009
parent reply Don <nospam nospam.com> writes:
Jeremie Pelletier wrote:
 David Gileadi Wrote:
 
 Daniel Keep wrote:
 Jeremie Pelletier wrote:
 If a function has both an asm and D implementations inside its body, and the D
version can be executed at compile time, but the asm one is much faster at
runtime. Is it possible to have the compiler use the D code path at compile
time (ie to fill in enums and whatnot), and have the asm version available at
runtime.

time. This was going to be solved, at least in part, using static arguments, but that got dropped. As it stands, you just have to use a suffix or prefix or something to distinguish CTFE methods from runtime methods.


No because it would also compile this block into the binary.

I think something like this might work: static if (__traits(CompileTime)) { ... // ctfe code } else { asm { ... } } Not sure what the exact syntax should be.
 
 The easy way is of course to have different symbols for compile-time and
run-time. But this doesn't go well with generic programming where the function
needing such a check can be deep in the compile-time call stack.
 
 For example:
 int foo() { return bar + 1; }
 int bar() { return foobar * 2; }
 int foobar() {
 static if(isCompileTime) return ...; /// asm cannot execute at compile time,
needed to keep foo and bar able to do CTFE
 else asm { ...; } /// asm optimized for runtime
 }

Aug 11 2009
parent Jeremie Pelletier <jeremiep gmail.com> writes:
Don Wrote:

 Jeremie Pelletier wrote:
 David Gileadi Wrote:
 
 Daniel Keep wrote:
 Jeremie Pelletier wrote:
 If a function has both an asm and D implementations inside its body, and the D
version can be executed at compile time, but the asm one is much faster at
runtime. Is it possible to have the compiler use the D code path at compile
time (ie to fill in enums and whatnot), and have the asm version available at
runtime.

time. This was going to be solved, at least in part, using static arguments, but that got dropped. As it stands, you just have to use a suffix or prefix or something to distinguish CTFE methods from runtime methods.


No because it would also compile this block into the binary.

I think something like this might work: static if (__traits(CompileTime)) { ... // ctfe code } else { asm { ... } } Not sure what the exact syntax should be.

Good idea, I agree with the use of __traits here. The syntax looks great to me as it is.
Aug 11 2009