Nuitka: компиляция Python-кода в C

PyInstaller упаковывает: ваш код внутри exe остаётся байткодом, и исполняет его всё та же виртуальная машина. Nuitka идёт дальше — это компилятор: программа транслируется в C, C собирается в машинный код, и интерпретация байткода с горячего пути исчезает. Урок разбирает конвейер компиляции по шагам и показывает на чистом Python, за счёт чего именно появляется ускорение.

Два режима работы

У Nuitka два режима. accelerated компилирует модуль в C-расширение — файл .pyd на Windows или .so на Unix: такой модуль импортируется обычным Python и ускоряет только себя, но требует установленного интерпретатора. standalone собирает полноценное приложение с библиотеками — как PyInstaller, только код внутри нативный:

Установка и сборка

pip install nuitka
python -m nuitka main.py

Для сборки нужен C-компилятор: MSVC или MinGW на Windows, gcc или clang на Unix-системах. Сборка занимает заметно больше времени, чем у PyInstaller, — это цена настоящего компилирования.

Что значит «компиляция в C»

Конвейер такой: исходник разбирается в дерево AST, из дерева Nuitka строит своё представление программы, из него генерирует C-код, и компилятор C доводит до машинного. Первый шаг можно повторить прямо в песочнице — стандартный модуль ast разбирает тот же исходник:

import ast

source = (
    "def total(prices):\n"
    "    s = 0\n"
    "    for p in prices:\n"
    "        s = s + p\n"
    "    return s\n"
)

tree = ast.parse(source)
func = tree.body[0]
print('Функция:', func.name)
print('Аргументы:', [a.arg for a in func.args.args])
kinds = []
for node in ast.walk(func):
    if isinstance(node, (ast.Assign, ast.For, ast.BinOp, ast.Return)):
        kinds.append(type(node).__name__)
print('Конструкции:', ', '.join(kinds))

Функция: total
Аргументы: ['prices']
Конструкции: Assign, For, Return, Assign, BinOp

Перед компилятором лежит дерево: функция, присваивания, цикл, сложение. Теперь он может делать то, что интерпретатор не умеет, — оптимизировать по всей программе. Классика: свёртка констант — выражения из одних констант вычисляются ещё при сборке, а не при каждом запуске:

import ast

class Folder(ast.NodeTransformer):
    def visit_BinOp(self, node):
        self.generic_visit(node)
        ops = {ast.Add: lambda a, b: a + b, ast.Sub: lambda a, b: a - b, ast.Mult: lambda a, b: a * b}
        if (
            isinstance(node.left, ast.Constant)
            and isinstance(node.right, ast.Constant)
            and type(node.op) in ops
        ):
            return ast.Constant(value=ops[type(node.op)](node.left.value, node.right.value))
        return node

print('Было: n = 2 + 3 * 4')
folded = Folder().visit(ast.parse('n = 2 + 3 * 4'))
ast.fix_missing_locations(folded)
ns = {}
exec(compile(folded, '<folded>', 'exec'), ns)
print('Стало: n =', ns['n'])

Было: n = 2 + 3 * 4
Стало: n = 14

Выражение вычислилось при сборке: в машинном коде лежит готовое значение. Таких оптимизаций у Nuitka десятки — от свёртки констант до упрощения известных форм вызовов.

/* упрощённая иллюстрация, а не реальный вывод Nuitka */
static PyObject *impl_total(PyObject *self, PyObject *prices) {
    PyObject *s = PyLong_FromLong(0L);
    /* цикл for p in prices стал машинным циклом */
    /* s = s + p стал вызовом PyNumber_Add(s, p)   */
    return s;
}

Что ускоряется, а что нет

Ключ к честным ожиданиям: компиляция не превращает Python в C с машинными числами. Значения остаются теми же объектами — PyObject, и арифметика над ними идёт через те же функции CPython. Проверим это на функции в «компиляторном стиле»:

def compiled_style(a, b):
    s = a + b
    return s * 2

result = compiled_style(21, 21)
print('Результат:', result)
print('Тип результата:', type(result))

Результат: 84
Тип результата: <class 'int'>

Nuitka заменяет интерпретацию байткода машинным потоком управления. Числа при этом остаются объектами CPython: ускоряются циклы и вызовы, а не каждая отдельная операция. Отсюда правило: выигрывает код с плотными циклами, ветвлениями и вызовами — а не одинокая арифметика.

Два источника ускорения

Первый источник: код собирается один раз. CPython разбирает и компилирует исходник при каждом запуске программы (пусть и с кэшем pyc), а нативный код собран заранее. Измерим саму идею: разбор строки на каждый вызов против заранее собранного кода:

import time

source = 'a * a + 2 * b'
ctx = {'a': 7, 'b': 30}

precompiled = compile(source, '<expr>', 'eval')

n = 10_000
t0 = time.perf_counter()
for _ in range(n):
    eval(compile(source, '<expr>', 'eval'), ctx)
t_fresh = time.perf_counter() - t0

t0 = time.perf_counter()
for _ in range(n):
    eval(precompiled, ctx)
t_ready = time.perf_counter() - t0

print('Результат одинаковый:', eval(precompiled, ctx) == eval(compile(source, '<expr>', 'eval'), ctx))
print('Скомпилированный заранее быстрее:', t_ready < t_fresh)

Результат одинаковый: True
Скомпилированный заранее быстрее: True

Второй источник: исчезает шаговая интерпретация. Виртуальная машина выполняет программу по инструкциям: диспетчер читает опкод, выбирает ветку, исполняет. Прямой код идёт без диспетчера. Сравним вызов функции со «стековой машиной» — так изнутри выглядит интерпретация:

import time

def direct(a, b, c):
    return (a + b) * c

def vm(program, args):
    stack = []
    for op, arg in program:
        if op == 'push':
            stack.append(args[arg])
        elif op == 'add':
            y = stack.pop()
            x = stack.pop()
            stack.append(x + y)
        elif op == 'mul':
            y = stack.pop()
            x = stack.pop()
            stack.append(x * y)
        elif op == 'ret':
            return stack[0]

prog = [('push', 0), ('push', 1), ('add', None), ('push', 2), ('mul', None), ('ret', None)]
args = (7, 5, 3)
print('Результат совпадает:', vm(prog, args) == direct(7, 5, 3))

n = 30_000
t0 = time.perf_counter()
for _ in range(n):
    direct(7, 5, 3)
t_direct = time.perf_counter() - t0

t0 = time.perf_counter()
for _ in range(n):
    vm(prog, args)
t_vm = time.perf_counter() - t0

print('Прямой код быстрее стековой машины:', t_direct < t_vm)

Результат совпадает: True
Прямой код быстрее стековой машины: True

Обе разницы мы выразили сравнением больше-меньше, а не абсолютными миллисекундами: время зависит от машины, а порядок результатов — никогда. Нативный код получает оба выигрыша разом: собран заранее и исполняется без диспетчера.

Nuitka против PyInstaller

python -m nuitka --standalone --onefile main.py

Для точечного ускорения вместо компиляции всей программы существует хирургический инструмент: Cython добавляет к Python типы и компилирует только горячий модуль — об этом следующий урок.