numbering + critical_edge_elimination

Roland Leißa · Roland Leißa · commit ad0f1012b14e · 2023-10-30T22:35:49.000+01:00
diff --git a/README.md b/README.md
@@ -58,3 +58,7 @@ s = ','
   | ';'
   | (ID | g) '->' ... '->' (ID | g) (* edge statement *)
 ```
+
+## Entry \& Exit
+
+The first node mentioned is considered the *entry*, the last one the *exit.
diff --git a/include/graphtool/graph.h b/include/graphtool/graph.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <ostream>
 #include <fe/driver.h>
 
 namespace graphtool {
@@ -13,48 +14,88 @@ class Graph {
 
     class Node {
     private:
+        static constexpr auto Not_Visited = size_t(-1);
+
         Node(Sym name)
             : name_(name) {}
 
     public:
+        Sym name() const { return name_; }
+        size_t pre() const { return pre_; }
+        size_t post() const { return post_; }
+        size_t rp() const { return rp_; }
+
         void link(Node* succ) {
             this->succs_.emplace(succ);
             succ->preds_.emplace(this);
         }
         const auto& preds() const { return preds_; }
         const auto& succs() const { return succs_; }
 
+        friend std::ostream& operator<<(std::ostream&, const Node&);
+
     private:
+        std::pair<size_t, size_t> number(size_t, size_t);
+
         Sym name_;
-        NodeSet preds_;
-        NodeSet succs_;
+        NodeSet preds_, succs_;
+        size_t pre_  = Not_Visited;
+        size_t post_ = Not_Visited;
+        size_t rp_   = Not_Visited;
 
         friend class Graph;
     };
 
-    Graph() = default;
     Graph(const Graph&) = delete;
+    Graph(fe::Driver& driver)
+        : driver_(driver) {}
     Graph(Graph&& other)
-        : name_(other.name_)
+        : driver_(other.driver_)
+        , name_(other.name_)
+        , entry_(other.entry_)
+        , exit_(other.exit_)
         , nodes_(std::move(other.nodes_)) {}
     ~Graph();
 
     Graph& operator=(const Graph&) = delete;
     Graph& operator=(Graph&&) = delete;
 
+    /// @name Getters
+    ///@{
+    fe::Driver& driver() { return driver_; }
+    Sym name() const { return name_; }
+    const auto& nodes() const { return nodes_; }
+    const auto& rpo() const { return rpo_; }
+    ///@}
+
     void set_name(Sym name) { name_ = name; }
     Node* node(Sym name);
+    void critical_edge_elimination();
+
+    void number();
+
+    friend std::ostream& operator<<(std::ostream&, const Graph&);
 
     friend void swap(Graph& g1, Graph& g2) noexcept {
         using std::swap;
-        swap(g1.name_, g2.name_);
-        swap(g1.nodes_, g2.nodes_);
+        // clang-format off
+        swap(g1.driver_, g2.driver_);
+        swap(g1.name_,   g2.name_);
+        swap(g1.entry_,  g2.entry_);
+        swap(g1.exit_,   g2.exit_);
+        swap(g1.nodes_,  g2.nodes_);
+        // clang-format on
     }
 
 private:
+    fe::Driver& driver_;
     Sym name_;
+    Node* entry_ = nullptr;
+    Node* exit_  = nullptr;
     fe::SymMap<Node*> nodes_;
+    std::vector<Node*> rpo_;
 };
 
-
 } // namespace graphtool
+
+template<> struct std::formatter<graphtool::Graph::Node> : fe::ostream_formatter {};
diff --git a/src/graphtool/graph.cpp b/src/graphtool/graph.cpp
@@ -9,9 +9,78 @@ Graph::~Graph() {
 Graph::Node* Graph::node(Sym name) {
     if (auto i = nodes_.find(name); i != nodes_.end()) return i->second;
     auto node = new Node(name);
+    if (entry_ == nullptr) entry_ = node;
+    exit_ = node;
     auto [_, ins] = nodes_.emplace(name, node);
     assert_unused(ins);
     return node;
 }
 
+/*
+ * number
+ */
+
+void Graph::number() {
+    auto [n, m] = entry_->number(0, 0);
+    assert(n == m);
+    rpo_.resize(n);
+    for (auto [_, node] : nodes()) {
+        if (node->post_ != Graph::Node::Not_Visited) {
+            size_t i = n - node->post_ - 1;
+            node->rp_ = i;
+            rpo_[i] = node;
+        }
+    }
+}
+
+std::pair<size_t, size_t> Graph::Node::number(size_t pre, size_t post) {
+    if (pre_ == Not_Visited) {
+        pre_ = pre++;
+        for (auto succ : succs()) std::tie(pre, post) = succ->number(pre, post);
+        post_ = post++;
+    }
+    return {pre, post};
+}
+
+void Graph::critical_edge_elimination() {
+    std::vector<std::pair<Node*, Node*>> crit;
+
+    for (auto [_, node] : nodes_) {
+        if (node->succs().size() > 1) {
+            for (auto succ : node->succs()) {
+                for (auto pred : succ->preds()) {
+                    if (pred->succs().size() > 1) crit.emplace_back(succ, pred);
+                }
+            }
+        }
+    }
+
+    for (auto [v, w] : crit) {
+        auto name = driver().sym(v->name().str() + "." + w->name().str());
+        auto x = node(name);
+        v->succs_.erase(w);
+        w->preds_.erase(v);
+        v->link(x);
+        x->link(w);
+    }
+}
+
+/*
+ * ostream
+ */
+
+std::ostream& operator<<(std::ostream& os, const Graph::Node& node) {
+    return os << std::format("\t\"{}|{}|{}|{}\"", node.name(), node.pre(), node.post(), node.rp());
+}
+
+std::ostream& operator<<(std::ostream& os, const Graph& graph) {
+    os << std::format("digraph {} {{", graph.name()) << std::endl;
+    for (const char* sep = ""; auto node : graph.rpo()) {
+        for (auto succ : node->succs())
+            os << std::format("\t{} -> {}", *node, *succ) << sep;
+        sep = "\n";
+    }
+    return os << '}' << std::endl;;
+}
+
 } // namespace graphtool
diff --git a/src/graphtool/parser.cpp b/src/graphtool/parser.cpp
@@ -10,7 +10,8 @@ namespace graphtool {
 using Tag = Tok::Tag;
 
 Parser::Parser(Driver& driver, std::istream& istream, const std::filesystem::path* path)
-    : lexer_(driver, istream, path)
+    : graph_(driver)
+    , lexer_(driver, istream, path)
     , error_(driver.sym("<error>"s)) {
     init(path);
 }
diff --git a/src/main.cpp b/src/main.cpp
@@ -19,10 +19,10 @@ int main(int argc, char** argv) {
                                     "OPTIONS, ARGUMENTS:\n"
                                     "  -?, -h, --help"
                                     "  -v, --version           Display version info and exit.\n"
-                                    "  -d, --dump              Dumps the graphtool program again.\n"
-                                    "  -e, --eval              Evaluate the graphtool program.\n"
+                                    "  -c, --crit              Eliminate critical edges.\n"
                                     "  <file>                  Input file.\n";
         std::string input;
+        bool crit = false;
 
         for (int i = 1; i < argc; ++i) {
             if (argv[i] == "-v"s || argv[i] == "--version"s) {
@@ -31,6 +31,8 @@ int main(int argc, char** argv) {
             } else if (argv[i] == "-?"s || argv[i] == "-h"s || argv[i] == "--help"s) {
                 std::cerr << usage;
                 return EXIT_SUCCESS;
+            } else if (argv[i] == "-c"s || argv[i] == "--crit"s) {
+                crit = true;
             } else {
                 if (!input.empty()) throw std::invalid_argument("more than one input file given");
                 input = argv[i];
@@ -50,6 +52,12 @@ int main(int argc, char** argv) {
             std::cerr << num << " error(s) encountered" << std::endl;
             return EXIT_FAILURE;
         }
+
+        if (crit) graph.critical_edge_elimination();
+        graph.number();
+
+        std::ofstream ofs("out.dot");
+        ofs << graph;
     } catch (const std::exception& e) {
         std::cerr << "error: " << e.what() << std::endl;
         return EXIT_FAILURE;

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,8 @@ namespace graphtool {`
`10`	`10`	`using Tag = Tok::Tag;`
`11`	`11`
`12`	`12`	`Parser::Parser(Driver& driver, std::istream& istream, const std::filesystem::path* path)`
`13`		`- : lexer_(driver, istream, path)`
	`13`	`+ : graph_(driver)`
	`14`	`+ , lexer_(driver, istream, path)`
`14`	`15`	`, error_(driver.sym("<error>"s)) {`
`15`	`16`	`init(path);`
`16`	`17`	`}`