refactoring minimizer

Author: arcuri82

core/src/main/kotlin/org/evomaster/core/search/service/Minimizer.kt

@@ -11,7 +11,9 @@ import org.evomaster.core.problem.rest.data.RestIndividual
 import org.evomaster.core.search.EvaluatedIndividual
 import org.evomaster.core.search.GroupsOfChildren
 import org.evomaster.core.search.Individual
+import org.evomaster.core.search.service.time.ExecutionPhaseController
 import org.evomaster.core.search.service.time.SearchStatusUpdater
+import org.evomaster.core.search.service.time.TimeBoxedPhase
 import org.evomaster.core.sql.SqlAction
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -21,7 +23,7 @@ import org.slf4j.LoggerFactory
  *
  * WARN: currently minimization loses all history info from EvaluatedIndividual, eg impact of genes
  */
-class Minimizer<T: Individual> {
+class Minimizer<T: Individual> : TimeBoxedPhase {
 
     companion object{
         private val log : Logger = LoggerFactory.getLogger(Minimizer::class.java)
@@ -38,45 +40,31 @@ class Minimizer<T: Individual> {
 
     @Inject
     private lateinit var idMapper: IdMapper
-    
 
-    private var startTimer : Long = -1
+    @Inject
+    private lateinit var epc: ExecutionPhaseController
 
 
-    fun doStartTheTimer(){
-        startTimer = System.currentTimeMillis()
-    }
+    override fun applyPhase() {
+        minimizeMainActionsPerCoveredTargetInArchive()
+        pruneNonNeededDatabaseActions()
+        simplifyActions()
 
-    fun passedTimeInSecond() : Int {
-        if(startTimer < 0){
-            throw IllegalStateException("Timer was not started")
-        }
-        return ((System.currentTimeMillis() - startTimer) / 1000).toInt()
+        //TODO there could be more to do here
     }
 
-    private fun checkHasTimedout() : Boolean{
-        if(startTimer < 0){
-            throw IllegalStateException("Timer was not started")
-        }
-        if(config.minimizeTimeout < 0){
-            return false
-        }
-        if(config.minimizeTimeout == 0){
-            return true
-        }
-        val current = System.currentTimeMillis()
-        val passed = (current - startTimer) / (1000 * 60.0)
-        return passed > config.minimizeTimeout
+    override fun hasPhaseTimedOut() : Boolean{
+        return epc.hasPhaseTimedOut(ExecutionPhaseController.Phase.MINIMIZATION)
     }
 
-    fun pruneNonNeededDatabaseActions(){
+    private fun pruneNonNeededDatabaseActions(){
         //TODO
     }
 
     /**
      * eg, removed un-needed optional parameters
      */
-    fun simplifyActions(){
+    private fun simplifyActions(){
         //TODO
     }
 
@@ -88,9 +76,9 @@ class Minimizer<T: Individual> {
      *
      * "EvoSuite: On The Challenges of Test Case Generation in the Real World"
      */
-    fun minimizeMainActionsPerCoveredTargetInArchive() {
+    private fun minimizeMainActionsPerCoveredTargetInArchive() {
 
-        if(checkHasTimedout()){
+        if(hasPhaseTimedOut()){
            LoggingUtil.getInfoLogger().warn("Minimization phase has timed-out. You can use --minimizeTimeout to increase it.")
            return
         }
@@ -121,7 +109,7 @@ class Minimizer<T: Individual> {
 
         current.forEach{
 
-            if(checkHasTimedout()){
+            if(hasPhaseTimedOut()){
                 LoggingUtil.getInfoLogger().warn("Minimization phase has timed-out. You can use --minimizeTimeout to increase it.")
                 return
             }

core/src/main/kotlin/org/evomaster/core/search/service/SearchAlgorithm.kt

@@ -105,13 +105,7 @@ abstract class SearchAlgorithm<T> where T : Individual {
 
         if(config.minimize){
             epc.markStartingMinimization()
-
-            minimizer.doStartTheTimer()
-            minimizer.minimizeMainActionsPerCoveredTargetInArchive()
-            minimizer.pruneNonNeededDatabaseActions()
-            minimizer.simplifyActions()
-            val seconds = minimizer.passedTimeInSecond()
-            LoggingUtil.getInfoLogger().info("Minimization phase took $seconds seconds")
+            minimizer.applyPhase()
         }
 
         if(config.addPreDefinedTests) {

core/src/main/kotlin/org/evomaster/core/search/service/time/ExecutionPhaseController.kt

@@ -8,18 +8,23 @@ import javax.inject.Inject
 /**
  * Service used to keep track of which phase of the fuzzing we are currently in,
  * and how long we have spent in them.
+ *
+ * The actual starting/stopping of these phases is done elsewhere (as it depends
+ * on the problem type)
  */
 class ExecutionPhaseController {
 
-    enum class Phase{
-        NOT_STARTED,
-        SEARCH,
-        MINIMIZATION,
-        SECURITY,
-        ADDITIONAL_ORACLES,
-        FLAKINESS,
-        WRITE_OUTPUT,
-        FINISHED
+    enum class Phase(
+        val timeBoxed: Boolean
+    ){
+        NOT_STARTED(false),
+        SEARCH(false),
+        MINIMIZATION(true),
+        SECURITY(true),
+        ADDITIONAL_ORACLES(true),
+        FLAKINESS(true),
+        WRITE_OUTPUT(false),
+        FINISHED(false)
     }
 
     @Inject
@@ -31,10 +36,41 @@ class ExecutionPhaseController {
 
     private val durationInSeconds : MutableMap<Phase, Long> = mutableMapOf()
 
+    private val hasTimedOut : MutableSet<Phase> = mutableSetOf()
+
     fun getCurrentPhase() : Phase{
         return phase
     }
 
+    fun hasPhaseTimedOut(target: Phase) : Boolean {
+
+        if(!target.timeBoxed){
+            throw IllegalArgumentException("Cannot query timeout for a non time-boxed phase: $target")
+        }
+
+        if(target != phase){
+            return  hasTimedOut.contains(target)
+        }
+
+        when(target){
+            Phase.MINIMIZATION -> {
+                if(config.minimizeTimeout < 0){
+                    return false
+                }
+                if(config.minimizeTimeout == 0){
+                    return true
+                }
+                //dealing with minutes
+                val passed = elapsedSeconds() / 60.0
+                return passed >= config.minimizeTimeout
+            }
+            else -> {
+                //TODO other cases
+                return false
+            }
+        }
+    }
+
     fun getPhaseDurationInSeconds(target: Phase) : Long {
         return durationInSeconds.getOrDefault(target, -1L)
     }
@@ -91,12 +127,27 @@ class ExecutionPhaseController {
         return phase != Phase.NOT_STARTED && phase != Phase.FINISHED
     }
 
+    private fun elapsedSeconds() : Long {
+
+        if(phase == Phase.NOT_STARTED){
+            throw IllegalStateException("Fuzzing session has not started yet")
+        }
+
+        val elapsed = System.currentTimeMillis() - lastPhaseStartMs
+        val seconds = elapsed / 1000
+
+        return seconds
+    }
+
     private fun startPhase(newPhase: Phase){
 
+        if(newPhase == Phase.NOT_STARTED){
+            throw IllegalStateException("Cannot start a 'not-started' phase")
+        }
+
         if(phase != Phase.NOT_STARTED){
             //starting a new phase will end the current one
-            val elapsed = System.currentTimeMillis() - lastPhaseStartMs
-            val seconds = elapsed / 1000
+            val seconds = elapsedSeconds()
             durationInSeconds[phase] = seconds
 
             if(!config.avoidNonDeterministicLogs) {
@@ -105,6 +156,8 @@ class ExecutionPhaseController {
             }
         }
 
+        LoggingUtil.getInfoLogger().info("Starting phase $newPhase")
+
         phase = newPhase
         lastPhaseStartMs = System.currentTimeMillis()
     }