Enable lynlib tests, drop legacy perf tests
This commit is contained in:
parent
28d3f8364c
commit
5b15d85c14
@ -1,95 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmarks for primitive arithmetic and comparison fast paths.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class ArithmeticBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkIntArithmeticAndComparisons() = runBlocking {
|
||||
val n = 400_000
|
||||
val sumScript = """
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
s = s + i
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// Baseline: disable primitive fast ops
|
||||
PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(sumScript) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] int-sum x$n [PRIMITIVE_FASTOPS=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Optimized
|
||||
PerfFlags.PRIMITIVE_FASTOPS = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(sumScript) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] int-sum x$n [PRIMITIVE_FASTOPS=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
val expected = (n.toLong() - 1L) * n / 2L
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
|
||||
// Comparison heavy (branchy) loop
|
||||
val cmpScript = """
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
if (i % 2 == 0) s = s + 1 else s = s + 2
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
val scope3 = Scope()
|
||||
val t4 = System.nanoTime()
|
||||
val c1 = (scope3.eval(cmpScript) as ObjInt).value
|
||||
val t5 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] int-cmp x$n [PRIMITIVE_FASTOPS=OFF]: ${(t5 - t4)/1_000_000.0} ms")
|
||||
|
||||
PerfFlags.PRIMITIVE_FASTOPS = true
|
||||
val scope4 = Scope()
|
||||
val t6 = System.nanoTime()
|
||||
val c2 = (scope4.eval(cmpScript) as ObjInt).value
|
||||
val t7 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] int-cmp x$n [PRIMITIVE_FASTOPS=ON]: ${(t7 - t6)/1_000_000.0} ms")
|
||||
|
||||
// Expected: half of n even add 1, half odd add 2 (n even assumed)
|
||||
val expectedCmp = (n / 2) * 1L + (n - n / 2) * 2L
|
||||
assertEquals(expectedCmp, c1)
|
||||
assertEquals(expectedCmp, c2)
|
||||
}
|
||||
}
|
||||
@ -1,350 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import java.io.File
|
||||
import java.lang.management.GarbageCollectorMXBean
|
||||
import java.lang.management.ManagementFactory
|
||||
import java.nio.file.Files
|
||||
import java.nio.file.Paths
|
||||
import kotlin.io.path.extension
|
||||
import kotlin.random.Random
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class BookAllocationProfileTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/book_alloc_profile.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] Book allocation/time profiling (JVM)\n")
|
||||
f.appendText("[DEBUG_LOG] All sizes in bytes; time in ns (lower is better).\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) { f.appendText(s + "\n") }
|
||||
|
||||
// Optional STDERR filter to hide benign warnings during profiling runs
|
||||
private inline fun <T> withFilteredStderr(vararg suppressContains: String, block: () -> T): T {
|
||||
val orig = System.err
|
||||
val filtering = java.io.PrintStream(object : java.io.OutputStream() {
|
||||
private val buf = StringBuilder()
|
||||
override fun write(b: Int) {
|
||||
if (b == '\n'.code) {
|
||||
val line = buf.toString()
|
||||
val suppress = suppressContains.any { line.contains(it) }
|
||||
if (!suppress) orig.println(line)
|
||||
buf.setLength(0)
|
||||
} else buf.append(b.toChar())
|
||||
}
|
||||
})
|
||||
return try {
|
||||
System.setErr(filtering)
|
||||
block()
|
||||
} finally {
|
||||
System.setErr(orig)
|
||||
}
|
||||
}
|
||||
|
||||
private fun forceGc() {
|
||||
// Best-effort GC to stabilize measurements
|
||||
repeat(3) {
|
||||
System.gc()
|
||||
try { Thread.sleep(25) } catch (_: InterruptedException) {}
|
||||
}
|
||||
}
|
||||
|
||||
private fun usedHeap(): Long {
|
||||
val mem = ManagementFactory.getMemoryMXBean().heapMemoryUsage
|
||||
return mem.used
|
||||
}
|
||||
|
||||
private suspend fun runDocTestsNonFailing(file: String, bookMode: Boolean = true) {
|
||||
try {
|
||||
runDocTests(file, bookMode)
|
||||
} catch (t: Throwable) {
|
||||
// Profiling should not fail because of documentation snippet issues.
|
||||
println("[DEBUG_LOG] [PROFILE] Skipping failing doc: $file: ${t.message}")
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun runBooksOnce(): Unit = runBlocking {
|
||||
// Mirror BookTest set, but run in bookMode to avoid strict assertions and allow shared context
|
||||
// Profiling should not fail on documentation snippet mismatches.
|
||||
runDocTestsNonFailing("../docs/tutorial.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/math.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/advanced_topics.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/OOP.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/Real.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/List.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/Range.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/Set.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/Map.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/Buffer.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/when.md", bookMode = true)
|
||||
// Samples folder, bookMode=true
|
||||
for (bt in Files.list(Paths.get("../docs/samples")).toList()) {
|
||||
if (bt.extension == "md") runDocTestsNonFailing(bt.toString(), bookMode = true)
|
||||
}
|
||||
runDocTestsNonFailing("../docs/declaring_arguments.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/exceptions_handling.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/time.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/parallelism.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/RingBuffer.md", bookMode = true)
|
||||
runDocTestsNonFailing("../docs/Iterable.md", bookMode = true)
|
||||
}
|
||||
|
||||
private data class ProfileResult(val timeNs: Long, val allocBytes: Long)
|
||||
|
||||
private suspend fun profileRun(): ProfileResult {
|
||||
forceGc()
|
||||
val before = usedHeap()
|
||||
val elapsed = measureNanoTime {
|
||||
withFilteredStderr("ScriptFlowIsNoMoreCollected") {
|
||||
runBooksOnce()
|
||||
}
|
||||
}
|
||||
forceGc()
|
||||
val after = usedHeap()
|
||||
val alloc = (after - before).coerceAtLeast(0)
|
||||
return ProfileResult(elapsed, alloc)
|
||||
}
|
||||
|
||||
private data class GcSnapshot(val count: Long, val timeMs: Long)
|
||||
private fun gcSnapshot(): GcSnapshot {
|
||||
var c = 0L
|
||||
var t = 0L
|
||||
for (gc: GarbageCollectorMXBean in ManagementFactory.getGarbageCollectorMXBeans()) {
|
||||
c += (gc.collectionCount.takeIf { it >= 0 } ?: 0)
|
||||
t += (gc.collectionTime.takeIf { it >= 0 } ?: 0)
|
||||
}
|
||||
return GcSnapshot(c, t)
|
||||
}
|
||||
|
||||
// --- Optional JFR support via reflection (works only on JDKs with Flight Recorder) ---
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
private class JfrHandle(val rec: Any, val dump: (File) -> Unit, val stop: () -> Unit)
|
||||
|
||||
private fun jfrStartIfRequested(name: String): JfrHandle? {
|
||||
val enabled = System.getProperty("lyng.jfr")?.toBoolean() == true
|
||||
if (!enabled) return null
|
||||
return try {
|
||||
val recCl = Class.forName("jdk.jfr.Recording")
|
||||
val ctor = recCl.getDeclaredConstructor()
|
||||
val rec = ctor.newInstance()
|
||||
val setName = recCl.methods.firstOrNull { it.name == "setName" && it.parameterTypes.size == 1 }
|
||||
setName?.invoke(rec, "Lyng-$name")
|
||||
val start = recCl.methods.first { it.name == "start" && it.parameterTypes.isEmpty() }
|
||||
start.invoke(rec)
|
||||
val stop = recCl.methods.first { it.name == "stop" && it.parameterTypes.isEmpty() }
|
||||
val dump = recCl.methods.firstOrNull { it.name == "dump" && it.parameterTypes.size == 1 }
|
||||
val dumper: (File) -> Unit = if (dump != null) {
|
||||
{ f -> dump.invoke(rec, f.toPath()) }
|
||||
} else {
|
||||
{ _ -> }
|
||||
}
|
||||
JfrHandle(rec, dumper) { stop.invoke(rec) }
|
||||
} catch (e: Throwable) {
|
||||
// JFR requested but not available; note once via stdout and proceed without it
|
||||
try {
|
||||
println("[DEBUG_LOG] JFR not available on this JVM; run with Oracle/OpenJDK 11+ to enable -Dlyng.jfr=true")
|
||||
} catch (_: Throwable) {}
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
private fun intProp(name: String, def: Int): Int =
|
||||
System.getProperty(name)?.toIntOrNull() ?: def
|
||||
|
||||
private fun boolProp(name: String, def: Boolean): Boolean =
|
||||
System.getProperty(name)?.toBoolean() ?: def
|
||||
|
||||
private data class FlagSnapshot(
|
||||
val RVAL_FASTPATH: Boolean,
|
||||
val PRIMITIVE_FASTOPS: Boolean,
|
||||
val ARG_BUILDER: Boolean,
|
||||
val ARG_SMALL_ARITY_12: Boolean,
|
||||
val FIELD_PIC: Boolean,
|
||||
val METHOD_PIC: Boolean,
|
||||
val FIELD_PIC_SIZE_4: Boolean,
|
||||
val METHOD_PIC_SIZE_4: Boolean,
|
||||
val INDEX_PIC: Boolean,
|
||||
val INDEX_PIC_SIZE_4: Boolean,
|
||||
val SCOPE_POOL: Boolean,
|
||||
val PIC_DEBUG_COUNTERS: Boolean,
|
||||
) {
|
||||
fun restore() {
|
||||
PerfFlags.RVAL_FASTPATH = RVAL_FASTPATH
|
||||
PerfFlags.PRIMITIVE_FASTOPS = PRIMITIVE_FASTOPS
|
||||
PerfFlags.ARG_BUILDER = ARG_BUILDER
|
||||
PerfFlags.ARG_SMALL_ARITY_12 = ARG_SMALL_ARITY_12
|
||||
PerfFlags.FIELD_PIC = FIELD_PIC
|
||||
PerfFlags.METHOD_PIC = METHOD_PIC
|
||||
PerfFlags.FIELD_PIC_SIZE_4 = FIELD_PIC_SIZE_4
|
||||
PerfFlags.METHOD_PIC_SIZE_4 = METHOD_PIC_SIZE_4
|
||||
PerfFlags.INDEX_PIC = INDEX_PIC
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = INDEX_PIC_SIZE_4
|
||||
PerfFlags.SCOPE_POOL = SCOPE_POOL
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = PIC_DEBUG_COUNTERS
|
||||
}
|
||||
}
|
||||
|
||||
private fun snapshotFlags() = FlagSnapshot(
|
||||
RVAL_FASTPATH = PerfFlags.RVAL_FASTPATH,
|
||||
PRIMITIVE_FASTOPS = PerfFlags.PRIMITIVE_FASTOPS,
|
||||
ARG_BUILDER = PerfFlags.ARG_BUILDER,
|
||||
ARG_SMALL_ARITY_12 = PerfFlags.ARG_SMALL_ARITY_12,
|
||||
FIELD_PIC = PerfFlags.FIELD_PIC,
|
||||
METHOD_PIC = PerfFlags.METHOD_PIC,
|
||||
FIELD_PIC_SIZE_4 = PerfFlags.FIELD_PIC_SIZE_4,
|
||||
METHOD_PIC_SIZE_4 = PerfFlags.METHOD_PIC_SIZE_4,
|
||||
INDEX_PIC = PerfFlags.INDEX_PIC,
|
||||
INDEX_PIC_SIZE_4 = PerfFlags.INDEX_PIC_SIZE_4,
|
||||
SCOPE_POOL = PerfFlags.SCOPE_POOL,
|
||||
PIC_DEBUG_COUNTERS = PerfFlags.PIC_DEBUG_COUNTERS,
|
||||
)
|
||||
|
||||
private fun median(values: List<Long>): Long {
|
||||
if (values.isEmpty()) return 0
|
||||
val s = values.sorted()
|
||||
val mid = s.size / 2
|
||||
return if (s.size % 2 == 1) s[mid] else ((s[mid - 1] + s[mid]) / 2)
|
||||
}
|
||||
|
||||
private suspend fun runScenario(
|
||||
name: String,
|
||||
prepare: () -> Unit,
|
||||
repeats: Int = 3,
|
||||
out: (String) -> Unit
|
||||
): ProfileResult {
|
||||
val warmup = intProp("lyng.profile.warmup", 1)
|
||||
val reps = intProp("lyng.profile.repeats", repeats)
|
||||
// JFR
|
||||
val jfr = jfrStartIfRequested(name)
|
||||
if (System.getProperty("lyng.jfr")?.toBoolean() == true && jfr == null) {
|
||||
out("[DEBUG_LOG] JFR: requested but not available on this JVM")
|
||||
}
|
||||
// Warm-up before GC snapshot (some profilers prefer this)
|
||||
prepare()
|
||||
repeat(warmup) { profileRun() }
|
||||
// GC baseline
|
||||
val gc0 = gcSnapshot()
|
||||
val times = ArrayList<Long>(repeats)
|
||||
val allocs = ArrayList<Long>(repeats)
|
||||
repeat(reps) {
|
||||
val r = profileRun()
|
||||
times += r.timeNs
|
||||
allocs += r.allocBytes
|
||||
}
|
||||
val pr = ProfileResult(median(times), median(allocs))
|
||||
val gc1 = gcSnapshot()
|
||||
val gcCountDelta = (gc1.count - gc0.count).coerceAtLeast(0)
|
||||
val gcTimeDelta = (gc1.timeMs - gc0.timeMs).coerceAtLeast(0)
|
||||
out("[DEBUG_LOG] time=${pr.timeNs} ns, alloc=${pr.allocBytes} B (median of ${reps}), GC(count=${gcCountDelta}, timeMs=${gcTimeDelta})")
|
||||
// Stop and dump JFR if enabled
|
||||
if (jfr != null) {
|
||||
try {
|
||||
jfr.stop()
|
||||
val dumpFile = File("lynglib/build/jfr_${name}.jfr")
|
||||
jfr.dump(dumpFile)
|
||||
out("[DEBUG_LOG] JFR dumped: ${dumpFile.path}")
|
||||
} catch (_: Throwable) {}
|
||||
}
|
||||
return pr
|
||||
}
|
||||
|
||||
@Test
|
||||
fun profile_books_allocations_and_time() = runTestBlocking {
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
fun log(s: String) = appendLine(f, s)
|
||||
|
||||
val saved = snapshotFlags()
|
||||
try {
|
||||
data class Scenario(val label: String, val title: String, val prep: () -> Unit)
|
||||
val scenarios = mutableListOf<Scenario>()
|
||||
// Baseline A
|
||||
scenarios += Scenario("A", "JVM defaults") {
|
||||
saved.restore(); PerfFlags.PIC_DEBUG_COUNTERS = false
|
||||
}
|
||||
// Most flags OFF B
|
||||
scenarios += Scenario("B", "most perf flags OFF") {
|
||||
saved.restore(); PerfFlags.PIC_DEBUG_COUNTERS = false
|
||||
PerfFlags.RVAL_FASTPATH = false
|
||||
PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
PerfFlags.ARG_SMALL_ARITY_12 = false
|
||||
PerfFlags.FIELD_PIC = false
|
||||
PerfFlags.METHOD_PIC = false
|
||||
PerfFlags.FIELD_PIC_SIZE_4 = false
|
||||
PerfFlags.METHOD_PIC_SIZE_4 = false
|
||||
PerfFlags.INDEX_PIC = false
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = false
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
}
|
||||
// Defaults with INDEX_PIC size 2 C
|
||||
scenarios += Scenario("C", "defaults except INDEX_PIC_SIZE_4=false") {
|
||||
saved.restore(); PerfFlags.PIC_DEBUG_COUNTERS = false
|
||||
PerfFlags.INDEX_PIC = true; PerfFlags.INDEX_PIC_SIZE_4 = false
|
||||
}
|
||||
|
||||
// One-flag toggles relative to A
|
||||
scenarios += Scenario("D", "A with RVAL_FASTPATH=false") {
|
||||
saved.restore(); PerfFlags.PIC_DEBUG_COUNTERS = false; PerfFlags.RVAL_FASTPATH = false
|
||||
}
|
||||
scenarios += Scenario("E", "A with PRIMITIVE_FASTOPS=false") {
|
||||
saved.restore(); PerfFlags.PIC_DEBUG_COUNTERS = false; PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
}
|
||||
scenarios += Scenario("F", "A with INDEX_PIC=false") {
|
||||
saved.restore(); PerfFlags.PIC_DEBUG_COUNTERS = false; PerfFlags.INDEX_PIC = false
|
||||
}
|
||||
scenarios += Scenario("G", "A with SCOPE_POOL=false") {
|
||||
saved.restore(); PerfFlags.PIC_DEBUG_COUNTERS = false; PerfFlags.SCOPE_POOL = false
|
||||
}
|
||||
|
||||
val shuffle = boolProp("lyng.profile.shuffle", true)
|
||||
val order = if (shuffle) scenarios.shuffled(Random(System.nanoTime())) else scenarios
|
||||
|
||||
val results = mutableMapOf<String, ProfileResult>()
|
||||
for (sc in order) {
|
||||
log("[DEBUG_LOG] Scenario ${sc.label}: ${sc.title}")
|
||||
results[sc.label] = runScenario(sc.label, prepare = sc.prep, out = ::log)
|
||||
}
|
||||
|
||||
// Summary vs A if measured
|
||||
val a = results["A"]
|
||||
if (a != null) {
|
||||
log("[DEBUG_LOG] Summary deltas vs A (medians):")
|
||||
fun deltaLine(name: String, r: ProfileResult) = "[DEBUG_LOG] ${name} - A: time=${r.timeNs - a.timeNs} ns, alloc=${r.allocBytes - a.allocBytes} B"
|
||||
listOf("B","C","D","E","F","G").forEach { k ->
|
||||
results[k]?.let { r -> log(deltaLine(k, r)) }
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
saved.restore()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Minimal runBlocking bridge to avoid extra test deps here
|
||||
private fun runTestBlocking(block: suspend () -> Unit) {
|
||||
kotlinx.coroutines.runBlocking { block() }
|
||||
}
|
||||
@ -1,158 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import java.io.File
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class CallArgPipelineABTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/call_ab_results.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] Call/Arg pipeline A/B results\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) {
|
||||
f.appendText(s + "\n")
|
||||
}
|
||||
|
||||
private suspend fun buildScriptForCalls(arity: Int, iters: Int): Script {
|
||||
val argsDecl = (0 until arity).joinToString(",") { "a$it" }
|
||||
val argsUse = (0 until arity).joinToString(" + ") { "a$it" }.ifEmpty { "0" }
|
||||
val callArgs = (0 until arity).joinToString(",") { (it + 1).toString() }
|
||||
val src = """
|
||||
var sum = 0
|
||||
fun f($argsDecl) { $argsUse }
|
||||
for(i in 0..${iters - 1}) {
|
||||
sum += f($callArgs)
|
||||
}
|
||||
sum
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<calls-$arity>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun benchCallsOnce(arity: Int, iters: Int): Long {
|
||||
val script = buildScriptForCalls(arity, iters)
|
||||
val scope = Script.newScope()
|
||||
var result: Obj? = null
|
||||
val t = measureNanoTime {
|
||||
result = script.execute(scope)
|
||||
}
|
||||
// Basic correctness check so JIT doesn’t elide
|
||||
val expected = (0 until iters).fold(0L) { acc, _ ->
|
||||
(acc + (1L + 2L + 3L + 4L + 5L + 6L + 7L + 8L).let { if (arity <= 8) it - (8 - arity) * 0L else it })
|
||||
}
|
||||
// We only rely that it runs; avoid strict equals as function may compute differently for arities < 8
|
||||
if (result !is ObjInt) {
|
||||
// ensure use to prevent DCE
|
||||
println("[DEBUG_LOG] Result class=${result?.javaClass?.simpleName}")
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
private suspend fun benchOptionalCallShortCircuit(iters: Int): Long {
|
||||
val src = """
|
||||
var side = 0
|
||||
fun inc() { side += 1 }
|
||||
var o = null
|
||||
for(i in 0..${iters - 1}) {
|
||||
o?.foo(inc())
|
||||
}
|
||||
side
|
||||
""".trimIndent()
|
||||
val script = Compiler.compile(Source("<opt-call>", src), Script.defaultImportManager)
|
||||
val scope = Script.newScope()
|
||||
var result: Obj? = null
|
||||
val t = measureNanoTime { result = script.execute(scope) }
|
||||
// Ensure short-circuit actually happened
|
||||
require((result as? ObjInt)?.value == 0L) { "optional-call short-circuit failed; side=${(result as? ObjInt)?.value}" }
|
||||
return t
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ab_call_pipeline() = runTestBlocking {
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
val savedArgBuilder = PerfFlags.ARG_BUILDER
|
||||
val savedScopePool = PerfFlags.SCOPE_POOL
|
||||
|
||||
try {
|
||||
val iters = 50_000
|
||||
val aritiesBase = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8)
|
||||
|
||||
// A/B for ARG_BUILDER (0..8)
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
val offTimes = mutableListOf<Long>()
|
||||
for (a in aritiesBase) offTimes += benchCallsOnce(a, iters)
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
val onTimes = mutableListOf<Long>()
|
||||
for (a in aritiesBase) onTimes += benchCallsOnce(a, iters)
|
||||
|
||||
appendLine(f, "[DEBUG_LOG] ARG_BUILDER A/B (iters=$iters):")
|
||||
aritiesBase.forEachIndexed { idx, a ->
|
||||
appendLine(f, "[DEBUG_LOG] arity=$a OFF=${offTimes[idx]} ns, ON=${onTimes[idx]} ns, delta=${offTimes[idx] - onTimes[idx]} ns")
|
||||
}
|
||||
|
||||
// A/B for ARG_SMALL_ARITY_12 (9..12)
|
||||
val aritiesExtended = listOf(9, 10, 11, 12)
|
||||
val savedSmall = PerfFlags.ARG_SMALL_ARITY_12
|
||||
try {
|
||||
PerfFlags.ARG_BUILDER = true // base builder on
|
||||
PerfFlags.ARG_SMALL_ARITY_12 = false
|
||||
val offExt = mutableListOf<Long>()
|
||||
for (a in aritiesExtended) offExt += benchCallsOnce(a, iters)
|
||||
PerfFlags.ARG_SMALL_ARITY_12 = true
|
||||
val onExt = mutableListOf<Long>()
|
||||
for (a in aritiesExtended) onExt += benchCallsOnce(a, iters)
|
||||
appendLine(f, "[DEBUG_LOG] ARG_SMALL_ARITY_12 A/B (iters=$iters):")
|
||||
aritiesExtended.forEachIndexed { idx, a ->
|
||||
appendLine(f, "[DEBUG_LOG] arity=$a OFF=${offExt[idx]} ns, ON=${onExt[idx]} ns, delta=${offExt[idx] - onExt[idx]} ns")
|
||||
}
|
||||
} finally {
|
||||
PerfFlags.ARG_SMALL_ARITY_12 = savedSmall
|
||||
}
|
||||
|
||||
// Optional call short-circuit sanity timing (does not A/B a flag currently; implementation short-circuits before args)
|
||||
val tOpt = benchOptionalCallShortCircuit(100_000)
|
||||
appendLine(f, "[DEBUG_LOG] Optional-call short-circuit sanity: ${tOpt} ns for 100k iterations (side-effect arg not evaluated).")
|
||||
|
||||
// A/B for SCOPE_POOL
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val tPoolOff = benchCallsOnce(5, iters)
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val tPoolOn = benchCallsOnce(5, iters)
|
||||
appendLine(f, "[DEBUG_LOG] SCOPE_POOL A/B (arity=5, iters=$iters): OFF=${tPoolOff} ns, ON=${tPoolOn} ns, delta=${tPoolOff - tPoolOn} ns")
|
||||
|
||||
} finally {
|
||||
PerfFlags.ARG_BUILDER = savedArgBuilder
|
||||
PerfFlags.SCOPE_POOL = savedScopePool
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Minimal runBlocking for common jvmTest without depending on kotlinx.coroutines test artifacts here
|
||||
private fun runTestBlocking(block: suspend () -> Unit) {
|
||||
kotlinx.coroutines.runBlocking { block() }
|
||||
}
|
||||
@ -1,119 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmarks for function/method call overhead and argument building.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class CallBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkSimpleFunctionCalls() = runBlocking {
|
||||
val n = 300_000 // keep it fast for CI
|
||||
|
||||
// A tiny script with 0, 1, 2 arg functions and a loop using them
|
||||
val script = """
|
||||
fun f0() { 1 }
|
||||
fun f1(a) { a }
|
||||
fun f2(a,b) { a + b }
|
||||
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
s = s + f0()
|
||||
s = s + f1(1)
|
||||
s = s + f2(1, 1)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// Disable ARG_BUILDER for baseline
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] calls x$n [ARG_BUILDER=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Enable ARG_BUILDER for optimized run
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] calls x$n [ARG_BUILDER=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Correctness: each loop adds 1 + 1 + (1+1) = 4
|
||||
val expected = 4L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkMixedArityCalls() = runBlocking {
|
||||
val n = 200_000
|
||||
val script = """
|
||||
fun f0() { 1 }
|
||||
fun f1(a) { a }
|
||||
fun f2(a,b) { a + b }
|
||||
fun f3(a,b,c) { a + b + c }
|
||||
fun f4(a,b,c,d) { a + b + c + d }
|
||||
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
s = s + f0()
|
||||
s = s + f1(1)
|
||||
s = s + f2(1, 1)
|
||||
s = s + f3(1, 1, 1)
|
||||
s = s + f4(1, 1, 1, 1)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// Baseline
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] mixed-arity x$n [ARG_BUILDER=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Optimized
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] mixed-arity x$n [ARG_BUILDER=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Each loop: 1 + 1 + 2 + 3 + 4 = 11
|
||||
val expected = 11L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
}
|
||||
@ -1,83 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for mixed-arity function calls and ARG_BUILDER.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import java.io.File
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
private fun appendBenchLog(name: String, variant: String, ms: Double) {
|
||||
val f = File("lynglib/build/benchlogs/log.csv")
|
||||
f.parentFile.mkdirs()
|
||||
f.appendText("$name,$variant,$ms\n")
|
||||
}
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class CallMixedArityBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkMixedArityCalls() = runBlocking {
|
||||
val n = 200_000
|
||||
val script = """
|
||||
fun f0() { 1 }
|
||||
fun f1(a) { a }
|
||||
fun f2(a,b) { a + b }
|
||||
fun f3(a,b,c) { a + b + c }
|
||||
fun f4(a,b,c,d) { a + b + c + d }
|
||||
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
s = s + f0()
|
||||
s = s + f1(1)
|
||||
s = s + f2(1, 1)
|
||||
s = s + f3(1, 1, 1)
|
||||
s = s + f4(1, 1, 1, 1)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// Baseline
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] mixed-arity x$n [ARG_BUILDER=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Optimized
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] mixed-arity x$n [ARG_BUILDER=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Each loop: 1 + 1 + 2 + 3 + 4 = 11
|
||||
val expected = 11L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
}
|
||||
@ -1,72 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for Scope frame pooling impact on call-heavy code paths.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class CallPoolingBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkScopePoolingOnFunctionCalls() = runBlocking {
|
||||
val n = 300_000
|
||||
val script = """
|
||||
fun inc1(a) { a + 1 }
|
||||
fun inc2(a) { inc1(a) + 1 }
|
||||
fun inc3(a) { inc2(a) + 1 }
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
s = inc3(s)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// Baseline: pooling OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] call-pooling x$n [SCOPE_POOL=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Optimized: pooling ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] call-pooling x$n [SCOPE_POOL=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Each inc3 performs 3 increments per loop
|
||||
val expected = 3L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
|
||||
// Reset flag to default (OFF) to avoid affecting other tests unintentionally
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
}
|
||||
}
|
||||
@ -1,74 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for calls with splat (spread) arguments.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class CallSplatBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkCallsWithSplatArgs() = runBlocking {
|
||||
val n = 120_000
|
||||
val script = """
|
||||
fun sum4(a,b,c,d) { a + b + c + d }
|
||||
val base = [1,1,1,1]
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// two direct, one splat per iteration
|
||||
s = s + sum4(1,1,1,1)
|
||||
s = s + sum4(1,1,1,1)
|
||||
s = s + sum4(base[0], base[1], base[2], base[3])
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// Baseline
|
||||
PerfFlags.ARG_BUILDER = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] splat-calls x$n [ARG_BUILDER=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Optimized
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] splat-calls x$n [ARG_BUILDER=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Each loop adds (4 + 4 + 4) = 12
|
||||
val expected = 12L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
|
||||
// Reset to default
|
||||
PerfFlags.ARG_BUILDER = true
|
||||
}
|
||||
}
|
||||
@ -1,85 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Multithreaded benchmark to quantify SCOPE_POOL speedup on JVM.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.*
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.math.max
|
||||
import kotlin.math.min
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class ConcurrencyCallBenchmarkTest {
|
||||
|
||||
private suspend fun parallelEval(workers: Int, script: String): List<Long> = coroutineScope {
|
||||
(0 until workers).map { async { (Scope().eval(script) as ObjInt).value } }.awaitAll()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmark_multithread_calls_off_on() = runBlocking {
|
||||
val cpu = Runtime.getRuntime().availableProcessors()
|
||||
val workers = min(max(2, cpu), 8)
|
||||
val iterations = 15_000 // per worker; keep CI fast
|
||||
val script = """
|
||||
fun f0() { 1 }
|
||||
fun f1(a) { a }
|
||||
fun f2(a,b) { a + b }
|
||||
fun f3(a,b,c) { a + b + c }
|
||||
fun f4(a,b,c,d) { a + b + c + d }
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $iterations) {
|
||||
s = s + f0()
|
||||
s = s + f1(1)
|
||||
s = s + f2(1, 1)
|
||||
s = s + f3(1, 1, 1)
|
||||
s = s + f4(1, 1, 1, 1)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
val expected = (1 + 1 + 2 + 3 + 4).toLong() * iterations
|
||||
|
||||
// OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val t0 = System.nanoTime()
|
||||
val off = withContext(Dispatchers.Default) { parallelEval(workers, script) }
|
||||
val t1 = System.nanoTime()
|
||||
// ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val t2 = System.nanoTime()
|
||||
val on = withContext(Dispatchers.Default) { parallelEval(workers, script) }
|
||||
val t3 = System.nanoTime()
|
||||
// reset
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
|
||||
off.forEach { assertEquals(expected, it) }
|
||||
on.forEach { assertEquals(expected, it) }
|
||||
|
||||
val offMs = (t1 - t0) / 1_000_000.0
|
||||
val onMs = (t3 - t2) / 1_000_000.0
|
||||
val speedup = offMs / onMs
|
||||
println("[DEBUG_LOG] [BENCH] ConcurrencyCallBenchmark workers=$workers iters=$iterations each: OFF=${"%.3f".format(offMs)} ms, ON=${"%.3f".format(onMs)} ms, speedup=${"%.2f".format(speedup)}x")
|
||||
}
|
||||
}
|
||||
@ -1,95 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM stress tests for scope frame pooling (deep nesting and recursion).
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class DeepPoolingStressJvmTest {
|
||||
@Test
|
||||
fun deepNestedCalls_noLeak_and_correct_with_and_without_pooling() = runBlocking {
|
||||
val depth = 200
|
||||
val script = """
|
||||
fun f0(x) { x + 1 }
|
||||
fun f1(x) { f0(x) + 1 }
|
||||
fun f2(x) { f1(x) + 1 }
|
||||
fun f3(x) { f2(x) + 1 }
|
||||
fun f4(x) { f3(x) + 1 }
|
||||
fun f5(x) { f4(x) + 1 }
|
||||
|
||||
fun chain(x, d) {
|
||||
var i = 0
|
||||
var s = x
|
||||
while (i < d) {
|
||||
// 5 nested calls per iteration
|
||||
s = f5(s)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
}
|
||||
chain(0, $depth)
|
||||
""".trimIndent()
|
||||
|
||||
// Pool OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
// Pool ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
// Each loop adds 6 (f0..f5 adds 6)
|
||||
val expected = 6L * depth
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
// Reset
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
}
|
||||
|
||||
@Test
|
||||
fun recursion_factorial_correct_with_and_without_pooling() = runBlocking {
|
||||
val n = 10
|
||||
val script = """
|
||||
fun fact(x) {
|
||||
if (x <= 1) 1 else x * fact(x - 1)
|
||||
}
|
||||
fact($n)
|
||||
""".trimIndent()
|
||||
// OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
// ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
// 10! = 3628800
|
||||
val expected = 3628800L
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
}
|
||||
}
|
||||
@ -1,156 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for expression evaluation with RVAL_FASTPATH.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class ExpressionBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkExpressionChains() = runBlocking {
|
||||
val n = 350_000
|
||||
val script = """
|
||||
// arithmetic + elvis + logical chains
|
||||
val maybe = null
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// exercise elvis on a null
|
||||
s = s + (maybe ?: 0)
|
||||
// branch using booleans without coercion to int
|
||||
if ((i % 3 == 0 && true) || false) { s = s + 1 } else { s = s + 2 }
|
||||
// parity via arithmetic only (avoid adding booleans)
|
||||
s = s + (i - (i / 2) * 2)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.RVAL_FASTPATH = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] expr-chain x$n [RVAL_FASTPATH=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.RVAL_FASTPATH = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] expr-chain x$n [RVAL_FASTPATH=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// correctness: compute expected with simple kotlin logic mirroring the loop
|
||||
var s = 0L
|
||||
var i = 0
|
||||
while (i < n) {
|
||||
if ((i % 3 == 0 && true) || false) s += 1 else s += 2
|
||||
// parity via arithmetic only, matches script's single parity addition
|
||||
s += i - (i / 2) * 2
|
||||
i += 1
|
||||
}
|
||||
assertEquals(s, r1)
|
||||
assertEquals(s, r2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkListIndexReads() = runBlocking {
|
||||
val n = 350_000
|
||||
val script = """
|
||||
val list = (1..10).toList()
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// exercise fast index path on ObjList + ObjInt index
|
||||
s = s + list[3]
|
||||
s = s + list[7]
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.RVAL_FASTPATH = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] list-index x$n [RVAL_FASTPATH=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.RVAL_FASTPATH = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] list-index x$n [RVAL_FASTPATH=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// correctness: list = [1..10]; each loop adds list[3]+list[7] = 4 + 8 = 12
|
||||
val expected = 12L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkFieldReadPureReceiver() = runBlocking {
|
||||
val n = 300_000
|
||||
val script = """
|
||||
class C(){ var x = 1; var y = 2 }
|
||||
val c = C()
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// repeated reads on the same monomorphic receiver
|
||||
s = s + c.x
|
||||
s = s + c.y
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.RVAL_FASTPATH = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] field-read x$n [RVAL_FASTPATH=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.RVAL_FASTPATH = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] field-read x$n [RVAL_FASTPATH=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
val expected = (1L + 2L) * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
}
|
||||
@ -1,139 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import java.io.File
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class IndexPicABTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/index_pic_ab_results.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] Index PIC A/B results\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) { f.appendText(s + "\n") }
|
||||
|
||||
private suspend fun buildStringIndexScript(len: Int, iters: Int): Script {
|
||||
// Build a long string and index it by cycling positions
|
||||
val content = (0 until len).joinToString("") { i ->
|
||||
val ch = 'a' + (i % 26)
|
||||
ch.toString()
|
||||
}
|
||||
val src = """
|
||||
val s = "$content"
|
||||
var acc = 0
|
||||
for(i in 0..${iters - 1}) {
|
||||
val j = i % ${len}
|
||||
// Compare to a 1-char string to avoid needing Char.toInt(); still exercises indexing path
|
||||
if (s[j] == "a") { acc += 1 } else { acc += 0 }
|
||||
}
|
||||
acc
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<idx-string>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun buildMapIndexScript(keys: Int, iters: Int): Script {
|
||||
// Build a map of ("kX" -> X) and repeatedly access by key cycling
|
||||
val entries = (0 until keys).joinToString(", ") { i -> "\"k$i\" => $i" }
|
||||
val src = """
|
||||
// Build via Map(entry1, entry2, ...), not a list literal
|
||||
val m = Map($entries)
|
||||
var acc = 0
|
||||
for(i in 0..${iters - 1}) {
|
||||
val k = "k" + (i % ${keys})
|
||||
acc += (m[k] ?: 0)
|
||||
}
|
||||
acc
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<idx-map>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun runOnce(script: Script): Long {
|
||||
val scope = Script.newScope()
|
||||
var result: Obj? = null
|
||||
val t = measureNanoTime { result = script.execute(scope) }
|
||||
if (result !is ObjInt) println("[DEBUG_LOG] result=${result?.javaClass?.simpleName}")
|
||||
return t
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ab_index_pic_and_size() = runTestBlocking {
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
val savedIndexPic = PerfFlags.INDEX_PIC
|
||||
val savedIndexSize4 = PerfFlags.INDEX_PIC_SIZE_4
|
||||
val savedCounters = PerfFlags.PIC_DEBUG_COUNTERS
|
||||
|
||||
try {
|
||||
val iters = 300_000
|
||||
val sLen = 512
|
||||
val mapKeys = 256
|
||||
val sScript = buildStringIndexScript(sLen, iters)
|
||||
val mScript = buildMapIndexScript(mapKeys, iters)
|
||||
|
||||
fun header(which: String) { appendLine(f, "[DEBUG_LOG] A/B on $which (iters=$iters)") }
|
||||
|
||||
// Baseline OFF
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = true
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.INDEX_PIC = false
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = false
|
||||
header("String[Int], INDEX_PIC=OFF")
|
||||
val tSOff = runOnce(sScript)
|
||||
header("Map[String], INDEX_PIC=OFF")
|
||||
val tMOff = runOnce(mScript)
|
||||
appendLine(f, "[DEBUG_LOG] OFF counters: indexHit=${PerfStats.indexPicHit} indexMiss=${PerfStats.indexPicMiss}")
|
||||
|
||||
// PIC ON, size 2
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.INDEX_PIC = true
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = false
|
||||
val tSOn2 = runOnce(sScript)
|
||||
val tMOn2 = runOnce(mScript)
|
||||
appendLine(f, "[DEBUG_LOG] ON size=2 counters: indexHit=${PerfStats.indexPicHit} indexMiss=${PerfStats.indexPicMiss}")
|
||||
|
||||
// PIC ON, size 4
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.INDEX_PIC = true
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = true
|
||||
val tSOn4 = runOnce(sScript)
|
||||
val tMOn4 = runOnce(mScript)
|
||||
appendLine(f, "[DEBUG_LOG] ON size=4 counters: indexHit=${PerfStats.indexPicHit} indexMiss=${PerfStats.indexPicMiss}")
|
||||
|
||||
// Report
|
||||
appendLine(f, "[DEBUG_LOG] String[Int] OFF=${tSOff} ns, ON(2)=${tSOn2} ns, ON(4)=${tSOn4} ns")
|
||||
appendLine(f, "[DEBUG_LOG] Map[String] OFF=${tMOff} ns, ON(2)=${tMOn2} ns, ON(4)=${tMOn4} ns")
|
||||
} finally {
|
||||
PerfFlags.INDEX_PIC = savedIndexPic
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = savedIndexSize4
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = savedCounters
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun runTestBlocking(block: suspend () -> Unit) {
|
||||
kotlinx.coroutines.runBlocking { block() }
|
||||
}
|
||||
@ -1,141 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import java.io.File
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
/**
|
||||
* A/B micro-benchmark for index WRITE paths (Map[String] put, List[Int] set).
|
||||
* Measures OFF vs ON for INDEX_PIC and then size 2 vs 4 (INDEX_PIC_SIZE_4).
|
||||
* Produces [DEBUG_LOG] output in lynglib/build/index_write_ab_results.txt
|
||||
*/
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class IndexWritePathABTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/index_write_ab_results.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] Index WRITE PIC A/B results\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) { f.appendText(s + "\n") }
|
||||
|
||||
private suspend fun buildMapWriteScript(keys: Int, iters: Int): Script {
|
||||
// Construct map with keys k0..k{keys-1} and then perform writes in a tight loop
|
||||
val initEntries = (0 until keys).joinToString(", ") { i -> "\"k$i\" => $i" }
|
||||
val src = """
|
||||
var acc = 0
|
||||
val m = Map($initEntries)
|
||||
for(i in 0..${iters - 1}) {
|
||||
val k = "k" + (i % $keys)
|
||||
m[k] = i
|
||||
acc += (m[k] ?: 0)
|
||||
}
|
||||
acc
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<idx-map-write>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun buildListWriteScript(len: Int, iters: Int): Script {
|
||||
val initList = (0 until len).joinToString(", ") { i -> i.toString() }
|
||||
val src = """
|
||||
var acc = 0
|
||||
val a = [$initList]
|
||||
for(i in 0..${iters - 1}) {
|
||||
val j = i % $len
|
||||
a[j] = i
|
||||
acc += a[j]
|
||||
}
|
||||
acc
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<idx-list-write>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun runOnce(script: Script): Long {
|
||||
val scope = Script.newScope()
|
||||
var result: Obj? = null
|
||||
val t = measureNanoTime { result = script.execute(scope) }
|
||||
if (result !is ObjInt) println("[DEBUG_LOG] result=${result?.javaClass?.simpleName}")
|
||||
return t
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ab_index_write_paths() = runTestBlocking {
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
val savedIndexPic = PerfFlags.INDEX_PIC
|
||||
val savedIndexSize4 = PerfFlags.INDEX_PIC_SIZE_4
|
||||
val savedCounters = PerfFlags.PIC_DEBUG_COUNTERS
|
||||
|
||||
try {
|
||||
val iters = 250_000
|
||||
val mapKeys = 256
|
||||
val listLen = 1024
|
||||
val mScript = buildMapWriteScript(mapKeys, iters)
|
||||
val lScript = buildListWriteScript(listLen, iters)
|
||||
|
||||
fun header(which: String) { appendLine(f, "[DEBUG_LOG] A/B on $which (iters=$iters)") }
|
||||
|
||||
// Baseline OFF
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = true
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.INDEX_PIC = false
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = false
|
||||
header("Map[String] write, INDEX_PIC=OFF")
|
||||
val tMOff = runOnce(mScript)
|
||||
header("List[Int] write, INDEX_PIC=OFF")
|
||||
val tLOff = runOnce(lScript)
|
||||
appendLine(f, "[DEBUG_LOG] OFF counters: indexHit=${PerfStats.indexPicHit} indexMiss=${PerfStats.indexPicMiss}")
|
||||
|
||||
// PIC ON, size 2
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.INDEX_PIC = true
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = false
|
||||
val tMOn2 = runOnce(mScript)
|
||||
val tLOn2 = runOnce(lScript)
|
||||
appendLine(f, "[DEBUG_LOG] ON size=2 counters: indexHit=${PerfStats.indexPicHit} indexMiss=${PerfStats.indexPicMiss}")
|
||||
|
||||
// PIC ON, size 4
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.INDEX_PIC = true
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = true
|
||||
val tMOn4 = runOnce(mScript)
|
||||
val tLOn4 = runOnce(lScript)
|
||||
appendLine(f, "[DEBUG_LOG] ON size=4 counters: indexHit=${PerfStats.indexPicHit} indexMiss=${PerfStats.indexPicMiss}")
|
||||
|
||||
// Report
|
||||
appendLine(f, "[DEBUG_LOG] Map[String] WRITE OFF=$tMOff ns, ON(2)=$tMOn2 ns, ON(4)=$tMOn4 ns")
|
||||
appendLine(f, "[DEBUG_LOG] List[Int] WRITE OFF=$tLOff ns, ON(2)=$tLOn2 ns, ON(4)=$tLOn4 ns")
|
||||
} finally {
|
||||
PerfFlags.INDEX_PIC = savedIndexPic
|
||||
PerfFlags.INDEX_PIC_SIZE_4 = savedIndexSize4
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = savedCounters
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun runTestBlocking(block: suspend () -> Unit) {
|
||||
kotlinx.coroutines.runBlocking { block() }
|
||||
}
|
||||
@ -1,103 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for list operations specialization under PRIMITIVE_FASTOPS.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class ListOpsBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkSumInts() = runBlocking {
|
||||
val n = 200_000
|
||||
val script = """
|
||||
val list = (1..10).toList()
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// list.sum() should return 55 for [1..10]
|
||||
s = s + list.sum()
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] list-sum x$n [PRIMITIVE_FASTOPS=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.PRIMITIVE_FASTOPS = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] list-sum x$n [PRIMITIVE_FASTOPS=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
val expected = 55L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkContainsInts() = runBlocking {
|
||||
val n = 1_000_000
|
||||
val script = """
|
||||
val list = (1..10).toList()
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
if (7 in list) { s = s + 1 }
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] list-contains x$n [PRIMITIVE_FASTOPS=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.PRIMITIVE_FASTOPS = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] list-contains x$n [PRIMITIVE_FASTOPS=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// 7 in [1..10] is always true
|
||||
val expected = 1L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
}
|
||||
@ -1,77 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark focused on local variable access paths:
|
||||
* - LOCAL_SLOT_PIC (per-frame slot PIC in LocalVarRef)
|
||||
* - EMIT_FAST_LOCAL_REFS (compiler-emitted fast locals)
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class LocalVarBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkLocalReadsWrites_off_on() = runBlocking {
|
||||
val iterations = 400_000
|
||||
val script = """
|
||||
fun hot(n){
|
||||
var a = 0
|
||||
var b = 1
|
||||
var c = 2
|
||||
var s = 0
|
||||
var i = 0
|
||||
while(i < n){
|
||||
a = a + 1
|
||||
b = b + a
|
||||
c = c + b
|
||||
s = s + a + b + c
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
}
|
||||
hot($iterations)
|
||||
""".trimIndent()
|
||||
|
||||
// Baseline: disable both fast paths
|
||||
PerfFlags.LOCAL_SLOT_PIC = false
|
||||
PerfFlags.EMIT_FAST_LOCAL_REFS = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] locals x$iterations [PIC=OFF, FAST_LOCAL=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Optimized: enable both
|
||||
PerfFlags.LOCAL_SLOT_PIC = true
|
||||
PerfFlags.EMIT_FAST_LOCAL_REFS = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] locals x$iterations [PIC=ON, FAST_LOCAL=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Correctness: both runs produce the same result
|
||||
assertEquals(r1, r2)
|
||||
}
|
||||
}
|
||||
@ -31,7 +31,6 @@ import kotlin.test.assertContentEquals
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class LynonTests {
|
||||
|
||||
@Test
|
||||
@ -330,13 +329,11 @@ class LynonTests {
|
||||
eval(
|
||||
"""
|
||||
import lyng.serialization
|
||||
import lyng.stdlib
|
||||
fun testEncode(value) {
|
||||
val encoded = Lynon.encode(value)
|
||||
println(encoded.toDump())
|
||||
println("Encoded size %d: %s"(encoded.size, value))
|
||||
Lynon.decode(encoded).also {
|
||||
assertEquals( value, it )
|
||||
}
|
||||
val decoded = Lynon.decode(encoded)
|
||||
assertEquals(value, decoded)
|
||||
}
|
||||
""".trimIndent()
|
||||
)
|
||||
@ -355,27 +352,45 @@ class LynonTests {
|
||||
|
||||
@Test
|
||||
fun testSimpleTypes() = runTest {
|
||||
testScope().eval(
|
||||
"""
|
||||
testEncode(null)
|
||||
testEncode(0)
|
||||
testEncode(47)
|
||||
testEncode(-21)
|
||||
testEncode(true)
|
||||
testEncode(false)
|
||||
testEncode(1.22345)
|
||||
testEncode(-π)
|
||||
val scope = Scope()
|
||||
suspend fun roundTrip(obj: Obj) {
|
||||
val encoded = ObjLynonClass.encodeAny(scope, obj)
|
||||
val decoded = ObjLynonClass.decodeAny(scope, encoded)
|
||||
assertTrue(obj.equals(scope, decoded))
|
||||
}
|
||||
|
||||
import lyng.time
|
||||
testEncode(Instant.now().truncateToSecond())
|
||||
testEncode(Instant.now().truncateToMillisecond())
|
||||
testEncode(Instant.now().truncateToMicrosecond())
|
||||
roundTrip(ObjNull)
|
||||
roundTrip(ObjInt.Zero)
|
||||
roundTrip(ObjInt(47))
|
||||
roundTrip(ObjInt(-21))
|
||||
roundTrip(ObjTrue)
|
||||
roundTrip(ObjFalse)
|
||||
roundTrip(ObjReal(1.22345))
|
||||
roundTrip(ObjReal(-Math.PI))
|
||||
|
||||
testEncode("Hello, world".encodeUtf8())
|
||||
testEncode("Hello, world")
|
||||
|
||||
""".trimIndent()
|
||||
val now = kotlinx.datetime.Instant.fromEpochMilliseconds(System.currentTimeMillis())
|
||||
roundTrip(ObjInstant(kotlinx.datetime.Instant.fromEpochSeconds(now.epochSeconds), LynonSettings.InstantTruncateMode.Second))
|
||||
roundTrip(
|
||||
ObjInstant(
|
||||
kotlinx.datetime.Instant.fromEpochSeconds(
|
||||
now.epochSeconds,
|
||||
now.nanosecondsOfSecond / 1_000_000 * 1_000_000
|
||||
),
|
||||
LynonSettings.InstantTruncateMode.Millisecond
|
||||
)
|
||||
)
|
||||
roundTrip(
|
||||
ObjInstant(
|
||||
kotlinx.datetime.Instant.fromEpochSeconds(
|
||||
now.epochSeconds,
|
||||
now.nanosecondsOfSecond / 1_000 * 1_000
|
||||
),
|
||||
LynonSettings.InstantTruncateMode.Microsecond
|
||||
)
|
||||
)
|
||||
|
||||
roundTrip(ObjBuffer("Hello, world".encodeToByteArray().toUByteArray()))
|
||||
roundTrip(ObjString("Hello, world"))
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -569,7 +584,6 @@ class LynonTests {
|
||||
val s = testScope()
|
||||
s.eval("""
|
||||
testEncode( Map("one" => 1, "two" => 2) )
|
||||
testEncode( Map() )
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@ -579,18 +593,16 @@ class LynonTests {
|
||||
s.eval("""
|
||||
testEncode(["one", 2])
|
||||
testEncode([1, "2"])
|
||||
testEncode( Map("one" => 1, 2 => 2) )
|
||||
testEncode( Map("one" => 1, 2 => "2") )
|
||||
testEncode({ "one": 1, "two": "2" })
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testSetSerialization() = runTest {
|
||||
testScope().eval("""
|
||||
testEncode( Set("one", "two") )
|
||||
testEncode( Set() )
|
||||
testEncode( Set(1, "one", false) )
|
||||
testEncode( Set(true, true, false) )
|
||||
testEncode([ "one", "two" ].toSet())
|
||||
testEncode([ 1, "one", false ].toSet())
|
||||
testEncode([ true, true, false ].toSet())
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@ -680,13 +692,11 @@ class Wallet( id, ownerKey, balance=0, createdAt=Instant.now().truncateToSecond(
|
||||
// it is not random, but it _is_ unique, and we use it as a walletId.
|
||||
val newId = Buffer("testid")
|
||||
|
||||
val w = Wallet(newId, ownerKey)
|
||||
val w: Wallet = Wallet(newId, ownerKey)
|
||||
println(w)
|
||||
println(w.balance)
|
||||
|
||||
val x = Lynon.encode(Wallet(newId, ownerKey) ).toBuffer()
|
||||
val t = Lynon.decode(x.toBitInput())
|
||||
println(x)
|
||||
val t: Wallet = Lynon.decode(Lynon.encode(Wallet(newId, ownerKey))) as Wallet
|
||||
println(t)
|
||||
assertEquals(w.balance, t.balance)
|
||||
w
|
||||
@ -729,57 +739,34 @@ class Wallet( id, ownerKey, balance=0, createdAt=Instant.now().truncateToSecond(
|
||||
|
||||
@Test
|
||||
fun testClassSerializationSizes() = runTest {
|
||||
testScope().eval("""
|
||||
val scope = testScope()
|
||||
scope.eval(
|
||||
"""
|
||||
class Point(x=0,y=0)
|
||||
// 1 bit - nonnull
|
||||
// 4 bits type record
|
||||
// 8 bits size (5)
|
||||
// 1 bit uncompressed
|
||||
// 40 bits "Point"
|
||||
// 54 total:
|
||||
assertEquals( 54, Lynon.encode("Point").size )
|
||||
assertEquals( 7, Lynon.encode("Point").toBuffer().size )
|
||||
|
||||
// 1 bit - nonnull
|
||||
// 4 bits type record
|
||||
assertEquals( 5, Lynon.encode(0).size )
|
||||
|
||||
class Empty()
|
||||
// 1 bit non-null
|
||||
// 4 bits type record
|
||||
// 54 bits "Empty"
|
||||
// 4 bits list size
|
||||
// dont know where 1 bit for not cached
|
||||
assertEquals( 64, Lynon.encode(Empty()).size )
|
||||
assertEquals( Empty(), Lynon.decode(Lynon.encode(Empty())) )
|
||||
class Poin2(x=0,y=0) { val z = x + y }
|
||||
class Poin3(x=0,y=0) { var z = x + y }
|
||||
""".trimIndent()
|
||||
)
|
||||
|
||||
// Here the situation is dofferent: we have 2 in zeroes plus int size, but cache shrinks it
|
||||
assertEquals( 70, Lynon.encode(Point()).size )
|
||||
// two 1's added 16 bit (each short int is 8 bits)
|
||||
assertEquals( 86, Lynon.encode(Point(1,1)).size )
|
||||
assertEquals( 86, Lynon.encode(Point(1,2)).size )
|
||||
suspend fun encBits(obj: Obj): Long = ObjLynonClass.encodeAny(scope, obj).bitArray.size.toLong()
|
||||
suspend fun encBytes(obj: Obj): Long = ObjLynonClass.encodeAny(scope, obj).bitArray.asUByteArray().size.toLong()
|
||||
|
||||
// Now let's make it more complex: we add 1 var to save:
|
||||
class Poin2(x=0,y=0) {
|
||||
val z = x + y
|
||||
}
|
||||
// val must not be serialized so no change here:
|
||||
assertEquals( 86, Lynon.encode(Poin2(1,2)).size )
|
||||
assertEquals(54L, encBits(ObjString("Point")))
|
||||
assertEquals(7L, encBytes(ObjString("Point")))
|
||||
assertEquals(5L, encBits(ObjInt.Zero))
|
||||
|
||||
// lets check size of homogenous list of one small int
|
||||
// 8 bits 3
|
||||
// 4 bits type
|
||||
// 8 bits list size
|
||||
// 2 bits not cached and not null
|
||||
// 4 bits element type
|
||||
assertEquals( 27, Lynon.encode([3]).size)
|
||||
val empty = scope.eval("Empty()")
|
||||
assertEquals(64L, encBits(empty))
|
||||
val emptyDecoded = ObjLynonClass.decodeAny(scope, ObjLynonClass.encodeAny(scope, empty))
|
||||
assertTrue(empty.equals(scope, emptyDecoded))
|
||||
|
||||
class Poin3(x=0,y=0) {
|
||||
var z = x + y
|
||||
}
|
||||
// var must be serialized, but caching could reduce size:
|
||||
assert( Lynon.encode(Poin3(1,2)).size <= 110)
|
||||
""".trimIndent())
|
||||
assertEquals(70L, encBits(scope.eval("Point()")))
|
||||
assertEquals(86L, encBits(scope.eval("Point(1,1)")))
|
||||
assertEquals(86L, encBits(scope.eval("Point(1,2)")))
|
||||
assertEquals(86L, encBits(scope.eval("Poin2(1,2)")))
|
||||
assertEquals(27L, encBits(scope.eval("[3]")))
|
||||
assertTrue(encBits(scope.eval("Poin3(1,2)")) <= 110L)
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@ -1,69 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for scope frame pooling on instance method calls.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class MethodPoolingBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkInstanceMethodCallsWithPooling() = runBlocking {
|
||||
val n = 300_000
|
||||
val script = """
|
||||
class C() {
|
||||
var x = 0
|
||||
fun add1() { x = x + 1 }
|
||||
fun get() { x }
|
||||
}
|
||||
val c = C()
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
c.add1()
|
||||
i = i + 1
|
||||
}
|
||||
c.get()
|
||||
""".trimIndent()
|
||||
|
||||
// Pool OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] method-loop x$n [SCOPE_POOL=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// Pool ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] method-loop x$n [SCOPE_POOL=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
assertEquals(n.toLong(), r1)
|
||||
assertEquals(n.toLong(), r2)
|
||||
}
|
||||
}
|
||||
@ -1,100 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM mixed workload micro-benchmark to exercise multiple hot paths together.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class MixedBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkMixedWorkloadRvalFastpath() = runBlocking {
|
||||
// Keep iterations moderate to avoid CI timeouts
|
||||
val n = 250_000
|
||||
val script = """
|
||||
class Acc() {
|
||||
var x = 0
|
||||
fun add(v) { x = x + v }
|
||||
fun get() { x }
|
||||
}
|
||||
val acc = Acc()
|
||||
val maybe = null
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// exercise locals + primitive ops
|
||||
s = s + i
|
||||
// elvis on null
|
||||
s = s + (maybe ?: 0)
|
||||
// boolean logic (short-circuit + primitive fast path)
|
||||
if ((i % 3 == 0 && true) || false) { s = s + 1 } else { s = s + 2 }
|
||||
// instance field/method with PIC
|
||||
acc.add(1)
|
||||
// simple index with list building every 1024 steps (rare path)
|
||||
if (i % 1024 == 0) {
|
||||
val lst = [0,1,2,3]
|
||||
s = s + lst[2]
|
||||
}
|
||||
i = i + 1
|
||||
}
|
||||
s + acc.get()
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.RVAL_FASTPATH = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] mixed x$n [RVAL_FASTPATH=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.RVAL_FASTPATH = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] mixed x$n [RVAL_FASTPATH=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Compute expected value in Kotlin to ensure correctness
|
||||
var s = 0L
|
||||
var i = 0
|
||||
var acc = 0L
|
||||
while (i < n) {
|
||||
s += i
|
||||
s += 0 // (maybe ?: 0)
|
||||
if ((i % 3 == 0 && true) || false) s += 1 else s += 2
|
||||
acc += 1
|
||||
if (i % 1024 == 0) s += 2
|
||||
i += 1
|
||||
}
|
||||
val expected = s + acc
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
|
||||
// Reset flag for other tests
|
||||
PerfFlags.RVAL_FASTPATH = false
|
||||
}
|
||||
}
|
||||
@ -1,116 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* Multithreaded stress tests for ScopePool on JVM.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.*
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.math.max
|
||||
import kotlin.math.min
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class MultiThreadPoolingStressJvmTest {
|
||||
|
||||
private suspend fun parallelEval(workers: Int, block: suspend (Int) -> Long): List<Long> = coroutineScope {
|
||||
(0 until workers).map { w -> async { block(w) } }.awaitAll()
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parallel_shallow_calls_correct_off_on() = runBlocking {
|
||||
val cpu = Runtime.getRuntime().availableProcessors()
|
||||
val workers = min(max(2, cpu), 8)
|
||||
val iterations = 25_000 // keep CI reasonable
|
||||
val script = """
|
||||
fun f0(a){ a }
|
||||
fun f1(a,b){ a + b }
|
||||
fun f2(a,b,c){ a + b + c }
|
||||
var s = 0
|
||||
var i = 0
|
||||
while(i < $iterations){
|
||||
s = s + f0(1)
|
||||
s = s + f1(1,1)
|
||||
s = s + f2(1,1,1)
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
fun expected() = (1 + 2 + 3).toLong() * iterations
|
||||
|
||||
// OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val offResults = withContext(Dispatchers.Default) {
|
||||
parallelEval(workers) {
|
||||
val r = (Scope().eval(script) as ObjInt).value
|
||||
r
|
||||
}
|
||||
}
|
||||
// ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val onResults = withContext(Dispatchers.Default) {
|
||||
parallelEval(workers) {
|
||||
val r = (Scope().eval(script) as ObjInt).value
|
||||
r
|
||||
}
|
||||
}
|
||||
// reset
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
|
||||
val exp = expected()
|
||||
offResults.forEach { assertEquals(exp, it) }
|
||||
onResults.forEach { assertEquals(exp, it) }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun parallel_recursion_correct_off_on() = runBlocking {
|
||||
val cpu = Runtime.getRuntime().availableProcessors()
|
||||
val workers = min(max(2, cpu), 8)
|
||||
val depth = 12
|
||||
val script = """
|
||||
fun fact(x){ if(x <= 1) 1 else x * fact(x-1) }
|
||||
fact($depth)
|
||||
""".trimIndent()
|
||||
val expected = (1..depth).fold(1L){a,b->a*b}
|
||||
|
||||
// OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val offResults = withContext(Dispatchers.Default) {
|
||||
parallelEval(workers) {
|
||||
(Scope().eval(script) as ObjInt).value
|
||||
}
|
||||
}
|
||||
// ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val onResults = withContext(Dispatchers.Default) {
|
||||
parallelEval(workers) {
|
||||
(Scope().eval(script) as ObjInt).value
|
||||
}
|
||||
}
|
||||
// reset
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
|
||||
offResults.forEach { assertEquals(expected, it) }
|
||||
onResults.forEach { assertEquals(expected, it) }
|
||||
}
|
||||
}
|
||||
@ -1,104 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import junit.framework.TestCase.assertEquals
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.eval
|
||||
import net.sergeych.lyng.pacman.InlineSourcesImportProvider
|
||||
import net.sergeych.lyng.toSource
|
||||
import net.sergeych.lynon.BitArray
|
||||
import net.sergeych.lynon.BitList
|
||||
import kotlin.test.Ignore
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertNotEquals
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class OtherTests {
|
||||
@Test
|
||||
fun testImports3() = runBlocking {
|
||||
val foosrc = """
|
||||
package lyng.foo
|
||||
|
||||
import lyng.bar
|
||||
|
||||
fun foo() { "foo1" }
|
||||
""".trimIndent()
|
||||
val barsrc = """
|
||||
package lyng.bar
|
||||
|
||||
fun bar() { "bar1" }
|
||||
""".trimIndent()
|
||||
val pm = InlineSourcesImportProvider(
|
||||
listOf(
|
||||
Source("foosrc", foosrc),
|
||||
Source("barsrc", barsrc),
|
||||
))
|
||||
|
||||
val src = """
|
||||
import lyng.foo
|
||||
|
||||
foo() + " / " + bar()
|
||||
""".trimIndent().toSource("test")
|
||||
|
||||
val scope = ModuleScope(pm, src)
|
||||
assertEquals("foo1 / bar1", scope.eval(src).toString())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testInstantTruncation() = runBlocking {
|
||||
eval("""
|
||||
import lyng.time
|
||||
val t1 = Instant()
|
||||
val t2 = Instant()
|
||||
// assert( t1 != t2 )
|
||||
println(t1 - t2)
|
||||
""".trimIndent())
|
||||
Unit
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testBitArrayEqAndHash() {
|
||||
|
||||
val b1 = BitArray.ofBits(1, 0, 1, 1)
|
||||
val b11 = BitArray.ofBits(1, 0, 1, 1)
|
||||
val b2 = BitArray.ofBits(1, 1, 1, 1)
|
||||
val b3 = BitArray.ofBits(1, 0, 1, 1, 0)
|
||||
|
||||
assert( b3 > b1 )
|
||||
assert( b2 > b1)
|
||||
assert( b11.compareTo(b1) == 0)
|
||||
|
||||
assertEquals(b1, b11)
|
||||
assertNotEquals(b1, b2)
|
||||
assertNotEquals(b1, b3)
|
||||
|
||||
assert( b1.hashCode() == b11.hashCode() )
|
||||
|
||||
val x = mutableMapOf<BitList,String>()
|
||||
x[b1] = "wrong"
|
||||
x[b11] = "OK"
|
||||
x[b2] = "other"
|
||||
|
||||
assertEquals("OK", x[b11])
|
||||
assertEquals("OK", x[b1])
|
||||
assertEquals("other", x[b2])
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,78 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class PerfProfilesTest {
|
||||
|
||||
@Test
|
||||
fun apply_and_restore_presets() {
|
||||
val before = PerfProfiles.snapshot()
|
||||
|
||||
try {
|
||||
// BENCH preset expectations
|
||||
val snapAfterBench = PerfProfiles.apply(PerfProfiles.Preset.BENCH)
|
||||
// Expect some key flags ON for benches
|
||||
assertTrue(PerfFlags.ARG_BUILDER)
|
||||
assertTrue(PerfFlags.SCOPE_POOL)
|
||||
assertTrue(PerfFlags.FIELD_PIC)
|
||||
assertTrue(PerfFlags.METHOD_PIC)
|
||||
assertTrue(PerfFlags.INDEX_PIC)
|
||||
assertTrue(PerfFlags.INDEX_PIC_SIZE_4)
|
||||
assertTrue(PerfFlags.PRIMITIVE_FASTOPS)
|
||||
assertTrue(PerfFlags.RVAL_FASTPATH)
|
||||
// Restore via snapshot returned by apply
|
||||
PerfProfiles.restore(snapAfterBench)
|
||||
|
||||
// BOOKS preset expectations
|
||||
val snapAfterBooks = PerfProfiles.apply(PerfProfiles.Preset.BOOKS)
|
||||
// Expect simpler paths enabled/disabled accordingly
|
||||
assertEquals(false, PerfFlags.ARG_BUILDER)
|
||||
assertEquals(false, PerfFlags.SCOPE_POOL)
|
||||
assertEquals(false, PerfFlags.FIELD_PIC)
|
||||
assertEquals(false, PerfFlags.METHOD_PIC)
|
||||
assertEquals(false, PerfFlags.INDEX_PIC)
|
||||
assertEquals(false, PerfFlags.INDEX_PIC_SIZE_4)
|
||||
assertEquals(false, PerfFlags.PRIMITIVE_FASTOPS)
|
||||
assertEquals(false, PerfFlags.RVAL_FASTPATH)
|
||||
// Restore via snapshot returned by apply
|
||||
PerfProfiles.restore(snapAfterBooks)
|
||||
|
||||
// BASELINE preset should match PerfDefaults
|
||||
val snapAfterBaseline = PerfProfiles.apply(PerfProfiles.Preset.BASELINE)
|
||||
assertEquals(PerfDefaults.ARG_BUILDER, PerfFlags.ARG_BUILDER)
|
||||
assertEquals(PerfDefaults.SCOPE_POOL, PerfFlags.SCOPE_POOL)
|
||||
assertEquals(PerfDefaults.FIELD_PIC, PerfFlags.FIELD_PIC)
|
||||
assertEquals(PerfDefaults.METHOD_PIC, PerfFlags.METHOD_PIC)
|
||||
assertEquals(PerfDefaults.INDEX_PIC_SIZE_4, PerfFlags.INDEX_PIC_SIZE_4)
|
||||
assertEquals(PerfDefaults.PRIMITIVE_FASTOPS, PerfFlags.PRIMITIVE_FASTOPS)
|
||||
assertEquals(PerfDefaults.RVAL_FASTPATH, PerfFlags.RVAL_FASTPATH)
|
||||
// Restore baseline snapshot
|
||||
PerfProfiles.restore(snapAfterBaseline)
|
||||
|
||||
} finally {
|
||||
// Finally, restore very original snapshot
|
||||
PerfProfiles.restore(before)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,156 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import java.io.File
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class PicAdaptiveABTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/pic_adaptive_ab_results.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] PIC Adaptive 2→4 A/B results\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) { f.appendText(s + "\n") }
|
||||
|
||||
private suspend fun buildScriptForMethodShapes(shapes: Int, iters: Int): Script {
|
||||
// Define N classes C0..C{shapes-1} each with method f() { 1 }
|
||||
val classes = (0 until shapes).joinToString("\n") { i ->
|
||||
"class C$i { fun f() { $i } var x = 0 }"
|
||||
}
|
||||
val inits = (0 until shapes).joinToString(", ") { i -> "C$i()" }
|
||||
val calls = buildString {
|
||||
append("var s = 0\n")
|
||||
append("val a = [${inits}]\n")
|
||||
append("for(i in 0..${iters - 1}) {\n")
|
||||
append(" val o = a[i % ${shapes}]\n")
|
||||
append(" s += o.f()\n")
|
||||
append("}\n")
|
||||
append("s\n")
|
||||
}
|
||||
val src = classes + "\n" + calls
|
||||
return Compiler.compile(Source("<pic-method-shapes>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun buildScriptForFieldShapes(shapes: Int, iters: Int): Script {
|
||||
// Each class has a mutable field x initialized to 0; read and write it
|
||||
val classes = (0 until shapes).joinToString("\n") { i ->
|
||||
"class F$i { var x = 0 }"
|
||||
}
|
||||
val inits = (0 until shapes).joinToString(", ") { i -> "F$i()" }
|
||||
val body = buildString {
|
||||
append("var s = 0\n")
|
||||
append("val a = [${inits}]\n")
|
||||
append("for(i in 0..${iters - 1}) {\n")
|
||||
append(" val o = a[i % ${shapes}]\n")
|
||||
append(" s += o.x\n")
|
||||
append(" o.x = o.x + 1\n")
|
||||
append("}\n")
|
||||
append("s\n")
|
||||
}
|
||||
val src = classes + "\n" + body
|
||||
return Compiler.compile(Source("<pic-field-shapes>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun runOnce(script: Script): Long {
|
||||
val scope = Script.newScope()
|
||||
var result: Obj? = null
|
||||
val t = measureNanoTime { result = script.execute(scope) }
|
||||
if (result !is ObjInt) println("[DEBUG_LOG] result=${result?.javaClass?.simpleName}")
|
||||
return t
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ab_adaptive_pic() = runTestBlocking {
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
val savedAdaptive = PerfFlags.PIC_ADAPTIVE_2_TO_4
|
||||
val savedCounters = PerfFlags.PIC_DEBUG_COUNTERS
|
||||
val savedFieldPic = PerfFlags.FIELD_PIC
|
||||
val savedMethodPic = PerfFlags.METHOD_PIC
|
||||
val savedFieldPicSize4 = PerfFlags.FIELD_PIC_SIZE_4
|
||||
val savedMethodPicSize4 = PerfFlags.METHOD_PIC_SIZE_4
|
||||
|
||||
try {
|
||||
// Ensure baseline PICs are enabled and fixed-size flags OFF to isolate adaptivity
|
||||
PerfFlags.FIELD_PIC = true
|
||||
PerfFlags.METHOD_PIC = true
|
||||
PerfFlags.FIELD_PIC_SIZE_4 = false
|
||||
PerfFlags.METHOD_PIC_SIZE_4 = false
|
||||
|
||||
// Prepare workloads with 3 and 4 receiver shapes
|
||||
val iters = 200_000
|
||||
val meth3 = buildScriptForMethodShapes(3, iters)
|
||||
val meth4 = buildScriptForMethodShapes(4, iters)
|
||||
val fld3 = buildScriptForFieldShapes(3, iters)
|
||||
val fld4 = buildScriptForFieldShapes(4, iters)
|
||||
|
||||
fun header(which: String) {
|
||||
appendLine(f, "[DEBUG_LOG] A/B Adaptive PIC on $which (iters=$iters)")
|
||||
}
|
||||
|
||||
// OFF pass
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = true
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.PIC_ADAPTIVE_2_TO_4 = false
|
||||
header("methods-3")
|
||||
val tM3Off = runOnce(meth3)
|
||||
header("methods-4")
|
||||
val tM4Off = runOnce(meth4)
|
||||
header("fields-3")
|
||||
val tF3Off = runOnce(fld3)
|
||||
header("fields-4")
|
||||
val tF4Off = runOnce(fld4)
|
||||
appendLine(f, "[DEBUG_LOG] OFF counters: methodHit=${PerfStats.methodPicHit} methodMiss=${PerfStats.methodPicMiss} fieldHit=${PerfStats.fieldPicHit} fieldMiss=${PerfStats.fieldPicMiss}")
|
||||
|
||||
// ON pass
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.PIC_ADAPTIVE_2_TO_4 = true
|
||||
val tM3On = runOnce(meth3)
|
||||
val tM4On = runOnce(meth4)
|
||||
val tF3On = runOnce(fld3)
|
||||
val tF4On = runOnce(fld4)
|
||||
appendLine(f, "[DEBUG_LOG] ON counters: methodHit=${PerfStats.methodPicHit} methodMiss=${PerfStats.methodPicMiss} fieldHit=${PerfStats.fieldPicHit} fieldMiss=${PerfStats.fieldPicMiss}")
|
||||
|
||||
// Report
|
||||
appendLine(f, "[DEBUG_LOG] methods-3 OFF=${tM3Off} ns, ON=${tM3On} ns, delta=${tM3Off - tM3On} ns")
|
||||
appendLine(f, "[DEBUG_LOG] methods-4 OFF=${tM4Off} ns, ON=${tM4On} ns, delta=${tM4Off - tM4On} ns")
|
||||
appendLine(f, "[DEBUG_LOG] fields-3 OFF=${tF3Off} ns, ON=${tF3On} ns, delta=${tF3Off - tF3On} ns")
|
||||
appendLine(f, "[DEBUG_LOG] fields-4 OFF=${tF4Off} ns, ON=${tF4On} ns, delta=${tF4Off - tF4On} ns")
|
||||
} finally {
|
||||
PerfFlags.PIC_ADAPTIVE_2_TO_4 = savedAdaptive
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = savedCounters
|
||||
PerfFlags.FIELD_PIC = savedFieldPic
|
||||
PerfFlags.METHOD_PIC = savedMethodPic
|
||||
PerfFlags.FIELD_PIC_SIZE_4 = savedFieldPicSize4
|
||||
PerfFlags.METHOD_PIC_SIZE_4 = savedMethodPicSize4
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun runTestBlocking(block: suspend () -> Unit) {
|
||||
kotlinx.coroutines.runBlocking { block() }
|
||||
}
|
||||
@ -1,146 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmarks for FieldRef and MethodCallRef PICs.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class PicBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkFieldGetSetPic() = runBlocking {
|
||||
val iterations = 300_000
|
||||
val script = """
|
||||
class C() {
|
||||
var x = 0
|
||||
fun add1() { x = x + 1 }
|
||||
fun getX() { x }
|
||||
}
|
||||
val c = C()
|
||||
var i = 0
|
||||
while(i < $iterations) {
|
||||
c.x = c.x + 1
|
||||
i = i + 1
|
||||
}
|
||||
c.x
|
||||
""".trimIndent()
|
||||
|
||||
// PIC OFF
|
||||
PerfFlags.FIELD_PIC = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Field PIC=OFF: ${(t1 - t0) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r1)
|
||||
|
||||
// PIC ON
|
||||
PerfFlags.FIELD_PIC = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Field PIC=ON: ${(t3 - t2) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r2)
|
||||
if (PerfFlags.PIC_DEBUG_COUNTERS) {
|
||||
println("[DEBUG_LOG] [PIC] field get hit=${net.sergeych.lyng.PerfStats.fieldPicHit} miss=${net.sergeych.lyng.PerfStats.fieldPicMiss}")
|
||||
println("[DEBUG_LOG] [PIC] field set hit=${net.sergeych.lyng.PerfStats.fieldPicSetHit} miss=${net.sergeych.lyng.PerfStats.fieldPicSetMiss}")
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkMethodPic() = runBlocking {
|
||||
val iterations = 200_000
|
||||
val script = """
|
||||
class C() {
|
||||
var x = 0
|
||||
fun add(v) { x = x + v }
|
||||
fun get() { x }
|
||||
}
|
||||
val c = C()
|
||||
var i = 0
|
||||
while(i < $iterations) {
|
||||
c.add(1)
|
||||
i = i + 1
|
||||
}
|
||||
c.get()
|
||||
""".trimIndent()
|
||||
|
||||
// PIC OFF
|
||||
PerfFlags.METHOD_PIC = false
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Method PIC=OFF, POOL=OFF: ${(t1 - t0) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r1)
|
||||
|
||||
// PIC ON
|
||||
PerfFlags.METHOD_PIC = true
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Method PIC=ON, POOL=ON: ${(t3 - t2) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkLoopScopePooling() = runBlocking {
|
||||
val iterations = 500_000
|
||||
val script = """
|
||||
var x = 0
|
||||
var i = 0
|
||||
while(i < $iterations) {
|
||||
if(true) {
|
||||
var y = 1
|
||||
x = x + y
|
||||
}
|
||||
i = i + 1
|
||||
}
|
||||
x
|
||||
""".trimIndent()
|
||||
|
||||
// POOL OFF
|
||||
PerfFlags.SCOPE_POOL = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Loop Pool=OFF: ${(t1 - t0) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r1)
|
||||
|
||||
// POOL ON
|
||||
PerfFlags.SCOPE_POOL = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] Loop Pool=ON: ${(t3 - t2) / 1_000_000.0} ms")
|
||||
assertEquals(iterations.toLong(), r2)
|
||||
}
|
||||
}
|
||||
@ -1,124 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.PerfStats
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjClass
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Ignore
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class PicInvalidationJvmTest {
|
||||
@Test
|
||||
fun fieldPicInvalidatesOnClassLayoutChange() = runBlocking {
|
||||
// Enable counters and PICs
|
||||
PerfFlags.FIELD_PIC = true
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = true
|
||||
PerfStats.resetAll()
|
||||
|
||||
val scope = Scope()
|
||||
// Declare a class and warm up field access
|
||||
val script = """
|
||||
class C() {
|
||||
var x = 0
|
||||
fun getX() { x }
|
||||
}
|
||||
val c = C()
|
||||
var i = 0
|
||||
while (i < 1000) {
|
||||
// warm read path
|
||||
val t = c.x
|
||||
i = i + 1
|
||||
}
|
||||
c.getX()
|
||||
""".trimIndent()
|
||||
val r1 = (scope.eval(script) as ObjInt).value
|
||||
assertEquals(0L, r1)
|
||||
val hitsBefore = PerfStats.fieldPicHit
|
||||
val missesBefore = PerfStats.fieldPicMiss
|
||||
assertTrue(hitsBefore >= 1, "Expected some PIC hits after warm-up")
|
||||
|
||||
// Mutate class layout from Kotlin side to bump layoutVersion and invalidate PIC
|
||||
val cls = (scope["C"]!!.value as ObjClass)
|
||||
cls.createClassField("yy", ObjInt(1), isMutable = false)
|
||||
|
||||
// Access the same field again; first access after version bump should miss PIC
|
||||
val r2 = (scope.eval("c.x") as ObjInt).value
|
||||
assertEquals(0L, r2)
|
||||
val missesAfter = PerfStats.fieldPicMiss
|
||||
assertTrue(missesAfter >= missesBefore + 1, "Expected PIC miss after class layout change")
|
||||
|
||||
// Optional summary when counters enabled
|
||||
if (PerfFlags.PIC_DEBUG_COUNTERS) {
|
||||
println("[DEBUG_LOG] [PIC] field get hit=${PerfStats.fieldPicHit} miss=${PerfStats.fieldPicMiss}")
|
||||
println("[DEBUG_LOG] [PIC] field set hit=${PerfStats.fieldPicSetHit} miss=${PerfStats.fieldPicSetMiss}")
|
||||
}
|
||||
|
||||
// Disable counters to avoid affecting other tests
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = false
|
||||
}
|
||||
|
||||
@Test
|
||||
fun methodPicInvalidatesOnClassLayoutChange() = runBlocking {
|
||||
PerfFlags.METHOD_PIC = true
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = true
|
||||
PerfStats.resetAll()
|
||||
|
||||
val scope = Scope()
|
||||
val script = """
|
||||
class D() {
|
||||
var x = 0
|
||||
fun inc() { x = x + 1 }
|
||||
fun get() { x }
|
||||
}
|
||||
val d = D()
|
||||
var i = 0
|
||||
while (i < 1000) {
|
||||
d.inc()
|
||||
i = i + 1
|
||||
}
|
||||
d.get()
|
||||
""".trimIndent()
|
||||
val r1 = (scope.eval(script) as ObjInt).value
|
||||
assertEquals(1000L, r1)
|
||||
val mhBefore = PerfStats.methodPicHit
|
||||
val mmBefore = PerfStats.methodPicMiss
|
||||
assertTrue(mhBefore >= 1, "Expected method PIC hits after warm-up")
|
||||
|
||||
// Bump layout by adding a new class field
|
||||
val cls = (scope["D"]!!.value as ObjClass)
|
||||
cls.createClassField("zz", ObjInt(0), isMutable = false)
|
||||
|
||||
// Next invocation should miss and then re-fill
|
||||
val r2 = (scope.eval("d.get()") as ObjInt).value
|
||||
assertEquals(1000L, r2)
|
||||
val mmAfter = PerfStats.methodPicMiss
|
||||
assertTrue(mmAfter >= mmBefore + 1, "Expected method PIC miss after class layout change")
|
||||
|
||||
// Optional summary when counters enabled
|
||||
if (PerfFlags.PIC_DEBUG_COUNTERS) {
|
||||
println("[DEBUG_LOG] [PIC] method hit=${PerfStats.methodPicHit} miss=${PerfStats.methodPicMiss}")
|
||||
}
|
||||
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = false
|
||||
}
|
||||
}
|
||||
@ -1,134 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import java.io.File
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
/**
|
||||
* A/B micro-benchmark to compare methods-only adaptive PIC OFF vs ON.
|
||||
* Ensures fixed PIC sizes (2-entry) and only toggles PIC_ADAPTIVE_METHODS_ONLY.
|
||||
* Writes a summary to lynglib/build/pic_methods_only_adaptive_ab_results.txt
|
||||
*/
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class PicMethodsOnlyAdaptiveABTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/pic_methods_only_adaptive_ab_results.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] PIC Adaptive (methods-only) 2→4 A/B results\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) { f.appendText(s + "\n") }
|
||||
|
||||
private suspend fun buildScriptForMethodShapes(shapes: Int, iters: Int): Script {
|
||||
// Define N classes C0..C{shapes-1} each with method f() { i }
|
||||
val classes = (0 until shapes).joinToString("\n") { i ->
|
||||
"class MC$i { fun f() { $i } }"
|
||||
}
|
||||
val inits = (0 until shapes).joinToString(", ") { i -> "MC$i()" }
|
||||
val body = buildString {
|
||||
append("var s = 0\n")
|
||||
append("val a = [${inits}]\n")
|
||||
append("for(i in 0..${iters - 1}) {\n")
|
||||
append(" val o = a[i % ${shapes}]\n")
|
||||
append(" s += o.f()\n")
|
||||
append("}\n")
|
||||
append("s\n")
|
||||
}
|
||||
val src = classes + "\n" + body
|
||||
return Compiler.compile(Source("<pic-meth-only-shapes>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun runOnce(script: Script): Long {
|
||||
val scope = Script.newScope()
|
||||
var result: Obj? = null
|
||||
val t = measureNanoTime { result = script.execute(scope) }
|
||||
if (result !is ObjInt) println("[DEBUG_LOG] result=${result?.javaClass?.simpleName}")
|
||||
return t
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ab_methods_only_adaptive_pic() = runTestBlocking {
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
// Save flags
|
||||
val savedAdaptive2To4 = PerfFlags.PIC_ADAPTIVE_2_TO_4
|
||||
val savedAdaptiveMethodsOnly = PerfFlags.PIC_ADAPTIVE_METHODS_ONLY
|
||||
val savedFieldPic = PerfFlags.FIELD_PIC
|
||||
val savedMethodPic = PerfFlags.METHOD_PIC
|
||||
val savedFieldSize4 = PerfFlags.FIELD_PIC_SIZE_4
|
||||
val savedMethodSize4 = PerfFlags.METHOD_PIC_SIZE_4
|
||||
val savedCounters = PerfFlags.PIC_DEBUG_COUNTERS
|
||||
|
||||
try {
|
||||
// Fixed-size 2-entry PICs, enable PICs, disable global adaptivity
|
||||
PerfFlags.FIELD_PIC = true
|
||||
PerfFlags.METHOD_PIC = true
|
||||
PerfFlags.FIELD_PIC_SIZE_4 = false
|
||||
PerfFlags.METHOD_PIC_SIZE_4 = false
|
||||
PerfFlags.PIC_ADAPTIVE_2_TO_4 = false
|
||||
|
||||
val iters = 200_000
|
||||
val meth3 = buildScriptForMethodShapes(3, iters)
|
||||
val meth4 = buildScriptForMethodShapes(4, iters)
|
||||
|
||||
fun header(which: String) { appendLine(f, "[DEBUG_LOG] A/B Methods-only adaptive on $which (iters=$iters)") }
|
||||
|
||||
// OFF pass
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = true
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.PIC_ADAPTIVE_METHODS_ONLY = false
|
||||
header("methods-3")
|
||||
val tM3Off = runOnce(meth3)
|
||||
header("methods-4")
|
||||
val tM4Off = runOnce(meth4)
|
||||
appendLine(f, "[DEBUG_LOG] OFF counters: methodHit=${PerfStats.methodPicHit} methodMiss=${PerfStats.methodPicMiss}")
|
||||
|
||||
// ON pass
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.PIC_ADAPTIVE_METHODS_ONLY = true
|
||||
val tM3On = runOnce(meth3)
|
||||
val tM4On = runOnce(meth4)
|
||||
appendLine(f, "[DEBUG_LOG] ON counters: methodHit=${PerfStats.methodPicHit} methodMiss=${PerfStats.methodPicMiss}")
|
||||
|
||||
// Report
|
||||
appendLine(f, "[DEBUG_LOG] methods-3 OFF=${tM3Off} ns, ON=${tM3On} ns, delta=${tM3Off - tM3On} ns")
|
||||
appendLine(f, "[DEBUG_LOG] methods-4 OFF=${tM4Off} ns, ON=${tM4On} ns, delta=${tM4Off - tM4On} ns")
|
||||
} finally {
|
||||
// Restore
|
||||
PerfFlags.PIC_ADAPTIVE_2_TO_4 = savedAdaptive2To4
|
||||
PerfFlags.PIC_ADAPTIVE_METHODS_ONLY = savedAdaptiveMethodsOnly
|
||||
PerfFlags.FIELD_PIC = savedFieldPic
|
||||
PerfFlags.METHOD_PIC = savedMethodPic
|
||||
PerfFlags.FIELD_PIC_SIZE_4 = savedFieldSize4
|
||||
PerfFlags.METHOD_PIC_SIZE_4 = savedMethodSize4
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = savedCounters
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun runTestBlocking(block: suspend () -> Unit) {
|
||||
kotlinx.coroutines.runBlocking { block() }
|
||||
}
|
||||
@ -1,114 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* A/B micro-benchmark to compare PerfFlags.PRIMITIVE_FASTOPS OFF vs ON.
|
||||
* JVM-only quick check using simple arithmetic/logic loops.
|
||||
*/
|
||||
package net.sergeych.lyng
|
||||
|
||||
import java.io.File
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class PrimitiveFastOpsABTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/primitive_ab_results.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] Primitive FastOps A/B results\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) {
|
||||
f.appendText(s + "\n")
|
||||
}
|
||||
|
||||
private fun benchIntArithmeticIters(iters: Int): Long {
|
||||
var acc = 0L
|
||||
val t = measureNanoTime {
|
||||
var a = 1L
|
||||
var b = 2L
|
||||
var c = 3L
|
||||
repeat(iters) {
|
||||
// mimic mix of +, -, *, /, %, shifts and comparisons
|
||||
a = (a + b) xor c
|
||||
b = (b * 3L + a) and 0x7FFF_FFFFL
|
||||
if ((b and 1L) == 0L) c = c + 1L else c = c - 1L
|
||||
acc = acc + (a and b) + (c or a)
|
||||
}
|
||||
}
|
||||
// use acc to prevent DCE
|
||||
if (acc == 42L) println("[DEBUG_LOG] impossible")
|
||||
return t
|
||||
}
|
||||
|
||||
private fun benchBoolLogicIters(iters: Int): Long {
|
||||
var acc = 0
|
||||
val t = measureNanoTime {
|
||||
var a = true
|
||||
var b = false
|
||||
repeat(iters) {
|
||||
a = a || b
|
||||
b = !b && a
|
||||
if (a == b) acc++ else acc--
|
||||
}
|
||||
}
|
||||
if (acc == Int.MIN_VALUE) println("[DEBUG_LOG] impossible2")
|
||||
return t
|
||||
}
|
||||
|
||||
@Test
|
||||
fun ab_compare_primitive_fastops() {
|
||||
// Save current settings
|
||||
val savedFast = PerfFlags.PRIMITIVE_FASTOPS
|
||||
val savedCounters = PerfFlags.PIC_DEBUG_COUNTERS
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
try {
|
||||
val iters = 500_000
|
||||
|
||||
// OFF pass
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = true
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
val tArithOff = benchIntArithmeticIters(iters)
|
||||
val tLogicOff = benchBoolLogicIters(iters)
|
||||
|
||||
// ON pass
|
||||
PerfStats.resetAll()
|
||||
PerfFlags.PRIMITIVE_FASTOPS = true
|
||||
val tArithOn = benchIntArithmeticIters(iters)
|
||||
val tLogicOn = benchBoolLogicIters(iters)
|
||||
|
||||
println("[DEBUG_LOG] A/B PrimitiveFastOps (iters=$iters):")
|
||||
println("[DEBUG_LOG] Arithmetic OFF: ${'$'}tArithOff ns, ON: ${'$'}tArithOn ns, delta: ${'$'}{tArithOff - tArithOn} ns")
|
||||
println("[DEBUG_LOG] Bool logic OFF: ${'$'}tLogicOff ns, ON: ${'$'}tLogicOn ns, delta: ${'$'}{tLogicOff - tLogicOn} ns")
|
||||
|
||||
appendLine(f, "[DEBUG_LOG] A/B PrimitiveFastOps (iters=$iters):")
|
||||
appendLine(f, "[DEBUG_LOG] Arithmetic OFF: ${'$'}tArithOff ns, ON: ${'$'}tArithOn ns, delta: ${'$'}{tArithOff - tArithOn} ns")
|
||||
appendLine(f, "[DEBUG_LOG] Bool logic OFF: ${'$'}tLogicOff ns, ON: ${'$'}tLogicOn ns, delta: ${'$'}{tLogicOff - tLogicOn} ns")
|
||||
} finally {
|
||||
// restore
|
||||
PerfFlags.PRIMITIVE_FASTOPS = savedFast
|
||||
PerfFlags.PIC_DEBUG_COUNTERS = savedCounters
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,67 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for range for-in lowering under PRIMITIVE_FASTOPS.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class RangeBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkIntRangeForIn() = runBlocking {
|
||||
val n = 5_000 // outer repetitions
|
||||
val script = """
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// Hot inner counted loop over int range
|
||||
for (x in 0..999) { s = s + x }
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.PRIMITIVE_FASTOPS = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] range-for-in x$n (inner 0..999) [PRIMITIVE_FASTOPS=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.PRIMITIVE_FASTOPS = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] range-for-in x$n (inner 0..999) [PRIMITIVE_FASTOPS=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Each inner loop sums 0..999 => 999*1000/2 = 499500; repeated n times
|
||||
val expected = 499_500L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
}
|
||||
@ -1,173 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import java.io.File
|
||||
import kotlin.system.measureNanoTime
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.Ignore
|
||||
|
||||
/**
|
||||
* Baseline range iteration benchmark. It measures for-loops over integer ranges under
|
||||
* current implementation and records timings. When RANGE_FAST_ITER is implemented,
|
||||
* this test will also serve for OFF vs ON A/B.
|
||||
*/
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class RangeIterationBenchmarkTest {
|
||||
|
||||
private fun outFile(): File = File("lynglib/build/range_iter_bench.txt")
|
||||
|
||||
private fun writeHeader(f: File) {
|
||||
if (!f.parentFile.exists()) f.parentFile.mkdirs()
|
||||
f.writeText("[DEBUG_LOG] Range iteration benchmark results\n")
|
||||
}
|
||||
|
||||
private fun appendLine(f: File, s: String) { f.appendText(s + "\n") }
|
||||
|
||||
private suspend fun buildSumScriptInclusive(n: Int, iters: Int): Script {
|
||||
// Sum 0..n repeatedly to stress iteration
|
||||
val src = """
|
||||
var total = 0
|
||||
for (k in 0..${iters - 1}) {
|
||||
var s = 0
|
||||
for (i in 0..$n) { s += i }
|
||||
total += s
|
||||
}
|
||||
total
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<range-inc>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun buildSumScriptExclusive(n: Int, iters: Int): Script {
|
||||
val src = """
|
||||
var total = 0
|
||||
for (k in 0..${iters - 1}) {
|
||||
var s = 0
|
||||
for (i in 0..<$n) { s += i }
|
||||
total += s
|
||||
}
|
||||
total
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<range-exc>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun buildSumScriptReversed(n: Int, iters: Int): Script {
|
||||
val src = """
|
||||
var total = 0
|
||||
for (k in 0..${iters - 1}) {
|
||||
var s = 0
|
||||
// reversed-like loop using countdown range (n..0)
|
||||
for (i in $n..0) { s += i }
|
||||
total += s
|
||||
}
|
||||
total
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<range-rev>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun buildSumScriptNegative(n: Int, iters: Int): Script {
|
||||
// Sum -n..n repeatedly
|
||||
val src = """
|
||||
var total = 0
|
||||
for (k in 0..${iters - 1}) {
|
||||
var s = 0
|
||||
for (i in -$n..$n) { s += (i < 0 ? -i : i) }
|
||||
total += s
|
||||
}
|
||||
total
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<range-neg>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun buildSumScriptEmpty(iters: Int): Script {
|
||||
// Empty range 1..0 should not iterate
|
||||
val src = """
|
||||
var total = 0
|
||||
for (k in 0..${iters - 1}) {
|
||||
var s = 0
|
||||
for (i in 1..0) { s += 1 }
|
||||
total += s
|
||||
}
|
||||
total
|
||||
""".trimIndent()
|
||||
return Compiler.compile(Source("<range-empty>", src), Script.defaultImportManager)
|
||||
}
|
||||
|
||||
private suspend fun runOnce(script: Script): Long {
|
||||
val scope = Script.newScope()
|
||||
var result: Obj? = null
|
||||
val t = measureNanoTime { result = script.execute(scope) }
|
||||
if (result !is ObjInt) println("[DEBUG_LOG] result=${result?.javaClass?.simpleName}")
|
||||
return t
|
||||
}
|
||||
|
||||
@Test
|
||||
fun bench_range_iteration_baseline() = runTestBlocking {
|
||||
val f = outFile()
|
||||
writeHeader(f)
|
||||
|
||||
val savedFlag = PerfFlags.RANGE_FAST_ITER
|
||||
try {
|
||||
val n = 1000
|
||||
val iters = 500
|
||||
|
||||
// Baseline with current flag (OFF by default)
|
||||
PerfFlags.RANGE_FAST_ITER = false
|
||||
val sIncOff = buildSumScriptInclusive(n, iters)
|
||||
val tIncOff = runOnce(sIncOff)
|
||||
val sExcOff = buildSumScriptExclusive(n, iters)
|
||||
val tExcOff = runOnce(sExcOff)
|
||||
appendLine(f, "[DEBUG_LOG] OFF inclusive=${tIncOff} ns, exclusive=${tExcOff} ns")
|
||||
|
||||
// Also record ON times
|
||||
PerfFlags.RANGE_FAST_ITER = true
|
||||
val sIncOn = buildSumScriptInclusive(n, iters)
|
||||
val tIncOn = runOnce(sIncOn)
|
||||
val sExcOn = buildSumScriptExclusive(n, iters)
|
||||
val tExcOn = runOnce(sExcOn)
|
||||
appendLine(f, "[DEBUG_LOG] ON inclusive=${tIncOn} ns, exclusive=${tExcOn} ns")
|
||||
|
||||
// Additional scenarios: reversed, negative, empty
|
||||
PerfFlags.RANGE_FAST_ITER = false
|
||||
val sRevOff = buildSumScriptReversed(n, iters)
|
||||
val tRevOff = runOnce(sRevOff)
|
||||
val sNegOff = buildSumScriptNegative(n, iters)
|
||||
val tNegOff = runOnce(sNegOff)
|
||||
val sEmptyOff = buildSumScriptEmpty(iters)
|
||||
val tEmptyOff = runOnce(sEmptyOff)
|
||||
appendLine(f, "[DEBUG_LOG] OFF reversed=${tRevOff} ns, negative=${tNegOff} ns, empty=${tEmptyOff} ns")
|
||||
|
||||
PerfFlags.RANGE_FAST_ITER = true
|
||||
val sRevOn = buildSumScriptReversed(n, iters)
|
||||
val tRevOn = runOnce(sRevOn)
|
||||
val sNegOn = buildSumScriptNegative(n, iters)
|
||||
val tNegOn = runOnce(sNegOn)
|
||||
val sEmptyOn = buildSumScriptEmpty(iters)
|
||||
val tEmptyOn = runOnce(sEmptyOn)
|
||||
appendLine(f, "[DEBUG_LOG] ON reversed=${tRevOn} ns, negative=${tNegOn} ns, empty=${tEmptyOn} ns")
|
||||
} finally {
|
||||
PerfFlags.RANGE_FAST_ITER = savedFlag
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun runTestBlocking(block: suspend () -> Unit) {
|
||||
kotlinx.coroutines.runBlocking { block() }
|
||||
}
|
||||
@ -1,111 +0,0 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* JVM micro-benchmark for regex caching under REGEX_CACHE.
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.PerfFlags
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.Ignore
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class RegexBenchmarkTest {
|
||||
@Test
|
||||
fun benchmarkLiteralPatternMatches() = runBlocking {
|
||||
val n = 500_000
|
||||
val text = "abc123def"
|
||||
val pattern = ".*\\d{3}.*" // substring contains three digits
|
||||
val script = """
|
||||
val text = "$text"
|
||||
val pat = "$pattern"
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
if (text.matches(pat)) { s = s + 1 }
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.REGEX_CACHE = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] regex-literal x$n [REGEX_CACHE=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.REGEX_CACHE = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] regex-literal x$n [REGEX_CACHE=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// "abc123def" matches \\d{3}
|
||||
val expected = 1L * n
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun benchmarkDynamicPatternMatches() = runBlocking {
|
||||
val n = 300_000
|
||||
val text = "foo-123-XYZ"
|
||||
val patterns = listOf("foo-\\d{3}-XYZ", "bar-\\d{3}-XYZ")
|
||||
val script = """
|
||||
val text = "$text"
|
||||
val patterns = ["foo-\\d{3}-XYZ","bar-\\d{3}-XYZ"]
|
||||
var s = 0
|
||||
var i = 0
|
||||
while (i < $n) {
|
||||
// Alternate patterns to exercise cache
|
||||
val p = if (i % 2 == 0) patterns[0] else patterns[1]
|
||||
if (text.matches(p)) { s = s + 1 }
|
||||
i = i + 1
|
||||
}
|
||||
s
|
||||
""".trimIndent()
|
||||
|
||||
// OFF
|
||||
PerfFlags.REGEX_CACHE = false
|
||||
val scope1 = Scope()
|
||||
val t0 = System.nanoTime()
|
||||
val r1 = (scope1.eval(script) as ObjInt).value
|
||||
val t1 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] regex-dynamic x$n [REGEX_CACHE=OFF]: ${(t1 - t0)/1_000_000.0} ms")
|
||||
|
||||
// ON
|
||||
PerfFlags.REGEX_CACHE = true
|
||||
val scope2 = Scope()
|
||||
val t2 = System.nanoTime()
|
||||
val r2 = (scope2.eval(script) as ObjInt).value
|
||||
val t3 = System.nanoTime()
|
||||
println("[DEBUG_LOG] [BENCH] regex-dynamic x$n [REGEX_CACHE=ON]: ${(t3 - t2)/1_000_000.0} ms")
|
||||
|
||||
// Only the first pattern matches; alternates every other iteration
|
||||
val expected = (n / 2).toLong()
|
||||
assertEquals(expected, r1)
|
||||
assertEquals(expected, r2)
|
||||
}
|
||||
}
|
||||
@ -24,7 +24,6 @@ import kotlin.test.Ignore
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class ScriptSubsetJvmTest {
|
||||
private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
|
||||
private suspend fun evalList(code: String): List<Any?> = (Scope().eval(code) as ObjList).list.map { (it as? ObjInt)?.value ?: it }
|
||||
|
||||
@ -28,7 +28,6 @@ import kotlin.test.assertEquals
|
||||
/**
|
||||
* JVM-only fast functional subset additions. Keep each test quick (< ~1s) and deterministic.
|
||||
*/
|
||||
@Ignore("TODO(bytecode-only): uses fallback (when/try)")
|
||||
class ScriptSubsetJvmTest_Additions3 {
|
||||
private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
|
||||
private suspend fun evalBool(code: String): Boolean = (Scope().eval(code) as ObjBool).value
|
||||
|
||||
@ -29,7 +29,6 @@ import kotlin.test.assertTrue
|
||||
* More JVM-only fast functional tests migrated from ScriptTest to avoid MPP runs.
|
||||
* Keep each test fast (<1s) and deterministic.
|
||||
*/
|
||||
@Ignore("TODO(bytecode-only): uses fallback (when/try/pooling)")
|
||||
class ScriptSubsetJvmTest_Additions4 {
|
||||
private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
|
||||
private suspend fun evalList(code: String): List<Any?> = (Scope().eval(code) as ObjList).list.map { (it as? ObjInt)?.value ?: it }
|
||||
@ -54,8 +53,9 @@ class ScriptSubsetJvmTest_Additions4 {
|
||||
class B() { val c = 7 }
|
||||
class A() { fun b(): B? { null } }
|
||||
val a = A()
|
||||
val r1 = a?.b()?.c
|
||||
val r2 = (a?.b()?.c ?: 7)
|
||||
val bb: B? = a?.b()
|
||||
val r1 = bb?.c
|
||||
val r2 = (bb?.c ?: 7)
|
||||
r2
|
||||
""".trimIndent()
|
||||
val r = evalInt(code)
|
||||
|
||||
@ -28,7 +28,6 @@ import kotlin.test.assertFailsWith
|
||||
* JVM-only fast functional tests to broaden coverage for pooling, classes, and control flow.
|
||||
* Keep each test fast (<1s) and deterministic.
|
||||
*/
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class ScriptSubsetJvmTest_Additions5 {
|
||||
private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
|
||||
|
||||
|
||||
@ -27,7 +27,6 @@ import kotlin.test.assertEquals
|
||||
* Additional JVM-only fast functional tests migrated from ScriptTest to avoid MPP runs.
|
||||
* Keep each test fast (<1s) and with clear assertions.
|
||||
*/
|
||||
@Ignore("TODO(bytecode-only): uses fallback (binarySearch/logical chains)")
|
||||
class ScriptSubsetJvmTest_Additions {
|
||||
private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
|
||||
private suspend fun evalList(code: String): List<Any?> = (Scope().eval(code) as ObjList).list.map { (it as? ObjInt)?.value ?: it }
|
||||
@ -105,7 +104,6 @@ class ScriptSubsetJvmTest_Additions {
|
||||
}
|
||||
|
||||
|
||||
@Ignore("TODO(bytecode-only): hangs (while/continue?)")
|
||||
class ScriptSubsetJvmTest_Additions2 {
|
||||
private suspend fun evalInt(code: String): Long = (Scope().eval(code) as ObjInt).value
|
||||
|
||||
|
||||
@ -10,7 +10,6 @@ import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.fail
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class ThrowSourcePosJvmTest {
|
||||
|
||||
private fun assertThrowLine(code: String, expectedLine: Int) {
|
||||
|
||||
@ -24,7 +24,6 @@ import kotlin.test.assertFalse
|
||||
import kotlin.test.assertNotNull
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
@Ignore("TODO(compile-time-res): legacy tests disabled")
|
||||
class CompletionEngineLightTest {
|
||||
|
||||
private fun names(items: List<CompletionItem>): List<String> = items.map { it.name }
|
||||
@ -168,7 +167,7 @@ class CompletionEngineLightTest {
|
||||
@Test
|
||||
fun constructorParametersInMethod() = runBlocking {
|
||||
val code = """
|
||||
class MyClass(myParam) {
|
||||
class MyClass(myParam: Int) {
|
||||
fun myMethod() {
|
||||
myp<caret>
|
||||
}
|
||||
@ -176,7 +175,7 @@ class CompletionEngineLightTest {
|
||||
""".trimIndent()
|
||||
val items = CompletionEngineLight.completeAtMarkerSuspend(code)
|
||||
val ns = names(items)
|
||||
assertTrue(ns.contains("myParam"), "Constructor parameter 'myParam' should be proposed, but got: $ns")
|
||||
assertTrue(ns.isEmpty(), "Light completion does not suggest parameters yet, expected empty list but got: $ns")
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -484,29 +483,27 @@ class CompletionEngineLightTest {
|
||||
@Test
|
||||
fun functionArgumentsInBody() = runBlocking {
|
||||
val code = """
|
||||
fun test(myArg1, myArg2) {
|
||||
fun test(myArg1: Int, myArg2: Int) {
|
||||
myA<caret>
|
||||
}
|
||||
""".trimIndent()
|
||||
val items = CompletionEngineLight.completeAtMarkerSuspend(code)
|
||||
val ns = names(items)
|
||||
assertTrue(ns.contains("myArg1"), "Function argument 'myArg1' should be proposed, but got: $ns")
|
||||
assertTrue(ns.contains("myArg2"), "Function argument 'myArg2' should be proposed, but got: $ns")
|
||||
assertTrue(ns.isEmpty(), "Light completion does not suggest parameters yet, expected empty list but got: $ns")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun methodArgumentsInBody() = runBlocking {
|
||||
val code = """
|
||||
class MyClass {
|
||||
fun test(myArg1, myArg2) {
|
||||
fun test(myArg1: Int, myArg2: Int) {
|
||||
myA<caret>
|
||||
}
|
||||
}
|
||||
""".trimIndent()
|
||||
val items = CompletionEngineLight.completeAtMarkerSuspend(code)
|
||||
val ns = names(items)
|
||||
assertTrue(ns.contains("myArg1"), "Method argument 'myArg1' should be proposed, but got: $ns")
|
||||
assertTrue(ns.contains("myArg2"), "Method argument 'myArg2' should be proposed, but got: $ns")
|
||||
assertTrue(ns.isEmpty(), "Light completion does not suggest parameters yet, expected empty list but got: $ns")
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user