PaddlePaddle · luotao1 · Mar 19, 2024 · Mar 14, 2024 · Mar 15, 2024 · Mar 15, 2024
diff --git a/paddle/cinn/adt/adt.h b/paddle/cinn/adt/adt.h
@@ -283,7 +283,7 @@ struct Ok final {
   bool operator!=(const Ok&) const { return false; }
 };
 
-#define ADT_TODO() LOG(FATAL) << "TODO"
+#define ADT_TODO() PADDLE_THROW(phi::errors::Fatal("TODO"))
 
 inline std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
   return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);

diff --git a/paddle/cinn/adt/equation_solver.cc b/paddle/cinn/adt/equation_solver.cc
@@ -273,7 +273,8 @@ void CheckEquationsSolvable(
         [&](const auto& opt_old_value, const auto& simplified_value) {
           LOG(ERROR) << "old_value: " << ToTxtString(opt_old_value);
           LOG(ERROR) << "simplified_value: " << ToTxtString(simplified_value);
-          LOG(FATAL) << "CheckEquationsSolvable Failed";
+          PADDLE_THROW(
+              phi::errors::InvalidArgument("CheckEquationsSolvable Failed"));
           return tValueInferSuccess<bool>{false};
         });
   };

diff --git a/paddle/cinn/adt/get_sub_reshape_dim_ranges.cc b/paddle/cinn/adt/get_sub_reshape_dim_ranges.cc
@@ -82,7 +82,7 @@ GetSubReshapeDimRanges(const List<DimExpr>& lhs_dims,
     } else if (LhsAcc() > RhsAcc()) {
       rhs_end++;
     } else {
-      LOG(FATAL) << "Dead code";
+      PADDLE_THROW(phi::errors::Fatal("Dead code"));
     }
   }
   CHECK(lhs_end == lhs_dims->size() && rhs_end == rhs_dims->size());

diff --git a/paddle/cinn/adt/igroup.cc b/paddle/cinn/adt/igroup.cc
@@ -102,10 +102,10 @@ List<Iterator> IGroup::GetIndexIterators(const Index& index) const {
     } else if (arg_pos.Has<Undefined>()) {
       // do nothing
     } else {
-      LOG(FATAL) << "Dead code";
+      PADDLE_THROW(phi::errors::Fatal("Dead code"));
     }
   }
-  LOG(FATAL) << "Can not find anchor iterators";
+  PADDLE_THROW(phi::errors::Fatal("Can not find anchor iterators"));
 }
 
 }  // namespace cinn::adt
