Bug aneh di Panda dan Numpy tentang multithreading

Sebagian besar fungsi Numpy akan mengaktifkan multithreading secara default.

misalnya, saya bekerja pada workstation intel cpu 8-core, jika saya menjalankan skrip

import numpy as np    
x=np.random.random(1000000)
for i in range(100000):
    np.sqrt(x)

linux topakan menunjukkan 800% penggunaan CPU selama menjalankan seperti Yang berarti numpy secara otomatis mendeteksi bahwa workstation saya memiliki 8 core, dan np.sqrtsecara otomatis menggunakan semua 8 core untuk mempercepat perhitungan.

Namun, saya menemukan bug aneh. Jika saya menjalankan skrip

import numpy as np
import pandas as pd
df=pd.DataFrame(np.random.random((10,10)))
df+df
x=np.random.random(1000000)
for i in range(100000):
    np.sqrt(x)

penggunaan cpu adalah 100% !!. Ini berarti bahwa jika Anda ditambah dua panda DataFrame sebelum menjalankan fungsi numpy, fitur multithreading otomatis numpy hilang tanpa peringatan! Ini sama sekali tidak masuk akal, mengapa perhitungan dataFrame Pandas memengaruhi pengaturan threading Numpy? Apakah ini bug? Bagaimana cara mengatasinya?

PS:

Saya menggali lebih jauh menggunakan perfalat Linux .

menjalankan tampilan skrip pertama

Saat menjalankan skrip kedua menunjukkan

Jadi kedua skrip melibatkan libmkl_vml_avx2.so, sedangkan skrip pertama melibatkan tambahan libiomp5.soyang tampaknya terkait dengan openMP.

Dan karena vml berarti perpustakaan vektor vektor intel, jadi menurut vml doc saya kira setidaknya fungsi di bawah ini semuanya otomatis multithreaded

Panda menggunakan di numexprbawah tenda untuk menghitung beberapa operasi, dan numexprmenetapkan jumlah maksimal utas untuk vml ke 1, saat diimpor :

# The default for VML is 1 thread (see #39)
set_vml_num_threads(1)

dan itu diimpor oleh panda saat df+dfdievaluasi dalam expressions.py :

from pandas.core.computation.check import _NUMEXPR_INSTALLED

if _NUMEXPR_INSTALLED:
   import numexpr as ne

Namun, distribusi Anaconda juga menggunakan vml-fungsi untuk fungsi-fungsi seperti sqrt, sin, cosdan sebagainya - dan sekali numexprmengatur jumlah maksimal vml-benang ke 1, numpy-fungsi tidak lagi digunakan paralelisasi.

Masalahnya dapat dengan mudah dilihat di gdb (menggunakan skrip lambat Anda):

>>> gdb --args python slow.py
(gdb) b mkl_serv_domain_set_num_threads
function "mkl_serv_domain_set_num_threads" not defined.
Make breakpoint pending on future shared library load? (y or [n]) y
Breakpoint 1 (mkl_serv_domain_set_num_threads) pending.
(gbd) run
Thread 1 "python" hit Breakpoint 1, 0x00007fffee65cd70 in mkl_serv_domain_set_num_threads () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_thread.so
(gdb) bt 
#0  0x00007fffee65cd70 in mkl_serv_domain_set_num_threads () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_thread.so
#1  0x00007fffe978026c in _set_vml_num_threads(_object*, _object*) () from /home/ed/anaconda37/lib/python3.7/site-packages/numexpr/interpreter.cpython-37m-x86_64-linux-gnu.so
#2  0x00005555556cd660 in _PyMethodDef_RawFastCallKeywords () at /tmp/build/80754af9/python_1553721932202/work/Objects/call.c:694
...
(gdb) print $rdi
$1 = 1

yaitu kita bisa melihat, numexprmengatur jumlah utas ke 1. Yang kemudian digunakan ketika fungsi vml-sqrt disebut:

(gbd) b mkl_serv_domain_get_max_threads
Breakpoint 2 at 0x7fffee65a900
(gdb) (gdb) c
Continuing.

Thread 1 "python" hit Breakpoint 2, 0x00007fffee65a900 in mkl_serv_domain_get_max_threads () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_thread.so
(gdb) bt
#0  0x00007fffee65a900 in mkl_serv_domain_get_max_threads () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_thread.so
#1  0x00007ffff01fcea9 in mkl_vml_serv_threader_d_1i_1o () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_thread.so
#2  0x00007fffedf78563 in vdSqrt () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_lp64.so
#3  0x00007ffff5ac04ac in trivial_two_operand_loop () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/core/_multiarray_umath.cpython-37m-x86_64-linux-gnu.so

