使用 PADDLE_ENFORCE_EQ 作为报错信息提示 (#66592)

MufanColin · web-flow · commit e72e268fa61d · 2024-07-29T10:30:18.000+08:00
diff --git a/test/cpp/fluid/framework/dlpack_tensor_test.cc b/test/cpp/fluid/framework/dlpack_tensor_test.cc
@@ -55,32 +55,103 @@ void TestMain(const phi::Place &place, uint16_t lanes) {
   DLPackTensor dlpack_tensor(tensor, lanes);
   ::DLTensor &dl_tensor = dlpack_tensor;
 
-  CHECK_EQ(p, dl_tensor.data);
+  PADDLE_ENFORCE_EQ(
+      p,
+      dl_tensor.data,
+      phi::errors::InvalidArgument("Tensor data pointer should be "
+                                   "equal to DLPack "
+                                   "tensor data pointer, but got "
+                                   "tensor data pointer: %p, "
+                                   "DLPack tensor data pointer: %p",
+                                   p,
+                                   dl_tensor.data));
   if (phi::is_cpu_place(place)) {
-    CHECK_EQ(kDLCPU, dl_tensor.device.device_type);
-    CHECK_EQ(0, dl_tensor.device.device_id);
+    PADDLE_ENFORCE_EQ(
+        kDLCPU,
+        dl_tensor.device.device_type,
+        phi::errors::InvalidArgument("Device type should be kDLCPU, "
+                                     "but got %d",
+                                     dl_tensor.device.device_type));
+    PADDLE_ENFORCE_EQ(0,
+                      dl_tensor.device.device_id,
+                      phi::errors::InvalidArgument("Device ID should be 0,"
+                                                   "but got %d",
+                                                   dl_tensor.device.device_id));
   } else if (phi::is_gpu_place(place)) {
-    CHECK_EQ(kDLGPU, dl_tensor.device.device_type);
-    CHECK_EQ(place.device, dl_tensor.device.device_id);
+    PADDLE_ENFORCE_EQ(
+        kDLGPU,
+        dl_tensor.device.device_type,
+        phi::errors::InvalidArgument("Device type should be kDLGPU, but got %d",
+                                     dl_tensor.device.device_type));
+    PADDLE_ENFORCE_EQ(place.device,
+                      dl_tensor.device.device_id,
+                      phi::errors::InvalidArgument("Device ID should be %d, "
+                                                   "but got %d",
+                                                   place.device,
+                                                   dl_tensor.device.device_id));
   } else if (phi::is_cuda_pinned_place(place)) {
-    CHECK_EQ(kDLCPUPinned, dl_tensor.device.device_type);
-    CHECK_EQ(0, dl_tensor.device.device_id);
+    PADDLE_ENFORCE_EQ(
+        kDLCPUPinned,
+        dl_tensor.device.device_type,
+        phi::errors::InvalidArgument("Device type should be kDLCPUPinned, "
+                                     "but got %d",
+                                     dl_tensor.device.device_type));
+    PADDLE_ENFORCE_EQ(0,
+                      dl_tensor.device.device_id,
+                      phi::errors::InvalidArgument("Device ID should be 0, "
+                                                   "but got %d",
+                                                   dl_tensor.device.device_id));
   } else {
-    CHECK_EQ(false, true);
+    PADDLE_ENFORCE_EQ(
+        false, true, phi::errors::InvalidArgument("Unsupported place type"));
   }
 
-  CHECK_EQ(dims.size(), dl_tensor.ndim);
+  PADDLE_ENFORCE_EQ(
+      dims.size(),
+      dl_tensor.ndim,
+      phi::errors::InvalidArgument("Dimension size should be equal to %d,"
+                                   "but got %d",
+                                   dims.size(),
+                                   dl_tensor.ndim));
   for (auto i = 0; i < dims.size(); ++i) {
-    CHECK_EQ(dims[i], dl_tensor.shape[i]);
+    PADDLE_ENFORCE_EQ(
+        dims[i],
+        dl_tensor.shape[i],
+        phi::errors::InvalidArgument("Dimension at index %d should be %d, "
+                                     "but got %d",
+                                     i,
+                                     dims[i],
+                                     dl_tensor.shape[i]));
   }
 
-  CHECK_EQ(dl_tensor.strides == nullptr, true);
-  CHECK_EQ(static_cast<uint64_t>(0), dl_tensor.byte_offset);
-
-  CHECK_EQ(lanes, dl_tensor.dtype.lanes);
-  CHECK_EQ(sizeof(T) * 8, dl_tensor.dtype.bits);
-
-  CHECK_EQ(GetDLDataTypeCode<T>(), dl_tensor.dtype.code);
+  PADDLE_ENFORCE_EQ(dl_tensor.strides == nullptr,
+                    true,
+                    phi::errors::InvalidArgument("Strides should be nullptr, "
+                                                 "but got non-nullptr value"));
+  PADDLE_ENFORCE_EQ(static_cast<uint64_t>(0),
+                    dl_tensor.byte_offset,
+                    phi::errors::InvalidArgument("Byte offset should be 0, "
+                                                 "but got %d",
+                                                 dl_tensor.byte_offset));
+
+  PADDLE_ENFORCE_EQ(
+      lanes,
+      dl_tensor.dtype.lanes,
+      phi::errors::InvalidArgument(
+          "Lanes should be %d, but got %d", lanes, dl_tensor.dtype.lanes));
+  PADDLE_ENFORCE_EQ(sizeof(T) * 8,
+                    dl_tensor.dtype.bits,
+                    phi::errors::InvalidArgument("Data type bits should be %d, "
+                                                 "but got %d",
+                                                 sizeof(T) * 8,
+                                                 dl_tensor.dtype.bits));
+
+  PADDLE_ENFORCE_EQ(GetDLDataTypeCode<T>(),
+                    dl_tensor.dtype.code,
+                    phi::errors::InvalidArgument("Data type code should be %d,"
+                                                 "but got %d",
+                                                 GetDLDataTypeCode<T>(),
+                                                 dl_tensor.dtype.code));
 }
 
 template <typename T>
@@ -94,14 +165,33 @@ void TestToDLManagedTensor(const phi::Place &place, uint16_t lanes) {
 
   ::DLManagedTensor *dl_managed_tensor = dlpack_tensor.ToDLManagedTensor();
 
-  CHECK_EQ(dl_managed_tensor->manager_ctx == nullptr, true);
+  PADDLE_ENFORCE_EQ(
+      dl_managed_tensor->manager_ctx == nullptr,
+      true,
+      phi::errors::InvalidArgument("Manager context should be nullptr, "
+                                   "but got non-nullptr value"));
 
   for (auto i = 0; i < dims.size(); ++i) {
-    CHECK_EQ(dims[i], dl_managed_tensor->dl_tensor.shape[i]);
+    PADDLE_ENFORCE_EQ(
+        dims[i],
+        dl_managed_tensor->dl_tensor.shape[i],
+        phi::errors::InvalidArgument("Dimension at index %d should be %d, "
+                                     "but got %d",
+                                     i,
+                                     dims[i],
+                                     dl_managed_tensor->dl_tensor.shape[i]));
   }
 
-  CHECK_EQ(dl_managed_tensor->dl_tensor.strides[0] == 7, true);
-  CHECK_EQ(dl_managed_tensor->dl_tensor.strides[1] == 1, true);
+  PADDLE_ENFORCE_EQ(
+      dl_managed_tensor->dl_tensor.strides[0] == 7,
+      true,
+      phi::errors::InvalidArgument("Stride at index 0 should be 7, but got %d",
+                                   dl_managed_tensor->dl_tensor.strides[0]));
+  PADDLE_ENFORCE_EQ(
+      dl_managed_tensor->dl_tensor.strides[1] == 1,
+      true,
+      phi::errors::InvalidArgument("Stride at index 1 should be 1, but got %d",
+                                   dl_managed_tensor->dl_tensor.strides[1]));
 
   dl_managed_tensor->deleter(dl_managed_tensor);
 }
