Как: CUDA IFFT

При вычислении ifft с MATLAB поведение по умолчанию выглядит следующим образом:

• Нет заполнения нулями входного сигнала
• Нет масштабирования выходного сигнала

Ваш код CUFFT корректен в потоке, но немного другие параметры по сравнению с MATLAB вызывают текущий вывод.

• NX постоянная, чтобы быть конкретной вызывает входной сигнал, чтобы быть
  дополняется нулями до длины 256. Для достижения поведения MATLAB сохраняйте NX равно SIGNAL_SIZE,
• CUFFT умножает значения выходного сигнала на длину входного сигнала. Вы должны разделить выходные значения с SIGNAL_SIZE чтобы получить фактические значения.
• Другая важная проблема заключается в том, что вы выполняете внешний доступ во время инициализации входного сигнала. Длина сигнала равна 10, но вы инициализируете значение с 10-го индекса, который находится за пределами. Я предполагаю, что это может быть связано с путаницей, вызванной индексированием MATLAB на основе 1. Входной сигнал должен быть инициализирован с 0 в SIGNAL_SIZE-1 только индексы.
• Не рекомендуется визуализировать сигнал с использованием ядра CUDA, поскольку печать может быть не в порядке. Вы должны скопировать результаты обратно на хост и распечатать их серийно.

Вот фиксированный код, который обеспечивает тот же вывод, что и MATLAB.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <cuda_runtime.h>
#include <cufft.h>
#include "device_launch_parameters.h"#include "device_functions.h"
#define NX 10
#define NY 1
#define NRANK 1
#define BATCH 1
#define SIGNAL_SIZE 10

typedef float2 Complex;

int main()
{
cufftHandle plan;
//int n[NRANK] = { NX, NY };
Complex *h_signal = (Complex *)malloc(sizeof(Complex)* SIGNAL_SIZE);
float *r_signal = 0;
if (r_signal != 0)
{
r_signal = (float*)realloc(r_signal, SIGNAL_SIZE * sizeof(float));
}
else
{
r_signal = (float*)malloc(SIGNAL_SIZE * sizeof(float));
}
int mem_size = sizeof(Complex)* SIGNAL_SIZE;

h_signal[0].x = (float)4.65;
h_signal[0].y = (float)0;

h_signal[1].x = (float)0.5964;
h_signal[1].y = (float)-1.4325;

h_signal[2].x = (float)0.4905;
h_signal[2].y = (float)-0.5637;

h_signal[3].x = (float)0.4286;
h_signal[3].y = (float)-0.2976;

h_signal[4].x = (float)0.4345;
h_signal[4].y = (float)-0.1512;

h_signal[5].x = (float)0.45;
h_signal[5].y = (float)0.0;

h_signal[6].x = (float)0.4345;
h_signal[6].y = (float)0.1512;

h_signal[7].x = (float)0.4286;
h_signal[7].y = (float)0.2976;

h_signal[8].x = (float)0.4905;
h_signal[8].y = (float)0.5637;

h_signal[9].x = (float)0.5964;
h_signal[9].y = (float)1.4325;

printf("\nInput:\n");
for(int i=0; i<SIGNAL_SIZE; i++)
{
char op = h_signal[i].y < 0 ? '-' : '+';
printf("%f %c %fi\n", h_signal[i].x/SIGNAL_SIZE, op, fabsf(h_signal[i].y/SIGNAL_SIZE ) );
}

//allocate device memory for signal
cufftComplex *d_signal, *d_signal_out;
cudaMalloc(&d_signal, mem_size);
cudaMalloc(&d_signal_out, mem_size);
cudaMemcpy(d_signal, h_signal, mem_size, cudaMemcpyHostToDevice);//cufftPlan1d(&plan, SIGNAL_SIZE, CUFFT_C2R, BATCH);
cufftPlan1d(&plan, NX, CUFFT_C2C, BATCH);

cufftExecC2C(plan, d_signal, d_signal_out, CUFFT_INVERSE);

cudaDeviceSynchronize();

cudaMemcpy(h_signal, d_signal_out, SIGNAL_SIZE*sizeof(Complex), cudaMemcpyDeviceToHost);printf("\n\n-------------------------------\n\n");
printf("Output:\n");
for(int i=0; i<SIGNAL_SIZE; i++)
{
char op = h_signal[i].y < 0 ? '-' : '+';
printf("%f %c %fi\n", h_signal[i].x/SIGNAL_SIZE, op, fabsf(h_signal[i].y/SIGNAL_SIZE ) );
}

cufftDestroy(plan);
cudaFree(d_signal);
cudaFree(d_signal_out);

return 0;
}

Результат все еще находится в сложной форме, но мнимые компоненты близки к нулю. Кроме того, разница в точности реального компонента заключается в том, что MATLAB по умолчанию использует двойную точность, в то время как этот код основан на значениях одинарной точности.

Скомпилировано и протестировано с помощью следующей команды в Ubuntu 14.04, CUDA 8.0:

nvcc -o ifft ifft.cu -arch = sm_61 -lcufft

По сравнению с MATLAB 2017a.

Input:
0.465000 + 0.000000i
0.059640 - 0.143250i
0.049050 - 0.056370i
0.042860 - 0.029760i
0.043450 - 0.015120i
0.045000 + 0.000000i
0.043450 + 0.015120i
0.042860 + 0.029760i
0.049050 + 0.056370i
0.059640 + 0.143250i-------------------------------

Output:
0.900000 - 0.000000i
0.800026 - 0.000000i
0.699999 - 0.000000i
0.599964 - 0.000000i
0.500011 + 0.000000i
0.400000 + 0.000000i
0.299990 + 0.000000i
0.199993 + 0.000000i
0.150000 + 0.000000i
0.100018 - 0.000000i