Zaten benim için çabaya değdi, bu yüzden burada ilgilenen herkes için en zor ve en az zarif çözümü önereceğim. Benim çözümüm, C ++ 'da tek geçişli algoritmada çok iş parçacıklı bir min-maks uygulamak ve bunu bir Python genişletme modülü oluşturmak için kullanmaktır. Bu çaba, Python ve NumPy C / C ++ API'lerinin nasıl kullanılacağını öğrenmek için biraz ek yük gerektirir ve burada kodu göstereceğim ve bu yoldan gitmek isteyenler için bazı küçük açıklamalar ve referanslar vereceğim.
Çok iş parçacıklı Min / Maks
Burada çok ilginç bir şey yok. Dizi, büyüklükteki parçalara bölünmüştür length / workers
. A'daki her öbek için min / maks hesaplanır ve future
bunlar daha sonra genel min / maks için taranır.
// mt_np.cc
//
// multi-threaded min/max algorithm
#include <algorithm>
#include <future>
#include <vector>
namespace mt_np {
/*
* Get {min,max} in interval [begin,end)
*/
template <typename T> std::pair<T, T> min_max(T *begin, T *end) {
T min{*begin};
T max{*begin};
while (++begin < end) {
if (*begin < min) {
min = *begin;
continue;
} else if (*begin > max) {
max = *begin;
}
}
return {min, max};
}
/*
* get {min,max} in interval [begin,end) using #workers for concurrency
*/
template <typename T>
std::pair<T, T> min_max_mt(T *begin, T *end, int workers) {
const long int chunk_size = std::max((end - begin) / workers, 1l);
std::vector<std::future<std::pair<T, T>>> min_maxes;
// fire up the workers
while (begin < end) {
T *next = std::min(end, begin + chunk_size);
min_maxes.push_back(std::async(min_max<T>, begin, next));
begin = next;
}
// retrieve the results
auto min_max_it = min_maxes.begin();
auto v{min_max_it->get()};
T min{v.first};
T max{v.second};
while (++min_max_it != min_maxes.end()) {
v = min_max_it->get();
min = std::min(min, v.first);
max = std::max(max, v.second);
}
return {min, max};
}
}; // namespace mt_np
Python Uzantı Modülü
İşte burada işler çirkinleşmeye başlıyor ... Python'da C ++ kodunu kullanmanın bir yolu, bir uzantı modülü uygulamaktır. Bu modül, distutils.core
standart modül kullanılarak oluşturulabilir ve kurulabilir . Bunun neleri gerektirdiğinin tam bir açıklaması Python belgelerinde yer almaktadır: https://docs.python.org/3/extending/extending.html . NOT: Benzer sonuçlar elde etmenin kesinlikle başka yolları da vardır, https://docs.python.org/3/extending/index.html#extending-index :
Bu kılavuz, yalnızca CPython'un bu sürümünün bir parçası olarak sağlanan uzantıları oluşturmak için temel araçları kapsar. Cython, cffi, SWIG ve Numba gibi üçüncü taraf araçlar, Python için C ve C ++ uzantıları oluşturmak için hem daha basit hem de daha karmaşık yaklaşımlar sunar.
Esasen, bu rota muhtemelen pratikten daha akademik. Bununla birlikte, daha sonra yaptığım şey, öğreticiye oldukça yaklaşarak bir modül dosyası oluşturmaktı. Bu, esasen dağıtımcıların kodunuzla ne yapacaklarını bilmesi ve ondan bir Python modülü oluşturması için bir ortak metindir. Bunlardan herhangi birini yapmadan önce, muhtemelen bir Python sanal ortamı oluşturmak akıllıca olacaktır, böylece sistem paketlerinizi kirletmezsiniz (bkz. Https://docs.python.org/3/library/venv.html#module-venv ).
İşte modül dosyası:
// mt_np_forpy.cc
//
// C++ module implementation for multi-threaded min/max for np
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include <python3.6/numpy/arrayobject.h>
#include "mt_np.h"
#include <cstdint>
#include <iostream>
using namespace std;
/*
* check:
* shape
* stride
* data_type
* byteorder
* alignment
*/
static bool check_array(PyArrayObject *arr) {
if (PyArray_NDIM(arr) != 1) {
PyErr_SetString(PyExc_RuntimeError, "Wrong shape, require (1,n)");
return false;
}
if (PyArray_STRIDES(arr)[0] != 8) {
PyErr_SetString(PyExc_RuntimeError, "Expected stride of 8");
return false;
}
PyArray_Descr *descr = PyArray_DESCR(arr);
if (descr->type != NPY_LONGLTR && descr->type != NPY_DOUBLELTR) {
PyErr_SetString(PyExc_RuntimeError, "Wrong type, require l or d");
return false;
}
if (descr->byteorder != '=') {
PyErr_SetString(PyExc_RuntimeError, "Expected native byteorder");
return false;
}
if (descr->alignment != 8) {
cerr << "alignment: " << descr->alignment << endl;
PyErr_SetString(PyExc_RuntimeError, "Require proper alignement");
return false;
}
return true;
}
template <typename T>
static PyObject *mt_np_minmax_dispatch(PyArrayObject *arr) {
npy_intp size = PyArray_SHAPE(arr)[0];
T *begin = (T *)PyArray_DATA(arr);
auto minmax =
mt_np::min_max_mt(begin, begin + size, thread::hardware_concurrency());
return Py_BuildValue("(L,L)", minmax.first, minmax.second);
}
static PyObject *mt_np_minmax(PyObject *self, PyObject *args) {
PyArrayObject *arr;
if (!PyArg_ParseTuple(args, "O", &arr))
return NULL;
if (!check_array(arr))
return NULL;
switch (PyArray_DESCR(arr)->type) {
case NPY_LONGLTR: {
return mt_np_minmax_dispatch<int64_t>(arr);
} break;
case NPY_DOUBLELTR: {
return mt_np_minmax_dispatch<double>(arr);
} break;
default: {
PyErr_SetString(PyExc_RuntimeError, "Unknown error");
return NULL;
}
}
}
static PyObject *get_concurrency(PyObject *self, PyObject *args) {
return Py_BuildValue("I", thread::hardware_concurrency());
}
static PyMethodDef mt_np_Methods[] = {
{"mt_np_minmax", mt_np_minmax, METH_VARARGS, "multi-threaded np min/max"},
{"get_concurrency", get_concurrency, METH_VARARGS,
"retrieve thread::hardware_concurrency()"},
{NULL, NULL, 0, NULL} /* sentinel */
};
static struct PyModuleDef mt_np_module = {PyModuleDef_HEAD_INIT, "mt_np", NULL,
-1, mt_np_Methods};
PyMODINIT_FUNC PyInit_mt_np() { return PyModule_Create(&mt_np_module); }
Bu dosyada NumPy API'sinin yanı sıra Python'un da önemli bir kullanımı vardır, daha fazla bilgi için şu adrese başvurun: https://docs.python.org/3/c-api/arg.html#c.PyArg_ParseTuple ve NumPy için : https://docs.scipy.org/doc/numpy/reference/c-api.array.html .
Modülü Kurma
Yapılması gereken bir sonraki şey, modülü kurmak için dağıtımları kullanmaktır. Bu bir kurulum dosyası gerektirir:
# setup.py
from distutils.core import setup,Extension
module = Extension('mt_np', sources = ['mt_np_module.cc'])
setup (name = 'mt_np',
version = '1.0',
description = 'multi-threaded min/max for np arrays',
ext_modules = [module])
Sonunda modülü kurmak python3 setup.py install
için sanal ortamınızdan çalıştırın .
Modülü Test Etme
Son olarak, C ++ uygulamasının aslında NumPy'nin saf kullanımından daha iyi performans gösterip göstermediğini görmek için test edebiliriz. Bunu yapmak için işte basit bir test komut dosyası:
# timing.py
# compare numpy min/max vs multi-threaded min/max
import numpy as np
import mt_np
import timeit
def normal_min_max(X):
return (np.min(X),np.max(X))
print(mt_np.get_concurrency())
for ssize in np.logspace(3,8,6):
size = int(ssize)
print('********************')
print('sample size:', size)
print('********************')
samples = np.random.normal(0,50,(2,size))
for sample in samples:
print('np:', timeit.timeit('normal_min_max(sample)',
globals=globals(),number=10))
print('mt:', timeit.timeit('mt_np.mt_np_minmax(sample)',
globals=globals(),number=10))
İşte tüm bunları yapmaktan aldığım sonuçlar:
8
********************
sample size: 1000
********************
np: 0.00012079699808964506
mt: 0.002468645994667895
np: 0.00011947099847020581
mt: 0.0020772050047526136
********************
sample size: 10000
********************
np: 0.00024697799381101504
mt: 0.002037393998762127
np: 0.0002713389985729009
mt: 0.0020942929986631498
********************
sample size: 100000
********************
np: 0.0007130410012905486
mt: 0.0019842900001094677
np: 0.0007540129954577424
mt: 0.0029724110063398257
********************
sample size: 1000000
********************
np: 0.0094779249993735
mt: 0.007134920000680722
np: 0.009129883001151029
mt: 0.012836456997320056
********************
sample size: 10000000
********************
np: 0.09471094200125663
mt: 0.0453535050037317
np: 0.09436299200024223
mt: 0.04188535599678289
********************
sample size: 100000000
********************
np: 0.9537652180006262
mt: 0.3957935369980987
np: 0.9624398809974082
mt: 0.4019058070043684
Bunlar, 3.5 kat hızlanma olduğunu belirten ve çoklu iş parçacığı içermeyen, sonuçların daha önce gösterdiğinden çok daha az cesaret vericidir. Elde ettiğim sonuçlar biraz makul, iş parçacığının ek yükünün ve diziler çok geniş olana kadar geçen süreye hakim olacağını umuyorum, bu noktada performans artışı std::thread::hardware_concurrency
x artışına yaklaşmaya başlayacaktı .
Sonuç
Bazı NumPy kodlarında uygulamaya özel optimizasyonlar için kesinlikle yer vardır, öyle görünüyor ki, özellikle çoklu iş parçacığı ile ilgili olarak. Bunun çabaya değip değmeyeceği açık değil, ama kesinlikle iyi bir egzersiz (veya başka bir şey) gibi görünüyor. Sanırım Cython gibi bazı "üçüncü parti araçları" öğrenmenin zamanı daha iyi kullanabileceğini düşünüyorum, ama kim bilir.
amax
veamin