01 · Python 调 C++ 的那条边界

// c01_kernel.cpp
// Linux/macOS: g++ -O2 -std=c++17 -shared -fPIC c01_kernel.cpp -o libkernel.so
// Windows(MinGW): g++ -O2 -std=c++17 -shared -static c01_kernel.cpp -o kernel.dll
#include <cstdint>

extern "C" {                       // ⭐ 关掉 C++ 的名字修饰，ctypes 才找得到这个名字

double sum_to(int64_t n) {         // 0+1+...+(n-1)
    double s = 0;
    for (int64_t i = 0; i < n; ++i) s += (double)i;
    return s;
}

double busy(int64_t n) {           // 纯占 CPU，第四节用它观察那把锁
    double s = 0;
    for (int64_t i = 0; i < n; ++i) s += (double)(i % 7);
    return s;
}

}

# c01_bench.py
import ctypes, time, os, platform

N = 20_000_000

t0 = time.perf_counter()
s = 0.0
for i in range(N):          # ⚠️ 循环体在 Python 里
    s += i
t1 = time.perf_counter()
py_ms = (t1 - t0) * 1000

lib_name = "kernel.dll" if platform.system() == "Windows" else "./libkernel.so"
lib = ctypes.CDLL(os.path.abspath(lib_name))
lib.sum_to.argtypes = [ctypes.c_int64]      # ⭐ 必须自己声明签名
lib.sum_to.restype = ctypes.c_double

lib.sum_to(1000)            # 预热，别把第一次调用的开销算进去
t2 = time.perf_counter()
s2 = lib.sum_to(N)          # ⭐ 循环体在 C++ 里
t3 = time.perf_counter()
cpp_ms = (t3 - t2) * 1000

print(f"Python {py_ms:8.1f} ms   结果 {s}")
print(f"C++    {cpp_ms:8.1f} ms   结果 {s2}")
print(f"倍数   {py_ms / cpp_ms:8.1f}x")
print(f"每个元素 Python {py_ms*1e6/N:.1f} ns / C++ {cpp_ms*1e6/N:.2f} ns")

# c01_box.py 的一部分
import dis

def f(s, i):
    s += i
    return s

dis.dis(f)

import sys, array

print(sys.getsizeof(0))          # 28
print(sys.getsizeof(1))          # 28
print(sys.getsizeof(2**100))     # 40

lst = list(range(1000))
print(sys.getsizeof(lst))                                        # 8056
print(sys.getsizeof(lst) + sum(sys.getsizeof(x) for x in lst))   # 36056
print(sys.getsizeof(array.array('q', range(1000))))              # 8320

# c01_gil.py
import ctypes, threading, time, os, platform

lib_name = "kernel.dll" if platform.system() == "Windows" else "./libkernel.so"
path = os.path.abspath(lib_name)

released = ctypes.CDLL(path)    # ⭐ CDLL：调用期间【放开】解释器的锁
held     = ctypes.PyDLL(path)   # ⚠️ PyDLL：调用期间【一直握着】锁
for lib in (released, held):
    lib.busy.argtypes = [ctypes.c_int64]
    lib.busy.restype = ctypes.c_double

N = 300_000_000

def run(lib, nthreads):
    ts = [threading.Thread(target=lib.busy, args=(N,)) for _ in range(nthreads)]
    t0 = time.perf_counter()
    for t in ts: t.start()
    for t in ts: t.join()
    return (time.perf_counter() - t0) * 1000

for name, lib in (("CDLL(放开锁)", released), ("PyDLL(不放开)", held)):
    one = run(lib, 1)
    two = run(lib, 2)
    print(f"{name}:  1个线程 {one:7.1f} ms   2个线程 {two:7.1f} ms   →  {two/one:.2f}x")

// mymod.cpp   🗓️ 未实跑 —— 本机无编译环境
#include <pybind11/pybind11.h>
#include <cstdint>
namespace py = pybind11;

double busy(int64_t n) {
    double s = 0;
    for (int64_t i = 0; i < n; ++i) s += (double)(i % 7);
    return s;
}

PYBIND11_MODULE(mymod, m) {
    m.def("busy", &busy, "占 CPU 的循环",
          py::call_guard<py::gil_scoped_release>());   // ⭐ 整个调用期间放开锁
}

// 🗓️ 未实跑
py::array_t<float> process(py::array_t<float> arr) {
    auto buf = arr.request();
    float* ptr = static_cast<float*>(buf.ptr);   // ⭐ 先把裸指针拿到手
    size_t n = buf.size;
    {
        py::gil_scoped_release release;          // ⭐ 从这里开始放开
        for (size_t i = 0; i < n; ++i) ptr[i] = ptr[i] * 2.0f;
    }                                            // ⭐ 出了大括号自动拿回来
    return arr;                                  // 这一行又碰 Python 对象了，必须在锁里
}