Merge pull request PaddlePaddle#33 from Superjomn/fea/init-module

fea/init module

cinn/CMakeLists.txt

@@ -7,5 +7,6 @@ add_subdirectory(poly)
 add_subdirectory(schedule)
 add_subdirectory(runtime)
 add_subdirectory(ir)
+add_subdirectory(backends)
 add_subdirectory(lang)
 add_subdirectory(optim)

cinn/backends/CMakeLists.txt

@@ -0,0 +1,4 @@
+cc_library(
+  backends
+  SRCS outputs.cc
+)

cinn/backends/outputs.cc

@@ -0,0 +1,5 @@
+#include "cinn/lang/outputs.h"
+
+namespace cinn {
+namespace lang {}  // namespace lang
+}  // namespace cinn

cinn/backends/outputs.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <string>
+
+namespace cinn {
+namespace backends {
+
+/**
+ * A struct specifying a collection of outputs.
+ */
+struct Outputs {
+  //! The name of the emitted object file. Empty if no object file is desired.
+  std::string object_name;
+
+  //! The name of the emitted llvm bitcode. Empty if no bitcode file is desired.
+  std::string bitcode_name;
+
+  //! The name of the emitted C header file.
+  std::string c_header_name;
+
+  Outputs object(const std::string& name) const {
+    Outputs updated     = *this;
+    updated.object_name = name;
+    return updated;
+  }
+
+  Outputs bitcode(const std::string& name) const {
+    Outputs updated      = *this;
+    updated.bitcode_name = name;
+    return updated;
+  }
+
+  Outputs c_header(const std::string& name) const {
+    Outputs updated       = *this;
+    updated.c_header_name = name;
+    return updated;
+  }
+};
+
+}  // namespace backends
+}  // namespace cinn

cinn/common/CMakeLists.txt

@@ -1,5 +1,6 @@
 cc_library(common
         SRCS shared.cc pod_value.cc type.cc
+        target.cc
         object.cc
         graph_utils.cc
         context.cc

cinn/common/common.h

@@ -5,7 +5,9 @@
 #include "cinn/common/graph_utils.h"
 #include "cinn/common/pod_value.h"
 #include "cinn/common/shared.h"
+#include "cinn/common/target.h"
 #include "cinn/common/type.h"
+#include "target.h"
 
 namespace cinn {
 
@@ -22,4 +24,6 @@ using common::Float;
 using common::Int;
 using common::type_of;
 
+using common::Target;
+
 }  // namespace cinn

cinn/utils/target.cc → cinn/common/target.cc

@@ -1,7 +1,7 @@
-#include "cinn/utils/target.h"
+#include "cinn/common/target.h"
 
 namespace cinn {
-namespace utils {
+namespace common {
 
 bool Target::operator==(const Target &other) const {
   return os == other.os &&      //
@@ -10,5 +10,5 @@ bool Target::operator==(const Target &other) const {
          features == other.features;
 }
 
-}  // namespace utils
+}  // namespace common
 }  // namespace cinn

cinn/utils/target.h → cinn/common/target.h

@@ -3,7 +3,7 @@
 #include <vector>
 
 namespace cinn {
-namespace utils {
+namespace common {
 
 struct Target {
   /**
@@ -46,5 +46,5 @@ struct Target {
   bool operator==(const Target& other) const;
   bool operator!=(const Target& other) const { return !(*this == other); }
 };
-}  // namespace utils
+}  // namespace common
 }  // namespace cinn

cinn/lang/CMakeLists.txt

@@ -3,6 +3,7 @@ cc_library(lang SRCS
         compute.cc
         placeholder.cc
         tensor.cc
+        module.cc
         DEPS ir poly runtime)
 
 cc_test(test_compute SRCS compute_test.cc DEPS lang)

cinn/lang/module.cc

@@ -0,0 +1,46 @@
+#include "cinn/lang/module.h"
+
+namespace cinn {
+namespace lang {
+
+/**
+ * Content of a module.
+ */
+struct _Module_ : Object {
+  std::string name;
+  Target target;
+  std::vector<ir::Buffer> buffers;
+  std::vector<ir::PackedFunc> functions;
+  std::vector<Module> submodules;
+
+  const char *type_info() const override { return "_Module_"; }
+};
+
+_Module_ *Module::self() { return module_->As<_Module_>(); }
+const _Module_ *Module::self() const { return module_->As<_Module_>(); }
+
+Module::Module(const std::string &name, const Target &target) : module_(make_shared<_Module_>()) {
+  self()->name   = name;
+  self()->target = target;
+}
+
+const Target &Module::target() const { return self()->target; }
+
+const std::string &Module::name() const { return self()->name; }
+
+const std::vector<ir::Buffer> &Module::buffers() const { return self()->buffers; }
+
+const std::vector<ir::PackedFunc> &Module::functions() const { return self()->functions; }
+
+const std::vector<Module> &Module::submodules() const { return self()->submodules; }
+
+void Module::Append(const ir::Buffer &buffer) { self()->buffers.push_back(buffer); }
+
+void Module::Append(const ir::PackedFunc &function) { self()->functions.push_back(function); }
+
+void Module::Append(const Module &module) { self()->submodules.push_back(module); }
+
+void Module::Compile(const backends::Outputs &outputs) const {}
+
+}  // namespace lang
+}  // namespace cinn

cinn/lang/module.h

@@ -0,0 +1,53 @@
+#pragma once
+#include <string>
+#include <vector>
+
+#include "cinn/backends/outputs.h"
+#include "cinn/common/common.h"
+#include "cinn/ir/buffer.h"
+#include "cinn/ir/function.h"
+
+namespace cinn {
+namespace lang {
+
+class _Module_;
+
+/**
+ * Module represents IR containing lowered function definitions and buffers.
+ */
+class Module {
+ public:
+  Module(const std::string& name, const Target& target);
+
+  //! Get the target of this module.
+  const Target& target() const;
+
+  //! Get the name of the module.
+  const std::string& name() const;
+
+  //! The members in the module.
+  // @{
+  const std::vector<ir::Buffer>& buffers() const;
+  const std::vector<ir::PackedFunc>& functions() const;
+  const std::vector<Module>& submodules() const;
+  // @}
+
+  //! Add something to this module.
+  // @{
+  void Append(const ir::Buffer& buffer);
+  void Append(const ir::PackedFunc& function);
+  void Append(const Module& module);
+  // @}
+
+  //! Compile a module to some outputs.
+  void Compile(const backends::Outputs& outputs) const;
+
+  _Module_* self();
+  const _Module_* self() const;
+
+ private:
+  Shared<_Module_> module_;
+};
+
+}  // namespace lang
+}  // namespace cinn

cinn/utils/CMakeLists.txt

@@ -1,4 +1,3 @@
 cc_library(utils SRCS string.cc
-        target.cc
         functional.cc
         )