NRL stress testing

src/jvm/main/org/jetbrains/kotlinx/lincheck/Actor.kt

@@ -33,7 +33,7 @@ import kotlin.reflect.jvm.*
  */
 data class Actor @JvmOverloads constructor(
     val method: Method,
-    val arguments: List<Any?>,
+    val arguments: MutableList<Any?>,
     val handledExceptions: List<Class<out Throwable>> = emptyList(),
     val cancelOnSuspension: Boolean = false,
     val allowExtraSuspension: Boolean = false,
@@ -42,7 +42,8 @@ data class Actor @JvmOverloads constructor(
     val promptCancellation: Boolean = false,
     // we have to specify `isSuspendable` property explicitly for transformed classes since
     // `isSuspendable` implementation produces a circular dependency and, therefore, fails.
-    val isSuspendable: Boolean = method.isSuspendable()
+    val isSuspendable: Boolean = method.isSuspendable(),
+    val threadIdArgsIndices: List<Int> = emptyList()
 ) {
     init {
         if (promptCancellation) require(cancelOnSuspension) {
@@ -57,6 +58,8 @@ data class Actor @JvmOverloads constructor(
         (if (cancelOnSuspension) "cancel" else "")
 
     val handlesExceptions = handledExceptions.isNotEmpty()
+
+    fun setThreadId(threadId: Int) = threadIdArgsIndices.forEach { index -> arguments[index] = threadId }
 }
 
 fun Method.isSuspendable(): Boolean = kotlinFunction?.isSuspend ?: false

src/jvm/main/org/jetbrains/kotlinx/lincheck/CTestConfiguration.kt

@@ -71,7 +71,8 @@ internal fun createFromTestClassAnnotations(testClass: Class<*>): List<CTestConf
                 ann.threads, ann.actorsPerThread, ann.actorsBefore, ann.actorsAfter,
                 ann.generator.java, ann.verifier.java, ann.invocationsPerIteration,
                 ann.requireStateEquivalenceImplCheck, ann.minimizeFailedScenario,
-                chooseSequentialSpecification(ann.sequentialSpecification.java, testClass), DEFAULT_TIMEOUT_MS
+                chooseSequentialSpecification(ann.sequentialSpecification.java, testClass), DEFAULT_TIMEOUT_MS,
+                ann.addCrashes
             )
         }
     val modelCheckingConfigurations: List<CTestConfiguration> = testClass.getAnnotationsByType(ModelCheckingCTest::class.java)

src/jvm/main/org/jetbrains/kotlinx/lincheck/LinChecker.kt

@@ -24,7 +24,9 @@ package org.jetbrains.kotlinx.lincheck
 import org.jetbrains.kotlinx.lincheck.CTestConfiguration.*
 import org.jetbrains.kotlinx.lincheck.annotations.*
 import org.jetbrains.kotlinx.lincheck.execution.*
+import org.jetbrains.kotlinx.lincheck.nvm.Probability
 import org.jetbrains.kotlinx.lincheck.strategy.*
+import org.jetbrains.kotlinx.lincheck.strategy.stress.StressCTestConfiguration
 import org.jetbrains.kotlinx.lincheck.verifier.*
 import kotlin.reflect.*
 
@@ -93,11 +95,15 @@ class LinChecker (private val testClass: Class<*>, options: Options<*, *>?) {
             for (j in scenario.parallelExecution[i].indices) {
                 val newScenario = scenario.copy()
                 newScenario.parallelExecution[i].removeAt(j)
-                if (newScenario.parallelExecution[i].isEmpty()) newScenario.parallelExecution.removeAt(i) // remove empty thread
+                if (newScenario.parallelExecution[i].isEmpty()) {
+                    newScenario.parallelExecution.removeAt(i) // remove empty thread
+                    newScenario.setThreadIds()
+                }
                 val newFailedIteration = newScenario.tryMinimize(testCfg, verifier)
                 if (newFailedIteration != null) return newFailedIteration.minimize(testCfg, verifier)
             }
         }
+        scenario.setThreadIds() // reset thread ids after parallel minimization
         for (i in scenario.initExecution.indices) {
             val newScenario = scenario.copy()
             newScenario.initExecution.removeAt(i)
@@ -110,9 +116,35 @@ class LinChecker (private val testClass: Class<*>, options: Options<*, *>?) {
             val newFailedIteration = newScenario.tryMinimize(testCfg, verifier)
             if (newFailedIteration != null) return newFailedIteration.minimize(testCfg, verifier)
         }
+        if (testCfg is StressCTestConfiguration && testCfg.addCrashes && this is IncorrectResultsFailure)
+            return minimizeCrashes(testCfg, verifier).also { Probability.expectedCrashes = 10 }
         return this
     }
 
+    private fun IncorrectResultsFailure.crashesNumber() = results.crashes.sumBy { it.size }
+
+    private fun IncorrectResultsFailure.minimizeCrashes(
+        testCfg: CTestConfiguration,
+        verifier: Verifier
+    ): LincheckFailure {
+        Probability.expectedCrashes--
+        val currentCrashesNumber = crashesNumber()
+        repeat(100) {
+            val newIteration = scenario.tryMinimize(testCfg, verifier)
+            if (newIteration != null
+                && newIteration is IncorrectResultsFailure
+                && newIteration.crashesNumber() < currentCrashesNumber
+            ) return newIteration.minimizeCrashes(testCfg, verifier)
+        }
+        return this
+    }
+
+    private fun List<Actor>.setThreadId(threadId: Int) = forEach { actor -> actor.setThreadId(threadId) }
+    private fun ExecutionScenario.setThreadIds() {
+        parallelExecution.forEachIndexed { index, actors -> actors.setThreadId(index + 1) }
+        postExecution.setThreadId(parallelExecution.size + 1)
+    }
+
     private fun ExecutionScenario.tryMinimize(testCfg: CTestConfiguration, verifier: Verifier) =
         if (isValid) run(testCfg, verifier) else null
 

src/jvm/main/org/jetbrains/kotlinx/lincheck/Reporter.kt

@@ -24,6 +24,7 @@ package org.jetbrains.kotlinx.lincheck
 
 import org.jetbrains.kotlinx.lincheck.LoggingLevel.*
 import org.jetbrains.kotlinx.lincheck.execution.*
+import org.jetbrains.kotlinx.lincheck.nvm.CrashError
 import org.jetbrains.kotlinx.lincheck.runner.*
 import org.jetbrains.kotlinx.lincheck.strategy.*
 import org.jetbrains.kotlinx.lincheck.strategy.managed.*
@@ -178,13 +179,17 @@ private fun StringBuilder.appendDeadlockWithDumpFailure(failure: DeadlockWithDum
     for ((t, stackTrace) in failure.threadDump) {
         val threadNumber = if (t is FixedActiveThreadsExecutor.TestThread) t.iThread.toString() else "?"
         appendLine("Thread-$threadNumber:")
-        stackTrace.map {
-            StackTraceElement(it.className.removePrefix(TransformationClassLoader.REMAPPED_PACKAGE_CANONICAL_NAME), it.methodName, it.fileName, it.lineNumber)
-        }.forEach { appendLine("\t$it") }
+        appendStackTrace(stackTrace)
     }
     return this
 }
 
+private fun StringBuilder.appendStackTrace(stackTrace: Array<StackTraceElement>) {
+    stackTrace.map {
+        StackTraceElement(it.className.removePrefix(TransformationClassLoader.REMAPPED_PACKAGE_CANONICAL_NAME), it.methodName, it.fileName, it.lineNumber)
+    }.forEach { appendLine("\t$it") }
+}
+
 private fun StringBuilder.appendIncorrectResultsFailure(failure: IncorrectResultsFailure): StringBuilder {
     appendln("= Invalid execution results =")
     if (failure.scenario.initExecution.isNotEmpty()) {
@@ -212,6 +217,16 @@ private fun StringBuilder.appendIncorrectResultsFailure(failure: IncorrectResult
     if (failure.results.parallelResultsWithClock.flatten().any { !it.clockOnStart.empty })
         appendln("\n---\nvalues in \"[..]\" brackets indicate the number of completed operations \n" +
             "in each of the parallel threads seen at the beginning of the current operation\n---")
+    failure.results.crashes.forEachIndexed { threadId, threadCrashes ->
+        if (threadCrashes.isNotEmpty()) {
+            appendLine("\nCrashes on thread $threadId:")
+            threadCrashes.forEach { crash ->
+                val actor = if (crash.actorIndex == -1) "constructor" else "actor ${1 + crash.actorIndex}"
+                appendLine("Crashed inside $actor:")
+                appendCrash(crash)
+            }
+        }
+    }
     return this
 }
 
@@ -232,4 +247,8 @@ private fun StringBuilder.appendException(t: Throwable) {
     val sw = StringWriter()
     t.printStackTrace(PrintWriter(sw))
     appendln(sw.toString())
-}
+}
+
+private fun StringBuilder.appendCrash(crash: CrashError) {
+    appendStackTrace(crash.stackTrace)
+}

src/jvm/main/org/jetbrains/kotlinx/lincheck/Utils.kt

@@ -232,7 +232,7 @@ internal fun ExecutionScenario.convertForLoader(loader: ClassLoader) = Execution
     initExecution,
     parallelExecution.map { actors ->
         actors.map { a ->
-            val args = a.arguments.map { it.convertForLoader(loader) }
+            val args = a.arguments.map { it.convertForLoader(loader) }.toMutableList()
             // the original `isSuspendable` is used here since `KFunction.isSuspend` fails on transformed classes
             Actor(
                 method = a.method.convertForLoader(loader),
@@ -243,7 +243,8 @@ internal fun ExecutionScenario.convertForLoader(loader: ClassLoader) = Execution
                 blocking = a.blocking,
                 causesBlocking = a.causesBlocking,
                 promptCancellation = a.promptCancellation,
-                isSuspendable = a.isSuspendable
+                isSuspendable = a.isSuspendable,
+                threadIdArgsIndices = a.threadIdArgsIndices
             )
         }
     },

src/jvm/main/org/jetbrains/kotlinx/lincheck/annotations/CrashFree.kt

@@ -0,0 +1,26 @@
+/*-
+ * #%L
+ * Lincheck
+ * %%
+ * Copyright (C) 2019 - 2020 JetBrains s.r.o.
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-3.0.html>.
+ * #L%
+ */
+package org.jetbrains.kotlinx.lincheck.annotations
+
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.CLASS)
+annotation class CrashFree

src/jvm/main/org/jetbrains/kotlinx/lincheck/annotations/Recoverable.kt

@@ -0,0 +1,34 @@
+/*-
+ * #%L
+ * Lincheck
+ * %%
+ * Copyright (C) 2019 - 2020 JetBrains s.r.o.
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-3.0.html>.
+ * #L%
+ */
+package org.jetbrains.kotlinx.lincheck.annotations
+
+/**
+ * Marks method recoverable.
+ * Links this method to [recoverMethod] that should be called when this method crashes.
+ * [recoverMethod] must have the same signature as this method.
+ */
+@Retention(AnnotationRetention.RUNTIME)
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CONSTRUCTOR)
+annotation class Recoverable(
+    val recoverMethod: String = "",
+    val beforeMethod: String = ""
+)

src/jvm/main/org/jetbrains/kotlinx/lincheck/execution/ActorGenerator.kt

@@ -45,20 +45,29 @@ class ActorGenerator(
     private val promptCancellation = cancellableOnSuspension && promptCancellation
 
     fun generate(threadId: Int): Actor {
+        val threadIdIndices = mutableListOf<Int>()
         val parameters = parameterGenerators
             .map { it.generate() }
-            .map { if (it === THREAD_ID_TOKEN) threadId else it }
+            .mapIndexed { index, value ->
+                if (value === THREAD_ID_TOKEN) {
+                    threadIdIndices.add(index)
+                    threadId
+                } else {
+                    value
+                }
+            }
         val cancelOnSuspension = this.cancellableOnSuspension and DETERMINISTIC_RANDOM.nextBoolean()
         val promptCancellation = cancelOnSuspension and this.promptCancellation and DETERMINISTIC_RANDOM.nextBoolean()
         return Actor(
             method = method,
-            arguments = parameters,
+            arguments = parameters.toMutableList(),
             handledExceptions = handledExceptions,
             cancelOnSuspension = cancelOnSuspension,
             allowExtraSuspension = allowExtraSuspension,
             blocking = blocking,
             causesBlocking = causesBlocking,
-            promptCancellation = promptCancellation
+            promptCancellation = promptCancellation,
+            threadIdArgsIndices = threadIdIndices
         )
     }
 

src/jvm/main/org/jetbrains/kotlinx/lincheck/execution/ExecutionResult.kt

@@ -22,6 +22,7 @@
 package org.jetbrains.kotlinx.lincheck.execution
 
 import org.jetbrains.kotlinx.lincheck.*
+ import org.jetbrains.kotlinx.lincheck.nvm.CrashError
 
 /**
  * This class represents a result corresponding to
@@ -56,7 +57,11 @@ data class ExecutionResult(
     /**
      * State representation at the end of the scenario.
      */
-    val afterPostStateRepresentation: String?
+    val afterPostStateRepresentation: String?,
+    /**
+     * Crashes occurred while execution.
+     */
+    internal val crashes: List<List<CrashError>> = emptyList()
 ) {
     constructor(initResults: List<Result>, parallelResultsWithClock: List<List<ResultWithClock>>, postResults: List<Result>) :
         this(initResults, null, parallelResultsWithClock, null, postResults, null)
@@ -71,6 +76,8 @@ val ExecutionResult.withEmptyClocks: ExecutionResult get() = ExecutionResult(
     this.afterPostStateRepresentation
 )
 
+val ExecutionResult.withoutCrashes: ExecutionResult get() = if (crashes.isEmpty()) this else copy(crashes = emptyList())
+
 val ExecutionResult.parallelResults: List<List<Result>> get() = parallelResultsWithClock.map { it.map { r -> r.result } }
 
 // for tests