Chamar C++ com pybind11

Quando o Python precisa do C++

Boa parte do código sério do mundo do trading é C++: motores de casamento, tratadores de dados de mercado, bibliotecas de precificação afinadas ao longo de quinze anos. Raramente se quer reescrevê-lo e raramente se quer abrir mão do Python para pesquisa. O pybind11 é a ponte: uma biblioteca C++ só de cabeçalhos em que você escreve algumas linhas dizendo «exponha esta função C++ ao Python com este nome», compila-as numa biblioteca compartilhada e a importa do Python como qualquer módulo. Argumentos e resultados são convertidos por você: uma lista Python de floats vira um std::vector<double> e vice-versa.

# A C++ function and the pybind11 file that exposes it to Python (shown here as text)
cpp = """\
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <vector>

namespace py = pybind11;

double mean(const std::vector<double>& x) {
    double total = 0.0;
    for (double v : x) total += v;
    return x.empty() ? 0.0 : total / x.size();
}

PYBIND11_MODULE(fastmath, m) {
    m.def("mean", &mean, "Mean of a list of floats");
}
"""
lines = cpp.splitlines()
print(lines[-2].strip())                             # m.def("mean", &mean, "Mean of a list of floats");
print(len(lines))                                    # 15

Os tipos através da ponte

Cada tipo Python tem um equivalente em C++: int é int64_t, float é double, str é std::string, uma lista de floats é std::vector<double>; todo o resto pode ser mantido como um py::object genérico. Incluir <pybind11/stl.h> torna automáticas as conversões de contêineres padrão. Passe valores grandes por referência constante (const std::vector<double>& x) para que a função C++ não os copie, e valores pequenos, como números, por valor. A conversão de uma lista Python para vetor ainda copia uma vez por chamada, então para arrays grandes use py::array_t<double>, que enxerga diretamente a memória de um array NumPy sem cópia.

# Choosing the C++ type of each argument; big values are passed by const reference
CPP_TYPES = {"int": "int64_t", "float": "double", "str": "std::string", "list[float]": "std::vector<double>"}

def cpp_type(py_type):
    return CPP_TYPES.get(py_type, "py::object")

def cpp_signature(name, params, returns):
    result = "void" if returns is None else cpp_type(returns)
    arguments = []
    for param, py_type in params:
        ctype = cpp_type(py_type)
        arguments.append(f"const {ctype}& {param}" if ctype.startswith("std::") else f"{ctype} {param}")
    return f"{result} {name}({', '.join(arguments)})"

print(cpp_signature("mean", [("x", "list[float]"), ("n", "int")], "float"))      # double mean(const std::vector<double>& x, int64_t n)
print(cpp_signature("label", [("symbol", "str")], "str"))                       # std::string label(const std::string& symbol)

Build, GIL e propriedade

Compila-se com CMake (pybind11_add_module) ou com pybind11.setup_helpers em um setup.py, e o resultado é um arquivo .so ou .pyd que se importa. Duas coisas a saber. Primeiro, enquanto o código C++ roda, o bloqueio global do interpretador (GIL) permanece retido a menos que você o libere com py::gil_scoped_release; um cálculo longo em C++ que não toca objetos Python deve liberá-lo para que outras threads Python rodem. Segundo, a propriedade: se o C++ devolve uma referência ou ponteiro para sua própria memória, o Python não deve sobreviver a ela (py::return_value_policy controla isso), e uma falha sem traceback Python geralmente indica um ponteiro pendente. Teste as funções ligadas a partir do Python contra uma versão Python pura, exatamente como nos laboratórios anteriores.

# Binding lines and the module file, generated from a table of functions
BACKSLASH = chr(92)

def binding_line(py_name, cpp_name, doc):
    escaped = doc.replace(BACKSLASH, BACKSLASH + BACKSLASH).replace('"', BACKSLASH + '"')
    return f'm.def("{py_name}", &{cpp_name}, "{escaped}");'

def module_source(module, functions):
    lines = ["#include <pybind11/pybind11.h>", "#include <pybind11/stl.h>", "", "namespace py = pybind11;", ""]
    lines.append(f"PYBIND11_MODULE({module}, m) {{")
    for py_name, cpp_name, doc in functions:
        lines.append("    " + binding_line(py_name, cpp_name, doc))
    lines.append("}")
    return "\n".join(lines) + "\n"

source = module_source("pricing", [("mean", "mean_impl", "Mean of x"), ("price", "bs_price", 'Black-Scholes "call" price')])
print(source.splitlines()[-3])                       #     m.def("mean", &mean_impl, "Mean of x");
print(source.splitlines()[-2])                       #     m.def("price", &bs_price, "Black-Scholes \"call\" price");

# From Python the built module is used like any other; this stand-in has the same interface
import types

def mean(x):
    """Mean of a list of floats"""
    return sum(x) / len(x) if x else 0.0

fastmath = types.SimpleNamespace(mean=mean)          # stands in for `import fastmath` after the build
print(fastmath.mean([100.0, 102.0, 101.0]))          # 101.0
print(fastmath.mean.__doc__)                         # Mean of a list of floats   the doc string given to m.def
print(fastmath.mean([]))                             # 0.0   what the C++ code returns for an empty vector

• O pybind11 expõe funções C++ ao Python com PYBIND11_MODULE e linhas m.def(...); o resultado é um módulo .so/.pyd importável.
• Os tipos correspondem: int→int64_t, float→double, str→std::string, listas→std::vector; passe valores grandes por referência constante e arrays NumPy como py::array_t.
• Libere o GIL em trabalhos longos em C++ puro, cuide de quem possui a memória devolvida, valide as entradas na fronteira e teste contra uma versão Python pura.

A seguir: threads e o GIL, o que as threads Python podem e não podem fazer em paralelo.

Lab: o que é avaliado

• Mapear tipos Python para C++ com cpp_type25 pts
• Declarar uma função com cpp_signature25 pts
• Expor uma função com binding_line25 pts
• Montar o módulo com module_source25 pts