Persisting the analysis state

.gitignore

@@ -32,3 +32,4 @@ out/
 *.zo
 __pycache__
 stats/
+res.json

build.sbt

@@ -23,6 +23,8 @@ lazy val maf = crossProject(JVMPlatform, JSPlatform)
     libraryDependencies += ("com.typesafe.akka" %% "akka-actor-typed" % "2.6.18").cross(CrossVersion.for3Use2_13),
     libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.10",
     libraryDependencies += "com.typesafe" % "config" % "1.4.1",
+	libraryDependencies += "io.bullet" %% "borer-core" % "1.10.0",
+	libraryDependencies += "io.bullet" %% "borer-derivation" % "1.10.0",
     /** Compilation options */
     maxErrors := 5,
     /** Configuration for running the tests */

code/jvm/src/main/scala/maf/cli/experiments/SchemeAnalyses.scala

@@ -21,6 +21,9 @@ import maf.modular.scheme.modactor.mirrors.ModActorWithMirrors
 import maf.modular.scheme.modactor.mirrors.SimpleModActorWithMirrors
 import maf.language.racket.RacketLoaderSemantics
 import maf.language.racket.RacketLoader
+import maf.save.LoadFIFOWorklist
+import maf.save.LoadModF
+import maf.save.SaveModF
 
 object SchemeAnalysesBoundedDomain:
     object NoSensitivity:
@@ -55,8 +58,15 @@ object SchemeAnalyses:
 
     def contextInsensitiveAnalysis(
         prg: SchemeExp
-      ) = new SimpleSchemeModFAnalysis(prg) with SchemeModFNoSensitivity with SchemeConstantPropagationDomain with FIFOWorklistAlgorithm[SchemeExp] {
+      ) = new SimpleSchemeModFAnalysis(prg)
+        with SchemeModFNoSensitivity
+        with SchemeConstantPropagationDomain
+        with FIFOWorklistAlgorithm[SchemeExp]
+        with SaveModF
+        with LoadModF
+        with LoadFIFOWorklist[SchemeExp] {
         override def toString = "no-sensitivity"
+        override val analysisName: String = "modf"
     }
 
     //def contextInsensitiveAnalysisRacket(

code/jvm/src/main/scala/maf/cli/runnables/Repl.scala

@@ -32,6 +32,8 @@ object Repl:
     | * -t TIMEOUT: run the analysis with the given timeout (in seconds). Defaults to 10.
     | * -dot  set flag to enable outputting a FILENAME.dot file that contains a visualisation of results of the analysis, only works with "-f"
     | * -m load the given Racket module, use instead of "-f"
