Migrate existing check functions to return bool pattern

Summary:
Migrate existing `check_` functions to the new pattern of using `ET_LOG_AND_RETURN_IF_FALSE` and returning a boolean instead of `ET_CHECK`.

Within kernel code, replace `ET_CHECK` with `ET_KERNEL_CHECK`.

Reviewed By: manuelcandales

Differential Revision: D48242981

fbshipit-source-id: 04a664dbbce79a26584ffb454ec8de21f8af07c7

Author: SS-JIA

kernels/portable/cpu/op_cat.cpp

@@ -26,7 +26,7 @@ Tensor& cat_out(
     dim += out.dim();
   }
 
-  check_cat_args(tensors, dim, out);
+  ET_KERNEL_CHECK(ctx, check_cat_args(tensors, dim, out), InvalidArgument, out);
 
   Tensor::SizesType expected_out_size[kTensorDimensionLimit];
   size_t expected_out_dim = 0;

kernels/portable/cpu/op_native_batch_norm.cpp

@@ -33,12 +33,26 @@ std::tuple<Tensor&, Tensor&, Tensor&> _native_batch_norm_legit_no_training_out(
     Tensor& var_out) {
   (void)ctx;
 
-  ET_CHECK(resize_tensor(out, in.sizes()) == Error::Ok);
+  std::tuple<Tensor&, Tensor&, Tensor&> ret_val(out, mean_out, var_out);
 
-  check_batch_norm_args(
-      in, weight, bias, running_mean, running_var, momentum, eps, out);
+  ET_KERNEL_CHECK(
+      ctx,
+      resize_tensor(out, in.sizes()) == Error::Ok,
+      InvalidArgument,
+      ret_val);
+
+  ET_KERNEL_CHECK(
+      ctx,
+      check_batch_norm_args(
+          in, weight, bias, running_mean, running_var, momentum, eps, out),
+      InvalidArgument,
+      ret_val);
   // For now, only support the default dim order
-  ET_CHECK(is_default_dim_order(in.dim_order().data(), in.dim_order().size()));
+  ET_KERNEL_CHECK(
+      ctx,
+      is_default_dim_order(in.dim_order().data(), in.dim_order().size()),
+      InvalidArgument,
+      ret_val);
 
   size_t C_dim = in.dim() >= 1 ? 1 : 0;
   size_t C = in.size(C_dim);
@@ -75,7 +89,7 @@ std::tuple<Tensor&, Tensor&, Tensor&> _native_batch_norm_legit_no_training_out(
         }
       });
 
-  return {out, mean_out, var_out};
+  return ret_val;
 }
 
 } // namespace native

kernels/portable/cpu/op_permute_copy.cpp

