Cython 實現不比純 python 快

Question

對於一個練習，我寫了一個 XOR 雙向鏈表

%%cython

from cpython.object cimport PyObject
from cpython.ref cimport Py_XINCREF, Py_XDECREF
from libc.stdint cimport uintptr_t

cdef class Node:
    cdef uintptr_t _prev_xor_next
    cdef object val

    def __init__(self, object val, uintptr_t prev_xor_next=0):
        self._prev_xor_next=prev_xor_next
        self.val=val

    @property
    def prev_xor_next(self):
        return self._prev_xor_next
    @prev_xor_next.setter
    def prev_xor_next(self, uintptr_t p):
        self._prev_xor_next=p

    def __repr__(self):
        return str(self.val)


cdef class CurrentNode(Node):
    cdef uintptr_t _node, _prev_ptr
    def __init__(self, uintptr_t node, uintptr_t prev_ptr=0):
        self._node = node
        self._prev_ptr= prev_ptr

    @property
    def val(self):
        return self.node.val
    @property
    def node(self):
        ret=<PyObject *> self._node
        return <Node> ret
    @property
    def prev_ptr(self):
        return self._prev_ptr

    cdef CurrentNode forward(self):
        if self.node.prev_xor_next!=self._prev_ptr:
            return CurrentNode(self.node.prev_xor_next^self._prev_ptr, self._node)

    cdef CurrentNode backward(self):
        if self._prev_ptr:
            pp=<PyObject*>self._prev_ptr
            return CurrentNode(self._prev_ptr, self._node^(<Node> pp).prev_xor_next)

    def __repr__(self):
        return str(self.node)

cdef class XORList:
    cdef PyObject* first
    cdef PyObject* last
    cdef int length

    def __init__(self):
        self.length=0
    @property
    def head(self):
        return (<Node> self.first)

    @property
    def tail(self):
        return (<Node> self.last)

    cdef append(self, object val):
        self.length+=1
        #empty list
        if not self.first:
            t=Node(val)
            tp=(<PyObject*> t)
            self.first=tp
            Py_XINCREF(tp)
            self.last=tp
            Py_XINCREF(tp)

        #not empty
        else:
            new_node=Node(val, <uintptr_t> self.last)
            new_ptr=<PyObject*> new_node
            cur_last=<Node>self.last
            cur_last.prev_xor_next=cur_last.prev_xor_next^(<uintptr_t> new_ptr)
            Py_XINCREF(new_ptr)
            self.last=new_ptr
            Py_XINCREF(new_ptr)

    cpdef reverse(self):
        temp=self.last
        self.last=self.first
        self.first=temp

    def __repr__(self):
        return str(list(iter_XORList(self)))
    def __len__(self):
        return self.length

def iter_XORList(l):
    head=<PyObject*>l.head
    cur=CurrentNode(<uintptr_t> head)
    while cur:
        yield cur
        cur=cur.forward()

import time

start=time.time()
cdef XORList l=XORList()
for i in range(100000):
    l.append(i)
print('time xor ', time.time()-start)

start=time.time()
l1=[]
for i in range(100000):
    l1.append(i)
print('time regular ', time.time()-start)

使用上面的內置列表，我在 cython 鏈表上的性能總是差 10 倍左右。

time xor  0.10768294334411621
time regular  0.010972023010253906

當我分析 xorlist 的循環時，我得到：

         700003 function calls in 1.184 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    1.184    1.184 <string>:1(<module>)
        1    0.039    0.039    1.184    1.184 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:108(list_check)
   100000    0.025    0.000    0.025    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:11(__init__)
    99999    0.019    0.000    0.019    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:16(__get__)
    99999    0.018    0.000    0.018    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:19(__set__)
        1    0.000    0.000    0.000    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:60(__init__)
   100000    0.937    0.000    0.999    0.000 _cython_magic_14cf45d2116440f3df600718d58e4f95.pyx:70(append)
   100000    0.113    0.000    1.146    0.000 line_profiler.py:111(wrapper)
        1    0.000    0.000    1.184    1.184 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
   100000    0.018    0.000    0.018    0.000 {method 'disable_by_count' of '_line_profiler.LineProfiler' objects}
   100000    0.015    0.000    0.015    0.000 {method 'enable_by_count' of '_line_profiler.LineProfiler' objects}

因此，忽略對append的調用，似乎大部分時間都花在了特殊方法上。