+    | * -s FILENAME: the name of the file where the analysis should be saved to when finished
+    | * -l FILENAME: the name of the file where the analysis should be loaded from
     """.stripMargin
 
     private val configurationsHelp: Map[String, String] = Map(
@@ -79,7 +81,9 @@ object Repl:
         interactive: Boolean = false,
         performance: Boolean = false,
         dot: Boolean = false,
-        timeout: Long = 10):
+        timeout: Long = 10,
+        saveFile: Option[String] = None,
+        loadFile: Option[String] = None):
         def isEmpty: Boolean = remaining.isEmpty
         def continue(remaining: List[String]): ArgParser = this.copy(remaining = remaining)
         def setAnalysis(analysis: String): ArgParser =
@@ -90,6 +94,14 @@ object Repl:
             ensureNotSet(this.filename, "filename")
             this.copy(filename = Some(filename))
 
+        def setSaveFilename(filename: String): ArgParser =
+            ensureNotSet(this.saveFile, "saveFile")
+            this.copy(saveFile = Some(filename))
+
+        def setLoadFilename(filename: String): ArgParser =
+            ensureNotSet(this.loadFile, "loadFile")
+            this.copy(loadFile = Some(filename))
+
         def setParser(parser: String): ArgParser =
             ensureNotSet(this.parser, "parser")
             this.copy(parser = Some(parser))
@@ -132,6 +144,12 @@ object Repl:
                 case "-dot" :: rest =>
                     parse(parser.copy(dot = true).continue(rest))
 
+                case "-s" :: filename :: rest =>
+                    parse(parser.setSaveFilename(filename).continue(rest))
+
+                case "-l" :: filename :: rest =>
+                    parse(parser.setLoadFilename(filename).continue(rest))
+
                 case arg =>
                     throw new Exception(s"invalid arguments $arg")
 
@@ -171,19 +189,25 @@ object Repl:
         performance: Boolean,
         timeout: Long,
         dot: Boolean,
+        saveFile: Option[String] = None,
+        loadFile: Option[String] = None,
         someLoader: Option[String => SchemeExp] = None
       ): Unit =
         val loader: String => SchemeExp = someLoader.getOrElse(Reader.loadFile andThen parser.parse)
         // Regardless of the performance mode, we parse the file only once.
         val exp = loader(filename)
         def runSingle(): Long =
             val anl = makeAnalysis(exp)
-            val (elapsed, _) = Timer.time { anl.analyzeWithTimeout(Timeout.start(timeout.seconds)) }
+            if loadFile.isDefined then
+                val (elapsed, _) = Timer.time { anl.load(loadFile.get) } //anl.analyzeWithTimeout(Timeout.start(timeout.seconds)) }
+                println(s"load time: ${elapsed / 1000000}")
+            val (elapsed, _) = Timer.time { anl.analyze() } //anl.analyzeWithTimeout(Timeout.start(timeout.seconds)) }
             // Do not print results if we are in perfomance testing mode
             if !performance then
                 if !anl.finished then println("Analysis timed out")
                 anl.printResult
                 println(s"Analysis took ${elapsed / (1000 * 1000)} ms")
+                if saveFile.isDefined then anl.save(saveFile.get)
             // Print a dot graph if the dot option has been enabled
             if dot then anl.toDot(filename.replace("/", "_").nn + ".dot")
             elapsed
@@ -221,7 +245,7 @@ object Repl:
         else runSingle()
 
     /** Runs a REPL that can be used to interactively test the abstract interpreter */
-    private def runRepl(parser: P, makeAnalysis: A): Unit =
+    private def runRepl(parser: P, makeAnalysis: A, saveFile: Option[String]): Unit =
         def repl(): Unit =
             print(">")
             val program = readLine().trim().nn
@@ -232,6 +256,7 @@ object Repl:
 
                 anl.printResult
                 println(s"Analysis took ${elapsed / (1000 * 1000)} ms")
+                if saveFile.isDefined then anl.save(saveFile.get)
                 repl()
         repl()
 
@@ -251,6 +276,8 @@ object Repl:
             assert(if options.dot then options.filename.isDefined else true, "-dot can only be combined with -f")
             // ensure that "-m" is not combined with "-f"
             assert(if options.module.isDefined then !options.filename.isDefined else true, "-m can not be combined with -f")
+            // ensure that "-i" is not combined with "-l"
+            assert(!(options.interactive && options.loadFile.isDefined), "-i can not be combined with -l")
             // setup the parser
             val parser = setupParser(options.parser)
             // setup the loader
@@ -261,8 +288,8 @@ object Repl:
             val analysisFactory = setupAnalysis(options.analysis.get)
             // setup the loader of the file/module
             // either run the file or the repl
-            if options.interactive then runRepl(parser, analysisFactory)
+            if options.interactive then runRepl(parser, analysisFactory, options.saveFile)
             else
                 // retrieve the file or module name
                 val path = options.filename.getOrElse(options.module.get)
-                runFile(path, parser, analysisFactory, options.performance, options.timeout, options.dot, loader)
+                runFile(path, parser, analysisFactory, options.performance, options.timeout, options.dot, options.saveFile, options.loadFile, loader)

code/shared/src/main/scala/maf/language/scheme/SchemeExp.scala

@@ -379,7 +379,7 @@ sealed trait SchemeLettishExp extends SchemeExp:
     val body: List[SchemeExp]
     val idn: Identity
     override type T <: SchemeLettishExp
-    override val height: Int = 1 + bindings.foldLeft(0)((mx, b) => mx.max(b._2.height).max(body.foldLeft(0)((mx, e) => mx.max(e.height))))
+    override val height: Int = 1 + bindings.foldLeft(0)((mx, b) => mx.max(b._2.height)).max(body.foldLeft(0)((mx, e) => mx.max(e.height)))
     def subexpressions: List[Expression] = bindings.foldLeft(List[Expression]())((a, b) => b._2 :: b._1 :: a) ::: body
     override def isomorphic(other: Expression): Boolean = super.isomorphic(other) && body.length == other.asInstanceOf[SchemeLettishExp].body.length
     override def eql(other: Expression): Boolean = super.eql(other) && body.length == other.asInstanceOf[SchemeLettishExp].body.length
@@ -1048,6 +1048,7 @@ case class SchemeAssert(exp: SchemeExp, idn: Identity) extends SchemeExp:
     override def toString: String = s"(assert $exp)"
     def fv: Set[String] = exp.fv
     val label: Label = ASS
+    override val height: Int = 1 + exp.height
 
     override def deepDropIdentifier(id: Identifier): Option[SchemeExp] =
       exp.deepDropIdentifier(id) match

code/shared/src/main/scala/maf/modular/ModAnalysis.scala

@@ -18,6 +18,9 @@ case class Metric(name: String, result: Double)
 
 /** Super type of all analyses in MAF, provides basic entry points to the analysis */
 trait AnalysisEntry[Exp <: Expression]:
+    /** The name of the analysis */
+    val analysisName: String = "None"
+
     /** Returns a boolean indicating whether the analysis has finished. Implementation should be provided by the work list algorithm. */
     def finished: Boolean
 
@@ -40,6 +43,42 @@ trait AnalysisEntry[Exp <: Expression]:
     /** Method that defines how to print the result of the analysis */
     def printResult: Unit = println(result)
 
+    /**
+     * This saves the current analysis to a file
+     *
+     * @param filename
+     *   The file to save to
+     */
+    def save(filename: String): Unit = System.err.nn.println("Save functionality is not implemented for this analysis")
+
+    /**
+     * This saves the current analysis to a file, but only the elements that are in save
+     *
+     * @param filename
+     *   The file to save to
+     * @param save
+     *   The elements to save
+     */
+    def save(filename: String, save: Set[String]): Unit = System.err.nn.println("Save functionality is not implemented for this analysis")
+
+    /**
+     * Load an analysis from a given file
+     *
+     * @param filename
+     *   The file to load the analysis from
+     */
+    def load(filename: String): Unit = System.err.nn.println("Load functionality is not implemented for this analysis")
+
+    /**
+     * Load the given elements of an analysis from a given file
+     *
+     * @param filename
+     *   The file to load the analysis from
+     * @param load
+     *   The elements to load
+     */
+    def load(filename: String, load: Set[String]): Unit = System.err.nn.println("Load functionality is not implemented for this analysis")
+
     /**
      * Method that renders a Dot graph of the components and the dependencies between them and writes it to a file
      *
@@ -134,6 +173,8 @@ abstract class ModAnalysis[Expr <: Expression](val program: Expr) extends Clonea
 
     // flag to indicate if the analysis has already been initialized (see method `init`)
     private var initialized: Boolean = false
+    def analysisInitialized = initialized
+    def analysisInitialized_=(init: Boolean) = initialized = init
 
     /* Runs the analysis with a timeout. Implementation should be provided by the worklist algorithm. */
     protected def run(timeout: Timeout.T): Unit
@@ -167,5 +208,4 @@ abstract class ModAnalysis[Expr <: Expression](val program: Expr) extends Clonea
     // Print analysis information.
 
     def configString(): String = "Modular analysis"
-
 }

code/shared/src/main/scala/maf/modular/scheme/modf/SchemeModFSemantics.scala

@@ -14,6 +14,9 @@ import maf.util._
 import maf.core.IdentityMonad.given
 import maf.core.Monad.MonadIterableOps
 import maf.core.Monad.MonadSyntaxOps
+import maf.save.SaveModF
+import maf.save.Savable
+import maf.save.LoadModF
 
 trait BaseEvalM[M[_]] extends Monad[M] with MonadError[M, Error] with MonadJoin[M]
 
@@ -71,7 +74,7 @@ trait BaseSchemeModFSemanticsM
             caller: Component
           ): M[ComponentContext] = Monad[M].unit(allocCtx(clo, args, call, caller))
 
-    lazy val mainBody = program
+    var mainBody = program
     def expr(cmp: Component): SchemeExp = body(cmp)
     def body(cmp: Component): SchemeExp = body(view(cmp))
     def body(cmp: SchemeModFComponent): SchemeExp = cmp match

code/shared/src/main/scala/maf/persistence/load/Analysis.scala

@@ -0,0 +1,122 @@
+package maf.save
+
+import io.bullet.borer.Decoder
+import io.bullet.borer.Json
+import maf.core.Expression
+import java.nio.file.Paths
+import java.nio.file.Files
+import maf.language.scheme.SchemeExp
+import io.bullet.borer.Reader
+import scala.collection.mutable.HashMap
+import maf.modular.AnalysisEntry
+import maf.modular.ModAnalysis
+import scala.collection.mutable.ListBuffer
+import io.bullet.borer.Cbor
+
+/**
+ * Contains info about the top-level objects that need to be loaded.
+ *
+ * @param load
+ *   Function that should be called with the value after it was decoded
+ * @param decoder
+ *   Decodes the value
+ * @tparam T
+ *   The type of the value the needs to be loaded
+ */
+case class Loadable[T](val load: (T) => Unit)(using val decoder: Decoder[T])
+
+/**
+ * The base trait for saving an analysis.
+ *
+ * Implementing this allows you to load your analysis, by default it will only load the name of your analysis and you should mixin other traits like
+ * [[LoadComponents]] to also load components.
+ *
+ * @tparam Expr
+ *   The type of expression used in the analysis
+ */
+trait Load[Expr <: Expression] extends AnalysisEntry[Expr]:
+    /** Decode an analysis. */
+    given analysisDecoder: Decoder[Load[Expr]] with
+        override def read(reader: Reader): Load[Expr] =
+            val loadInfo = Load.this.loadInfo
+            loadSet = loadInfo.map(_._1).toSet
+            reader.read[Load[Expr]]()
+            loadSet = Set[String]()
+            return Load.this
+
+    protected var loadSet = Set[String]()
+    protected given excludedAnalysisDecoder: MapDecoder[Load[Expr]] with
+        override def read(reader: Reader): Load[Expr] =
+            reader.start()
+            for (key, value) <- loadInfo do
+                if loadSet.contains(key) then
+                    val result = reader.readMember(key)(using value.decoder)
+                    value.load(result)
+            reader.close()
+            return Load.this
+
+    def startLoad(): Unit = return
+
+    override def load(filename: String): Unit =
+        startLoad()
+        val bytes = Files.readAllBytes(Paths.get(filename))
+        if bytes != null then Json.decode(bytes).to[Load[Expr]](using analysisDecoder).value
+
+    override def load(filename: String, load: Set[String]): Unit =
+        startLoad()
+        val bytes = Files.readAllBytes(Paths.get(filename))
+        if bytes != null then Json.decode(bytes).to[Load[Expr]](using excludedAnalysisDecoder).value
+
+    /**
+     * Returns a map strings and [[Loadable]] s.
+     *
+     * This map defines all top-level objects that should be loaded in your analysis, and the key with which they should be loaded. If you want to
+     * load something else, you can override this method and add something to it.
+     *
+     * {{{
+     * override def loadInfo: Map[String, Loadable[_]] =
+     *     super.loadInfo + ("< key >" -> Loadable[< loadType >]((< loaded object >: < SaveType >) => < put loaded object into analysis >))
+     * }}}
+     */
+    def loadInfo: List[(String, Loadable[_])] = List(("name", Loadable((name: String) => ())))
+
+trait LoadCbor[Expr <: Expression] extends Load[Expr]:
+    override def load(filename: String): Unit =
+        startLoad()
+        val bytes = Files.readAllBytes(Paths.get(filename))
+        if bytes != null then Cbor.decode(bytes).to[Load[Expr]](using analysisDecoder).value
+
+    override def load(filename: String, load: Set[String]): Unit =
+        startLoad()
+        val bytes = Files.readAllBytes(Paths.get(filename))
+        if bytes != null then Json.decode(bytes).to[Load[Expr]](using excludedAnalysisDecoder).value
+
+trait LoadInitialized[Expr <: Expression] extends ModAnalysis[Expr] with Load[Expr]:
+    override def loadInfo: List[(String, Loadable[?])] =
+        super.loadInfo ++ List(
+          ("initialized",
+           Loadable((initialized: Boolean) =>
+               if !visited.contains(initialComponent) then visited = visited + initialComponent
+               analysisInitialized = initialized
+           )
+          )
+        )
+
+/** The trait used to load the modF analysis. */
+trait LoadModF
+    extends Load[SchemeExp]
+    with LoadInitialized[SchemeExp]
+    with LoadSchemeExpressions
+    // with LoadExpressionIntID[SchemeExp]
+    with LoadActualExpressions[SchemeExp]
+    with LoadMainSchemeBody
+    with LoadComponents[SchemeExp]
+    // with LoadComponentIntID[SchemeExp]
+    with LoadActualComponents[SchemeExp]
+    with LoadStandardSchemeComponents
+    with LoadNoContext[SchemeExp]
+    with LoadSchemeAddr
+    with LoadDependency[SchemeExp]
+    with LoadAddrDependency[SchemeExp]
+    with LoadGlobalStore[SchemeExp]
+    with LoadModularSchemeDomain