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

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/fpcf/analyses/TypeImmutabilityAnalysisDemo.scala

@@ -1,6 +1,5 @@
 /* BSD 2-Clause License - see OPAL/LICENSE for details. */
-package org
-package opalj
+package org.opalj
 package fpcf
 package analyses
 
@@ -19,10 +18,6 @@ import org.opalj.br.fpcf.properties.immutability.MutableType
 import org.opalj.br.fpcf.properties.immutability.NonTransitivelyImmutableType
 import org.opalj.br.fpcf.properties.immutability.TransitivelyImmutableType
 import org.opalj.br.fpcf.properties.immutability.TypeImmutability
-import org.opalj.fpcf.Entity
-import org.opalj.fpcf.EPS
-import org.opalj.fpcf.FPCFAnalysesManagerKey
-import org.opalj.fpcf.PropertyStore
 import org.opalj.tac.cg.RTACallGraphKey
 import org.opalj.tac.fpcf.analyses.LazyFieldImmutabilityAnalysis
 import org.opalj.tac.fpcf.analyses.LazyFieldLocalityAnalysis

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/br/src/main/scala/org/opalj/br/analyses/cg/InitialEntryPointsKey.scala

@@ -68,10 +68,9 @@ object InitialEntryPointsKey extends ProjectInformationKey[Iterable[Method], Not
         val epFinder = instantiateEntryPointFinder(fqn)
         epFinder
     }
+
     /**
-     * Reflectively instantiates a ''ClosedPackagesAnalysis'' for the given project.
-     * The instantiated class has to satisfy the interface and needs to provide a single
-     * constructor parameterized over a Project.
+     * Reflectively instantiates an ''EntryPointFinder'' object.
      */
     private[this] def instantiateEntryPointFinder(fqn: String): EntryPointFinder = {
         import scala.reflect.runtime.universe._

OPAL/common/src/main/scala/org/opalj/concurrent/OPALThreadPoolExecutor.scala

@@ -1,6 +1,5 @@
 /* BSD 2-Clause License - see OPAL/LICENSE for details. */
-package org
-package opalj
+package org.opalj
 package concurrent
 
 import java.util.concurrent.{Future => JFuture}

OPAL/common/src/main/scala/org/opalj/concurrent/package.scala

@@ -1,6 +1,5 @@
 /* BSD 2-Clause License - see OPAL/LICENSE for details. */
-package org
-package opalj
+package org.opalj
 
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.Executors

OPAL/common/src/main/scala/org/opalj/graphs/package.scala

@@ -729,4 +729,40 @@ package object graphs {
         sccs
     }
 
+    /**
+     * Provides a topological order of the given acyclic graph's nodes.
+     *
+     * @throws IllegalStateException If the graph contains cycles
+     */
+    def topologicalSort(graph: Map[Int, List[Int]]): List[Int] = {
+        var sortedNodes: List[Int] = List.empty
+        var permanent: Set[Int] = Set.empty
+        var temporary: Set[Int] = Set.empty
+
+        val preparedGraph = graph.map { case (node, deps) =>
+            node -> deps.filter(_ != node)
+        }
+
+        def visit(node: Int): Unit = {
+            if (!permanent.contains(node)) {
+                if (temporary.contains(node)) {
+                    throw new IllegalStateException("Graph contains a cycle")
+                }
+                temporary = temporary + node
+
+                preparedGraph(node).foreach { otherNode => visit(otherNode) }
+
+                permanent = permanent + node
+                temporary = temporary - node
+
+                sortedNodes = sortedNodes :+ node
+            }
+
+        }
+        for (node <- preparedGraph.keys) {
+            visit(node)
+        }
+
+        sortedNodes
+    }
 }

OPAL/common/src/main/scala/org/opalj/util/Return.scala

@@ -1,6 +1,5 @@
 /* BSD 2-Clause License - see OPAL/LICENSE for details. */
-package org
-package opalj
+package org.opalj
 package util
 
 // TODO: Replace this class by scala.util.control.NonLocalReturns in Scala 3

OPAL/common/src/main/scala/org/opalj/util/package.scala

