rename subgraph executor into pipeline executor

huajsj · huajsj · commit 7f0997e34b30 · 2021-04-30T23:45:51.000-07:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -351,11 +351,11 @@ if(USE_PROFILER)
   list(APPEND RUNTIME_SRCS ${RUNTIME_VM_PROFILER_SRCS})
 endif(USE_PROFILER)
 
-if(USE_SUBGRAPH_EXECUTOR)
-    message(STATUS "Build with Subgraph Executor support...")
-  file(GLOB RUNTIME_SUBGRAPH_SRCS src/runtime/subgraph/*.cc)
-  list(APPEND RUNTIME_SRCS ${RUNTIME_SUBGRAPH_SRCS})
-endif(USE_SUBGRAPH_EXECUTOR)
+if(USE_PIPELINE_EXECUTOR)
+  message(STATUS "Build with Pipeline Executor support...")
+  file(GLOB RUNTIME_PIPELINE_SRCS src/runtime/pipeline/*.cc)
+  list(APPEND RUNTIME_SRCS ${RUNTIME_PIPELINE_SRCS})
+endif(USE_PIPELINE_EXECUTOR)
 
 # Module rules
 include(cmake/modules/VTA.cmake)
diff --git a/cmake/config.cmake b/cmake/config.cmake
@@ -99,7 +99,7 @@ set(USE_STACKVM_RUNTIME OFF)
 # Whether enable tiny embedded graph executor.
 set(USE_GRAPH_EXECUTOR ON)
 # Whether enable subgraph runtime.
-set(USE_SUBGRAPH_EXECUTOR ON)
+set(USE_PIPELINE_EXECUTOR ON)
 
 # Whether enable tiny graph executor with CUDA Graph
 set(USE_GRAPH_EXECUTOR_CUDA_GRAPH OFF)
diff --git a/python/tvm/contrib/pipeline_executor.py b/python/tvm/contrib/pipeline_executor.py
@@ -14,13 +14,13 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-"""Minimum subgraph executor that executes subgraph containing TVM PackedFunc."""
+"""Minimum pipeline executor that executes pipeline containing TVM PackedFunc."""
 import tvm._ffi
 from tvm.contrib import graph_executor
 
 
 def create(sub_mods):
-    """Create a subgraph runtime executor.
+    """Create a pipeline runtime executor.
 
     Parameters
     ----------
@@ -30,19 +30,19 @@ def create(sub_mods):
 
     Returns
     -------
-    submodule : SubGraphModule
-        Runtime subgraph module.
+    submodule : PipelineModule
+        Runtime pipeline module.
     """
     mods = []
     for sub_mod in sub_mods:
         mod = graph_executor.GraphModule(sub_mod["default"](sub_mods[sub_mod]["dev"]))
         mods.append(mod)
 
-    submodule = SubGraphModule(mods)
+    submodule = PipelineModule(mods)
     return submodule
 
 
-class SubGraphModule(object):
+class PipelineModule(object):
     """Wrapper runtime module.
 
     This is a thin wrapper of the underlying TVM module.
@@ -66,8 +66,8 @@ def __init__(self, graph_modules):
         for module in graph_modules:
             mods.append(module.module)
 
-        subgraphcreate = tvm._ffi.get_global_func("tvm.subgraph_executor.create")
-        module = subgraphcreate(mods)
+        pipelinecreate = tvm._ffi.get_global_func("tvm.pipeline_executor.create")
+        module = pipelinecreate(mods)
 
         self.graph_modules_ = graph_modules
 
@@ -115,7 +115,7 @@ def run(self, **input_dict):
         self._run()
 
     def stop(self):
-        """Stop subgraph run"""
+        """Stop pipeline run"""
         self._stop()
 
     def get_num_outputs(self):
diff --git a/src/runtime/pipeline/pipeline_data.h b/src/runtime/pipeline/pipeline_data.h
@@ -16,16 +16,16 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-#ifndef TVM_RUNTIME_SUBGRAPH_SUBGRAPH_DATA_H_
-#define TVM_RUNTIME_SUBGRAPH_SUBGRAPH_DATA_H_
+#ifndef TVM_RUNTIME_PIPELINE_PIPELINE_DATA_H_
+#define TVM_RUNTIME_PIPELINE_PIPELINE_DATA_H_
 #define EXPORT __attribute__((visibility("default")))
 #define IMPORT
 #include <condition_variable>
 #include <cstddef>
 #include <mutex>
 #include <thread>
 
-#include "subgraph_struct.h"
+#include "pipeline_struct.h"
 #ifdef __cplusplus
 
 #define read_barrier() std::atomic_thread_fence(std::memory_order_acquire)
@@ -71,4 +71,4 @@ bool q_poll(squeue<SLOT_TYPE>* q, VARIABLE_TYPE* s) {
 // extern "C"
 #endif
 
-#endif  // TVM_RUNTIME_SUBGRAPH_SUBGRAPH_DATA_H_
+#endif  // TVM_RUNTIME_PIPELINE_PIPELINE_DATA_H_
diff --git a/src/runtime/pipeline/pipeline_executor.cc b/src/runtime/pipeline/pipeline_executor.cc
@@ -18,26 +18,26 @@
  */
 
 /*!
- * \file subgraph_runtime.cc
+ * \file pipeline_runtime.cc
  */
-#include "subgraph_executor.h"
+#include "pipeline_executor.h"
 
 #include <tvm/runtime/registry.h>
 
 namespace tvm {
 namespace runtime {
 
 /*!
- *\bief Stop subgraph run.
+ *\bief Stop pipeline run.
  */
-void SubGraphRuntime::Stop() { subgraph_stop(runtimes); }
+void SubGraphRuntime::Stop() { pipeline_stop(runtimes); }
 /*!
  * \brief Run all the operations one by one.
  */
-void SubGraphRuntime::Run() { subgraph_run(runtimes); }
+void SubGraphRuntime::Run() { pipeline_run(runtimes); }
 
 void SubGraphRuntime::Init(const Array<tvm::runtime::Module>& modules) {
-  subgraph_init(modules, &runtimes);
+  pipeline_init(modules, &runtimes);
   SetupStorage();
   return;
 }
@@ -77,14 +77,14 @@ void SubGraphRuntime::SetInput(const std::string& name, DLTensor* data_in) {
 /*!
  * \brief Get the number of outputs
  *
- * \return The number of outputs from last subgraph.
+ * \return The number of outputs from last pipeline.
  */
 int SubGraphRuntime::NumOutputs() const { return runtimes.back()->runtimePtr->NumOutputs(); }
 
 /*!
  * \brief Get the number of inputs
  *
- * \return The number of inputs to the first subgraph.
+ * \return The number of inputs to the first pipeline.
  */
 int SubGraphRuntime::NumInputs() const { return runtimes.front()->runtimePtr->NumInputs(); }
 
@@ -111,7 +111,7 @@ NDArray SubGraphRuntime::GetInput(const std::string& name, int mIndx) const {
  */
 Array<NDArray> SubGraphRuntime::GetOutput(bool syncPoll) {
   Array<NDArray> nd;
-  if (subgraph_poll(&output_entry_, runtimes, syncPoll)) {
+  if (pipeline_poll(&output_entry_, runtimes, syncPoll)) {
     for (auto output : output_entry_) {
       nd.push_back(output);
     }
@@ -169,14 +169,14 @@ PackedFunc SubGraphRuntime::GetFunction(const std::string& name,
   }
 }
 
-Module SubGraphRuntimeCreate(const Array<tvm::runtime::Module>& m) {
+Module PipelineRuntimeCreate(const Array<tvm::runtime::Module>& m) {
   auto exec = make_object<SubGraphRuntime>();
   exec->Init(m);
   return Module(exec);
 }
 
-TVM_REGISTER_GLOBAL("tvm.subgraph_executor.create").set_body([](TVMArgs args, TVMRetValue* rv) {
-  *rv = SubGraphRuntimeCreate(args[0]);
+TVM_REGISTER_GLOBAL("tvm.pipeline_executor.create").set_body([](TVMArgs args, TVMRetValue* rv) {
+  *rv = PipelineRuntimeCreate(args[0]);
 });
 }  // namespace runtime
 }  // namespace tvm
diff --git a/src/runtime/pipeline/pipeline_executor.h b/src/runtime/pipeline/pipeline_executor.h
@@ -22,19 +22,19 @@
  *        containing only tvm PackedFunc.
  * \file graph_runtime.h
  */
-#ifndef TVM_RUNTIME_SUBGRAPH_SUBGRAPH_EXECUTOR_H_
-#define TVM_RUNTIME_SUBGRAPH_SUBGRAPH_EXECUTOR_H_
+#ifndef TVM_RUNTIME_PIPELINE_PIPELINE_EXECUTOR_H_
+#define TVM_RUNTIME_PIPELINE_PIPELINE_EXECUTOR_H_
 #include <memory>
 #include <string>
 #include <vector>
 
-#include "subgraph_function.h"
+#include "pipeline_function.h"
 
 namespace tvm {
 namespace runtime {
 
 /*!
- * \brief subgraph runtime.
+ * \brief pipeline runtime.
  *
  *  This runtime can be acccesibly in various language via
  *  TVM runtime PackedFunc API.
@@ -106,4 +106,4 @@ class TVM_DLL SubGraphRuntime : public ModuleNode {
 }  // namespace runtime
 }  // namespace tvm
 
-#endif  // TVM_RUNTIME_SUBGRAPH_SUBGRAPH_EXECUTOR_H_
+#endif  // TVM_RUNTIME_PIPELINE_PIPELINE_EXECUTOR_H_
diff --git a/src/runtime/pipeline/pipeline_function.cc b/src/runtime/pipeline/pipeline_function.cc
@@ -16,12 +16,12 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-#include "subgraph_function.h"
+#include "pipeline_function.h"
 
 #include <utility>
 using namespace tvm::runtime;
 
-void subgraph_pipeline_run(const int& num, const shared_ptr<RuntimeItem>& curRunItem) {
+void pipeline_pipeline_run(const int& num, const shared_ptr<RuntimeItem>& curRunItem) {
   QUEUE* curQueue = curRunItem->queue;
   QUEUE* nextQueue = curRunItem->next->queue;
 
@@ -31,28 +31,28 @@ void subgraph_pipeline_run(const int& num, const shared_ptr<RuntimeItem>& curRun
    */
   bool suc = false;
   while (curRunItem->waitPipeLineData(suc)) {
-    suc = subgraph_queue_poll(curQueue, &curRunItem->rData);
+    suc = pipeline_queue_poll(curQueue, &curRunItem->rData);
     if (!suc) {
       continue;
     }
 
     curRunItem->Run();
 
     auto output = curRunItem->GetOutput();
-    subgraph_queue_push(nextQueue, output);
+    pipeline_queue_push(nextQueue, output);
     curRunItem->notifyDataReadyToNext();
   }
   curRunItem->notifyNextExit();
 }
 
-thread* subgraph_pipeline_init(SHARED_RUNTIME_VEC* runtimes) {
+thread* pipeline_pipeline_init(SHARED_RUNTIME_VEC* runtimes) {
   for (size_t i = 1; i < runtimes->size(); i++) {
-    (*runtimes)[i]->t = thread(subgraph_pipeline_run, i, (*runtimes)[i]);
+    (*runtimes)[i]->t = thread(pipeline_pipeline_run, i, (*runtimes)[i]);
   }
   return NULL;
 }
 
-void subgraph_init(Array<Module> graphRuntimes, SHARED_RUNTIME_VEC* runtimes) {
+void pipeline_init(Array<Module> graphRuntimes, SHARED_RUNTIME_VEC* runtimes) {
   int len = graphRuntimes.size();
   for (int i = 0; i < len; i++) {
     QUEUE* sub_queue = createQueue<SLOT>(NULL, SUB_Q_SIZE);
@@ -69,43 +69,43 @@ void subgraph_init(Array<Module> graphRuntimes, SHARED_RUNTIME_VEC* runtimes) {
       (*runtimes)[i]->next = (*runtimes)[0];
     }
   }
-  subgraph_pipeline_init(runtimes);
+  pipeline_pipeline_init(runtimes);
   return;
 }
 
-inline void subgraph_queue_push(QUEUE* queue, Array<NDArray> arrays) {
+inline void pipeline_queue_push(QUEUE* queue, Array<NDArray> arrays) {
   q_push<SLOT, Array<NDArray>>(queue, arrays);
   return;
 }
 
-bool subgraph_queue_poll(QUEUE* queue, RuntimeData* runtimeData) {
+bool pipeline_queue_poll(QUEUE* queue, RuntimeData* runtimeData) {
   return q_poll<SLOT, RuntimeData>(queue, runtimeData);
 }
 
-void subgraph_run(const SHARED_RUNTIME_VEC& runtimes) {
+void pipeline_run(const SHARED_RUNTIME_VEC& runtimes) {
   shared_ptr<RuntimeItem> runtime = runtimes.front();
   runtime->Run();
-  subgraph_queue_push(runtime->next->queue, runtime->GetOutput());
+  pipeline_queue_push(runtime->next->queue, runtime->GetOutput());
   runtime->notifyDataReadyToNext();
   return;
 }
 
-bool subgraph_poll(vector<NDArray>* output, const SHARED_RUNTIME_VEC& runtimes, const bool bSynch) {
+bool pipeline_poll(vector<NDArray>* output, const SHARED_RUNTIME_VEC& runtimes, const bool bSynch) {
   shared_ptr<RuntimeItem> firstRuntime = runtimes.front();
   QUEUE* queue = firstRuntime->queue;
   bool suc = false;
-  subgraphOutputData<> outputData(output);
-  suc = q_poll<SLOT, subgraphOutputData<>>(queue, &outputData);
+  pipelineOutputData<> outputData(output);
+  suc = q_poll<SLOT, pipelineOutputData<>>(queue, &outputData);
   while (!suc && bSynch) {
     /*
      * If get exit notify then break.
      */
     if (!firstRuntime->waitPipeLineData(!bSynch)) {
       break;
     }
-    suc = q_poll<SLOT, subgraphOutputData<>>(queue, &outputData);
+    suc = q_poll<SLOT, pipelineOutputData<>>(queue, &outputData);
   }
   return suc;
 }
 
-void subgraph_stop(const SHARED_RUNTIME_VEC& runtimes) { runtimes.front()->notifyNextExit(); }
+void pipeline_stop(const SHARED_RUNTIME_VEC& runtimes) { runtimes.front()->notifyNextExit(); }
diff --git a/src/runtime/pipeline/pipeline_function.h b/src/runtime/pipeline/pipeline_function.h
@@ -16,23 +16,23 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-#ifndef TVM_RUNTIME_SUBGRAPH_SUBGRAPH_FUNCTION_H_
-#define TVM_RUNTIME_SUBGRAPH_SUBGRAPH_FUNCTION_H_
+#ifndef TVM_RUNTIME_PIPELINE_PIPELINE_FUNCTION_H_
+#define TVM_RUNTIME_PIPELINE_PIPELINE_FUNCTION_H_
 #include <memory>
 #include <vector>
 
-#include "subgraph_data.h"
+#include "pipeline_data.h"
 
 using namespace std;
 using namespace tvm::runtime;
 typedef vector<shared_ptr<RuntimeItem>> SHARED_RUNTIME_VEC;
 
-void subgraph_init(Array<Module> graphRuntimes, SHARED_RUNTIME_VEC* runtimes);
-void subgraph_run(const SHARED_RUNTIME_VEC& runtimes);
-inline void subgraph_queue_push(QUEUE* queue, Array<NDArray> arrays);
-bool subgraph_queue_poll(QUEUE* queue, RuntimeData* runtimeData);
-bool subgraph_poll(vector<NDArray>* output, const SHARED_RUNTIME_VEC& runtimes,
+void pipeline_init(Array<Module> graphRuntimes, SHARED_RUNTIME_VEC* runtimes);
+void pipeline_run(const SHARED_RUNTIME_VEC& runtimes);
+inline void pipeline_queue_push(QUEUE* queue, Array<NDArray> arrays);
+bool pipeline_queue_poll(QUEUE* queue, RuntimeData* runtimeData);
+bool pipeline_poll(vector<NDArray>* output, const SHARED_RUNTIME_VEC& runtimes,
                    const bool bSync = false);
-void subgraph_stop(const SHARED_RUNTIME_VEC& runtimes);
+void pipeline_stop(const SHARED_RUNTIME_VEC& runtimes);
 
-#endif  // TVM_RUNTIME_SUBGRAPH_SUBGRAPH_FUNCTION_H_
+#endif  // TVM_RUNTIME_PIPELINE_PIPELINE_FUNCTION_H_
diff --git a/src/runtime/pipeline/pipeline_struct.h b/src/runtime/pipeline/pipeline_struct.h
diff --git a/tests/python/relay/test_analysis_pipeline.py b/tests/python/relay/test_analysis_pipeline.py
