.

benchmark/src/incrementsInt.scala

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2020, 2021, Ludovic Henry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Please contact git@ludovic.dev or visit ludovic.dev if you need additional
+ * information or have any questions.
+ */
+
+package vecxt.benchmark
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+// import vecxt.Matrix.*
+import vecxt.BoundsCheck
+import scala.compiletime.uninitialized
+import vecxt.all.*
+import jdk.incubator.vector.VectorSpecies
+import jdk.incubator.vector.VectorOperators
+
+@State(Scope.Thread)
+class IncrementIntBenchmark extends BLASBenchmark:
+
+  @Param(Array("3", "100", "100000"))
+  var len: String = uninitialized;
+
+  var arr: Array[Int] = uninitialized
+
+  // format: off
+  @Setup(Level.Trial)
+  def setup: Unit =
+    arr = randomIntArray(len.toInt);
+    ()
+  end setup
+
+  extension (vec: Array[Int])
+    inline def increments_loop: Array[Int] =
+      val out = new Array[Int](vec.length)
+      out(0) = vec(0)
+      var i = 1
+      while i < vec.length do
+        out(i) = vec(i) - vec(i - 1)
+        i = i + 1
+      end while
+      out
+    end increments_loop
+
+  end extension
+
+  @Benchmark
+  def increment_normal(bh: Blackhole) =
+    val r = arr.increments_loop
+    bh.consume(r);
+  end increment_normal
+
+  @Benchmark
+  def increment_vec(bh: Blackhole) =
+    val r = arr.increments
+    bh.consume(r);
+  end increment_vec
+end IncrementIntBenchmark
+

jsSite/src/BenchmarkPlots.scala

@@ -148,6 +148,24 @@ object BenchmarkPlots:
     write(thePlot)
   end incrementsBenchmark
 
+  def incrementsIntBenchmark =
+    val thePlot = BenchmarkPlotElements.schema ++
+      BenchmarkPlotElements.data("../../benchmarks/benchmark_history.json") ++
+      (transform =
+        BenchmarkPlotElements.transform(
+          List("IncrementIntBenchmark.increment_normal", "IncrementIntBenchmark.increment_vec")
+        )
+      ) ++
+      (vconcat =
+        List(
+          BenchmarkPlotElements.layer(3, "len"),
+          BenchmarkPlotElements.layer(100, "len"),
+          BenchmarkPlotElements.layer(100000, "len")
+        )
+      )
+    write(thePlot)
+  end incrementsIntBenchmark
+
   def matMulBenchmark =
     val thePlot = BenchmarkPlotElements.schema ++
       BenchmarkPlotElements.data("../../benchmarks/benchmark_history.json") ++
@@ -194,7 +212,7 @@ object BenchmarkPlots:
       )
 
     write(thePlot)
-  end sumBenchmark
+  end sumIntBenchmark
 
   def sumBenchmarkOverTime: String =
     val thePlot = BenchmarkPlotElements.schema ++

justfile

@@ -7,7 +7,7 @@ benchmark:
   mill benchmark.runJmh -jvmArgs --add-modules=jdk.incubator.vector -rf json
 
 benchmarkOnly:
-  mill benchmark.runJmh -jvmArgs --add-modules=jdk.incubator.vector -rf json vecxt.benchmark.SumIntBenchmark
+  mill benchmark.runJmh -jvmArgs --add-modules=jdk.incubator.vector -rf json vecxt.benchmark.IncrementIntBenchmark
 
 
 setJvm:

vecxt/jvm/src/arrays.scala

@@ -208,9 +208,7 @@ object arrays:
 
       var i = 1
       while i < spi.loopBound(vec.length - 2) do
-        val v1 = IntVector.fromArray(spi, vec, i - 1)
-        val v2 = IntVector.fromArray(spi, vec, i)
-        v2.sub(v1).intoArray(out, i)
+        IntVector.fromArray(spi, vec, i).sub(IntVector.fromArray(spi, vec, i - 1)).intoArray(out, i)
         i += spil
       end while
 
@@ -379,9 +377,10 @@ object arrays:
 
       var i = 1
       while i < spd.loopBound(vec.length - 2) do
-        val v1 = DoubleVector.fromArray(spd, vec, i - 1)
-        val v2 = DoubleVector.fromArray(spd, vec, i)
-        v2.sub(v1).intoArray(out, i)
+        DoubleVector
+          .fromArray(spd, vec, i)
+          .sub(DoubleVector.fromArray(spd, vec, i - 1))
+          .intoArray(out, i)
         i += spdl
       end while