Add frozen compiler snapshot to bench

The idea is that we have a stable base on which to test performance

Author: odersky

bench/dottyBench/tools/FatalError.scala

@@ -0,0 +1,3 @@
+package dottyBench.tools
+
+case class FatalError(msg: String) extends Exception(msg)

bench/dottyBench/tools/backend/ScalaPrimitivesOps.scala

@@ -0,0 +1,232 @@
+package dottyBench.tools
+package backend
+
+object ScalaPrimitivesOps extends ScalaPrimitivesOps
+
+class ScalaPrimitivesOps {
+  // Arithmetic unary operations
+  final val POS = 1                            // +x
+  final val NEG = 2                            // -x
+  final val NOT = 3                            // ~x
+
+  // Arithmetic binary operations
+  final val ADD = 10                           // x + y
+  final val SUB = 11                           // x - y
+  final val MUL = 12                           // x * y
+  final val DIV = 13                           // x / y
+  final val MOD = 14                           // x % y
+
+  // Bitwise operations
+  final val OR  = 20                           // x | y
+  final val XOR = 21                           // x ^ y
+  final val AND = 22                           // x & y
+
+  // Shift operations
+  final val LSL = 30                           // x << y
+  final val LSR = 31                           // x >>> y
+  final val ASR = 32                           // x >> y
+
+  // Comparison operations
+  final val ID = 40                            // x eq y
+  final val NI = 41                            // x ne y
+  final val EQ = 42                            // x == y
+  final val NE = 43                            // x != y
+  final val LT = 44                            // x < y
+  final val LE = 45                            // x <= y
+  final val GT = 46                            // x > y
+  final val GE = 47                            // x >= y
+
+  // Boolean unary operations
+  final val ZNOT = 50                          // !x
+
+  // Boolean binary operations
+  final val ZOR = 60                           // x || y
+  final val ZAND = 61                          // x && y
+
+  // Array operations
+  final val LENGTH = 70                        // x.length
+  final val APPLY  = 71                        // x(y)
+  final val UPDATE = 72                        // x(y) = z
+
+  // Any operations
+  final val IS = 80                            // x.is[y]
+  final val AS = 81                            // x.as[y]
+  final val HASH = 87                          // x.##
+
+  // AnyRef operations
+  final val SYNCHRONIZED = 90                  // x.synchronized(y)
+
+  // String operations
+  final val CONCAT = 100                       // String.valueOf(x)+String.valueOf(y)
+
+  // coercions
+  final val COERCE = 101
+
+  // RunTime operations
+  final val BOX = 110                          // RunTime.box_<X>(x)
+  final val UNBOX = 111                        // RunTime.unbox_<X>(x)
+  final val NEW_ZARRAY = 112                   // RunTime.zarray(x)
+  final val NEW_BARRAY = 113                   // RunTime.barray(x)
+  final val NEW_SARRAY = 114                   // RunTime.sarray(x)
+  final val NEW_CARRAY = 115                   // RunTime.carray(x)
+  final val NEW_IARRAY = 116                   // RunTime.iarray(x)
+  final val NEW_LARRAY = 117                   // RunTime.larray(x)
+  final val NEW_FARRAY = 118                   // RunTime.farray(x)
+  final val NEW_DARRAY = 119                   // RunTime.darray(x)
+  final val NEW_OARRAY = 120                   // RunTime.oarray(x)
+
+  final val ZARRAY_LENGTH = 131                // RunTime.zarray_length(x)
+  final val BARRAY_LENGTH = 132                // RunTime.barray_length(x)
+  final val SARRAY_LENGTH = 133                // RunTime.sarray_length(x)
+  final val CARRAY_LENGTH = 134                // RunTime.carray_length(x)
+  final val IARRAY_LENGTH = 135                // RunTime.iarray_length(x)
+  final val LARRAY_LENGTH = 136                // RunTime.larray_length(x)
+  final val FARRAY_LENGTH = 137                // RunTime.farray_length(x)
+  final val DARRAY_LENGTH = 138                // RunTime.darray_length(x)
+  final val OARRAY_LENGTH = 139                // RunTime.oarray_length(x)
+
+  final val ZARRAY_GET = 140                   // RunTime.zarray_get(x,y)
+  final val BARRAY_GET = 141                   // RunTime.barray_get(x,y)
+  final val SARRAY_GET = 142                   // RunTime.sarray_get(x,y)
+  final val CARRAY_GET = 143                   // RunTime.carray_get(x,y)
+  final val IARRAY_GET = 144                   // RunTime.iarray_get(x,y)
+  final val LARRAY_GET = 145                   // RunTime.larray_get(x,y)
+  final val FARRAY_GET = 146                   // RunTime.farray_get(x,y)
+  final val DARRAY_GET = 147                   // RunTime.darray_get(x,y)
+  final val OARRAY_GET = 148                   // RunTime.oarray_get(x,y)
+
+  final val ZARRAY_SET = 150                   // RunTime.zarray(x,y,z)
+  final val BARRAY_SET = 151                   // RunTime.barray(x,y,z)
+  final val SARRAY_SET = 152                   // RunTime.sarray(x,y,z)
+  final val CARRAY_SET = 153                   // RunTime.carray(x,y,z)
+  final val IARRAY_SET = 154                   // RunTime.iarray(x,y,z)
+  final val LARRAY_SET = 155                   // RunTime.larray(x,y,z)
+  final val FARRAY_SET = 156                   // RunTime.farray(x,y,z)
+  final val DARRAY_SET = 157                   // RunTime.darray(x,y,z)
+  final val OARRAY_SET = 158                   // RunTime.oarray(x,y,z)
+
+  final val B2B = 200                          // RunTime.b2b(x)
+  final val B2S = 201                          // RunTime.b2s(x)
+  final val B2C = 202                          // RunTime.b2c(x)
+  final val B2I = 203                          // RunTime.b2i(x)
+  final val B2L = 204                          // RunTime.b2l(x)
+  final val B2F = 205                          // RunTime.b2f(x)
+  final val B2D = 206                          // RunTime.b2d(x)
+
+  final val S2B = 210                          // RunTime.s2b(x)
+  final val S2S = 211                          // RunTime.s2s(x)
+  final val S2C = 212                          // RunTime.s2c(x)
+  final val S2I = 213                          // RunTime.s2i(x)
+  final val S2L = 214                          // RunTime.s2l(x)
+  final val S2F = 215                          // RunTime.s2f(x)
+  final val S2D = 216                          // RunTime.s2d(x)
+
+  final val C2B = 220                          // RunTime.c2b(x)
+  final val C2S = 221                          // RunTime.c2s(x)
+  final val C2C = 222                          // RunTime.c2c(x)
+  final val C2I = 223                          // RunTime.c2i(x)
+  final val C2L = 224                          // RunTime.c2l(x)
+  final val C2F = 225                          // RunTime.c2f(x)
+  final val C2D = 226                          // RunTime.c2d(x)
+
+  final val I2B = 230                          // RunTime.i2b(x)
+  final val I2S = 231                          // RunTime.i2s(x)
+  final val I2C = 232                          // RunTime.i2c(x)
+  final val I2I = 233                          // RunTime.i2i(x)
+  final val I2L = 234                          // RunTime.i2l(x)
+  final val I2F = 235                          // RunTime.i2f(x)
+  final val I2D = 236                          // RunTime.i2d(x)
+
+  final val L2B = 240                          // RunTime.l2b(x)
+  final val L2S = 241                          // RunTime.l2s(x)
+  final val L2C = 242                          // RunTime.l2c(x)
+  final val L2I = 243                          // RunTime.l2i(x)
+  final val L2L = 244                          // RunTime.l2l(x)
+  final val L2F = 245                          // RunTime.l2f(x)
+  final val L2D = 246                          // RunTime.l2d(x)
+
+  final val F2B = 250                          // RunTime.f2b(x)
+  final val F2S = 251                          // RunTime.f2s(x)
+  final val F2C = 252                          // RunTime.f2c(x)
+  final val F2I = 253                          // RunTime.f2i(x)
+  final val F2L = 254                          // RunTime.f2l(x)
+  final val F2F = 255                          // RunTime.f2f(x)
+  final val F2D = 256                          // RunTime.f2d(x)
+
+  final val D2B = 260                          // RunTime.d2b(x)
+  final val D2S = 261                          // RunTime.d2s(x)
+  final val D2C = 262                          // RunTime.d2c(x)
+  final val D2I = 263                          // RunTime.d2i(x)
+  final val D2L = 264                          // RunTime.d2l(x)
+  final val D2F = 265                          // RunTime.d2f(x)
+  final val D2D = 266                          // RunTime.d2d(x)
+
+  /** Check whether the given operation code is an array operation. */
+  def isArrayOp(code: Int): Boolean =
+    isArrayNew(code) | isArrayLength(code) | isArrayGet(code) | isArraySet(code)
+
+  def isArrayNew(code: Int): Boolean = code match {
+    case NEW_ZARRAY | NEW_BARRAY | NEW_SARRAY | NEW_CARRAY |
+         NEW_IARRAY | NEW_LARRAY | NEW_FARRAY | NEW_DARRAY |
+         NEW_OARRAY => true
+    case _ => false
+  }
+
+  def isArrayLength(code: Int): Boolean = code match {
+    case ZARRAY_LENGTH | BARRAY_LENGTH | SARRAY_LENGTH | CARRAY_LENGTH |
+         IARRAY_LENGTH | LARRAY_LENGTH | FARRAY_LENGTH | DARRAY_LENGTH |
+         OARRAY_LENGTH | LENGTH => true
+    case _ => false
+  }
+
+  def isArrayGet(code: Int): Boolean = code match {
+    case ZARRAY_GET | BARRAY_GET | SARRAY_GET | CARRAY_GET |
+         IARRAY_GET | LARRAY_GET | FARRAY_GET | DARRAY_GET |
+         OARRAY_GET | APPLY => true
+    case _ => false
+  }
+
+  def isArraySet(code: Int): Boolean = code match {
+    case ZARRAY_SET | BARRAY_SET | SARRAY_SET | CARRAY_SET |
+         IARRAY_SET | LARRAY_SET | FARRAY_SET | DARRAY_SET |
+         OARRAY_SET | UPDATE => true
+    case _ => false
+  }
+
+  /** Check whether the given code is a comparison operator */
+  def isComparisonOp(code: Int): Boolean = code match {
+    case ID | NI | EQ | NE |
+         LT | LE | GT | GE => true
+
+    case _ => false
+  }
+  def isUniversalEqualityOp(code: Int): Boolean = (code == EQ) || (code == NE)
+  def isReferenceEqualityOp(code: Int): Boolean = (code == ID) || (code == NI)
+
+  def isArithmeticOp(code: Int): Boolean = code match {
+    case POS | NEG | NOT => true; // unary
+    case ADD | SUB | MUL |
+         DIV | MOD       => true; // binary
+    case OR  | XOR | AND |
+         LSL | LSR | ASR => true; // bitwise
+    case _ => false
+  }
+
+  def isLogicalOp(code: Int): Boolean = code match {
+    case ZNOT | ZAND | ZOR => true
+    case _ => false
+  }
+
+  def isShiftOp(code: Int): Boolean = code match {
+    case LSL | LSR | ASR => true
+    case _ => false
+  }
+
+  def isBitwiseOp(code: Int): Boolean = code match {
+    case OR | XOR | AND => true
+    case _ => false
+  }
+
+  def isCoercion(code: Int): Boolean = (code >= B2B) && (code <= D2D)
+
+}

