implement warm-up invocations at the beginning of each iteration

* warm-up invocations do not contribute into statistics calculated by AdaptivePlanner

Signed-off-by: Evgenii Moiseenko <[email protected]>

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

@@ -198,31 +198,56 @@ internal class AdaptivePlanner(
     private val invocationsLowerBound = INVOCATIONS_LOWER_BOUND
 
     /**
-     * upper bound of invocations allocated by iteration
+     * Upper bound of invocations allocated by iteration
      */
     private val invocationsUpperBound = when (mode) {
         LincheckMode.Stress         -> STRESS_INVOCATIONS_UPPER_BOUND
         LincheckMode.ModelChecking  -> MODEL_CHECKING_INVOCATIONS_UPPER_BOUND
         else -> throw IllegalArgumentException()
     }
 
+    private var warmUpInvocations = 0
+
+    private var currentIterationWarmUpInvocations = 0
+
+    private var currentIterationWarmUpTimeNano = 0L
+
     override fun shouldDoNextIteration(iteration: Int): Boolean {
         check(iteration == statisticsTracker.iteration + 1)
         if (iteration >= WARM_UP_ITERATIONS.coerceAtLeast(1) /* && iteration % BOUNDS_ADJUSTMENT_INTERVAL == 0 */) {
             adjustBounds(
                 performedIterations = statisticsTracker.iteration + 1,
-                performedInvocations = statisticsTracker.iterationsInvocationsCount.sum(),
-                averageInvocationTimeNano = statisticsTracker.averageInvocationTimeNano(statisticsTracker.iteration),
-                remainingTimeNano = remainingTimeNano,
+                performedInvocations = statisticsTracker.iterationsInvocationsCount.sum() - warmUpInvocations,
+                remainingTimeNano = remainingTimeNano - currentIterationWarmUpTimeNano,
+                averageInvocationTimeNano = with(statisticsTracker) {
+                    (iterationsRunningTimeNano[this.iteration] - currentIterationWarmUpTimeNano) /
+                            iterationsInvocationsCount[this.iteration].toDouble()
+                },
             )
         }
+        resetCurrentIterationInternalStatistics()
         return (iteration < iterationsBound) && (remainingTimeNano > 0)
     }
 
     override fun shouldDoNextInvocation(invocation: Int): Boolean {
         check(invocation == statisticsTracker.invocation + 1)
-        return (invocation < invocationsBound) &&
-                (statisticsTracker.runningTimeNano < testingTimeNano + admissibleDelayTimeNano)
+        if (statisticsTracker.runningTimeNano > testingTimeNano + admissibleDelayTimeNano) {
+            return false
+        }
+        if (currentIterationWarmUpInvocations < WARM_UP_INVOCATIONS_COUNT) {
+            warmUpInvocations++
+            currentIterationWarmUpInvocations++
+            if (currentIterationWarmUpInvocations == WARM_UP_INVOCATIONS_COUNT) {
+                currentIterationWarmUpTimeNano += statisticsTracker.currentIterationRunningTimeNano
+            }
+            return true
+        }
+        return (invocation < invocationsBound + currentIterationWarmUpInvocations)
+    }
+
+    private fun resetCurrentIterationInternalStatistics() {
+        currentIterationWarmUpInvocations = 0
+        currentIterationWarmUpTimeNano = 0L
     }
 
     /*
@@ -336,6 +361,9 @@ internal class AdaptivePlanner(
         // initial number of invocations
         private const val INITIAL_INVOCATIONS_BOUND = 500
 
+        // number of warm-up invocations
+        private const val WARM_UP_INVOCATIONS_COUNT = 10
+
         // number of invocations should be divisible to this constant,
         // that is we ensure number of invocations is always rounded up to this constant
         internal const val INVOCATIONS_FACTOR = 100