Merge branch 'develop' into clang-tidy/modernize-raw-string-literal

Author: SigureMo

.clang-tidy

@@ -174,7 +174,7 @@ Checks: '
 modernize-make-unique,
 -modernize-pass-by-value,
 modernize-raw-string-literal,
--modernize-redundant-void-arg,
+modernize-redundant-void-arg,
 -modernize-replace-auto-ptr,
 -modernize-replace-random-shuffle,
 -modernize-shrink-to-fit,

paddle/cinn/backends/ir_schedule_test.cc

@@ -177,7 +177,7 @@ void TestSplitThrow() {
   std::vector<Expr> vec_ast{ast_expr};
   ir::ModuleExpr mod_expr(vec_ast);
   ir::IRSchedule ir_sch(
-      mod_expr, -1, false, ir::ScheduleErrorMessageLevel::kGeneral);
+      mod_expr, -1, false, utils::ErrorMessageLevel::kGeneral);
   auto fused = ir_sch.Fuse("B", {0, 1});
   // statement that cause the exception
   auto splited = ir_sch.Split(fused, {-1, -1});
@@ -196,7 +196,7 @@ void TestSplitThrow() {
   auto source_code = codegen.Compile(module, CodeGenC::OutputKind::CImpl);
 }
 TEST(IrSchedule, split_throw) {
-  ASSERT_THROW(TestSplitThrow(), ir::enforce::EnforceNotMet);
+  ASSERT_THROW(TestSplitThrow(), utils::enforce::EnforceNotMet);
 }
 
 TEST(IrSchedule, reorder1) {

paddle/cinn/frontend/paddle_model_to_program.cc

@@ -398,12 +398,6 @@ void PaddleModelToProgram::AddOpMapper_relu6() {
     CHECK_EQ(op_desc.Output("Out").size(), 1UL);
     auto out_name = op_desc.Output("Out").front();
 
-    absl::flat_hash_map<std::string, hlir::framework::NodeAttr::attr_t> attrs;
-    CHECK(op_desc.HasAttr("threshold"));
-    CHECK_EQ(op_desc.GetAttr<float>("threshold"), 6.0f)
-        << "Threshold of Relu6 is not 6! To be implemented.";
-    attrs["threshold"] = op_desc.GetAttr<float>("threshold");
-
     auto x = GetVar(TransValidVarName(x_name));
     auto out = net_builder_->Relu6(x);
     AddVar(TransValidVarName(out_name), out);

paddle/cinn/hlir/framework/new_ir_compiler.h

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #pragma once
+#include <absl/types/variant.h>
 #include <memory>
 #include <unordered_map>
 #include "paddle/cinn/common/context.h"
@@ -30,9 +31,15 @@ namespace cinn {
 namespace hlir {
 namespace framework {
 
-// TODO(Aurelius): Need add name mapping logic in REGISTER_CINN_OP
-// macros or attempt to unify Op name with Paddle and CINN.
-static const std::unordered_map<std::string, std::string> OP_NAMES = {
+struct CompatibleInfo {
+  static constexpr char* kInputPrefix = "input_";
+  static constexpr char* kOutputPrefix = "output_";
+  // TODO(Aurelius): Need add name mapping logic in REGISTER_CINN_OP
+  // macros or attempt to unify Op name with Paddle and CINN.
+  static const std::unordered_map<std::string, std::string> OP_NAMES;
+};
+
+const std::unordered_map<std::string, std::string> CompatibleInfo::OP_NAMES = {
     {"pd.full", "fill_constant"}, {"pd.matmul", "matmul"}};
 
 // TODO(Aurelius84): Need abstract this logic to implement Proxy for
@@ -70,18 +77,32 @@ class NewIRCompiler final {
     compiler_->Build(build_module, "");
 
     auto instructions = BuildInstructions(groups);
+
+    // TODO(Aurelius84): Instantiate all tensors on compile-time, which is
+    // controlled by 'options.with_instantiate_variables' in GraphCompiler.
+    // Moreover, it's better to implement InsertBufferHandlers() logic
+    // to automatically insert Malloc and Free instructions.
+    for (auto& name : scope_->var_names()) {
+      std::string var_name({name.data(), name.size()});
+      VLOG(4) << "Instantiate " << var_name << " on compile-time";
+      auto* var = scope_->Var<Tensor>(var_name);
+      auto& tensor = absl::get<Tensor>(*var);
+      tensor->mutable_data(target_, tensor->type());
+    }
     return std::make_unique<Program>(scope_, std::move(instructions));
   }
 
   std::vector<ir::LoweredFunc> GetOpFunc(const ::ir::Operation& op, int idx) {
     std::vector<ir::Tensor> inputs;
     std::vector<common::CINNValue> cinn_inputs;
-    VLOG(4) << "GetOpFunc for op: " << op.name();
+    auto op_name = op.name();
+    VLOG(4) << "GetOpFunc for op: " << op_name;
     // step 1: Deal with Oprands
     for (int i = 0; i < op.num_operands(); ++i) {
       auto in_value = op.operand(i);
       // TODO(Aurelius84): For now, use addr as name but it's not wise.
-      std::string input_id = std::to_string(std::hash<::ir::Value>()(in_value));
+      std::string input_id = CompatibleInfo::kInputPrefix +
+                             std::to_string(std::hash<::ir::Value>()(in_value));
       // NOTE(Aurelius84): whether need to support other Type?
       auto type_info =
           in_value.type().dyn_cast<paddle::dialect::DenseTensorType>();
@@ -100,8 +121,7 @@ class NewIRCompiler final {
       cinn_inputs.push_back(common::CINNValue(temp));
     }
     for (auto out_name : OpGetOutputNames(op)) {
-      cinn_inputs.push_back(
-          common::CINNValue(op.name().substr(3) + "_" + out_name));
+      cinn_inputs.push_back(common::CINNValue(out_name));
     }
 
     VLOG(4) << "inputs.size(): " << inputs.size();
@@ -124,14 +144,14 @@ class NewIRCompiler final {
     {
       VLOG(4) << "op.attributes():" << op.attributes().size();
       auto attrs = utils::ConvertAttributes(op.attributes());
-      node_attrs.node_name = OP_NAMES.at(op.name());
+      node_attrs.node_name = CompatibleInfo::OP_NAMES.at(op_name);
       node_attrs.attr_store = std::move(attrs);
     }
     auto& strategy = Operator::GetAttrs<StrategyFunction>("CINNStrategy");
     // NOTE(Aurelius84): Do we need replace all hlir::framework Operator with
     // ::ir::Program ？
     const hlir::framework::Operator* cinn_op =
-        Operator::Get(OP_NAMES.at(op.name()));
+        Operator::Get(CompatibleInfo::OP_NAMES.at(op_name));
     auto impl = OpStrategy::SelectImpl(
         strategy[cinn_op](node_attrs, inputs, out_types, out_shapes, target_));
     common::CINNValuePack C =
@@ -223,7 +243,8 @@ class NewIRCompiler final {
     std::unordered_set<std::string> repeat;
     for (int i = 0; i < op.num_operands(); ++i) {
       auto value = op.operand(i);
-      std::string name = std::to_string(std::hash<::ir::Value>()(value));
+      std::string name = CompatibleInfo::kInputPrefix +
+                         std::to_string(std::hash<::ir::Value>()(value));
       if (repeat.count(name)) {
         continue;
       }
@@ -237,7 +258,8 @@ class NewIRCompiler final {
     std::vector<std::string> names;
     for (int i = 0; i < op.num_results(); ++i) {
       auto value = op.result(i);
-      std::string name = std::to_string(std::hash<::ir::Value>()(value));
+      std::string name = CompatibleInfo::kOutputPrefix +
+                         std::to_string(std::hash<::ir::Value>()(value));
       names.push_back(std::move(name));
     }
     return names;
@@ -257,11 +279,12 @@ std::shared_ptr<Scope> BuildScope(const Target& target,
   std::unordered_set<::ir::Value> visited;
   auto scope = std::make_shared<Scope>();
 
-  auto create_var = [&](::ir::Value value) {
+  auto create_var = [&](const std::string& name_prefix, ::ir::Value value) {
     if (visited.count(value) > 0) return;
     visited.emplace(value);
 
-    std::string name = std::to_string(std::hash<::ir::Value>()(value));
+    std::string name =
+        name_prefix + std::to_string(std::hash<::ir::Value>()(value));
     auto type_info = value.type().dyn_cast<paddle::dialect::DenseTensorType>();
     auto* var = scope->Var<Tensor>(name);
     auto& tensor = absl::get<Tensor>(*var);
@@ -279,12 +302,12 @@ std::shared_ptr<Scope> BuildScope(const Target& target,
     // visit OpOprands
     for (auto i = 0; i < (*it)->num_operands(); ++i) {
       auto in_value = (*it)->operand(i);
-      create_var(in_value);
+      create_var(CompatibleInfo::kInputPrefix, in_value);
     }
 
     for (auto i = 0; i < (*it)->num_results(); ++i) {
       auto out_value = (*it)->result(i);
-      create_var(out_value);
+      create_var(CompatibleInfo::kOutputPrefix, out_value);
     }
   }
   return scope;

paddle/cinn/ir/schedule/ir_schedule.cc

@@ -41,7 +41,7 @@
 #include "paddle/cinn/optim/replace_var_with_expr.h"
 #include "paddle/cinn/utils/string.h"
 
-DECLARE_int32(cinn_schedule_error_message_level);
+DECLARE_int32(cinn_error_message_level);
 
 namespace cinn {
 namespace ir {
@@ -54,12 +54,11 @@ class ScheduleImpl {
   ScheduleImpl() = default;
   explicit ScheduleImpl(const ModuleExpr& module_expr,
                         bool debug_flag = false,
-                        ScheduleErrorMessageLevel err_msg_level =
-                            ScheduleErrorMessageLevel::kGeneral)
+                        utils::ErrorMessageLevel err_msg_level =
+                            utils::ErrorMessageLevel::kGeneral)
       : module_expr_(module_expr), debug_flag_(debug_flag) {
-    err_msg_level_ = static_cast<ScheduleErrorMessageLevel>(
-        FLAGS_cinn_schedule_error_message_level ||
-        static_cast<int>(err_msg_level));
+    err_msg_level_ = static_cast<utils::ErrorMessageLevel>(
+        FLAGS_cinn_error_message_level || static_cast<int>(err_msg_level));
   }
   explicit ScheduleImpl(ModuleExpr&& module_expr)
       : module_expr_(std::move(module_expr)) {}
@@ -138,8 +137,7 @@ class ScheduleImpl {
 
   ModuleExpr module_expr_;
   bool debug_flag_{false};
-  ScheduleErrorMessageLevel err_msg_level_ =
-      ScheduleErrorMessageLevel::kGeneral;
+  utils::ErrorMessageLevel err_msg_level_ = utils::ErrorMessageLevel::kGeneral;
 };
 
 /** \brief A macro that guards the beginning of each implementation of schedule
@@ -152,10 +150,10 @@ class ScheduleImpl {
  * @param err_msg_level A ScheduleErrorMessageLevel enum, level of error message
  * printing
  */
-#define CINN_IR_SCHEDULE_END(primitive, err_msg_level)                    \
-  }                                                                       \
-  catch (const IRScheduleErrorHandler& err_hanlder) {                     \
-    CINN_THROW(err_hanlder.FormatErrorMessage(primitive, err_msg_level)); \
+#define CINN_IR_SCHEDULE_END(err_msg_level)                    \
+  }                                                            \
+  catch (const utils::ErrorHandler& err_hanlder) {             \
+    CINN_THROW(err_hanlder.FormatErrorMessage(err_msg_level)); \
   }
 
 std::vector<Expr> ScheduleImpl::Split(const Expr& loop,
@@ -177,7 +175,7 @@ std::vector<Expr> ScheduleImpl::Split(const Expr& loop,
   std::vector<int> processed_factors;
   CINN_IR_SCHEDULE_BEGIN();
   processed_factors = ValidateFactors(factors, tot_extent, this->module_expr_);
-  CINN_IR_SCHEDULE_END("split", this->err_msg_level_);
+  CINN_IR_SCHEDULE_END(this->err_msg_level_);
   int prod_size = std::accumulate(processed_factors.begin(),
                                   processed_factors.end(),
                                   1,
@@ -2316,7 +2314,7 @@ IRSchedule::IRSchedule() {}
 IRSchedule::IRSchedule(const ModuleExpr& module_expr,
                        utils::LinearRandomEngine::StateType rand_seed,
                        bool debug_flag,
-                       ScheduleErrorMessageLevel err_msg_level) {
+                       utils::ErrorMessageLevel err_msg_level) {
   impl_ =
       std::make_unique<ScheduleImpl>(module_expr, debug_flag, err_msg_level);
   this->InitSeed(rand_seed);

paddle/cinn/ir/schedule/ir_schedule.h

@@ -24,25 +24,12 @@
 #include "paddle/cinn/ir/schedule/schedule_desc.h"
 #include "paddle/cinn/ir/tensor.h"
 #include "paddle/cinn/ir/utils/ir_mutator.h"
+#include "paddle/cinn/utils/error.h"
 #include "paddle/cinn/utils/random_engine.h"
 
 namespace cinn {
 namespace ir {
 
-/**
- *  \brief Indicates the level of printing error message in the current Schedule
- */
-enum class ScheduleErrorMessageLevel : int32_t {
-  /** \brief  Print an error message in short mode.
-   * Short mode shows which and where the schedule error happens*/
-  kGeneral = 0,
-  /** \brief Print an error message in detailed mode.
-   * Detailed mode shows which and where the schedule error happens, and the
-   * schedule input parameters.
-   */
-  kDetailed = 1,
-};
-
 /**
  * A struct representing a module that contains Expr. This struct is only used
  * in Schedule process.
@@ -85,8 +72,8 @@ class IRSchedule {
   explicit IRSchedule(const ModuleExpr& modexpr,
                       utils::LinearRandomEngine::StateType rand_seed = -1,
                       bool debug_flag = false,
-                      ScheduleErrorMessageLevel err_msg_level =
-                          ScheduleErrorMessageLevel::kGeneral);
+                      utils::ErrorMessageLevel err_msg_level =
+                          utils::ErrorMessageLevel::kGeneral);
   IRSchedule(ir::ModuleExpr&& mod_expr,
              ScheduleDesc&& trace,
              utils::LinearRandomEngine::StateType rand_seed = -1);

paddle/cinn/ir/schedule/ir_schedule_error.cc

@@ -20,7 +20,11 @@ namespace cinn {
 namespace ir {
 
 std::string IRScheduleErrorHandler::GeneralErrorMessage() const {
-  return this->err_msg_;
+  std::ostringstream os;
+  os << "[IRScheduleError] An error occurred in the scheduel primitive < "
+     << this->primitive_ << " >. " << std::endl;
+  os << this->err_msg_;
+  return os.str();
 }
 
 std::string IRScheduleErrorHandler::DetailedErrorMessage() const {
@@ -31,44 +35,5 @@ std::string IRScheduleErrorHandler::DetailedErrorMessage() const {
   return os.str();
 }
 
-std::string IRScheduleErrorHandler::FormatErrorMessage(
-    const std::string& primitive,
-    const ScheduleErrorMessageLevel& err_msg_level) const {
-  std::ostringstream os;
-  std::string err_msg = err_msg_level == ScheduleErrorMessageLevel::kDetailed
-                            ? DetailedErrorMessage()
-                            : GeneralErrorMessage();
-
-  os << "[IRScheduleError] An error occurred in the scheduel primitive <"
-     << primitive << ">. " << std::endl;
-  os << "[Error info] " << err_msg;
-  return os.str();
-}
-
-std::string NegativeFactorErrorMessage(const int64_t& factor,
-                                       const size_t& idx) {
-  std::ostringstream os;
-  os << "The params in factors of Split should be positive. However, the "
-        "factor at position "
-     << idx << " is " << factor << std::endl;
-  return os.str();
-}
-
-std::string InferFactorErrorMessage() {
-  std::ostringstream os;
-  os << "The params in factors of Split should not be less than -1 or have "
-        "more than one -1!"
-     << std::endl;
-  return os.str();
-}
-
-std::string FactorProductErrorMessage() {
-  std::ostringstream os;
-  os << "In Split, the factors' product should be not larger than or equal "
-        "to original loop's extent!"
-     << std::endl;
-  return os.str();
-}
-
 }  // namespace ir
 }  // namespace cinn