bench/dottyBench/tools/backend/WorklistAlgorithm.scala

@@ -0,0 +1,59 @@
+package dottyBench.tools
+package backend
+
+import scala.collection.mutable
+
+/**
+ * Simple implementation of a worklist algorithm. A processing
+ * function is applied repeatedly to the first element in the
+ * worklist, as long as the stack is not empty.
+ *
+ * The client class should mix-in this class and initialize the worklist
+ * field and define the `processElement` method. Then call the `run` method
+ * providing a function that initializes the worklist.
+ *
+ * @author  Martin Odersky
+ * @version 1.0
+ * @see     [[scala.tools.nsc.backend.icode.Linearizers]]
+ */
+trait WorklistAlgorithm {
+  type Elem
+  class WList {
+    private var list: List[Elem] = Nil
+    def isEmpty = list.isEmpty
+    def nonEmpty = !isEmpty
+    def push(e: Elem): Unit = { list = e :: list }
+    def pop(): Elem = {
+      val head = list.head
+      list = list.tail
+      head
+    }
+    def pushAll(xs: Iterable[Elem]): Unit = xs.foreach(push)
+    def clear(): Unit = list = Nil
+
+  }
+
+  val worklist: WList
+
+  /**
+   * Run the iterative algorithm until the worklist remains empty.
+   * The initializer is run once before the loop starts and should
+   * initialize the worklist.
+   */
+  def run(initWorklist: => Unit) = {
+    initWorklist
+
+    while (worklist.nonEmpty)
+      processElement(dequeue)
+  }
+
+  /**
+   * Process the current element from the worklist.
+   */
+  def processElement(e: Elem): Unit
+
+  /**
+   * Remove and return the first element to be processed from the worklist.
+   */
+  def dequeue: Elem
+}