這讓我想到了我的問題：

1. 我怎樣才能加快速度
2. 我認為 Cython 中的擴展類型是通過結構在下面實現的，所以是什么導致它們的初始化需要這么長時間

我還在純 python 中嘗試了另一種普通雙向鏈表的自定義實現，它和 cython xorlist 的時序在我的機器上相似，相差 10%。

Answer 1

分析中的三個罪魁禍首看起來是 Node 的__init__ （這在這里是不可避免的），以及__get__屬性的prev_xor_next和__set__ 。 我的觀點是你不想要prev_xor_next屬性（或者如果你這樣做，它應該是只讀的），因為它使 Python 中的 Cython 內部可以訪問。

無論您是否刪除該屬性，您都在 Cython 中工作，因此您可以直接寫入底層 C 屬性_prev_xor_next 。 您可能需要在 append 的開頭設置cdef Node cur_last append也許在其他函數中）以確保 Cython 知道cur_last的類型 - 我認為它應該能夠解決它但是如果你在運行時得到AttributeErrors那么這是你需要做什么。

這種變化使我的速度提高了 30%（即它仍然比常規列表慢，但這是一個顯着的改進）。

---

我將概述一個更劇烈的變化，我可能應該就你關於這個問題的第一個問題提出建議。 這確實是一個模糊的輪廓，所以沒有努力讓它發揮作用......

• Node完全在您的XORList class 內部：它不應該在 Python 中使用，並且XORList中所有Nodes的生命周期直接與列表相關聯。 因此，它們應該在銷毀它們擁有的XORList時被銷毀（或者如果列表縮小等），因此不需要進行引用計數。 因此Node應該是 C 結構而不是 Python object：

   cdef struct Node: uintptr_t prev_xor_next PyObject* val # with associated constructor- and destructor-like functions: cdef Node* make_node(object val, uintptr_t prev_xor_next): cdef Node* n = <Node*>malloc(sizeof(Node)) n.val = <PyObject*>val Py_XINCREF(n.val) n.prev_xor_next = prev_xor_next return n cdef void destroy_node(Node* n): Py_XDECREF(n.val) free(n)

• XORList需要一個__dealloc__ function 循環遍歷每個Node上調用destroy_node的列表（它也需要一個__dealloc__ function 在您的版本中！）

• CurrentNode需要保留 Cython class，因為這是您的“迭代器”接口。 它顯然不能再從Node繼承。 我將其更改為：

   cdef class XORListIterator: cdef Node* current_node cdef XORList our_list

  our_list屬性的重點是確保XORList至少與CurrentNode一樣長 - 如果您最終得到一個不再存在的XORList的迭代器，則current_node屬性將無效。 current_node不屬於XORListIterator ，因此不需要析構函數。

我認為這種方案的危險在於確保如果對XORList的任何更改都不會完全使任何現有的XORListIterators失效，那么就會導致崩潰。 我懷疑這也是您當前版本的問題。

---

我懷疑內置list仍將保持競爭力，因為它是一個編寫良好、高效的結構。 請記住， list.append通常是一個簡單的Py_INCREF ，偶爾會重新分配和復制數組。 你的總是涉及創建一個新的 Python object （ Node ）以及一些相關的引用計數。

我的替代方案避免了很多引用計數（在計算時間和“你必須考慮它”的時間方面），所以我希望它更接近。 它保留了每個append分配一個小的 memory 的缺點，這對於鏈表結構是不可避免的。

---

附錄：解決關於“Cython 類的便利性”的評論。 在我看來，使用 Cython class 與結構的兩個優點是：

1. 你得到的東西相當接近結構，但不必擔心 C 指針，並且引用計數得到了處理。 很明顯，對於這個問題，你對指針做了奇怪的事情，並且必須明確地處理引用計數，所以我認為這不適用於你。
2. 您可以從 Python 使用它 - 您不僅限於 Cython。 在這種情況下，我認為這完全是XORList的實現細節，不應該暴露給 Python 用戶。

因此，我認為使用 Cython 類的主要原因不適用於您的問題。 （當然，對於很多代碼來說，優勢確實適用！）

可能還值得補充的是，構建 Cython 類可能是它們速度較慢的特性之一——為了支持可能的 inheritance，構建過程相當“間接”。 您已經設法創建了一個幾乎所有構建的基准 - 我猜它是一個稍微傾斜的基准，實際情況可能沒有那么糟糕。