Support new PWMap implementation in evaluator

Author: Kalashnikovni

eval/eval_exec.cpp

@@ -64,14 +64,19 @@ void printHeader(Util::prog_opts::variables_map vm)
 // Evaluation Executor ---------------------------------------------------------
 ////////////////////////////////////////////////////////////////////////////////
 
-EvalExecutor::EvalExecutor() : set_impl_(0)
+EvalExecutor::EvalExecutor() : scc_impl_(1)
 {
   config_.add_options()
     ("set_impl,s", Util::prog_opts::value(&set_impl_),
      " Desired set implementation:"
      "\n  - 0 for unordered sets (default option)"
      "\n  - 1 for ordered sets"
      "\n  - 2 for unidimensional ordered dense sets")
+    ("pw_impl,p", Util::prog_opts::value(&pw_impl_),
+     " Desired PWMap implementation:"
+     "\n  - 0 for unordered PWMaps (default option)"
+     "\n  - 1 for ordered PWMaps"
+     "\n  - 2 for domain ordered PWMaps")
     ("scc_impl", Util::prog_opts::value(&scc_impl_),
      "Desired SCC algorithm implementation:"
      "\n  - 0 for V1 of minimum reachable SCC (default option)"
@@ -82,11 +87,32 @@ EvalExecutor::EvalExecutor() : set_impl_(0)
   visible_.add(generic_).add(config_);
 }
 
-EvalUserInput EvalExecutor::gatherUserInput()
+EvalUserInput EvalExecutor::chooseImplementation()
 {
   EvalUserInput result;
 
-  result.set_set_impl(set_impl_);
+  AutomImplVisitor autom_impl_visitor;
+  std::streambuf* old_cout_buffer = std::cout.rdbuf();
+  std::cout.rdbuf(nullptr);
+  EvalUserInput autom_impl = autom_impl_visitor.visit(Parser::parseFile(
+    *input_file_));
+  std::cout.rdbuf(old_cout_buffer);
+
+  result.set_set_impl(autom_impl.set_impl());
+  result.set_pw_impl(autom_impl.pw_impl());
+
+  if (set_impl_) {
+    if (set_impl_ > autom_impl.set_impl())
+      Util::ERROR("Incompatible set implementation for the SBG input\n");
+
+    result.set_set_impl(set_impl_);
+  }
+  if (pw_impl_) {
+    if (pw_impl_ > autom_impl.pw_impl())
+      Util::ERROR("Incompatible PW implementation for the SBG input\n");
+
+    result.set_pw_impl(pw_impl_);
+  }
   result.set_scc_impl(scc_impl_);
 
   return result;
@@ -131,13 +157,7 @@ void EvalExecutor::execute(int arg_count, char* args[])
   // Input SBG program file handling -------------------------------------------
 
   if (input_file_) {
-    AutomImplVisitor autom_impl;
-    std::streambuf* old_cout_buffer = std::cout.rdbuf();
-    std::cout.rdbuf(nullptr);
-    autom_impl.visit(Parser::parseFile(*input_file_));
-    std::cout.rdbuf(old_cout_buffer);
-
-    EvalUserInput input = gatherUserInput();
+    EvalUserInput input = chooseImplementation();
     InputTranslator input_translator;
     input_translator.translate(input);
     ProgramIO eval_result = parseEvalFile(*input_file_); 

eval/eval_exec.hpp

@@ -38,9 +38,10 @@ class EvalExecutor : public Util::UserInputHandler {
   void execute(int arg_count, char* args[]) override;
 
   private:
-  EvalUserInput gatherUserInput();
+  EvalUserInput chooseImplementation();
 
   boost::optional<int> set_impl_;
+  boost::optional<int> pw_impl_;
   boost::optional<int> scc_impl_;
 };
 

eval/input_translator.cpp

@@ -30,9 +30,23 @@ InputTranslator::InputTranslator() {}
 void InputTranslator::translate(EvalUserInput& input)
 {
   EvalUserInput::MaybeInt s = input.set_impl();
-  if (s) {
+  EvalUserInput::MaybeInt pw = input.pw_impl();
+  if (pw && s) {
+    if (*pw == 2 && *s == 0) {
+      Util::ERROR("Domain ordered PWMap should be used with an ordered set"
+        " implementation\n");
+    }
+    else {
+      setSetFactory(*s);
+      setPWFactory(*pw);
+    }
+  }
+  else if (s) {
     setSetFactory(*s);
   }
+  else if (pw) {
+    setPWFactory(*pw);
+  }
 
   EvalUserInput::MaybeInt scc = input.scc_impl();
   if (scc) {

eval/user_impl_map.cpp

@@ -67,6 +67,7 @@ UserImplMap::StructImplMap pwMap()
   UserImplMap::StructImplMap pw_mapping;
   pw_mapping[0] = []() { return std::make_unique<LIB::UnordPWMapFact>(); };
   pw_mapping[1] = []() { return std::make_unique<LIB::OrdPWMapFact>(); };
+  pw_mapping[2] = []() { return std::make_unique<LIB::DomOrdPWMapFact>(); };
   pw_mapping.freeze();
   return pw_mapping;
 }

eval/visitors/autom_impl_visitor.cpp

@@ -33,7 +33,7 @@ namespace Eval {
 
 AutomImplVisitor::AutomImplVisitor() {}
 
-void AutomImplVisitor::visit(AST::SBGProgram p) const
+EvalUserInput AutomImplVisitor::visit(AST::SBGProgram p) const
 { 
   // Statement inspection ------------------------------------------------------ 
 
@@ -55,17 +55,23 @@ void AutomImplVisitor::visit(AST::SBGProgram p) const
   // Set Implementation --------------------------------------------------------
 
   int auto_set_impl = 2;
-  if (dims < 2) {
-    SetImplExprVisitor set_impl_visit(stm_eval.eval_ctx().venv());
-    for (AST::Expr expr : p.exprs()) {
-      int ith_set_impl = boost::apply_visitor(set_impl_visit, expr);
-      auto_set_impl = std::min(auto_set_impl, ith_set_impl);
-    }
+  SetImplExprVisitor set_impl_visit(stm_eval.eval_ctx().venv());
+  for (AST::Expr expr : p.exprs()) {
+    int ith_set_impl = boost::apply_visitor(set_impl_visit, expr);
+    auto_set_impl = std::min(auto_set_impl, ith_set_impl);
   }
 
-  setSetFactory(auto_set_impl);
+  EvalUserInput result;
+  result.set_set_impl(auto_set_impl);
 
-  return;
+  // PW Implementation ---------------------------------------------------------
+
+  result.set_pw_impl(1);
+  if (auto_set_impl > 0) {
+    result.set_pw_impl(2);
+  }
+
+  return result;
 }
 
 } // namespace Eval

eval/visitors/autom_impl_visitor.hpp

@@ -31,6 +31,7 @@
 #include <boost/variant.hpp>
 
 #include "ast/sbg_program.hpp"
+#include "eval/user_input.hpp"
 
 namespace SBG {
 
@@ -40,7 +41,7 @@ class AutomImplVisitor {
   public:
   AutomImplVisitor();
 
-  void visit(AST::SBGProgram p) const;
+  EvalUserInput visit(AST::SBGProgram p) const;
 };
 
 } // namespace Eval

eval/visitors/set_impl_visitor.cpp

@@ -70,6 +70,10 @@ int SetImplExprVisitor::operator()(AST::Interval v) const
 int SetImplExprVisitor::operator()(AST::MultiDimInter v) const
 {
   int impl = 2;
+
+  if (v.intervals().size() > 1)
+    return 1;
+
   for (const AST::Expr &e : v.intervals())
     impl = std::min(impl, boost::apply_visitor(*this, e));
 

test/rl2.test

@@ -83,7 +83,7 @@ Emap: <<{[1:1:E1]} -> |0*x+1|, {[E1+1:1:E2]} -> |0*x+2|, {[E2+1:1:E3], [E3+1:1:E
   |, {[E6+1:1:E7]} -> |0*x+6|, {[E7+1:1:E8]} -> |0*x+7|, {[E8+1:1:E9]} -> |0*x+8
   |, {[E9+1:1:E10]} -> |0*x+9|>>;
 
-matchSCCTS(
+matchSCC(
   V: {[1:1:F1], [F1+1:1:F2], [F2+1:1:F3], [F3+1:1:F4], [F4+1:1:F5]
     , [F5+1:1:U1], [U1+1:1:U2], [U2+1:1:U3]}
   Vmap: <<{[1:1:F1]} -> |0*x+1|, {[F1+1:1:F2]} -> |0*x+2|, {[F2+1:1:F3]} -> |0*x+3