1. Which is faster, preprocessor (-P) or use constant pragma?
   They both are the same.

2. How did you find this out (better yet, aside from reading the internals of the perl interpreter -- I am not ready, is there a way to profile the compilation stage and where can I go to read/learn about such things)?
   You can use the B::Graph module to see how perl constructed the execution tree for the code you've written. The only difference between the two is that when you use constant, the constant needs to be initialized at the top of the parse tree, while the preprocessed code does not have such step.

3. Once the optimizer strips out unnecessary code, at anytime in recompilation (such as when an eval() gets compiled at run-time), does this folded code effect the compilation time?
   I believe once a portion of code is discarded, it is discarded forever. In the example above, since you cannot change the value of the constant UNDEF, there is really no point in keeping the stuff inside the if statement.

    #!/usr/bin/perl -P -MO=Graph,-text
    
    use constant UNDEF => 0;
    
    my $test = 1;
    
    if(UNDEF){
        $test = 'Hello World';
    }   

    print "\$test => $test\n";
[download]

    #!/usr/bin/perl -P -MO=Graph,-text

    my $test = 1;

    #if 0
        $test = 'Hello World';
    #endif

    print "\$test => $test\n";
[download]

Hope this answers your questions.

PS: -MO=Graph,-text will show you an ascii drawing of the tree, while -MO=Graph,-dot will output a dot file that you can view if you have dotty, part of the Graphviz package.

You show that both programs compile to the same thing. However, compilation time is a definite issue for a scripting language. If filtering with <samp>cpp</samp> compiles twice as quickly as using a <samp>constant</samp>, then it is faster for short-lived programs.

To determine run time of a program, use one of the UN*X <samp>time</samp> commands (either the shell builtin or <samp>/usr/bin/time</samp> or <samp>/usr/bin/timex</samp>). This should give equivalent results to the suggestion given above for using <samp>Benchmark</samp>.

However, almost surely it does not matter: for very many Perl programs, the compile time is dominated by the run time. Exceptions may include some CGI programs (and hence e.g. <samp>mod_perl</samp>, which seeks to reduce the number of times compilation time is paid).

Well, here's the direct way. (samtregar suggests a more Perlish way, which will do much the same, in a possibly nicer way).

I created 2 files, <samp>cond-cpp</samp> and <samp>cond-prl</samp> which contain your codes. Neither ran <samp>-w</samp> or <samp>use strict</samp>; at least the latter will probably reduce the difference in execution time even further (<samp>cond-prl</samp>, however, runs the <samp>-P</samp> switch, for obvious reasons).

<hal4 143 [15:07] ~/Perl/Test >time csh -c 'repeat 500 ./cond-prl >/de
+v/null'
0:17.75 elapsed, 14.410+3.200 user+system (99.2%), 0 (0+0) mem (avg. s
+hared+unshared stack), 152908 faults, 0/0 I/O
<hal4 144 [15:08] ~/Perl/Test >time csh -c 'repeat 500 ./cond-cpp >/de
+v/null'
0:16.55 elapsed, 11.630+7.200 user+system (113.7%), 0 (0+0) mem (avg. 
+shared+unshared stack), 431514 faults, 0/0 I/O
[download]

On a slower uniprocessor machine, we get

<sylvie 113 [16:10] ~/Perl/Test >time csh -c 'repeat 500 ./cond-prl >/
+dev/null'
0:35.42 elapsed, 25.740+6.140 user+system (90.0%), 0 (0+0) mem (avg. s
+hared+unshared stack), 154646 faults, 0/0 I/O
<sylvie 114 [16:10] ~/Perl/Test >time csh -c 'repeat 500 ./cond-cpp >/
+dev/null'
0:39.19 elapsed, 16.490+18.530 user+system (89.3%), 0 (0+0) mem (avg. 
+shared+unshared stack), 462331 faults, 0/0 I/O
[download]

Explanations? Only thing I can think of is "CPP is faster than Perl at doing this". Doubtless the real <samp>perl</samp> hackers out there can explain this.

Importance? Probably almost nil, unless you're starting a great many very short-lived processes.

Benchmarking eval of strings, since you want to include compile time:

#!/usr/bin/perl -w
use strict;

my $foo = <<'BAR';
my $test = 1;
#ifdef UNDEF
    $test = 0;
#endif
print "\$test => $test\n";
BAR

my $bar = <<'BAZ';
use constant UNDEF => 0;
my $test = 1;
if (UNDEF) {
   $test = 0;
}
print "\$test => $test\n";
BAZ

use Benchmark;

=pod

this is still wrong
timethese (100000, {
              cpp => sub { eval "perl -P -e '$foo'";},
              prl => sub { eval "perl -e '$bar'";}
             }
       );
=cut

timethese (1000, {
              cpp => sub { system "perl -P -e '$foo'";},
              prl => sub { system "perl -e '$bar'";}
             }
       );
[download]

=pod
$ perl bmp.pl
Benchmark: timing 1000 iterations of cpp, prl...
       cpp: 88 wallclock secs ( 0.08 usr  0.54 sys + 52.56 cusr 29.98 
+csys = 83.16 CPU) @ 1612.90/s (n=1000)
       prl: 49 wallclock secs ( 0.09 usr  0.56 sys + 33.78 cusr 12.19 
+csys = 46.62 CPU) @ 1538.46/s (n=1000)
=cut
[download]

timethese (10000, {
              cpp => sub { eval "$foo"; },
              prl => sub { eval "$bar"; }});
=pod
$ perl -P bmp.pl
Benchmark: timing 10000 iterations of cpp, prl...
       cpp:  1 wallclock secs ( 0.50 usr +  0.02 sys =  0.52 CPU) @ 19
+230.77/s (n=10000)
       prl:  2 wallclock secs ( 2.40 usr +  0.03 sys =  2.43 CPU) @ 41
+15.23/s (n=10000)
=cut
[download]

Update: Corrected code, was only firing up an interpreter before. U²: Still had it wrong, showing two ways of doing it with two very different results. It looks like the interpreter with preprocessor is slower to start, but compilation is indeed faster by a pretty wide margin. Your mileage will vary. ++ariels for catching my blunders so kindly.

After Compline,
Zaxo

Comparing the results of this Benchmark with my benchmark just below yields a startling discrepancy. My computers can barely manage 25 iterations a second, whereas Zaxo's seem to finish 15_000 iterations a second easily!

Actually, there's still a problem with the code above: it's measuring how long it takes to ``eval "perl -P -e '$foo'"'' (and something similar for $bar). But that's just string concatenation, with a useless eval thrown in (it fails; that's not legal Perl code!). You need actually to run the command line, say by s/eval/system/g;.

-sam