add some method for utils

lib/utils/CMakeLists.txt

@@ -31,4 +31,4 @@ target_link_libraries(
 ff_set_cxx_properties(${project_target})
 
 add_subdirectory(ffi)
-# add_subdirectory(test)
+add_subdirectory(test)

lib/utils/include/utils/graph/adjacency_digraph.h

@@ -25,10 +25,13 @@ class AdjacencyDiGraph : public IDiGraph {
     return new AdjacencyDiGraph(this->next_node_idx, this->adjacency);
   }
 
+  AdjacencyDiGraph() = default;
+
 private:
   using ContentsType = std::unordered_map<Node, std::unordered_set<Node>>;
 
-  AdjacencyDiGraph(std::size_t, ContentsType);
+  AdjacencyDiGraph(std::size_t idx, ContentsType adjacency)
+      : next_node_idx(idx), adjacency(adjacency) {}
 
   std::size_t next_node_idx = 0;
   ContentsType adjacency;

lib/utils/include/utils/graph/adjacency_multidigraph.h

@@ -21,14 +21,19 @@ class AdjacencyMultiDiGraph : public IMultiDiGraph {
     return new AdjacencyMultiDiGraph(this->next_node_idx, this->adjacency);
   }
 
+  AdjacencyMultiDiGraph() = default;
+  ~AdjacencyMultiDiGraph() = default;
+
 private:
   using ContentsType = std::unordered_map<
       Node,
       std::unordered_map<
           Node,
           std::unordered_map<std::size_t, std::unordered_set<std::size_t>>>>;
 
-  AdjacencyMultiDiGraph(std::size_t, ContentsType const &);
+  AdjacencyMultiDiGraph(std::size_t next_node_idx,
+                        ContentsType const &adjacency)
+      : next_node_idx(next_node_idx), adjacency(adjacency) {}
 
 private:
   std::size_t next_node_idx = 0;

lib/utils/include/utils/graph/algorithms.h

@@ -113,9 +113,11 @@ std::unordered_map<Node, std::unordered_set<Node>>
 std::unordered_map<Node, std::unordered_set<Node>>
     get_predecessors(DiGraphView const &, std::unordered_set<Node> const &);
 
+// return the set of nodes without incoming edges
 std::unordered_set<Node> get_sources(DiGraphView const &);
 std::unordered_set<Node> get_sources(MultiDiGraphView const &);
 
+// return the set of nodes without outgoing edges
 std::unordered_set<Node> get_sinks(DiGraphView const &);
 std::unordered_set<Node> get_sinks(MultiDiGraphView const &);
 

lib/utils/include/utils/graph/cow_ptr_t.h

@@ -50,21 +50,26 @@ struct cow_ptr_t {
   }
 
   T const *operator->() const {
-    return &this->get();
+    return this->get();
   }
 
   std::shared_ptr<T const> get_shared_ptr() const {
     if (this->has_unique_access()) {
-      this->set_shared(shared_ptr(this->get_unique()));
+      this->set_shared(shared_t(this->get_unique()));
     }
     return this->get_shared();
   }
 
   T *mutable_ptr() const {
     if (this->has_unique_access()) {
-      return *this->get_unique();
+      return this->get_unique().get();
     } else {
-      this->set_unique(unique_t(this->get_shared()->clone()));
+      auto shared = this->get_shared();
+      this->set_unique(unique_t(shared->clone()));
+      if (auto ptr = mpark::get_if<unique_t>(&this->ptr)) {
+        return ptr->get();
+      }
+      return nullptr;
     }
   }
 
@@ -91,25 +96,29 @@ struct cow_ptr_t {
   }
 
 private:
-  void set_shared(shared_t ptr) {
-    this->ptr = variant<shared_t>(std::move(ptr));
+  void set_shared(shared_t ptr) const {
+    this->ptr =
+        variant<std::unique_ptr<T>, std::shared_ptr<T const>>(std::move(ptr));
   }
 
-  void set_unique(unique_t ptr) {
-    this->ptr = variant<unique_t>(std::move(ptr));
+  void set_unique(std::unique_ptr<T> ptr) const {
+    this->ptr =
+        variant<std::unique_ptr<T>, std::shared_ptr<T const>>(std::move(ptr));
   }
 
-  std::unique_ptr<T> &get_unique() const {
-    return ::FlexFlow::get<unique_t>(this->ptr);
+  std::unique_ptr<T> get_unique() const {
+    auto ptr = mpark::get_if<unique_t>(&this->ptr);
+    return std::move(*ptr);
   }
 
-  std::shared_ptr<T const> &get_shared() const {
-    return ::FlexFlow::get<shared_t>(this->ptr);
+  std::shared_ptr<T const> get_shared() const {
+    auto ptr = mpark::get_if<shared_t>(&this->ptr);
+    return *ptr;
   }
 
-  mutable variant<unique_t, shared_t> ptr;
+  mutable variant<std::unique_ptr<T>, std::shared_ptr<T const>> ptr;
 };
 
 } // namespace FlexFlow
 
-#endif
+#endif

lib/utils/include/utils/graph/digraph.h

@@ -46,7 +46,7 @@ struct IDiGraphView : public IGraphView {
   IDiGraphView &operator=(IDiGraphView const &) = delete;
 
   virtual std::unordered_set<Edge> query_edges(EdgeQuery const &) const = 0;
-  virtual ~IDiGraphView();
+  virtual ~IDiGraphView() = default;
 
 protected:
   IDiGraphView() = default;
@@ -62,7 +62,9 @@ struct DiGraphView {
 
   DiGraphView() = delete;
 
-  operator GraphView() const;
+  operator GraphView() const {
+    return GraphView(this->ptr);
+  }
 
   friend void swap(DiGraphView &, DiGraphView &);
 
@@ -87,9 +89,9 @@ struct DiGraphView {
     return DiGraphView(std::make_shared<T>(std::forward<Args>(args)...));
   }
 
-private:
-  DiGraphView(std::shared_ptr<IDiGraphView const>);
+  DiGraphView(std::shared_ptr<IDiGraphView const> ptr) : ptr(ptr) {}
 
+private:
   friend DiGraphView unsafe(IDiGraphView const &);
 
 private:

lib/utils/include/utils/graph/labelled_graph_interfaces.h

@@ -48,7 +48,7 @@ static_assert(
 struct MultiDiOutput : public use_visitable_cmp<MultiDiOutput> {
 public:
   MultiDiOutput() = delete;
-  MultiDiOutput(Node const &, size_t);
+  MultiDiOutput(Node const &node, size_t idx) : node(node), idx(idx) {}
 
 public:
   Node node;
@@ -57,7 +57,7 @@ struct MultiDiOutput : public use_visitable_cmp<MultiDiOutput> {
 
 struct MultiDiInput : public use_visitable_cmp<MultiDiInput> {
 public:
-  MultiDiInput(Node const &, size_t);
+  MultiDiInput(Node const &node, size_t idx) : node(node), idx(idx) {}
 
 public:
   Node node;