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,6 @@ object Immutability {
 
         var projectTime: Seconds = Seconds.None
         var analysisTime: Seconds = Seconds.None
-        val callGraphTime: Seconds = Seconds.None
 
         val project = time {
             Project(
@@ -182,11 +181,13 @@ object Immutability {
         val propertyStore = project.get(PropertyStoreKey)
         val analysesManager = project.get(FPCFAnalysesManagerKey)
 
-        project.get(callgraphKey)
+        callgraphKey.requirements(project)
+
+        val allDependencies = dependencies ++ callgraphKey.allCallGraphAnalyses(project)
 
         time {
             analysesManager.runAll(
-                dependencies,
+                allDependencies,
                 {
                     (css: List[ComputationSpecification[FPCFAnalysis]]) =>
                         analysis match {
@@ -571,15 +572,14 @@ object Immutability {
                 |""".stripMargin
             )
 
-        val totalTime = projectTime + callGraphTime + analysisTime
+        val totalTime = projectTime + analysisTime
 
         stringBuilderNumber.append(
             s"""
             | running ${analysis.toString} analysis
             | took:
             |   $totalTime seconds total time
             |   $projectTime seconds project time
-            |   $callGraphTime seconds callgraph time
             |   $analysisTime seconds analysis time
             |""".stripMargin
         )

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

@@ -41,15 +41,12 @@ import org.opalj.br.fpcf.properties.ImpureByAnalysis
 import org.opalj.br.fpcf.properties.ImpureByLackOfInformation
 import org.opalj.br.fpcf.properties.Pure
 import org.opalj.br.fpcf.properties.SideEffectFree
-import org.opalj.br.fpcf.properties.cg.Callers
-import org.opalj.br.fpcf.properties.cg.NoCallers
 import org.opalj.bytecode.JRELibraryFolder
 import org.opalj.collection.immutable.IntTrieSet
 import org.opalj.fpcf.ComputationSpecification
 import org.opalj.fpcf.FinalEP
 import org.opalj.fpcf.FinalP
 import org.opalj.fpcf.FPCFAnalysesManagerKey
-import org.opalj.fpcf.FPCFAnalysis
 import org.opalj.fpcf.FPCFAnalysisScheduler
 import org.opalj.fpcf.FPCFLazyAnalysisScheduler
 import org.opalj.fpcf.PropertyStore
@@ -174,7 +171,6 @@ object Purity {
         var projectTime: Seconds = Seconds.None
         var propertyStoreTime: Seconds = Seconds.None
         var analysisTime: Seconds = Seconds.None
-        var callGraphTime: Seconds = Seconds.None
 
         // TODO: use variables for the constants
         implicit var config: Config =
@@ -251,24 +247,18 @@ object Purity {
 
         val manager = project.get(FPCFAnalysesManagerKey)
 
-        time {
-            project.get(callGraphKey)
-        } { t => callGraphTime = t.toSeconds }
+        callGraphKey.requirements(project)
 
-        val reachableMethods =
-            ps.entities(Callers.key).collect {
-                case FinalEP(m: DeclaredMethod, c: Callers) if c ne NoCallers => m
-            }.toSet
+        val allAnalyses = analysis :: support ++ callGraphKey.allCallGraphAnalyses(project)
 
         val contextProvider = project.get(ContextProviderKey)
-        val analyzedContexts = projMethods.filter(reachableMethods.contains).map(contextProvider.newContext(_))
+        val projectMethods: Set[DeclaredMethod] = declaredMethods.declaredMethods.toSet
+        val analyzedContexts = projMethods.filter(projectMethods.contains).map(contextProvider.newContext(_))
 
         time {
-            val analyses = analysis :: support
-
             manager.runAll(
-                analyses,
-                (css: List[ComputationSpecification[FPCFAnalysis]]) =>
+                allAnalyses,
+                (css: List[ComputationSpecification[org.opalj.fpcf.FPCFAnalysis]]) =>
                     if (css.contains(analysis)) {
                         analyzedContexts.foreach { dm => ps.force(dm, br.fpcf.properties.Purity.key) }
                     }
@@ -340,8 +330,8 @@ object Purity {
                 if (newFile) {
                     output.createNewFile()
                     outputWriter.println(
-                        "analysisName;project time;propertyStore time;" +
-                            "callGraph time;analysis time; total time;" +
+                        "analysisName;project time;" +
+                            "propertyStore time;analysis time; total time;" +
                             "compile time pure;pure;domain-specific pure;" +
                             "side-effect free;domain-specific side-effect free;" +
                             "externally pure;domain-specific externally pure;" +
@@ -351,11 +341,10 @@ object Purity {
                             "side-effect free;impure;count"
                     )
                 }
-                val totalTime = projectTime + propertyStoreTime + callGraphTime + analysisTime
+                val totalTime = projectTime + propertyStoreTime + analysisTime
                 outputWriter.println(
                     s"${configurationName.get};${projectTime.toString(false)};" +
                         s"${propertyStoreTime.toString(false)};" +
-                        s"${callGraphTime.toString(false)};" +
                         s"${analysisTime.toString(false)};" +
                         s"${totalTime.toString(false)};" +
                         s"${compileTimePure.size};${pure.size};${dPure.size};" +
@@ -473,7 +462,6 @@ object Purity {
                     "\nImpure:                                " + lbImpure.size +
                     "\nTotal:                                 " + projectEntitiesWithPurity.size
             Console.println(result)
-            Console.println(s"Call-graph time: $callGraphTime")
             Console.println(s"Analysis time: $analysisTime")
         }
     }

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.MaximumPhaseScheduling"
+      ScheduleLazyInMultiplePhases = true
+    } 
+  } 
 
   si.flowanalysis.StructuralAnalysis {
     maxIterations = 1000