Add runner

Author: Parzival-05

usvm-ml-gameserver/src/main/kotlin/org.usvm/gameserver/ModelRunner.kt

@@ -0,0 +1,142 @@
+package org.usvm
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.usvm.gameserver.GameMap
+import org.usvm.gameserver.GameOver
+import org.usvm.gameserver.GameState
+import org.usvm.gameserver.Searcher
+import org.usvm.gameserver.serialization.createGameState
+import org.usvm.runner.JavaMethodRunner
+import org.usvm.runner.defaultOptions
+import org.usvm.statistics.BasicBlock
+import org.usvm.utils.AIGameStep
+import org.usvm.utils.Mode
+import org.usvm.utils.OnnxModelImpl
+import java.io.File
+import java.net.Socket
+import java.nio.file.Paths
+import kotlin.math.floor
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.DurationUnit
+
+@Serializable
+data class AIGameStepSerializable(
+    @SerialName("GameState") val GameState: GameState, @SerialName("Output") val NNOutput: Array<FloatArray>
+) {
+    // autogenerated
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as AIGameStepSerializable
+
+        if (GameState != other.GameState) return false
+        if (!NNOutput.contentDeepEquals(other.NNOutput)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = GameState.hashCode()
+        result = 31 * result + NNOutput.contentDeepHashCode()
+        return result
+    }
+}
+
+fun sendModelRunner(
+    port: Int,
+    stepsToPlay: Int,
+    stepsToStart: Int,
+    defaultSearcher: Searcher,
+    assemblyFullName: String,
+    nameOfObjectToCover: String,
+    mapName: String,
+    outFolder: String,
+    model: String,
+    useGPU: Boolean
+) {
+    val gameMap = GameMap(
+        stepsToPlay = stepsToPlay.toUInt(),
+        stepsToStart = stepsToStart.toUInt(),
+        defaultSearcher = defaultSearcher,
+        assemblyFullName = assemblyFullName,
+        nameOfObjectToCover = nameOfObjectToCover,
+        mapName = mapName
+    )
+
+    val (gameOver, gameSteps) = sendModelExplorer(model, if (useGPU) Mode.GPU else Mode.CPU, gameMap)
+    println("Running for ${gameMap.mapName} finished with coverage ${gameOver.percent}, tests ${gameOver.test}, steps ${gameOver.stepsCount}, errors ${gameOver.error}.")
+
+    // lets save the results
+    val directory = File(outFolder)
+    if (!directory.exists()) {
+        directory.mkdirs()
+    }
+    val serializedGameOver = "${gameOver.percent} ${gameOver.test} ${gameOver.stepsCount} ${gameOver.error}"
+    val outFile = Paths.get(outFolder, "${gameMap.mapName}result")
+    File(outFile.toString()).writeText(serializedGameOver)
+
+    // send steps to the client if needed
+    val needToSendSteps = Socket("localhost", port).let { socket ->
+        val inputStream = socket.getInputStream()
+        val buffer = ByteArray(1)
+        val bytesRead = inputStream.read(buffer)
+        if (bytesRead == -1) {
+            throw RuntimeException("No data received from port=$port")
+        }
+        buffer[0].toInt() != 0
+    }
+
+    if (!needToSendSteps) {
+        return
+    }
+    val stepsFile = Paths.get(outFolder, "${gameMap.mapName}_steps")
+    val gameStepsString = Json { }.encodeToString(gameSteps)
+    File(stepsFile.toString()).writeText(gameStepsString)
+}
+
+
+fun sendModelExplorer(
+    model: String,
+    mode: Mode,
+    gameMap: GameMap,
+): Pair<GameOver, ArrayList<AIGameStepSerializable>> {
+    val steps = ArrayList<AIGameStepSerializable>()
+    fun <Block : BasicBlock> saveStep(aiGameStep: AIGameStep<Block>) {
+        val gameState = createGameState(aiGameStep.Game)
+        val gameStep = AIGameStepSerializable(gameState.copy(), aiGameStep.NNOutput)
+        steps.add(gameStep)
+    }
+
+    val runner = JavaMethodRunner(
+        defaultOptions.copy(
+            oracle = OnnxModelImpl(
+                model,
+                mode,
+                true,
+                ::saveStep,
+            ),
+            stepLimit = (gameMap.stepsToPlay + gameMap.stepsToStart).toULong(),
+            timeout = (30 * 60).seconds,
+            stepsToStart = (gameMap.stepsToPlay + gameMap.stepsToStart)
+        ),
+        classpath = gameMap.assemblyFullName,
+    )
+
+    val (results, percentageCoverage) = runner.cover(gameMap.nameOfObjectToCover)
+    val errors = results.count { it.isExceptional }
+    val tests = results.size - errors
+
+    return Pair(
+        GameOver(
+            floor(percentageCoverage).toUInt(),
+            test = tests.toUInt(),
+            stepsCount = gameMap.stepsToStart + gameMap.stepsToPlay, // TODO: send the actual step count
+            error = errors.toUInt()
+        ), steps
+    )
+}