如何在Scala中优化理解和循环？

因此，Scala应该和Java一样快。我正在重新研究最初在Java中解决的Scala Project Euler问题。尤其是问题5：“能被1到20的所有数均分的最小正数是多少？”

这是我的Java解决方案，需要0.7秒才能在我的计算机上完成：

public class P005_evenly_divisible implements Runnable{
    final int t = 20;

    public void run() {
        int i = 10;
        while(!isEvenlyDivisible(i, t)){
            i += 2;
        }
        System.out.println(i);
    }

    boolean isEvenlyDivisible(int a, int b){
        for (int i = 2; i <= b; i++) {
            if (a % i != 0) 
                return false;
        }
        return true;
    }

    public static void main(String[] args) {
        new P005_evenly_divisible().run();
    }
}

这是我对Scala的“直接翻译”，需要103秒（长147倍！）

object P005_JavaStyle {
    val t:Int = 20;
    def run {
        var i = 10
        while(!isEvenlyDivisible(i,t))
            i += 2
        println(i)
    }
    def isEvenlyDivisible(a:Int, b:Int):Boolean = {
        for (i <- 2 to b)
            if (a % i != 0)
                return false
        return true
    }
    def main(args : Array[String]) {
        run
    }
}

最后，这是我进行函数式编程的尝试，该过程需要39秒（长55倍）

object P005 extends App{
    def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}
    def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
    println (find (2))
}

在Windows 7 64位上使用Scala 2.9.0.1。如何改善效能？难道我做错了什么？还是Java快了很多？

在这种情况下，问题是您从for表达式中返回。依次将其转换为抛出NonLocalReturnException的异常，该异常在封装方法中捕获。优化器可以消除前馈，但仍不能消除抛出/捕获。而且投掷/接球很昂贵。但是由于这样的嵌套返回在Scala程序中很少见，因此优化器尚未解决这种情况。有一些工作正在进行中，以改进优化器，希望它能尽快解决此问题。

问题很可能是for在方法中使用了理解isEvenlyDivisible。for用等效while循环代替应该消除Java的性能差异。

与Java for循环相反，Scala的for理解实际上是高阶方法的语法糖。在这种情况下，您是foreach在Range对象上调用方法。Scala的用法for很笼统，但有时会导致痛苦的表现。

您可能想-optimize在Scala 2.9版中尝试使用该标志。观察到的性能可能取决于所使用的特定JVM，并且JIT优化器具有足够的“热身”时间来识别和优化热点。

关于邮件列表的最新讨论表明，Scala团队正在努力改善for简单情况下的性能：

• http://groups.google.com/group/scala-user/browse_thread/thread/86adb44d72ef4498
• http://groups.google.com/group/scala-language/browse_thread/thread/94740a10205dddd2

这是错误跟踪器中的问题：https : //issues.scala-lang.org/browse/SI-4633

更新5/28：

• 作为一种短期解决方案，ScalaCL插件（alpha）会将简单的Scala循环转换为等效的while循环。
• 作为潜在的长期解决方案，EPFL和斯坦福大学的团队正在合作进行一个项目，该项目可对“虚拟” Scala进行运行时编译以实现非常高的性能。例如，可以在运行时将多个惯用功能循环融合到最佳JVM字节码中，或融合到另一个目标（例如GPU）上。该系统是可扩展的，允许用户定义DSL和转换。查看出版物和斯坦福大学课程笔记。初步代码可在Github上获得，并计划在未来几个月内发布。

作为后续，我尝试了-optimize标志，它将运行时间从103秒减少到了76秒，但是仍然比Java或while循环慢107倍。

然后我在看“功能”版本：

object P005 extends App{
  def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}
  def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
  println (find (2))
}

并试图找出如何以简洁的方式摆脱“所有人”的问题。我惨败了，想出了

object P005_V2 extends App {
  def isDivis(x:Int):Boolean = {
    var i = 1
    while(i <= 20) {
      if (x % i != 0) return false
      i += 1
    }
    return true
  }
  def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
  println (find (2))
}

因此，我狡猾的5行解决方案已减少到12行。但是，此版本的运行时间为0.71秒，与原始Java 版本的运行速度相同，比使用“ forall”（40.2 s）的上述版本快56倍！（有关为什么它比Java更快的原因，请参见下面的编辑）

显然，我的下一步是将以上内容转换回Java，但是Java无法处理它，并在22000标记附近抛出StackOverflowError，其中n为n。

然后，我挠了一下头，然后用更多的尾部递归替换了“ while”，这节省了几行，并且运行得一样快，但让我们面对现实，这会使阅读起来更加混乱：