@@ -42,14 +42,19 @@ Tensor& permute_copy_out(
     IntArrayRef dims,
     Tensor& out) {
   (void)ctx;
-  check_permute_copy_args(in, dims, out);
+
+  ET_KERNEL_CHECK(
+      ctx, check_permute_copy_args(in, dims, out), InvalidArgument, out);
 
   Tensor::SizesType expected_out_size[kTensorDimensionLimit];
   size_t expected_out_dim = 0;
   get_permute_copy_out_target_size(
       in, dims, expected_out_size, &expected_out_dim);
-  ET_CHECK(
-      resize_tensor(out, {expected_out_size, expected_out_dim}) == Error::Ok);
+  ET_KERNEL_CHECK(
+      ctx,
+      resize_tensor(out, {expected_out_size, expected_out_dim}) == Error::Ok,
+      InvalidArgument,
+      out);
 
   const auto in_type = out.scalar_type();
   // in and out must be the same dtype

kernels/portable/cpu/op_stack.cpp

@@ -28,13 +28,17 @@ Tensor& stack_out(
     dim += out.dim();
   }
 
-  check_stack_args(tensors, dim, out);
+  ET_KERNEL_CHECK(
+      ctx, check_stack_args(tensors, dim, out), InvalidArgument, out);
 
   Tensor::SizesType expected_out_size[kTensorDimensionLimit];
   size_t expected_out_dim = 0;
   get_stack_out_target_size(tensors, dim, expected_out_size, &expected_out_dim);
-  ET_CHECK(
-      resize_tensor(out, {expected_out_size, expected_out_dim}) == Error::Ok);
+  ET_KERNEL_CHECK(
+      ctx,
+      resize_tensor(out, {expected_out_size, expected_out_dim}) == Error::Ok,
+      InvalidArgument,
+      out);
 
   const size_t outer = getLeadingDims(out, dim);
   const size_t inner = getTrailingDims(out, dim);

kernels/portable/cpu/util/copy_ops_util.cpp

@@ -8,22 +8,19 @@
 
 #include <cstring>
 
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-#include <executorch/runtime/core/exec_aten/util/tensor_util.h>
-#include <executorch/runtime/platform/assert.h>
+#include <executorch/kernels/portable/cpu/util/copy_ops_util.h>
 
 namespace torch {
 namespace executor {
 
 using Tensor = exec_aten::Tensor;
 
-void check_cat_args(
+bool check_cat_args(
     exec_aten::ArrayRef<Tensor> tensors,
     int64_t dim,
     Tensor& out) {
   // Ensure the input tensors list is non-empty
-  ET_CHECK(tensors.size() > 0);
+  ET_LOG_AND_RETURN_IF_FALSE(tensors.size() > 0);
 
   // Find the first non-empty tensor in the list to use as a reference
   size_t ref_i = 0;
@@ -39,25 +36,30 @@ void check_cat_args(
   // https://pytorch.org/docs/stable/generated/torch.cat.html
   for (size_t i = 0; i < tensors.size(); ++i) {
     // All input dtypes must be castable to the output dtype.
-    ET_CHECK(canCast(tensors[i].scalar_type(), out.scalar_type()));
+    ET_LOG_AND_RETURN_IF_FALSE(
+        canCast(tensors[i].scalar_type(), out.scalar_type()));
 
     // Empty tensors have no shape constraints.
     if (tensors[i].numel() == 0) {
       continue;
     }
 
     // All input tensors must have the same number of dimensions.
-    ET_CHECK(tensors[i].dim() == tensors[ref_i].dim());
+    ET_LOG_AND_RETURN_IF_FALSE(
+        tensor_is_rank(tensors[ref_i], tensors[i].dim()));
 
     for (size_t d = 0; d < tensors[i].dim(); ++d) {
       if (d != dim) {
-        ET_CHECK(tensors[i].size(d) == tensors[ref_i].size(d));
+        ET_LOG_AND_RETURN_IF_FALSE(
+            tensors_have_same_size_at_dims(tensors[i], d, tensors[ref_i], d));
       }
     }
   }
 
   // Ensure dim is in range.
-  ET_CHECK(dim >= 0 && dim < tensors[ref_i].dim());
+  ET_LOG_AND_RETURN_IF_FALSE(tensor_has_dim(tensors[ref_i], dim));
+
+  return true;
 }
 
 void get_cat_out_target_size(
@@ -86,9 +88,9 @@ void get_cat_out_target_size(
   }
 }
 
-void check_permute_copy_args(const Tensor& in, IntArrayRef dims, Tensor& out) {
-  ET_CHECK(in.dim() == dims.size());
-  ET_CHECK_SAME_DTYPE2(in, out);
+bool check_permute_copy_args(const Tensor& in, IntArrayRef dims, Tensor& out) {
+  ET_LOG_AND_RETURN_IF_FALSE(tensor_is_rank(in, dims.size()));
+  ET_LOG_AND_RETURN_IF_FALSE(tensors_have_same_dtype(in, out));
 
   // Make sure no dimensions are duplicated and all in the range [-in.dim(),
   // in.dim() - 1]. Use gaussian sum to check this.
@@ -98,13 +100,15 @@ void check_permute_copy_args(const Tensor& in, IntArrayRef dims, Tensor& out) {
     // Convert dimension to a non-negative number. dim_base is in the range
     // [0 .. in.dim() - 1].
     size_t dim = dims[i] > -1 ? dims[i] : in.dim() + dims[i];
-    ET_CHECK(dim >= 0 && dim < in.dim());
+    ET_LOG_AND_RETURN_IF_FALSE(tensor_has_dim(in, dim));
     gauss_sum += dim + 1;
   }
 
-  ET_CHECK_MSG(
+  ET_LOG_MSG_AND_RETURN_IF_FALSE(
       gauss_sum == expected_sum,
       "The dims passed to permute_copy must contain one of each dim!");
+
+  return true;
 }
 
 void get_permute_copy_out_target_size(
@@ -119,28 +123,32 @@ void get_permute_copy_out_target_size(
   }
 }
 
-void check_stack_args(
+bool check_stack_args(
     exec_aten::ArrayRef<Tensor> tensors,
     int64_t dim,
     Tensor& out) {
   // Ensure the input tensors list is non-empty
-  ET_CHECK(tensors.size() > 0);
+  ET_LOG_AND_RETURN_IF_FALSE(tensors.size() > 0);
 
   // All input tensors need to be of the same size
   // https://pytorch.org/docs/stable/generated/torch.stack.html
   for (size_t i = 0; i < tensors.size(); i++) {
     // All input dtypes must be castable to the output dtype.
-    ET_CHECK(canCast(tensors[i].scalar_type(), out.scalar_type()));
+    ET_LOG_AND_RETURN_IF_FALSE(
+        canCast(tensors[i].scalar_type(), out.scalar_type()));
 
-    ET_CHECK(tensors[i].dim() == tensors[0].dim());
+    ET_LOG_AND_RETURN_IF_FALSE(tensor_is_rank(tensors[i], tensors[0].dim()));
     for (size_t d = 0; d < tensors[i].dim(); d++) {
-      ET_CHECK(tensors[i].size(d) == tensors[0].size(d));
+      ET_LOG_AND_RETURN_IF_FALSE(
+          tensors_have_same_size_at_dims(tensors[i], d, tensors[0], d));
     }
   }
 
   // The output tensor will have a dimension inserted, so dim should be between
   // 0 and ndim_of_inputs + 1
-  ET_CHECK(dim >= 0 && dim < tensors[0].dim() + 1);
+  ET_LOG_AND_RETURN_IF_FALSE(dim >= 0 && dim < tensors[0].dim() + 1);
+
+  return true;
 }
 
 void get_stack_out_target_size(

kernels/portable/cpu/util/copy_ops_util.h

@@ -13,7 +13,7 @@
 namespace torch {
 namespace executor {
 
-void check_cat_args(
+bool check_cat_args(
     exec_aten::ArrayRef<Tensor> tensors,
     int64_t dim,
     Tensor& out);
@@ -24,15 +24,15 @@ void get_cat_out_target_size(
     Tensor::SizesType* out_sizes,
     size_t* out_ndim);
 
-void check_permute_copy_args(const Tensor& in, IntArrayRef dims, Tensor& out);
+bool check_permute_copy_args(const Tensor& in, IntArrayRef dims, Tensor& out);
 
 void get_permute_copy_out_target_size(
     const Tensor& in,
     IntArrayRef dims,
     Tensor::SizesType* out_sizes,
     size_t* out_ndim);
 
-void check_stack_args(
+bool check_stack_args(
     exec_aten::ArrayRef<Tensor> tensors,
     int64_t dim,
     Tensor& out);

kernels/portable/cpu/util/normalization_ops_util.cpp

@@ -8,17 +8,14 @@
 
 #include <cstring>
 
-#include <executorch/runtime/core/exec_aten/exec_aten.h>
-#include <executorch/runtime/core/exec_aten/util/scalar_type_util.h>
-#include <executorch/runtime/core/exec_aten/util/tensor_util.h>
-#include <executorch/runtime/platform/assert.h>
+#include <executorch/kernels/portable/cpu/util/normalization_ops_util.h>
 
 namespace torch {
 namespace executor {
 
 using Tensor = exec_aten::Tensor;
 
-void check_batch_norm_args(
+bool check_batch_norm_args(
     const Tensor& in,
     const exec_aten::optional<Tensor>& weight,
     const exec_aten::optional<Tensor>& bias,
@@ -28,27 +25,34 @@ void check_batch_norm_args(
     double eps,
     Tensor& out) {
   // All tensors must be the same dtype
-  ET_CHECK_SAME_DTYPE3(in, running_mean, running_var);
-  ET_CHECK_SAME_DTYPE2(in, out);
+  ET_LOG_AND_RETURN_IF_FALSE(
+      tensors_have_same_dtype(in, running_mean, running_var));
+  ET_LOG_AND_RETURN_IF_FALSE(tensors_have_same_dtype(in, out));
   if (weight.has_value()) {
-    ET_CHECK_SAME_DTYPE2(in, weight.value());
+    ET_LOG_AND_RETURN_IF_FALSE(tensors_have_same_dtype(in, weight.value()));
   }
   if (bias.has_value()) {
-    ET_CHECK_SAME_DTYPE2(in, bias.value());
+    ET_LOG_AND_RETURN_IF_FALSE(tensors_have_same_dtype(in, bias.value()));
   }
 
   size_t C_dim = in.dim() >= 1 ? 1 : 0;
   // All parameter tensors must be of dim 1 and have length equal to the
   // channels dim of in
-  ET_CHECK(running_mean.dim() == 1 && running_mean.size(0) == in.size(C_dim));
-  ET_CHECK(running_var.dim() == 1 && running_var.size(0) == in.size(C_dim));
+  ET_LOG_AND_RETURN_IF_FALSE(tensor_is_rank(running_mean, 1));
+  ET_LOG_AND_RETURN_IF_FALSE(
+      tensors_have_same_size_at_dims(running_mean, 0, in, C_dim));
   if (weight.has_value()) {
-    ET_CHECK(
-        weight.value().dim() == 1 && weight.value().size(0) == in.size(C_dim));
+    ET_LOG_AND_RETURN_IF_FALSE(tensor_is_rank(weight.value(), 1));
+    ET_LOG_AND_RETURN_IF_FALSE(
+        tensors_have_same_size_at_dims(weight.value(), 0, in, C_dim));
   }
   if (bias.has_value()) {
-    ET_CHECK(bias.value().dim() == 1 && bias.value().size(0) == in.size(C_dim));
+    ET_LOG_AND_RETURN_IF_FALSE(tensor_is_rank(bias.value(), 1));
+    ET_LOG_AND_RETURN_IF_FALSE(
+        tensors_have_same_size_at_dims(bias.value(), 0, in, C_dim));
   }
+
+  return true;
 }
 
 } // namespace executor

kernels/portable/cpu/util/normalization_ops_util.h

@@ -13,7 +13,7 @@
 namespace torch {
 namespace executor {
 
-void check_batch_norm_args(
+bool check_batch_norm_args(
     const Tensor& in,
     const exec_aten::optional<Tensor>& weight,
     const exec_aten::optional<Tensor>& bias,