Смешайте два изображения с помощью графического процессора

Судя по вашей функции Blend, это операция, полностью ограниченная памятью. Кэши на ЦП, вероятно, могут хранить только очень небольшую часть из тысяч изображений, которые у вас есть. Это означает, что большая часть вашего времени тратится на ожидание, пока ОЗУ выполнит запросы на загрузку/сохранение, а ЦП будет много простаивать.

Вы НЕ получите никакого ускорения, если вам придется копировать ваши изображения из ОЗУ в графический процессор, заставлять арифметические блоки графического процессора простаивать, пока они ждут, пока ОЗУ графического процессора передаст им данные, ждать, пока ОЗУ графического процессора снова записывает результаты, а затем копировать все это обратно в основной ОЗУ. Использование GPU для этого может существенно замедлить работу.

Но я могу ошибаться, и вы, возможно, еще не насыщаете свою шину памяти. Вам придется попробовать его в своей системе и профилировать. Вот несколько простых вещей, которые вы можете попытаться оптимизировать.

1. Многопоточность

Я бы сосредоточился на оптимизации алгоритма непосредственно на процессоре. Самое простое — использовать многопоточность, для чего достаточно включить OpenMP в компиляторе и обновить цикл for:

#include <omp.h> // add this along with enabling OpenMP support in your compiler
...
#pragma omp parallel for // <--- compiler magic happens here
for (int i=0 ; i< _frameSize ; i++) 
{
    source[i] = _apply(blend[i]);
}

Если пропускная способность вашей памяти не перегружена, это, скорее всего, ускорит смешивание, сколько бы ядер ни было в вашей системе.

2. Микрооптимизации

Еще одна вещь, которую вы можете попробовать, это реализовать Blend с помощью SIMD-инструкций, которые в настоящее время есть в большинстве процессоров. Я не могу помочь вам с этим, не зная, на какой процессор вы ориентируетесь.

Вы также можете попробовать развернуть цикл for, чтобы уменьшить некоторые накладные расходы цикла.

Одним из простых способов добиться того и другого является использование библиотеки собственных матриц, обернув ваш данные в своих структурах данных.

// initialize your data and result buffer
byte *source = ...
byte *blend = ...
byte *result = ...

// tell Eigen where you data/buffer are, and to treat it like a dynamic vectory of bytes
// this is a cheap shallow copy
Map<Matrix<byte, Dynamic,1> > sourceMap(source, _frameSize);
Map<Matrix<byte, Dynamic,1> > blendMap(blend, _frameSize);
Map<Matrix<byte, Dynamic,1> > resultMap(result, _frameSize);

// perform blend using all manner of insane optimization voodoo under the covers
resultMap = (sourceMap + blendMap)/2;

3. Используйте графический процессор

Наконец, я дам прямой ответ на ваш вопрос с простым способом использования графического процессора без особых знаний о программировании графического процессора. Проще всего попробовать библиотеку Thrust. Вам придется переписать свои алгоритмы как алгоритмы в стиле STL, но в вашем случае это довольно просто.

// functor for blending
struct blend_functor
{
  template <typename Tuple>
  __host__ __device__
  void operator()(Tuple t)
  {
    // C[i] = (A[i] + B[i])/2;
    thrust::get<2>(t) = (thrust::get<0>(t) + thrust::get<1>(t))/2;
  }
};

// initialize your data and result buffer
byte *source = ...
byte *blend = ...
byte *result = NULL;

// copy the data to the vectors on the GPU
thrust::device_vector<byte> A(source, source + _frameSize);
thrust::device_vector<byte> B(blend, blend + _frameSize);
// allocate result vector on the GPU
thrust::device_vector<byte> C(_frameSize);

// process the data on the GPU device
thrust::for_each(thrust::make_zip_iterator(thrust::make_tuple(
                                  A.begin(), B.begin(), C.begin())),
                 thrust::make_zip_iterator(thrust::make_tuple(
                                  A.end(), B.end(), C.end())),
                 blend_functor());

// copy the data back to main RAM
thrust::host_vector<byte> resultVec = C;
result = resultVec.data();

Отличительной особенностью тяги является то, что после того, как вы написали алгоритмы в общем виде, они могут автоматически использовать разные концы для выполнения вычислений. CUDA — это серверная часть по умолчанию, но вы также можете настроить ее во время компиляции для использования OpenMP или TBB (библиотека потоков Intel).