Implementation of several scheduling methods to improve the performance of static analyses

OPAL/si/src/main/resources/reference.conf

@@ -24,6 +24,6 @@ org.opalj {
   // MPS - Maximum Phase Scheduling
   // IPMS - Independent Phase Merge Scheduling
   // SPMS - Smallest Phase Merge Scheduling
-  fpcf.AnalysisScenario.ScheduleStrategy = "IPMS"
+  fpcf.AnalysisScenario.ScheduleStrategy = "MPS"
   fpcf.AnalysisScenario.AnalysisScheduleLazyTransformerInMultipleBatches = true
 }

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/IndependentPhaseMergeScheduling.scala

@@ -24,9 +24,6 @@ class IndependentPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransfor
         allCS: Set[ComputationSpecification[A]]
     ): List[PhaseConfiguration[A]] = {
 
-        val lazyType = LazyComputation
-        val transformerType = Transformer
-
         // Creates a map from ComputationSpecifications to their indices
         val computationSpecificationMap: Map[ComputationSpecification[A], Int] = allCS.zipWithIndex.toMap
         val computationSpecificationArray: Array[ComputationSpecification[A]] = allCS.toArray
@@ -77,8 +74,8 @@ class IndependentPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransfor
             ): Map[List[Int], Set[Int]] = {
 
                 if (firstElement.forall(csID =>
-                        computationSpecificationArray(csID).computationType.equals(lazyType) ||
-                            computationSpecificationArray(csID).computationType.equals(transformerType)
+                        computationSpecificationArray(csID).computationType.equals(LazyComputation) ||
+                            computationSpecificationArray(csID).computationType.equals(Transformer)
                     )
                 ) {
                     var existInSomeBatch = false
@@ -229,8 +226,8 @@ class IndependentPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransfor
         if (!scheduleLazyTransformerInAllBatches) {
             scheduleGraph.foreach { node =>
                 if (computationSpecificationArray(node._1).computationType.equals(
-                        lazyType
-                    ) || computationSpecificationArray(node._1).computationType.equals(transformerType)
+                        LazyComputation
+                    ) || computationSpecificationArray(node._1).computationType.equals(Transformer)
                 ) {
                     scheduleGraph.foreach { subNode =>
                         if (subNode._2.contains(node._1)) {

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/MaximumPhaseScheduling.scala

@@ -25,9 +25,6 @@ class MaximumPhaseScheduling[A](ps: PropertyStore, scheduleLazyTransformerInAllB
         allCS: Set[ComputationSpecification[A]]
     ): List[PhaseConfiguration[A]] = {
 
-        val lazyType = LazyComputation
-        val transformerType = Transformer
-
         // Creates a map from ComputationSpecifications to their indices
         val computationSpecificationMap: Map[ComputationSpecification[A], Int] = allCS.zipWithIndex.toMap
         val computationSpecificationArray: Array[ComputationSpecification[A]] = allCS.toArray
@@ -89,8 +86,8 @@ class MaximumPhaseScheduling[A](ps: PropertyStore, scheduleLazyTransformerInAllB
             ): Map[List[Int], Set[Int]] = {
 
                 if (firstElement.forall(csID =>
-                        computationSpecificationArray(csID).computationType.equals(lazyType) ||
-                            computationSpecificationArray(csID).computationType.equals(transformerType)
+                        computationSpecificationArray(csID).computationType.equals(LazyComputation) ||
+                            computationSpecificationArray(csID).computationType.equals(Transformer)
                     )
                 ) {
                     var existInSomeBatch = false
@@ -163,8 +160,8 @@ class MaximumPhaseScheduling[A](ps: PropertyStore, scheduleLazyTransformerInAllB
         if (!scheduleLazyTransformerInAllBatches) {
             scheduleGraph.foreach { node =>
                 if (computationSpecificationArray(node._1).computationType.equals(
-                        lazyType
-                    ) || computationSpecificationArray(node._1).computationType.equals(transformerType)
+                        LazyComputation
+                    ) || computationSpecificationArray(node._1).computationType.equals(Transformer)
                 ) {
                     scheduleGraph.foreach { subNode =>
                         if (subNode._2.contains(node._1)) {

OPAL/si/src/main/scala/org/opalj/fpcf/scheduling/SmallestPhaseMergeScheduling.scala

@@ -24,9 +24,6 @@ class SmallestPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransformer
         allCS: Set[ComputationSpecification[A]]
     ): List[PhaseConfiguration[A]] = {
 
-        val lazyType = LazyComputation
-        val transformerType = Transformer
-
         // Creates a map from ComputationSpecifications to their indices
         val computationSpecificationMap: Map[ComputationSpecification[A], Int] = allCS.zipWithIndex.toMap
         val computationSpecificationArray: Array[ComputationSpecification[A]] = allCS.toArray
@@ -76,8 +73,8 @@ class SmallestPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransformer
             ): Map[List[Int], Set[Int]] = {
 
                 if (firstElement.forall(csID =>
-                        computationSpecificationArray(csID).computationType.equals(lazyType) ||
-                            computationSpecificationArray(csID).computationType.equals(transformerType)
+                        computationSpecificationArray(csID).computationType.equals(LazyComputation) ||
+                            computationSpecificationArray(csID).computationType.equals(Transformer)
                     )
                 ) {
                     var existInSomeBatch = false
@@ -245,9 +242,9 @@ class SmallestPhaseMergeScheduling[A](ps: PropertyStore, scheduleLazyTransformer
         if (!scheduleLazyTransformerInAllBatches) {
             scheduleGraph.foreach { node =>
                 if (computationSpecificationArray(node._1).computationType.equals(
-                        lazyType
+                        LazyComputation
                     ) || computationSpecificationArray(node._1).computationType.equals(
-                        transformerType
+                        Transformer
                     )
                 ) {
                     scheduleGraph.foreach { subNode =>

OPAL/si/src/test/scala/org/opalj/fpcf/PropertyComputationsSchedulerTest.scala

@@ -71,8 +71,8 @@ class PropertyComputationsSchedulerTest extends AnyFunSpec with Matchers with Be
                 analysis2phase += 1
         }
 
-        if (analysis1phase <= analysis2phase) println("Success")
-        else fail(s"$analysis1 is not scheduled before or in the same batch as $analysis2!")
+        if (!(analysis1phase <= analysis2phase))
+            fail(s"$analysis1 is not scheduled before or in the same batch as $analysis2!")
     }
 
     /**
@@ -102,8 +102,8 @@ class PropertyComputationsSchedulerTest extends AnyFunSpec with Matchers with Be
                 analysis2phase += 1
         }
 
-        if (analysis1phase < analysis2phase) println("Success")
-        else fail(s"$analysis1 is not scheduled before $analysis2!")
+        if (!(analysis1phase < analysis2phase))
+            fail(s"$analysis1 is not scheduled before $analysis2!")
     }
 
     /**
@@ -141,11 +141,9 @@ class PropertyComputationsSchedulerTest extends AnyFunSpec with Matchers with Be
             }
         }
 
-        if (analysis1phase == analysis2phase) {
-            println("Success")
-        } else {
+        if (!(analysis1phase == analysis2phase))
             fail(s"$analysis1 is not scheduled in the same batch as $analysis2!")
-        }
+
     }
 
     // **********************************************************************************************
@@ -275,7 +273,21 @@ class PropertyComputationsSchedulerTest extends AnyFunSpec with Matchers with Be
                 )
                 val schedule = scenario.computeSchedule(ps)
 
-                print(schedule.batches)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, lazy1, eager1)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager1, eager4)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager1, eager5)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager1, eager6)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager1, transformer1)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager4, lazy3)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager4, eager2)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager6, lazy2)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager6, lazy2)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager6, lazy3)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager3, triggered1)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager3, triggered2)
+                analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(schedule, eager3, triggered3)
+                analysis1IsScheduledInTheSameBatchAsAnalysis2(schedule, triggered1, triggered2)
+                analysis1IsScheduledInTheSameBatchAsAnalysis2(schedule, triggered1, triggered3)
             }
         }
     }