以cufftPlanMany爲例FFT變換中embed,stride,dist的解釋與設置

原創 holyprince 2019-09-09 21:29

關於FFT的自定義數據分佈進行變換，之前每次都是用的寫demo，這次搞明白之後記錄一下，以便以後查閱。

比如需要對一個二維數組裏的每一行或者每一列進行傅里葉變換，那麼需要對cufftPlanMany進行設置，然後進行批量處理。

cufftPlanMany的函數聲明如下

cufftResult cufftPlanMany(cufftHandle *plan, int rank, int *n, int *inembed,
int istride, int idist, int *onembed, int ostride,int odist, cufftType type, int batch);

比如對於一個10*5的二維數組，想對每一行進行FFT：

NX=10；NY=5；

rank=1，表明是進行一維傅里葉變換；

n[1]，數組n維度與rank相同，表明每一維的變換數目，本例中n只有一維，n[0]=NX，表示一維傅里葉變換需要10個元素；

inembed[2]，表明原始輸入數據的維度，本例中輸入數據是一個二維數組，所以inembed維度爲2，inembed[0]=NX, inembed[1]=NY;

istride，表明在一個傅里葉變換內部每一個元素相距的距離，本例中 istride=1；

idist，表明在兩個傅里葉變換之間，每一個元素相距的距離，本例中 isist=NX;

batch 表明多少個獨立的傅里葉變換，本例中 batch=NY

本例中我們進行C2C的傅里葉變換，所以輸入和輸出格式一樣。實現代碼如下:

#include <stdlib.h>
#include <stdio.h>

#include <string.h>
#include <math.h>
#include "timer.h"

#include <cuda_runtime.h>
#include <cufft.h>
#include "device_launch_parameters.h"
#define Ndim 2
#define NX 10
#define NY 5


void testplanmany() {

	int N[2];
	N[0] = NX, N[1] = NY;
	int NXY = N[0] * N[1];
	cufftComplex *input = (cufftComplex*) malloc(NXY * sizeof(cufftComplex));
	cufftComplex *output = (cufftComplex*) malloc(NXY * sizeof(cufftComplex));
	int i;
	for (i = 0; i < NXY; i++) {
		input[i].x = i % 1000;
		input[i].y = 0;
	}
	cufftComplex *d_inputData, *d_outData;
	cudaMalloc((void**) &d_inputData, N[0] * N[1] * sizeof(cufftComplex));
	cudaMalloc((void**) &d_outData, N[0] * N[1] * sizeof(cufftComplex));
	cudaMemcpy(d_inputData, input, N[0] * N[1] * sizeof(cufftComplex), cudaMemcpyHostToDevice);
	cufftHandle plan;
	/*
	cufftMakePlanMany(cufftHandle plan, int rank, int *n, int *inembed,
	int istride, int idist, int *onembed, int ostride,
	int odist, cufftType type, int batch, size_t *workSize);
	 */
	int rank=1;
	int n[1];
	n[0]=NX;
	int istride=1;
	int idist = NX;
	int ostride=1;
	int odist = NX;
	int inembed[2];
	int onembed[2];
	inembed[0]=NX;  onembed[0]=NX;
	inembed[1] = NY; onembed[0] = NY;

	cufftPlanMany(&plan,rank,n,inembed, istride ,idist , onembed, ostride,odist, CUFFT_C2C, NY);
	cufftExecC2C(plan, d_inputData, d_outData, CUFFT_FORWARD);
	cudaMemcpy(output, d_outData, NXY * sizeof(cufftComplex), cudaMemcpyDeviceToHost);

	for (i = 0; i < NXY; i++) {
		if(i%NX==0)
			printf("\n");
		printf("%f %f \n", output[i].x, output[i].y);
	}

	cufftDestroy(plan);
	free(input);
	free(output);
	cudaFree(d_inputData);
	cudaFree(d_outData);
}

int main() {

	testplanmany();
}

實際輸出如下：

45.000000 0.000000 
-5.000000 15.388418 
-5.000000 6.881910 
-5.000000 3.632713 
-5.000000 1.624598 
-5.000000 0.000000 
-5.000000 -1.624598 
-5.000000 -3.632713 
-5.000000 -6.881910 
-5.000000 -15.388418 

145.000000 0.000000 
-5.000000 15.388418 
-5.000000 6.881910 
-5.000000 3.632713 
-5.000000 1.624598 
-5.000000 0.000000 
-5.000000 -1.624598 
-5.000000 -3.632713 
-5.000000 -6.881910 
-5.000000 -15.388418 

245.000000 0.000000 
-4.999997 15.388416 
-5.000000 6.881910 
-5.000000 3.632713 
-5.000000 1.624597 
-5.000000 0.000000 
-5.000000 -1.624597 
-5.000000 -3.632713 
-5.000000 -6.881910 
-4.999997 -15.388416 

345.000000 0.000000 
-4.999998 15.388418 
-4.999999 6.881909 
-4.999999 3.632712 
-5.000000 1.624598 
-5.000000 0.000000 
-5.000000 -1.624598 
-4.999999 -3.632712 
-4.999999 -6.881909 
-4.999998 -15.388418 

