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.
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.
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.
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.
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