diff --git a/paddle/cinn/adt/m_ir.cc b/paddle/cinn/adt/m_ir.cc
@@ -38,12 +38,12 @@ void CollectTensorIndexIterators(const TensorIndexExpr& tensor_index_expr,
 
 void CollectTensorIndexIteratorsImpl(const Undefined& tensor_index_expr,
                                      std::unordered_set<Iterator>* ret) {
-  LOG(FATAL) << "Not Implemented";
+  PADDLE_THROW(phi::errors::Unimplemented("Not Implemented"));
 }
 
 void CollectTensorIndexIteratorsImpl(const Ok& ok,
                                      std::unordered_set<Iterator>* ret) {
-  LOG(FATAL) << "Not Implemented";
+  PADDLE_THROW(phi::errors::Unimplemented("Not Implemented"));
 }
 
 void CollectTensorIndexIteratorsImpl(const Iterator& iterator,
@@ -134,7 +134,7 @@ LoopIterators GetAnchorTensorLoopIterators(
 namespace {
 
 Tensor GetTensorImpl(const OpStmt& op_stmt, const Undefined& undefined) {
-  LOG(FATAL) << "position not found";
+  PADDLE_THROW(phi::errors::Fatal("position not found"));
 }
 
 Tensor GetTensorImpl(const OpStmt& op_stmt, const tIn<std::size_t>& pos) {

diff --git a/paddle/cinn/adt/naive_op_equation_context.cc b/paddle/cinn/adt/naive_op_equation_context.cc
@@ -240,7 +240,7 @@ std::optional<std::int64_t> GetArgDimSizeImpl(
     const Undefined&,
     const GetArgStaticDimT& GetInDim,
     const GetArgStaticDimT& GetOutDim) {
-  LOG(FATAL) << "position not found";
+  PADDLE_THROW(phi::errors::Fatal("position not found"));
 }
 
 std::optional<std::int64_t> GetArgDimSize(const OpArgDimPos& arg_dim_pos,

diff --git a/paddle/cinn/adt/print_utils/print_map_expr.cc b/paddle/cinn/adt/print_utils/print_map_expr.cc
@@ -71,7 +71,7 @@ std::string ToTxtStringImpl(const adapter::DynamicTensor& tensor) {
 }
 
 std::string ToTxtStringImpl(const TempStorage& tensor) {
-  LOG(FATAL) << "Not supported yet";
+  PADDLE_THROW(phi::errors::Unimplemented("Not supported yet"));
 }
 
 }  // namespace

diff --git a/paddle/cinn/adt/schedule_dim.cc b/paddle/cinn/adt/schedule_dim.cc
@@ -188,7 +188,7 @@ List<int> GetReduceAxis(const List<ScheduleDim>& loop_sizes) {
     } else if (sched_dim.Has<tInjective<LoopSize>>()) {
       // do nothing
     } else {
-      LOG(FATAL) << "Dead code";
+      PADDLE_THROW(phi::errors::Fatal("Dead code"));
     }
   }
   return reduce_axis;
@@ -203,7 +203,7 @@ List<int> GetInjectiveAxis(const List<ScheduleDim>& loop_sizes) {
     } else if (sched_dim.Has<tInjective<LoopSize>>()) {
       injective_axis->emplace_back(i);
     } else {
-      LOG(FATAL) << "Dead code";
+      PADDLE_THROW(phi::errors::Fatal("Dead code"));
     }
   }
   return injective_axis;

diff --git a/paddle/cinn/adt/schedule_mesh.cc b/paddle/cinn/adt/schedule_mesh.cc
@@ -370,7 +370,8 @@ std::tuple<ScheduleMesh, List<LoopType>> CreateOptimizedScheduleMesh(
       return policy->Optimize(loop_sizes);
     }
   }
-  LOG(FATAL) << "Dead code, no valid schedule mesh policy found";
+  PADDLE_THROW(
+      phi::errors::Fatal("Dead code, no valid schedule mesh policy found"));
 }
 
 ScheduleMesh MeshReshape(const ScheduleMesh& sched_mesh,

diff --git a/paddle/cinn/adt/simplify_value.cc b/paddle/cinn/adt/simplify_value.cc
@@ -67,7 +67,7 @@ struct SimplifyRedundantBroadcastedIterator {
       const auto& simplified_bd = DimExpr{symbol::SimplifyDimExpr(bd)};
       return BroadcastedIterator<Value, DimExpr>{inner_iterator, simplified_bd};
     }
-    LOG(FATAL) << "Dead code";
+    PADDLE_THROW(phi::errors::Fatal("Dead code"));
   }
 };
 
@@ -368,7 +368,7 @@ struct SymbolicDim_SimplifyDotUndot {
       return IndexDotValue<Value, List<DimExpr>>{
           SimplifyValue(list_get_item_values, ctx), dot_dims};
     }
-    LOG(FATAL) << "Dead code";
+    PADDLE_THROW(phi::errors::Fatal("Dead code"));
   }
 };
 
@@ -415,7 +415,7 @@ struct SymbolicDim_SimplifyDotUndot_DimExpr {
       return IndexDotValue<Value, List<DimExpr>>{
           SimplifyValue(list_get_item_values, ctx), dot_dims};
     }
-    LOG(FATAL) << "Dead code";
+    PADDLE_THROW(phi::errors::Fatal("Dead code"));
   }
 };
 

diff --git a/paddle/cinn/adt/tree.h b/paddle/cinn/adt/tree.h
@@ -15,9 +15,9 @@
 #pragma once
 
 #include <optional>
-
 #include "paddle/cinn/adt/adt.h"
 #include "paddle/cinn/adt/tags.h"