445.000000 0.000000 
-4.999999 15.388418 
-5.000001 6.881911 
-5.000000 3.632714 
-5.000000 1.624598 
-5.000000 0.000000 
-5.000000 -1.624598 
-5.000000 -3.632714 
-5.000001 -6.881911 
-4.999999 -15.388418

 

對於上述數據每一列進行一次FFT來說：

NX=10；NY=5；

rank=1，表明是進行一維傅里葉變換；

n[1]，數組n維度與rank相同，表明每一維的變換數目，本例中n只有一維，n[0]=NY，表示一維傅里葉變換需要5個元素；

inembed[2]，表明原始輸入數據的維度，本例中輸入數據是一個二維數組，所以inembed維度爲2，inembed[0]=NX, inembed[1]=NY;

istride，表明在一個傅里葉變換內部每一個元素相距的距離，本例中 istride= NX；

idist，表明在兩個傅里葉變換之間，每一個元素相距的距離，本例中 isist=1; （因爲兩列傅里葉變換第一個元素相鄰）

batch 表明多少個獨立的傅里葉變換，本例中 batch=NX

代碼如下：

#include <stdlib.h>
#include <stdio.h>

#include <string.h>
#include <math.h>
#include "timer.h"

#include <cuda_runtime.h>
#include <cufft.h>
#include "device_launch_parameters.h"
#define Ndim 2
#define NX 10
#define NY 5


void testplanmany() {

	int N[2];
	N[0] = NX, N[1] = NY;
	int NXY = N[0] * N[1];
	cufftComplex *input = (cufftComplex*) malloc(NXY * sizeof(cufftComplex));
	cufftComplex *output = (cufftComplex*) malloc(NXY * sizeof(cufftComplex));
	int i;
	for (i = 0; i < NXY; i++) {
		input[i].x = i % 1000;
		input[i].y = 0;
	}
	cufftComplex *d_inputData, *d_outData;
	cudaMalloc((void**) &d_inputData, N[0] * N[1] * sizeof(cufftComplex));
	cudaMalloc((void**) &d_outData, N[0] * N[1] * sizeof(cufftComplex));
	cudaMemcpy(d_inputData, input, N[0] * N[1] * sizeof(cufftComplex), cudaMemcpyHostToDevice);
	cufftHandle plan;
	/*
	cufftMakePlanMany(cufftHandle plan, int rank, int *n, int *inembed,
	int istride, int idist, int *onembed, int ostride,
	int odist, cufftType type, int batch, size_t *workSize);
	 */
	int rank=1;
	int n[1];
	n[0]=NY;
	int istride=NX;
	int idist = 1;
	int ostride=NX;
	int odist = 1;
	int inembed[2];
	int onembed[2];
	inembed[0]=NX;  onembed[0]=NX;
	inembed[1] = NY; onembed[0] = NY;

	cufftPlanMany(&plan,rank,n,inembed, istride ,idist , onembed, ostride,odist, CUFFT_C2C, NX);
	cufftExecC2C(plan, d_inputData, d_outData, CUFFT_FORWARD);
	cudaMemcpy(output, d_outData, NXY * sizeof(cufftComplex), cudaMemcpyDeviceToHost);

	for (i = 0; i < NXY; i++) {
		if(i%NX==0)
			printf("\n");
		printf("%f %f \n", output[i].x, output[i].y);
	}

	cufftDestroy(plan);
	free(input);
	free(output);
	cudaFree(d_inputData);
	cudaFree(d_outData);
}

int main() {

	testplanmany();
}

結果如下：


100.000000 0.000000 
105.000000 0.000000 
110.000000 0.000000 
115.000000 0.000000 
120.000000 0.000000 
125.000000 0.000000 
130.000000 0.000000 
135.000000 0.000000 
140.000000 0.000000 
145.000000 0.000000 

-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 
-25.000000 34.409550 

-25.000002 8.122991 
-25.000002 8.122991 
-24.999998 8.122991 
-24.999998 8.122991 
-24.999998 8.122991 
-25.000000 8.122991 
-25.000000 8.122991 
-25.000000 8.122991 
-25.000000 8.122991 
-25.000000 8.122991 

-25.000002 -8.122991 
-25.000002 -8.122991 
-24.999998 -8.122991 
-24.999998 -8.122991 
-24.999998 -8.122991 
-25.000000 -8.122991 
-25.000000 -8.122991 
-25.000000 -8.122991 
-25.000000 -8.122991 
-25.000000 -8.122991 

-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550 
-25.000000 -34.409550

另外文章參考了這個資源：

https://rocfft.readthedocs.io/en/latest/real.html#setting-strides

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

高性能計算亂七八糟之術語篇

線程池 簡單來說就是有一堆已經創建好的線程（最大數目一定），初始時他們都處於空閒狀態，當有新的任務進來，從線程池中取出一個空閒的線程處理任務，然後當任務處理完成之後，該線程被重新放回到線程池中，供其他的任務使用，當線程池中的線程都

