Dynamo 深入浅出¶
TorchDynamo（或简称为 Dynamo）是 torch.compile 中的跟踪器，它通常是那些疯狂的回溯的罪魁祸首。但是，我们不能盲目地责怪 Dynamo 造成这些错误。为了为用户提供灵活性，Dynamo 被赋予了理解任何 Python 程序的艰巨任务。特别是，Dynamo 必须在内部实现 Python 编程语言的很大一部分！
在这篇文章中，我们将从头到尾介绍 Dynamo 的内部设计。我们将讨论它提供的功能以及它的实现方式。在本篇文章结束时，您将更好地了解当您 torch.compiled 一个 PyTorch 程序并且编译出错，或者编译成功但速度提升不符合预期时，发生了什么问题。
Dynamo 的简要介绍¶
在深入研究所有实现细节之前，让我们首先讨论 Dynamo 做的事情。
Dynamo 是一个跟踪器。这意味着，给定一个函数及其输入，它会执行该函数并将指令的线性序列（不含控制流）记录到一个图中。例如，考虑以下程序
import torch
@torch.compile
def mse(x, y):
z = (x - y) ** 2
return z.sum()
x = torch.randn(200)
y = torch.randn(200)
mse(x, y)
如果我们将此程序保存到文件 example.py 中，并运行
TORCH_LOGS=graph_code python example.py
我们将看到 Dynamo 跟踪的输出
def forward(l_x_: torch.Tensor, l_y_: torch.Tensor):
# File: example.py:5, code: z = (x - y) ** 2
sub = l_x_ - l_y_
z = sub ** 2
# File: example.py:6, code: return z.sum()
sum_1 = z.sum()
return (sum_1,)
我们称之为 **函数的图（或跟踪）对于给定的输入**。它通过一个 FX 图 来表示。我们将简单地将 FX 图视为一个存储函数调用列表的容器。
我们首先应该注意的是，该图是 PyTorch 操作的线性序列。1 Dynamo 记录所有 PyTorch 操作并将它们按顺序存储。例如，它将 z = (x - y) ** 2 拆分为其两个组成操作，sub = l_x_ - l_y_ 和 z = sub ** 2。
当我们说跟踪是线性的时，我们的意思是它没有分支或任何控制流。要了解这一点，请考虑
import torch
@torch.compile
def fn(x, n):
y = x ** 2
if n >= 0:
return (n + 1) * y
else:
return y / n
x = torch.randn(200)
fn(x, 2)
它在使用 TORCH_LOGS=graph_code 执行时，将返回
def forward(l_x_: torch.Tensor):
# File: example.py:5, code: y = x ** 2
y = l_x_ ** 2
# File: example.py:7, code: return (n + 1) * y
mul = 3 * y
return (mul,)
我们看到 Dynamo 完全从跟踪中删除了 if 语句，只记录了使用输入执行的操作。
因此，应该清楚 **函数的跟踪取决于输入**。特别是，这意味着跟踪不是在写入 @torch.compile 时生成的，而是在使用实际参数执行函数 fn(x, 2) 时生成的。
另一个值得注意的有趣之处是 Dynamo 删除了函数的第二个参数。相反，它将其视为一个常量，并在图中记录了操作 n + 1 的结果。这是 Dynamo 的另一个特性：Dynamo 将任何非张量值视为常量……除了整数。现在让我们看看整数为何特殊。
Dynamo 的最后一个定义属性是它知道如何处理动态形状。符号形状指的是 Dynamo 跟踪形状（更一般地说，是整数）的能力，而不是将其保留为常量。这使得能够避免重新编译并在生产中部署适用于任何大小的通用模型。动态形状出现的主要例子是批次大小，我们可能使用固定的批次大小训练模型，然后对任意批次大小执行推理，或者在处理文本或音频时遇到的可变序列长度。
我们可以通过多次执行上面的示例来看到这一点
import torch
@torch.compile
def fn(x, n):
y = x ** 2
if n >= 0:
return (n + 1) * y
else:
return y / n
x = torch.randn(200)
fn(x, 2)
fn(x, 3)
fn(x, -2)
在这种情况下，TORCH_LOGS=graph_code 会生成另外两个图
# Graph for n==2 omitted
def forward(self, l_x_: torch.Tensor, l_n_: torch.SymInt):
# File: a.py:5, code: y = x ** 2
y = l_x_ ** 2
# File: a.py:7, code: return (n + 1) * y
add = l_n_ + 1
mul = add * y
return (mul,)
def forward(self, l_x_: torch.Tensor, l_n_: torch.SymInt):
# File: a.py:5, code: y = x ** 2
y = l_x_ ** 2
# File: a.py:9, code: return y / n
truediv = y / l_n_
return (truediv,)
Dynamo 检测到一个整数在第一次调用后更改了其值，并开始跟踪它。我们看到这些图是通用的，并通过 SymInt 类型的对象符号地跟踪变量 n。
如果在这些调用之后，我们调用 fn(x, 4)，Dynamo 不会重新编译，而是会重用已经跟踪的图。
总结：1. Dynamo 是一个 Python 跟踪器 2. 给定一些输入，它会返回一个包含已执行的 PyTorch 函数的 FX 图 3. 如果它检测到整数在调用之间发生了变化，它还可以跟踪整数 4. 它会专门化任何非张量或标量的值
当然，Dynamo 还会做更多事情，例如找出何时需要重新跟踪、重写函数的字节码、实现图断点……为了使介绍简短，我们将在后续章节中逐步讨论所有这些。
PEP 523：为 CPython 添加帧评估 API¶
现在假设我们要实现 Dynamo。我们应该从哪里开始呢？幸运的是，PEP 523 已经在 Python 3.6 中发布了。这个 PEP 旨在 允许第三方为 Python 创建 JIT 编译器。让我们看看它是如何实现的。
**关于 CPython 的说明**：CPython 在内部实现为 堆栈机。Python 程序会被编译成 字节码，然后由这个解释器执行。要了解更多关于这些字节码的信息，请参阅标准库中的 dis 模块。还可以参考 开发者文档 来了解 CPython 解释器的介绍。我们假设读者熟悉堆栈机的概念。
PEP 523 公开了 API，用户可以通过它添加自定义的每函数解释器。然后，CPython 将使用这个解释器而不是它自己的解释器来执行函数。为了能够执行函数，在进入时，CPython 会向自定义解释器提供以下信息：- 函数的字节码 - 函数参数的值（即局部变量）及其名称 - 全局变量的值及其名称 - 内置函数，例如 abs 或 print
总之，CPython 向用户的解释器提供执行函数所需的所有信息。 3
通过这个 API，我们可以通过实现一个运行代码并在图中记录此执行期间发生的 PyTorch 操作的解释器来实现跟踪器。这正是 Dynamo 的工作原理。
Dynamo 使用这个 CPython API 解析所有这些对象并将它们打包到 一个 Python 结构 中。完成之后，它会从 C 返回到 python。除了与 CPython 通信的这一段代码之外，Dynamo 完全在 Python 中实现。
很明显，装饰器 @torch.compile 的作用是安装必要的脚手架，以便在调用函数时将字节码、参数、全局变量等传递给 Dynamo。同样，@torch.compile 实际上并不编译任何东西。
在 Python 中实现 CPython¶
因此，我们回到了 Python 世界。我们拥有函数的字节码以及执行它所需的所有上下文。具体来说，我们已经到达了 _convert_frame_assert。这就是装饰器 torch.compile 返回的函数！我们从 _dynamo.optimize 中调用这个函数。装饰器 torch.compile 只是 _dynamo.optimize 的一个友好的 API。
在开始实现 Python 解释器之前，我们需要定义一个 IR。具体来说，我们希望将所有局部变量和全局变量包装到我们自己的内部类中。这使我们能够更好地跟踪这些对象，并将可以以相同方式处理的对象分组到 Dynamo 的眼中。
内部类结构的父类是 VariableTracker，它表示 Dynamo 理解的不同对象。例如，ListVariable 表示一个 list 对象，并在内部保存 VariableTracker 列表。另一个 VariableTracker 的例子是 ConstantVariable。ConstantVariable 包装所有 Dynamo 认为是常量对象。我们还为需要特别注意的对象定义了特殊的子类，例如 TensorVariable。所有这些内部类都在 torch/_dynamo/variables 文件夹中定义。
Python 对象在 VariableBuilder._wrap 中被包装到它们相应的 VariableTracker 类中。这个函数只是一长串 elif，它试图递归地将 Python 输入与适当类型的 VariableTracker 匹配。
**调试技巧**。当我们从 Dynamo 得到意外结果时，有时是由于构建器引起的。如果构建器的逻辑错误，有时 Dynamo 可能会将变量包装到不正确的 VariableTracker 类型中，这可能会导致以后出现问题。查看在 Dynamo 错误中出现的 VariableTracker 类型以及在遇到 Dynamo 错误时抛出异常的 VariableTracker 方法非常有用。特别是，有时我们会发现，一个对象被跟踪为 UserDefinedObjectVariable（这是 Dynamo 的万能类），而它应该被跟踪为更具体的类型。在这些情况下，SourceBuilder.__call__ 逻辑通常是罪魁祸首。
**调试技巧**。在使用 TORCH_LOGS=dynamo 运行程序时，打印出来的一个工件是以下形式的行
TRACE LOAD_GLOBAL y [TorchInGraphFunctionVariable(<built-in method any>), TensorVariable()]
这是原始程序的字节码，以及此时堆栈的状态。这对于查找对象没有被跟踪到正确的 VariableTracker 的位置非常有用。
好的，所以我们有一个用于跟踪器的 IR，现在我们 *只需要* 重新实现 CPython 的堆栈机。这由 InstructorTranslatorBase 在 symbolic_convert.py 中实现。
InstructionTranslatorBase 具有大约 200 个方法，实现了几乎所有 Python 字节码。例如，我们可以看到 BUILD_LIST 的实现
def BUILD_LIST(self, inst):
items = self.popn(inst.argval)
self.push(ListVariable(items, mutable_local=MutableLocal()))
这是由类似 l = [2, 3, 4] 的构造生成的字节码。在这种情况下，由于有三个元素，生成的字节码是 BUILD_LIST 3。这意味着我们弹出堆栈的顶部 3 个元素，并使用这三个元素创建一个新的列表对象并将其推送到堆栈顶部。
生成输出图¶
通过一种符号执行 Python 代码的方式，我们就可以提取在给定一些输入的程序的符号执行期间发生的 PyTorch 操作。这在 Dynamo 中通过 OutputGraph 对象实现。OutputGraph 对象 绑定到一个 `InstructionTranslator 对象，它跟踪创建 Dynamo 将返回的 FX 图所需的所有数据。
FX 图的所有输入和中间元素都是 fx.Node。在 Dynamo 中，fx.Node 被包装在 fx.Proxy 中。fx.Proxy 用于构建 FX 图。特别是，它们将对它们执行的每个 PyTorch 操作记录到图中。你可以通过调用 create_proxy 创建一个新的操作来添加到图中。然后，我们可以通过函数 wrap_fx_proxy 将其添加到图中。
图存储对张量的操作……以及对符号整数的操作。我们将在后面讨论符号整数，但首先我们将讨论 Dynamo 如何解决一个相当重要的正确性问题。
使 Dynamo 健壮：保护措施¶
在这一点上，我们有一种完全不考虑控制流的跟踪程序的方式。为此，我们重新实现了所有 CPython……如果这听起来有点过分，那是因为它确实过分了。torch.jit.trace 已经实现了这一点，而无需所有这些机制，那么为什么还要这么做呢？
如其文档中所警告的那样，torch.jit.trace 的问题在于，它只有在被跟踪的程序不是数据相关的时才有效。换句话说，只有在程序本身是线性的情况下，它才会有效。这意味着在编写程序时不能使用 if-elses、for-while 循环、异常。更重要的是，我们使用的所有库都不能使用任何控制流！总而言之，在像 Python 这样动态的语言中不使用控制流实际上是一个巨大的限制。
JAX 通过在每次重新跟踪后重新跟踪并缓存图来解决这个问题。另一方面，Dynamo 使用保护措施来避免每次都重新跟踪整个程序。
**保护措施** 是为了专门针对一组示例输入而对框架做出的假设（对输入的布尔表达式）。只有在这些假设对新输入成立的情况下，重用图才是有效的。
例如，函数的任何常量输入（例如字符串）都会安装一个保护措施，该保护措施说明该输入应该是 str 类型，并且应该等于我们传递的字符串。运行
import torch
@torch.compile
def fn(a, b):
return a * len(b)
fn(torch.arange(10), "Hello")
使用 TORCH_LOGS=guards 打印（除了其他保护措施之外）
___check_type_id(L['b'], 94334122025024)
L['b'] == 'Hello'
这表示“局部变量 b 应该具有特定类型（在本例中为 str，由常量 9433... 表示），并且它的值应该为 'Hello'”。如果我们随后再次执行函数，传递不同的参数
import torch
@torch.compile
def fn(a, b):
return a * len(b)
fn(torch.arange(10), "Hello")
fn(torch.arange(10), "Hi")
我们可以通过运行 TORCH_LOGS=recompiles 来查看失败的保护措施
Recompiling function fn in script.py:3
triggered by the following guard failure(s):
- L['b'] == 'Hello'
在将函数的输入包装到构建器中时，以及在程序执行期间，会累积守卫。我们将在下一节中展示更多守卫示例，但首先让我们讨论来源。
一个 **来源** 追踪如何从进入当前帧时存在的原始局部或全局变量中重建一个变量。特别是，它跟踪原始的局部和全局对象以及它们包含的任何对象。
def foo(x: Tensor, y: List[Tensor]):
a = x * y[0]
return a * x
x 和 y 的来源是 LocalSource，而 y[0] 的来源是 GetItemSource，它内部存储一个 LocalSource。另一方面，a 将没有来源，因为它是一个仅在 fx 图中存在的中间变量。
所有这些都在 torch/_dynamo/source.py 中定义。我们可以在下面的示例中看到由 GetItemSource 生成的守卫。
import torch
@torch.compile
def fn(x, l):
return x * len(l[0])
fn(torch.randn(8), ["Hi", "Hello"])
生成以下守卫。
___check_type_id(L['l'], 94439025877664)
len(L['l']) == 2
___check_type_id(L['l'][0], 94439025840192)
L['l'][0] == 'Hi'
___check_type_id(L['l'][1], 94439025840192)
L['l'][1] == 'Hello'
在这里，我们看到由 GetItemSource ([0] 和 [1]) 生成的代码，它包装了一个 LocalSource (L['l'])。
此时，有了来源和守卫，我们能够实现一个缓存系统，以避免在没有每次都重新跟踪的情况下进行重新编译。我们将在续集中更详细地讨论这个缓存系统。
细心的读者会注意到，这还没有解释为什么我们需要对 Python 解释器有如此精细的控制，以至于不得不重新实现它。我们已经展示的守卫示例依赖于输入对象，因此我们仍然可以在执行函数之前计算这些守卫。换句话说，我们可以在 torch.jit.trace 之上实现这个守卫系统，并以更少的努力获得相同的功能……进入符号形状。
符号形状¶
我们在介绍中讨论的另一个观点是，Dynamo 知道如何跟踪整数。为了实现这一点，我们使用了一个符号类 torch.SymInt，它像一个 int，但它在输出 FX 图中记录了对其执行的所有操作。 4 我们已经在介绍中介绍符号整数跟踪时看到了这个类。
现在让我们讨论定义 Dynamo 中符号形状跟踪的三个属性以及如何实现它们。
默认情况下为静态¶
Dynamo 假设每个整数，无论是输入还是张量的形状，默认情况下都是静态的。换句话说，在第一次执行函数时不会跟踪任何整数。然后，只有当它检测到在执行期间整数或形状的值发生改变时，它才会跟踪它并生成一个针对该变量的通用图形。
我们已经在介绍中使用整数看到了这种行为。现在让我们看一个使用张量形状的示例。
import torch
@torch.compile
def fn(a, b):
return a.shape[0] * a * b
fn(torch.randn(4, 3), torch.randn(4, 3))
fn(torch.randn(8, 3), torch.randn(8, 3))
使用 TORCH_LOGS=graph_code 运行这个程序，我们会看到这两个调用被跟踪为
def forward(self, l_a_: torch.Tensor, l_b_: torch.Tensor):
mul = 4 * l_a_
mul_1 = mul * l_b_
return (mul_1,)
def forward(self, s0: torch.SymInt, l_a_: torch.Tensor, l_b_: torch.Tensor):
size = l_a_.size()
getitem = size[0]
mul = getitem * l_a_
mul_1 = mul * l_b_
return (mul_1,)
在第一个图中，形状被跟踪为常量，但一旦它改变，它就会使用 SymInts 符号地跟踪它。一般来说，查看中间值形状的一个更简单的方法是使用 TORCH_LOGS=graph_sizes 运行程序
TRACED GRAPH TENSOR SIZES
===== __compiled_fn_1 =====
l_a_: (s0, 3)
l_a_ (concrete): (8, 3)
l_b_: (s0, 3)
l_b_ (concrete): (8, 3)
mul: (s0, 3)
mul (concrete): (8, 3)
mul_1: (s0, 3)
mul_1 (concrete): (8, 3)
在这里，我们可以看到两个张量参数的第一维是动态的，因为它是用 s0 变量表示的。
我们可以通过运行 TORCH_LOGS=guards 来找到 Dynamo 如何实现这一点
# Guards first call
check_tensor(L['a'], torch.float32, device=None, requires_grad=False, size=[4, 3], stride=[3, 1])
check_tensor(L['b'], torch.float32, device=None, requires_grad=False, size=[4, 3], stride=[3, 1])
# Guards second call
check_tensor(L['a'], torch.float32, device=None, requires_grad=False, size=[None, 3], stride=[3, 1])
check_tensor(L['b'], torch.float32, device=None, requires_grad=False, size=[None, 3], stride=[3, 1])
L['b'].size()[0] == L['a'].size()[0]
2 <= L['a'].size()[0]
我们看到在第一次调用中，守卫检查张量是否具有某些固定的大小和跨度。这些守卫在第二次执行中失败，因此它重新跟踪。由于这是一个 int 守卫失败，因此在第二次迭代中它符号地跟踪这个 int，并在这个更通用的内核上安装了更通用的守卫。
**编译性能提示**。如果你知道某个维度的大小会变化，你可以在调用 torch.compile 之前调用 torch._dynamo.mark_dynamic 来将其标记为动态的。这将避免第一次使用静态形状进行编译。还有一些其他有用的实用程序函数，比如 maybe_mark_dynamic 或 mark_static。你也可以通过调用 torch.compile(dynamic=True) 来跟踪所有整数和形状。这主要用于调试目的。
0、1 总是被专门化¶
无论我们是否将某个维度标记为动态的，或者我们是否将某个整数跟踪为动态的，如果我们传递一个输入，其中该维度是 0 或 1，Dynamo 将将其跟踪为非动态的，并为其生成一个特定图形。这就是为什么我们在上面的示例中找到形式为 2 <= L['a'].size()[0] 的守卫的原因。
这种选择有几个原因。有两个特别重要 - 一个张量为空当且仅当它的任何维度为零 - 一个张量只有当它的某个跨度为 1 时才是连续的。
鸭子整形¶
Dynamo 执行我们称为“鸭子整形”的操作。如果两个动态整数在跟踪时具有相同的值，我们将假设它们相等并对其进行守卫。实际上，这意味着我们不是在上面的示例中使用两个符号 s0、s1，而是将它们统一为 s0，并且有守卫 L['b'].size()[0] == L['a'].size()[0]。这使得能够在编译器中执行融合，同时能够生成足够通用的内核。
对符号整数的守卫¶
我们现在了解了符号形状如何在高级别上实现以及它们所具有的属性。现在，为什么符号形状迫使我们通过获得对 CPython 解释器的控制权的复杂途径？考虑以下示例。
import torch
@torch.compile(dynamic=True)
def fn(a):
if a.shape[0] * 2 < 16:
return a
else:
return a + 1
fn(torch.randn(8))
这段代码有一个形式为 2*L['a'].size()[0] >= 16 的守卫。在函数输入方面，这是一个非平凡的守卫，但它是在程序执行的中间注册的。更重要的是，我们无法知道在看到基于 SymNodeVariable 参数的 if 语句条件之前，是否需要这个守卫。这种条件对 torch.jit.trace 是不可见的，并且需要对 python 代码进行深入分析。
**调试提示** 使用 TORCH_LOGS=dynamo 运行这段代码，可以告诉我们这个守卫是在哪里添加的。
eval 2*s0 >= 16 [guard added] at script.py:5 in fn (_dynamo/variables/tensor.py:812 in evaluate_expr)
在那里放置一个断点并查看回溯对理解守卫来自哪里非常有用。
使 Dynamo 完整：图形中断¶
有了我们已经讨论过的所有工具，我们有一个跟踪器，它可以跟踪张量和整数上的 PyTorch 操作，并有一个缓存系统，它知道何时可以重用先前跟踪的图形以及何时需要重新跟踪。所有这些都执行任意 Python 代码！
这只有一个小小的问题。语句“执行任意 Python 代码”也许过于笼统。Dynamo 实现了一大部分 Python，但它是否实现了更复杂的部分，比如协程或 async？它是否实现了整个 Python 标准库？NumPy 也具有 Python API。torch.compile 是否也理解 NumPy？以及 Django？ 5
Python 的生态系统非常庞大，其中很大一部分是用其他更高效的语言（如 C++ 或 Rust）编写的，它只是公开 Python 绑定。Dynamo 无法跟踪用 C++ 实现的 Python 对象，这没有希望。当跟踪器遇到一个它不理解的操作时，它能做什么？
机器学习跟踪器处理这个问题的通常方法是通知用户它卡在了什么操作上，并放弃跟踪。在 PyTorch 的情况下，这会带来一个真正可用性的问题，因为 PyTorch 的用户习惯了它提供的灵活性。作为一个现实世界的例子，doctr_det_predictor 模型使用 NumPy 和 cv2 库来 对模型的结果进行后处理。
这里又是另一个访问 CPython 很有趣的地方。Dynamo 不会出错，而是可以放任 CPython 运行那个有问题的代码！为此，Dynamo 在跟踪时生成一个包含问题代码之前所有操作的图形，以及一个包含问题代码之后所有操作的图形。 6 然后，在运行时，它将委托给 CPython 来执行第一个图形，然后是问题代码，最后是第二个图形。这个停止跟踪并生成多个图形的过程称为 **图形中断**。
一个小小的承认：我在整个介绍和前几节都撒了谎。Dynamo 并没有生成一个图形，而是 **多个图形**！就所有实际目的而言，从第二个图形之后开始重新跟踪可以看作是开始跟踪一个新函数。图形中断后的新图形将有它自己的守卫，它自己的局部变量集等等。
为了讨论如何实现图中断，我们需要首先回顾 Dynamo 如何与 CPython 交互。使用 PEP 523，CPython 允许用户使用自己的帧评估机制。我们之前没有讨论的是，CPython 还公开了自己的帧评估供其他人使用。Dynamo 利用这一点，让快速的 CPython 解释器运行编译后的代码。对于没有图中断的函数，调用该函数两次并使用相同参数的程序的整个跟踪/执行过程如下所示
在第一次调用函数时
Dynamo 将函数跟踪到一个 FX 图
FX 图由编译器（Inductor）编译成高效的低级代码……但这留待以后再讲
它重写了函数的字节码，使其简单地调用编译后的函数
它将这个新的字节码提供给 CPython 并要求它运行它 [这里]
在第二次调用函数时
这个过程本身看起来过于复杂。为什么生成新的字节码并要求 CPython 运行它，而不是简单地创建一个 C++ 绑定到编译后的函数并执行它？好吧，这种模式允许我们实现图中断！由图中断生成的字节码具有以下结构
执行第一个图的字节码
将堆栈保留在 CPython 执行第一个图时的状态。它还回放对在此时可见的局部或全局变量的任何修改
导致 Dynamo 图中断的字节码
执行第二个图的字节码
让我们来看一个简单的例子
import torch
@torch.compile
def fn(a):
b = a + 2
print("Hi")
return b + a
fn(torch.randn(4))
使用 TORCH_LOGS=bytecode 运行它，会显示初始字节码和修改后的字节码
MODIFIED BYTECODE fn script.py line 3
0 LOAD_GLOBAL 1 (__compiled_fn_0)
2 LOAD_FAST 0 (a)
4 CALL_FUNCTION 1
6 STORE_FAST 3 (graph_out_0)
8 LOAD_GLOBAL 0 (print)
10 LOAD_CONST 2 ('Hi')
12 LOAD_FAST 3 (graph_out_0)
14 LOAD_CONST 3 (0)
16 BINARY_SUBSCR
18 STORE_FAST 1 (b)
20 CALL_FUNCTION 1
22 LOAD_GLOBAL 2 (__resume_at_14_1)
24 ROT_TWO
26 LOAD_FAST 0 (a)
28 LOAD_FAST 1 (b)
30 CALL_FUNCTION 3
32 RETURN_VALUE
MODIFIED BYTECODE resume_in_fn script.py line 6
0 LOAD_GLOBAL 1 (__compiled_fn_2)
2 LOAD_FAST 2 (b)
4 LOAD_FAST 1 (a)
6 CALL_FUNCTION 2
8 UNPACK_SEQUENCE 1
10 RETURN_VALUE
我们可以看到修改后的字节码被分成两个函数，fn（原始函数）和一个名为 resume_in_fn 的函数。第二个函数是由 Dynamo 创建的，用于实现从图中断开始的程序执行。这通常被称为 延续函数。这个延续函数只是使用正确的参数调用第二个编译后的函数。初始函数的代码被重写，实现了我们之前描述的策略
L0-4. 调用编译后的函数 (
a + 2)。L6. 将其结果存储在一个名为
graph_out_0的局部变量中。graph_out_0是一个元组L8-18. 将堆栈保留在图中断时的状态
L20. 执行导致图中断的代码
L22-32. 调用编译后的延续函数 (
a + b)
Dynamo 中堆栈的代码生成委托给 VariableTracker 子类。Dynamo 中的每个 VariableTracker 对象都具有一个 reconstruct 方法，该方法生成在堆栈上创建它所表示的 Python 对象所需的字节码。
调试提示。图中断会影响性能，因此最好避免它们。使用 TORCH_LOGS=graph_breaks 运行程序是了解程序遇到了多少个图中断的好方法。它返回的信息是以 VariableTracker 对象的形式，因此上面的调试技巧有时也有助于找出是什么导致了图中断。
结论¶
Dynamo 是一款复杂的软件。一旦你决定实现一个 CPython 解释器，你就知道自己将踏上一段不寻常的旅程。也就是说，我们希望这篇文章能帮助你更好地理解它。
Dynamo（大部分）是用 Python 实现的。我们留下了很多链接指向我们讨论的代码片段。我们希望阅读这些代码片段并查找调用它们的地方，或者在它们上面设置断点并查看调用堆栈有助于理解其余代码库。
当然，了解软件工作原理的最佳方法是扩展它。在这种情况下，最好的方法是查看 github 上的开放 dynamo 问题。其中很多只需要对代码进行非常小的改动，一旦你找到需要进行改动的地方。
