[iss-108]

Author: Kalashnikovni

3rd-party/CMakeLists.txt

@@ -21,3 +21,16 @@ add_custom_target(
 )
 
 add_dependencies(sbgraph 3rd-party-libs)
+
+include(FetchContent)
+
+set(BENCHMARK_ENABLE_GTEST_TESTS OFF CACHE BOOL "" FORCE)
+set(BENCHMARK_ENABLE_TESTING OFF CACHE BOOL "" FORCE)
+set(BENCHMARK_ENABLE_INSTALL OFF CACHE BOOL "" FORCE)
+
+FetchContent_Declare(
+  google_benchmark
+  GIT_REPOSITORY https://github.com/google/benchmark.git
+  GIT_TAG v1.6.1
+)
+FetchContent_MakeAvailable(google_benchmark)

algorithms/scc/decreasing_edges_mrv.cpp

@@ -33,32 +33,17 @@ LtEdgesMRV::LtEdgesMRV() : dsbg_(), smap_(PW_FACT.createPWMap())
 
 Set LtEdgesMRV::decreasingRepresentative(const PWMap& rmap) const
 {
-  Set result = SET_FACT.createSet();
-
   PWMap mapB = dsbg_.mapB();
   PWMap mapD = dsbg_.mapD();
 
   if (mapB.isEmpty() || mapD.isEmpty())
-    return result;
+    return SET_FACT.createSet();
 
   PWMap rmapB = rmap.composition(mapB);
   PWMap rmapD = rmap.composition(mapD);
 
-  unsigned int dims = rmapD.arity();
-  PWMap offD = rmapD.offsetImage(MD_NAT(dims, 1)); 
-  PWMap subt = (offD - rmapB);
-  SetPiece im(dims, Interval(0, 1, Inf));
-  Set min_in_mapD = SET_FACT.createSet();
-  for (unsigned int k = 0; k < dims; ++k) {
-    im[k] = Interval(0, 1, 0);
-    if (k > 0)
-      im[k-1] = Interval(1, 1, 1);
-
-    Set kth = subt.preImage(SET_FACT.createSet(im));
-    min_in_mapD = min_in_mapD.disjointCup(kth);
-  }
-
-  return min_in_mapD;
+  Set result = rmapD.lessImage(rmapB);
+  return result;
 }
 
 Set LtEdgesMRV::edgesInPaths(const PWMap& smap) const

algorithms/scc/minadj_mrv.cpp

@@ -51,7 +51,6 @@ PWMap MinAdjMRV::calculate(const DSBG& dsbg)
       rmap = rmap.minMap(new_rmap).combine(rmap);
       Util::DEBUG_LOG << "rmap before rec: " << rmap << "\n\n";
 
-      Set positive = SET_FACT.createSet(SetPiece(copies, Interval(1, 1, Inf)));
       PWMap rec_rmap = PW_FACT.createPWMap();
       Vc = V.difference(old_rmap.equalImage(rmap));
       if (!Vc.isEmpty()) {
@@ -92,7 +91,7 @@ PWMap MinAdjMRV::calculate(const DSBG& dsbg)
                 }
                 PWMap dmapB = dmap.composition(mapB), dmapD = dmap.composition(mapD);
                 // Get edges where the end is closer to the rep than the beginning
-                Set not_cycle_edges = (dmapB - dmapD).preImage(positive);
+                Set not_cycle_edges = dmapD.lessImage(dmapB);
                 ER = ER.intersection(not_cycle_edges);
 
                 // Extend to subset-edge

algorithms/scc/minreach_scc.cpp

@@ -70,10 +70,12 @@ SCCData MinReachSCC::calculate(const DSBG& dsbg)
   PWMap rmap = PW_FACT.createPWMap();
   Set Ediff = SET_FACT.createSet();
   Set oldE = dsbg.E();
+  Set deleted_edges = SET_FACT.createSet();
   do {
     oldE = dsbg_.E();
     rmap = sccStep();
     Ediff = oldE.difference(dsbg_.E());
+    deleted_edges = deleted_edges.disjointCup(Ediff);
   } while (Ediff != SET_FACT.createSet());
   rmap = rmap.compact();
   auto end = std::chrono::high_resolution_clock::now();
@@ -85,7 +87,7 @@ SCCData MinReachSCC::calculate(const DSBG& dsbg)
 
   Util::DEBUG_LOG << "MinReachSCC result: " << rmap << "\n\n";
 
