python - Cython 中 C++ 函数的性能不佳

Question

我有这个 C++ 函数，我可以使用下面的代码从 Python 中调用它。与运行纯 C++ 相比，性能只有一半。有没有办法让他们的表现达到同一水平？我用 -Ofast -march=native 标志编译这两个代码。我不明白我可以在哪里损失 50%，因为大部分时间应该花在 C++ 内核上。 Cython 是否正在制作我可以避免的内存拷贝？

namespace diff
{
    void diff_cpp(double* __restrict__ at, const double* __restrict__ a, const double visc,
                  const double dxidxi, const double dyidyi, const double dzidzi,
                  const int itot, const int jtot, const int ktot)
    {
        const int ii = 1;
        const int jj = itot;
        const int kk = itot*jtot;

        for (int k=1; k<ktot-1; k++)
            for (int j=1; j<jtot-1; j++)
                for (int i=1; i<itot-1; i++)
                {
                    const int ijk = i + j*jj + k*kk;
                    at[ijk] += visc * (
                            + ( (a[ijk+ii] - a[ijk   ]) 
                              - (a[ijk   ] - a[ijk-ii]) ) * dxidxi 
                            + ( (a[ijk+jj] - a[ijk   ]) 
                              - (a[ijk   ] - a[ijk-jj]) ) * dyidyi
                            + ( (a[ijk+kk] - a[ijk   ]) 
                              - (a[ijk   ] - a[ijk-kk]) ) * dzidzi
                            );
                }
    }
}

我有这个 .pyx 文件

# import both numpy and the Cython declarations for numpy
import cython
import numpy as np
cimport numpy as np

# declare the interface to the C code
cdef extern from "diff_cpp.cpp" namespace "diff":
    void diff_cpp(double* at, double* a, double visc, double dxidxi, double dyidyi, double dzidzi, int itot, int jtot, int ktot)

@cython.boundscheck(False)
@cython.wraparound(False)
def diff(np.ndarray[double, ndim=3, mode="c"] at not None,
         np.ndarray[double, ndim=3, mode="c"] a not None,
         double visc, double dxidxi, double dyidyi, double dzidzi):
    cdef int ktot, jtot, itot
    ktot, jtot, itot = at.shape[0], at.shape[1], at.shape[2]
    diff_cpp(&at[0,0,0], &a[0,0,0], visc, dxidxi, dyidyi, dzidzi, itot, jtot, ktot)
    return None

我在 Python 中调用这个函数

import numpy as np
import diff
import time

nloop = 20;
itot = 256;
jtot = 256;
ktot = 256;
ncells = itot*jtot*ktot;

at = np.zeros((ktot, jtot, itot))

index = np.arange(ncells)
a = (index/(index+1))**2
a.shape = (ktot, jtot, itot)

