a simple test case to show immutable's improvements

Author: butterunderflow

benchmarks/wasm/staged/long-trivial-execution.wat

@@ -0,0 +1,54 @@
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (param i32)))
+  (import "console" "assert" (func (type 1)))
+  (func (;1;) (type 0)
+    (local i32 i32)
+    i32.const 1
+    local.set 0
+    i32.const 0
+    local.set 1
+    block
+      loop
+        local.get 0
+        i32.const 10000
+        i32.ge_s
+        br_if 1
+        local.get 1
+        i32.const 0
+        i32.add
+        local.set 1
+        local.get 0
+        i32.const 1
+        i32.add
+        local.set 0
+        br 0
+      end
+    end
+    i32.const 10000
+    local.set 0
+    i32.const 0
+    local.set 1
+    block
+      loop
+      local.get 0
+      i32.eqz
+      br_if 1        ;; break if counter == 0
+      local.get 1
+      i32.const 0
+      i32.sub        ;; acc - 0 (no change)
+      local.set 1
+      local.get 0
+      i32.const 1
+      i32.sub
+      local.set 0    ;; counter--
+      br 0           ;; repeat loop
+      end
+    end
+    local.get 1
+    if
+      i32.const 0
+      call 0
+    end
+  )
+  (start 1))

src/test/scala/genwasym/TestStagedConcolicEval.scala

@@ -37,21 +37,36 @@ class TestStagedConcolicEval extends FunSuite {
       println(result)
       exploreTreeFile
     }
+    val exploreTreeFileImm = {
+      // Do concolic execution with immutable data structure and snapshot reuse
+      val exe = s"$cppFile.imm.exe"
+      val exploreTreeFile = s"$filename.imm.tree.dot"
+      WasmToCppCompiler.compileToExe(moduleInst, main, cppFile, exe, true, optimizeLevel=0, if (exitByCoverage) "BY_COVERAGE" else "EARLY_EXIT", "USE_IMM")
+      println(s"Running compiled concolic execution with immutable data structure and snapshot reuse: $exe")
+      val result = Process(s"./$exe", None, "TREE_FILE" -> exploreTreeFile).!!
+      println(result)
+      exploreTreeFile
+    }
     // The explore tree generated by two executions should be same
     import java.nio.file.Files
     assert(
       Files.readAllBytes(java.nio.file.Paths.get(exploreTreeFile))
       sameElements Files.readAllBytes(java.nio.file.Paths.get(exploreTreeFileNoReuse)),
       s"Explore trees $exploreTreeFile and $exploreTreeFileNoReuse are different!"
     )
+    assert(
+      Files.readAllBytes(java.nio.file.Paths.get(exploreTreeFile))
+      sameElements Files.readAllBytes(java.nio.file.Paths.get(exploreTreeFileImm)),
+      s"Explore trees $exploreTreeFile and $exploreTreeFileImm are different!"
+    )
   }
 
   // only test concrete execution and its result
   def testFileConcreteCpp(filename: String, main: Option[String] = None, expect: Option[List[Float]] = None) = {
     val moduleInst = ModuleInstance(Parser.parseFile(filename))
     val cppFile = s"$filename.cpp"
     val exe = s"$cppFile.exe"
-    WasmToCppCompiler.compileToExe(moduleInst, main, cppFile, exe, true, optimizeLevel=0, "NO_INFO", "RUN_ONCE")
+    WasmToCppCompiler.compileToExe(moduleInst, main, cppFile, exe, true, optimizeLevel=0, "NO_INFO", "RUN_ONCE", "USE_IMM")
 
     import sys.process._
     val result = s"./$exe".!!
@@ -98,6 +113,10 @@ class TestStagedConcolicEval extends FunSuite {
   }
   test("btree-bug-finding-concolic") { testFileConcolicCpp("./benchmarks/wasm/btree/2o1u-unlabeled.wat", exitByCoverage = true) }
 
+  test("long-trivial-execution-concrete") {
+    // This is a example to show how much performance improvement we can get by immutable data structure
+    testFileConcreteCpp("./benchmarks/wasm/staged/long-trivial-execution.wat", None)
+  }
 
   test("return-poly - concrete") {
     testFileConcreteCpp("./benchmarks/wasm/staged/return_poly.wat", Some("$real_main"), expect=Some(List(42)))