Forum: Ruby Re: while vs loop

54185df1d348bbd34587fcd4f8e4779b?d=identicon&s=25 Louis-Philippe (Guest)
on 2009-02-20 22:58
(Received via mailing list)
Hi,I saw this thread from last week: while vs loop,

I don't think anybody mentioned the slight performance difference
between
the two,
(or maybe I got the wrong info!!)
In fact, I had always assumed the 'loop do' construct to be better than
'while 1 do', if only to be more elegant or concise for implementing
infinite loops... but it turns out it seems to be the other way:

##############
require 'benchmark'
Benchmark.bm do |x|
 x.report('while1') do
n = 0
while 1 do
break if n >= 10000000
n += 1
end
end
 x.report('loop  ') do
n = 0
loop do
break if n >= 10000000
n += 1
end
end
end

##############
RESULTS:

                   user     system      total        real
while 1 19.770000   0.230000  20.000000 ( 34.458926)
loop     25.870000   0.300000  26.170000 ( 42.804569)

###########

I'm running this benchmark on 1.8.6 patchlevel 114 (universal-darwin9.0)

So why is it behaving this way?
Are every implementations doing the same?

Thanks!

L-P





On Sat, Feb 14, 2009 at 7:16 AM, Nobuyoshi Nakada
<n...<http://groups.google.com/groups/unlock?_done=/grou...
@ruby-lang.org> wrote:
> Hi,

> At Sat, 14 Feb 2009 15:03:03 +0900,
> Vetrivel Vetrivel wrote in [ruby-talk:328175]:
>> what is the Difference between loop and while in ruby ?

>> loop do
>> end

> loop is a kernel method which takes a block.  A block
> introduces new local variable scope.

>  loop do
>    a = 1
>    break
>  end
>  p a #=> causes NameError

>> while 1
>> end

> while doesn't.

>  while 1
>    a = 1
>    break
>  end
>  p a #=> 1

> --
> Nobu Nakada

furthermore loop do has an implicit rescue clause for a StopIteration
exception
(I believe 1.8.7 and 1.9.1 only IIRC)

therefore

loop do
   some_enumerator.next
end
becomes a convenient idiom.

HTH
Robert
5a837592409354297424994e8d62f722?d=identicon&s=25 Ryan Davis (Guest)
on 2009-02-20 23:22
(Received via mailing list)
On Feb 20, 2009, at 13:57 , Louis-Philippe wrote:

> Hi,I saw this thread from last week: while vs loop,
>
> I don't think anybody mentioned the slight performance difference
> between
> the two,

If you're going to talk performance differences between while and
loop, don't forget for and each:

>                           user     system      total        real
> each                  1.370000   0.010000   1.380000 (  1.380012)
> for                   1.630000   0.000000   1.630000 (  1.652562)
> each-var              2.450000   0.010000   2.460000 (  2.479478)
> while                 5.510000   0.010000   5.520000 (  5.532909)
> loop                  7.730000   0.020000   7.750000 (  7.786959)


require 'benchmark'

max = (ARGV.shift || 1_000_000).to_i

puts "# of iterations = #{max}"
Benchmark::bm(20) do |x|
   x.report("each") do
     (0..max).each do
     end
   end

   x.report("for") do
     for i in 0..max do
       # do nothing
     end
   end

   x.report("each-var") do
     (0..max).each do |i|
     end
   end

   x.report("while") do
     n = 0
     while true do
       break if n >= max
       n += 1
     end
   end

   x.report("loop") do
     n = 0
     loop do
       break if n >= max
       n += 1
     end
   end
end
54185df1d348bbd34587fcd4f8e4779b?d=identicon&s=25 Louis-Philippe (Guest)
on 2009-02-21 00:03
(Received via mailing list)
mmm, Interesting to see loop being this high in the list,
but even if they all loop from 0  to X doesn't mean they can all
compared...
I'm not sure what was the initial question (!!!), but mine is about
infinite
loop implementations,
where list iterators  of the .each flavour don't do.

So *THE* fastest ruby infinite loop is 'while 1'?



2009/2/20 Ryan Davis <ryand-ruby@zenspider.com>
5a837592409354297424994e8d62f722?d=identicon&s=25 Ryan Davis (Guest)
on 2009-02-21 09:52
(Received via mailing list)
On Feb 20, 2009, at 15:02 , Louis-Philippe wrote:

> mmm, Interesting to see loop being this high in the list,
> but even if they all loop from 0  to X doesn't mean they can all
> compared...
> I'm not sure what was the initial question (!!!), but mine is about
> infinite
> loop implementations,
> where list iterators  of the .each flavour don't do.
>
> So *THE* fastest ruby infinite loop is 'while 1'?


wrong
8f6f95c4bd64d5f10dfddfdcd03c19d6?d=identicon&s=25 Rick Denatale (rdenatale)
on 2009-02-21 15:44
(Received via mailing list)
On Fri, Feb 20, 2009 at 6:02 PM, Louis-Philippe
<default@spiralix.org>wrote:

