[PIR] add paddle fatal mechanism. (#62571)

winter-wang · web-flow · commit e365fcd46c4c · 2024-03-11T11:10:00.000+08:00
diff --git a/paddle/common/enforce.cc b/paddle/common/enforce.cc
@@ -14,6 +14,7 @@ limitations under the License. */
 
 #include "paddle/common/enforce.h"
 #include <array>
+#include <atomic>
 #include <map>
 #include <string>
 #include <vector>
@@ -48,13 +49,19 @@ std::string SimplifyDemangleStr(std::string str) {
   }
   return str;
 }
+
+std::atomic_bool paddle_fatal_skip{false};
+
 }  // namespace
 
 namespace common {
 namespace enforce {
-TEST_API int GetCallStackLevel() { return FLAGS_call_stack_level; }
+void SkipPaddleFatal(bool skip) { paddle_fatal_skip.store(skip); }
+bool IsPaddleFatalSkip() { return paddle_fatal_skip.load(); }
+
+int GetCallStackLevel() { return FLAGS_call_stack_level; }
 
-TEST_API std::string SimplifyErrorTypeFormat(const std::string& str) {
+std::string SimplifyErrorTypeFormat(const std::string& str) {
   std::ostringstream sout;
   size_t type_end_pos = str.find(':', 0);
   if (type_end_pos == std::string::npos) {
diff --git a/paddle/common/enforce.h b/paddle/common/enforce.h
@@ -66,7 +66,24 @@ class CommonNotMetException : public std::exception {
 };
 
 namespace enforce {
+
+TEST_API void SkipPaddleFatal(bool skip = true);
+TEST_API bool IsPaddleFatalSkip();
+
 namespace details {
+
+class PaddleFatalGuard {
+ public:
+  PaddleFatalGuard() : skip_paddle_fatal_(IsPaddleFatalSkip()) {
+    if (!skip_paddle_fatal_) SkipPaddleFatal(true);
+  }
+  ~PaddleFatalGuard() {
+    if (!skip_paddle_fatal_) SkipPaddleFatal(false);
+  }
+
+ private:
+  bool skip_paddle_fatal_;
+};
 template <typename T>
 struct CanToString {
  private:
@@ -204,6 +221,8 @@ struct EnforceNotMet : public std::exception {
   // Simple error message used when no C++ stack and python compile stack
   // e.g. (InvalidArgument) ***
   std::string simple_err_str_;
+
+  details::PaddleFatalGuard paddle_fatal_guard_;
 };
 /** HELPER MACROS AND FUNCTIONS **/
 #ifndef PADDLE_MAY_THROW
@@ -266,6 +285,14 @@ using CommonType2 = typename std::add_lvalue_reference<
     END_HANDLE_THE_ERROR                                                \
   } while (0)
 
+#define PADDLE_FATAL(...)                                          \
+  if (!::common::enforce::IsPaddleFatalSkip()) {                   \
+    auto info = ::common::enforce::EnforceNotMet(                  \
+        paddle::string::Sprintf(__VA_ARGS__), __FILE__, __LINE__); \
+    std::cerr << info.what() << std::endl;                         \
+    std::abort();                                                  \
+  }
+
 #define __PADDLE_BINARY_COMPARE(__VAL1, __VAL2, __CMP, __INV_CMP, ...)         \
   do {                                                                         \
     auto __val1 = (__VAL1);                                                    \
@@ -357,6 +384,7 @@ class IrNotMetException : public std::exception {
 
  private:
   std::string err_str_;
+  ::common::enforce::details::PaddleFatalGuard paddle_fatal_guard_;
 };
 
 #define IR_THROW(...)                                                     \
diff --git a/paddle/pir/include/core/op_info.h b/paddle/pir/include/core/op_info.h
@@ -32,7 +32,7 @@ typedef void (*VerifyPtr)(Operation *op);
 
 class IR_API OpInfo {
  public:
-  OpInfo() = default;
+  OpInfo(std::nullptr_t ptr = nullptr){};  // NOLINT
 
   OpInfo(const OpInfo &other) = default;
 
diff --git a/paddle/pir/include/core/value.h b/paddle/pir/include/core/value.h
@@ -32,7 +32,7 @@ class ValueImpl;
 ///
 class IR_API Value {
  public:
-  Value() = default;
+  Value(std::nullptr_t ptr = nullptr){};  // NOLINT
 
   Value(detail::ValueImpl *impl) : impl_(impl) {}  // NOLINT
 
diff --git a/paddle/pir/src/core/block.cc b/paddle/pir/src/core/block.cc
@@ -24,7 +24,10 @@
 namespace pir {
 Block::~Block() {
   if (!use_empty()) {
-    LOG(FATAL) << "Destroyed a block that is still in use.";
+    auto parent_op = GetParentOp();
+    PADDLE_FATAL(
+        "Destroyed a block that is still in use.. The parent op is : %s",
+        parent_op ? parent_op->name() : std::string("nullptr"));
   }
   ClearOps();
   ClearKwargs();
diff --git a/paddle/pir/src/core/block_argument.cc b/paddle/pir/src/core/block_argument.cc
@@ -75,7 +75,17 @@ class BlockArgumentImpl : public ValueImpl {
 
 BlockArgumentImpl::~BlockArgumentImpl() {
   if (!use_empty()) {
-    LOG(FATAL) << "Destroyed a block argument that is still in use.";
+    if (is_kwarg_) {
+      PADDLE_FATAL(
+          "Destroyed a keyword block argument that is still in use. The key is "
+          ": %s",
+          keyword_);
+    } else {
+      PADDLE_FATAL(
+          "Destroyed a position block argument that is still in use. The index "
+          "is : %u",
+          index_);
+    }
   }
 }
 
diff --git a/paddle/pir/src/core/op_result_impl.cc b/paddle/pir/src/core/op_result_impl.cc
@@ -14,6 +14,7 @@
 
 #include <glog/logging.h>
 
+#include "paddle/common/enforce.h"
 #include "paddle/pir/include/core/builtin_attribute.h"
 #include "paddle/pir/include/core/operation.h"
 #include "paddle/pir/src/core/op_result_impl.h"
@@ -30,8 +31,9 @@ uint32_t OpResultImpl::index() const {
 
 OpResultImpl::~OpResultImpl() {
   if (!use_empty()) {
-    LOG(FATAL) << "Destroyed a op_result that is still in use. \n"
-               << "The owner op type is:" << owner()->name();
+    PADDLE_FATAL(
+        "Destroyed a op_result that is still in use. The owner op type is : %s",
+        owner()->name());
   }
 }
 
@@ -73,11 +75,12 @@ Attribute OpResultImpl::attribute(const std::string &key) const {
 void OpResultImpl::set_attribute(const std::string &key, Attribute value) {
   auto owner = this->owner();
   auto attr = owner->attribute(key);
-  if (attr && !attr.isa<ArrayAttribute>()) {
-    IR_THROW(
-        "The %s attribute has existed as operation attribute. Can't set it as "
-        "value attribute. ");
-  }
+  PADDLE_ENFORCE_EQ(attr && !attr.isa<ArrayAttribute>(),
+                    false,
+                    common::errors::PreconditionNotMet(
+                        "The %s attribute has existed as operation attribute. "
+                        "Can't set it as value attribute. ",
+                        key));
   auto array_attr = attr.dyn_cast<ArrayAttribute>();
   auto index = this->index();
   std::vector<Attribute> vec;
@@ -87,5 +90,15 @@ void OpResultImpl::set_attribute(const std::string &key, Attribute value) {
   owner->set_attribute(key, ArrayAttribute::get(owner->ir_context(), vec));
 }
 
+OpInlineResultImpl::OpInlineResultImpl(Type type, uint32_t result_index)
+    : OpResultImpl(type, result_index) {
+  PADDLE_ENFORCE_LE(
+      result_index,
+      MAX_INLINE_RESULT_IDX,
+      common::errors::PreconditionNotMet(
+          "Inline result index [%u] should not exceed MaxInlineResultIndex(5)",
+          result_index));
+}
+
 }  // namespace detail
 }  // namespace pir
diff --git a/paddle/pir/src/core/op_result_impl.h b/paddle/pir/src/core/op_result_impl.h
@@ -42,7 +42,7 @@ class OpResultImpl : public ValueImpl {
   ///
   uint32_t index() const;
 
-  ~OpResultImpl();
+  TEST_API ~OpResultImpl();
 
   ///
   /// \brief attribute related public interfaces
@@ -60,12 +60,7 @@ class OpResultImpl : public ValueImpl {
 ///
 class OpInlineResultImpl : public OpResultImpl {
  public:
-  OpInlineResultImpl(Type type, uint32_t result_index)
-      : OpResultImpl(type, result_index) {
-    if (result_index > MAX_INLINE_RESULT_IDX) {
-      throw("Inline result index should not exceed MaxInlineResultIndex(5)");
-    }
-  }
+  TEST_API OpInlineResultImpl(Type type, uint32_t result_index);
 
   static bool classof(const ValueImpl &value) {
     return value.kind() < OUTLINE_RESULT_IDX;
diff --git a/paddle/pir/src/core/operation.cc b/paddle/pir/src/core/operation.cc
@@ -372,9 +372,13 @@ void Operation::Verify() {
 }
 
 int32_t Operation::ComputeOpResultOffset(uint32_t index) const {
-  if (index >= num_results_) {
-    LOG(FATAL) << "index exceeds OP op result range.";
-  }
+  PADDLE_ENFORCE_LT(
+      index,
+      num_results_,
+      common::errors::PreconditionNotMet(
+          "The op result index [%u] must less than results size[%u].",
+          index,
+          num_results_));
   if (index < OUTLINE_RESULT_IDX) {
     return -static_cast<int32_t>((index + 1u) * sizeof(OpInlineResultImpl));
   }
@@ -384,9 +388,13 @@ int32_t Operation::ComputeOpResultOffset(uint32_t index) const {
 }
 
 int32_t Operation::ComputeOpOperandOffset(uint32_t index) const {
-  if (index >= num_operands_) {
-    LOG(FATAL) << "index exceeds OP op operand range.";
-  }
+  PADDLE_ENFORCE_LT(
+      index,
+      num_operands_,
+      common::errors::PreconditionNotMet(
+          "The op operand index [%u] must less than operands size[%u].",
+          index,
+          num_operands_));
   return static_cast<int32_t>(index * sizeof(OpOperandImpl) +
                               sizeof(Operation));
 }
diff --git a/paddle/pir/src/core/value_impl.cc b/paddle/pir/src/core/value_impl.cc
@@ -14,6 +14,7 @@
 
 #include <glog/logging.h>
 
+#include "paddle/common/enforce.h"
 #include "paddle/pir/src/core/value_impl.h"
 
 namespace {
@@ -50,10 +51,12 @@ std::string ValueImpl::PrintUdChain() {
   return result.str();
 }
 ValueImpl::ValueImpl(Type type, uint32_t kind) : id_(GenerateId()) {
-  if (kind > BLOCK_ARG_IDX) {
-    LOG(FATAL) << "The kind of value_impl(" << kind
-               << "), is bigger than BLOCK_ARG_IDX(7)";
-  }
+  PADDLE_ENFORCE_LE(
+      kind,
+      BLOCK_ARG_IDX,
+      common::errors::PreconditionNotMet(
+          "The kind of value_impl[%u] must not bigger than BLOCK_ARG_IDX(7)",
+          kind));
   type_ = type;
   first_use_offseted_by_kind_ = reinterpret_cast<OpOperandImpl *>(
       reinterpret_cast<uintptr_t>(nullptr) + kind);
diff --git a/test/cpp/pir/core/CMakeLists.txt b/test/cpp/pir/core/CMakeLists.txt
@@ -8,6 +8,7 @@ paddle_test(ir_program_test SRCS ir_program_test.cc)
 paddle_test(ir_infershape_test SRCS ir_infershape_test.cc)
 paddle_test(scalar_attribute_test SRCS scalar_attribute_test.cc)
 paddle_test(ir_printer_test SRCS ir_printer_test.cc DEPS test_dialect)
+paddle_test(paddle_fatal_test SRCS paddle_fatal_test.cc)
 
 file(
   DOWNLOAD https://paddle-ci.gz.bcebos.com/ir_translator_test/resnet50_main.prog
diff --git a/test/cpp/pir/core/block_argument_test.cc b/test/cpp/pir/core/block_argument_test.cc
@@ -103,3 +103,22 @@ TEST(block_argument_test, kwargs) {
   EXPECT_EQ(block->kwargs_size(), 4u);
   EXPECT_EQ(value.type(), builder.bool_type());
 }
+
+TEST(block_argument_test, fatal) {
+  auto block = new pir::Block();
+  auto arg = block->AddArg(nullptr);
+  auto op = pir::Operation::Create({arg}, {}, {}, nullptr);
+  EXPECT_DEATH(delete block,
+               "Destroyed a position block argument that is still in use.*");
+  auto kwarg = block->AddKwarg("a", nullptr);
+  arg.ReplaceAllUsesWith(kwarg);
+  block->ClearArgs();
+  EXPECT_DEATH(delete block,
+               "Destroyed a keyword block argument that is still in use.*");
+
+  op->Destroy();
+  op = pir::Operation::Create({}, {}, {}, nullptr, 0, {block});
+  EXPECT_DEATH(delete block, "Destroyed a block that is still in use.*");
+  op->Destroy();
+  delete block;
+}
diff --git a/test/cpp/pir/core/ir_value_test.cc b/test/cpp/pir/core/ir_value_test.cc
@@ -21,6 +21,7 @@
 #include "paddle/pir/include/core/ir_context.h"
 #include "paddle/pir/include/core/operation.h"
 #include "paddle/pir/include/dialect/shape/utils/shape_analysis.h"
+#include "paddle/pir/src/core/op_result_impl.h"
 
 // This unittest is used to test the construction interfaces of value class and
 // operation. The constructed test scenario is: a = OP1(); b = OP2(); c = OP3(a,
@@ -50,7 +51,7 @@ TEST(value_test, value_test) {
       op1_inputs,
       test::CreateAttributeMap({"op1_name"}, {"op1_attr"}),
       op1_output_types,
-      pir::OpInfo());
+      nullptr);
   op1->Print(std::cout);
   pir::Value a = op1->result(0);
   EXPECT_TRUE(a.use_empty());
@@ -61,7 +62,7 @@ TEST(value_test, value_test) {
       op2_inputs,
       test::CreateAttributeMap({"op2_name"}, {"op2_attr"}),
       op2_output_types,
-      pir::OpInfo());
+      nullptr);
   op2->Print(std::cout);
   pir::Value b = op2->result(0);
   EXPECT_TRUE(b.use_empty());
@@ -72,7 +73,7 @@ TEST(value_test, value_test) {
       op3_inputs,
       test::CreateAttributeMap({"op3_name"}, {"op3_attr"}),
       op3_output_types,
-      pir::OpInfo());
+      nullptr);
 
   EXPECT_TRUE(op1->result(0).HasOneUse());
   EXPECT_TRUE(op2->result(0).HasOneUse());
@@ -88,7 +89,7 @@ TEST(value_test, value_test) {
       op4_inputs,
       test::CreateAttributeMap({"op4_name"}, {"op4_attr"}),
       op4_output_types,
-      pir::OpInfo());
+      nullptr);
   op4->Print(std::cout);
 
   // Test 1:
@@ -135,3 +136,21 @@ TEST(value_test, value_test) {
   VLOG(0) << op1->result(0).PrintUdChain() << std::endl;
   op1->Destroy();
 }
+
+TEST(op_result_test, exception) {
+  EXPECT_THROW(
+      pir::detail::OpInlineResultImpl(nullptr, MAX_INLINE_RESULT_IDX + 1),
+      common::enforce::EnforceNotMet);
+  pir::IrContext *ctx = pir::IrContext::Instance();
+  auto op = pir::Operation::Create(
+      {}, {{"test", pir::Int32Attribute::get(ctx, 1)}}, {nullptr}, nullptr);
+  auto result = op->result(0);
+  auto op2 = pir::Operation::Create({result}, {}, {}, nullptr);
+  EXPECT_DEATH(op->Destroy(), "Destroyed a op_result that is still in use.*");
+  EXPECT_THROW(result.set_attribute("test", nullptr),
+               common::enforce::EnforceNotMet);
+  EXPECT_THROW(op->result(1), common::enforce::EnforceNotMet);
+  EXPECT_THROW(op->operand(1), common::enforce::EnforceNotMet);
+  op2->Destroy();
+  op->Destroy();
+}
diff --git a/test/cpp/pir/core/paddle_fatal_test.cc b/test/cpp/pir/core/paddle_fatal_test.cc
