c++ - 如何在 ArrayFire 中正确使用固定内存？

Question

在 ArrayFire 中使用固定内存时，性能变慢。

我已经尝试了各种创建固定内存和从中创建数组的方法，例如。 cudaMallocHost。使用带 cudaMemcpy 的 cudaMallocHost 方式非常快(几百 usec。)，但随后创建/初始化 arrayfire 数组非常慢(~ 2-3 秒)。最后我想出了下面的方法，分配需要大约 2-3 秒，但它可以移动到别处。使用主机数据初始化阵列是令人满意的(100 - 200 微秒)，但现在操作(在本例中为 FFT)非常慢:~ 400 毫秒。我应该补充说输入信号的大小是可变的，但对于时间我使用了 64K 样本(复数 double )。另外，为了简洁起见，我没有提供我的计时功能，但这不是问题，我已经使用其他方法计时并且结果是一致的。

// Use the Frequency-Smoothing method to calculate the full 
// Spectral Correlation Density
// currently the whole function takes ~ 2555 msec. w/ signal 64K samples
// and window_length = 400 (currently not implemented)
void exhaustive_fsm(std::vector<std::complex<double>> signal, uint16_t window_length) {

  // Allocate pinned memory (eventually move outside function)
  // 2192 ms.
  af::af_cdouble* device_ptr = af::pinned<af::af_cdouble>(signal.size());

  // Init arrayfire array (eventually move outside function)
  // 188 us.
  af::array s(signal.size(), device_ptr, afDevice);

  // Copy to device
  // 289 us.
  s.write((af::af_cdouble*) signal.data(), signal.size() * sizeof(std::complex<double>), afHost);

  // FFT
  // 351 ms. equivalent to:
  // af::array fft = af::fft(s, signal.size());
  af::array fft = zrp::timeit(&af::fft, s, signal.size());
  fft.eval();

  // Convolution

  // Copy result to host

  // free memory (eventually move outside function)
  // 0 ms.
  af::freePinned((void*) s.device<af::af_cdouble>());

  // Return result
}

正如我在上面所说的，FFT 大约需要 400 毫秒。这个使用 Armadillo 的函数需要大约 110 毫秒。包括卷积在内，使用 FFTW 的 FFT 大约需要 5 毫秒。同样在我的机器上使用 ArrayFire FFT 示例我得到以下结果(修改为使用 c64)

            A             = randu(1, N, c64);)

基准 1-by-N CX fft

   1 x  128:                    time:     29 us.
   1 x  256:                    time:     31 us.
   1 x  512:                    time:     33 us.
   1 x 1024:                    time:     41 us.
   1 x 2048:                    time:     53 us.
   1 x 4096:                    time:     75 us.
   1 x 8192:                    time:    109 us.
   1 x 16384:                   time:    179 us.
   1 x 32768:                   time:    328 us.
   1 x 65536:                   time:    626 us.
   1 x 131072:                  time:   1227 us.
   1 x 262144:                  time:   2423 us.
   1 x 524288:                  time:   4813 us.
   1 x 1048576:                 time:   9590 us.

所以我能看到的唯一区别是固定内存的使用。知道我哪里出错了吗？谢谢。

编辑

我注意到在运行 AF FFT 示例时，在第一次打印之前有一个明显的延迟(即使该时间不包括此延迟)。所以我决定制作一个类并将所有分配/取消分配移动到 ctor/dtor 中。出于好奇，我还在 ctor 中放置了一个 FFT，因为我还注意到如果我运行第二个 FFT，它需要大约 600 微秒。与我的基准一致。果然运行“初步”FFT 似乎“初始化”了某些东西，随后的 FFT 运行得更快。必须有更好的方法，我一定遗漏了一些东西。

Answer 1

我是 pradeep，是 ArrayFire 的开发者之一。

首先，所有 ArrayFire 函数(CUDA 和 OpenCL)后端都有一些启动成本，包括设备预热和/或内核缓存(内核在第一次调用特定函数时被缓存)。这就是您注意到第一次运行后运行时间更好的原因。这也是原因，我们几乎总是强烈推荐使用我们的 in-built timeit函数对 arrayfire 代码进行计时，因为它对一组运行进行平均，而不是使用第一次运行。

正如您已经从实验中推测的那样，以受控方式保持固定内存分配总是更好。如果您还不知道使用固定内存时所涉及的权衡取舍，您可以从 this blog post 开始。来自 NVIDIA(它同样适用于来自 OpenCL 后端的固定内存，当然有任何供应商特定的限制)。超链接帖子中建议的一般准则如下:

You should not over-allocate pinned memory. Doing so can reduce overall system performance because it reduces the amount of physical memory available to the operating system and other programs. How much is too much is difficult to tell in advance, so as with all optimizations, test your applications and the systems they run on for optimal performance parameters.

如果可能，以下是我为您的 FFT 使用固定内存的路线

1. 将固定的分配/释放封装成 RAII 格式，您现在已经根据编辑的描述执行此操作。
2. 如果可能，只进行一次固定内存分配 - 如果您的数据大小是静态的。

除此之外，我认为您的函数在几个方面不正确。我将按行顺序介绍该功能。

af::af_cdouble* device_ptr = af::pinned(signal.size());

此调用不会在设备/GPU 上分配内存。它是主机上的页面锁定内存，RAM。

af::array s(signal.size(), device_ptr, afDevice);

因为 af::pinned 不分配设备内存，所以它不是设备指针，枚举是 afHost。因此，调用将是 af::array s(signal.size(), ptr);

您正在使用 s.write本身正确，但我相信您的用例不需要它。

下面是我会做的。

• 对 af::pinned 返回的指针使用 RAII 构造并且只分配一次。确保您没有太多此类页面锁定分配。
• 使用页面锁定分配作为常规主机分配而不是 std::vector<complex>因为这是主机内存，只是页面锁定。如果您在 std::vector 上运行，这将涉及在您的主机端编写一些额外的代码。以某种方式。否则，您可以只使用 RAIIed-pinned-pointer 来存储您的数据。
• 全部，您需要将您的 fft 数据传输到设备是 af::array s(size, ptr)

此时，您需要执行的操作是从固定内存传输到 GPU，这是上面列表中的最后一个调用； fft执行；复制回主机。