object P005_V3 extends App {
  def isDivis(x:Int, i:Int):Boolean = 
    if(i > 20) true
    else if(x % i != 0) false
    else isDivis(x, i+1)

  def find(n:Int):Int = if (isDivis(n, 2)) n else find (n+2)
  println (find (2))
}

因此，Scala的尾部递归赢得了胜利，但是令我惊讶的是，诸如“ for”循环（以及“ forall”方法）之类的简单操作本质上已被破坏，并且必须由笨拙且冗长的“ whiles”或尾递归来代替。我尝试Scala的很多原因是因为语法简洁，但是如果我的代码运行速度慢100倍，那就不好了！

编辑：（已删除）

编辑：以前在2.5s和0.7s之间的运行时间差异完全是由于使用32位还是64位JVM。命令行中的Scala使用JAVA_HOME设置的内容，而Java使用64位（如果可用）。IDE具有自己的设置。这里的一些测量：Eclipse中的Scala执行时间

关于理解的答案是正确的，但这不是全部。您应该注意，returnin 的使用isEvenlyDivisible不是免费的。在中使用return会for强制Scala编译器生成非本地返回（即在函数外部返回）。

这是通过使用异常退出循环来完成的。如果您构建自己的控件抽象，也会发生相同的情况，例如：

def loop[T](times: Int, default: T)(body: ()=>T) : T = {
    var count = 0
    var result: T = default
    while(count < times) {
        result = body()
        count += 1
    }
    result
}

def foo() : Int= {
    loop(5, 0) {
        println("Hi")
        return 5
    }
}

foo()

这只会打印“ Hi”一次。

请注意，returnin foo出口foo（这是您期望的）。由于方括号括起来的表达式是函数文字，您可以在签名中看到loop这迫使编译器生成非本地返回值，即，return迫使您退出foo，而不仅仅是body。

在Java（即JVM）中，实现这种行为的唯一方法是引发异常。

回到isEvenlyDivisible：

def isEvenlyDivisible(a:Int, b:Int):Boolean = {
  for (i <- 2 to b) 
    if (a % i != 0) return false
  return true
}

该if (a % i != 0) return false是有回报的功能文字，所以每次返回被击中时，运行时必须抛出和捕捉异常，导致相当多的GC的开销。

加快forall我发现的方法的一些方法：

原稿：41.3秒

def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}

预先实例化范围，因此我们不会每次都创建一个新范围：9.0 s

val r = (1 to 20)
def isDivis(x:Int) = r forall {x % _ == 0}

转换为列表而不是范围：4.8 s

val rl = (1 to 20).toList
def isDivis(x:Int) = rl forall {x % _ == 0}

我尝试了其他一些集合，但是List最快（尽管比我们完全避免使用Range和高阶函数要慢7倍）。

虽然我是Scala的新手，但我猜编译器可以通过用最外面的作用域中的Range常量简单地自动替换方法（如上）中的Range文字来轻松实现快速而显着的性能提升。或者更好的是，像Java中的Strings文字一样对它们进行实习。

脚注：数组与Range大致相同，但是有趣的是，拉皮条新forall方法（如下所示）在64位上的执行速度提高了24％，在32位上的执行速度提高了8％。当我通过将因子数量从20减少到15来减小计算量时，差异消失了，所以这可能是垃圾回收效果。无论是什么原因，长时间在满负载下运行都非常重要。

List的类似皮条客也使性能提高了约10％。

  val ra = (1 to 20).toArray
  def isDivis(x:Int) = ra forall2 {x % _ == 0}

  case class PimpedSeq[A](s: IndexedSeq[A]) {
    def forall2 (p: A => Boolean): Boolean = {      
      var i = 0
      while (i < s.length) {
        if (!p(s(i))) return false
        i += 1
      }
      true
    }    
  }  
  implicit def arrayToPimpedSeq[A](in: Array[A]): PimpedSeq[A] = PimpedSeq(in)  

我只是想为可能对这样的问题失去信心的人们发表评论，因为这类问题几乎涉及所有功能语言的性能。如果要在Haskell中优化折叠，则通常必须将其重写为递归尾部调用优化循环，否则将遇到性能和内存问题。

我知道不幸的是，FP还没有进行优化，以至于我们不必考虑这样的事情，但这并不是Scala特有的问题。

已经讨论了Scala特有的问题，但是主要问题是使用蛮力算法不是很酷。考虑一下（比原始Java代码快得多）：

def gcd(a: Int, b: Int): Int = {
    if (a == 0)
        b
    else
        gcd(b % a, a)
}
print (1 to 20 reduce ((a, b) => {
  a / gcd(a, b) * b
}))

尝试在解决方案Scala中为欧拉计划提供的单线

给定的时间至少比您的时间快，尽管距离while循环还很远.. :)