Made benchmarks more consistent and complete

Author: Antoine Brunner

bench-run/src/main/scala/tuples/Apply.scala

@@ -21,15 +21,12 @@ class Apply {
   }
 
   @Benchmark
-  def baseline(): Unit = {}
-
-  @Benchmark
-  def normal(): Any = {
-    tuple(index)
+  def tupleApply(): Any = {
+    DynamicTuple.dynamicApply(tuple, index)
   }
 
   @Benchmark
-  def inlined(): Any = {
-    DynamicTuple.dynamicApply(tuple, index)
+  def productElement(): Any = {
+    tuple.asInstanceOf[Product].productElement(index)
   }
 }

bench-run/src/main/scala/tuples/ArrayOps.scala

@@ -23,25 +23,27 @@ class ArrayOps {
   }
 
   @Benchmark
-  def baseline(): Unit = {}
-
-  @Benchmark
-  def toArray(): Array[Object] = {
+  def tupleToArray(): Array[Object] = {
     DynamicTuple.dynamicToArray(tuple)
   }
 
   @Benchmark
-  def toIArray(): IArray[Object] = {
+  def tupleToIArray(): IArray[Object] = {
     DynamicTuple.dynamicToIArray(tuple)
   }
 
   @Benchmark
-  def fromArray(): Tuple = {
+  def tupleFromArray(): Tuple = {
     DynamicTuple.dynamicFromArray(array)
   }
 
   @Benchmark
-  def fromIArray(): Tuple = {
+  def tupleFromIArray(): Tuple = {
     DynamicTuple.dynamicFromIArray(iarray)
   }
+
+  @Benchmark
+  def productToArray(): Array[Object] = {
+    DynamicTuple.productToArray(tuple.asInstanceOf[Product])
+  }
 }

bench-run/src/main/scala/tuples/Concat.scala

@@ -31,34 +31,12 @@ class Concat {
   }
 
   @Benchmark
-  def baseline(): Unit = {}
-
-  @Benchmark
-  def normal(): Tuple = {
-   tuple1 ++ tuple2
-  }
-
-  @Benchmark
-  def inlined(): Tuple = {
+  def tupleConcat(): Tuple = {
     DynamicTuple.dynamicConcat(tuple1, tuple2)
   }
 
-  // This part is here to try and measure the overhead of tranforming tuples to arrays, then concatenating
-  // the array, and then transforming back to a tuple
-  @Benchmark
-  def toArray(bh: Blackhole): Unit = {
-    bh.consume(DynamicTuple.dynamicToArray(tuple1))
-    bh.consume(DynamicTuple.dynamicToArray(tuple2))
-  }
-
   @Benchmark
   def arrayConcat(): Array[Object] = {
     array1 ++ array2
   }
-
-  @Benchmark
-  def fromArray(bh: Blackhole): Unit = {
-    bh.consume(DynamicTuple.dynamicFromArray[Tuple](array1))
-    bh.consume(DynamicTuple.dynamicFromArray[Tuple](array2))
-  }
 }

bench-run/src/main/scala/tuples/Cons.scala

@@ -21,19 +21,10 @@ class Cons {
   }
 
   @Benchmark
-  def baseline(): Unit = {}
-
-  @Benchmark
-  def normal(): Tuple = {
-    "elem" *: tuple
-  }
-
-  @Benchmark
-  def inlined(): Tuple = {
+  def tupleCons(): Tuple = {
     DynamicTuple.dynamicCons("elem", tuple)
   }
 
-  // This part is here to measure the performance of dong a cons on arrays directly
   @Benchmark
   def arrayCons(): Array[Object] = {
     DynamicTuple.cons$Array("elem", array)

bench-run/src/main/scala/tuples/Tail.scala

@@ -0,0 +1,32 @@
+package dotty.tools.benchmarks.tuples
+
+import org.openjdk.jmh.annotations._
+import scala.runtime.DynamicTuple
+
+@State(Scope.Thread)
+class Tail {
+  @Param(Array("1"))
+  var size: Int = _
+  var tuple: NonEmptyTuple = _
+  var array: Array[Object] = _
+
+  @Setup
+  def setup(): Unit = {
+    tuple = "elem" *: ()
+
+    for (i <- 1 until size)
+      tuple = "elem" *: tuple
+
+    array = Array.fill(size)("elem")
+  }
+
+  @Benchmark
+  def tupleTail(): Tuple = {
+    DynamicTuple.dynamicTail(tuple)
+  }
+
+  @Benchmark
+  def arrayTail(): Array[Object] = {
+    array.tail
+  }
+}