长生不老药比红宝石慢吗?

Question

请帮我解决一个关于Elixir与Ruby性能的基准问题。

我尝试在两种语言中实现相同的阶乘，Ruby显示出比Elixir更好的结果：

# ruby_factorial_with_iterator.rb
def factorial_with_iterator(n)
res = 1
(1..n).each{|time| res *= time}
res
end
p "factorial_with_iterator(200000)"
p factorial_with_iterator(200000)

运行后：

$ time ruby ruby_factorial_with_iterator.rb
real  0m18.378s
user  0m17.348s
sys   0m0.844s

和两个长生不老药的例子：

# elixir_factorial_with_iterator.exs
defmodule FactorialWithIterator do
def of(n) do
Enum.reduce(1..n, 1, &*/2)
end
end
IO.puts "Factorial of 200000: "
IO.puts FactorialWithIterator.of(200000)

运行后：

$ time elixir elixir_factorial_with_iterator.exs
real  1m1.735s
user  1m1.556s
sys   0m0.104s

再比如：

# elixir_factorial_with_recursion.exs
defmodule FactorialWithRecursion do
def of(0), do: 1
def of(n) when n > 0 do
n * of(n - 1)
end
end
IO.puts "Factorial of 200000: "
IO.puts FactorialWithRecursion.of(200000)

运行后：

$ time elixir elixir_factorial_with_recursion.exs
real  1m7.149s
user  1m6.248s
sys   0m0.092s

为什么会有如此巨大的差异：Elixir - 1m1s，而Ruby - 只有18s？或者如何在Elixir中编写正确的迭代代码？

附言 环境：

• 乌班图16.04
• Ruby 2.3.1P112 (2016-04-26 修订版 54768) [x86_64-Linux]
• Erlang/OTP 19 [erts-8.3] [source-d5c06c6] [64 位] [smp：4：4] [异步线程：10] [hipe] [内核-poll：false]
• 长生不老药 1.4.4

Answer 1

正如其中一条评论中提到的，您正在使用time，这也是 VM 的启动时间，在 elixir 的情况下，将代码编译为 BEAM 字节码。 为了避免计算所有这些，您应该使用语言本身的基准测试工具。

我很好奇，所以我尝试自己对这些函数进行基准测试。

我使用过：

• 长生不老药的benchee：https://github.com/PragTob/benchee
• 红宝石benchmark-ips：https://github.com/evanphx/benchmark-ips

红宝石：

require 'benchmark/ips'
def factorial_with_iterator(n)
res = 1
(1..n).each{|time| res *= time}
res
end
Benchmark.ips do |x|
x.config(time: 5, warmup: 2)
x.report('factorial_with_iterator.rb') do
factorial_with_iterator(200000)
end
x.compare!
end

炼金药：

defmodule Factorial do
def iter(n) do
Enum.reduce(1..n, 1, &*/2)
end
def recur(0), do: 1
def recur(n) when n > 0 do
n * recur(n - 1)
end
end
Benchee.run(%{
"factorial_with_iter.ex" => fn -> Factorial.iter(200000) end,
"factorial_with_recur.ex" => fn -> Factorial.recur(200000) end
})

我得到了这些结果：

红宝石：

Warming up --------------------------------------
factorial_with_iterator.rb
1.000  i/100ms
Calculating -------------------------------------
factorial_with_iterator.rb
0.033  (± 0.0%) i/s -      1.000  in  29.994713s

炼金药：

Name                              ips        average  deviation         median         99th %
factorial_with_iter.ex         0.0395        25.29 s     ±0.00%        25.29 s        25.29 s
factorial_with_recur.ex        0.0368        27.17 s     ±0.00%        27.17 s        27.17 s
Comparison:
factorial_with_iter.ex         0.0395
factorial_with_recur.ex        0.0368 - 1.07x slower

因此，这些结果表明，Elixir在两种实现中都略快，Ruby需要~30秒，Elixir需要~25和~27秒。

但是，使用"每秒迭代次数"，对于花费比一秒长得多的函数可能有点"错误"。 所以我也尝试了低得多的输入。 我用 1_000 代替 200_000，并得到以下结果：

红宝石：

Warming up --------------------------------------
factorial_with_iterator.rb
169.000  i/100ms
Calculating -------------------------------------
factorial_with_iterator.rb
1.750k (± 8.0%) i/s -      8.788k in   5.064619s

炼金药：

Name                              ips        average  deviation         median         99th %
factorial_with_recur.ex        3.15 K      317.36 μs    ±12.72%         306 μs      481.87 μs
factorial_with_iter.ex         3.02 K      331.13 μs    ±16.83%         316 μs         559 μs
Comparison:
factorial_with_recur.ex        3.15 K
factorial_with_iter.ex         3.02 K - 1.04x slower

奇怪的是，这表明Elixir比Ruby快得多。 Elixir能够为两种实现每秒执行超过3k的迭代，而Ruby每秒只能执行1.75k迭代。

用：

• Ruby 2.4.1P111 (2017-03-22 修订版 58053) [x86_64-达尔文16]
• Elixir 1.6.5 (使用 OTP 19 编译) 运行在 Erlang/OTP 21 上 [erts-10.0] [源] [64 位] [smp：8：8] [ds：8：8：10] [异步线程：1] [hipe] [dtrace]