7

我在 Cython 中使用了很多 3D 内存视图，例如

cython.declare(a='double[:, :, ::1]')
a = np.empty((10, 20, 30), dtype='double')

我经常想遍历a. 我可以使用三重循环来做到这一点

for i in range(a.shape[0]):
    for j in range(a.shape[1]):
        for k in range(a.shape[2]):
            a[i, j, k] = ...

如果我不关心索引i,j和k，则执行平面循环会更有效，例如

cython.declare(a_ptr='double*')
a_ptr = cython.address(a[0, 0, 0])
for i in range(size):
    a_ptr[i] = ...

在这里，我需要知道size数组中元素 ( ) 的数量。这是由属性中元素的乘积给出的shape，即size = a.shape[0]*a.shape[1]*a.shape[2]，或更一般地size = np.prod(np.asarray(a).shape)。我发现这两个都很难写，而且（尽管很小）的计算开销让我很困扰。这样做的好方法是使用sizememoryviews 的内置属性，size = a.size. 但是，由于我无法理解的原因，这会导致 C 代码未优化，这从 Cython 生成的注释 html 文件中可以明显看出。具体来说，生成的C代码size = a.shape[0]*a.shape[1]*a.shape[2]简直就是

__pyx_v_size = (((__pyx_v_a.shape[0]) * (__pyx_v_a.shape[1])) * (__pyx_v_a.shape[2]));

其中生成的 C 代码size = a.size是

__pyx_t_10 = __pyx_memoryview_fromslice(__pyx_v_a, 3, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2238, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_size); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2238, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_7 = __Pyx_PyIndex_AsSsize_t(__pyx_t_14); if (unlikely((__pyx_t_7 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2238, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__pyx_v_size = __pyx_t_7;

为了生成上述代码，我通过编译器指令启用了所有可能的优化，这意味着无法优化生成的笨重的 C 代码a.size。在我看来，size“属性”并不是真正的预先计算的属性，而是在查找时实际执行计算。此外，这种计算比简单地用乘积代替shape属性要复杂得多。我在文档中找不到任何解释的提示。

a.shape[0]*a.shape[1]*a.shape[2]这种行为的解释是什么，如果我真的关心这个微优化，我有比写出更好的选择吗？

4

2 回答 2

6

通过查看生成的 C 代码，您已经可以看到这size是一个属性，而不是一个简单的 C 成员。这是内存视图的原始 Cython 代码：

@cname('__pyx_memoryview')
cdef class memoryview(object):
...
   cdef object _size
...
    @property
    def size(self):
        if self._size is None:
            result = 1

            for length in self.view.shape[:self.view.ndim]:
                result *= length

            self._size = result

return self._size

很容易看出，产品只计算一次，然后被缓存。显然它对 3 维数组没有太大的作用，但是对于更多的维度，缓存可能变得非常重要（正如我们将看到的，最多有 8 个维度，所以它不是很清楚，无论这种缓存真的很值得）。

人们可以理解懒惰地计算的决定size- 毕竟，size并不总是需要/使用并且不想为此付费。显然，如果你使用size很多，这种懒惰是要付出代价的——这就是 cython 所做的权衡。

我不会在调用的开销上停留太久a.size——与从 python 调用 cython 函数的开销相比，这算不了什么。

例如，@danny 的测量只测量这个 python 调用开销，而不是不同方法的实际性能。为了展示这一点，我将第三个函数加入其中：

%%cython
...
def both():
    a.size+a.shape[0]*a.shape[1]*a.shape[2]

它做了双倍的工作，但是

>>> %timeit mv_size
22.5 ns ± 0.0864 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

>>> %timeit mv_product
20.7 ns ± 0.087 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

>>>%timeit both
21 ns ± 0.39 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

一样快。另一方面：

%%cython
...
def nothing():
   pass

不是更快：

%timeit nothing
24.3 ns ± 0.854 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

简而言之：我会a.size因为可读性而使用，假设优化不会加速我的应用程序，除非分析证明有所不同。

整个故事：变量a是类型的__Pyx_memviewslice，而不是__pyx_memoryview人们想象的类型。该结构__Pyx_memviewslice具有以下定义：

struct __pyx_memoryview_obj;
typedef struct {
  struct __pyx_memoryview_obj *memview;
  char *data;
  Py_ssize_t shape[8];
  Py_ssize_t strides[8];
  Py_ssize_t suboffsets[8];
} __Pyx_memviewslice;

这意味着，shape可以通过 Cython 代码非常有效地访问，因为它是一个简单的 C 数组（顺便说一句。我问我自己，如果有超过 8 个维度会发生什么？ - 答案是：你不能超过8 个维度）。

成员memview是内存所在的位置，__pyx_memoryview_obj是 C-Extension，它由我们在上面看到的 cython 代码生成，如下所示：

/* "View.MemoryView":328
 * 
 * @cname('__pyx_memoryview')
 * cdef class memoryview(object):             # <<<<<<<<<<<<<<
 * 
 *     cdef object obj
 */
struct __pyx_memoryview_obj {
  PyObject_HEAD
  struct __pyx_vtabstruct_memoryview *__pyx_vtab;
  PyObject *obj;
  PyObject *_size;
  PyObject *_array_interface;
  PyThread_type_lock lock;
  __pyx_atomic_int acquisition_count[2];
  __pyx_atomic_int *acquisition_count_aligned_p;
  Py_buffer view;
  int flags;
  int dtype_is_object;
  __Pyx_TypeInfo *typeinfo;
};

所以，Pyx_memviewslice它并不是一个真正的 Python 对象——它是一种方便的包装器，它缓存重要的数据，shape所以stride可以快速而廉价地访问这些信息。

当我们打电话时会发生什么a.size？首先，__pyx_memoryview_fromslice被调用它做一些额外的引用计数和一些进一步的东西，并memview从__Pyx_memviewslice-object 返回成员。

然后size在这个返回的 memoryview 上调用该属性，它访问缓存的值，_size如上面的 Cython 代码所示。

看起来，python 程序员似乎为shape,strides和等重要信息引入了快捷方式suboffsets，但没有为size可能不那么重要的shape.

于 2018-04-19T16:30:05.943 回答
2

生成的 C 代码a.size看起来不错。

它必须与 Python 交互，因为内存视图是 Python 扩展类型。size在内存视图上是一个 python 属性并被转换为ssize_t. 这就是 C 代码所做的一切。可以通过键入size变量 asPy_ssize_t而不是来避免转换ssize_t。

因此，C 代码中没有任何看起来未经优化的东西——它只是在 python 对象上查找一个属性，在这种情况下是在内存视图上查找大小。

以下是这两种方法的微基准测试结果。

设置：

cimport numpy as np
import numpy as np
cimport cython
cython.declare(a='double[:, :, ::1]')
a = np.empty((10, 20, 30), dtype='double')

def mv_size():
    return a.size
def mv_product():
    return a.shape[0]*a.shape[1]*a.shape[2]

结果：

%timeit mv_size
10000000 loops, best of 3: 23.4 ns per loop

%timeit mv_product
10000000 loops, best of 3: 23.4 ns per loop

性能几乎相同。

product 方法是纯 C 代码，如果它需要并行执行，这很重要，但在其他方面与 memory view 相比没有性能优势size。

于 2018-04-19T13:44:41.973 回答