[FFI] Add new containers and Implementations

include/mxnet/runtime/ndarray_handle.h

@@ -31,7 +31,7 @@ namespace mxnet {
 class NDArrayHandleObj : public Object {
  public:
   /*! \brief the Internal value. */
-  NDArray* value;
+  NDArray value;
 
   static constexpr const char* _type_key = "MXNet.NDArrayHandle";
   MXNET_DECLARE_FINAL_OBJECT_INFO(NDArrayHandleObj, Object)
@@ -41,12 +41,14 @@ class NDArrayHandle : public ObjectRef {
  public:
   explicit NDArrayHandle(NDArray* value) {
     runtime::ObjectPtr<NDArrayHandleObj> node = make_object<NDArrayHandleObj>();
-    node->value = value;
+    node->value = *value;
     data_ = std::move(node);
   }
   MXNET_DEFINE_OBJECT_REF_METHODS(NDArrayHandle, ObjectRef, NDArrayHandleObj)
 };
-
+  inline NDArray* getArray() const {
+    return static_cast<NDArray*>(&(static_cast<NDArrayHandleObj*>(data_.get())->value));
+  }
 };  // namespace mxnet
 
 #endif  // MXNET_RUNTIME_NDARRAY_HANDLE_H_

include/mxnet/runtime/object.h

@@ -54,11 +54,12 @@ enum TypeIndex  {
   kMXNetTensor = 1,
   kMXNetClosure = 2,
   kMXNetADT = 3,
-  kRuntimeModule = 4,
-  kEllipsis = 5,
-  kSlice = 6,
-  kInteger = 7,
-  kFloat = 8,
+  kMXNetMap = 4,
+  kMXNetString = 5,
+  kEllipsis = 6,
+  kSlice = 7,
+  kInteger = 8,
+  kFloat = 9,
   kStaticIndexEnd,
   /*! \brief Type index is allocated during runtime. */
   kDynamic = kStaticIndexEnd
@@ -567,6 +568,8 @@ class ObjectRef {
 
   /*! \brief type indicate the container type. */
   using ContainerType = Object;
+  // Default type properties for the reference class.
+  static constexpr bool _type_is_nullable = true;
 
  protected:
   /*! \brief Internal pointer that backs the reference. */
@@ -681,6 +684,11 @@ struct ObjectEqual {
   static DMLC_ATTRIBUTE_UNUSED uint32_t __make_Object_tidx ## _ ## TypeName ## __ = \
       TypeName::_GetOrAllocRuntimeTypeIndex()
 
+#define MXNET_DEFINE_DEFAULT_COPY_MOVE_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName& other) = default;                \
+  TypeName(TypeName&& other) = default;                     \
+  TypeName& operator=(const TypeName& other) = default;     \
+  TypeName& operator=(TypeName&& other) = default;
 
 #define MXNET_DEFINE_OBJECT_REF_METHODS(TypeName, ParentType, ObjectName) \
   TypeName() {}                                                           \
@@ -704,6 +712,14 @@ struct ObjectEqual {
   operator bool() const { return data_ != nullptr; }                          \
   using ContainerType = ObjectName;
 
+#define MXNET_DEFINE_NOTNULLABLE_OBJECT_REF_METHODS(TypeName, ParentType, ObjectName)              \
+  explicit TypeName(::mxnet::runtime::ObjectPtr<::mxnet::runtime::Object> n) : ParentType(n) {}    \
+  MXNET_DEFINE_DEFAULT_COPY_MOVE_AND_ASSIGN(TypeName);                                             \
+  const ObjectName* operator->() const { return static_cast<const ObjectName*>(data_.get()); }     \
+  const ObjectName* get() const { return operator->(); }                                           \
+  static constexpr bool _type_is_nullable = false;                                                 \
+  using ContainerType = ObjectName;
+
 // Implementations details below
 // Object reference counting.
 #if MXNET_OBJECT_ATOMIC_REF_COUNTER
@@ -794,6 +810,9 @@ template <typename RefType, typename ObjType>
 inline RefType GetRef(const ObjType* ptr) {
   static_assert(std::is_base_of<typename RefType::ContainerType, ObjType>::value,
                 "Can only cast to the ref of same container type");
+  if (!RefType::_type_is_nullable) {
+    CHECK(ptr != nullptr);
+  }
   return RefType(ObjectPtr<Object>(const_cast<Object*>(static_cast<const Object*>(ptr))));
 }
 
@@ -806,9 +825,14 @@ inline ObjectPtr<BaseType> GetObjectPtr(ObjType* ptr) {
 
 template <typename SubRef, typename BaseRef>
 inline SubRef Downcast(BaseRef ref) {
-  CHECK(ref->template IsInstance<typename SubRef::ContainerType>())
-      << "Downcast from " << ref->GetTypeKey() << " to "
-      << SubRef::ContainerType::_type_key << " failed.";
+  if (ref.defined()) {
+    CHECK(ref->template IsInstance<typename SubRef::ContainerType>())
+        << "Downcast from " << ref->GetTypeKey() << " to "
+        << SubRef::ContainerType::_type_key << " failed.";
+  } else {
+    CHECK(SubRef::_type_is_nullable) << "Downcast from nullptr to not nullable reference of "
+                                     << SubRef::ContainerType::_type_key;
+  }
   return SubRef(std::move(ref.data_));
 }
 

include/mxnet/runtime/packed_func.h

@@ -30,6 +30,7 @@
 #include <mxnet/runtime/object.h>
 #include <mxnet/runtime/ndarray.h>
 #include <mxnet/runtime/container.h>
+#include <mxnet/runtime/container_ext.h>
 #include <mxnet/runtime/ndarray_handle.h>
 #include <mxnet/runtime/ffi_helper.h>
 #include <mxnet/runtime/data_type.h>
@@ -382,6 +383,23 @@ struct extension_type_info {
   static const int code = 0;
 };
 
+/*!
+ * \brief Type traits for runtime type check during FFI conversion.
+ * \tparam T the type to be checked.
+ */
+template <typename T>
+struct ObjectTypeChecker {
+  static bool Check(const Object* ptr) {
+    using ContainerType = typename T::ContainerType;
+    if (ptr == nullptr) return T::_type_is_nullable;
+    return ptr->IsInstance<ContainerType>();
+  }
+  static std::string TypeName() {
+    using ContainerType = typename T::ContainerType;
+    return ContainerType::_type_key;
+  }
+};
+
 /*!
  * \brief Internal base class to
  *  handle conversion to POD values.
@@ -433,6 +451,8 @@ class MXNetPODValue_ {
            typename = typename std::enable_if<
              std::is_class<TObjectRef>::value>::type>
   inline bool IsObjectRef() const;
+  template <typename TObjectRef>
+  inline TObjectRef AsObjectRef() const;
   int type_code() const {
     return type_code_;
   }
@@ -487,6 +507,7 @@ class MXNetArgValue : public MXNetPODValue_ {
   using MXNetPODValue_::operator void*;
   using MXNetPODValue_::operator ObjectRef;
   using MXNetPODValue_::IsObjectRef;
+  using MXNetPODValue_::AsObjectRef;
 
   // conversion operator.
   operator std::string() const {
@@ -497,6 +518,12 @@ class MXNetArgValue : public MXNetPODValue_ {
       MXNET_CHECK_TYPE_CODE(type_code_, kStr);
       return std::string(value_.v_str);
     }
+    // } else if (type_code_ == kStr) {
+    //   return std::string(value_.v_str);
+    // } else {
+    //   CHECK(IsObjectRef<tvm::runtime::String>());
+    //   return AsObjectRef<tvm::runtime::String>().operator std::string();
+    // }
   }
   operator DLDataType() const {
     if (type_code_ == kStr) {
@@ -528,9 +555,6 @@ class MXNetArgValue : public MXNetPODValue_ {
   const MXNetValue& value() const {
     return value_;
   }
-  // Deferred extension handler.
-  template<typename TObjectRef>
-  inline TObjectRef AsObjectRef() const;
   template<typename T,
            typename = typename std::enable_if<
            std::is_class<T>::value>::type>
@@ -571,6 +595,7 @@ class MXNetRetValue : public MXNetPODValue_ {
   using MXNetPODValue_::operator void*;
   using MXNetPODValue_::operator ObjectRef;
   using MXNetPODValue_::IsObjectRef;
+  using MXNetPODValue_::AsObjectRef;
 
   MXNetRetValue(const MXNetRetValue& other) : MXNetPODValue_() {
     this->Assign(other);
@@ -681,7 +706,8 @@ class MXNetRetValue : public MXNetPODValue_ {
   }
   MXNetRetValue& operator=(NDArrayHandle value) {
     this->SwitchToPOD(kNDArrayHandle);
-    value_.v_handle = reinterpret_cast<void*>(value->value);
+    NDArray* arr = new NDArray(value->value);
+    value_.v_handle = reinterpret_cast<void*>(arr);
     return *this;
   }
   MXNetRetValue& operator=(const PythonArg& value) {
@@ -725,8 +751,6 @@ class MXNetRetValue : public MXNetPODValue_ {
            typename = typename std::enable_if<
              std::is_class<T>::value>::type>
   inline operator T() const;
-  template<typename TObjectRef>
-  inline TObjectRef AsObjectRef() const;
 
  private:
   template<typename T>
@@ -1173,13 +1197,88 @@ struct MXNetValueCast {
 
 }  // namespace detail
 
-template<typename T, typename>
-inline MXNetRetValue::operator T() const {
-  return detail::
-      MXNetValueCast<T, MXNetRetValue,
-                   (extension_type_info<T>::code != 0),
-                   (array_type_info<T>::code > 0)>
-      ::Apply(this);
+/*!
+ * \brief Type trait to specify special value conversion rules from
+ *        MXNetArgValue and MXNetRetValue.
+ *
+ *  The trait can be specialized to add type specific conversion logic
+ *  from the TVMArgvalue and TVMRetValue.
+ *
+ * \tparam TObjectRef the specific ObjectRefType.
+ */
+template <typename TObjectRef>
+struct PackedFuncValueConverter {
+  /*!
+   * \brief Convert a TObjectRef from an argument value.
+   * \param val The argument value.
+   * \return the converted result.
+   */
+  static TObjectRef From(const MXNetArgValue& val) { return val.AsObjectRef<TObjectRef>(); }
+  /*!
+   * \brief Convert a TObjectRef from a return value.
+   * \param val The argument value.
+   * \return the converted result.
+   */
+  static TObjectRef From(const MXNetRetValue& val) { return val.AsObjectRef<TObjectRef>(); }
+};
+
+template <>
+struct PackedFuncValueConverter<::mxnet::runtime::String> {
+  static String From(const MXNetArgValue& val) {
+    if (val.IsObjectRef<mxnet::runtime::String>()) {
+      return val.AsObjectRef<mxnet::runtime::String>();
+    } else {
+      return mxnet::runtime::String(val.operator std::string());
+    }
+  }
+
+  static String From(const MXNetRetValue& val) {
+    if (val.IsObjectRef<mxnet::runtime::String>()) {
+      return val.AsObjectRef<mxnet::runtime::String>();
+    } else {
+      return mxnet::runtime::String(val.operator std::string());
+    }
+  }
+};
+
+template <typename TObjectRef>
+inline TObjectRef MXNetPODValue_::AsObjectRef() const {
+  static_assert(std::is_base_of<ObjectRef, TObjectRef>::value,
+                "Conversion only works for ObjectRef");
+  using ContainerType = typename TObjectRef::ContainerType;
+
+  if (type_code_ == kNull) {
+    CHECK(TObjectRef::_type_is_nullable)
+        << "Expect a not null value of " << ContainerType::_type_key;
+    return TObjectRef(ObjectPtr<Object>(nullptr));
+  }
+  if (type_code_ == kObjectHandle) {
+    // normal object type check.
+    Object* ptr = static_cast<Object*>(value_.v_handle);
+    CHECK(ObjectTypeChecker<TObjectRef>::Check(ptr))
+        << "Expect " << ObjectTypeChecker<TObjectRef>::TypeName() << " but get "
+        << ptr->GetTypeKey();
+    return TObjectRef(GetObjectPtr<Object>(ptr));
+  } else {
+    MXNET_CHECK_TYPE_CODE(type_code_, kObjectHandle);
+    return TObjectRef(ObjectPtr<Object>(nullptr));
+  }
+}
+
+template <typename T, typename>
+inline MXNetArgValue::operator T() const {
+  return PackedFuncValueConverter<T>::From(*this);
+}
+
+template <typename TObjectRef, typename>
+inline bool MXNetPODValue_::IsObjectRef() const {
+  using ContainerType = typename TObjectRef::ContainerType;
+  return  type_code_ == kObjectHandle &&
+          ObjectTypeChecker<TObjectRef>::Check(static_cast<Object*>(value_.v_handle));
+}
+
+inline bool String::CanConvertFrom(const MXNetArgValue& val) {
+  return val.type_code() == kStr || val.IsObjectRef<mxnet::runtime::String>();
 }
 
 }  // namespace runtime

python/mxnet/_ctypes/_api_internal.py

@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""CachedOp APIs exposed from C++."""
+
+import mxnet._ffi
+
+mxnet._ffi._init_api("cached_op", __name__)