Implement VTA in new IFDS for evaluation

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/NewIFDSEvaluation.scala

@@ -0,0 +1,31 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.tac.fpcf.analyses
+
+import java.io.File
+
+import org.opalj.tac.fpcf.analyses.heros.analyses.HerosVariableTypeAnalysisRunner
+import org.opalj.tac.fpcf.analyses.ifds.old
+import org.opalj.tac.fpcf.analyses.ifds.IFDSBasedVariableTypeAnalysisRunner
+
+/**
+ * Generates some evaluation files related to the AbstractIFDSAnalysis.
+ *
+ * @author Mario Trageser
+ */
+object NewIFDSEvaluation {
+
+    /**
+     * args should contain exactly one parameter:
+     * A directory, which will contain the evaluation files; terminated with a '/'.
+     *
+     */
+    def main(args: Array[String]): Unit = {
+        val dir = args(0)
+        new File(dir).mkdirs
+
+        old.IFDSBasedVariableTypeAnalysisRunner.main(Array("-seq", "-l2", "-f", dir+"OldIFDSBasedVariableTypeAnalysis.txt"))
+        HerosVariableTypeAnalysisRunner.main(Array("-f", dir+"HerosVariableTypeAnalysis.txt"))
+        IFDSBasedVariableTypeAnalysisRunner.main(Array("-seq", "-l2", "-f", dir+"IFDSBasedVariableTypeAnalysis.txt"))
+    }
+
+}

OPAL/ifds/src/main/scala/org/opalj/ifds/IFDSAnalysis.scala

@@ -68,17 +68,19 @@ case class PathEdges[IFDSFact <: AbstractIFDSFact, S <: Statement[_ <: C, _], C]
                 true
             case Some(Left(existingFacts)) =>
                 if (predecessor.isDefined) throw new IllegalArgumentException(s"${statement} does not accept a predecessor")
