I looked at those benchmarks and said, "Well, those all took the same amount of time." Then I read the conclusions drawn and frowned. The numbers are way too close together to determine that any of these are faster than the other. In fact, I'd be surprised if the first two don't compile to the exact same parse tree.

Compare my benchmarks:

#!/usr/bin/perl -w

use strict;
use Benchmark;

timethese( 1000, {
    '0while' => sub { $_ = 0; while (1)   { $_++; last if ($_ == 10000
+); } },
    '0for'   => sub { $_ = 0; for   (;;)  { $_++; last if ($_ == 10000
+); } },
    '0block' => sub { $_ = 0;             { $_++; redo if ($_ < 10000)
+;  } },
    '1while' => sub { $_ = 0; while (1)   { $_++; last if ($_ == 10000
+); } },
    '1for'   => sub { $_ = 0; for   (;;)  { $_++; last if ($_ == 10000
+); } },
    '1block' => sub { $_ = 0;             { $_++; redo if ($_ < 10000)
+;  } },
});
__END__
Benchmark: timing 1000 iterations of
0block, 0for, 0while, 1block, 1for, 1while...
    0block:  7 wallclock secs (  6.81 CPU) @ 146.84/s
      0for:  7 wallclock secs (  6.98 CPU) @ 143.27/s
    0while:  7 wallclock secs (  6.70 CPU) @ 149.25/s
    1block:  6 wallclock secs (  6.37 CPU) @ 156.99/s
      1for:  6 wallclock secs (  6.26 CPU) @ 159.74/s
    1while:  6 wallclock secs (  6.32 CPU) @ 158.23/s
[download]

I'm sticking with while(1) since I think it looks nicer.

So I tried it (with Deparse)...

while ()  { $_++; last if $_ == 1000; }
while (1) { $_++; last if $_ == 1000; }
for (;;)  { $_++; last if $_ == 1000; }
[download]

perl -MO=Deparse test.pl

for (;;) {
    ++$_;
    last if $_ == 1000;
}
for (;;) {
    ++$_;
    last if $_ == 1000;
}
for (;;) {
    ++$_;
    last if $_ == 1000;
}
test.pl syntax OK
[download]

So they should be all the same speed. I'm with tye on this one - I'll be sticking with with while(1) since I think it looks nicer.

Have fun,

rdw

Those three parse the same, but the block loops don't parse that way. In fact, there are at least three different ways to do an infinite loop with redo that parse differently... So I modified tye's benchmark, and got:

#!/usr/bin/perl -w

use strict;
use Benchmark;

timethese( 1000, 
  {
   '0while' => sub { $_ = 0; while (1)   { $_++; last if ($_ == 10000)
+; } },
   '0for'   => sub { $_ = 0; for   (;;)  { $_++; last if ($_ == 10000)
+; } },
   '0redo1' => sub { $_ = 0;   { $_++; redo if     ($_ <  10000);     
+  } },
   '0redo2' => sub { $_ = 0;   { $_++; redo unless ($_ == 10000);     
+  } },
   '0redo3' => sub { $_ = 0;   { $_++; last if     ($_ == 10000); redo
+; } },
   '1while' => sub { $_ = 0; while (1)   { $_++; last if ($_ == 10000)
+; } },
   '1for'   => sub { $_ = 0; for   (;;)  { $_++; last if ($_ == 10000)
+; } },
   '1redo1' => sub { $_ = 0;   { $_++; redo if     ($_ <  10000);     
+  } },
   '1redo2' => sub { $_ = 0;   { $_++; redo unless ($_ == 10000);     
+  } },
   '1redo3' => sub { $_ = 0;   { $_++; last if     ($_ == 10000); redo
+; } },
  });
__END__
Benchmark: timing 1000 iterations of 0for, 0redo1, 0redo2, 0redo3, 0wh
+ile, 1for, 1redo1, 1redo2, 1redo3, 1while...
      0for: 14 wallclock secs (11.43 usr +  0.00 sys = 11.43 CPU)
    0redo1: 14 wallclock secs (11.62 usr +  0.00 sys = 11.62 CPU)
    0redo2: 15 wallclock secs (12.68 usr +  0.00 sys = 12.68 CPU)
    0redo3: 15 wallclock secs (12.36 usr +  0.00 sys = 12.36 CPU)
    0while: 14 wallclock secs (11.48 usr +  0.00 sys = 11.48 CPU)
      1for: 13 wallclock secs (11.40 usr +  0.00 sys = 11.40 CPU)
    1redo1: 14 wallclock secs (11.63 usr +  0.00 sys = 11.63 CPU)
    1redo2: 14 wallclock secs (11.54 usr +  0.00 sys = 11.54 CPU)
    1redo3: 15 wallclock secs (12.36 usr +  0.01 sys = 12.37 CPU)
    1while: 14 wallclock secs (11.42 usr +  0.00 sys = 11.42 CPU)
[download]

I don't know why the difference in times between the first run and the second...

The anecdote was that your infinite loop reminded me of the story of a team that was trying to speed up an operating system. Well they profiled and found that it spent most of its time in one loop. So they optimized the heck out of that loop - only to find no reduction in the time spent in that code.

Turns out that they had optimized the idle loop!

Oops. :-)

On an ironic note, I have heard elsewhere that even though they did not speed up the OS, it turned out that they had made it noticably more responsive to users and smoother at multi-tasking. So it turned out to be a good thing to do after all!

Check out this excellent post on benchmarking for more ideas: Benchmarking Your Code Also, the perldoc for Benchmark.pm has even more good stuff.

I never realized that while() could be used as an infinite loop, so I went and benchmarked it up against for (;;) and I got these results:


Benchmark: timing 20000 iterations of for, while()...
       for: 45 wallclock secs (43.95 usr +  0.00 sys = 43.95 CPU) @ 45
+5.06/s (n=20000)
   while(): 43 wallclock secs (43.28 usr +  0.00 sys = 43.28 CPU) @ 46
+2.11/s (n=20000)
[download]

Note: Do not be alarmed if it took longer this time than in the above post, I did it on a slower computer.

Sooo..., I guess you were right!!

Zenon Zabinski | zdog | zdog7@hotmail.com

Shoudn't the least efficient method be the proper one to use over an infinite time? Seems fewer iterations would mean less wear and tear on the loop...

If you execute the following:

perl -MO=Bytecode,-H,-ofor_loop    -e 'for (;;) {}'
perl -MO=Bytecode,-H,-owhile_loop  -e 'while () {}'
perl -MO=Bytecode,-H,-owhile1_loop -e 'while (1) {}'
[download]

AgentM Systems or Nasca Enterprises is not responsible for the comments made by AgentM- anywhere.