红宝石中无限的发电机速度 - Method vs Enumerator vs Lazy

Question

警告:这没什么实际价值.我只是想知道发生了什么.

我在网上多次来到这条线:

return to_enum __method__ unless block_given?

我想测试它并用它制作一个生成器方法(#1),然后我尝试了它,并提出了一个枚举器(#2).我对此很满意,认为应该这样做 - 尽管后来我想出了一个使用#lazy(#3)的解决方案,我觉得它看起来更优雅.

你能猜出哪个最快吗？令我惊讶的是,#1是最快的,其次是#2和#3!
对我来说,第一个看起来像一个黑客,并有不良行为,如停止,如果你给它一个空块(而不是只是在给出一个块时抛出错误).

我的问题是,最快的方法是什么？为什么#1比#2快,我错过了什么？如果我的解决方案没问题,客观上最好吗？

编辑:更简单的例子,之前是fizzbuzz(http://pastebin.com/kXbbfxBc)

def method
  return to_enum __method__ unless block_given?
  n = 0
  loop do
    n += 1
    yield n ** 2
  end
end

enum = Enumerator.new do |yielder|
  n = 0
  loop do
    n += 1
    yielder.yield n ** 2
  end
end

lazy = (1..Float::INFINITY).lazy.map do |n|
  n ** 2
end

p method.take 50
p enum.take 50
p lazy.first 50

require 'benchmark/ips'
Benchmark.ips do |bm|
  bm.report('Method'){ method.take 50 }
  bm.report('Enumerator'){ enum.take 50 }
  bm.report('Lazy'){ lazy.first 50 }
  bm.compare!
end

Answer 1

后两种形式都有块绑定,这确实有一些开销; 当您使用块创建枚举器时,Ruby会将块转换为Proc并将其分配给a Enumerator::Generator,然后通过调用proc进行迭代.这会产生直接调用方法的开销.

如果我们消除块形式,也会消除性能损失:

def method
  return to_enum __method__ unless block_given?
  n = 0
  loop do
    n += 1
    yield n ** 2
  end
end

def method_sans_enum
  n = 0
  loop do
    n += 1
    yield n ** 2
  end
end

method_enum = Enumerator.new(self, :method_sans_enum)

enum = Enumerator.new do |yielder|
  n = 0
  loop do
    n += 1
    yielder.yield n ** 2
  end
end

lazy = (1..Float::INFINITY).lazy.map do |n|
  n ** 2
end

p method.take 50
p enum.take 50
p method_enum.take 50
p lazy.first 50

require 'benchmark/ips'
Benchmark.ips do |bm|
  bm.report('Method'){ method.take 50 }
  bm.report('Enumerator'){ enum.take 50 }
  bm.report('Enumerator 2'){ method_enum.take 50 }
  bm.report('Lazy'){ lazy.first 50 }
  bm.compare!
end

结果:

      Method    10.874k i/100ms
  Enumerator     6.152k i/100ms
Enumerator 2    11.733k i/100ms
        Lazy     3.885k i/100ms

Comparison:
        Enumerator 2:   132050.2 i/s
              Method:   124784.1 i/s - 1.06x slower
          Enumerator:    65961.9 i/s - 2.00x slower
                Lazy:    40063.6 i/s - 3.30x slower

调用procs涉及调用方法没有的开销; 例如:

class Foo
  def meth; end
end

instance = Foo.new
pr = instance.method(:meth).to_proc

require 'benchmark/ips'
Benchmark.ips do |bm|
  bm.report('Method'){ instance.meth }
  bm.report('Proc'){ pr.call }
  bm.compare!
end

结果:

Calculating -------------------------------------
          Method   121.016k i/100ms
            Proc   104.612k i/100ms
-------------------------------------------------
          Method      6.823M (± 0.1%) i/s -     34.127M
            Proc      3.443M (± 6.4%) i/s -     17.156M

Comparison:
          Method:  6822666.0 i/s
            Proc:  3442578.2 i/s - 1.98x slower

调用已转换为proc的方法比直接调用方法慢2倍 - 几乎就是您观察到的确切性能偏差.