-                val isNew = !existingFacts.contains(fact)
-                edges = edges.updated(statement, Left(existingFacts + fact))
-                isNew
+                if (isNew(existingFacts, fact)) {
+                    edges = edges.updated(statement, Left(existingFacts + fact))
+                    true
+                } else false
             case Some(Right(existingFacts)) =>
                 predecessor match {
                     case None => throw new IllegalArgumentException(s"${statement} requires a predecessor")
                     case Some(predecessor) => existingFacts.get(statement) match {
                         case Some(existingPredecessorFacts) => {
-                            val isNew = !existingPredecessorFacts.contains(fact)
-                            edges = edges.updated(statement, Right(existingFacts.updated(predecessor, existingPredecessorFacts + fact)))
-                            isNew
+                            if (isNew(existingPredecessorFacts, fact)) {
+                                edges = edges.updated(statement, Right(existingFacts.updated(predecessor, existingPredecessorFacts + fact)))
+                                true
+                            } else false
                         }
                         case None => {
                             edges = edges.updated(statement, Right(existingFacts.updated(predecessor, Set(fact))))
@@ -89,6 +91,8 @@ case class PathEdges[IFDSFact <: AbstractIFDSFact, S <: Statement[_ <: C, _], C]
         }
     }
 
+    private def isNew(existingFacts: Set[IFDSFact], newFact: IFDSFact): Boolean = !existingFacts.contains(newFact)
+
     /**
      * @param statement
      * @return The edges reaching statement if any. In case the statement minds about predecessors it is a map with an entry for each predecessor
@@ -121,7 +125,7 @@ protected class IFDSState[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statem
 /**
  * Contains int variables, which count, how many times some method was called.
  */
-protected class Statistics {
+class Statistics {
     var normalFlow = 0
     var callFlow = 0
     var returnFlow = 0

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/ifds/EvaluationRunner.scala

@@ -0,0 +1,192 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.tac.fpcf.analyses.ifds
+
+import java.io.File
+import java.io.PrintWriter
+import scala.language.existentials
+import com.typesafe.config.ConfigValueFactory
+import org.opalj.bytecode
+import org.opalj.ifds.Statistics
+import org.opalj.ifds.IFDSAnalysis
+import org.opalj.ifds.IFDSAnalysisScheduler
+
+import org.opalj.util.Milliseconds
+import org.opalj.util.PerformanceEvaluation.time
+import org.opalj.fpcf.FinalEP
+import org.opalj.fpcf.PropertyStore
+import org.opalj.fpcf.seq.PKESequentialPropertyStore
+import org.opalj.br.fpcf.FPCFAnalysesManagerKey
+import org.opalj.br.DeclaredMethod
+import org.opalj.br.analyses.Project
+import org.opalj.br.analyses.SomeProject
+import org.opalj.br.fpcf.PropertyStoreKey
+import org.opalj.ai.domain.l0.PrimitiveTACAIDomain
+import org.opalj.ai.domain.l2
+import org.opalj.ai.fpcf.properties.AIDomainFactoryKey
+import org.opalj.tac.cg.RTACallGraphKey
+import org.opalj.tac.fpcf.properties.cg.Callers
+
+abstract class EvaluationRunner {
+
+    protected def analysisClass: IFDSAnalysisScheduler[_, _, _]
+
+    protected def printAnalysisResults(analysis: IFDSAnalysis[_, _, _], ps: PropertyStore): Unit = ()
+
+    protected def run(
+        debug:                    Boolean,
+        useL2:                    Boolean,
+        delay:                    Boolean,
+        evalSchedulingStrategies: Boolean,
+        evaluationFile:           Option[File]
+    ): Unit = {
+
+        if (debug) {
+            PropertyStore.updateDebug(true)
+        }
+
+        def evalProject(p: SomeProject): (Milliseconds, Statistics, Option[Object]) = {
+            if (useL2) {
+                p.updateProjectInformationKeyInitializationData(AIDomainFactoryKey) {
+                    case None => Set(classOf[l2.DefaultPerformInvocationsDomainWithCFGAndDefUse[_]])
+                    case Some(requirements) =>
+                        requirements + classOf[l2.DefaultPerformInvocationsDomainWithCFGAndDefUse[_]]
+                }
+            } else {
+                p.updateProjectInformationKeyInitializationData(AIDomainFactoryKey) {
+                    case None               => Set(classOf[PrimitiveTACAIDomain])
+                    case Some(requirements) => requirements + classOf[PrimitiveTACAIDomain]
+                }
+            }
+
+            val ps = p.get(PropertyStoreKey)
+            var analysisTime: Milliseconds = Milliseconds.None
+            p.get(RTACallGraphKey)
+            println("Start: "+new java.util.Date)
+            org.opalj.util.gc()
+            val analysis =
+                time {
+                    p.get(FPCFAnalysesManagerKey).runAll(analysisClass)._2
+                }(t => analysisTime = t.toMilliseconds).collect {
+                    case (_, a: IFDSAnalysis[_, _, _]) => a
+                }.head
+
+            printAnalysisResults(analysis, ps)
+            println(s"The analysis took $analysisTime.")
+            println(
+                ps.statistics.iterator
+                    .map(_.toString())
+                    .toList
+                    .sorted
+                    .mkString("PropertyStore Statistics:\n\t", "\n\t", "\n")
+            )
+            (
+                analysisTime,
+                analysis.statistics,
+                additionalEvaluationResult(analysis)
+            )
+        }
+
+        val p = Project(bytecode.RTJar)
+
+        if (delay) {
+            println("Sleeping for three seconds.")
+            Thread.sleep(3000)
+        }
+
+        if (evalSchedulingStrategies) {
+            val results = for {
+                i <- 1 to EvaluationRunner.NUM_EXECUTIONS_EVAL_SCHEDULING_STRATEGIES
+                strategy <- PKESequentialPropertyStore.Strategies
+            } yield {
+                println(s"Round: $i - $strategy")
+                val strategyValue = ConfigValueFactory.fromAnyRef(strategy)
+                val newConfig =
+                    p.config.withValue(PKESequentialPropertyStore.TasksManagerKey, strategyValue)
+                val evaluationResult = evalProject(Project.recreate(p, newConfig))
+                org.opalj.util.gc()
+                (i, strategy, evaluationResult._1, evaluationResult._2)
+            }
+            println(results.mkString("AllResults:\n\t", "\n\t", "\n"))
+            if (evaluationFile.nonEmpty) {
+                val pw = new PrintWriter(evaluationFile.get)
+                PKESequentialPropertyStore.Strategies.foreach { strategy =>
+                    val strategyResults = results.filter(_._2 == strategy)
+                    val averageTime = strategyResults.map(_._3.timeSpan).sum / strategyResults.size
+                    val (normalFlow, callToStart, exitToReturn, callToReturn) =
+                        computeAverageStatistics(strategyResults.map(_._4))
+                    pw.println(s"Strategy $strategy:")
+                    pw.println(s"Average time: ${averageTime}ms")
+                    pw.println(s"Average calls of normalFlow: $normalFlow")
+                    pw.println(s"Average calls of callToStart: $callToStart")
+                    pw.println(s"Average calls of exitToReturn: $exitToReturn")
+                    pw.println(s"Average calls of callToReturn: $callToReturn")
+                    pw.println()
+                }
+                pw.close()
+            }
+        } else {
+            var times = Seq.empty[Milliseconds]
+            var statistics = Seq.empty[Statistics]
+            var additionalEvaluationResults = Seq.empty[Object]
+            for {
+                _ <- 1 to EvaluationRunner.NUM_EXECUTIONS
+            } {
+                val evaluationResult = evalProject(Project.recreate(p))
+                val additionalEvaluationResult = evaluationResult._3
+                times :+= evaluationResult._1
+                statistics :+= evaluationResult._2
+                if (additionalEvaluationResult.isDefined)
+                    additionalEvaluationResults :+= additionalEvaluationResult.get
+            }
+            if (evaluationFile.nonEmpty) {
+                val (normalFlow, callFlow, returnFlow, callToReturnFlow) = computeAverageStatistics(
+                    statistics
+                )
+                val time = times.map(_.timeSpan).sum / times.size
+                val pw = new PrintWriter(evaluationFile.get)
+                pw.println(s"Average time: ${time}ms")
+                pw.println(s"Average calls of normalFlow: $normalFlow")
+                pw.println(s"Average calls of callFlow: $callFlow")
+                pw.println(s"Average calls of returnFlow: $returnFlow")
+                pw.println(s"Average calls of callToReturnFlow: $callToReturnFlow")
+                if (additionalEvaluationResults.nonEmpty)
+                    writeAdditionalEvaluationResultsToFile(pw, additionalEvaluationResults)
+                pw.close()
+            }
+        }
+    }
+
+    protected def additionalEvaluationResult(analysis: IFDSAnalysis[_, _, _]): Option[Object] = None
+
+    protected def writeAdditionalEvaluationResultsToFile(
+        writer:                      PrintWriter,
+        additionalEvaluationResults: Seq[Object]
+    ): Unit = {}
+
+    protected def canBeCalledFromOutside(
+        method:        DeclaredMethod,
+        propertyStore: PropertyStore
+    ): Boolean =
+        propertyStore(method, Callers.key) match {
+            // This is the case, if the method may be called from outside the library.
+            case FinalEP(_, p: Callers) => p.hasCallersWithUnknownContext
+            case _ =>
+                throw new IllegalStateException(
+                    "call graph mut be computed before the analysis starts"
+                )
+        }
+
+    private def computeAverageStatistics(statistics: Seq[Statistics]): (Int, Int, Int, Int) = {
+        val length = statistics.length
+        val normalFlow = statistics.map(_.normalFlow).sum / length
+        val callFlow = statistics.map(_.callFlow).sum / length
+        val returnFlow = statistics.map(_.returnFlow).sum / length
+        val callToReturnFlow = statistics.map(_.callToReturnFlow).sum / length
+        (normalFlow, callFlow, returnFlow, callToReturnFlow)
+    }
+}
+
+object EvaluationRunner {
+    var NUM_EXECUTIONS = 10
+    var NUM_EXECUTIONS_EVAL_SCHEDULING_STRATEGIES = 2
+}

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/ifds/IFDSBasedVariableTypeAnalysis.scala

@@ -0,0 +1,108 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.tac.fpcf.analyses.ifds
+
+import org.opalj.br.analyses.SomeProject
+import org.opalj.fpcf.{PropertyBounds, PropertyKey, PropertyStore}
+import org.opalj.ifds.old.{NumberOfSubsumptions, Subsuming}
+import org.opalj.ifds.{IFDSProperty, IFDSPropertyMetaInformation}
+
+import org.opalj.tac.fpcf.properties.TACAI
+import org.opalj.tac.fpcf.properties.cg.Callers
+import java.io.{File, PrintWriter}
+
+import org.opalj.ifds.IFDSAnalysis
+import org.opalj.ifds.IFDSAnalysisScheduler
+
+import org.opalj.br.Method
+import org.opalj.br.analyses.DeclaredMethodsKey
+import org.opalj.br.analyses.ProjectInformationKeys
+import org.opalj.br.fpcf.PropertyStoreKey
+import org.opalj.tac.cg.TypeProviderKey
+
+/**
+ * A variable type analysis implemented as an IFDS analysis.
+ * In contrast to an ordinary variable type analysis, which also determines types of fields,
+ * this analysis only determines the types of local variables.
+ * The subsuming taint can be mixed in to enable subsuming.
+ *
+ * @param project The analyzed project.
+ * @author Mario Trageser
+ */
+class IFDSBasedVariableTypeAnalysis(project: SomeProject)
+    extends IFDSAnalysis()(project, new VariableTypeProblem(project), VTAResult)
+
+object IFDSBasedVariableTypeAnalysisScheduler extends IFDSAnalysisScheduler[VTAFact, Method, JavaStatement] {
+    override def init(p: SomeProject, ps: PropertyStore) = new IFDSBasedVariableTypeAnalysis(p)
+    override def property: IFDSPropertyMetaInformation[JavaStatement, VTAFact] = VTAResult
+    override val uses: Set[PropertyBounds] = Set(PropertyBounds.finalP(TACAI), PropertyBounds.finalP(Callers))
+    override def requiredProjectInformation: ProjectInformationKeys = Seq(DeclaredMethodsKey, TypeProviderKey, PropertyStoreKey)
+}
+
+/**
+ * The IFDSProperty for this analysis.
+ */
+case class VTAResult(flows: Map[JavaStatement, Set[VTAFact]], debugData: Map[JavaStatement, Set[VTAFact]] = Map.empty) extends IFDSProperty[JavaStatement, VTAFact] {
+
+    override type Self = VTAResult
+    override def create(result: Map[JavaStatement, Set[VTAFact]]): IFDSProperty[JavaStatement, VTAFact] = new VTAResult(result)
+    override def create(result: Map[JavaStatement, Set[VTAFact]], debugData: Map[JavaStatement, Set[VTAFact]]): IFDSProperty[JavaStatement, VTAFact] = new VTAResult(result, debugData)
+
+    override def key: PropertyKey[VTAResult] = VTAResult.key
+}
+
+object VTAResult extends IFDSPropertyMetaInformation[JavaStatement, VTAFact] {
+
+    override type Self = VTAResult
+    override def create(result: Map[JavaStatement, Set[VTAFact]]): IFDSProperty[JavaStatement, VTAFact] = new VTAResult(result)
+    override def create(result: Map[JavaStatement, Set[VTAFact]], debugData: Map[JavaStatement, Set[VTAFact]]): IFDSProperty[JavaStatement, VTAFact] = new VTAResult(result, debugData)
+
+    val key: PropertyKey[VTAResult] = PropertyKey.create("VTAnew", new VTAResult(Map.empty))
+}
+
+class IFDSBasedVariableTypeAnalysisRunner extends EvaluationRunner {
+
+    override def analysisClass: IFDSBasedVariableTypeAnalysisScheduler.type = IFDSBasedVariableTypeAnalysisScheduler
+
+    override protected def additionalEvaluationResult(
+        analysis: IFDSAnalysis[_, _, _]
+    ): Option[Object] =
+        analysis match {
+            case subsuming: Subsuming[_, _] => Some(subsuming.numberOfSubsumptions)
+            case _                          => None
+        }
+
+    override protected def writeAdditionalEvaluationResultsToFile(
+        writer:                      PrintWriter,
+        additionalEvaluationResults: Seq[Object]
+    ): Unit = {
+        val numberOfSubsumptions = additionalEvaluationResults.map(_.asInstanceOf[NumberOfSubsumptions])
+        val length = additionalEvaluationResults.length
+        val tries = numberOfSubsumptions.map(_.triesToSubsume).sum / length
+        val successes = numberOfSubsumptions.map(_.successfulSubsumes).sum / length
+        writer.println(s"Average tries to subsume: $tries")
+        writer.println(s"Average successful subsumes: $successes")
+    }
+}
+
+object IFDSBasedVariableTypeAnalysisRunner {
+    def main(args: Array[String]): Unit = {
+        if (args.contains("--help")) {
+            println("Potential parameters:")
+            println(" -seq (to use the SequentialPropertyStore)")
+            println(" -l2 (to use the l2 domain instead of the default l1 domain)")
+            println(" -delay (for a three seconds delay before the taint flow analysis is started)")
+            println(" -debug (for debugging mode in the property store)")
+            println(" -evalSchedulingStrategies (evaluates all available scheduling strategies)")
+            println(" -f <file> (Stores the average runtime to this file)")
+        } else {
+            val fileIndex = args.indexOf("-f")
+            new IFDSBasedVariableTypeAnalysisRunner().run(
+                args.contains("-debug"),
+                args.contains("-l2"),
+                args.contains("-delay"),
+                args.contains("-evalSchedulingStrategies"),
+                if (fileIndex >= 0) Some(new File(args(fileIndex + 1))) else None
+            )
+        }
+    }
+}

OPAL/tac/src/main/scala/org/opalj/tac/fpcf/analyses/ifds/JavaIFDSProblem.scala

@@ -47,6 +47,9 @@ object JavaStatement {
 
 abstract class JavaIFDSProblem[Fact <: AbstractIFDSFact](project: SomeProject)
     extends IFDSProblem[Fact, Method, JavaStatement](new ForwardICFG()(project)) {
+
+    override def needsPredecessor(statement: JavaStatement): Boolean = false
+
     /**
      * Gets the call object for a statement that contains a call.
      *