zrp | based intranet penetration tool developed in Java | FTP library

One method (which is not the fastest) but doesn't require subqueries is to use a with ties trick:

I am pradeep and one of the developers of ArrayFire.

Firstly, all ArrayFire functions(CUDA & OpenCL) backends, have some startup cost which includes device warmup and/or kernel caching(kernels are cached the first time a particular function is invoked). This is the reason, you are noticing better run times after the first run. This is also the reason, we almost always strongly recommend using our in-built timeit function to time arrayfire code as it averages out over a set of runs rather than using the first run.

As you already surmised from your experiments, it is always better to keep pinned memory allocations in a controlled way. If you are not already aware of the trade-offs involved while using pinned memory, you can start with this blog post from NVIDIA(It equally applies to pinned memory from OpenCL backend, with any vendor specific limitations of course). The general guideline as suggested in the hyperlinked post is as follows:

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.

If possible, the following is the route I would take to use pinned memory for your FFTs

1. Encapsulate pinned allocations/frees into RAII format, which you are already doing now from your edited description.
2. Do the pinned memory allocation only once if possible - if your data size is static.

Apart from these, I think your function is incorrect in couple of ways. I will go over the function in line order.

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

This call doesn't allocate memory on device/GPU. It is page-locked memory on host, RAM.

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

Since, af::pinned doesn't allocate device memory, it is not device pointer and enum is afHost. So, the call would be af::array s(signal.size(), ptr);

You are using s.write correctly by itself, but I believe it is not needed in your use case.

The following what I would do.

• Use RAII construct for the pointer returned by af::pinned and allocate it only once. Be sure you don't have too many of these page-locked allocations.
• Use the page-locked allocation as your regular host allocation instead of std::vector because this is host memory, just page-locked. This would involve writing some extra code on your host side if you are operating on std::vector in some fashion. Otherwise, you can just use the RAIIed-pinned-pointer to store your data.
• All, you need to do transfer your fft data to device is af::array s(size, ptr)

At this, the operations you would have to time are transfer from pinned-memory to GPU, the last call in above list; fft execution; copy back to host.

I have separated the same code in 2 tags, like this: