Inline traits for specialization in Scala 3

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

@@ -0,0 +1,27 @@
+package dotty.tools.benchmarks.inlinetraits
+
+import org.openjdk.jmh.annotations._
+import java.util.concurrent.TimeUnit.{SECONDS, MILLISECONDS}
+import scala.util.Random
+
+// @BenchmarkMode(Array(Mode.SampleTime))
+@Fork(3)
+@Threads(3)
+@Warmup(iterations = 5, time = 10, timeUnit = SECONDS)
+@Measurement(iterations = 10, time = 10, timeUnit = SECONDS)
+// @OutputTimeUnit(MILLISECONDS)
+@State(Scope.Benchmark)
+class Boxing {
+  class Wrapper[T](val x: T)
+  class IntWrapper(val x: Int)
+
+  val numbers = 1 to 1000000
+  val ws = numbers.map(Wrapper(_))
+  val iws = numbers.map(IntWrapper(_))
+
+  @Benchmark
+  def noUnboxing: Int = iws.map(w => IntWrapper(w.x*w.x + 2*w.x)).foldLeft(0)(_ + _.x)
+
+  @Benchmark
+  def withUnboxing: Int = ws.map(w => Wrapper(w.x*w.x + 2*w.x)).foldLeft(0)(_ + _.x)
+}

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

@@ -0,0 +1,35 @@
+package dotty.tools.benchmarks.inlinetraits
+
+import org.openjdk.jmh.annotations._
+import java.util.concurrent.TimeUnit.SECONDS
+import scala.util.Random
+
+@Fork(10)
+@Threads(3)
+@Warmup(iterations = 3, time = 5, timeUnit = SECONDS)
+@Measurement(iterations = 5, time = 10, timeUnit = SECONDS)
+@State(Scope.Benchmark)
+class MatrixBenchmark {
+  val n: Int = 100
+
+  def intMatrixElems: List[List[Int]] =
+    List.tabulate(n, n)((_, _) => Random.nextInt())
+
+  @Param(Array("standard", "specialized", "inlinetrait"))
+  var libType: String = _
+
+  var m1: BenchmarkMatrix = _
+  var m2: BenchmarkMatrix = _
+
+  @Setup(Level.Trial)
+  def setup = {
+    Random.setSeed(n)
+
+    val matrixFactory = BenchmarkMatrix.ofType(libType)
+    m1 = matrixFactory(intMatrixElems)
+    m2 = matrixFactory(intMatrixElems)
+  }
+
+  @Benchmark
+  def matrixBenchmark = (m1 + m2) * m1 // O(n^3) loops
+}

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

@@ -0,0 +1,44 @@
+package dotty.tools.benchmarks.inlinetraits
+
+import standard.IntMatrixLib.{Matrix => StdIntMatrix}
+import specialized.IntMatrixLib.{Matrix => SpeIntMatrix}
+import inlinetrait.IntMatrixLib.{Matrix => InlIntMatrix}
+
+trait BenchmarkMatrix:
+  def +(n: BenchmarkMatrix): BenchmarkMatrix
+  def *(n: BenchmarkMatrix): BenchmarkMatrix
+
+object BenchmarkMatrix:
+  def ofType(tpe: String): Seq[Seq[Int]] => BenchmarkMatrix =
+    (elems: Seq[Seq[Int]]) => tpe.toLowerCase() match {
+      case "standard" => StdBenchmarkMatrix(StdIntMatrix(elems*))
+      case "specialized" => SpeBenchmarkMatrix(SpeIntMatrix(elems*))
+      case "inlinetrait" => InlBenchmarkMatrix(InlIntMatrix(elems*))
+    }
+
+private class StdBenchmarkMatrix(val m: StdIntMatrix) extends BenchmarkMatrix:
+  import standard.IntMatrixLib.{+, `*`}
+  override def +(n: BenchmarkMatrix): StdBenchmarkMatrix = n match {
+    case stdN: StdBenchmarkMatrix => StdBenchmarkMatrix(this.m + stdN.m)
+  }
+  override def *(n: BenchmarkMatrix): StdBenchmarkMatrix = n match {
+    case stdN: StdBenchmarkMatrix => StdBenchmarkMatrix(this.m * stdN.m)
+  }
+
+private class SpeBenchmarkMatrix(val m: SpeIntMatrix) extends BenchmarkMatrix:
+  import specialized.IntMatrixLib.{+ => plus, `*` => times}
+  override def +(n: BenchmarkMatrix): SpeBenchmarkMatrix = n match {
+    case speN: SpeBenchmarkMatrix => SpeBenchmarkMatrix(plus(this.m)(speN.m))
+  }
+  override def *(n: BenchmarkMatrix): SpeBenchmarkMatrix = n match {
+    case speN: SpeBenchmarkMatrix => SpeBenchmarkMatrix(times(this.m)(speN.m))
+  }
+
+private class InlBenchmarkMatrix(val m: InlIntMatrix) extends BenchmarkMatrix:
+  import inlinetrait.IntMatrixLib.{+, `*`}
+  override def +(n: BenchmarkMatrix): InlBenchmarkMatrix = n match {
+    case inlN: InlBenchmarkMatrix => InlBenchmarkMatrix(this.m + inlN.m)
+  }
+  override def *(n: BenchmarkMatrix): InlBenchmarkMatrix = n match {
+    case inlN: InlBenchmarkMatrix => InlBenchmarkMatrix(this.m * inlN.m)
+  }

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

