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 Compatibility 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 函数时没有开销。