建议为类型化的内存视图分配内存的方法是什么？

70

有关类型化内存视图的Cython文档列出了分配给类型化内存视图的三种方式：

  1. 从原始的C指针，
  2. 从一个 np.ndarray和
  3. 从cython.view.array。

假设我没有从外部将数据传递到cython函数中，而是想分配内存并将其返回为np.ndarray，那么我选择了哪些选项？还假设该缓冲区的大小不是编译时常量，即我无法在堆栈上分配，但需要malloc为选项1。

因此，这三个选项看起来像这样：

from libc.stdlib cimport malloc, free
cimport numpy as np
from cython cimport view

np.import_array()

def memview_malloc(int N):
    cdef int * m = <int *>malloc(N * sizeof(int))
    cdef int[::1] b = <int[:N]>m
    free(<void *>m)

def memview_ndarray(int N):
    cdef int[::1] b = np.empty(N, dtype=np.int32)

def memview_cyarray(int N):
    cdef int[::1] b = view.array(shape=(N,), itemsize=sizeof(int), format="i")

让我惊讶的是，在所有这三种情况下，Cython都会为内存分配生成大量代码，尤其是对的调用__Pyx_PyObject_to_MemoryviewSlice_dc_int。这表明（我可能错了，我对Cython内部工作的了解非常有限）它首先创建了一个Python对象，然后将其“投射”到内存视图中，这似乎是不必要的开销。

一个简单的基准测试并不能揭示这三种方法之间的太大差异，其中2.是最快的，而且差距很小。

建议使用三种方法中的哪一种？还是有其他更好的选择？

后续问题：np.ndarray在函数中使用该内存视图后，我想最终将结果返回为。类型化的内存视图是最佳选择，还是我宁愿只使用如下所示的旧缓冲区接口来创建一个ndarray？

cdef np.ndarray[DTYPE_t, ndim=1] b = np.empty(N, dtype=np.int32)
python  memory  memory-management  buffer  cython 
— 基南
source
2
很好的问题，我想知道类似的事情。
— AlexE
您的基准测试是我所知道的最佳答案。要回答后续问题，您只需以通常的方式声明您的NumPy数组（您甚至不必使用旧的类型接口），然后执行类似的操作cdef int[:] arrview = arr以获取用于NumPy数组的相同内存的视图。您可以使用该视图进行快速索引并在Cython函数之间传递切片，同时仍然可以通过NumPy数组访问NumPy函数。完成后，您可以返回NumPy数组。
— 2013年
这里有一个很好的相关问题...在这里您可以看到np.empty可能很慢...
— Saullo GP Castro

Answers:

77

看看这里的回答。

基本思想是您想要cpython.array.array和cpython.array.clone（不是 cython.array.*）：

from cpython.array cimport array, clone

# This type is what you want and can be cast to things of
# the "double[:]" syntax, so no problems there
cdef array[double] armv, templatemv

templatemv = array('d')

# This is fast
armv = clone(templatemv, L, False)

编辑

事实证明，该线程中的基准是垃圾。这是我的设定，以及我的时间安排：

# cython: language_level=3
# cython: boundscheck=False
# cython: wraparound=False

import time
import sys

from cpython.array cimport array, clone
from cython.view cimport array as cvarray
from libc.stdlib cimport malloc, free
import numpy as numpy
cimport numpy as numpy

cdef int loops

def timefunc(name):
    def timedecorator(f):
        cdef int L, i

        print("Running", name)
        for L in [1, 10, 100, 1000, 10000, 100000, 1000000]:
            start = time.clock()
            f(L)
            end = time.clock()
            print(format((end-start) / loops * 1e6, "2f"), end=" ")
            sys.stdout.flush()

        print("μs")
    return timedecorator

print()
print("INITIALISATIONS")
loops = 100000

@timefunc("cpython.array buffer")
def _(int L):
    cdef int i
    cdef array[double] arr, template = array('d')

    for i in range(loops):
        arr = clone(template, L, False)

    # Prevents dead code elimination
    str(arr[0])

