simplify operation-merging passes into one, log compile time on jvm

Author: rhysdh540

src/commonMain/kotlin/dev/rdh/bf/opt/OpMerger.kt

@@ -0,0 +1,64 @@
+package dev.rdh.bf.opt
+
+import dev.rdh.bf.BFOperation
+import dev.rdh.bf.Copy
+import dev.rdh.bf.PointerMove
+import dev.rdh.bf.SetToConstant
+import dev.rdh.bf.ValueChange
+
+/**
+ * Final peephole pass that merges the current operation with the previously emitted one.
+ */
+internal object OpMerger : OptimisationPass {
+    override fun run(program: MutableList<BFOperation>) {
+        val merged = mutableListOf<BFOperation>()
+
+        for (op in program) {
+            var current = op
+
+            while (merged.isNotEmpty()) {
+                val previous = merged.last()
+                val combined = tryMerge(previous, current) ?: break
+                merged.removeLast()
+                current = combined
+            }
+
+            when (current) {
+                is PointerMove -> if (current.value != 0) merged += current
+                is ValueChange -> if (current.value != 0) merged += current
+                else -> merged += current
+            }
+        }
+
+        program.clear()
+        program.addAll(merged)
+    }
+
+    private fun tryMerge(previous: BFOperation, current: BFOperation): BFOperation? {
+        if (previous is PointerMove && current is PointerMove) {
+            return PointerMove(previous.value + current.value)
+        }
+
+        if (previous is ValueChange && current is ValueChange && previous.offset == current.offset) {
+            return ValueChange(previous.value + current.value, previous.offset)
+        }
+
+        if (previous is SetToConstant && current is ValueChange && previous.offset == current.offset) {
+            val value = (previous.value.toInt() + current.value).toUByte()
+            return SetToConstant(value = value, offset = previous.offset)
+        }
+
+        if (current is SetToConstant && previous.overwritesCell(current.offset)) {
+            return current
+        }
+
+        return null
+    }
+
+    private fun BFOperation.overwritesCell(offset: Int): Boolean = when (this) {
+        is SetToConstant -> this.offset == offset
+        is ValueChange -> this.offset == offset
+        is Copy -> this.offset == offset
+        else -> false
+    }
+}

src/commonMain/kotlin/dev/rdh/bf/opt/RunLengthMerger.kt

@@ -17,7 +17,7 @@ fun bfOptimise(program: Iterable<BFOperation>, iterations: Int = 5): List<BFOper
     val program = program.toMutableList()
 
     val corePasses = arrayOf(
-        RunLengthMerger, ConstantReplacer, OffsetAdder, CopyLoopReplacer, WriteMerger
+        ConstantReplacer, OffsetAdder, CopyLoopReplacer, OpMerger
     )
     val cleanupPasses = arrayOf(
         DeadStartRemover,
@@ -38,7 +38,5 @@ fun bfOptimise(program: Iterable<BFOperation>, iterations: Int = 5): List<BFOper
         it.run(program)
     }
 
-    LoopOptimiser(ConsecutiveLoopRemover, ZeroRemover).run(program)
-
     return program
 }

src/commonMain/kotlin/dev/rdh/bf/opt/WriteMerger.kt

@@ -8,6 +8,7 @@ import kotlin.io.path.Path
 import kotlin.io.path.deleteRecursively
 import kotlin.io.path.readText
 import kotlin.time.measureTime
+import kotlin.time.measureTimedValue
 
 @OptIn(ExperimentalPathApi::class)
 fun main(args: Array<String>) {
@@ -148,11 +149,12 @@ private fun runProgram(
     } else {
         InterpreterRunner
     }
-    val executable = runner.compile(program)
+    val (executable, cTime) = measureTimedValue { runner.compile(program) }
 
     val time = measureTime { executable.run(SysInInput, SysOutOutput) }
 
     if (printTime) {
+        System.err.println("Compile time: ${formatTime(cTime)}")
         System.err.println("Execution time: ${formatTime(time)}")
     }
 }

src/commonMain/kotlin/dev/rdh/bf/opt/optimise.kt

@@ -27,13 +27,21 @@ const CTRL_DONE = 2;
 const OUTPUT_BUFFER_SIZE = 1024 * 1024;
 const supportsSab = globalThis.crossOriginIsolated === true && typeof SharedArrayBuffer === "function";
 
+function formatTime(ms) {
+    if (ms < 1000) {
+        return `${ms.toFixed(2)} ms`;
+    } else {
+        return `${(ms / 1000).toFixed(2)} s`;
+    }
+}
+
 function finishRun(doneMsg) {
     if (doneMsg == null) return;
     running = false;
     runBtn.disabled = false;
     outputEl.value += outputDecoder.decode();
-    const compileLabel = doneMsg.compileMs > 0.0 ? `${doneMsg.compileMs.toFixed(2)} ms` : "cached";
-    timeEl.innerHTML = `<span title="compile: ${compileLabel} ms, execute: ${doneMsg.runMs.toFixed(2)} ms">done in ${doneMsg.workerTotalMs.toFixed(2)} ms</span>`;
+    const compileLabel = doneMsg.compileMs > 0.0 ? formatTime(doneMsg.compileMs) : "cached";
+    timeEl.innerHTML = `<span title="compile: ${compileLabel}, execute: ${formatTime(doneMsg.runMs)}">done in ${formatTime(doneMsg.workerTotalMs)}</span>`;
 }
 
 function drainBufAndMaybeFinish() {