TVM：Object家族
Object.h概述
命名空间：
TVM::runtime
文件中包含的结构：
- 1.结构体TypeIndex
- 2.类Object
- 3.类ObjectPtr
- 4.类ObjectRef
- 5.结构体ObjectPtrHash
- 6.结构体ObjectPtrEqual
- 7.宏
结构体TypeIndex
该结构体内部仅包含一个枚举类型，通过下面的代码可以看到，Object类存在一个TypeIndex类型的成员变量。
/*!
* \brief Namespace for the list of type index.
* \note Use struct so that we have to use TypeIndex::ENumName to refer to
* the constant, but still able to use enum.
*/
struct TypeIndex {
enum {
/*! \brief Root object type. */
kRoot = 0,
// Standard static index assignments,
// Frontends can take benefit of these constants.
/*! \brief runtime::Module. */
kRuntimeModule = 1,
/*! \brief runtime::NDArray. */
kRuntimeNDArray = 2,
/*! \brief runtime::String. */
kRuntimeString = 3,
/*! \brief runtime::Array. */
kRuntimeArray = 4,
/*! \brief runtime::Map. */
kRuntimeMap = 5,
/*! \brief runtime::ShapeTuple. */
kRuntimeShapeTuple = 6,
/*! \brief runtime::PackedFunc. */
kRuntimePackedFunc = 7,
// static assignments that may subject to change.
kRuntimeClosure,
kRuntimeADT,
kStaticIndexEnd,
/*! \brief Type index is allocated during runtime. */
kDynamic = kStaticIndexEnd
};
}; // namespace TypeIndex
为什么要将enum类型放在一个struct结构体中呢？
避免命名冲突
包含在struct的{}中，相当于在一个命名空间下，这样已经能够避免命名冲突的问题，而且使用起来比较方便TypeIndex::ENumName。同样也可以将其放在类中，但由于enum中的类型信息本就是对外部开放的，因此struct相较于class更为简洁方便。
参考：C++ enum枚举型
在TypeIndex中可以看到，共有四种object type:
- 1.kRoot:root object type
- 2.前端可以获取的常量：
1.runtime::Module
2.runtime::NDArray
3.runtime::String
4.runtime::Array
5.runtime::Map
6.runtime::ShapeTuple
7.runtime::PackedFunc
- 3.static assignments that may subject to change 可能发生变化的静态分配
- 4.Type index is allocated during runtime.运行时分配的Type Index
kDynamic
Class Object
成员变量：
tvm::runtime::Object
+ _type_key
+ _type_final
+ _type_child_slots
+ _type_child_slots_can_overflow
+ _type_has_method_visit_attrs
+ _type_has_method_sequal_reduce
+ _type_has_method_shash_reduce
+ _type_index
# type_index_
# ref_counter_
# deleter_
可以看到，除了类的回收器deleter_和引用计数ref_counter外，其余成员变量都是关于type_index的标志位或子类插槽（slots）等信息。由于作为多有容器对象的基类（base class of all object containers.）所以主要提供了一系列的操作接口。但最重要的成员变量是type_index_。
成员函数：
成员函数主要是类相关的构造函数，拷贝构造、拷贝复制、move构造、move赋值函数
其次是type_index_相关的函数
剩下的为引用计数相关函数。
类相关
// 构造函数
// Default constructor and copy constructor
Object() {}
// 拷贝构造
// Override the copy and assign constructors to do nothing.
// This is to make sure only contents, but not deleter and ref_counter
// are copied when a child class copies itself.
// This will enable us to use make_object<ObjectClass>(*obj_ptr)
// to copy an existing object.
Object(const Object& other) { // NOLINT(*)
}
// 移动构造（move）
Object(Object&& other) { // NOLINT(*)
}
// 拷贝赋值
Object& operator=(const Object& other) { // NOLINT(*)
return *this;
}
// 移动构造（move）
Object& operator=(Object&& other) { // NOLINT(*)
return *this;
}
// 析构器（FDeleter函数指针）
typedef void (*FDeleter)(Object* self);
type_index_相关
uint32_t type_index() const { return type_index_; }
std::string GetTypeKey() const { return TypeIndex2Key(type_index_); }
std::string GetTypeKey() const { return TypeIndex2Key(type_index_); }
static std::string TypeIndex2Key(uint32_t tindex);
static size_t TypeIndex2KeyHash(uint32_t tindex);
static uint32_t TypeKey2Index(const std::string& key);
template <typename TargetType>
inline bool IsInstance() const;
static uint32_t _GetOrAllocRuntimeTypeIndex() { return TypeIndex::kRoot; }
static uint32_t RuntimeTypeIndex() { return TypeIndex::kRoot; }
static uint32_t GetOrAllocRuntimeTypeIndex(const std::string& key, uint32_t static_tindex,
uint32_t parent_tindex, uint32_t type_child_slots,
bool type_child_slots_can_overflow);
继承、引用计数相关
void IncRef();
void DecRef();
int use_count() const;
DerivedFrom(uint32_t parent_tindex) const;
友元类
template <typename>
friend class ObjAllocatorBase;
template <typename>
friend class ObjectPtr;
friend class TVMRetValue;
friend class ObjectInternal;
class ObjectPtr
注释中将这个类描述为 A custom smart pointer for Object.一个用户自定义的指向Object类的智能指针。
其中最重要的成员变量和成员函数为:
private:
/*! \brief internal pointer field */
Object* data_{nullptr};
/*!
* \brief constructor from Object
* \param data The data pointer
*/
explicit ObjectPtr(Object* data) : data_(data) {
if (data != nullptr) {
data_->IncRef();
}
}
可以看到，该类的成员变量中包含一个指向Object对象的指针 data_，以及一个私有的构造函数，接收一个指向Object对象的指针，初始化data_并增加 data_的引用计数。
该类中的其余函数主要是类的多种构造函数，以及重载了多个运算符，供用户将该类的对象作为指针使用。
总结：因此可以将ObjectPtr看作是一个指向Object对象的指针的包装器，其本质依旧是Object类型的指针。经过包装后我们可以根据其提供的各种接口，更加方便地对指针进行操作。值得注意的是，该类是一个模板类，因此该类的对象包含一个描述Object对象的类型。
class ObjectRef
注释中将该类描述为 Base class of all object reference所有对象引用的基类。
其中最重要的成员变量和成员函数为：
protected:
/*! \brief Internal pointer that backs the reference. */
ObjectPtr<Object> data_;
该类中包含了一个ObjectPtr的对象。因此可以看做是ObjectPtr的包装器。除该对象外，ObjectRef类也提供了多种函数接口，方便用户操作。
Object、ObjectPtr、ObjectRef关系
ObjectPtr类是封装的、指向Object类的一个智能指针类
/*!
* \brief A custom smart pointer for Object.
* \tparam T the content data type.
* \sa make_object
*/
template <typename T>
class ObjectPtr {
public:
ObjectPtr() {}
ObjectPtr(std::nullptr_t) {} // NOLINT(*)
ObjectPtr(const ObjectPtr<T>& other) // NOLINT(*)
: ObjectPtr(other.data_) {}
template <typename U>
ObjectPtr(const ObjectPtr<U>& other) // NOLINT(*)
: ObjectPtr(other.data_) {
static_assert(std::is_base_of<T, U>::value,
"can only assign of child class ObjectPtr to parent");
}
......
// 关键数据成员，一个指向Object对象的指针
Object *data_{nullptr};
// 几个关键的运算符重载接口，用于获取指向Object的指针或者引用
T* get() const { return static_cast<T*>(data_); }
T* operator->() const { return get(); }
T& operator*() const { return *get(); }
包含了智能指针应该有的：拷贝构造、移动构造、swap函数、运算符重载等的实现，可参考C++智能指针
使用自定义的智能指针管理Object对象生命周期，便于管理，防止内存泄漏
ObjectRef类为所有对象引用的基类( Base class of all object reference)
它的关键数据成员和几个运算符重载接口如下：
// 关键数据成员
ObjectPtr<Object> data_;
// 关键运算符重载接口
const Object* get() const { return data_.get(); }
const Object* operator->() const { return get(); }
在具体的使用中，Object机制有两套继承体系，一套继承自Object，用于表示实际的类， 一套继承自ObjectRef，它就像是指向实际类对象的智能指针，用于操作实际的类对象，虽然实际上没有shared_ptr，但我们可以用下图来帮助理解这两套继承体系：
Object的所有子类基本上都遵循了 NameNode 继承 Object，Name继承 ObjectRef；，例如：
/*! \brief Base node of all statements. */
class StmtNode : public Object
/*! \brief Container of all statements */
class Stmt : public ObjectRef
而 ObjectPtr作为模板类，记录有指向Object类对象的类型，在使用过程中，会出现指针的向下转型（downcast）以及类型转换等操作，因此其作用主要做转型和检查。
使用场景：对Object的子类做修改
SumExpr ToSumExpr(PrimExpr expr) {
// Ref对象调用.as<>()函数返回一个类型为<SumExprNode>的Ptr
if (const auto* op = expr.as<SumExprNode>()) {
// 通过Ptr构造Ref
return GetRef<SumExpr>(op);
}
// 通过make_object创建<>类型对象，并返回指向该对象的指针。
ObjectPtr<SumExprNode> n = make_object<SumExprNode>();
n->dtype = expr.dtype();
// Ref对象调用.as<>()函数返回一个类型为<>的Ptr
if (const auto* op = expr.as<IntImmNode>()) {
// 通过Ref对内容进行操作
n->base = op->value;
// 通过Ptr构造Ref对象
return SumExpr(n);
} else {
n->args.emplace_back(ToSplitExpr(expr));
return SumExpr(n);
}
}
ObjectPtr：用于记录类型，类型检查（.as()），对Object实体内容进行操作，还可以作为构造引用的参数。
Object：为对象实体。
ObjectRef：作为函数间传递和处理的形式。
如果拿Object、ObjectPtr、ObjectRef这三个类和shared_ptr类比的话：
-
Object相当于控制块，可以通过引用计数ref_counter_来控制对象的生命周期，对象的析构函数也可以通过delete_这个函数指针指定 -
Object的子类的除去Object基类的部分相当于数据块，里面保存有类的真实数据 -
ObjectRef就像是shared_ptr这个wrapper，自身不包含实际数据，但是可以操作实际的数据 -
ObjectPtr的作用在使用的角度有点类似ObjectRef，不同的是数据类型，ObjectPtr<T>是一个模板