@timefunc("cpython.array memoryview")
def _(int L):
    cdef int i
    cdef double[::1] arr
    cdef array template = array('d')

    for i in range(loops):
        arr = clone(template, L, False)

    # Prevents dead code elimination
    str(arr[0])

@timefunc("cpython.array raw C type")
def _(int L):
    cdef int i
    cdef array arr, template = array('d')

    for i in range(loops):
        arr = clone(template, L, False)

    # Prevents dead code elimination
    str(arr[0])

@timefunc("numpy.empty_like memoryview")
def _(int L):
    cdef int i
    cdef double[::1] arr
    template = numpy.empty((L,), dtype='double')

    for i in range(loops):
        arr = numpy.empty_like(template)

    # Prevents dead code elimination
    str(arr[0])

@timefunc("malloc")
def _(int L):
    cdef int i
    cdef double* arrptr

    for i in range(loops):
        arrptr = <double*> malloc(sizeof(double) * L)
        free(arrptr)

    # Prevents dead code elimination
    str(arrptr[0])

@timefunc("malloc memoryview")
def _(int L):
    cdef int i
    cdef double* arrptr
    cdef double[::1] arr

    for i in range(loops):
        arrptr = <double*> malloc(sizeof(double) * L)
        arr = <double[:L]>arrptr
        free(arrptr)

    # Prevents dead code elimination
    str(arr[0])

@timefunc("cvarray memoryview")
def _(int L):
    cdef int i
    cdef double[::1] arr

    for i in range(loops):
        arr = cvarray((L,),sizeof(double),'d')

    # Prevents dead code elimination
    str(arr[0])



print()
print("ITERATING")
loops = 1000

@timefunc("cpython.array buffer")
def _(int L):
    cdef int i
    cdef array[double] arr = clone(array('d'), L, False)

    cdef double d
    for i in range(loops):
        for i in range(L):
            d = arr[i]

    # Prevents dead-code elimination
    str(d)

@timefunc("cpython.array memoryview")
def _(int L):
    cdef int i
    cdef double[::1] arr = clone(array('d'), L, False)

    cdef double d
    for i in range(loops):
        for i in range(L):
            d = arr[i]

    # Prevents dead-code elimination
    str(d)

@timefunc("cpython.array raw C type")
def _(int L):
    cdef int i
    cdef array arr = clone(array('d'), L, False)

    cdef double d
    for i in range(loops):
        for i in range(L):
            d = arr[i]

    # Prevents dead-code elimination
    str(d)

@timefunc("numpy.empty_like memoryview")
def _(int L):
    cdef int i
    cdef double[::1] arr = numpy.empty((L,), dtype='double')

    cdef double d
    for i in range(loops):
        for i in range(L):
            d = arr[i]

    # Prevents dead-code elimination
    str(d)

@timefunc("malloc")
def _(int L):
    cdef int i
    cdef double* arrptr = <double*> malloc(sizeof(double) * L)

    cdef double d
    for i in range(loops):
        for i in range(L):
            d = arrptr[i]

    free(arrptr)

    # Prevents dead-code elimination
    str(d)

@timefunc("malloc memoryview")
def _(int L):
    cdef int i
    cdef double* arrptr = <double*> malloc(sizeof(double) * L)
    cdef double[::1] arr = <double[:L]>arrptr

    cdef double d
    for i in range(loops):
        for i in range(L):
            d = arr[i]

    free(arrptr)

    # Prevents dead-code elimination
    str(d)

@timefunc("cvarray memoryview")
def _(int L):
    cdef int i
    cdef double[::1] arr = cvarray((L,),sizeof(double),'d')

    cdef double d
    for i in range(loops):
        for i in range(L):
            d = arr[i]

    # Prevents dead-code elimination
    str(d)

输出：