@@ -1,6 +1,5 @@
 /* BSD 2-Clause License - see OPAL/LICENSE for details. */
-package org
-package opalj
+package org.opalj
 
 import scala.annotation.nowarn
 

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

@@ -1,23 +1,31 @@
 org.opalj {
 
-  // Turns on the debugging support of the property store which is primarily meant
-  // 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.TraceFallbacks = false
-  fpcf.PropertyStore.TraceSuppressedNotifications = false
-  fpcf.PropertyStore.Default = "Parallel"
+  fpcf {
+    PropertyStore {
+      // Turns on the debugging support of the property store which is primarily meant
+      // 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.
+      Debug = false
+      TraceFallbacks = false
+      TraceSuppressedNotifications = false
+    Default = "Parallel"
+    }
 
-  // For tasks managers for the seq. store see PKESequentialPropertyStore.Strategies
-  fpcf.seq.PKESequentialPropertyStore.TasksManager = "ManyDirectDependenciesLast"
-  fpcf.seq.PKESequentialPropertyStore.MaxEvaluationDepth = 32
+    // For tasks managers for the seq. store see PKESequentialPropertyStore.Strategies
+    seq.PKESequentialPropertyStore.TasksManager = "ManyDirectDependenciesLast"
+    seq.PKESequentialPropertyStore.MaxEvaluationDepth = 32
 
-  // For tasks managers for the par. store see PKECPropertyStore.Strategies
-  fpcf.par.PKECPropertyStore.TasksManager = "NoPriority"
-  fpcf.par.PKECPropertyStore.MaxEvaluationDepth = 32
+    // For tasks managers for the par. store see PKECPropertyStore.Strategies
+    par.PKECPropertyStore.TasksManager = "NoPriority"
+    par.PKECPropertyStore.MaxEvaluationDepth = 32
 
-  fpcf.AnalysisScenario.AnalysisAutoConfig = false
+    AnalysisScenario {
+      AnalysisAutoConfig = false
+      SchedulingStrategy = "org.opalj.fpcf.scheduling.SmallestPhaseMergeScheduling"
+      ScheduleLazyInMultiplePhases = true
+    } 
+  } 
 
   si.flowanalysis.StructuralAnalysis {
     maxIterations = 1000

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

@@ -2,10 +2,15 @@
 package org.opalj
 package fpcf
 
+import com.typesafe.config.Config
+
 import org.opalj.fpcf.AnalysisScenario.AnalysisAutoConfigKey
+import org.opalj.fpcf.AnalysisScenario.AnalysisSchedulingStrategyKey
+import org.opalj.fpcf.scheduling.SchedulingStrategy
 import org.opalj.graphs.Graph
 import org.opalj.log.LogContext
 import org.opalj.log.OPALLogger
+import org.opalj.util.PerformanceEvaluation.time
 
 /**
  * Provides functionality to determine whether a set of analyses is compatible and to compute
@@ -225,103 +230,80 @@ class AnalysisScenario[A](val ps: PropertyStore) {
             scheduleComputed = true
         }
 
-        allCS.foreach(processCS)
+        val scheduledBatches = if (allCS.isEmpty) List.empty
+        else time {
+            allCS.foreach(processCS)
 
-        val alreadyComputedPropertyKinds = propertyStore.alreadyComputedPropertyKindIds.toSet
+            val alreadyComputedPropertyKinds = propertyStore.alreadyComputedPropertyKindIds.toSet
 
-        // 0. check that a property was not already derived
-        allCS.foreach { cs =>
-            cs.derives foreach { derivedProperty =>
-                if (alreadyComputedPropertyKinds.contains(derivedProperty.pk.id)) {
-                    val pkName = PropertyKey.name(derivedProperty.pk.id)
-                    val m = s"can not register $cs: $pkName was computed in a previous phase"
-                    throw new SpecificationViolation(m)
+            // 0. check that a property was not already derived
+            allCS.foreach { cs =>
+                cs.derives foreach { derivedProperty =>
+                    if (alreadyComputedPropertyKinds.contains(derivedProperty.pk.id)) {
+                        val pkName = PropertyKey.name(derivedProperty.pk.id)
+                        val m = s"can not register $cs: $pkName was computed in a previous phase"
+                        throw new SpecificationViolation(m)
+                    }
                 }
             }
-        }
 
-        // 1. check for properties that are not derived (and which require an analysis)
-        def useFallback(underivedProperty: PropertyBounds, propertyName: String) = {
-            if (PropertyKey.hasFallback(underivedProperty.pk)) {
-                val message = s"no analyses scheduled for: $propertyName; using fallback"
-                OPALLogger.warn("analysis configuration", message)
-            } else {
-                throw new IllegalStateException(s"no analysis scheduled for $propertyName")
+            // 1. check for properties that are not derived (and which require an analysis)
+            def useFallback(underivedProperty: PropertyBounds, propertyName: String) = {
+                if (PropertyKey.hasFallback(underivedProperty.pk)) {
+                    val message = s"no analyses scheduled for: $propertyName; using fallback"
+                    OPALLogger.warn("analysis configuration", message)
+                } else {
+                    throw new IllegalStateException(s"no analysis scheduled for $propertyName")
+                }
             }
-        }
 
-        val analysisAutoConfig = BaseConfig.getBoolean(AnalysisAutoConfigKey)
-        val underivedProperties = usedProperties -- derivedProperties
-        underivedProperties
-            .filterNot { underivedProperty => alreadyComputedPropertyKinds.contains(underivedProperty.pk.id) }
-            .foreach { underivedProperty =>
-                if (!derivedProperties.contains(underivedProperty)) {
-                    val propertyName = PropertyKey.name(underivedProperty.pk.id)
-                    val defaultCSOpt =
-                        if (analysisAutoConfig) defaultAnalysis(underivedProperty) else None
-                    if (defaultCSOpt.isDefined) {
-                        val defaultCS = defaultCSOpt.get
-                        try {
-                            processCS(defaultCS)
-                            val message = s"no analyses scheduled for: $propertyName; using ${defaultCS.name}"
-                            OPALLogger.info("analysis configuration", message)
-                        } catch {
-                            case _: SpecificationViolation =>
-                                useFallback(underivedProperty, propertyName)
+            implicit val config = propertyStore.context(classOf[Config])
+
+            val analysisAutoConfig = config.getBoolean(AnalysisAutoConfigKey)
+            val underivedProperties = usedProperties -- derivedProperties
+            underivedProperties
+                .filterNot { underivedProperty => alreadyComputedPropertyKinds.contains(underivedProperty.pk.id) }
+                .foreach { underivedProperty =>
+                    if (!derivedProperties.contains(underivedProperty)) {
+                        val propertyName = PropertyKey.name(underivedProperty.pk.id)
+                        val defaultCSOpt =
+                            if (analysisAutoConfig) defaultAnalysis(underivedProperty) else None
+                        if (defaultCSOpt.isDefined) {
+                            val defaultCS = defaultCSOpt.get
+                            try {
+                                processCS(defaultCS)
+                                val message = s"no analyses scheduled for: $propertyName; using ${defaultCS.name}"
+                                OPALLogger.info("analysis configuration", message)
+                            } catch {
+                                case _: SpecificationViolation =>
+                                    useFallback(underivedProperty, propertyName)
+                            }
+                        } else {
+                            useFallback(underivedProperty, propertyName)
                         }
-                    } else {
-                        useFallback(underivedProperty, propertyName)
                     }
                 }
-            }
-
-        // TODO check all further constraints (in particular those related to cyclic dependencies between analysis...)
 
-        // 2. assign analyses to different batches if an analysis can only process
-        //    final properties (unless it is a transformer, the latter have special paths and
-        //    constraints and can always be scheduled in the same batch!)
+            val schedulingStrategy = instantiateSchedulingStrategy(config.getString(AnalysisSchedulingStrategyKey))
+            OPALLogger.info("scheduler", s"scheduling strategy ${schedulingStrategy} is selected")
 
-        // TODO ....
+            schedulingStrategy.schedule(ps, allCS)
+        } { t => OPALLogger.info("scheduler", s"computation of schedule took ${t.toSeconds}") }
 
         Schedule(
-            if (allCS.isEmpty) List.empty else List(computePhase(propertyStore)),
+            scheduledBatches,
             initializationData
         )
     }
 
     /**
-     * Computes the configuration for a specific batch; this method can only handle the situation
-     * where all analyses can be executed in the same phase.
+     * Reflectively instantiates a ''SchedulingStrategy'' object.
      */
-    private def computePhase(propertyStore: PropertyStore): PhaseConfiguration[A] = {
-
-        // 1. compute the phase configuration; i.e., find those properties for which we must
-        //    suppress interim updates.
-        var suppressInterimUpdates: Map[PropertyKind, Set[PropertyKind]] = Map.empty
-        // Interim updates have to be suppressed when an analysis uses a property for which
-        // the wrong bounds/not enough bounds are computed.
-        transformersCS foreach { cs => suppressInterimUpdates += (cs.derivesLazily.get.pk -> cs.uses(ps).map(_.pk)) }
-
-        // 3. create the batch
-        val batchBuilder = List.newBuilder[ComputationSpecification[A]]
-        batchBuilder ++= lazyCS
-        batchBuilder ++= transformersCS
-        batchBuilder ++= triggeredCS
-        batchBuilder ++= eagerCS
-
-        // FIXME...
-
-        // Interim updates can be suppressed when the depender and dependee are not in a cyclic
-        // relation; however, this could have a negative impact on the effect of deep laziness -
-        // once we are actually implementing it. For the time being, suppress notifications is always
-        // advantageous.
-
-        val phase1Configuration = PropertyKindsConfiguration(
-            propertyKindsComputedInThisPhase = derivedProperties.map(_.pk),
-            suppressInterimUpdates = suppressInterimUpdates
-        )
-
-        PhaseConfiguration(phase1Configuration, batchBuilder.result())
+    private[this] def instantiateSchedulingStrategy(fqn: String): SchedulingStrategy = {
+        import scala.reflect.runtime.universe._
+        val mirror = runtimeMirror(this.getClass.getClassLoader)
+        val module = mirror.staticModule(fqn)
+        mirror.reflectModule(module).instance.asInstanceOf[SchedulingStrategy]
     }
 }
 
@@ -330,7 +312,10 @@ class AnalysisScenario[A](val ps: PropertyStore) {
  */
 object AnalysisScenario {
 
-    final val AnalysisAutoConfigKey = "org.opalj.fpcf.AnalysisScenario.AnalysisAutoConfig"
+    final val ConfigKeyPrefix = "org.opalj.fpcf.AnalysisScenario."
+
+    final val AnalysisAutoConfigKey = s"${ConfigKeyPrefix}AnalysisAutoConfig"
+    final val AnalysisSchedulingStrategyKey = s"${ConfigKeyPrefix}SchedulingStrategy"
 
     /**
      * @param analyses The set of analyses that should be executed as part of this analysis scenario.

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

@@ -619,14 +619,20 @@ abstract class PropertyStore {
         // Step 4
         // Save the information about the finalization order (of properties which are
         // collaboratively computed).
-        val cleanUpSubPhase =
-            (propertyKindsComputedInThisPhase -- finalizationOrder.flatten.toSet) + AnalysisKey
-        this.subPhaseFinalizationOrder =
+        val cleanUpSubPhase = propertyKindsComputedInThisPhase -- finalizationOrder.flatten.toSet
+
+        val finalizationWithAnalysisKey = finalizationOrder.zipWithIndex.map {
+            case (subPhase, 0) => subPhase :+ AnalysisKey // Add AnalysisKey to first sub-phase
+            case (subPhase, _) => subPhase // Keep other sub-phases unchanged
+        }
+
+        this.subPhaseFinalizationOrder = {
             if (cleanUpSubPhase.isEmpty) {
-                finalizationOrder.toArray
+                finalizationWithAnalysisKey
             } else {
-                (finalizationOrder :+ cleanUpSubPhase.toList).toArray
+                finalizationWithAnalysisKey :+ cleanUpSubPhase.toList
             }
+        }.toArray
 
         subPhaseId = 0
         hasSuppressedNotifications = suppressInterimUpdates.nonEmpty