Add benchmarks for specialization

bench-run/src/main/scala/dotty/tools/benchmarks/specialization/Functions.scala

@@ -20,33 +20,52 @@ class Functions {
     def foo(x: => Int): Int = x
   }
 
+  // outsmart JVM with storage in mutable array
   var byName = new ByName
+  var arrByName = Array(byName, null)
 
   @Benchmark
-  def byNameBench(): Int = 10000.times { byName.foo(6) }
+  def byNameBench(): Int = 10000.times {
+    // necessary to outsmart JVM
+    // remove it will result in 200x speed up
+    arrByName(1) = null
+    arrByName(0).foo(6)
+  }
 
 
   var fn = (x: Int) => x + 1
+  var arr = Array(fn, null)
   @Benchmark
-  def lambdaBench(): Int = 10000.times { fn(2) }
+  def lambdaBench(): Int = 10000.times {
+    arr(1) = null
+    arr(0)(2)
+  }
 
   class Func1[T](fn: T => Int) extends Function1[T, Int] {
     def apply(x: T): Int = fn(x)
   }
   class Fn extends Func1(identity[Int])
 
   var fn1: Function1[Int, Int] = new Fn
+  var arr1 = Array(fn1, null)
 
   @Benchmark
-  def extendFun1Bench(): Int = 10000.times { fn1(12) }
+  def extendFun1Bench(): Int = 10000.times {
+    arr1(1) = null
+    arr1(0)(12)
+  }
 
 
   class Func2 extends Function2[Int, Int, Int] {
     def apply(i: Int, j: Int) = i + j
   }
 
   var fn2: Function2[Int, Int, Int] = new Func2
+  var arr2 = Array(fn2, null)
 
   @Benchmark
-  def extendFun2Bench(): Int = 1000000.times { fn2(1300, 37) }
+  def extendFun2Bench(): Int = 10000.times {
+    arr2(1) = null
+    arr2(0)(1300, 37)
+  }
 }