+#include "paddle/common/enforce.h"
 
 namespace cinn::adt {
 
@@ -144,7 +144,7 @@ List<typename TreeMergerT::tree_type> MergeTwoInnerTreeImpl(
                                                List<TreeT>{new_lhs, new_rhs});
     return List<TreeT>{ret};
   } else {
-    LOG(FATAL) << "Dead code";
+    PADDLE_THROW(phi::errors::Fatal("Dead code"));
   }
 }
 

diff --git a/paddle/cinn/auto_schedule/database/database.cc b/paddle/cinn/auto_schedule/database/database.cc
@@ -54,7 +54,7 @@ std::unique_ptr<Database> Database::Make(const DatabaseConfig& config) {
         config.capacity_per_task, config.record_file_path, true);
   }
 
-  LOG(FATAL) << "Unimplemented database type.";
+  PADDLE_THROW(phi::errors::Unimplemented("Unimplemented database type."));
   return nullptr;
 }
 

diff --git a/paddle/cinn/auto_schedule/search_space/auto_gen_rule/reduction_factoring.h b/paddle/cinn/auto_schedule/search_space/auto_gen_rule/reduction_factoring.h
@@ -36,7 +36,8 @@ class ReductionFactoring : public AutoGenRule {
   }
   // In the future, we will no longer use this interface.
   void Apply(int index) override {
-    LOG(FATAL) << "This is a deprecated interface, please do not use it.";
+    PADDLE_THROW(phi::errors::InvalidArgument(
+        "This is a deprecated interface, please do not use it."));
     return;
   }
 

diff --git a/paddle/cinn/auto_schedule/search_space/auto_gen_rule/test_helper.cc b/paddle/cinn/auto_schedule/search_space/auto_gen_rule/test_helper.cc
@@ -145,7 +145,7 @@ void MemoryCopy(const float* src, float* dst, int numel, std::string type) {
       dst[i] = src[i];
     }
   } else {
-    LOG(FATAL) << "Unknown memory copy type";
+    PADDLE_THROW(phi::errors::InvalidArgument("Unknown memory copy type"));
   }
 }
 

diff --git a/paddle/cinn/auto_schedule/search_space/block_sampler.cc b/paddle/cinn/auto_schedule/search_space/block_sampler.cc
@@ -40,7 +40,9 @@ std::unique_ptr<BlockSampler> BlockSampler::Make(
         all_blocks, default_remove_policy, rand_seed, weights);
   }
 
-  LOG(FATAL) << "Unimplemented strategy:" << strategy;
+  std::stringstream ss;
+  ss << "Unimplemented strategy:" << strategy;
+  PADDLE_THROW(phi::errors::Unimplemented(ss.str()));
   return nullptr;
 }
 

diff --git a/paddle/cinn/auto_schedule/search_space/rule_sampler.cc b/paddle/cinn/auto_schedule/search_space/rule_sampler.cc
@@ -35,7 +35,9 @@ std::unique_ptr<RuleSampler> RuleSampler::Make(
         potential_rules, default_remove_policy, rand_seed, weights);
   }
 
-  LOG(FATAL) << "Unimplemented strategy:" << strategy;
+  std::stringstream ss;
+  ss << "Unimplemented strategy:" << strategy;
+  PADDLE_THROW(phi::errors::Unimplemented(ss.str()));
   return nullptr;
 }
 

diff --git a/paddle/cinn/auto_schedule/search_space/search_space.cc b/paddle/cinn/auto_schedule/search_space/search_space.cc
@@ -261,7 +261,8 @@ std::vector<SearchState> SearchSpace::GenerateSketches(
     } else if (strategy == "random_prune") {
       sketches = InitSketchWithRandomPrunedStrategy();
     } else {
-      LOG(FATAL) << "Unimplemented init sketch strategy";
+      PADDLE_THROW(
+          phi::errors::Unimplemented("Unimplemented init sketch strategy"));
     }
 
     // the more rules are applied, the greater the possibility of good results,