bench/dottyBench/tools/backend/jvm/AsmUtils.scala

@@ -0,0 +1,63 @@
+package dottyBench.tools
+package backend
+package jvm
+
+import scala.tools.asm.tree.{AbstractInsnNode}
+import java.io.PrintWriter
+import scala.tools.asm.util.{TraceClassVisitor, TraceMethodVisitor, Textifier}
+import scala.tools.asm.ClassReader
+
+object AsmUtils {
+
+  /**
+   * Print the bytecode of methods generated by GenBCode to the standard output. Only methods
+   * whose name contains `traceMethodPattern` are traced.
+   */
+  final val traceMethodEnabled = sys.env.contains("printBCODE")
+  final val traceMethodPattern = sys.env.getOrElse("printBCODE", "")
+
+  /**
+   * Print the bytecode of classes generated by GenBCode to the standard output.
+   */
+  final val traceClassEnabled = false
+  final val traceClassPattern = ""
+
+  /**
+   * Print the bytedcode of classes as they are serialized by the ASM library. The serialization
+   * performed by `asm.ClassWriter` can change the code generated by GenBCode. For example, it
+   * introduces stack map frames, it computes the maximal stack sizes, and it replaces dead
+   * code by NOPs (see also https://github.com/scala/scala/pull/3726#issuecomment-42861780).
+   */
+  final val traceSerializedClassEnabled = false
+  final val traceSerializedClassPattern = ""
+
+  def traceMethod(mnode: MethodNode1): Unit = {
+    println(s"Bytecode for method ${mnode.name}")
+    val p = new Textifier
+    val tracer = new TraceMethodVisitor(p)
+    mnode.accept(tracer)
+    val w = new PrintWriter(System.out)
+    p.print(w)
+    w.flush()
+  }
+
+  def traceClass(cnode: ClassNode1): Unit = {
+    println(s"Bytecode for class ${cnode.name}")
+    val w = new PrintWriter(System.out)
+    cnode.accept(new TraceClassVisitor(w))
+    w.flush()
+  }
+
+  def traceClass(bytes: Array[Byte]): Unit = traceClass(readClass(bytes))
+
+  def readClass(bytes: Array[Byte]): ClassNode1 = {
+    val node = new ClassNode1()
+    new ClassReader(bytes).accept(node, 0)
+    node
+  }
+
+  def instructionString(instruction: AbstractInsnNode): String = instruction.getOpcode match {
+    case -1 => instruction.toString
+    case op => scala.tools.asm.util.Printer.OPCODES(op)
+  }
+}