TVM 运行时系统

TVM 支持多种编程语言用于编译器堆栈的开发和部署。在本笔记中，我们将解释 TVM 运行时的关键要素。

我们需要满足一些非常有趣的需求

• 部署：从 python/javascript/c++ 语言调用编译后的函数。

• 调试：在 python 中定义一个函数，并从编译后的函数中调用它。

• 链接：编写驱动程序代码以调用设备特定代码 (CUDA)，并从编译后的主机函数中调用它。

• 原型：从 python 定义一个 IR pass，并从 C++ 后端调用它。

• 暴露：在 c++ 中开发的编译器堆栈到前端（即 python）

• 实验：将编译后的函数交付到嵌入式设备以直接在那里运行。

我们希望能够从任何语言定义函数，并从另一种语言调用。我们还希望运行时核心尽可能小，以便部署到嵌入式设备。

PackedFunc

PackedFunc 是我们找到的简单而优雅的解决方案，用于解决列出的挑战。单个 PackedFunc 对象表示一个函数调用，其调用者和被调用者可能使用不同的语言。

以下代码块提供了 C++ 中的示例

#include <tvm/runtime/packed_func.h>

void MyAdd(TVMArgs args, TVMRetValue* rv) {
  // automatically convert arguments to desired type.
  int a = args[0];
  int b = args[1];
  // automatically assign value return to rv
  *rv = a + b;
}

void CallPacked() {
  PackedFunc myadd = PackedFunc(MyAdd);
  // get back 3
  int c = myadd(1, 2);
}

在上面的代码块中，我们定义了一个 PackedFunc MyAdd。它接受两个参数：args 表示输入参数，而 rv 表示返回值。该函数是类型擦除的，这意味着函数签名不限制要传入的输入类型或要返回的类型。在底层，当我们调用 PackedFunc 时，它会将输入参数打包到堆栈上的 TVMArgs 中，并通过 TVMRetValue 获取结果。

由于 C++ 中的模板技巧，我们可以像调用普通函数一样调用 PackedFunc。由于其类型擦除的性质，我们可以从 python 等动态语言调用 PackedFunc，而无需为创建的每个新类型函数添加额外的粘合代码。以下示例在 C++ 中注册 PackedFunc 并从 python 调用。

// register a global packed function in c++
TVM_REGISTER_GLOBAL("myadd")
.set_body(MyAdd);

import tvm

myadd = tvm.get_global_func("myadd")
# prints 3
print(myadd(1, 2))

PackedFunc 的大部分魔力在于 TVMArgs 和 TVMRetValue 结构。我们限制了可以传递的可能类型列表。以下是常见的类型

• int、float 和 string

• PackedFunc 本身

• 用于编译模块的模块

• 用于张量对象交换的 DLTensor*

• 用于表示 IR 中任何对象的 TVM 对象

这种限制使实现变得简单，无需序列化。尽管 PackedFunc 非常简洁，但对于深度学习部署的用例来说已经足够了，因为大多数函数只接受 DLTensor 或数字。

由于一个 PackedFunc 可以将另一个 PackedFunc 作为参数，我们可以将函数从 python（作为 PackedFunc）传递到 C++。

TVM_REGISTER_GLOBAL("callhello")
.set_body([](TVMArgs args, TVMRetValue* rv) {
  PackedFunc f = args[0];
  f("hello world");
});

import tvm

def callback(msg):
  print(msg)

# convert to PackedFunc
f = tvm.convert(callback)
callhello = tvm.get_global_func("callhello")
# prints hello world
callhello(f)

TVM 提供了一个 最小 C API，这使我们能够将 PackedFunc 嵌入到任何语言中。除了 python 之外，到目前为止我们还支持 java 和 javascript。这种嵌入式 API 的理念非常像 Lua，只是我们没有使用新语言，而是使用了 C++。

关于 PackedFunc 有趣的事实之一是，我们将其用于编译器和部署堆栈。

• TVM 的所有编译器 pass 函数都作为 PackedFunc 暴露给前端

• 编译后的模块还将编译后的函数作为 PackedFunc 返回

为了保持运行时的最小化，我们将 IR 对象支持与部署运行时隔离。最终的运行时大小约为 200K - 600K，具体取决于包含多少运行时驱动程序模块（例如 CUDA）。

调用 PackedFunc 与调用普通函数相比，开销很小，因为它只是在堆栈上保存一些值。因此，只要我们不包装小函数，它就可以接受。总而言之，PackedFunc 是 TVM 中的通用粘合剂，我们广泛使用它来支持我们的编译器和部署。

模块

由于 TVM 支持多种类型的设备，我们需要支持不同类型的驱动程序。我们必须使用驱动程序 API 来加载内核，以打包格式设置参数并执行内核启动。我们还需要修补驱动程序 API，以便暴露的函数是线程安全的。因此，我们经常需要在 C++ 中实现这些驱动程序粘合代码，并将它们暴露给用户。我们当然不能为每种类型的函数都这样做，因此 PackedFunc 再次成为我们的答案。

TVM 将编译后的对象定义为 Module。用户可以从 Module 中获取编译后的函数作为 PackedFunc。生成的编译代码可以在运行时动态地从 Module 获取函数。它在第一次调用时缓存函数句柄，并在后续调用中重用。我们使用它来链接设备代码，并从生成的代码回调到任何 PackedFunc（例如 python）。