@@ -0,0 +1,39 @@
+package dotty.tools.benchmarks.inlinetraits
+
+import org.openjdk.jmh.annotations._
+import java.util.concurrent.TimeUnit.SECONDS
+import scala.util.Random
+
+@Fork(10)
+@Threads(3)
+@Warmup(iterations = 3, time = 5, timeUnit = SECONDS)
+@Measurement(iterations = 5, time = 10, timeUnit = SECONDS)
+@State(Scope.Benchmark)
+class PairsBenchmark {
+  val numPairs: Int = 3_000_000
+
+  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 pairs: List[BenchmarkPair] = _
+
+  @Setup(Level.Trial)
+  def setup = {
+    Random.setSeed(numPairs)
+
+    val pairFactory = (l: List[(First, Second)]) => l.map((_1, _2) => BenchmarkPair.ofType(libType)(_1, _2))
+    pairs = pairFactory(pairElems)
+  }
+
+  @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/PairsOps.scala

@@ -0,0 +1,39 @@
+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" =>
+        val concretePair: SpePair[First, Second] = (_1, _2) match {
+          case (_1: Int, _2: Double) => SpePair(_1, _2)
+          case (_1: Char, _2: Short) => SpePair(_1, _2)
+          case _ => ???
+        }
+        BenchmarkPair(concretePair)
+      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/Matrix.scala

@@ -0,0 +1,47 @@
+package dotty.tools.benchmarks.inlinetraits
+package inlinetrait
+
+import scala.reflect.ClassTag
+
+inline trait MatrixLib[T: ClassTag]:
+  // FIXME make Matrix opaque once inlinedTypeRef works properly
+  /*opaque*/ type Matrix = Array[Array[T]]
+
+  // FIXME uncomment object and remove following code when inner objects work
+  /*
+   *  object Matrix:
+   *    def apply(rows: Seq[T]*): Matrix =
+   *      rows.map(_.toArray).toArray
+   */
+  // ----------------------------------
+  def Matrix(rows: Seq[T]*): Matrix =
+    rows.map(_.toArray).toArray
+  // ----------------------------------
+  // end of code to remove
+
+  extension (m: Matrix)
+    def apply(x: Int)(y: Int): T = m(x)(y)
+    def rows: Int = m.length
+    def cols: Int = m(0).length
+
+object IntMatrixLib extends MatrixLib[Int]:
+  extension (m: Matrix)
+    def +(n: Matrix): Matrix =
+      val sum =
+        for row <- 0 until m.rows
+        yield
+          for col <- 0 until m.cols
+          yield m(row)(col) + n(row)(col)
+      Matrix(sum*)
+    end +
+
+    def *(n: Matrix): Matrix =
+      val prod =
+        for i <- 0 until m.rows
+        yield
+          for j <- 0 until n.cols
+          yield
+            val mults = for k <- 0 until n.rows yield m(i)(k) * n(k)(j)
+            mults.fold(0)(_ + _)
+      Matrix(prod*)
+    end *

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

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

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

@@ -0,0 +1,113 @@
+package dotty.tools.benchmarks.inlinetraits
+package specialized
+
+/*
+ * This implementation relies on the @specialized tag to specialize the MatrixLib.
+ * However, @specialized does nothing in Scala 3. Therefore, an equivalent version is
+ * recreated by hand further down, and the actual Scala 2 code is provided below:
+ *
+ *   import scala.reflect.ClassTag
+ *   import scala.specialized
+ *
+ *   class MatrixLib[@specialized(Int) T: ClassTag] {
+ *     type Matrix = Array[Array[T]]
+ *
+ *     object Matrix {
+ *       def apply(rows: Seq[T]*): Matrix =
+ *         rows.map(_.toArray).toArray
+ *     }
+ *
+ *     def get(m: Matrix)(x: Int)(y: Int): T = m(x)(y)
+ *     def rows(m: Matrix): Int = m.length
+ *     def cols(m: Matrix): Int = m(0).length
+ *   }
+ *
+ *   object IntMatrixLib extends MatrixLib[Int] {
+ *     def +(m: Matrix)(n: Matrix): Matrix = {
+ *       val sum = {
+ *         for (row <- 0 until rows(m))
+ *           yield {
+ *             for (col <- 0 until cols(m))
+ *               yield m(row)(col) + n(row)(col)
+ *           }
+ *       }
+ *       Matrix(sum: _*)
+ *     }
+ *
+ *     def *(m: Matrix)(n: Matrix): Matrix = {
+ *       val prod = {
+ *         for (i <- 0 until rows(m))
+ *           yield {
+ *             for (j <- 0 until cols(n))
+ *               yield {
+ *                 val mults =
+ *                   for (k <- 0 until rows(n)) yield get(m)(i)(k) * get(n)(k)(j)
+ *                 mults.fold(0)(_ + _)
+ *               }
+ *           }
+ *       }
+ *       Matrix(prod: _*)
+ *     }
+ *   }
+ */
+
+import scala.reflect.ClassTag
+import scala.specialized
+
+class MatrixLib {
+  private[specialized] type ObjectMatrix = Array[Array[Object]]
+  private[specialized] type IntMatrix = Array[Array[Int]]
+
+  def get(m: ObjectMatrix)(x: Int)(y: Int): Object = m(x)(y)
+  def rows(m: ObjectMatrix): Int = m.length
+  def cols(m: ObjectMatrix): Int = m(0).length
+  private[specialized] def get$mcI$sp(m: IntMatrix)(x: Int)(y: Int): Int = Int.unbox(get(m.asInstanceOf[ObjectMatrix])(x)(y))
+  private[specialized] def rows$mcI$sp(m: IntMatrix): Int = rows(m.asInstanceOf[ObjectMatrix])
+  private[specialized] def cols$mcI$sp(m: IntMatrix): Int = cols(m.asInstanceOf[ObjectMatrix])
+}
+
+private class MatrixLib$mcI$sp extends MatrixLib {
+  override def get(m: ObjectMatrix)(x: Int)(y: Int): Object = Int.box(get(m.asInstanceOf[IntMatrix])(x)(y))
+  override def rows(m: ObjectMatrix): Int = rows(m.asInstanceOf[IntMatrix])
+  override def cols(m: ObjectMatrix): Int = cols(m.asInstanceOf[IntMatrix])
+  def get(m: IntMatrix)(x: Int)(y: Int): Int = get$mcI$sp(m)(x)(y)
+  def rows(m: IntMatrix): Int = rows$mcI$sp(m)
+  def cols(m: IntMatrix): Int = cols$mcI$sp(m)
+  override private[specialized] def get$mcI$sp(m: IntMatrix)(x: Int)(y: Int): Int = m(x)(y)
+  override private[specialized] def rows$mcI$sp(m: IntMatrix): Int = m.length
+  override private[specialized] def cols$mcI$sp(m: IntMatrix): Int = m(0).length
+}
+
+object IntMatrixLib extends MatrixLib$mcI$sp {
+  type Matrix = IntMatrix
+  object Matrix {
+    def apply(rows: Seq[Int]*): IntMatrix =
+      rows.map(_.toArray).toArray
+  }
+
+  def +(m: Matrix)(n: Matrix): Matrix = {
+    val sum = {
+      for (row <- 0 until rows(m))
+        yield {
+          for (col <- 0 until cols(m))
+            yield m(row)(col) + n(row)(col)
+        }
+    }
+    Matrix(sum: _*)
+  }
+
+  def *(m: Matrix)(n: Matrix): Matrix = {
+    val prod = {
+      for (i <- 0 until rows(m))
+        yield {
+          for (j <- 0 until cols(n))
+            yield {
+              val mults =
+                for (k <- 0 until rows(n)) yield get(m)(i)(k) * get(n)(k)(j)
+              mults.fold(0)(_ + _)
+            }
+        }
+    }
+    Matrix(prod: _*)
+  }
+}

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

@@ -0,0 +1,26 @@
+package dotty.tools.benchmarks.inlinetraits
+package specialized
+
+/*
+ * This implementation relies on the @specialized tag to specialize Pair.
+ * However, @specialized does nothing in Scala 3. Therefore, an equivalent version is
+ * recreated by hand further down, and the actual Scala 2 code is provided below:
+ *
+ *   import scala.specialized
+ *
+ *   class Pair[@specialized(Int, Char) +T1, @specialized(Double, Short) +T2](_1: T1, _2: T2) {}
+ */
+
+class Pair[+T1, +T2] protected (val _1: T1, val _2: T2)
+
+object Pair {
+  def apply(_1: Int, _2: Double): Pair[Int, Double] = new Pair$mcID$sp(_1, _2)
+  def apply(_1: Int, _2: Short): Pair[Int, Short] = new Pair$mcIS$sp(_1, _2)
+  def apply(_1: Char, _2: Double): Pair[Char, Double] = new Pair$mcCD$sp(_1, _2)
+  def apply(_1: Char, _2: Short): Pair[Char, Short] = new Pair$mcCS$sp(_1, _2)
+}
+
+private class Pair$mcID$sp(protected[this] val _1$mcI$sp: Int, protected[this] val _2$mcD$sp: Double) extends Pair[Int, Double](_1$mcI$sp, _2$mcD$sp)
+private class Pair$mcIS$sp(protected[this] val _1$mcI$sp: Int, protected[this] val _2$mcS$sp: Short) extends Pair[Int, Short](_1$mcI$sp, _2$mcS$sp)
+private class Pair$mcCD$sp(protected[this] val _1$mcC$sp: Char, protected[this] val _2$mcD$sp: Double) extends Pair[Char, Double](_1$mcC$sp, _2$mcD$sp)
+private class Pair$mcCS$sp(protected[this] val _1$mcC$sp: Char, protected[this] val _2$mcS$sp: Short) extends Pair[Char, Short](_1$mcC$sp, _2$mcS$sp)