Update t2 program generator (#11)

Author: Jaeho Choi

src/main/scala/fhetest/Command.scala

@@ -1,7 +1,7 @@
 package fhetest
 
 import fhetest.Utils.*
-import fhetest.Phase.{Parse, Interp, Print, Execute}
+import fhetest.Phase.{Parse, Interp, Print, Execute, Generate}
 
 sealed abstract class Command(
   /** command name */
@@ -143,3 +143,19 @@ case object CmdExecute extends Command("execute") {
     case Nil => println("No backend given.")
   }
 }
+
+/** `gen` command */
+case object CmdGen extends Command("gen") {
+  val help = "Generate random T2 programs."
+  val examples = List(
+    "fhetest gen",
+    "fhetest gen -n 10",
+  )
+  def apply(args: List[String]): Unit = args match {
+    case Nil => println("No argument given.")
+    case n :: _ => {
+      val num = n.toInt
+      Generate(List(Backend.SEAL, Backend.OpenFHE), ENC_TYPE.ENC_INT, num)
+    }
+  }
+}

src/main/scala/fhetest/Phase/Execute.scala

@@ -1,5 +1,8 @@
 package fhetest.Phase
 
+import sys.process.*
+import java.io.File
+
 import fhetest.Utils.*
 
 case object Execute {
@@ -8,14 +11,16 @@ case object Execute {
     val cmakeCommand = "cmake ."
     val makeCommand = "make -j"
     val executeCommand = "./test.out"
+
+    // TODO : Add option silent (default true)
     val cmakeProcess =
-      sys.process.Process(cmakeCommand, new java.io.File(workspaceDir))
+      Process(cmakeCommand, new File(workspaceDir))
     val makeProcess =
-      sys.process.Process(makeCommand, new java.io.File(workspaceDir))
+      Process(makeCommand, new File(workspaceDir))
     val executeProcess =
-      sys.process.Process(executeCommand, new java.io.File(binPath))
-    cmakeProcess.!
-    makeProcess.!
+      Process(executeCommand, new File(binPath))
+    cmakeProcess.!(silentLogger)
+    makeProcess.!(silentLogger)
     executeProcess.!!
   }
 }

src/main/scala/fhetest/Phase/Generate.scala

@@ -16,30 +16,43 @@ import scala.util.Random
 
 case object Generate {
 
-  def apply(backend: Backend, encType: ENC_TYPE, n: Int) =
+  def apply(backends: List[Backend], encType: ENC_TYPE, n: Int) =
     for {
-      program <- allPrograms.take(n)
+      template <- allTempletes.take(n)
     } {
-      // withBackendTempDir(
-      //  backend,
-      //  { workspaceDir =>
-      //    given DirName = workspaceDir
-      //    val ast = baseAst
-      //    // appendToBaseAst(exampleStmt)
-      //    appendToBaseAst(program)
-      //    Print(ast, symbolTable, encType, backend)
-      //    Execute(backend)
-      //  },
-      // )
-      given DirName = getWorkspaceDir(backend)
-      val template = buildTemplate(program)
-      val ast = concretizeTemplate(template)
-      Print(ast, symbolTable, encType, backend)
-      Execute(backend)
+      // TODO: currently concretize 5 times for each template
+      // TODO: store the results into a json file and print it by parsing the json file
+      print("=" * 80 + "\n")
+      print("<Program>\n")
+      print(toString(template) + "\n")
+      print("=" * 80 + "\n")
+      for _ <- 0 until 5 do {
+        val concretized = concretizeTemplate(template)
+        print(toString(concretized) + "\n")
+        print("-" * 80 + "\n")
+
+        val ast = buildTemplate(concretized)
+        val result = Interp(ast, 32768, 65537)
+        print("CLEAR" + " : " + result + "\n")
+        for {
+          backend <- backends
+        } {
+          withBackendTempDir(
+            backend,
+            { workspaceDir =>
+              given DirName = workspaceDir
+              Print(ast, symbolTable, encType, backend)
+              val result = Execute(backend)
+              print(backend.toString + " : " + result)
+            },
+          )
+        }
+        print("-" * 80 + "\n")
+      }
     }
 
-  def concretizeTemplate(template: Goal): Goal =
-    return assignRandIntValues(template, 1000)
+  def concretizeTemplate(template: Templete): Templete =
+    return assignRandIntValues(template, 100)
 
   // FIXME: This is just a temporary solution for making symbolTable and encType available
   val (_: Goal, symbolTable, encType) =
@@ -65,34 +78,28 @@ case object Generate {
     Parse(baseStream)._1
   }
 
-  def assignIntValue(template: Goal, vx: Int, vy: Int): Goal =
-    val XStr = s"x = $vx;"
-    val YStr = s"y = $vy;"
-    print(XStr)
-    print(YStr)
-    val assignments = List(XStr, YStr)
-    val stmts = assignments.map(parseStmt)
-    val templateStmts = template.f0.f7.nodes
-    templateStmts.addAll(0, stmts.asJava)
-    return template
+  def assignIntValue(template: Templete, vx: Int, vy: Int): Templete =
+    val assignments = List(Assign("x", vx), Assign("y", vy))
+    return assignments ++ template
 
   // vxs = [1, 2, 3], vys = [4, 5, 6] => x = { 1, 2, 3 }; y = { 4, 5, 6 };
-  def assignIntValues(template: Goal, vxs: List[Int], vys: List[Int]): Goal =
-    val XStr = s"x = {${vxs.mkString(",")}};"
-    val YStr = s"y = {${vys.mkString(",")}};"
-    val assignments = List(XStr, YStr)
-    val stmts = assignments.map(parseStmt)
-    val templateStmts = template.f0.f7.nodes
-    templateStmts.addAll(0, stmts.asJava)
-    return template
-
-  def assignRandIntValue(template: Goal, bound: Int): Goal =
+  def assignIntValues(
+    template: Templete,
+    vxs: List[Int],
+    vys: List[Int],
+  ): Templete =
+    val assignments = List(AssignVec("x", vxs), AssignVec("y", vys))
+    return assignments ++ template
+
+  def assignRandIntValue(template: Templete, bound: Int): Templete =
     val vx = Random.between(0, bound)
     val vy = Random.between(0, bound)
     return assignIntValue(template, vx, vy)
 
   // current length = 5
-  def assignRandIntValues(template: Goal, bound: Int): Goal =
+  // TODO : Currently, it only supports the length of 5
+  // TODO : Currently, T2 DSL does not support negative numbers
+  def assignRandIntValues(template: Templete, bound: Int): Templete =
     val vxs = List.fill(5)(Random.between(0, bound))
     val vys = List.fill(5)(Random.between(0, bound))
     return assignIntValues(template, vxs, vys)
@@ -103,48 +110,54 @@ case object Generate {
     )
     T2DSLParser(input_stream).Statement()
 
-  def buildTemplate(stmts: List[Statement]): Goal =
-    val base = createNewBaseTemplate()
-    val baseStmts = base.f0.f7.nodes
-    baseStmts.addAll(0, stmts.asJava)
-    return base
-
   trait Stmt
   case class Var()
+  case class Assign(l: String, r: Int) extends Stmt
+  case class AssignVec(l: String, r: List[Int]) extends Stmt
   case class Add(l: Var, r: Var) extends Stmt
   case class Sub(l: Var, r: Var) extends Stmt
   case class Mul(l: Var, r: Var) extends Stmt
   case class Rot(l: Var, r: Var) extends Stmt
 
-  def concretize(s: Stmt) = s match
-    case Add(l, r) => parseStmt("x += y;")
-    case Sub(l, r) => parseStmt("x -= y;")
-    case Mul(l, r) => parseStmt("x *= y;")
-    // case Rot(l, r) => parseStmt("rotate_left(x, c);")
-
-  type Program = List[Stmt]
   val V = Var()
 
+  def toString(s: Stmt) = s match
+    case Assign(l, r)    => s"$l = $r;"
+    case AssignVec(l, r) => s"$l = {${r.mkString(",")}};"
+    case Add(l, r)       => "x += y;"
+    case Sub(l, r)       => "x -= y;"
+    case Mul(l, r)       => "x *= y;"
+    // case Rot(l, r) => "rotate_left(x, c);"
+  def concretize(s: Stmt) = parseStmt(toString(s))
+
+  type Templete = List[Stmt]
+  def toString(t: Templete): String = t.map(toString).mkString("\n")
+
+  def buildTemplate(temp: Templete): Goal =
+    val stmts = temp.map(toString).map(parseStmt)
+    val base = createNewBaseTemplate()
+    val baseStmts = base.f0.f7.nodes
+    baseStmts.addAll(0, stmts.asJava)
+    return base
+
 // 가능한 모든 Stmt를 생성하는 함수
   def allStmts: LazyList[Stmt] = LazyList(
     Add(V, V),
     Sub(V, V),
     Mul(V, V),
   )
 
-// 주어진 길이에 대해 가능한 모든 프로그램을 생성하는 함수
-  def allProgramsOfSize(n: Int): LazyList[Program] = n match {
+// 주어진 길이에 대해 가능한 모든 템플릿을 생성하는 함수
+  def allTempletesOfSize(n: Int): LazyList[Templete] = n match {
     case 1 => allStmts.map(stmt => List(stmt))
     case _ =>
       for {
         stmt <- allStmts
-        program <- allProgramsOfSize(n - 1)
+        program <- allTempletesOfSize(n - 1)
       } yield stmt :: program
   }
 
-// 모든 길이에 대해 가능한 모든 프로그램을 생성하는 LazyList
-  val allPrograms: LazyList[List[Statement]] =
-    LazyList.from(1).flatMap(allProgramsOfSize).map(_.map(concretize))
-
-  def generateTemplate() = ???
+// 모든 길이에 대해 가능한 모든 템플릿을 생성하는 LazyList
+  val allTempletes: LazyList[Templete] =
+    LazyList.from(1).flatMap(allTempletesOfSize)
 }

src/main/scala/fhetest/Utils/Utils.scala

@@ -2,6 +2,7 @@ package fhetest.Utils
 
 import org.twc.terminator.Main.ENC_TYPE as T2ENC_TYPE
 
+import sys.process.*
 import java.nio.file.{Files, Path, Paths, StandardCopyOption}
 import java.util.Comparator
 import scala.util.Try
@@ -101,3 +102,5 @@ def withBackendTempDir[Result](
     deleteTemp()
   }
 }
+
+val silentLogger = ProcessLogger(_ => (), _ => ())

src/main/scala/fhetest/fhetest.scala

@@ -25,6 +25,8 @@ object FHETest {
     // Run the given T2 program
     // Compile -> Execute (SEAL, OpenFHE) / Interp (if no backend is given)
     CmdRun,
+    // Generate random T2 programs
+    CmdGen,
   )
   val cmdMap = commands.foldLeft[Map[String, Command]](Map()) {
     case (map, cmd) => map + (cmd.name -> cmd)