INITIALISATIONS
Running cpython.array buffer
0.100040 0.097140 0.133110 0.121820 0.131630 0.108420 0.112160 μs
Running cpython.array memoryview
0.339480 0.333240 0.378790 0.445720 0.449800 0.414280 0.414060 μs
Running cpython.array raw C type
0.048270 0.049250 0.069770 0.074140 0.076300 0.060980 0.060270 μs
Running numpy.empty_like memoryview
1.006200 1.012160 1.128540 1.212350 1.250270 1.235710 1.241050 μs
Running malloc
0.021850 0.022430 0.037240 0.046260 0.039570 0.043690 0.030720 μs
Running malloc memoryview
1.640200 1.648000 1.681310 1.769610 1.755540 1.804950 1.758150 μs
Running cvarray memoryview
1.332330 1.353910 1.358160 1.481150 1.517690 1.485600 1.490790 μs

ITERATING
Running cpython.array buffer
0.010000 0.027000 0.091000 0.669000 6.314000 64.389000 635.171000 μs
Running cpython.array memoryview
0.013000 0.015000 0.058000 0.354000 3.186000 33.062000 338.300000 μs
Running cpython.array raw C type
0.014000 0.146000 0.979000 9.501000 94.160000 916.073000 9287.079000 μs
Running numpy.empty_like memoryview
0.042000 0.020000 0.057000 0.352000 3.193000 34.474000 333.089000 μs
Running malloc
0.002000 0.004000 0.064000 0.367000 3.599000 32.712000 323.858000 μs
Running malloc memoryview
0.019000 0.032000 0.070000 0.356000 3.194000 32.100000 327.929000 μs
Running cvarray memoryview
0.014000 0.026000 0.063000 0.351000 3.209000 32.013000 327.890000 μs

（之所以使用“迭代”基准，是因为某些方法在这方面具有令人惊讶的不同特征。）

按照初始化速度的顺序：

malloc：这是一个严酷的世界，但是很快。如果您需要分配很多东西并且具有不受阻碍的迭代和索引性能，那就必须如此。但是通常来说，您是一个不错的选择。

cpython.array raw C type：该死，很快。而且很安全。不幸的是，它通过Python来访问其数据字段。您可以使用一个绝妙的技巧来避免这种情况：

arr.data.as_doubles[i]

从而在确保安全的同时将其提升到标准速度！这使得它成为了一个绝佳的替代品malloc，基本上是一个参考计数很高的版本！

cpython.array buffer：进入的时间只有的三到四倍malloc，这似乎是一个不错的选择。不幸的是，它具有大量的开销（尽管与boundscheckandwraparound指令相比很小）。这意味着它只能与完全安全的变体竞争，但这是初始化速度最快的。你的选择。

cpython.array memoryview：这比malloc初始化要慢一个数量级。太可惜了，但是迭代的速度一样快。这是我建议的标准解决方案，除非boundscheck或wraparound启用（在这种情况下cpython.array buffer可能是更引人注目的折衷）。

其余的部分。numpy由于对象具有许多有趣的方法，因此唯一有价值的东西是。就是这样。

— 维德拉克
source
感谢您进行的全面调查并提供数字备份！
— kynan 2014年
2
好答案！我是否认为只有纯粹的malloc解决方案才能完全规避获得GIL的需要，对吗？我对在并行工作线程中分配多维数组的方法感兴趣。
— ali_m 2014年
试试看，然后回报！
— Veedrac'3
人们似乎确实发现这很有用。我看看是否可以添加它。
— Veedrac
1
cpython.array在已经描述docs.cython.org/src/tutorial/array.html的代码应改为包括“arr.data.as_doubles [I]”特技为“原始C类”基准，因为如果没有该索引绝对不是原始的（当前的索引可以称为'plain cpython.array'索引，但这不是一个有趣的数据点）。
— Andreas
9

作为Veedrac的回答的后续行动：请注意，使用python 2.7的memoryview支持cpython.array似乎会导致当前内存泄漏。这是一个长期存在的问题，在cython用户邮件列表中（从2012年11月开始）中已提及。使用Vethrac的基准脚本在Cython 0.22版中同时使用Python 2.7.6和Python 2.7.9会导致cpython.array使用buffer或memoryview接口初始化a时，大内存泄漏。使用Python 3.4运行脚本时，不会发生内存泄漏。我已经向Cython开发人员邮件列表提交了一个错误报告。

— 马特·格雷厄姆
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.