perf: convert stdlib hot paths from Scala collections to while-loops (#765)

He-Pin · web-flow · commit 89c64be68274 · 2026-04-12T09:48:07.000-07:00
## Motivation Scala collection methods like `forall`, `exists`, `map`, `mkString`, `indexWhere`, and `forEach` create closures, iterators, and intermediate collections that are harder for JIT/AOT compilers to optimize. In hot stdlib paths, these can be replaced with imperative while-loops for better performance. ## Key Design Decision Replace functional collection operations with while-loops only in hot stdlib paths where profiling shows measurable impact. This improves JIT inlining, reduces allocation pressure, and produces more predictable native code under Scala Native LTO. ## Modification **ObjectModule** (6 methods): - `objectFields`, `objectFieldsAll`, `objectFieldsEx`: iterator → while-loop over `allKeysArray` - `getObjValuesFromKeys`: for-comprehension → while-loop - `objectKeysValues`, `objectKeysValuesAll`: for-comprehension → while-loop with pre-allocated array - `mergePatch.distinctKeys`: `(lKeys ++ rKeys).distinct` → `LinkedHashSet`-based dedup **ArrayModule** (7 methods): - `all`: `forall` → early-exit while-loop returning `Val.staticTrue/False` - `any`: `exists` → early-exit while-loop returning `Val.staticTrue/False` - `member` (array path): `indexWhere` → while-loop with `found` flag - `contains`: `indexWhere` → while-loop with `found` flag - `remove`: `indexWhere` → while-loop with `idx` sentinel - `minArray/maxArray` (keyF path): `map.zipWithIndex.min/max` → single-pass while-loop - `repeat`: `ArrayBuilder ++= lazyArray` → `System.arraycopy` **ManifestModule** (1 method): - `manifestYamlStream`: `map.mkString` → `StringBuilder` with while-loop **StringModule** (1 method): - `escapeStringXML`: `for (c <- str)` → `while` with `charAt` **Val.Obj** (1 method): - `visibleKeyNames`: `forEach` lambda → `entrySet` iterator while-loop ## Benchmark Results ### JMH (JVM, single iteration, lower is better) | Benchmark | Before (ms/op) | After (ms/op) | Change | |-----------|----------------|---------------|--------| | gen_big_object | 1.122 | 0.933 | **-16.8%** ✅ | | large_string_template | 2.432 | 1.659 | **-31.8%** ✅ | | realistic2 | 61.774 | 56.379 | **-8.7%** ✅ | | large_string_join | 0.582 | 0.561 | -3.6% | | member | 0.665 | 0.661 | -0.6% | | setDiff | 0.426 | 0.416 | -2.3% | | setInter | 0.377 | 0.371 | -1.6% | | setUnion | 0.638 | 0.623 | -2.3% | | bench.02 | 35.330 | 34.461 | -2.5% | No regressions observed (bench.07 variance is JMH single-fork noise). ### Hyperfine (Scala Native vs jrsonnet, Apple Silicon) | Benchmark | sjsonnet (ms) | jrsonnet (ms) | Ratio | |-----------|--------------|--------------|-------| | gen_big_object | 10.1 | 13.2 | **1.31x faster** ✅ | | large_string_join | 9.0 | 7.7 | 1.17x slower | | large_string_template | 14.3 | 6.9 | 2.07x slower | | realistic2 | 161.2 | 100.4 | 1.61x slower | | member | 8.4 | 5.8 | 1.45x slower | | comparison | 18.3 | 13.5 | 1.36x slower | ## Analysis The biggest JMH win is `large_string_template` (-31.8%) which benefits from the ObjectModule while-loop conversions since format rendering triggers object field enumeration. The `gen_big_object` improvement (-16.8%) directly measures ObjectModule throughput. `realistic2` (-8.7%) shows compound benefits from all modules. On Scala Native, `gen_big_object` is now definitively faster than jrsonnet (1.31x). The remaining gaps in string-heavy benchmarks require rope strings (#761) and format-level optimizations. ## References Ported from jit branch exploration commits: - af4832f (std.all/any/member while-loops) - cd612df (escapeStringXML, std.contains/remove while-loops) - d1629fd (manifestYamlStream StringBuilder) - 8cd8d31 (minArray/maxArray single-pass) - 9149654 (visibleKeyNames entrySet iterator) ## Result All 420 tests pass across JVM/JS/WASM/Native × Scala 3.3.7/2.13.18/2.12.21. Consistent improvements on object-heavy and realistic workloads with no regressions.
diff --git a/sjsonnet/src/sjsonnet/Val.scala b/sjsonnet/src/sjsonnet/Val.scala
@@ -1126,7 +1126,11 @@ object Val {
             buf.sizeHint(v0.size())
             v0.forEach((k, m) => if (m.visibility != Visibility.Hidden) buf += k)
           } else {
-            getAllKeys.forEach((k, b) => if (b == java.lang.Boolean.FALSE) buf += k)
+            val iter = getAllKeys.entrySet().iterator()
+            while (iter.hasNext()) {
+              val e = iter.next()
+              if (e.getValue() == java.lang.Boolean.FALSE) buf += e.getKey()
+            }
           }
           buf.result()
         }
