add specialization and loop optis benchmark suites

saddle-jmh/src/main/scala/org/saddle/LoopOptimizations.scala

@@ -0,0 +1,134 @@
+package org.saddle
+
+import org.openjdk.jmh.annotations._
+
+/** Benchmark suite comparing different loop patterns and the impact of loop optimizations.
+  * https://wiki.openjdk.java.net/pages/viewpage.action?pageId=20415918
+  */
+@State(Scope.Benchmark)
+@Warmup(iterations = 10) 
+@Measurement(iterations = 10)
+@Fork(1)
+@Threads(1)
+class LoopOptimisations {
+  @Param(Array("10000"))
+  var size: Int = _
+  var arr: Array[Double] = _
+  var vec1: Vec[Double] = _
+  var b: Double = _
+
+  @Setup(Level.Iteration)
+  def setup() = {
+    arr = vec.rand(size).toArray
+    vec1 = Vec(arr)
+    b = scala.util.Random.nextDouble()
+  }
+
+  @Benchmark
+  /** Simplest variant, should trigger vectorization and other optimisations.
+    */
+  def arrayAdd(): Array[Double] = {
+    var i = 0
+    while (i < arr.length) {
+      arr(i) += b
+      i += 1
+    }
+    arr
+  }
+
+  @Benchmark
+  def arrayAddExpandedAssignmentOperator(): Array[Double] = {
+    var i = 0
+    while (i < arr.length) {
+      // assignement operator seems to perform worse
+      arr(i) = arr(i) + b
+      i += 1
+    }
+    arr
+  }
+
+
+  /** hand-unrolled loops prevent vectorization and potentially other
+    * optimisations
+    */
+  @Benchmark
+  def arrayAddHandUnrolled2(): Array[Double] = {
+    var i = 0
+    val length = arr.length
+    val unrolledStride = 2
+    val preloopIterations = length % unrolledStride
+    while (i < preloopIterations) {
+      arr(i) += b
+      i += 1
+    }
+    while (i < length) {
+      arr(i + 0) += b
+      arr(i + 1) += b
+      i += unrolledStride
+    }
+    arr
+  }
+
+  @Benchmark
+  def arrayAddHandUnrolled5(): Array[Double] = {
+    var i = 0
+    val length = arr.length
+    val unrolledStride = 5
+    val preloopIterations = length % unrolledStride
+    while (i < preloopIterations) {
+      arr(i) += b
+      i += 1
+    }
+    while (i < length) {
+      arr(i + 0) += b
+      arr(i + 1) += b
+      arr(i + 2) += b
+      arr(i + 3) += b
+      arr(i + 4) += b
+      i += unrolledStride
+    }
+    arr
+  }
+
+  @Benchmark
+  def arrayDiv(): Array[Double] = {
+    var i = 0
+    while (i < arr.length) {
+      arr(i) /= b
+      i += 1
+    }
+    arr
+  }
+
+  @Benchmark
+  def arrayDivHandUnrolled2(): Array[Double] = {
+    var i = 0
+    val length = arr.length
+    val unrolledStride = 2
+    val preloopIterations = length % unrolledStride
+    while (i < preloopIterations) {
+      arr(i) /= b
+      i += 1
+    }
+    while (i < length) {
+      arr(i + 0) /= b
+      arr(i + 1) /= b
+      i += unrolledStride
+    }
+    arr
+  }
+
+  @Benchmark
+  def vecBinOps(): Vec[Double] = {
+    import ops.BinOps._
+    vec1 += b
+    vec1
+  }
+
+  @Benchmark
+  def vecBinOpsMacros(): Vec[Double] = {
+    import macros.BinOps._
+    vec1 += b
+    vec1
+  }
+}

saddle-jmh/src/main/scala/org/saddle/Specialization.scala

@@ -0,0 +1,47 @@
+package org.saddle
+
+import org.saddle.scalar.ScalarTag
+import org.saddle.vec.VecDefault
+
+import org.openjdk.jmh.annotations._
+
+class VecBoxed[T: ScalarTag](values: Array[T])
+    extends VecDefault[T](values, implicitly[ScalarTag[T]])
+
+/** Benchmark suite illustrating the performance boost of specialization.
+  */
+@State(Scope.Benchmark)
+@Warmup(iterations = 10)
+@Measurement(iterations = 10)
+@Fork(1)
+@Threads(1)
+class Specialization {
+  @Param(Array("10", "10000"))
+  var size: Int = _
+
+  var v1: Vec[Double] = _
+  var v2: VecBoxed[Double] = _
+  var b: Double = _
+
+  @Setup(Level.Iteration)
+  def setup() = {
+    v1 = vec.rand(size)
+    v2 = new VecBoxed(v1.toArray)
+    b = scala.util.Random.nextDouble()
+  }
+
+  @Benchmark
+  def vecSpecialized(): Vec[Double] = {
+    import org.saddle.ops.BinOps._
+    v1 += b
+    v1
+  }
+
+  @Benchmark
+  def vecBoxed(): Vec[Double] = {
+    import org.saddle.ops.BinOps._
+    v2 += b
+    v2
+  }
+
+}