Add Pair to benchmark

This way, we have a benchmark test that does not rely on inner classes

Author: timotheeandres

bench-micro/src/main/scala/dotty/tools/benchmarks/inlinetraits/InlineTraitBenchmark.scala

@@ -5,34 +5,52 @@ import java.util.concurrent.TimeUnit.{SECONDS, MILLISECONDS}
 import scala.util.Random
 
 @BenchmarkMode(Array(Mode.AverageTime))
-@Fork(3)
+@Fork(2)
 @Threads(3)
 @Warmup(iterations = 3, time = 3, timeUnit = SECONDS)
 @Measurement(iterations = 5, time = 5, timeUnit = SECONDS)
 @OutputTimeUnit(MILLISECONDS)
 @State(Scope.Benchmark)
 class InlineTraitBenchmark {
-  // @Param(Array("100", "200", "300"))
   var matrixSize: Int = 300
 
+  var numPairs: Int = 3_000_000
+
   def intMatrixElems: List[List[Int]] =
     List.tabulate(matrixSize, matrixSize)((_, _) => Random.nextInt())
 
+  def pairElems: List[(First, Second)] = List.tabulate(numPairs)(_ % 2 match {
+    case 0 => (Random.nextInt(), Random.nextDouble())
+    case 1 => (Random.nextInt(Char.MaxValue).asInstanceOf[Char], Random.nextInt(Short.MaxValue).asInstanceOf[Short])
+  })
+
   @Param(Array("standard", "specialized", "inlinetrait"))
   var libType: String = _
 
   var m1: BenchmarkMatrix = _
   var m2: BenchmarkMatrix = _
 
+  var pairs: List[BenchmarkPair] = _
+
   @Setup(Level.Trial)
   def setup = {
     Random.setSeed(matrixSize)
 
     val matrixFactory = BenchmarkMatrix.ofType(libType)
     m1 = matrixFactory(intMatrixElems)
     m2 = matrixFactory(intMatrixElems)
+
+    val pairFactory = BenchmarkPair.ofType(libType)
+    pairs = pairElems.map((_1, _2) => pairFactory(_1, _2))
   }
 
   @Benchmark
   def matrixBenchmark = (m1 + m2) * m1 // O(n^3) loops
+
+  @Benchmark
+  def pairsBenchmark = pairs.foldLeft(0){ case (sum, pair) => pair match {
+      case BenchmarkPair(i: Int, d: Double) => 7 * i + 3 * d.toInt + sum
+      case BenchmarkPair(c: Char, s: Short) => 5 * c + 2 * s + sum
+    }
+  }
 }

bench-micro/src/main/scala/dotty/tools/benchmarks/inlinetraits/PairOps.scala

@@ -0,0 +1,33 @@
+package dotty.tools.benchmarks.inlinetraits
+
+import standard.{Pair => StdPair}
+import specialized.{Pair => SpePair}
+import inlinetrait.{
+  Pair => InlPair,
+  IntDoublePair => IDPair,
+  CharShortPair => CSPair,
+}
+
+type First = Int | Char
+type Second = Double | Short
+
+class BenchmarkPair private (val _1: First, val _2: Second):
+  def this(p: StdPair[First, Second]) = this(p._1, p._2)
+  def this(p: SpePair[First, Second]) = this(p._1, p._2)
+  def this(p: InlPair[First, Second]) = this(p._1, p._2)
+
+object BenchmarkPair:
+  def ofType(tpe: String): (First, Second) => BenchmarkPair =
+    (_1: First, _2: Second) => tpe.toLowerCase() match {
+      case "standard" => BenchmarkPair(StdPair(_1, _2))
+      case "specialized" => BenchmarkPair(SpePair(_1, _2))
+      case "inlinetrait" =>
+        val concretePair: InlPair[First, Second] = (_1, _2) match {
+          case (_1: Int, _2: Double) => IDPair(_1, _2)
+          case (_1: Char, _2: Short) => CSPair(_1, _2)
+          case _ => ???
+        }
+        BenchmarkPair(concretePair)
+    }
+
+  def unapply(p: BenchmarkPair): Option[(First, Second)] = Some(p._1, p._2)

bench-micro/src/main/scala/dotty/tools/benchmarks/inlinetraits/inlinetrait/Pair.scala

@@ -0,0 +1,10 @@
+package dotty.tools.benchmarks.inlinetraits
+package inlinetrait
+
+inline trait Pair[+T1, +T2]:
+  val _1: T1
+  val _2: T2
+  final def toTuple: (T1, T2) = (_1, _2)
+
+case class IntDoublePair(_1: Int, _2: Double) extends Pair[Int, Double]
+case class CharShortPair(_1: Char, _2: Short) extends Pair[Char, Short]

bench-micro/src/main/scala/dotty/tools/benchmarks/inlinetraits/specialized/Pair.scala

@@ -0,0 +1,8 @@
+package dotty.tools.benchmarks.inlinetraits
+package specialized
+
+import scala.specialized
+
+case class Pair[@specialized(Int, Char) +T1, @specialized(Double, Short) +T2](_1: T1, _2: T2) {
+  final def toTuple: (T1, T2) = (_1, _2)
+}

bench-micro/src/main/scala/dotty/tools/benchmarks/inlinetraits/standard/Pair.scala

@@ -0,0 +1,5 @@
+package dotty.tools.benchmarks.inlinetraits
+package standard
+
+case class Pair[+T1, +T2](_1: T1, _2: T2):
+  final def toTuple: (T1, T2) = (_1, _2)