diff --git a/paddle/cinn/auto_schedule/search_strategy/mutate_rule/mutate_rule.cc b/paddle/cinn/auto_schedule/search_strategy/mutate_rule/mutate_rule.cc
@@ -23,7 +23,9 @@ std::unique_ptr<MutateRule> MutateRule::Make(const std::string& name) {
   if (name == "mutate_tile_size") {
     return std::make_unique<MutateTileSize>();
   } else {
-    LOG(FATAL) << "MutateRule " << name << " is not supported.";
+    std::stringstream ss;
+    ss << "MutateRule " << name << " is not supported.";
+    PADDLE_THROW(phi::errors::InvalidArgument(ss.str()));
   }
   return nullptr;
 }

diff --git a/paddle/cinn/auto_schedule/task_scheduler/task_scheduler.cc b/paddle/cinn/auto_schedule/task_scheduler/task_scheduler.cc
@@ -34,7 +34,9 @@ std::unique_ptr<TaskScheduler> TaskScheduler::Make(
     return std::make_unique<EfficiencyPriority>(tasks, config);
   }
 
-  LOG(FATAL) << "Unimplemented strategy:" << strategy;
+  std::stringstream ss;
+  ss << "Unimplemented strategy:" << strategy;
+  PADDLE_THROW(phi::errors::Unimplemented(ss.str()));
   return nullptr;
 }
 

diff --git a/paddle/cinn/backends/codegen_c.cc b/paddle/cinn/backends/codegen_c.cc
@@ -76,7 +76,7 @@ std::string CodeGenC::Compile(const ir::Module &module,
       Compile(func);
     }
   } else {
-    LOG(FATAL) << "Not supported OutputKind";
+    PADDLE_THROW(phi::errors::Unimplemented("Not supported OutputKind"));
   }
   return str_;
 }
@@ -526,8 +526,9 @@ void CodeGenC::Visit(const ir::Let *op) {
 }
 
 void CodeGenC::Visit(const ir::Reduce *op) {
-  LOG(FATAL) << "Reduce IR is just for internal representation, should not be "
-                "used for CodeGen.";
+  PADDLE_THROW(phi::errors::InvalidArgument(
+      "Reduce IR is just for internal representation, should not be "
+      "used for CodeGen."));
 }
 
 void CodeGenC::Visit(const ir::Ramp *op) {
@@ -731,7 +732,8 @@ void CodeGenC::PrintRuntimeType(const cinn_type_t &type) {
   } else if (type == cinn_float64_t()) {
     str_ += "cinn_float64_t()";
   } else {
-    LOG(FATAL) << "Unknown type is not supported to print";
+    PADDLE_THROW(
+        phi::errors::InvalidArgument("Unknown type is not supported to print"));
   }
 }
 
@@ -806,7 +808,9 @@ void CodeGenC::Visit(const ir::intrinsics::PodValueToX *op) {
   } else if (to_type == type_of<cinn_buffer_t *>()) {
     str_ += runtime::intrinsic::pod_value_to_buffer_p;
   } else {
-    LOG(FATAL) << "Not supported type: " << to_type;
+    std::stringstream ss;
+    ss << "Not supported type: " << to_type;
+    PADDLE_THROW(phi::errors::InvalidArgument(ss.str()));
   }
 
   str_ += "(";

diff --git a/paddle/cinn/backends/codegen_cuda_dev.cc b/paddle/cinn/backends/codegen_cuda_dev.cc
@@ -292,7 +292,7 @@ std::string CodeGenCUDA_Dev::Compile(const ir::Module &module,
       Compile(func);
     }
   } else {
-    LOG(FATAL) << "Not supported OutputKind";
+    PADDLE_THROW(phi::errors::InvalidArgument("Not supported OutputKind"));
   }
 
   if (for_nvrtc_) {
@@ -372,8 +372,10 @@ void CodeGenCUDA_Dev::PrintTempBufferCreation(const ir::Buffer &buffer) {
       print_gpu_memory("");
     }
   } else {
-    LOG(FATAL) << "CUDA device codegen not support memory " << buffer->name
-               << ", type " << buffer->memory_type;
+    std::stringstream ss;
+    ss << "CUDA device codegen not support memory " << buffer->name << ", type "
+       << buffer->memory_type;
+    PADDLE_THROW(phi::errors::InvalidArgument(ss.str()));
   }
 }