ModuleNode 是一个抽象类，可以由每种类型的设备实现。到目前为止，我们支持 CUDA、Metal、OpenCL 的模块以及加载动态共享库。这种抽象使得引入新设备变得容易，并且我们不需要为每种类型的设备重新进行主机代码生成。

远程部署

PackedFunc 和 Module 系统也使得将函数直接交付到远程设备变得容易。在底层，我们有一个 RPCModule，它可以序列化参数以进行数据移动并在远程启动计算。

RPC 服务器本身是最小的，可以捆绑到运行时中。我们可以在 iPhone/android/raspberry pi 甚至浏览器上启动一个最小的 TVM RPC 服务器。服务器上的交叉编译和模块交付以进行测试可以在同一个脚本中完成。请查看 交叉编译和 RPC 以获取更多详细信息。

这种即时反馈给了我们很多优势。例如，为了测试 iPhone 上生成的代码的正确性，我们不再需要从头开始用 swift/objective-c 编写测试用例——我们可以使用 RPC 在 iPhone 上执行，将结果复制回主机，并通过 numpy 在主机上进行验证。我们还可以使用相同的脚本进行性能分析。

TVM 对象和编译器堆栈

正如我们前面提到的，我们在 PackedFunc 运行时系统之上构建了编译器堆栈 API。为了研究的需要，我们面临着编译器 API 的不断变化。每当我们想要测试新的原语时，我们都需要一个新的语言对象或 IR 节点。但是，我们不想不时地更改我们的 API。除此之外，我们还希望

• 能够序列化任何语言对象和 IR

• 能够在前端语言中探索、打印和操作 IR 对象，以进行快速原型设计。

我们引入了一个基类，称为 Object 来解决这个问题。编译器堆栈中的所有语言对象都是 Object 的子类。每个对象都包含一个字符串 type_key，用于唯一标识对象的类型。我们选择字符串而不是 int 作为类型键，这样可以在分散式的方式添加新的 Object 类，而无需将代码添加回中央存储库。为了提高调度速度，我们在运行时为每个 type_key 分配一个整数 type_index。

由于通常一个 Object 可以在语言中的多个位置被引用，因此我们使用 shared_ptr 来跟踪引用。我们使用 ObjectRef 类来表示对 Object 的引用。我们可以大致将 ObjectRef 类视为指向 Object 容器的 shared_ptr。我们还可以定义 ObjectRef 的子类来保存 Object 的每个子类型。Object 的每个子类都需要定义 VisitAttr 函数。

class AttrVisitor {
public:
  virtual void Visit(const char* key, double* value) = 0;
  virtual void Visit(const char* key, int64_t* value) = 0;
  virtual void Visit(const char* key, uint64_t* value) = 0;
  virtual void Visit(const char* key, int* value) = 0;
  virtual void Visit(const char* key, bool* value) = 0;
  virtual void Visit(const char* key, std::string* value) = 0;
  virtual void Visit(const char* key, void** value) = 0;
  virtual void Visit(const char* key, Type* value) = 0;
  virtual void Visit(const char* key, ObjectRef* value) = 0;
  // ...
};

class BaseAttrsNode : public Object {
public:
  virtual void VisitAttrs(AttrVisitor* v) {}
  // ...
};

每个 Object 子类都将覆盖此方法以访问其成员。以下是 TensorNode 的示例实现。

class TensorNode : public Object {
public:
  /*! \brief The shape of the tensor */
  Array<Expr> shape;
  /*! \brief data type in the content of the tensor */
  Type dtype;
  /*! \brief the source operation, can be None */
  Operation op;
  /*! \brief the output index from source operation */
  int value_index{0};
  /*! \brief constructor */
  TensorNode() {}

  void VisitAttrs(AttrVisitor* v) final {
    v->Visit("shape", &shape);
    v->Visit("dtype", &dtype);
    v->Visit("op", &op);
    v->Visit("value_index", &value_index);
  }
};

在上面的示例中，Operation 和 Array<Expr> 都是 ObjectRef。VisitAttrs 为我们提供了一个反射 API 来访问对象的每个成员。我们可以使用此函数来访问节点并递归地序列化任何语言对象。它还允许我们在前端语言中轻松获取对象的成员。例如，在以下代码中，我们访问了 TensorNode 的 op 字段。

import tvm
from tvm import te

x = te.placeholder((3,4), name="x")
# access the op field of TensorNode
print(x.op.name)

新的 Object 可以添加到 C++ 中，而无需更改前端运行时，从而可以轻松地对编译器堆栈进行扩展。请注意，这不是将成员暴露给前端语言的最快方法，但可能是最简单的方法之一。我们还发现它符合我们的目的，因为我们主要使用 python 进行测试和原型设计，仍然使用 c++ 来完成繁重的工作。

实现细节

PackedFunc 中的每个参数都包含一个联合值 TVMValue 和一个类型代码。这种设计允许动态类型语言直接转换为相应的类型，并允许静态类型语言在转换期间进行运行时类型检查。

相关文件是

• packed_func.h 用于 C++ API

• c_runtime_api.cc 用于 C API 以及如何提供回调。

为了支持扩展类型，我们使用注册表系统来注册类型相关信息，例如对 C++ 中 any 的支持，有关更多详细信息，请参见 扩展类型。

运行时特定信息

• Vulkan 运行时