# Check results
diff.diff(at, a, 0.1, 0.1, 0.1, 0.1)
print("at={0}".format(at.flatten()[itot*jtot+itot+itot//2]))

# Time the loop
start = time.perf_counter()
for i in range(nloop):
    diff.diff(at, a, 0.1, 0.1, 0.1, 0.1)
end = time.perf_counter()

print("Time/iter: {0} s ({1} iters)".format((end-start)/nloop, nloop))

这是setup.py:

from distutils.core import setup
from distutils.extension import Extension
from Cython.Distutils import build_ext

import numpy

setup(
    cmdclass = {'build_ext': build_ext},
    ext_modules = [Extension("diff",
                             sources=["diff.pyx"],
                             language="c++",
                             extra_compile_args=["-Ofast -march=native"],
                             include_dirs=[numpy.get_include()])],
)

这里是达到两倍性能的C++引用文件:

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <stdlib.h>
#include <cstdio>
#include <ctime>
#include "math.h"

void init(double* const __restrict__ a, double* const __restrict__ at, const int ncells)
{
    for (int i=0; i<ncells; ++i)
    {
        a[i]  = pow(i,2)/pow(i+1,2);
        at[i] = 0.;
    }
}

void diff(double* const __restrict__ at, const double* const __restrict__ a, const double visc, 
          const double dxidxi, const double dyidyi, const double dzidzi, 
          const int itot, const int jtot, const int ktot)
{
    const int ii = 1;
    const int jj = itot;
    const int kk = itot*jtot;

    for (int k=1; k<ktot-1; k++)
        for (int j=1; j<jtot-1; j++)
            for (int i=1; i<itot-1; i++)
            {
                const int ijk = i + j*jj + k*kk;
                at[ijk] += visc * (
                        + ( (a[ijk+ii] - a[ijk   ]) 
                          - (a[ijk   ] - a[ijk-ii]) ) * dxidxi 
                        + ( (a[ijk+jj] - a[ijk   ]) 
                          - (a[ijk   ] - a[ijk-jj]) ) * dyidyi
                        + ( (a[ijk+kk] - a[ijk   ]) 
                          - (a[ijk   ] - a[ijk-kk]) ) * dzidzi
                        );
            }
}

int main()
{
    const int nloop = 20;
    const int itot = 256;
    const int jtot = 256;
    const int ktot = 256;
    const int ncells = itot*jtot*ktot;

    double *a  = new double[ncells];
    double *at = new double[ncells];

    init(a, at, ncells);

    // Check results
    diff(at, a, 0.1, 0.1, 0.1, 0.1, itot, jtot, ktot); 
    printf("at=%.20f\n",at[itot*jtot+itot+itot/2]);

    // Time performance 
    std::clock_t start = std::clock(); 

    for (int i=0; i<nloop; ++i)
        diff(at, a, 0.1, 0.1, 0.1, 0.1, itot, jtot, ktot); 

    double duration = (std::clock() - start ) / (double)CLOCKS_PER_SEC;

    printf("time/iter = %f s (%i iters)\n",duration/(double)nloop, nloop);

    return 0;
}

Answer 1

这里的问题不是运行时发生了什么，而是编译时发生了哪些优化。

进行哪种优化取决于编译器(甚至版本)，并且不能保证每次可以进行的优化都会进行。

实际上有两个不同的原因导致 cython 变慢，这取决于您使用的是 g++ 还是 clang++:

• 由于 cython 构建中的标志 -fwrapv，g++ 无法优化
• clang++ 一开始就无法优化(继续阅读以了解会发生什么)。

---

第一个问题 (g++):与纯 c++ 程序的标志相比，Cython 使用不同的标志进行编译，因此无法进行一些优化。

如果您查看设置日志，您将看到:

 x86_64-linux-gnu-gcc ... -O2 ..-fwrapv .. -c diff.cpp ... -Ofast -march=native

如您所说，-Ofast 将战胜 -O2，因为它排在最后。但问题是 -fwrapv，它似乎阻止了一些优化，因为有符号整数溢出不能再被视为 UB 并用于优化。

所以你有以下选择:

• 将 -fno-wrapv 添加到 extra_compile_flags，缺点是所有文件现在都使用更改的标志进行编译，这可能是不需要的。
• 从 cpp 构建一个仅包含您喜欢的标志的库，并将其链接到您的 cython 模块。这个解决方案有一些开销，但具有健壮的优点:正如您针对不同的编译器指出的，不同的 cython-flags 可能是问题所在 - 所以第一个解决方案可能太脆弱了。
• 不确定您是否可以禁用默认标志，但也许文档中有一些信息。

---

第二期 (clang++) 在测试 cpp 程序中内联。

当我用我相当老的 5.4 版本的 g++ 编译你的 cpp 程序时:

 g++ test.cpp -o test -Ofast -march=native -fwrapv

与没有 -fwrapv 的编译相比，它几乎慢了 3 倍。然而，这是优化器的一个弱点:在内联时，它应该看到，没有符号整数溢出是可能的(所有维度都是大约 256)，所以标志 -fwrapv 应该不会有任何影响。

我的旧 clang++-version (3.8) 似乎在这里做得更好:使用上面的标志我看不到任何性能下降。我需要通过 -fno-inline 禁用内联以成为较慢的代码，但即使没有 -fwrapv 也更慢，即:

 clang++ test.cpp -o test -Ofast -march=native -fno-inline

因此存在系统性偏向于支持您的 C++ 程序:优化器可以在内联后针对已知值优化代码——这是 cython 无法做到的。

因此我们可以看到:clang++ 无法优化具有任意大小的 function diff 但能够针对 size=256 对其进行优化。然而，Cython 只能使用未优化的 diff 版本。这就是为什么 -fno-wrapv 没有积极影响的原因。

我的收获:禁止在 cpp-tester 中内联感兴趣的函数(例如，将其编译到自己的目标文件中)以确保与 cython 处于同一水平，否则会看到程序的性能特别针对这一输入进行了优化。

---

注意:有趣的是，如果所有 int 都替换为 unsigned int，那么 -fwrapv 自然不会起任何作用，但是带有unsigned int的版本和int-带有-fwrapv的版本一样慢，这只是合乎逻辑的，因为有没有未定义的行为被利用。