【发布时间】：2013-02-28 14:56:25
【问题描述】：
我编写了一个简单的测试平台来测量三种阶乘实现的性能：基于循环、非尾递归和尾递归。
令我惊讶的是，性能最差的是循环的（«while» 预计会更高效，所以我提供了两者） 几乎是尾递归替代方案的两倍。
*回答：修复循环实现，避免 = 运算符，该运算符在 BigInt 中表现最差，因为它的内部 «循环» 变得如预期的那样最快
我遇到的另一个 «woodoo» 行为是 StackOverflow 没有针对相同输入系统地抛出的异常 非尾递归实现的情况。我可以绕过 StackOverlow 通过逐步调用越来越大的函数 values... 我觉得很疯狂 :) 答案：JVM 需要在启动过程中收敛，然后行为是连贯和系统的
这是代码：
final object Factorial {
type Out = BigInt
def calculateByRecursion(n: Int): Out = {
require(n>0, "n must be positive")
n match {
case _ if n == 1 => return 1
case _ => return n * calculateByRecursion(n-1)
}
}
def calculateByForLoop(n: Int): Out = {
require(n>0, "n must be positive")
var accumulator: Out = 1
for (i <- 1 to n)
accumulator = i * accumulator
accumulator
}
def calculateByWhileLoop(n: Int): Out = {
require(n>0, "n must be positive")
var accumulator: Out = 1
var i = 1
while (i <= n) {
accumulator = i * accumulator
i += 1
}
accumulator
}
def calculateByTailRecursion(n: Int): Out = {
require(n>0, "n must be positive")
@tailrec def fac(n: Int, acc: Out): Out = n match {
case _ if n == 1 => acc
case _ => fac(n-1, n * acc)
}
fac(n, 1)
}
def calculateByTailRecursionUpward(n: Int): Out = {
require(n>0, "n must be positive")
@tailrec def fac(i: Int, acc: Out): Out = n match {
case _ if i == n => n * acc
case _ => fac(i+1, i * acc)
}
fac(1, 1)
}
def comparePerformance(n: Int) {
def showOutput[A](msg: String, data: (Long, A), showOutput:Boolean = false) =
showOutput match {
case true => printf("%s returned %s in %d ms\n", msg, data._2.toString, data._1)
case false => printf("%s in %d ms\n", msg, data._1)
}
def measure[A](f:()=>A): (Long, A) = {
val start = System.currentTimeMillis
val o = f()
(System.currentTimeMillis - start, o)
}
showOutput ("By for loop", measure(()=>calculateByForLoop(n)))
showOutput ("By while loop", measure(()=>calculateByWhileLoop(n)))
showOutput ("By non-tail recursion", measure(()=>calculateByRecursion(n)))
showOutput ("By tail recursion", measure(()=>calculateByTailRecursion(n)))
showOutput ("By tail recursion upward", measure(()=>calculateByTailRecursionUpward(n)))
}
}
以下是 sbt 控制台的一些输出（在 «while» 实施之前）：
scala> example.Factorial.comparePerformance(10000)
By loop in 3 ns
By non-tail recursion in >>>>> StackOverflow!!!!!… see later!!!
........
scala> example.Factorial.comparePerformance(1000)
By loop in 3 ms
By non-tail recursion in 1 ms
By tail recursion in 4 ms
scala> example.Factorial.comparePerformance(5000)
By loop in 105 ms
By non-tail recursion in 27 ms
By tail recursion in 34 ms
scala> example.Factorial.comparePerformance(10000)
By loop in 236 ms
By non-tail recursion in 106 ms >>>> Now works!!!
By tail recursion in 127 ms
scala> example.Factorial.comparePerformance(20000)
By loop in 977 ms
By non-tail recursion in 495 ms
By tail recursion in 564 ms
scala> example.Factorial.comparePerformance(30000)
By loop in 2285 ms
By non-tail recursion in 1183 ms
By tail recursion in 1281 ms
以下是 sbt 控制台的一些输出（在 «while» 实施之后）：
scala> example.Factorial.comparePerformance(10000)
By for loop in 252 ms
By while loop in 246 ms
By non-tail recursion in 130 ms
By tail recursion in 136 ns
scala> example.Factorial.comparePerformance(20000)
By for loop in 984 ms
By while loop in 1091 ms
By non-tail recursion in 508 ms
By tail recursion in 560 ms
以下是 sbt 控制台的一些输出（在«向上»尾递归实施之后）世界恢复正常：
scala> example.Factorial.comparePerformance(10000)
By for loop in 259 ms
By while loop in 229 ms
By non-tail recursion in 114 ms
By tail recursion in 119 ms
By tail recursion upward in 105 ms
scala> example.Factorial.comparePerformance(20000)
By for loop in 1053 ms
By while loop in 957 ms
By non-tail recursion in 513 ms
By tail recursion in 565 ms
By tail recursion upward in 470 ms
以下是在 «loops» 中修复 BigInt 乘法后 sbt 控制台的一些输出：世界完全正常：
scala> example.Factorial.comparePerformance(20000)
By for loop in 498 ms
By while loop in 502 ms
By non-tail recursion in 521 ms
By tail recursion in 611 ms
By tail recursion upward in 503 ms
BigInt 开销和我的 愚蠢 实现掩盖了预期的行为。
PS.：最后我应该把这篇文章重新命名为 «A lernt course on BigInts»
【问题讨论】：
-
问题是什么？
-
"应该避免循环" 这是误导性的，在 scala 中，for 循环通常比等效的 while 循环慢得多。尾递归通常比非尾递归快，我会说它更慢，因为你在函数开始之前创建了闭包。
-
谁能帮助我理解这种指向权威参考的行为。
-
@Score_Under：我没有看到尾递归实现中有任何闭包，你指的是哪一个？
-
Rex 解决了主要问题，但您应该研究 JVM 上的基准，因为您做错了。在 JVM 上正确地进行基准测试非常非常困难，并且很难从它们的结果中推断出任何有用的东西（适用于微基准的内容不适用于更大的上下文）。这里需要注意的是，在开始测试之前你不是垃圾收集，这势必会产生很大的变化。
标签： performance scala stack-overflow tail-recursion