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并将其分配给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倍 - 几乎就是您观察到的确切性能偏差。

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

1 个答案: