Add cache for TaintConfigurationProvider

Author: mmvpm

gradle.properties

@@ -60,8 +60,9 @@ kryoSerializersVersion=0.45
 asmVersion=9.2
 testNgVersion=7.6.0
 mockitoInlineVersion=4.0.0
-kamlVersion = 0.51.0
-jacksonVersion = 2.12.3
+kamlVersion=0.51.0
+jacksonVersion=2.12.3
+kotlinxSerializationVersion=1.5.0
 slf4jVersion=1.7.36
 eclipseAetherVersion=1.1.0
 mavenWagonVersion=3.5.1

utbot-framework/build.gradle

@@ -1,3 +1,7 @@
+plugins {
+    id 'org.jetbrains.kotlin.plugin.serialization' version '1.7.20'
+}
+
 dependencies {
 
     api project(':utbot-fuzzers')
@@ -19,6 +23,7 @@ dependencies {
 
     implementation group: 'com.charleskorn.kaml', name: 'kaml', version: kamlVersion
     implementation group: 'com.fasterxml.jackson.module', name: 'jackson-module-kotlin', version: jacksonVersion
+    implementation group: 'org.jetbrains.kotlinx', name: 'kotlinx-serialization-cbor', version: kotlinxSerializationVersion
     implementation group: 'com.github.curious-odd-man', name: 'rgxgen', version: rgxgenVersion
     implementation group: 'org.apache.logging.log4j', name: 'log4j-slf4j-impl', version: log4j2Version
     implementation group: 'io.github.microutils', name: 'kotlin-logging', version: kotlinLoggingVersion

utbot-framework/src/main/kotlin/org/utbot/engine/UtBotSymbolicEngine.kt

@@ -145,12 +145,8 @@ class UtBotSymbolicEngine(
     private val taintMarkRegistry: TaintMarkRegistry = TaintMarkRegistry()
     private val taintMarkManager: TaintMarkManager = TaintMarkManager(taintMarkRegistry)
 
-    private val taintConfigProvider: TaintConfigurationProvider = TaintConfigurationProviderCombiner(listOf(
-        TaintConfigurationProviderUserRules(taintUserConfigPath ?: ""),
-        TaintConfigurationProviderResources("taint/config.yaml")
-    ))
     private val taintConfiguration: TaintConfiguration = if (UtSettings.useTaintAnalysis)
-        taintConfigProvider.getConfiguration()
+        constructDefaultProvider(taintUserConfigPath).getConfiguration()
     else
         TaintConfiguration() // empty
 

utbot-framework/src/main/kotlin/org/utbot/taint/TaintConfigurationProvider.kt

@@ -1,13 +1,30 @@
 package org.utbot.taint
 
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.cbor.Cbor
+import kotlinx.serialization.decodeFromByteArray
+import kotlinx.serialization.encodeToByteArray
 import org.utbot.common.PathUtil.toPath
+import org.utbot.common.utBotTempDirectory
 import org.utbot.taint.model.TaintConfiguration
 import org.utbot.taint.parser.TaintYamlParser
+import java.io.File
 
 /**
  * Provide the [TaintConfiguration].
  */
 interface TaintConfigurationProvider {
+
+    /**
+     * Returns the time that the configuration was last modified.
+     *
+     * Uses the same format as the [java.io.File.lastModified].
+     */
+    fun lastModified(): Long
+
+    /**
+     * Provides [TaintConfiguration].
+     */
     fun getConfiguration(): TaintConfiguration
 }
 
@@ -17,6 +34,12 @@ interface TaintConfigurationProvider {
  * @param configPath relative path to the .yaml file in resources
  */
 class TaintConfigurationProviderResources(private val configPath: String) : TaintConfigurationProvider {
+
+    override fun lastModified(): Long {
+        val selfJarFile = File(javaClass.protectionDomain.codeSource.location.toURI().path)
+        return selfJarFile.lastModified()
+    }
+
     override fun getConfiguration(): TaintConfiguration {
         val configUrl = javaClass.classLoader.getResource(configPath)
             ?: return TaintConfiguration()
@@ -32,6 +55,15 @@ class TaintConfigurationProviderResources(private val configPath: String) : Tain
  * @param configPath relative path to the .yaml file in the user's project.
  */
 class TaintConfigurationProviderUserRules(private val configPath: String) : TaintConfigurationProvider {
+
+    override fun lastModified(): Long {
+        val configFile = configPath.toPath().toFile()
+        if (!configFile.exists()) {
+            return 0
+        }
+        return configFile.lastModified()
+    }
+
     override fun getConfiguration(): TaintConfiguration {
         val configFile = configPath.toPath().toFile()
         if (!configFile.exists()) {
@@ -43,11 +75,64 @@ class TaintConfigurationProviderUserRules(private val configPath: String) : Tain
     }
 }
 
+/**
+ * Combines taint configurations from several providers.
+ */
 class TaintConfigurationProviderCombiner(private val inners: List<TaintConfigurationProvider>) : TaintConfigurationProvider {
+
+    override fun lastModified(): Long {
+        return inners.maxOf { it.lastModified() }
+    }
+
     override fun getConfiguration(): TaintConfiguration =
         inners.fold(TaintConfiguration()) { resultConfig, configProvider ->
             resultConfig + configProvider.getConfiguration()
         }
 }
 
-// TODO: TaintConfigurationProviderCached -- stores binary config to the temp directory
+/**
+ * Stores binary configuration file to the utbot temp directory to reduce parsing time in the future.
+ *
+ * @param nameSuffix the cached file will have "-$nameSuffix" suffix
+ * @param inner provider to cache
+ */
+class TaintConfigurationProviderCached(
+    nameSuffix: String,
+    private val inner: TaintConfigurationProvider,
+) : TaintConfigurationProvider {
+
+    private val cachedConfigName = "taint-config-cached-$nameSuffix"
+
+    private val cachedConfigFile = utBotTempDirectory.resolve(cachedConfigName).toFile()
+
+    override fun lastModified(): Long {
+        return cachedConfigFile.lastModified()
+    }
+
+    @OptIn(ExperimentalSerializationApi::class)
+    override fun getConfiguration(): TaintConfiguration =
+        if (!cachedConfigFile.exists() || cachedConfigFile.lastModified() < inner.lastModified()) {
+            val config = inner.getConfiguration()
+            val bytes = Cbor.encodeToByteArray(config)
+            cachedConfigFile.writeBytes(bytes)
+            config
+        } else {
+            val bytes = cachedConfigFile.readBytes()
+            Cbor.decodeFromByteArray(bytes)
+        }
+}
+
+fun constructDefaultProvider(
+    taintUserConfigPath: String?,
+    taintResourcesConfigPath: String = "taint/config.yaml"
+): TaintConfigurationProvider {
+    val resourcesConfig = TaintConfigurationProviderResources(taintResourcesConfigPath)
+    val cachedResourcesConfig = TaintConfigurationProviderCached("resources", resourcesConfig)
+
+    val cachedUserConfigOrNull = taintUserConfigPath?.let {
+        val userConfig = TaintConfigurationProviderUserRules(taintUserConfigPath)
+        TaintConfigurationProviderCached("user", userConfig)
+    }
+
+    return TaintConfigurationProviderCombiner(listOfNotNull(cachedUserConfigOrNull, cachedResourcesConfig))
+}

utbot-framework/src/main/kotlin/org/utbot/taint/model/DataClasses.kt

@@ -1,41 +1,45 @@
 package org.utbot.taint.model
 
+import kotlinx.serialization.Serializable
+
 // Data classes corresponding to the parsed data transfer objects.
 // See [org.utbot.taint.parser.model] for more details.
 
+@Serializable
 data class MethodFqn(
     val packageNames: List<String>,
     val className: String,
     val methodName: String
 )
 
+@Serializable
 sealed interface TaintEntities {
     val entities: Collection<TaintEntity>
 }
-data class TaintEntitiesSet(override val entities: Set<TaintEntity>) : TaintEntities
+@Serializable data class TaintEntitiesSet(override val entities: Set<TaintEntity>) : TaintEntities
 
-sealed interface TaintMarks
-object TaintMarksAll : TaintMarks
-data class TaintMarksSet(val marks: Set<TaintMark>) : TaintMarks
+@Serializable sealed interface TaintMarks
+@Serializable object TaintMarksAll : TaintMarks
+@Serializable data class TaintMarksSet(val marks: Set<TaintMark>) : TaintMarks
 
-sealed interface TaintEntity
-object TaintEntityThis : TaintEntity
-object TaintEntityReturn : TaintEntity
-data class TaintEntityArgument(/** one-based */ val index: UInt) : TaintEntity
+@Serializable sealed interface TaintEntity
+@Serializable object TaintEntityThis : TaintEntity
+@Serializable object TaintEntityReturn : TaintEntity
+@Serializable data class TaintEntityArgument(/** one-based */ val index: UInt) : TaintEntity
 
-data class TaintMark(val name: String)
+@Serializable  data class TaintMark(val name: String)
 
-sealed interface ArgumentValue
-object ArgumentValueNull : ArgumentValue
-data class ArgumentValueBoolean(val value: Boolean) : ArgumentValue
-data class ArgumentValueLong(val value: Long) : ArgumentValue
-data class ArgumentValueDouble(val value: Double) : ArgumentValue
-data class ArgumentValueString(val value: String) : ArgumentValue
+@Serializable sealed interface ArgumentValue
+@Serializable object ArgumentValueNull : ArgumentValue
+@Serializable data class ArgumentValueBoolean(val value: Boolean) : ArgumentValue
+@Serializable data class ArgumentValueLong(val value: Long) : ArgumentValue
+@Serializable data class ArgumentValueDouble(val value: Double) : ArgumentValue
+@Serializable data class ArgumentValueString(val value: String) : ArgumentValue
 
-sealed interface ArgumentType
-object ArgumentTypeAny : ArgumentType
-data class ArgumentTypeString(val typeFqn: String) : ArgumentType
+@Serializable sealed interface ArgumentType
+@Serializable object ArgumentTypeAny : ArgumentType
+@Serializable data class ArgumentTypeString(val typeFqn: String) : ArgumentType
 
-sealed interface TaintSignature
-object TaintSignatureAny : TaintSignature
-data class TaintSignatureList(val argumentTypes: List<ArgumentType>) : TaintSignature
+@Serializable sealed interface TaintSignature
+@Serializable object TaintSignatureAny : TaintSignature
+@Serializable data class TaintSignatureList(val argumentTypes: List<ArgumentType>) : TaintSignature

utbot-framework/src/main/kotlin/org/utbot/taint/model/TaintCondition.kt

@@ -1,19 +1,22 @@
 package org.utbot.taint.model
 
+import kotlinx.serialization.Serializable
 import org.utbot.engine.*
 import org.utbot.engine.pc.*
 import soot.Scene
 
 /**
  * Condition that imposed on the taint rule. It must be met to trigger the rule.
  */
-interface TaintCondition {
+@Serializable
+sealed interface TaintCondition {
     fun toBoolExpr(traverser: Traverser, methodData: SymbolicMethodData): UtBoolExpression
 }
 
 /**
  * Returns always true.
  */
+@Serializable
 object ConditionTrue : TaintCondition {
     override fun toBoolExpr(traverser: Traverser, methodData: SymbolicMethodData): UtBoolExpression =
         UtTrue
@@ -22,6 +25,7 @@ object ConditionTrue : TaintCondition {
 /**
  * The [entity] must be equal to [argumentValue].
  */
+@Serializable
 class ConditionEqualValue(
     private val entity: TaintEntity,
     private val argumentValue: ArgumentValue
@@ -67,6 +71,7 @@ class ConditionEqualValue(
 /**
  * The [entity] must be [argumentType] at the runtime.
  */
+@Serializable
 class ConditionIsType(
     private val entity: TaintEntity,
     private val argumentType: ArgumentType
@@ -100,6 +105,7 @@ class ConditionIsType(
 /**
  * Negates [inner].
  */
+@Serializable
 class ConditionNot(private val inner: TaintCondition) : TaintCondition {
     override fun toBoolExpr(traverser: Traverser, methodData: SymbolicMethodData): UtBoolExpression =
         mkNot(inner.toBoolExpr(traverser, methodData))
@@ -108,6 +114,7 @@ class ConditionNot(private val inner: TaintCondition) : TaintCondition {
 /**
  * Combines [inners] with `or` operator.
  */
+@Serializable
 class ConditionOr(private val inners: List<TaintCondition>) : TaintCondition {
     override fun toBoolExpr(traverser: Traverser, methodData: SymbolicMethodData): UtBoolExpression =
         mkOr(inners.map { it.toBoolExpr(traverser, methodData) })
@@ -116,6 +123,7 @@ class ConditionOr(private val inners: List<TaintCondition>) : TaintCondition {
 /**
  * Combines [inners] with `and` operator.
  */
+@Serializable
 class ConditionAnd(private val inners: List<TaintCondition>) : TaintCondition {
     override fun toBoolExpr(traverser: Traverser, methodData: SymbolicMethodData): UtBoolExpression =
         mkAnd(inners.map { it.toBoolExpr(traverser, methodData) })

utbot-framework/src/main/kotlin/org/utbot/taint/model/TaintConfiguration.kt

@@ -1,11 +1,13 @@
 package org.utbot.taint.model
 
+import kotlinx.serialization.Serializable
 import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.ExecutableId
 
 /**
  * Storage for all taint rules.
  */
+@Serializable
 data class TaintConfiguration(
     private val sources: List<TaintSource> = listOf(),
     private val passes: List<TaintPass> = listOf(),
@@ -77,6 +79,7 @@ data class TaintConfiguration(
  * @param signature list of argument types (at compile time)
  * @param condition condition that must be met to trigger this rule
  */
+@Serializable
 data class TaintSource(
     val methodFqn: MethodFqn,
     val addTo: TaintEntities,
@@ -93,6 +96,7 @@ data class TaintSource(
  * @param signature list of argument types (at compile time)
  * @param condition condition that must be met to trigger this rule
  */
+@Serializable
 data class TaintPass(
     val methodFqn: MethodFqn,
     val getFrom: TaintEntities,
@@ -109,6 +113,7 @@ data class TaintPass(
  * @param signature list of argument types (at compile time)
  * @param condition condition that must be met to trigger this rule
  */
+@Serializable
 data class TaintCleaner(
     val methodFqn: MethodFqn,
     val removeFrom: TaintEntities,
@@ -125,6 +130,7 @@ data class TaintCleaner(
  * @param signature list of argument types (at compile time)
  * @param condition condition that must be met to trigger this rule
  */
+@Serializable
 data class TaintSink(
     val methodFqn: MethodFqn,
     val check: TaintEntities,