> mmm, Interesting to see loop being this high in the list,
> but even if they all loop from 0  to X doesn't mean they can all
> compared...
> I'm not sure what was the initial question (!!!), but mine is about
> infinite
> loop implementations,
> where list iterators  of the .each flavour don't do.
>
> So *THE* fastest ruby infinite loop is 'while 1'?
>

Anything purporting to be an infinite loop which runs faster than
something
which is an infinite loop is, by definition NOT an infinite loop!
<G>
--
Rick DeNatale

Blog: http://talklikeaduck.denhaven2.com/
Twitter: http://twitter.com/RickDeNatale
WWR: http://www.workingwithrails.com/person/9021-rick-denatale
LinkedIn: http://www.linkedin.com/in/rickdenatale
149379873fe2cb70e550c6bff8fedd0c?d=identicon&s=25 Jeff Schwab (Guest)
on 2009-02-21 16:50
(Received via mailing list)
Rick DeNatale wrote:

> Anything purporting to be an infinite loop which runs faster than something
> which is an infinite loop is, by definition NOT an infinite loop!
> <G>

Not sure Georg Cantor would agree with you.  One infinite loop might
only go through a countable (but infinite) number of iterations, i.e.
aleph null, whereas another might go through an uncountable number of
iterations.

Suppose one loop iterates over just the rationals, while another
iterates over the reals.  The former iterates fewer times than the
latter, even though both are infinite.

Still, your point is well taken. :)
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2009-02-21 17:56
(Received via mailing list)
On Sat, Feb 21, 2009 at 3:42 PM, Rick DeNatale <rick.denatale@gmail.com>
wrote:
> On Fri, Feb 20, 2009 at 6:02 PM, Louis-Philippe <default@spiralix.org>wrote:

> Anything purporting to be an infinite loop which runs faster than something
> which is an infinite loop is, by definition NOT an infinite loop!
> <G>
This was one of the most famous stories in our department . We were
developing a Debugger and my colleague was debugging an infinite loop,
which happened to be inside another infinite loop. Of course he did
not discover the problem of the outer infinite loop before having
fixed the inner one.
When our project leader asked him about the progress he had made, he
genuinely replied: "It still loops, but much faster". We happened to
pull his leg for quite some time of course :)?
Robert
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2009-02-21 17:57
(Received via mailing list)
On Sat, Feb 21, 2009 at 4:49 PM, Jeff Schwab <jeff@schwabcenter.com>
wrote:
> Rick DeNatale wrote:
>
>> Anything purporting to be an infinite loop which runs faster than
>> something
>> which is an infinite loop is, by definition NOT an infinite loop!
>> <G>
>
> Not sure Georg Cantor would agree with you.  One infinite loop might only go
> through a countable (but infinite) number of iterations, i.e. aleph null,
> whereas another might go through an uncountable number of iterations.
Might it? I do not think so! I believe that a Turing complete language
can only loop countable times, which of course should be fixed ;).
R.
54185df1d348bbd34587fcd4f8e4779b?d=identicon&s=25 Louis-Philippe (Guest)
on 2009-02-23 18:04
(Received via mailing list)
This is indeed very fun and mind boggling!Still, pragmatically, not all
infinite loops are equal, in the performance of their implementations
that
is.
So taking Ryan's idea to twist iterators to perform infinite loops, here
is
the benchmark again.

For the comparison to be as close as possible between the control
structures, I use the same inner routine for all, ignoring the fact that
I
could derive incrementation from the infinite range iteration, because
this
is not the subject of the benchmark.

Ruby Infinite loops Inplementations:
                           user     system      total        real
while1          31.960000   0.150000  32.110000 ( 36.749597)
loop             42.240000   0.190000  42.430000 ( 45.533708)
Infinite.each  108.400000   0.970000 109.370000 (117.421059)
for Infinite     112.070000   1.010000 113.080000 (126.712828)

#############

Benchmark.bm do |x|
 x.report('while1') do
n = 0
while 1 do
break if n >= 1000000
n += 1
end
end
 x.report('loop') do
n = 0
loop do
break if n >= 1000000
n += 1
end
end
 x.report('Infinite.each') do
n = 0
(0..(1/0.0)).each do
break if n >= 1000000
n += 1
end
end
 x.report('for Infinite') do
n = 0
for i in (0..(1/0.0)) do
break if n >= 1000000
n += 1
end
end
end

#############



2009/2/21 Robert Dober <robert.dober@gmail.com>
Please log in before posting. Registration is free and takes only a minute.
Existing account

NEW: Do you have a Google/GoogleMail, Yahoo or Facebook account? No registration required!
Log in with Google account | Log in with Yahoo account | Log in with Facebook account
No account? Register here.