Python 语义

Python 难以优化，因为几乎所有东西都是可变的：内置函数、函数代码、全局变量、局部变量……都可以在运行时修改。实现尊重 Python 语义的优化需要检测“何时发生变化”，我们将这些检查称为“守卫器”。

此 PEP 提出向 Python C API 添加一个公共 API，以便向函数添加带有守卫器的专门化代码。当调用函数时，如果没有任何变化，则使用专门化的代码，否则使用原始字节码。

即使守卫器有助于尊重 Python 语义的大部分内容，但在不对精确行为进行细微更改的情况下，也很难优化 Python。CPython 拥有悠久的历史，许多应用程序依赖于实现细节。必须在“一切都是可变的”和性能之间找到折衷方案。

编写优化器不在本 PEP 的范围内。

为什么不使用 JIT 编译器？

有多个积极开发的 Python JIT 编译器

• PyPy
• Pyston
• Numba
• Pyjion

Numba 专注于数值计算。Pyston 和 Pyjion 仍然很年轻。PyPy 是最完整的 Python 解释器，它通常在微基准测试和许多宏基准测试中比 CPython 更快，并且与 CPython 具有非常好的兼容性（它尊重 Python 语义）。Python JIT 编译器仍然存在一些问题，导致它们无法广泛用于替代 CPython。

许多流行的库，如 numpy、PyGTK、PyQt、PySide 和 wxPython，都是用 C 或 C++ 实现的，并使用 Python C API。为了拥有较小的内存占用和更好的性能，Python JIT 编译器不使用引用计数以使用更快的垃圾收集器，不使用 CPython 对象的 C 结构，并以不同的方式管理内存分配。PyPy 有一个 cpyext 模块可以模拟 Python C API，但它的性能比 CPython 差，并且不支持完整的 Python C API。

新功能首先在 CPython 中开发。在 2016 年 1 月，最新的 CPython 稳定版本是 3.5，而 PyPy 仅支持 Python 2.7 和 3.2，Pyston 仅支持 Python 2.7。

即使 PyPy 与 Python 具有非常好的兼容性，一些模块仍然与 PyPy 不兼容：请参阅 PyPy 兼容性 Wiki。Python C API 的不完整支持是此问题的一部分。PyPy 和 CPython 之间也存在细微差别，例如引用计数：对象析构函数始终在 PyPy 中被调用，但在 CPython 中可以“稍后”被调用。使用上下文管理器有助于控制何时释放资源。

即使 PyPy 在广泛的基准测试中比 CPython 快得多，一些用户仍然报告在某些特定用例中性能比 CPython 差或性能不稳定。

当 Python 用作运行时间少于 1 分钟的程序的脚本程序时，JIT 编译器可能会更慢，因为它们的启动时间更长，并且 JIT 编译器需要时间来优化代码。例如，大多数 Mercurial 命令需要几秒钟。

Numba 现在支持提前编译，但它需要装饰器来指定参数类型，并且它仅支持数值类型。

CPython 3.5 几乎没有优化：窥孔优化器仅实现基本优化。静态编译器是 CPython 3.5 和 PyPy 之间的折衷方案。

假设的 myoptimizer 模块

此 PEP 中的示例使用假设的 myoptimizer 模块，该模块提供以下函数和类型

• specialize(func, code, guards)：向函数 func 添加带有守卫器 guards 的专门化代码 code
• get_specialized(func)：将专门化代码的列表作为 (code, guards) 元组列表获取，其中 code 是可调用对象或代码对象，而 guards 是守卫器列表
• GuardBuiltins(name)：监视 builtins.__dict__[name] 和 globals()[name] 的守卫器。如果替换了 builtins.__dict__[name]，或者设置了 globals()[name]，则守卫器失败。

使用字节码

添加专门化的字节码，其中对纯内置函数 chr(65) 的调用被替换为其结果 "A"

import myoptimizer