Jadi kita bisa melihat implementasi nml menggunakan nml vdSqrtyang digunakan mkl_vml_serv_threader_d_1i_1ountuk memutuskan apakah perhitungan harus dilakukan secara paralel dan terlihat jumlah utas:

(gdb) fin
Run till exit from #0  0x00007fffee65a900 in mkl_serv_domain_get_max_threads () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_thread.so
0x00007ffff01fcea9 in mkl_vml_serv_threader_d_1i_1o () from /home/ed/anaconda37/lib/python3.7/site-packages/numpy/../../../libmkl_intel_thread.so
(gdb) print $rax
$2 = 1

register %raxmemiliki jumlah utas maksimal dan 1.

Sekarang kita bisa menggunakan numexpruntuk menambah jumlah vml-threads , yaitu:

import numpy as np
import numexpr as ne
import pandas as pd
df=pd.DataFrame(np.random.random((10,10)))
df+df

#HERE: reset number of vml-threads
ne.set_vml_num_threads(8)

x=np.random.random(1000000)
for i in range(10000):
    np.sqrt(x)     # now in parallel

Sekarang banyak core digunakan!

Melihat numpy, sepertinya, di bawah tenda itu memiliki masalah on / off dengan multithreading, dan tergantung pada versi apa yang Anda gunakan, Anda mungkin akan mulai melihat crash ketika Anda bertemu ne.set_vml_num_threads () ..

http://numpy-discussion.10968.n7.nabble.com/ANN-NumExpr-2-7-0-Release-td47414.html

Saya perlu mencari tahu bagaimana ini terpaku pada interpreter python, memberikan contoh kode Anda di mana tampaknya entah bagaimana memungkinkan beberapa panggilan yang tampaknya sinkron / dipesan ke np.sqrt () untuk melanjutkan secara paralel. Saya kira jika interpreter python selalu hanya mengembalikan referensi ke objek ketika muncul tumpukan, dan dalam contoh Anda hanya melempar referensi tersebut dan tidak menetapkan atau memanipulasi mereka dengan cara apa pun itu akan baik-baik saja. Tetapi jika iterasi loop berikutnya tergantung pada yang sebelumnya maka tampaknya kurang jelas bagaimana ini dapat diparalelkan dengan aman. Kegagalan diam-diam / hasil yang salah adalah hasil yang lebih buruk daripada crash.

Saya pikir premis awal Anda mungkin salah -

Anda menyatakan: Yang berarti numpy secara otomatis mendeteksi bahwa workstation saya memiliki 8 core, dan np.sqrt secara otomatis menggunakan semua 8 core untuk mempercepat perhitungan.

Satu fungsi np.sqrt () tidak dapat menebak bagaimana selanjutnya akan dipanggil atau kembali sebelum sebagian selesai. Ada mekanisme paralelisme dalam python, tetapi tidak ada yang otomatis.

Sekarang, setelah mengatakan itu, interpreter python mungkin dapat mengoptimalkan loop for untuk paralelisme, yang mungkin apa yang Anda lihat, tapi saya sangat curiga jika Anda melihat waktu jam dinding untuk menjalankan loop ini tidak akan ada berbeda terlepas jika Anda (tampaknya) menggunakan 8 core atau 1 core.

UPDATE: Setelah membaca sedikit lebih banyak komentar, sepertinya perilaku multi-core yang Anda lihat terkait dengan distribusi anaconda dari interpreter python. Saya melihat tetapi tidak dapat menemukan kode sumber untuk itu, tetapi tampaknya lisensi python mengizinkan entitas (seperti anaconda.com) untuk mengkompilasi dan mendistribusikan turunan dari juru bahasa tanpa mengharuskan perubahan mereka untuk dipublikasikan.

Saya kira Anda dapat menjangkau orang-orang anaconda - perilaku yang Anda lihat akan sulit untuk dipecahkan tanpa mengetahui apa / jika ada sesuatu yang telah mereka ubah pada penerjemah.

Juga lakukan pemeriksaan cepat dari waktu jam dinding dengan / tanpa optimasi untuk melihat apakah memang 8x lebih cepat - bahkan jika Anda benar-benar memiliki semua 8 core bekerja, bukan 1 akan lebih baik untuk mengetahui apakah hasilnya benar-benar 8x lebih cepat atau jika ada spinlocks yang digunakan yang masih bersambung pada satu mutex.