From 2a147c235db08f1aec8e2c955c85cfd8a66fe693 Mon Sep 17 00:00:00 2001
From: YdrMaster <ydrml@hotmail.com>
Date: Sun, 23 Apr 2023 16:02:38 +0800
Subject: [PATCH] =?UTF-8?q?style:=20=E8=B0=83=E6=95=B4=E7=BB=93=E6=9E=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: YdrMaster <ydrml@hotmail.com>
---
 optimization/include/optimization/common.h | 19 +++++++++++++++++
 optimization/src/mutation.cc               | 24 ----------------------
 optimization/src/mutation.h                | 14 -------------
 optimization/src/pass/single_operator.cc   | 14 +++++++++++++
 optimization/src/pass/single_operator.h    | 16 +++++++++++++++
 optimization/test/test.cpp                 |  9 ++++----
 6 files changed, 54 insertions(+), 42 deletions(-)
 delete mode 100644 optimization/src/mutation.cc
 create mode 100644 optimization/src/pass/single_operator.cc
 create mode 100644 optimization/src/pass/single_operator.h

diff --git a/optimization/include/optimization/common.h b/optimization/include/optimization/common.h
index 588f8c69..86ce0d20 100644
--- a/optimization/include/optimization/common.h
+++ b/optimization/include/optimization/common.h
@@ -1,3 +1,22 @@
 #pragma once
 
 #include "../../src/mutation.h"
+#include "../../src/pass/single_operator.h"
+#include <unordered_set>
+
+namespace optimization {
+
+/// @brief Calculates the memory usage of a graph.
+/// @param arg0 The graph.
+/// @return The reciprocal of the total memory usage of the graph in bytes.
+inline float memory_usage(Unigraph const &g) {
+    std::unordered_set<size_t> mark;
+    uintptr_t memory;
+    for (const auto &op : g.operators)
+        for (const auto &t : op.outputs)
+            if (mark.insert(reinterpret_cast<uintptr_t>(t.get())).second)
+                memory += t->size();
+    return 1e6f / static_cast<float>(memory);
+}
+
+} // namespace optimization
diff --git a/optimization/src/mutation.cc b/optimization/src/mutation.cc
deleted file mode 100644
index d2f2fc3e..00000000
--- a/optimization/src/mutation.cc
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "mutation.h"
-#include <unordered_set>
-
-using namespace optimization;
-
-Vec<std::pair<Unigraph, SingleOperator>>
-optimization::split_each(Unigraph &&g) {
-    Vec<std::pair<Unigraph, SingleOperator>> ans;
-    for (auto &op : g.operators) {
-        auto &[g, t] = ans.emplace_back();
-        g.push_operator(op.op_type, op.inputs, op.outputs);
-    }
-    return ans;
-}
-
-float optimization::memory_usage(Unigraph const &g) {
-    std::unordered_set<size_t> mark;
-    uintptr_t memory;
-    for (const auto &op : g.operators)
-        for (const auto &t : op.outputs)
-            if (mark.insert(reinterpret_cast<uintptr_t>(t.get())).second)
-                memory += t->size();
-    return 1e6f / static_cast<float>(memory);
-}
diff --git a/optimization/src/mutation.h b/optimization/src/mutation.h
index 93bbc935..5334f2a1 100644
--- a/optimization/src/mutation.h
+++ b/optimization/src/mutation.h
@@ -147,20 +147,6 @@ template <class PartitionType> class Rating {
     }
 };
 
-/// @brief Partition every operator as a `Unigraph`.
-struct SingleOperator {};
-
-/// @brief Splits a graph into subgraphs, where each subgraph contains
-///        only one operator.
-/// @param arg0 An unpartitioned graph.
-/// @return A vector of individual subgraphs.
-Vec<std::pair<Unigraph, SingleOperator>> split_each(Unigraph &&);
-
-/// @brief Calculates the memory usage of a graph.
-/// @param arg0 The graph.
-/// @return The reciprocal of the total memory usage of the graph in bytes.
-float memory_usage(Unigraph const &);
-
 template <class t> Vec<size_t> list_size(Vec<SubGraph<t>> const &list) {
     Vec<size_t> ans(list.size());
     std::transform(list.begin(), list.end(), ans.begin(),
diff --git a/optimization/src/pass/single_operator.cc b/optimization/src/pass/single_operator.cc
new file mode 100644
index 00000000..cd471ad5
--- /dev/null
+++ b/optimization/src/pass/single_operator.cc
@@ -0,0 +1,14 @@
+#include "single_operator.h"
+
+using namespace optimization;
+using namespace pass;
+
+Vec<std::pair<Unigraph, SingleOperator>>
+optimization::pass::split_each(Unigraph &&g) {
+    Vec<std::pair<Unigraph, SingleOperator>> ans;
+    for (auto &op : g.operators) {
+        auto &[g, t] = ans.emplace_back();
+        g.push_operator(op.op_type, op.inputs, op.outputs);
+    }
+    return ans;
+}
diff --git a/optimization/src/pass/single_operator.h b/optimization/src/pass/single_operator.h
new file mode 100644
index 00000000..0a88dd45
--- /dev/null
+++ b/optimization/src/pass/single_operator.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../mutation.h"
+
+namespace optimization::pass {
+
+/// @brief Partition every operator as a `Unigraph`.
+struct SingleOperator {};
+
+/// @brief Splits a graph into subgraphs, where each subgraph contains
+///        only one operator.
+/// @param arg0 An unpartitioned graph.
+/// @return A vector of individual subgraphs.
+Vec<std::pair<Unigraph, SingleOperator>> split_each(Unigraph &&);
+
+} // namespace optimization::pass
diff --git a/optimization/test/test.cpp b/optimization/test/test.cpp
index baa7186e..b6a0f8d9 100644
--- a/optimization/test/test.cpp
+++ b/optimization/test/test.cpp
@@ -1,4 +1,4 @@
-#include "../src/mutation.h"
+#include "../include/optimization/common.h"
 #include <iostream>
 #include <unordered_set>
 
@@ -28,11 +28,12 @@ int main() {
             {c}                        // outputs
         );
 
-        auto p = Partition<SingleOperator>(std::move(g), split_each);
-        auto m = Mutation<SingleOperator>(
+        auto p =
+            Partition<pass::SingleOperator>(std::move(g), pass::split_each);
+        auto m = Mutation<pass::SingleOperator>(
             std::move(p),
             [](const auto &g, const auto &t) { return Vec<Unigraph>{}; });
-        auto r = Rating<SingleOperator>(std::move(m), memory_usage);
+        auto r = Rating<pass::SingleOperator>(std::move(m), memory_usage);
         auto ans = r.build(Vec<size_t>(r.size().size(), 0));
 
         return 0;