Very slow while loop when condition requires value outide of block.

Compiler version

3.0.0

Minimized example

object Main extends App {
  def timeMeasure[R](name: String)(block: => R): R = {
    val startTime = System.currentTimeMillis()
    val result = block
    val endTime = System.currentTimeMillis()
    println(s"Execute '$name' in ${endTime - startTime} ms")
    result
  }

  timeMeasure("filling array via while, n inside of block") {
    val n = 1000000
    val array = new Array[Int](n)
    var i = 0
    while (i < n) {
      array(i) = i
      i += 1
    }
    array
  }
  val n = 1000000
  timeMeasure("filling array via while, n outside of block") {
    val array = new Array[Int](n)
    var i = 0
    while (i < n) {
      array(i) = i
      i += 1
    }
    array
  }
}

Output

Execute 'filling array via while, n inside of block' in 4 ms
Execute 'filling array via while, n outside of block' in 7497 ms

Event when I warm my JVM, and execute this test 100 times, result (I mean, performance) the same.

Expectation

I expect that 2nd block will executes in about 4 ms. I found that there is difference in generated Java bytecode: 2nd version use n() as function. But when I copy this code as Java code, and run it, it was fast. So problem not only in using n as function instead of using it as integer. This problem also exists on Scala 3.0.1 and event on 3.1.2-RC1-bin-20211022-f7abd32-NIGHTLY.

Linked with: https://stackoverflow.com/questions/69697784/why-fill-array-in-while-loop-is-so-slow-in-scala-3

[SethTisue]

in Scala 2, App uses DelayedInit, as per https://docs.scala-lang.org/scala3/book/methods-main-methods.html . the doc page should probably call attention to the slow-constructor problem, since it’s the whole reason DelayedInit exists

[dwijnand]

The previous functionality of App, which relied on the “magic” DelayedInit trait, is no longer available. App still exists in limited form for now, but it doesn’t support command line arguments and will be deprecated in the future.

And it seems like using @main with a top level val has the same speed:

$ scala -3.head i13819.scala
Execute 'filling array via while, n inside of block' in 4 ms
Execute 'filling array via while, n outside of block' in 3 ms
Execute 'filling array via while, m top level' in 4 ms