[onert] Dedicated exception for invalid data type

This commit introduces dedicated exception for reporting unsupported or
invalid data type.

ONE-DCO-1.0-Signed-off-by: Arkadiusz Bokowy <[email protected]>

Author: arkq

runtime/onert/api/nnfw/include/nnfw.h

@@ -125,6 +125,8 @@ typedef enum
   NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE = 5,
   /** When API is deprecated */
   NNFW_STATUS_DEPRECATED_API = 6,
+  /** When given input or ouput data type is not supported. */
+  NNFW_STATUS_UNSUPPORTED_DATA_TYPE = 7,
 } NNFW_STATUS;
 
 /**

runtime/onert/api/nnfw/src/CustomKernel.cc

@@ -16,6 +16,8 @@
 
 #include "CustomKernel.h"
 
+#include <util/Exceptions.h>
+
 namespace onert::api
 {
 
@@ -54,7 +56,7 @@ class APIConverter
         api_type.dtype = NNFW_TYPE_TENSOR_BOOL;
         break;
       default:
-        throw std::runtime_error("Unsupported tensor datatype");
+        throw UnsupportedDataTypeException("Converter", type.dtype);
     }
     return api_type;
   }

runtime/onert/api/nnfw/src/nnfw_session.cc

@@ -481,6 +481,11 @@ NNFW_STATUS nnfw_session::run()
     std::cerr << "Error during nnfw_session::run : " << e.what() << std::endl;
     return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
   }
+  catch (const onert::UnsupportedDataTypeException &e)
+  {
+    std::cerr << "Error during nnfw_session::run : " << e.what() << std::endl;
+    return NNFW_STATUS_UNSUPPORTED_DATA_TYPE;
+  }
   catch (const std::exception &e)
   {
     std::cerr << "Error during nnfw_session::run : " << e.what() << std::endl;

runtime/onert/api/python/include/nnfw_exceptions.h

@@ -49,6 +49,10 @@ struct NnfwDeprecatedApiError : public NnfwError
 {
   using NnfwError::NnfwError;
 };
+struct NnfwUnsupportedDataTypeError : public NnfwError
+{
+  using NnfwError::NnfwError;
+};
 
 } // namespace onert::api::python
 

runtime/onert/api/python/src/bindings/nnfw_exception_bindings.cc

@@ -41,6 +41,8 @@ void bind_nnfw_exceptions(py::module_ &m)
                                                       m.attr("OnertError").cast<py::object>());
   py::register_exception<NnfwDeprecatedApiError>(m, "OnertDeprecatedApiError",
                                                  m.attr("OnertError").cast<py::object>());
+  py::register_exception<NnfwUnsupportedDataTypeError>(m, "OnertUnsupportedDataTypeError",
+                                                       m.attr("OnertError").cast<py::object>());
 }
 
 } // namespace onert::api::python

runtime/onert/api/python/src/wrapper/nnfw_api_wrapper.cc

@@ -42,9 +42,10 @@ void ensure_status(NNFW_STATUS status)
       throw NnfwInsufficientOutputError("NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE");
     case NNFW_STATUS::NNFW_STATUS_DEPRECATED_API:
       throw NnfwDeprecatedApiError("NNFW_STATUS_DEPRECATED_API");
-    default:
-      throw NnfwError("NNFW_UNKNOWN_ERROR");
+    case NNFW_STATUS::NNFW_STATUS_UNSUPPORTED_DATA_TYPE:
+      throw NnfwUnsupportedDataTypeError("NNFW_STATUS_UNSUPPORTED_DATA_TYPE");
   }
+  throw NnfwError("NNFW_UNKNOWN_ERROR");
 }
 
 NNFW_LAYOUT getLayout(const char *layout)

runtime/onert/backend/acl_common/Convert.cc

@@ -19,6 +19,7 @@
 #include "Swizzle.h"
 #include "ir/DataType.h"
 #include "ir/operation/ElementwiseActivation.h"
+#include <util/Exceptions.h>
 #include <memory>
 
 namespace onert::backend::acl_common
@@ -96,8 +97,7 @@ ::arm_compute::DataType asDataType(const ir::DataType type)
     case ir::DataType::QUANT_INT8_SYMM_PER_CHANNEL:
       return ::arm_compute::DataType::QSYMM8_PER_CHANNEL;
     default:
-      throw std::runtime_error("Not supported internal data type, yet");
-      break;
+      throw UnsupportedDataTypeException(type);
   }
 }
 
@@ -224,7 +224,8 @@ std::set<uint32_t> asSet(const ir::Operand &operand, int32_t rank)
   for (size_t i = 0; i < operand.shape().num_elements(); ++i)
   {
     int32_t axis = 0;
-    switch (operand.typeInfo().type())
+    const auto data_type = operand.typeInfo().type();
+    switch (data_type)
     {
       case ir::DataType::INT32:
         axis = reinterpret_cast<const int32_t *>(operand.data()->base())[i];
@@ -233,7 +234,7 @@ std::set<uint32_t> asSet(const ir::Operand &operand, int32_t rank)
         axis = reinterpret_cast<const int64_t *>(operand.data()->base())[i];
         break;
       default:
-        throw std::runtime_error("acl_common::asSet: Not supported data type");
+        throw UnsupportedDataTypeException("asSet", data_type);
     }
     if (axis < 0)
       axis += rank;
@@ -273,8 +274,7 @@ ir::DataType asRuntimeDataType(::arm_compute::DataType data_type)
     case ::arm_compute::DataType::QSYMM16:
       return ir::DataType::QUANT_INT16_SYMM;
     default:
-      throw std::runtime_error{"Not supported acl data type, yet"};
-      break;
+      throw UnsupportedDataTypeException("asRuntimeDataType", data_type);
   }
 }
 
@@ -312,7 +312,8 @@ arm_compute::PixelValue asPixelValue(const ir::Operand &operand)
 {
   assert(operand.isConstant());
   assert(operand.shape().num_elements() == 1);
-  switch (operand.typeInfo().type())
+  const auto data_type = operand.typeInfo().type();
+  switch (data_type)
   {
     case ir::DataType::INT32:
       return arm_compute::PixelValue(operand.asScalar<int32_t>());
@@ -325,7 +326,7 @@ arm_compute::PixelValue asPixelValue(const ir::Operand &operand)
     case ir::DataType::FLOAT32:
       return arm_compute::PixelValue(operand.asScalar<float>());
     default:
-      throw std::runtime_error("asPixelValue : Not supported datatype yet");
+      throw UnsupportedDataTypeException("asPixelValue", data_type);
   }
 }
 

runtime/onert/backend/cpu/ops/AddNLayer.cc

@@ -19,6 +19,7 @@
 #include "OperationUtils.h"
 
 #include <cker/operation/AddN.h>
+#include <util/Exceptions.h>
 #include <assert.h>
 
 namespace onert::backend::cpu::ops
@@ -53,7 +54,7 @@ void AddNLayer::run()
   }
   else
   {
-    throw std::runtime_error("AddN: unsupported data type");
+    throw UnsupportedDataTypeException{"AddN", _output->data_type()};
   }
 }
 

runtime/onert/backend/cpu/ops/ArgMinMaxLayer.cc

@@ -19,6 +19,7 @@
 #include "OperationUtils.h"
 
 #include <cker/operation/ArgMinMax.h>
+#include <util/Exceptions.h>
 #include <assert.h>
 
 namespace onert::backend::cpu::ops
@@ -79,7 +80,7 @@ void ArgMinMaxLayer::run()
         TF_LITE_ARG_MIN_MAX(int32_t, int32_t, int32_t);
         break;
       default:
-        throw std::runtime_error("ArgMinMax: unsupported data type");
+        throw UnsupportedDataTypeException{"ArgMinMax", _input->data_type()};
     }
   }
   else if (_output->data_type() == ir::DataType::INT64)
@@ -100,12 +101,12 @@ void ArgMinMaxLayer::run()
         TF_LITE_ARG_MIN_MAX(int32_t, int32_t, int64_t);
         break;
       default:
-        throw std::runtime_error("ArgMinMax: unsupported data type");
+        throw UnsupportedDataTypeException{"ArgMinMax", _input->data_type()};
     }
   }
   else
   {
-    throw std::runtime_error("ArgMinMax: unsupported data type");
+    throw UnsupportedDataTypeException{"ArgMinMax", _output->data_type()};
   }
 
 #undef TF_LITE_ARG_MIN_MAX

runtime/onert/backend/cpu/ops/BatchMatMulLayer.cc

@@ -17,6 +17,7 @@
 #include "BatchMatMulLayer.h"
 
 #include <cker/operation/BatchMatMul.h>
+#include <util/Exceptions.h>
 
 namespace onert::backend::cpu::ops
 {
@@ -60,14 +61,11 @@ void BatchMatMulLayer::configure(const IPortableTensor *lhs, const IPortableTens
 
 void BatchMatMulLayer::run()
 {
-  if ((_lhs->data_type() == OperandType::FLOAT32) && (_rhs->data_type() == OperandType::FLOAT32))
-  {
-    batchMatMulFloat32();
-  }
-  else
-  {
-    throw std::runtime_error{"BatchMatMul: unsupported data type"};
-  }
+  if (_lhs->data_type() != OperandType::FLOAT32)
+    throw UnsupportedDataTypeException{"BatchMatMul", _lhs->data_type()};
+  if (_rhs->data_type() != OperandType::FLOAT32)
+    throw UnsupportedDataTypeException{"BatchMatMul", _rhs->data_type()};
+  batchMatMulFloat32();
 }
 
 #undef AVGPOOLING_PARAMETERS