Protect internal fields to make dtype immutable

Author: arkq

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

@@ -40,17 +40,24 @@ namespace py = pybind11;
  */
 struct datatype
 {
-  NNFW_TYPE nnfw_type;
-  py::dtype py_dtype;
+private:
+  NNFW_TYPE _nnfw_type;
+  py::dtype _py_dtype;
   // The name of the dtype, e.g., "float32", "int32", etc.
   // This is mainly for the __repr__ implementation.
-  const char *name;
+  const char *_name;
 
-  datatype() = default;
+public:
+  datatype() : datatype(NNFW_TYPE::NNFW_TYPE_TENSOR_FLOAT32) {}
   explicit datatype(NNFW_TYPE type);
 
-  bool operator==(const datatype &other) const { return nnfw_type == other.nnfw_type; }
-  bool operator!=(const datatype &other) const { return nnfw_type != other.nnfw_type; }
+  const char *name() const { return _name; }
+  ssize_t itemsize() const { return _py_dtype.itemsize(); }
+  NNFW_TYPE nnfw_type() const { return _nnfw_type; }
+  py::dtype py_dtype() const { return _py_dtype; }
+
+  bool operator==(const datatype &other) const { return _nnfw_type == other._nnfw_type; }
+  bool operator!=(const datatype &other) const { return _nnfw_type != other._nnfw_type; }
 };
 
 /**

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

@@ -46,17 +46,19 @@ void bind_tensorinfo(py::module_ &m)
   py::class_<datatype>(m, "dtype", "Defines the type of the OneRT tensor.", py::module_local())
     .def(py::self == py::self)
     .def(py::self != py::self)
-    .def("__repr__", [](const datatype &dt) { return std::string("onert.") + dt.name; })
-    .def_readonly("name", &datatype::name, "The name of the data type.")
-    .def_readonly("dtype", &datatype::py_dtype, "A corresponding numpy data type.")
+    .def("__repr__", [](const datatype &dt) { return std::string("onert.") + dt.name(); })
     .def_property_readonly(
-      "itemsize", [](const datatype &dt) { return dt.py_dtype.itemsize(); },
+      "name", [](const datatype &dt) { return dt.name(); }, "The name of the data type.")
+    .def_property_readonly(
+      "dtype", [](const datatype &dt) { return dt.py_dtype(); }, "A corresponding numpy data type.")
+    .def_property_readonly(
+      "itemsize", [](const datatype &dt) { return dt.itemsize(); },
       "The element size of this data-type object.");
 
   // Export OneRT dtypes in a submodule, so we can batch import them
   auto m_dtypes = m.def_submodule("dtypes", "OneRT tensor data types");
   for (const auto &dt : dtypes)
-    m_dtypes.attr(dt.name) = dt;
+    m_dtypes.attr(dt.name()) = dt;
 
   py::class_<tensorinfo>(m, "tensorinfo", "tensorinfo describes the type and shape of tensors",
                          py::module_local())

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

@@ -58,41 +58,41 @@ NNFW_LAYOUT getLayout(const char *layout)
   throw NnfwError(std::string("Unknown layout type: '") + layout + "'");
 }
 
-datatype::datatype(NNFW_TYPE type) : nnfw_type(type)
+datatype::datatype(NNFW_TYPE type) : _nnfw_type(type)
 {
   switch (type)
   {
     case NNFW_TYPE::NNFW_TYPE_TENSOR_FLOAT32:
-      py_dtype = py::dtype("float32");
-      name = "float32";
+      _py_dtype = py::dtype("float32");
+      _name = "float32";
       return;
     case NNFW_TYPE::NNFW_TYPE_TENSOR_INT32:
-      py_dtype = py::dtype("int32");
-      name = "int32";
+      _py_dtype = py::dtype("int32");
+      _name = "int32";
       return;
     case NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT8_ASYMM:
-      py_dtype = py::dtype("uint8");
-      name = "quint8";
+      _py_dtype = py::dtype("uint8");
+      _name = "quint8";
       return;
     case NNFW_TYPE::NNFW_TYPE_TENSOR_UINT8:
-      py_dtype = py::dtype("uint8");
-      name = "uint8";
+      _py_dtype = py::dtype("uint8");
+      _name = "uint8";
       return;
     case NNFW_TYPE::NNFW_TYPE_TENSOR_BOOL:
-      py_dtype = py::dtype("bool");
-      name = "bool";
+      _py_dtype = py::dtype("bool");
+      _name = "bool";
       return;
     case NNFW_TYPE::NNFW_TYPE_TENSOR_INT64:
-      py_dtype = py::dtype("int64");
-      name = "int64";
+      _py_dtype = py::dtype("int64");
+      _name = "int64";
       return;
     case NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT8_ASYMM_SIGNED:
-      py_dtype = py::dtype("int8");
-      name = "qint8";
+      _py_dtype = py::dtype("int8");
+      _name = "qint8";
       return;
     case NNFW_TYPE::NNFW_TYPE_TENSOR_QUANT16_SYMM_SIGNED:
-      py_dtype = py::dtype("int16");
-      name = "qint16sym";
+      _py_dtype = py::dtype("int16");
+      _name = "qint16sym";
       return;
   }
   // This code should not be reached because compiler will generate a warning
@@ -154,7 +154,7 @@ void NNFW_SESSION::close_session()
 void NNFW_SESSION::set_input_tensorinfo(uint32_t index, const tensorinfo *tensor_info)
 {
   nnfw_tensorinfo ti;
-  ti.dtype = tensor_info->dtype.nnfw_type;
+  ti.dtype = tensor_info->dtype.nnfw_type();
   ti.rank = tensor_info->rank;
   for (int i = 0; i < NNFW_MAX_RANK; i++)
   {
@@ -236,8 +236,8 @@ py::array NNFW_SESSION::get_output(uint32_t index)
 
   const auto dtype = datatype(out_info.dtype);
   // Wrap the raw buffer in a numpy array;
-  py::array arr(dtype.py_dtype, shape);
-  std::memcpy(arr.mutable_data(), out_buffer, num_elements * dtype.py_dtype.itemsize());
+  py::array arr(dtype.py_dtype(), shape);
+  std::memcpy(arr.mutable_data(), out_buffer, num_elements * dtype.itemsize());
   arr.attr("flags").attr("writeable") = false;
 
   return arr;