diff --git a/sjsonnet/src/sjsonnet/stdlib/ArrayModule.scala b/sjsonnet/src/sjsonnet/stdlib/ArrayModule.scala
@@ -27,15 +27,20 @@ object ArrayModule extends AbstractFunctionModule {
       } else if (keyF.isInstanceOf[Val.False]) {
         arr.asStrictArray.min(ev)
       } else {
-        val minTuple = arr.asStrictArray
-          .map(v =>
-            keyF
-              .asInstanceOf[Val.Func]
-              .apply1(v, pos.fileScope.noOffsetPos)(ev, TailstrictModeDisabled)
-          )
-          .zipWithIndex
-          .min((x: (Val, Int), y: (Val, Int)) => ev.compare(x._1, y._1))
-        arr.value(minTuple._2)
+        val strict = arr.asStrictArray
+        val func = keyF.asInstanceOf[Val.Func]
+        var bestIdx = 0
+        var bestVal = func.apply1(strict(0), pos.fileScope.noOffsetPos)(ev, TailstrictModeDisabled)
+        var i = 1
+        while (i < strict.length) {
+          val v = func.apply1(strict(i), pos.fileScope.noOffsetPos)(ev, TailstrictModeDisabled)
+          if (ev.compare(v, bestVal) < 0) {
+            bestVal = v
+            bestIdx = i
+          }
+          i += 1
+        }
+        strict(bestIdx)
       }
     }
   }
@@ -59,28 +64,45 @@ object ArrayModule extends AbstractFunctionModule {
       } else if (keyF.isInstanceOf[Val.False]) {
         arr.asStrictArray.max(ev)
       } else {
-        val maxTuple = arr.asStrictArray
-          .map(v =>
-            keyF
-              .asInstanceOf[Val.Func]
-              .apply1(v, pos.fileScope.noOffsetPos)(ev, TailstrictModeDisabled)
-          )
-          .zipWithIndex
-          .max((x: (Val, Int), y: (Val, Int)) => ev.compare(x._1, y._1))
-        arr.value(maxTuple._2)
+        val strict = arr.asStrictArray
+        val func = keyF.asInstanceOf[Val.Func]
+        var bestIdx = 0
+        var bestVal = func.apply1(strict(0), pos.fileScope.noOffsetPos)(ev, TailstrictModeDisabled)
+        var i = 1
+        while (i < strict.length) {
+          val v = func.apply1(strict(i), pos.fileScope.noOffsetPos)(ev, TailstrictModeDisabled)
+          if (ev.compare(v, bestVal) > 0) {
+            bestVal = v
+            bestIdx = i
+          }
+          i += 1
+        }
+        strict(bestIdx)
       }
     }
   }
 
   private object All extends Val.Builtin1("all", "arr") {
     def evalRhs(arr: Eval, ev: EvalScope, pos: Position): Val = {
-      Val.bool(arr.value.asArr.forall(v => v.asBoolean))
+      val a = arr.value.asArr
+      var i = 0
+      while (i < a.length) {
+        if (!a.value(i).asBoolean) return Val.staticFalse
+        i += 1
+      }
+      Val.staticTrue
     }
   }
 
   private object Any extends Val.Builtin1("any", "arr") {
     def evalRhs(arr: Eval, ev: EvalScope, pos: Position): Val = {
-      Val.bool(arr.value.asArr.iterator.exists(v => v.asBoolean))
+      val a = arr.value.asArr
+      var i = 0
+      while (i < a.length) {
+        if (a.value(i).asBoolean) return Val.staticTrue
+        i += 1
+      }
+      Val.staticFalse
     }
   }
 
