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

DEVELOPING_OPAL/tools/src/main/scala/org/opalj/support/info/Immutability.scala

@@ -128,7 +128,7 @@ object Immutability {
 
         var projectTime: Seconds = Seconds.None
         var analysisTime: Seconds = Seconds.None
-        val callGraphTime: Seconds = Seconds.None
+        var callGraphTime: Seconds = Seconds.None
 
         val project = time {
             Project(
@@ -182,7 +182,9 @@ object Immutability {
         val propertyStore = project.get(PropertyStoreKey)
         val analysesManager = project.get(FPCFAnalysesManagerKey)
 
-        project.get(callgraphKey)
+        time {
+            project.get(callgraphKey)
+        } { t => callGraphTime = t.toSeconds }
 
         time {
             analysesManager.runAll(

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

@@ -4,7 +4,7 @@ org.opalj {
   // to support the debugging of analyses developed using the property store.
   // I.e., debug performs a wide range of additionaly checks to identify errors as
   // early as possible.
-  fpcf.PropertyStore.Debug = false
+  fpcf.PropertyStore.Debug = true
   fpcf.PropertyStore.TraceFallbacks = false
   fpcf.PropertyStore.TraceSuppressedNotifications = false
   fpcf.PropertyStore.Default = "Parallel"
@@ -18,4 +18,12 @@ org.opalj {
   fpcf.par.PKECPropertyStore.MaxEvaluationDepth = 32
 
   fpcf.AnalysisScenario.AnalysisAutoConfig = false
+
+  // For scheduling the analysis with different batching strategies
+  // SPS - Single Phase Scheduling
+  // MPS - Maximum Phase Scheduling
+  // IPMS - Independent Phase Merge Scheduling
+  // SPMS - Smallest Phase Merge Scheduling
+  fpcf.AnalysisScenario.ScheduleStrategy = "SPS"
+  fpcf.AnalysisScenario.AnalysisScheduleLazyTransformerInMultipleBatches = true
 }

OPAL/si/src/main/scala/org/opalj/fpcf/PropertyStore.scala

@@ -620,13 +620,12 @@ abstract class PropertyStore {
         // Save the information about the finalization order (of properties which are
         // collaboratively computed).
         val cleanUpSubPhase =
-            (propertyKindsComputedInThisPhase -- finalizationOrder.flatten.toSet) + AnalysisKey
-        this.subPhaseFinalizationOrder =
-            if (cleanUpSubPhase.isEmpty) {
-                finalizationOrder.toArray
+            (propertyKindsComputedInThisPhase -- finalizationOrder.flatten.toSet)
+        this.subPhaseFinalizationOrder = (if (cleanUpSubPhase.isEmpty) {
+                finalizationOrder.zipWithIndex.map(x => if(x._2 == 0) x._1 :+ AnalysisKey else x._1)
             } else {
-                (finalizationOrder :+ cleanUpSubPhase.toList).toArray
-            }
+                (finalizationOrder.zipWithIndex.map(x => if(x._2 == 0) x._1 :+ AnalysisKey else x._1) :+ cleanUpSubPhase.toList)
+            }).toArray
 
         subPhaseId = 0
         hasSuppressedNotifications = suppressInterimUpdates.nonEmpty

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

@@ -7,7 +7,6 @@ import org.scalatest.BeforeAndAfterEach
 import org.scalatest.funspec.AnyFunSpec
 import org.scalatest.matchers.should.Matchers
 import org.scalatestplus.junit.JUnitRunner
-
 import org.opalj.fpcf.fixtures.PropertyStoreConfigurationRecorder
 import org.opalj.log.GlobalLogContext
 
@@ -34,8 +33,8 @@ class PropertyComputationsSchedulerTest extends AnyFunSpec with Matchers with Be
         override def uses(ps: PropertyStore): Set[PropertyBounds] = uses
     }
 
-    val pks: Array[PropertyKind] = new Array[PropertyKind](12)
-    (0 to 11).foreach { i => pks(i) = PropertyKey.create[Null, Null]("p" + (i)) }
+    val pks: Array[PropertyKind] = new Array[PropertyKind](21)
+    (0 to 20).foreach { i => pks(i) = PropertyKey.create[Null, Null]("p" + (i)) }
 
     val c1 = BasicComputationSpecification(
         "c1",
@@ -44,6 +43,114 @@ class PropertyComputationsSchedulerTest extends AnyFunSpec with Matchers with Be
         derivesEagerly = Set(PropertyBounds.lub(pks(1)))
     )
 
+    def analysis1IsScheduledBeforeOrAtTheSameBatchAsAnalysis2(
+        schedule:  Schedule[Unit],
+        analysis1: BasicComputationSpecification,
+        analysis2: BasicComputationSpecification
+    ): Unit = {
+        var analysis1AlreadyComputed = false
+        var analysis1phase = 0
+        schedule.batches.foreach { batch =>
+            if (batch.scheduled.contains(analysis1)) {
+                if (!analysis1AlreadyComputed) {
+                    analysis1AlreadyComputed = true
+                }
+            } else if (!analysis1AlreadyComputed) {
+                analysis1phase += 1
+            }
+        }
+
+        var analysis2AlreadyComputed = false
+        var analysis2phase = 0
+        schedule.batches.foreach { batch =>
+            if (batch.scheduled.contains(analysis2)) {
+                if (!analysis2AlreadyComputed) {
+                    analysis2AlreadyComputed = true
+                }
+            } else if (!analysis2AlreadyComputed) {
+                analysis2phase += 1
+            }
+        }
+
+        if (analysis1phase <= analysis2phase) {
+            println("Success")
+        } else {
+            fail(s"$analysis1 is not scheduled before or in the same batch as $analysis2!")
+        }
+    }
+
+    def analysis1IsScheduledBeforeAnalysis2(
+        schedule:  Schedule[Unit],
+        analysis1: BasicComputationSpecification,
+        analysis2: BasicComputationSpecification
+    ): Unit = {
+        var analysis1AlreadyComputed = false
+        var analysis1phase = 0
+        schedule.batches.foreach { batch =>
+            if (batch.scheduled.contains(analysis1)) {
+                if (!analysis1AlreadyComputed) {
+                    analysis1AlreadyComputed = true
+                }
+            } else if (!analysis1AlreadyComputed) {
+                analysis1phase += 1
+            }
+        }
+
+        var analysis2AlreadyComputed = false
+        var analysis2phase = 0
+        schedule.batches.foreach { batch =>
+            if (batch.scheduled.contains(analysis2)) {
+                if (!analysis2AlreadyComputed) {
+                    analysis2AlreadyComputed = true
+                }
+            } else if (!analysis2AlreadyComputed) {
+                analysis2phase += 1
+            }
+        }
+
+        if (analysis1phase < analysis2phase) {
+            println("Success")
+        } else {
+            fail(s"$analysis1 is not scheduled before $analysis2!")
+        }
+    }
+
+    def analysis1IsScheduledInTheSameBatchAsAnalysis2(
+        schedule:  Schedule[Unit],
+        analysis1: BasicComputationSpecification,
+        analysis2: BasicComputationSpecification
+    ): Unit = {
+        var analysis1AlreadyComputed = false
+        var analysis1phase = 0
+        schedule.batches.foreach { batch =>
+            if (batch.scheduled.contains(analysis1)) {
+                if (!analysis1AlreadyComputed) {
+                    analysis1AlreadyComputed = true
+                }
+            } else if (!analysis1AlreadyComputed) {
+                analysis1phase += 1
+            }
+        }
+
+        var analysis2AlreadyComputed = false
+        var analysis2phase = 0
+        schedule.batches.foreach { batch =>
+            if (batch.scheduled.contains(analysis2)) {
+                if (!analysis2AlreadyComputed) {
+                    analysis2AlreadyComputed = true
+                }
+            } else if (!analysis2AlreadyComputed) {
+                analysis2phase += 1
+            }
+        }
+
+        if (analysis1phase == analysis2phase) {
+            println("Success")
+        } else {
+            fail(s"$analysis1 is not scheduled in the same batch as $analysis2!")
+        }
+    }
+
     // **********************************************************************************************
     //
     // TESTS
@@ -68,6 +175,94 @@ class PropertyComputationsSchedulerTest extends AnyFunSpec with Matchers with Be
                 ps.phaseConfigurations.head should be((Set.empty, Set.empty, Map.empty))
             }
 
+            it("an mixed analysis scenario") {
+                val lazy1 = BasicComputationSpecification(
+                    "lazy1",
+                    LazyComputation,
+                    derivesLazily = Option(PropertyBounds.lub(pks(10)))
+                )
+                val eager1 = BasicComputationSpecification(
+                    "eager1",
+                    EagerComputation,
+                    derivesEagerly = Set(PropertyBounds.lub(pks(1))),
+                    uses = Set(PropertyBounds.lub(pks(10)))
+                )
+                val eager4 = BasicComputationSpecification(
+                    "eager4",
+                    EagerComputation,
+                    derivesCollaboratively = Set(PropertyBounds.lub(pks(13))),
+                    uses = Set(PropertyBounds.lub(pks(1)))
+                )
+                val transformer1 =
+                    BasicComputationSpecification(
+                        "transformer1",
+                        Transformer,
+                        derivesLazily = Option(PropertyBounds.lub(pks(7))),
+                        uses = Set(PropertyBounds.finalP(pks(1)))
+                    )
+                val eager5 = BasicComputationSpecification(
+                    "eager5",
+                    EagerComputation,
+                    derivesCollaboratively = Set(PropertyBounds.lub(pks(13))),
+                    uses = Set(PropertyBounds.lub(pks(7)))
+                )
+                val eager6 = BasicComputationSpecification(
+                    "eager6",
+                    EagerComputation,
+                    derivesCollaboratively = Set(PropertyBounds.lub(pks(13)))
+                )
+                val lazy2 = BasicComputationSpecification(
+                    "lazy2",
+                    LazyComputation,
+                    derivesLazily = Option(PropertyBounds.lub(pks(11))),
+                    uses = Set(PropertyBounds.lub(pks(13)))
+                )
+                val lazy3 = BasicComputationSpecification(
+                    "lazy3",
+                    LazyComputation,
+                    derivesLazily = Option(PropertyBounds.lub(pks(12))),
+                    uses = Set(PropertyBounds.lub(pks(13)))
+                )
+                val eager2 = BasicComputationSpecification(
+                    "eager2",
+                    EagerComputation,
+                    derivesEagerly = Set(PropertyBounds.lub(pks(2))),
+                    uses = Set(PropertyBounds.lub(pks(12)))
+                )
+                val eager3 = BasicComputationSpecification(
+                    "eager3",
+                    EagerComputation,
+                    derivesEagerly = Set(PropertyBounds.lub(pks(3))),
+                    uses = Set(PropertyBounds.lub(pks(13)))
+                )
+                val triggered1 =
+                    BasicComputationSpecification(
+                        "triggered1",
+                        TriggeredComputation,
+                        derivesEagerly = Set(PropertyBounds.lub(pks(4))),
+                        uses = Set(PropertyBounds.lub(pks(3)), PropertyBounds.lub(pks(6)))
+                    )
+                val triggered2 =
+                    BasicComputationSpecification(
+                        "triggered2",
+                        TriggeredComputation,
+                        derivesEagerly = Set(PropertyBounds.lub(pks(5))),
+                        uses = Set(PropertyBounds.lub(pks(4)))
+                    )
+                val triggered3 =
+                    BasicComputationSpecification(
+                        "triggered3",
+                        TriggeredComputation,
+                        derivesEagerly = Set(PropertyBounds.lub(pks(6))),
+                        uses = Set(PropertyBounds.lub(pks(5)))
+                    )
+
+                val ps = new PropertyStoreConfigurationRecorder()
+                val scenario = AnalysisScenario(Set(eager1, eager3, eager4, eager5, eager6, eager2, lazy1, lazy2, lazy3, transformer1, triggered1, triggered2, triggered3), ps)
+                val schedule = scenario.computeSchedule(ps)
+
+                print(schedule.batches)
+            }
         }
     }
 }

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/FieldImmutabilityAnalysis.scala

@@ -114,7 +114,7 @@ class FieldImmutabilityAnalysis private[analyses] (val project: SomeProject)
          * Query type iterator for concrete class types.
          * Note: This only works precisely in a closed world assumption!!
          */
-        def queryTypeIterator(implicit state: State, typeIterator: TypeIterator): Unit = {
+        def queryTypeIterator()(implicit state: State, typeIterator: TypeIterator): Unit = {
             val actualTypes = typeIterator.typesProperty(state.field, typeIterator)
 
             typeIterator.foreachType(state.field, actualTypes) { actualType => determineClassImmutability(actualType) }
@@ -173,7 +173,7 @@ class FieldImmutabilityAnalysis private[analyses] (val project: SomeProject)
             }
         }
 
-        def determineTypeImmutability(implicit state: State): Unit = {
+        def determineTypeImmutability()(implicit state: State): Unit = {
             if (state.field.fieldType == ObjectType.Object) {
                 // in case of a field with type object: field immutability stays NonTransitivelyImmutable
                 if (state.genericTypeParameters.isEmpty)
@@ -269,13 +269,13 @@ class FieldImmutabilityAnalysis private[analyses] (val project: SomeProject)
         def c(eps: SomeEPS)(implicit state: State): ProperPropertyComputationResult = {
 
             if (state.hasDependee(eps.toEPK)) {
+                typeIterator.continuation(state.field, eps) {
+                    actualType => determineClassImmutability(actualType)
+                }
                 if (eps.isFinal)
                     state.removeDependee(eps.toEPK)
                 else
                     state.updateDependency(eps)
-                typeIterator.continuation(state.field, eps) {
-                    actualType => determineClassImmutability(actualType.asObjectType)
-                }
             } else {
 
                 state.fieldImmutabilityDependees =
@@ -321,9 +321,9 @@ class FieldImmutabilityAnalysis private[analyses] (val project: SomeProject)
 
         if (field.fieldType.isReferenceType) {
             if (typeExtensibility(ObjectType.Object).isNo)
-                queryTypeIterator
+                queryTypeIterator()
             else
-                determineTypeImmutability
+                determineTypeImmutability()
         }
 
         createResult()