BaldStrong 2020-06-24 12:02:08

Windows下unzip解壓縮遇到的warning: xxx appears to use backslashes as path separators

IBM Spectrum Symphony是基於SOA架構的分佈式計算框架，它能在自由伸縮的共享集羣中，爲計算密集型和數據密集型的應用提供強大的企業級管理。 Symphony有一個配置是這樣的，在應用的profile裏頭，有個方法是Reg

飞鸿踏雪Ben归来 2020-07-07 03:51:57

strong scaling and weak scaling

1，scalability 在高性能計算（或並行計算）中，scalability是用來衡量當計算資源增加時，我們的硬件和軟件利用計算資源的能力。 2，speedup speedup=t1/tNt_1/t_Nt1​/tN​，t1t_

JasonKQLin 2020-06-30 15:57:13

高性能與並行計算領域一些期刊與會議及資料閱讀列表

IEEE transactions on parallel and distributed systems (TPDS) 主頁：https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumbe

holyprince 2020-06-27 13:04:15

Liunx下HPCC(HPC Challenge)的安裝運行

安裝運行步驟 下載安裝mpich 或者其他MPI實現應該也行，參考網上相關教程，已安裝則可以忽略這一步。 下載安裝blas wget http://www.netlib.org/blas/blas.tgz tar zxvf

祈晴小义 2020-06-24 16:56:14

LSF使用

bhosts：查看LSF計算節點列表 bqueues：查看LSF所有隊列的整體信息，查看某個隊列的信息：bqueues fat lsload：查看計算節點負載，查看某個節點的負載：lsload node001 查看作業狀態bj

BaldStrong 2020-06-24 12:02:08

cuda編程系列-高效編程（二）

安裝好cuda,使用Visual Studio進行編程，會發現代碼沒有高亮和智能提示功能，爲了更加方便的進行cuda程序的高效編程，通過一些插件安裝和環境配置可以完美實現，接下來開始進行配置。 1、下載Visual Assist插

cool_策 2020-07-06 01:38:34

cuda編程系列-內核調用（三）

1、內核調用介紹 使用ANSI C 和cuda擴展關鍵字編寫的代碼稱爲內核，該代碼是運行在gpu上面，通過cpu代碼通過內核調用的方式來啓動。也就是說，內核調用即cpu代碼啓動gpu代碼。內核調用通常會生成大量的塊（Block）和

cool_策 2020-07-06 01:38:34

cuda編程系列-架構簡介（一）

1、cuda介紹 cuda(Compuite unified Device Architecture)是由英偉達開發的進行並行計算的平臺和編程模型。支持英偉達顯卡進行加速。其他類型的顯卡進行加速可以使用Opencl，它比cuda更

cool_策 2020-07-05 16:19:47

CUDA編程之入門

CUDA代碼中的函數 CUDA程序文件後綴爲.cu。一個.cu文件內既包含CPU程序（稱爲主機程序），也包含GPU程序（稱爲設備程序）。凡是掛有“__global__”或者“__device__”前綴的函數，都是在GPU上運行的設備程序

USTC暖暖 2020-07-04 09:33:33

cublasSgemmBatched使用說明

背景 在GPU進行計算的時候，很多時候都需要利用cublas的API, 常用的API有兩個：cublasSgemm 和cublasSgemmBatched, 使用過MKL的可能覺得很熟悉，連參數都是一樣的，但是這裏有一比較坑的地方

s.feng 2020-07-03 05:06:04

斯坦福、伯克利及MIT聯合打造-2020年DL/RL必學6門經典課程

    本資源整理了6門由斯坦福大學、加州大學伯克利分校、麻省理工學院講授的深度學習經典課程，分別是深度學習入門、深度強化學習、深度學習與計算機視覺、無監督學習、多任務與元學習、深度學習與NLP。本資源將六門課程最新的視頻完整課程視頻整

lqfarmer 2020-07-02 00:55:08

【代碼閱讀】詳解在Pytorch中定義自己寫的CUDA編程函數

文章目錄pytorch接口設置編譯的方式在運行是調用的形式要點如何自己編寫使用CUDA的函數PointNet++Faster-RCNNPVCNN 目前，3D的網絡，尤其時point-based的網絡，很多模塊在pytorch中都沒

麒麒哈尔 2020-06-29 15:49:07

【轉載】cuda編程入門

目錄 1.什麼是CUDA 2.爲什麼要用到CUDA 3.CUDA環境搭建 4.第一個CUDA程序 5. CUDA編程 5.1. 基本概念 5.2. 線程層次結構 5.3. 存儲器層次結構 5.4. 運行時API 5.4.1. 初始化 5.

疯狂的兔子Philip 2020-06-27 18:23:16

Nvidia顯卡硬件與軟件

硬件 下面這張圖是GPU的硬件結構，這個圖有點大，放大看可以看到很多細節，我們可以看到有各種硬件組成單元，比如GPC,TPC,SM, L2Cache，綠色小塊就是cuda core也叫sp,後面這些都有專門對應的軟件信息。 再往

s.feng 2020-06-26 07:38:35