-  return SCCData(dsbg, rmap, Ediff);
+  return SCCData(dsbg, rmap, deleted_edges);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -99,7 +101,7 @@ PWMap MinReachSCCV1::sccStep()
   // Calculate MRV
   MinAdjMRV mrv;
   PWMap new_rmap = mrv.calculate(dsbg_);
-  Util::DEBUG_LOG << "MinReachSCC new_rmap: " << new_rmap << "\n";
+  Util::DEBUG_LOG << "MinReachSCCV1 new_rmap: " << new_rmap << "\n";
 
   // Leave edges in the same SCC
   PWMap rmapB = new_rmap.composition(dsbg_.mapB());
@@ -126,14 +128,14 @@ PWMap MinReachSCCV2::sccStep()
   // Calculate MRV
   LtEdgesMRV mrv;
   PWMap new_rmap = mrv.calculate(dsbg_);
-  Util::DEBUG_LOG << "MinReachSCC new_rmap: " << new_rmap << "\n";
+  Util::DEBUG_LOG << "MinReachSCCV2 new_rmap: " << new_rmap << "\n";
 
   // Leave edges in the same SCC
   PWMap rmapB = new_rmap.composition(dsbg_.mapB());
   PWMap rmapD = new_rmap.composition(dsbg_.mapD());
   Set Esame = rmapB.equalImage(rmapD);
   E_ = Esame;
-  Util::DEBUG_LOG << "MinReachSCCV1 erased edges: "
+  Util::DEBUG_LOG << "MinReachSCCV2 erased edges: "
     << dsbg_.E().difference(E_) << "\n\n";
 
   // Swap directions

ast/expr.cpp

@@ -437,7 +437,7 @@ std::ostream &operator<<(std::ostream &out, const Call &c)
   out << c.name() << "(";
   if (sz > 0) {
     unsigned int i = 0;
-    for (; i < sz - 1; i++)
+    for (; i < sz - 1; ++i)
       out << c.args()[i] << ", ";
     out << c.args()[i];
   }

eval/eval_exec.cpp

@@ -32,6 +32,7 @@
 #include "eval/visitors/autom_impl_visitor.hpp"
 #include "parser/file_parser.hpp"
 #include "util/debug.hpp"
+#include "util/logger.hpp"
 
 namespace SBG {
 
@@ -64,29 +65,52 @@ 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)"
-     "\n  - 1 for V2 of minimum reachable SCC");
+     "\n  - 0 for V1 of minimum reachable SCC"
+     "\n  - 1 for V2 of minimum reachable SCC (default option)");
 
   cmd_line_opts_.add(generic_).add(config_).add(hidden_);
   cfg_file_opts_.add(config_).add(hidden_);
   visible_.add(generic_).add(config_);
 }
 
-EvalUserInput EvalExecutor::gatherUserInput()
+EvalUserInput EvalExecutor::chooseImplementation()
 {
   EvalUserInput result;
 
-  result.set_set_impl(set_impl_);
+  AutomImplVisitor autom_impl_visitor;
+  EvalUserInput autom_impl = autom_impl_visitor.visit(Parser::parseFile(
+    *input_file_, false));
+
+  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;
@@ -130,14 +154,12 @@ 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);
+  if (vm.count("debug")) {
+    Util::SBGLogger::instance().setLevel(Util::LogLevel::Debug);
+  }
 
-    EvalUserInput input = gatherUserInput();
+  if (input_file_) {
+    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/pretty_print.hpp

@@ -33,14 +33,14 @@ namespace Eval {
 template<typename T, typename... Ts>
 std::ostream &operator<<(std::ostream &out, const std::variant<T, Ts...> &v);
 
-using StmResult = std::tuple<AST::Name, ExprBaseType>;
-std::ostream &operator<<(std::ostream &out, const StmResult &e);
-using StmResultList = std::vector<StmResult>;
-std::ostream &operator<<(std::ostream &out, const StmResultList &e);
 using ExprResult = std::tuple<AST::Expr, ExprBaseType>;
 std::ostream &operator<<(std::ostream &out, const ExprResult &e);
 using ExprResultList = std::vector<ExprResult>;
 std::ostream &operator<<(std::ostream &out, const ExprResultList &ee);
+using StmResult = std::tuple<AST::Name, ExprBaseType>;
+std::ostream &operator<<(std::ostream &out, const StmResult &s);
+using StmResultList = std::vector<StmResult>;
+std::ostream &operator<<(std::ostream &out, const StmResultList &ss);
 
 /** 
  * @brief Class to pretty print a program and its correspondent evaluation.

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;
 }