Быстрый расчет логарифма - программирование

Весь код был запущен на том же компьютере в Linux.

В python:

import numpy as np
drr = abs(np.random.randn(100000,50))
%timeit np.log2(drr)

10 петель, лучше всего 3: 77,9 мс за цикл

В С++ (скомпилировано с g++ -o log./log.cpp -std = С++ 11 -O3):

#include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>
#include <ctime>
int main()
{
std::mt19937 e2(0);
std::normal_distribution<> dist(0, 1);
const int n_seq = 100000;
const int l_seq = 50;
static double x[n_seq][l_seq];
for (int n = 0;n < n_seq; ++n) {
  for (int k = 0; k < l_seq; ++k) {
    x[n][k] = abs(dist(e2));
    if(x[n][k] <= 0)
      x[n][k] = 0.1;
    }
  }
 clock_t begin = clock();

 for (int n = 0; n < n_seq; ++n) {
   for (int k = 0; k < l_seq; ++k) {
     x[n][k] = std::log2(x[n][k]);
       }
  }
  clock_t end = clock();

Работает через 60 мс

В MATLAB:

abr = abs(randn(100000,50));
tic;abr=log2(abr);toc

Истекшее время составляет 7,8 мс.

Я могу понять разницу в скорости между С++ и numpy, но MATLAB превосходит все. Я столкнулся http://fastapprox.googlecode.com/svn/trunk/fastapprox/src/fastonebigheader.h но это только float, а не double, и я не уверен, как преобразовать его в double.

Я также пробовал: http://hackage.haskell.org/package/approximate-0.2.2.1/src/cbits/fast.c который имеет быстрые функции журнала, а когда скомпилирован как numpy ufunc, работает в 20 мс, что отлично, но потеря точности является значительной.

Любые идеи о том, как достичь магической скорости log2, которую получает MATLAB?

UPDATE

Спасибо всем за комментарии, это было очень быстро и очень полезно! В самом деле, ответ - это параллелизация, т.е. Распространение нагрузки на несколько потоков. Следуя предложению @morningsun,

% timeit numexpr.evaluate('log (drr)')

дает 5.6 мс, что наравне с MATLAB, спасибо! numexpr включен MKL

#include <math.h> #include "omp.h" #include "mkl_vml.h" #define restrict __restrict inline void log_omp(int m, float * restrict a, float * restrict c); void log_omp(int m, float * restrict a, float * restrict c) { int i; #pragma omp parallel for default(none) shared(m,a,c) private(i) for (i=0; i<m; i++) { a[i] = log(c[i]); } } // VML / icc only: void log_VML(int m, float * restrict a, float * restrict c) { int i; int split_to = 14; int iter = m / split_to; int additional = m % split_to; // vsLn(m, c, a); #pragma omp parallel for default(none) shared(m,a,c, additional, iter) private(i) num_threads(split_to) for (i=0;i < (m-additional); i+=iter) vsLog10(iter,c+i,a+i); //vmsLn(iter,c+i,a+i, VML_HA); if (additional > 0) vsLog10(additional, c+m-additional, a+m-additional); //vmsLn(additional, c+m-additional, a+m-additional, VML_HA); }

from ctypes import CDLL, c_int, c_void_p def log_omp(xs, out): lib = CDLL('./log_omp.so') lib.log_omp.argtypes = [c_int, np.ctypeslib.ndpointer(dtype=np.float32), np.ctypeslib.ndpointer(dtype=np.float32)] lib.log_omp.restype = c_void_p n = xs.shape[0] out = np.empty(n, np.float32) lib.log_omp(n, out, xs) return out

%%cython --compile-args=-fopenmp --link-args=-fopenmp import numpy as np cimport numpy as np from libc.math cimport log from cython.parallel cimport prange import cython @cython.boundscheck(False) def cylog(np.ndarray[np.float32_t, ndim=1] a not None, np.ndarray[np.float32_t, ndim=1] out=None): if out is None: out = np.empty((a.shape[0]), dtype=a.dtype) cdef Py_ssize_t i with nogil: for i in prange(a.shape[0]): out[i] = log(a[i]) return out

numexpr.detect_number_of_cores() // 2 28 %env OMP_NUM_THREADS=28 x = np.abs(np.random.randn(50000000).astype('float32')) y = x.copy() # GCC %timeit log_omp(x, y) 10 loops, best of 3: 21.6 ms per loop # ICC %timeit log_omp(x, y) 100 loops, best of 3: 9.6 ms per loop %timeit log_VML(x, y) 100 loops, best of 3: 10 ms per loop %timeit cylog(x, out=y) 10 loops, best of 3: 21.7 ms per loop numexpr.set_num_threads(28) %timeit out = numexpr.evaluate('log(x)') 100 loops, best of 3: 13 ms per loop

Ответ 1