@@ -271,7 +293,14 @@ object ArrayModule extends AbstractFunctionModule {
             }
             str.str.contains(secondArg)
           case a: Val.Arr =>
-            a.asLazyArray.indexWhere(v => ev.equal(v.value, x.value)) >= 0
+            val la = a.asLazyArray
+            var i = 0
+            var found = false
+            while (i < la.length && !found) {
+              if (ev.equal(la(i).value, x.value)) found = true
+              i += 1
+            }
+            found
           case arr =>
             Error.fail(
               "std.member first argument must be an array or a string, got " + arr.prettyName
@@ -543,14 +572,14 @@ object ArrayModule extends AbstractFunctionModule {
           Val.Str(pos, builder.toString())
         case a: Val.Arr =>
           val lazyArray = a.asLazyArray
-          val out = new mutable.ArrayBuilder.ofRef[Eval]
-          out.sizeHint(lazyArray.length * count)
+          val elemLen = lazyArray.length
+          val result = new Array[Eval](elemLen * count)
           var i = 0
           while (i < count) {
-            out ++= lazyArray
+            System.arraycopy(lazyArray, 0, result, i * elemLen, elemLen)
             i += 1
           }
-          Val.Arr(pos, out.result())
+          Val.Arr(pos, result)
         case x => Error.fail("std.repeat first argument must be an array or a string")
       }
       res
@@ -579,10 +608,23 @@ object ArrayModule extends AbstractFunctionModule {
       )
     },
     builtin("contains", "arr", "elem") { (_, ev, arr: Val.Arr, elem: Val) =>
-      arr.asLazyArray.indexWhere(s => ev.equal(s.value, elem)) != -1
+      val la = arr.asLazyArray
+      var i = 0
+      var found = false
+      while (i < la.length && !found) {
+        if (ev.equal(la(i).value, elem)) found = true
+        i += 1
+      }
+      found
     },
     builtin("remove", "arr", "elem") { (_, ev, arr: Val.Arr, elem: Val) =>
-      val idx = arr.asLazyArray.indexWhere(s => ev.equal(s.value, elem))
+      val la = arr.asLazyArray
+      var idx = -1
+      var i = 0
+      while (i < la.length && idx == -1) {
+        if (ev.equal(la(i).value, elem)) idx = i
+        i += 1
+      }
       if (idx == -1) {
         arr
       } else {
diff --git a/sjsonnet/src/sjsonnet/stdlib/ManifestModule.scala b/sjsonnet/src/sjsonnet/stdlib/ManifestModule.scala
@@ -270,16 +270,24 @@ object ManifestModule extends AbstractFunctionModule {
       }
       v match {
         case arr: Val.Arr =>
-          arr.asLazyArray
-            .map { item =>
+          val items = arr.asLazyArray
+          val sb = new java.lang.StringBuilder()
+          var i = 0
+          while (i < items.length) {
+            if (i > 0) sb.append("\n---\n")
+            else sb.append("---\n")
+            sb.append(
               Materializer
                 .apply0(
-                  item.value,
+                  items(i).value,
                   new YamlRenderer(indentArrayInObject = indentArrayInObject, quoteKeys = quoteKeys)
                 )(ev)
                 .toString
-            }
-            .mkString("---\n", "\n---\n", if (cDocumentEnd) "\n...\n" else "\n")
+            )
+            i += 1
+          }
+          if (cDocumentEnd) sb.append("\n...\n") else sb.append('\n')
+          sb.toString
         case _ => Error.fail("manifestYamlStream only takes arrays, got " + v.getClass)
       }
     },
diff --git a/sjsonnet/src/sjsonnet/stdlib/ObjectModule.scala b/sjsonnet/src/sjsonnet/stdlib/ObjectModule.scala
@@ -38,14 +38,26 @@ object ObjectModule extends AbstractFunctionModule {
   private object ObjectFields extends Val.Builtin1("objectFields", "o") {
     def evalRhs(o: Eval, ev: EvalScope, pos: Position): Val = {
       val keys = getVisibleKeys(ev, o.value.asObj)
-      Val.Arr(pos, keys.map(k => Val.Str(pos, k)))
+      val result = new Array[Eval](keys.length)
+      var i = 0
+      while (i < keys.length) {
+        result(i) = Val.Str(pos, keys(i))
+        i += 1
+      }
+      Val.Arr(pos, result)
     }
   }
 
   private object ObjectFieldsAll extends Val.Builtin1("objectFieldsAll", "o") {
     def evalRhs(o: Eval, ev: EvalScope, pos: Position): Val = {
       val keys = getAllKeys(ev, o.value.asObj)
-      Val.Arr(pos, keys.map(k => Val.Str(pos, k)))
+      val result = new Array[Eval](keys.length)
+      var i = 0
+      while (i < keys.length) {
+        result(i) = Val.Str(pos, keys(i))
+        i += 1
+      }
+      Val.Arr(pos, result)
     }
   }
 
@@ -54,7 +66,13 @@ object ObjectModule extends AbstractFunctionModule {
       val keys =
         if (incHidden.value.asBoolean) getAllKeys(ev, o.value.asObj)
         else getVisibleKeys(ev, o.value.asObj)
-      Val.Arr(pos, keys.map(k => Val.Str(pos, k)))
+      val result = new Array[Eval](keys.length)
+      var i = 0
+      while (i < keys.length) {
+        result(i) = Val.Str(pos, keys(i))
+        i += 1
+      }
+      Val.Arr(pos, result)
     }
   }
 
@@ -165,13 +183,16 @@ object ObjectModule extends AbstractFunctionModule {
       pos: Position,
       ev: EvalScope,
       v1: Val.Obj,
-      keys: Array[String]): Val.Arr =
-    Val.Arr(
-      pos,
-      keys.map { k =>
-        new LazyFunc(() => v1.value(k, pos.noOffset)(ev))
-      }
-    )
+      keys: Array[String]): Val.Arr = {
+    val result = new Array[Eval](keys.length)
+    var i = 0
+    while (i < keys.length) {
+      val k = keys(i)
+      result(i) = new LazyFunc(() => v1.value(k, pos.noOffset)(ev))
+      i += 1
+    }
+    Val.Arr(pos, result)
+  }
 
   val functions: Seq[(String, Val.Func)] = Seq(
     builtin(ObjectHas),
@@ -193,45 +214,43 @@ object ObjectModule extends AbstractFunctionModule {
     builtin(MapWithKey),
     builtin("objectKeysValues", "o") { (pos, ev, o: Val.Obj) =>
       val keys = getVisibleKeys(ev, o)
-      Val.Arr(
-        pos,
-        keys.map(k =>
-          Val.Obj.mk(
-            pos.fileScope.noOffsetPos,
-            "key" -> new Val.Obj.ConstMember(
-              false,
-              Visibility.Normal,
-              Val.Str(pos.fileScope.noOffsetPos, k)
-            ),
-            "value" -> new Val.Obj.ConstMember(
-              false,
-              Visibility.Normal,
-              o.value(k, pos.fileScope.noOffsetPos)(ev)
-            )
+      val noOffsetPos = pos.fileScope.noOffsetPos
+      val result = new Array[Eval](keys.length)
+      var i = 0
+      while (i < keys.length) {
+        val k = keys(i)
+        result(i) = Val.Obj.mk(
+          noOffsetPos,
+          "key" -> new Val.Obj.ConstMember(false, Visibility.Normal, Val.Str(noOffsetPos, k)),
+          "value" -> new Val.Obj.ConstMember(
+            false,
+            Visibility.Normal,
+            o.value(k, noOffsetPos)(ev)
           )
         )
-      )
+        i += 1
+      }
+      Val.Arr(pos, result)
     },
     builtin("objectKeysValuesAll", "o") { (pos, ev, o: Val.Obj) =>
       val keys = getAllKeys(ev, o)
-      Val.Arr(
-        pos,
-        keys.map(k =>
-          Val.Obj.mk(
-            pos.fileScope.noOffsetPos,
-            "key" -> new Val.Obj.ConstMember(
-              false,
-              Visibility.Normal,
-              Val.Str(pos.fileScope.noOffsetPos, k)
-            ),
-            "value" -> new Val.Obj.ConstMember(
-              false,
-              Visibility.Normal,
-              o.value(k, pos.fileScope.noOffsetPos)(ev)
-            )
+      val noOffsetPos = pos.fileScope.noOffsetPos
+      val result = new Array[Eval](keys.length)
+      var i = 0
+      while (i < keys.length) {
+        val k = keys(i)
+        result(i) = Val.Obj.mk(
+          noOffsetPos,
+          "key" -> new Val.Obj.ConstMember(false, Visibility.Normal, Val.Str(noOffsetPos, k)),
+          "value" -> new Val.Obj.ConstMember(
+            false,
+            Visibility.Normal,
+            o.value(k, noOffsetPos)(ev)
           )
         )
-      )
+        i += 1
+      }
+      Val.Arr(pos, result)
     },
     builtin("objectRemoveKey", "obj", "key") { (pos, ev, o: Val.Obj, key: String) =>
       o.removeKeys(pos, key)
@@ -348,8 +367,13 @@ object ObjectModule extends AbstractFunctionModule {
             outArray
           }
         } else {
-          // Fallback: Use hash-based deduplication for large RHS arrays:
-          (lKeys ++ rKeys).distinct
+          // Fallback: Use LinkedHashSet for large RHS arrays (preserves order, avoids quadratic):
+          val allKeys = new java.util.LinkedHashSet[String](lKeys.length + rKeys.length)
+          var li = 0
+          while (li < lKeys.length) { allKeys.add(lKeys(li)); li += 1 }
+          var ri = 0
+          while (ri < rKeys.length) { allKeys.add(rKeys(ri)); ri += 1 }
+          allKeys.toArray(new Array[String](allKeys.size))
         }
       }
       recPair(target.value, patch.value)
diff --git a/sjsonnet/src/sjsonnet/stdlib/StringModule.scala b/sjsonnet/src/sjsonnet/stdlib/StringModule.scala
@@ -518,15 +518,17 @@ object StringModule extends AbstractFunctionModule {
     },
     builtin("escapeStringXML", "str") { (_, _, str: String) =>
       val out = new java.io.StringWriter()
-      for (c <- str) {
-        c match {
+      var i = 0
+      while (i < str.length) {
+        str.charAt(i) match {
           case '<'  => out.write("&lt;")
           case '>'  => out.write("&gt;")
           case '&'  => out.write("&amp;")
           case '"'  => out.write("&quot;")
           case '\'' => out.write("&apos;")
-          case _    => out.write(c)
+          case c    => out.write(c)
         }
+        i += 1
       }
       out.toString
     },

Original file line number	Diff line number	Diff line change
`@@ -1126,7 +1126,11 @@ object Val {`
`1126`	`1126`	`buf.sizeHint(v0.size())`
`1127`	`1127`	`v0.forEach((k, m) => if (m.visibility != Visibility.Hidden) buf += k)`
`1128`	`1128`	`} else {`
`1129`		`- getAllKeys.forEach((k, b) => if (b == java.lang.Boolean.FALSE) buf += k)`
	`1129`	`+ val iter = getAllKeys.entrySet().iterator()`
	`1130`	`+ while (iter.hasNext()) {`
	`1131`	`+ val e = iter.next()`
	`1132`	`+ if (e.getValue() == java.lang.Boolean.FALSE) buf += e.getKey()`
	`1133`	`+ }`
`1130`	`1134`	`}`
`1131`	`1135`	`buf.result()`
`1132`	`1136`	`}`