def func():
    return chr(65)

def fast_func():
    return "A"

myoptimizer.specialize(func, fast_func.__code__,
                       [myoptimizer.GuardBuiltins("chr")])
del fast_func

显示守卫器行为的示例

print("func(): %s" % func())
print("#specialized: %s" % len(myoptimizer.get_specialized(func)))
print()

import builtins
builtins.chr = lambda obj: "mock"

print("func(): %s" % func())
print("#specialized: %s" % len(myoptimizer.get_specialized(func)))

输出

func(): A
#specialized: 1

func(): mock
#specialized: 0

第一个调用使用专门化的字节码，该字节码返回字符串 "A"。第二个调用删除专门化的代码，因为替换了内置 chr() 函数，并执行调用 chr(65) 的原始字节码。

在微基准测试中，调用专门化的字节码需要 88 ns，而原始函数需要 145 ns（+57 ns）：速度提高了 1.6 倍。

使用内置函数

添加 C 内置 chr() 函数作为专门化代码，而不是调用 chr(obj) 的字节码

import myoptimizer

def func(arg):
    return chr(arg)

myoptimizer.specialize(func, chr,
                       [myoptimizer.GuardBuiltins("chr")])

显示守卫器行为的示例

print("func(65): %s" % func(65))
print("#specialized: %s" % len(myoptimizer.get_specialized(func)))
print()

import builtins
builtins.chr = lambda obj: "mock"

print("func(65): %s" % func(65))
print("#specialized: %s" % len(myoptimizer.get_specialized(func)))

输出

func(): A
#specialized: 1

func(): mock
#specialized: 0

第一个调用调用 C 内置 chr() 函数（无需创建 Python 框架）。第二个调用删除专门化的代码，因为替换了内置 chr() 函数，并执行原始字节码。

在微基准测试中，调用 C 内置函数需要 95 ns，而原始字节码需要 155 ns（+60 ns）：速度提高了 1.6 倍。直接调用 chr(65) 需要 76 ns。

函数守卫器

添加函数守卫器对象

typedef struct {
    PyObject ob_base;
    int (*init) (PyObject *guard, PyObject *func);
    int (*check) (PyObject *guard, PyObject **stack, int na, int nk);
} PyFuncGuardObject;

init() 函数初始化守卫器

• 成功时返回 0
• 如果守卫器将始终失败，则返回 1： PyFunction_Specialize() 必须忽略专门化的代码
• 在发生错误时引发异常并返回 -1

check() 函数检查守卫器

• 成功时返回 0
• 如果守卫器暂时失败，则返回 1
• 如果守卫器将始终失败，则返回 2：必须删除专门化的代码
• 在发生错误时引发异常并返回 -1

stack 是参数数组：索引参数后跟关键字参数的 (key, value) 对。na 是索引参数的数量。nk 是关键字参数的数量： (key, value) 对的数量。 stack 包含 na + nk * 2 个对象。

专门化的代码

添加专门化代码结构

typedef struct {
    PyObject *code;        /* callable or code object */
    Py_ssize_t nb_guard;
    PyObject **guards;     /* PyFuncGuardObject objects */
} PySpecializedCode;

函数方法

int PyFunction_Specialize(PyObject *func,
                          PyObject *code, PyObject *guards)

PyObject* PyFunction_GetSpecializedCodes(PyObject *func)

PyObject* PyFunction_GetSpecializedCode(PyObject *func,
                                        PyObject **stack,
                                        int na, int nk)

int PyFunction_RemoveSpecialized(PyObject *func, Py_ssize_t index)

int PyFunction_RemoveAllSpecialized(PyObject *func)

基准测试

在python3.6 -m timeit -s 'def f(): pass' 'f()'上进行微基准测试（最佳3次运行）。

• 原始 Python：79 ns
• 修补后的 Python：79 ns

根据此微基准测试，更改对调用没有特殊化的 Python 函数没有开销。