object.h

Go to the documentation of this file.

/*
 * 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.
 */
#ifndef TVM_RUNTIME_OBJECT_H_
#define TVM_RUNTIME_OBJECT_H_
 
#include <tvm/ffi/cast.h>
#include <tvm/ffi/object.h>
#include <tvm/ffi/optional.h>
#include <tvm/runtime/base.h>
 
#include <utility>
 
namespace tvm {
namespace runtime {
 
using tvm::ffi::Object;
using tvm::ffi::ObjectPtr;
using tvm::ffi::ObjectPtrEqual;
using tvm::ffi::ObjectPtrHash;
using tvm::ffi::ObjectRef;
 
using tvm::ffi::GetObjectPtr;
using tvm::ffi::GetRef;
 
enum TypeIndex : int32_t {
  // Standard static index assignments,
  // Frontends can take benefit of these constants.
  kRuntimeModule = TVMFFITypeIndex::kTVMFFIModule,
  kRuntimeTensor = TVMFFITypeIndex::kTVMFFITensor,
  kRuntimeShape = TVMFFITypeIndex::kTVMFFIShape,
  // Extra builtin static index here
  // We reserve 16 extra static indices for custom types
  kCustomStaticIndex = TVMFFITypeIndex::kTVMFFIDynObjectBegin - 16,
  kRuntimePackedFunc = kCustomStaticIndex + 1,
  kRuntimeDiscoDRef = kCustomStaticIndex + 2,
  kRuntimeRPCObjectRef = kCustomStaticIndex + 3,
  // custom builtin
  kRuntimeString,
  kRuntimeMap,
  kRuntimeArray,
  // static assignments that may subject to change.
  kStaticIndexEnd,
};
 
static_assert(static_cast<int>(TypeIndex::kCustomStaticIndex) >=
                  static_cast<int>(TVMFFITypeIndex::kTVMFFIStaticObjectEnd),
              "Static slot overflows to custom indices");
 
/*
 * \brief Define the default copy/move constructor and assign operator
 * \param TypeName The class typename.
 */
#define TVM_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 TVM_DEFINE_OBJECT_REF_COW_METHOD(ObjectName)                   \
  static_assert(ObjectName::_type_final,                               \
                "TVM's CopyOnWrite may only be used for "              \
                "Object types that are declared as final, "            \
                "using the TVM_FFI_DECLARE_OBJECT_INFO_FINAL macro."); \
  ObjectName* CopyOnWrite() {                                          \
    ICHECK(data_ != nullptr);                                          \
    if (!data_.unique()) {                                             \
      auto n = ::tvm::ffi::make_object<ObjectName>(*(operator->()));   \
      ObjectPtr<Object>(std::move(n)).swap(data_);                     \
    }                                                                  \
    return static_cast<ObjectName*>(data_.get());                      \
  }
 
/*
 * \brief Define object reference methods.
 * \param TypeName The object type name
 * \param ParentType The parent type of the objectref
 * \param ObjectName The type name of the object.
 */
#define TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE_WITHOUT_DEFAULT_CONSTRUCTOR(                \
    TypeName, ParentType, ObjectName)                                                          \
  explicit TypeName(::tvm::ffi::ObjectPtr<ObjectName> n) : ParentType(n) {}                    \
  TVM_DEFINE_DEFAULT_COPY_MOVE_AND_ASSIGN(TypeName);                                           \
  const ObjectName* operator->() const { return static_cast<const ObjectName*>(data_.get()); } \
  const ObjectName* get() const { return operator->(); }                                       \
  using ContainerType = ObjectName;
 
#define TVM_STR_CONCAT_(__x, __y) __x##__y
#define TVM_STR_CONCAT(__x, __y) TVM_STR_CONCAT_(__x, __y)
 
}  // namespace runtime
 
using tvm::ffi::ObjectPtr;
using tvm::ffi::ObjectRef;
}  // namespace tvm
#endif  // TVM_RUNTIME_OBJECT_H_