[iss-44]

Author: Kalashnikovni

eval/defs.hpp

@@ -40,38 +40,6 @@ namespace Eval {
 
 // Type definitions ------------------------------------------------------------
 
-/** @brief Types NatBaseType, ContainerBaseType, LinearBaseType and MapBaseType 
- *  are defined to decrease the compilation memory consumption of eval_expr.cpp.
- *  When evaluating an AST::Call, multiple std::visit are invoked, where each 
- *  one generates a function table with size dependent of the number types in
- *  the variant. Initially ExprBaseType was used.
- */
-/*
-typedef std::variant<Util::NAT
-  , Util::MD_NAT> NatType;
-
-typedef std::variant<LIB::Interval
-  , LIB::SetPiece
-  , LIB::UnordSet
-  , LIB::OrdSet> ContainerBaseType;
-
-typedef std::variant<LIB::LExp
-  , LIB::Exp> ExprBaseType;
-
-typedef std::variant<LIB::BaseMap
-  , LIB::CanonMap
-  , LIB::BasePWMap
-  , LIB::CanonPWMap> MapBaseType;
-
-typedef std::variant<LIB::BaseSBG
-  , LIB::CanonSBG
-  , LIB::BaseDSBG
-  , LIB::CanonDSBG> SBGBaseType;
-
-typedef std::variant<LIB::MatchInfo<LIB::UnordSet>
-  , LIB::MatchInfo<LIB::OrdSet>> InfoBaseType;
-*/
-
 typedef std::variant<LIB::MD_NAT
   , LIB::RATIONAL
   , LIB::Interval

eval/main.cpp

@@ -31,7 +31,14 @@
 #include "parser/sbg_program.hpp"
 #include "eval/visitors/program_visitor.hpp"
 
-void parseEvalProgramFromFile(std::string fname, bool debug)
+struct Impl {
+  int set_impl_;
+  int pw_impl_;
+
+  Impl(int set_impl, int pw_impl) : set_impl_(set_impl), pw_impl_(pw_impl) {};
+};
+
+void parseEvalProgramFromFile(std::string fname, Impl impl, bool debug)
 {
   std::ifstream in(fname.c_str());
   if (in.fail()) 
@@ -57,7 +64,26 @@ void parseEvalProgramFromFile(std::string fname, bool debug)
     std::cout << ">>>>>> Eval result <<<<<<\n";
     std::cout << "-------------------------\n\n";
 
-    SBG::Eval::ProgramVisitor program_visit(debug); 
+    std::unique_ptr<SBG::LIB::SetAF> set_fact 
+      = std::make_unique<SBG::LIB::UnordAF>();
+
+    switch (impl.set_impl_) {
+      case 2:
+        set_fact = std::make_unique<SBG::LIB::OrdDenseAF>();
+
+      default:
+        break;
+    }
+
+    SBG::LIB::MapAF map_fact(*set_fact);
+    std::unique_ptr<SBG::LIB::PWMapAF> fact
+      = std::make_unique<SBG::LIB::UnordPWMapAF>(map_fact);
+    switch (impl.pw_impl_) {
+      default:
+        break;
+    }
+
+    SBG::Eval::ProgramVisitor program_visit(*fact, debug); 
     SBG::Eval::ProgramIO visit_result = boost::apply_visitor(
       program_visit, parser_result
     );
@@ -78,6 +104,8 @@ void usage()
   std::cout << "Usage evaluator: ./bin/sbg-eval -f filename [options]\n";
   std::cout << "Parses and evaluates a SBG program.\n\n";
   std::cout << "-f, --file      SBG program file used as input\n";
+  std::cout << "-s, --set_impl  Choose set implementation: 0 unordered sets,\n";
+  std::cout << "                1 ordered sets, 2 ordered dense sets.\n";
   std::cout << "-h, --help      Display this information and exit\n";
   std::cout << "-d, --debug     Activate debug info\n";
   std::cout << "-v, --version   Display version information and exit\n\n";
@@ -201,27 +229,30 @@ void version()
   std::cout << "There is NO WARRANTY, to the extent permitted by law.\n";
 }
 
-
 int main(int argc, char**argv)
 {
   std::string filename;
-  int opt;
+  int opt, set_impl = 0, pw_impl = 0;
   extern char* optarg;
   bool debug = false;
 
   while (true) {
     static struct option long_options[] = {{"file", required_argument, 0, 'f'}
+                                           , {"set_impl", required_argument, 0, 's'}
                                            , {"help", no_argument, 0, 'h'}
                                            , {"debug", no_argument, 0, 'd'}
                                            , {"version", no_argument, 0, 'v'}
                                            , {0, 0, 0, 0}};
-    opt = getopt_long(argc, argv, "f:hdv", long_options, nullptr);
+    opt = getopt_long(argc, argv, "f:s:hdv", long_options, nullptr);
     if (opt == EOF) 
       break;
     switch (opt) {
       case 'f':
         filename = optarg;
         break;
+      case 's':
+        set_impl = std::stoi(optarg);
+        break;
       case 'h':
         usage();
         exit(0);
@@ -241,7 +272,7 @@ int main(int argc, char**argv)
   }
 
   if (!filename.empty())
-    parseEvalProgramFromFile(filename, debug);
+    parseEvalProgramFromFile(filename, Impl(set_impl, pw_impl), debug);
   else
     SBG::Util::ERROR("A filename should be provided\n");
 

eval/visitors/program_visitor.cpp

@@ -23,7 +23,8 @@ namespace SBG {
 
 namespace Eval {
 
-ProgramVisitor::ProgramVisitor(bool debug) : env_(), debug_(debug) {}
+ProgramVisitor::ProgramVisitor(const LIB::PWMapAF &fact, bool debug)
+  : fact_(fact), env_(), debug_(debug) {}
 
 ProgramIO ProgramVisitor::operator()(AST::Program p) const 
 { 
@@ -43,19 +44,7 @@ ProgramIO ProgramVisitor::operator()(AST::Program p) const
     }
   }
 
-  bool check = true;
-  OptConds opt_conds(stm_visit.env());
-  for (AST::Expr e : p.exprs())
-    check = check && boost::apply_visitor(opt_conds, e);
-
-  // Choose concrete factory according to the desired implementation
-  std::unique_ptr<LIB::SetAF> set_fact = std::make_unique<LIB::UnordAF>();
-  if (check)
-    set_fact = std::make_unique<LIB::OrdDenseAF>();
-  LIB::MapAF map_fact(*set_fact);
-  LIB::UnordPWMapAF pw_fact(map_fact);
-
-  EvalExpression eval_expr(dims, pw_fact, stm_visit.env(), debug_);
+  EvalExpression eval_expr(dims, fact_, stm_visit.env(), debug_);
   for (AST::Expr e : p.exprs()) {
     ExprBaseType expr_res = boost::apply_visitor(eval_expr, e);
     exprs.push_back(ExprEval(e, expr_res));

eval/visitors/program_visitor.hpp

@@ -39,11 +39,12 @@ namespace Eval {
 
 struct ProgramVisitor : public boost::static_visitor<ProgramIO> {
   public:
-  ProgramVisitor(bool debug);
+  ProgramVisitor(const LIB::PWMapAF &fact, bool debug);
 
   ProgramIO operator()(AST::Program p) const; 
 
   private:
+  const LIB::PWMapAF &fact_;
   mutable VarEnv env_;
   mutable bool debug_;
 };

sbg/af_map.hpp

@@ -37,10 +37,10 @@ struct MapAF : public SetAF {
   public:
   MapAF(const SetAF &set_fact);
 
-  Set createSet() const;
-  Set createSet(const MD_NAT &x) const;
-  Set createSet(const Interval &i) const;
-  Set createSet(const SetPiece &mdi) const;
+  Set createSet() const override;
+  Set createSet(const MD_NAT &x) const override;
+  Set createSet(const Interval &i) const override;
+  Set createSet(const SetPiece &mdi) const override;
 
   Map createMap() const;
   Map createMap(MD_NAT x, Exp exp) const;

sbg/map.cpp

@@ -173,13 +173,11 @@ Set Map::image(const Set &subdom) const
 
     if (cond) {
       for (const SetPiece &mdi : capdom)
-        res.emplace(SBG::LIB::image(mdi, exp_));
+        res.emplaceBack(SBG::LIB::image(mdi, exp_));
     }
     else {
-      // TODO: optimization?
-      for (const SetPiece &mdi : capdom) {
+      for (const SetPiece &mdi : capdom)
         res = res.cup(fact_.createSet(SBG::LIB::image(mdi, exp_)));
-      }
     }
   }
 

sbg/pw_map.cpp

@@ -689,7 +689,6 @@ PWMapDelegPtr UnordPWMap::offsetImage(const Exp &off) const
   return res;
 }
 
-// TODO
 PWMapDelegPtr UnordPWMap::compact() const
 {
   UnordPWMap res(fact_);

sbg/sbg_algorithms.cpp

@@ -655,68 +655,6 @@ const PWMapAF &SBGSCC::fact() const { return fact_; }
 // Topological sort ------------------------------------------------------------
 ////////////////////////////////////////////////////////////////////////////////
 
-/* TODO
-DSBG partitionSE(const DSBG &dg)
-{
-  const PWMapAF &fact_ = dg.fact();
-
-  Set V = dg.V();
-  unsigned int dims = V.arity(), j = 1;
-  PWMap mapB = dg.mapB(), mapD = dg.mapD(), Emap = dg.Emap();
-  PWMap subE = dg.subEmap();
-
-  std::vector<Map> vs;
-  for (const Map &map : dg.Vmap())
-    vs.emplace_back(map.dom());
-
-  Set univ = fact_.createSet(SetPiece(dims, Interval(0, 1, Inf)));
-  for (const Map &map : subE) {
-    Set ith_edge = mapB.image(map.dom());
-    Set not_ith_edge = univ.difference(ith_edge);
-    std::vector<Set> aux_vs;
-    aux_vs.reserve(2*vs.size());
-    for (const Set &ith_vs : vs) {
-      Set s1 = ith_edge.intersection(ith_vs);
-      Set s2 = not_ith_edge.intersection(ith_vs);
-
-      if (!s1.isEmpty())
-        aux_vs.emplace_back(s1);
-
-      if (!s2.isEmpty())
-        aux_vs.emplace_back(s2);
-    }
-    vs = aux_vs;
-  }
-
-  for (const Map &map : subE) {
-    Set ith_edge = mapD.image(map.dom());
-    Set not_ith_edge = univ.difference(ith_edge);
-    std::vector aux_vs;
-    aux_vs.reserve(2*vs.size());
-    for (const Set &ith_vs : vs) {
-      Set s1 = ith_edge.intersection(ith_vs);
-      Set s2 = not_ith_edge.intersection(ith_vs);
-
-      if (!s1.isEmpty())
-        aux_vs.emplace_back(s1);
-
-      if (!s2.isEmpty())
-        aux_vs.emplace_back(s2);
-    }
-    vs = aux_vs;
-  }
-
-  PWMap Vmap;
-  for (const Set &dom : vs) {
-    MD_NAT v(dims, j);
-    Vmap.emplaceBack(Map(dom, Exp(v)));
-    ++j;
-  }
-
-  return DSBG(V, Vmap, mapB, mapD, Emap, subE);
-}
-*/
-
 SBGTopSort::SBGTopSort(const DSBG &dsbg, bool debug) 
   : fact_(dsbg.fact()), dsbg_(dsbg), debug_(debug) {}
 

test/matching1.test

@@ -42,5 +42,5 @@ matching(
   map1: <<{[1:1:E1]} -> 1*x+off1b, {[E1+1:1:E2]} -> 1*x+off2b, {[E2+1:1:E3]} -> 1*x+off3b>>
   map2: <<{[1:1:E1]} -> 1*x+off1d, {[E1+1:1:E2]} -> 1*x+off2d, {[E2+1:1:E3]} -> 1*x+off3d>>
   Emap: <<{[1:1:E1]} -> 0*x+1, {[E1+1:1:E2], [E2+1:1:E3]} -> 0*x+2>>
-  , 64
+  , 1
 );