我正在嘗試找到使用 Numba 對 2 個相同大小的矩陣求和的最快方法。我想出了 3 種不同的方法，但沒有一個能打敗 Numpy。這是我的代碼：
import numpy as np
from numba import njit,vectorize, prange,float64
import timeit
import time
# function 1:
def sum_numpy(A,B):
return A B
# function 2:
sum_numba_simple= njit(cache=True,fastmath=True) (sum_numpy)
# function 3:
@vectorize([float64(float64, float64)])
def sum_numba_vectorized(A,B):
return A B
# function 4:
@njit('(float64[:,:],float64[:,:])', cache=True, fastmath=True, parallel=True)
def sum_numba_loop(A,B):
n=A.shape[0]
m=A.shape[1]
C = np.empty((n, m), A.dtype)
for i in prange(n):
for j in prange(m):
C[i,j]=A[i,j] B[i,j]
return C
#Test the functions with 2 matrices of size 1,000,000x3:
N=1000000
np.random.seed(123)
A=np.random.uniform(low=-10, high=10, size=(N,3))
B=np.random.uniform(low=-5, high=5, size=(N,3))
t1=min(timeit.repeat(stmt='sum_numpy(A,B)',timer=time.perf_counter,repeat=3, number=100,globals=globals()))
t2=min(timeit.repeat(stmt='sum_numba_simple(A,B)',timer=time.perf_counter,repeat=3, number=100,globals=globals()))
t3=min(timeit.repeat(stmt='sum_numba_vectorized(A,B)',timer=time.perf_counter,repeat=3, number=100,globals=globals()))
t4=min(timeit.repeat(stmt='sum_numba_loop(A,B)',timer=time.perf_counter,repeat=3, number=100,globals=globals()))
print("function 1 (sum_numpy): t1= ",t1,"\n")
print("function 2 (sum_numba_simple): t2= ",t2,"\n")
print("function 3 (sum_numba_vectorized): t3= ",t3,"\n")
print("function 4 (sum_numba_loop): t4= ",t4,"\n")
結果如下：
函式 1 (sum_numpy): t1= 0.1655790419999903
函式 2 (sum_numba_simple): t2= 0.3019776669998464
函式 3 (sum_numba_vectorized): t3= 0.16486266700030683
函式 4 (sum_numba_loop): t4= 0.1862256660001549
如您所見，結果表明在這種情況下使用 Numba 沒有任何優勢。因此，我的問題是：
是否有任何其他實作可以提高求和速度？
uj5u.com熱心網友回復：
您的代碼受頁面錯誤的約束（有關此內容的更多資訊，請參見此處、此處和此處）。發生頁面錯誤是因為陣列是新分配的。一種解決方案是預先分配它，然后在其中寫入，這樣就不會導致頁面在物理記憶體中重新映射。np.add(A, B, out=C)按照@August 在評論中的指示執行此操作。另一種解決方案可能是調整標準分配器，以便不以顯著的記憶體使用開銷為代價將記憶體歸還給作業系統（例如，AFAIK TC-Malloc 可以做到這一點）。
大多數平臺（尤其是 x86 平臺）還有另一個問題：寫回高速快取的高速快取行寫入分配在寫入期間非常昂貴。避免這種情況的典型解決方案是進行非臨時存盤（如果在目標處理器上可用，x86-64 就是這種情況，但可能不是其他處理器）。話雖如此，Numpy 和 Numba 都無法做到這一點。對于 Numba，我填寫了一個問題涵蓋一個簡單的用例。編譯器本身（針對 Numpy 的 GCC 和針對 Numba 的 Clang）往往不會生成這樣的指令，因為當陣列適合快取并且編譯器在編譯時不知道陣列的大小時，它們可能會損害性能（它們可能會在編譯時生成特定代碼）他們可以評估計算的資料量，但這并不容易，并且會減慢一些其他代碼的速度）。AFAIK，解決此問題的唯一可能方法是撰寫 C 代碼并使用低級指令或使用編譯器指令。在您的情況下，由于這種影響，大約 25% 的帶寬會丟失，導致速度下降高達 33%。
使用多個執行緒并不總是讓記憶體系結代碼更快。事實上，它通常幾乎無法擴展，因為在 RAM 已經飽和時使用更多內核不會加快執行速度。通常需要很少的內核，以便在大多數平臺上使 RAM 飽和。頁面錯誤可以從使用目標系統的多個內核中受益（Linux 在并行方面做得很好，Windows 通常不能很好地擴展，IDK 用于 MacOS）。
最后，還有另一個問題：代碼沒有向量化（至少在我的機器上沒有，但它可以）。解決方案是展平陣列視圖并執行一個大回圈，編譯器可以更輕松地對其進行矢量化（基于 j 的回圈太小，SIMD 指令無法生效）。還應為編譯器指定輸入陣列的連續性以生成快速 SIMD 代碼。這是生成的 Numba 代碼：
@njit('(float64[:,::1], float64[:,::1], float64[:,::1])', cache=True, fastmath=True, parallel=True)
def sum_numba_fast_loop(A, B, C):
n, m = A.shape
assert C.shape == A.shape
A_flat = A.reshape(n*m)
B_flat = B.reshape(n*m)
C_flat = C.reshape(n*m)
for i in prange(n*m):
C_flat[i]=A_flat[i] B_flat[i]
return C
以下是我的 6 核 i5-9600KF 處理器和 ~42 GiB/s RAM 的結果：
sum_numpy: 0.642 s 13.9 GiB/s
sum_numba_simple: 0.851 s 10.5 GiB/s
sum_numba_vectorized: 0.639 s 14.0 GiB/s
sum_numba_loop serial: 0.759 s 11.8 GiB/s
sum_numba_loop parallel: 0.472 s 18.9 GiB/s
Numpy "np.add(A, B, out=C)": 0.281 s 31.8 GiB/s <----
Numba fast: 0.288 s 31.0 GiB/s <----
Optimal time: 0.209 s 32.0 GiB/s
Numba 代碼和 Numpy 代碼使我的 RAM 飽和。使用更多內核并沒有幫助（事實上，由于記憶體控制器的爭用，它確實會慢一些）。兩者都是次優的，因為它們不使用可以防止快取行寫入分配的非臨時存盤指令（導致在寫回之前從 RAM 中獲取資料）。最佳時間是使用此類指令的預期時間。請注意，由于 RAM 混合讀/寫，預計它只能達到 RAM 帶寬的 65-80%。實際上，交錯讀取和寫入會導致低級開銷，從而防止 RAM 飽和。有關 RAM 作業原理的更多資訊，請考慮閱讀高性能科學計算簡介——第 1.3 章和每個程式員應該了解的關于記憶體的知識（可能還有這個）。
轉載請註明出處，本文鏈接：https://www.uj5u.com/qiye/513766.html
標籤：多线程麻木的表现时间麻木
上一篇：核心程式中的執行緒鎖混淆