remove abort

Author: Github Executorch

examples/mediatek/executor_runner/llama_runner/ModelChunk.cpp

@@ -560,8 +560,12 @@ void ModelChunk::SetBackendInputs() {
     std::vector dim_order(dim_order_raw.begin(), dim_order_raw.end());
     auto buffer_data = mInputBufferInfos[i].data;
 
+    ssize_t numel = 1;
+    for (size_t j = 0; j < dim; j++) {
+      numel *= sizes[j];
+    }
     TensorImpl impl = TensorImpl(
-        scalar_type, dim, sizes.data(), buffer_data, dim_order.data());
+        scalar_type, dim, sizes.data(), numel, buffer_data, dim_order.data());
     Tensor tensor(&impl);
     const auto error = method.set_input(tensor, i);
     ET_CHECK_MSG(

examples/mediatek/executor_runner/mtk_oss_executor_runner.cpp

@@ -260,8 +260,12 @@ int main(int argc, char** argv) {
       std::vector sizes(sizes_raw.begin(), sizes_raw.end());
       std::vector dim_order(dim_order_raw.begin(), dim_order_raw.end());
 
+      ssize_t numel = 1;
+      for (size_t i = 0; i < dim; i++) {
+        numel *= sizes[i];
+      }
       TensorImpl impl = TensorImpl(
-          scalar_type, dim, sizes.data(), data_ptr, dim_order.data());
+          scalar_type, dim, sizes.data(), numel, data_ptr, dim_order.data());
 
       Tensor tensor(&impl);
       Error ret = method->set_input(tensor, i);

examples/qualcomm/executor_runner/qnn_executor_runner.cpp

@@ -341,10 +341,15 @@ int main(int argc, char** argv) {
         "Failed to allocate custom memory. tensor index: %d, bytes: %zu",
         input_index,
         tensor_meta->nbytes());
+    ssize_t numel = 1;
+    for (size_t i = 0; i < tensor_meta->sizes().size(); i++) {
+      numel *= tensor_meta->sizes()[i];
+    }
     TensorImpl impl = TensorImpl(
         tensor_meta->scalar_type(),
         /*dim=*/tensor_meta->sizes().size(),
         const_cast<TensorImpl::SizesType*>(tensor_meta->sizes().data()),
+        numel,
         custom_mem_ptr->GetPtr(),
         const_cast<TensorImpl::DimOrderType*>(tensor_meta->dim_order().data()));
     Error ret = method->set_input(Tensor(&impl), input_index);
@@ -475,13 +480,19 @@ int main(int argc, char** argv) {
         // For pre-allocated use case, we need to call set_input
         // to copy data for the input tensors since they doesn't
         // share the data with in_custom_mem.
+        const auto* sizes_ptr = expected_input_shapes.empty()
+            ? tensor_meta->sizes().data()
+            : expected_input_shapes[input_index].data();
+        ssize_t dim = tensor_meta->sizes().size();
+        ssize_t numel = 1;
+        for (ssize_t i = 0; i < dim; i++) {
+          numel *= sizes_ptr[i];
+        }
         TensorImpl impl = TensorImpl(
             tensor_meta->scalar_type(),
-            /*dim=*/tensor_meta->sizes().size(),
-            const_cast<TensorImpl::SizesType*>(
-                expected_input_shapes.empty()
-                    ? tensor_meta->sizes().data()
-                    : expected_input_shapes[input_index].data()),
+            /*dim=*/dim,
+            const_cast<TensorImpl::SizesType*>(sizes_ptr),
+            numel,
             in_custom_mem[input_index]->GetPtr(),
             const_cast<TensorImpl::DimOrderType*>(
                 tensor_meta->dim_order().data()));

examples/samsung/executor_runner/enn_executor_runner.cpp

@@ -302,10 +302,15 @@ int main(int argc, char** argv) {
     ET_CHECK_MSG(
         input_data_reader.nbytes(input_index) == tensor_meta->nbytes(),
         "Given inputs size is invalid");
+    ssize_t numel = 1;
+    for (size_t i = 0; i < tensor_meta->sizes().size(); i++) {
+      numel *= tensor_meta->sizes()[i];
+    }
     TensorImpl impl = TensorImpl(
         tensor_meta->scalar_type(),
         tensor_meta->sizes().size(),
         const_cast<TensorImpl::SizesType*>(tensor_meta->sizes().data()),
+        numel,
         input_data_reader.get(input_index),
         const_cast<TensorImpl::DimOrderType*>(tensor_meta->dim_order().data()));
     Error ret = method->set_input(Tensor(&impl), input_index);

extension/kernel_util/test/make_boxed_from_unboxed_functor_test.cpp

@@ -26,6 +26,7 @@ using executorch::runtime::get_op_function_from_registry;
 using executorch::runtime::KernelRuntimeContext;
 using executorch::runtime::registry_has_op_function;
 using executorch::runtime::Span;
+using executorch::runtime::TensorShapeDynamism;
 using std::optional;
 
 Tensor& my_op_out(KernelRuntimeContext& ctx, const Tensor& a, Tensor& out) {
@@ -104,7 +105,7 @@ TEST_F(MakeBoxedFromUnboxedFunctorTest, UnboxLogicWorks) {
   TensorImpl::SizesType sizes[1] = {5};
   TensorImpl::DimOrderType dim_order[1] = {0};
   int32_t data[5] = {0, 0, 0, 0, 0};
-  auto a_impl = TensorImpl(ScalarType::Int, 1, sizes, data, dim_order, nullptr);
+  auto a_impl = TensorImpl(ScalarType::Int, 1, sizes, 5, data, dim_order);
   auto a = Tensor(&a_impl);
 
   // get boxed callable

extension/runner_util/inputs_portable.cpp

@@ -59,6 +59,10 @@ Error fill_and_set_input(
     size_t input_index,
     void* data_ptr,
     bool fill_tensor) {
+  ssize_t numel = 1;
+  for (size_t i = 0; i < tensor_meta.sizes().size(); i++) {
+    numel *= tensor_meta.sizes()[i];
+  }
   TensorImpl impl = TensorImpl(
       tensor_meta.scalar_type(),
       /*dim=*/tensor_meta.sizes().size(),
@@ -67,6 +71,7 @@ Error fill_and_set_input(
       // that the shape is correct; the Method manages its own sizes and
       // dim_order arrays for the input.
       const_cast<TensorImpl::SizesType*>(tensor_meta.sizes().data()),
+      numel,
       data_ptr,
       const_cast<TensorImpl::DimOrderType*>(tensor_meta.dim_order().data()));
   Tensor t(&impl);

kernels/portable/cpu/util/broadcast_util.cpp

@@ -59,10 +59,15 @@ Tensor make_tensor(
   auto tensor_impl = static_cast<TensorImpl*>(malloc(sizeof(TensorImpl)));
   ET_CHECK_MSG(tensor_impl != nullptr, "Failed to malloc for data TensorImpl");
 
+  ssize_t numel = 1;
+  for (int i = 0; i < dim; i++) {
+    numel *= sizes[i];
+  }
   new (tensor_impl) TensorImpl(
       dtype,
       dim,
       reinterpret_cast<Tensor::SizesType*>(size_data_ptr),
+      numel,
       nullptr,
       reinterpret_cast<Tensor::DimOrderType*>(dim_order_data_ptr),
       reinterpret_cast<Tensor::StridesType*>(strides_data_ptr));

kernels/quantized/cpu/op_dequantize.cpp

@@ -610,14 +610,16 @@ Tensor& dequantize_per_token_out(
   dim_order_to_stride_nocheck(
       input_sizes.data(), input_dim_order.data(), 2, input_strides.data());
   void* input_data = input.mutable_data_ptr();
+  ssize_t reshaped_numel =
+      static_cast<ssize_t>(num_channels) * input.size(input.dim() - 1);
   TensorImpl reshaped_input_impl = TensorImpl(
       input.scalar_type(),
       2,
       input_sizes.data(),
+      reshaped_numel,
       input_data,
       input_dim_order.data(),
-      input_strides.data(),
-      TensorShapeDynamism::STATIC);
+      input_strides.data());
   Tensor reshaped_input(&reshaped_input_impl);
   torch::executor::Error err = resize_tensor(out, input.sizes());
   ET_CHECK_MSG(

kernels/quantized/cpu/op_quantize.cpp

@@ -662,14 +662,16 @@ Tensor& quantize_per_token_out(
   dim_order_to_stride_nocheck(
       input_sizes.data(), input_dim_order.data(), 2, input_strides.data());
   void* input_data = input.mutable_data_ptr();
+  ssize_t reshaped_numel =
+      static_cast<ssize_t>(num_tokens) * input.size(input.dim() - 1);
   TensorImpl reshaped_input_impl = TensorImpl(
       input.scalar_type(),
       2,
       input_sizes.data(),
+      reshaped_numel,
       input_data,
       input_dim_order.data(),
-      input_strides.data(),
-      TensorShapeDynamism::STATIC);
+      input_strides.data());
   Tensor reshaped_input(&reshaped_input_impl);
   torch::executor::Error err = resize_tensor(out, input.sizes());
   ET_CHECK_MSG(

runtime/core/exec_aten/exec_aten.h

@@ -66,6 +66,8 @@ namespace executorch {
 namespace aten {
 
 using TensorShapeDynamism = executorch::runtime::TensorShapeDynamism;
+template <typename T>
+using Result = executorch::runtime::Result<T>;
 
 using std::nullopt;
 using std::nullopt_t;
@@ -105,7 +107,7 @@ template <typename T>
 using OptionalArrayRef = c10::OptionalArrayRef<T>;
 using OptionalIntArrayRef = OptionalArrayRef<int64_t>;
 
-inline ssize_t compute_numel(const SizesType* sizes, ssize_t dim) {
+inline Result<ssize_t> compute_numel(const SizesType* sizes, ssize_t dim) {
   return static_cast<ssize_t>(
       c10::multiply_integers(c10::ArrayRef<SizesType>(sizes, dim)));
 }