EarlyAbortTests

astral/catalyst/impl/src/com/astraldb/catalyst/Tester.scala

@@ -75,12 +75,14 @@ object Tester
   case class SubResults(
     val input: LogicalPlan,
     val astral: Result,
+    val astralEarlyAbort: Result,
     val bdd: Result,
   )
   {
  
     def tests = Seq(
       "Astral-Raw" -> astral,
+      "Astral-Raw-EarlyAbort" -> astralEarlyAbort,
       "Astral-BDD" -> bdd,
     )
  
@@ -88,6 +90,8 @@ object Tester
     {
       // assert(lesserSpark.plan == astral.plan, s"The astral plan is wrong: \n${diffPlanSummary("Spark-Fair", "Astral-Raw", lesserSpark.plan, astral.plan)}")
       assert(astral.plan == bdd.plan, s"The bdd plan is wrong: \n${diffPlanSummary("Astral-Raw", "Astral-BDD", astral.plan, bdd.plan)}")
+      assert(astral.plan == bdd.plan, s"The early abort plan is wrong: \n${diffPlanSummary("Astral-Raw-EarlyAbort", "Astral-BDD", astralEarlyAbort.plan, bdd.plan)}")
+      assert(astral.plan == bdd.plan, s"The early abort plan is wrong: \n${diffPlanSummary("Astral-Raw", "Astral-Raw-EarlyAbort", astral.plan, astralEarlyAbort.plan)}")
       // if(completenessCheck){
       //   assert(spark.plan == bdd.plan, s"The final plan is not complete : \n${diffPlanSummary("Spark-Full", "Astral-BDD", spark.plan, bdd.plan)}")
       // }
@@ -127,6 +131,7 @@ object Tester
   def dumpStatsBenchmark(): Unit =
   {
     println(s"Using Optimizer with ${BenchmarkOptimizer.rules.size} rule fragments based on ${BenchmarkOptimizer.rules.map { _.getClass.getSimpleName().replaceAll("\\$", "").replaceAll("[^a-zA-Z].+", "") }.toSet.size} rules")
+    println(s"Using Optimizer with ${BenchmarkOptimizerEarlyAbort.rules.size} rule fragments based on ${BenchmarkOptimizerEarlyAbort.rules.map { _.getClass.getSimpleName().replaceAll("\\$", "").replaceAll("[^a-zA-Z].+", "") }.toSet.size} rules")
     println(s"Using BDD Optimizer with ${BenchmarkLogicalPlanBDDOptimizer.rules.size} rules")
   }
 
@@ -196,6 +201,9 @@ object Tester
       astral = Result.time {
         BenchmarkOptimizer.rewrite(plan)
       },
+      astralEarlyAbort = Result.time {
+        BenchmarkOptimizerEarlyAbort.rewrite(plan)
+      },
       bdd = Result.time {
         BenchmarkLogicalPlanBDDOptimizer.rewrite(plan)
       }

astral/compiler/src/com/astraldb/codegen/Optimizer.scala

@@ -5,11 +5,14 @@ import com.astraldb.spec.Type
 
 object Optimizer
 {
-  def apply(definition: Definition, benchmark: Boolean = false): String =
+  def apply(definition: Definition, benchmark: Boolean = false, earlyAbort: Boolean = false): String =
   {
-      if(benchmark)
+      if(benchmark && !earlyAbort)
       {
-        scala.Optimizer(definition.rules.map { "Benchmark" + _.safeLabel }, "BenchmarkOptimizer").toString
+        scala.Optimizer(definition.rules.map { "Benchmark" + _.safeLabel }, "BenchmarkOptimizer").toString 
+      } else if (benchmark && earlyAbort) 
+      {
+        scala.OptimizerEarlyAbort(definition.rules.map { "Benchmark" + _.safeLabel }, "BenchmarkOptimizerEarlyAbort").toString
       } else {
         scala.Optimizer(definition.rules.map { _.safeLabel }).toString
       }

astral/compiler/src/com/astraldb/codegen/Render.scala

@@ -16,6 +16,7 @@ object Render
         }
       Map(
         "BenchmarkOptimizer.scala" -> Optimizer(schema, true),
+        "BenchmarkOptimizerEarlyAbort.scala" -> Optimizer(schema,true, true),
       ) ++ (bddRule.flatMap { case (family, bdd) => Seq(
         s"Benchmark${family.scalaType}BDD.scala" -> Rule(schema, bdd, family, true),
         s"Benchmark${family.scalaType}BDDOptimizer.scala" -> Optimizer.bdd(family, true)

astral/compiler/views/com/astraldb/codegen/OptimizerEarlyAbort.scala.scala

@@ -0,0 +1,43 @@
+@import com.astraldb.spec.Definition
+
+@(rules: Seq[String], clazz: String = "Optimizer")
+
+object @clazz
+{
+  val rules = Seq[Rule[LogicalPlan]](
+    @for(rule <- rules){ @rule , 
+    }
+  )
+
+  def MAX_ITERATIONS = 100
+
+  def rewrite(plan: LogicalPlan): (LogicalPlan, Int) =
+  {
+    var current = plan
+    var last = plan
+
+    for(i <- 0 until MAX_ITERATIONS)
+    {
+      var index = 0
+      while (index < rules.size)
+      {
+        current = rules(index).apply(current)
+        index = index + 1
+        if (!last.fastEquals(current)){
+          index = Int.MaxValue
+        }
+      }
+      // for(rule <- rules)
+      // {
+      //   current = rule(current)
+
+      // }
+      if(last.fastEquals(current))
+      {
+        return (current, i+1)
+      }
+      last = current
+    }
+    return (current, MAX_ITERATIONS)
+  }
+}