VS中Cuda使用cublas库进行复数矩阵的乘法

最新推荐文章于 2023-10-23 14:46:07 发布
最新推荐文章于 2023-10-23 14:46:07 发布
阅读量2.1k 收藏 9
点赞数
分类专栏： Cuda学习 文章标签： c++ cuda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kewang93/article/details/118702824
版权

找了很久都没有发现 调用cuda库  中 cublasCgemmBatched 使用复数矩阵的乘法，自己尝试写了一个。

1，新建一个cuda项目 

配置相关路径和依赖项 （）

 

C:\ProgramData\NVIDIA Corporation\CUDA Samples\v10.0\common\inc
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\include

C:\ProgramData\NVIDIA Corporation\CUDA Samples\v10.0\common\lib
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.0\lib

 

cublas.lib

cuda.lib
cudadevrt.lib
cudart.lib
cudart_static.lib
cufft.lib
cufftw.lib
curand.lib
cusolver.lib
cusparse.lib

粘贴源代码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>

#include <cuda_runtime.h>
#include <cublas_v2.h>

#include <helper_cuda.h>
//#include "batchCUBLAS.h"


#define T_ELEM cuComplex
#define CUBLASTEST_FAILED  1
const char *sSDKname = "batchCUBLAS";



static __inline__ int imax(int x, int y)
{
	return (x > y) ? x : y;
}
static __inline__ unsigned cuRand(void)
{
	/* George Marsaglia's fast inline random number generator */
#define CUDA_ZNEW  (cuda_z=36969*(cuda_z&65535)+(cuda_z>>16))
#define CUDA_WNEW  (cuda_w=18000*(cuda_w&65535)+(cuda_w>>16))
#define CUDA_MWC   ((CUDA_ZNEW<<16)+CUDA_WNEW)
#define CUDA_SHR3  (cuda_jsr=cuda_jsr^(cuda_jsr<<17), \
	cuda_jsr = cuda_jsr ^ (cuda_jsr >> 13), \
	cuda_jsr = cuda_jsr ^ (cuda_jsr << 5))
#define CUDA_CONG  (cuda_jcong=69069*cuda_jcong+1234567)
#define KISS  ((CUDA_MWC^CUDA_CONG)+CUDA_SHR3)
	static unsigned int cuda_z = 362436069, cuda_w = 521288629;
	static unsigned int cuda_jsr = 123456789, cuda_jcong = 380116160;
	return KISS;
}
#include <windows.h>
static __inline__ double second(void)
{
	LARGE_INTEGER t;
	static double oofreq;
	static int checkedForHighResTimer;
	static BOOL hasHighResTimer;

	if (!checkedForHighResTimer)
	{
		hasHighResTimer = QueryPerformanceFrequency(&t);
		oofreq = 1.0 / (double)t.QuadPart;
		checkedForHighResTimer = 1;
	}

	if (hasHighResTimer)
	{
		QueryPerformanceCounter(&t);
		return (double)t.QuadPart * oofreq;
	}
	else
	{
		return (double)GetTickCount() / 1000.0;
	}
}
struct gemmOpts
{
	int m;
	int n;
	int k;
	//testMethod test_method;
	char *elem_type;
	int N;    // number of multiplications
};
struct gemmTestParams
{
	cublasOperation_t transa;
	cublasOperation_t transb;
	int   m;
	int   n;
	int   k;
	T_ELEM alpha;
	T_ELEM beta;
};
#define CLEANUP()                           \
    do {                                        \
        if (A) free (A);                        \
        if (B) free (B);                        \
        if (C) free (C);                        \
        for(int i = 0; i < opts.N; ++i) {       \
            if(devPtrA[i]) cudaFree(devPtrA[i]);\
            if(devPtrB[i]) cudaFree(devPtrB[i]);\
            if(devPtrC[i]) cudaFree(devPtrC[i]);\
        }                                       \
        if (devPtrA) free(devPtrA);             \
        if (devPtrB) free(devPtrB);             \
        if (devPtrC) free(devPtrC);             \
        if (devPtrA_dev) cudaFree(devPtrA_dev); \
        if (devPtrB_dev) cudaFree(devPtrB_dev); \
        if (devPtrC_dev) cudaFree(devPtrC_dev); \
        fflush (stdout);                        \
    } while (0)

void fillupMatrixDebug(T_ELEM *A, int lda, int rows, int cols)
{
	for (int j = 0; j < cols; j++)
	{
		for (int i = 0; i < rows; i++)
		{
			A[i + lda*j].x = (i + 0);
			A[i + lda*j].y = (j + 0);
		}
	}
}
void PrintMatrixDebug(T_ELEM *A, int lda, int rows, int cols)
{
	printf("========The matrix is  \n");
	for (int j = 0; j < cols; j++)
	{
		for (int i = 0; i < rows; i++)
		{
			printf("%+.02f%+.02fi\t", A[i + lda*j].x, A[i + lda*j].y);
			//A[i + lda*j] = (i + j);
		}
		printf("  \n");
	}
}

int main(int argc, char *argv[])
{
	printf("%s Starting...\n\n", sSDKname);

	int dev = findCudaDevice(argc, (const char **)argv);

	if (dev == -1)
	{
		return CUBLASTEST_FAILED;
	}
	cublasHandle_t handle;

	if (cublasCreate(&handle) != CUBLAS_STATUS_SUCCESS)
	{
		fprintf(stdout, "CUBLAS initialization failed!\n");
		exit(EXIT_FAILURE);
	}

	cublasStatus_t status1, status2, status3;
	T_ELEM *A = NULL;
	T_ELEM *B = NULL;
	T_ELEM *C = NULL;
	T_ELEM **devPtrA = 0;
	T_ELEM **devPtrB = 0;
	T_ELEM **devPtrC = 0;
	T_ELEM **devPtrA_dev = NULL;
	T_ELEM **devPtrB_dev = NULL;
	T_ELEM **devPtrC_dev = NULL;

	int matrixM, matrixN, matrixK;
	int rowsA, rowsB, rowsC;
	int colsA, colsB, colsC;
	int m, n, k;
	int matrixSizeA, matrixSizeB, matrixSizeC;
	int errors;
	double start, stop;
	gemmOpts opts;
	opts.N = 20;
	gemmTestParams params;

	printf("Testing Batch INV Cublas\n");

	matrixM = 5;
	matrixN = 5;
	matrixK = 5;

	rowsA = imax(1, matrixM);
	colsA = imax(1, matrixK);
	rowsB = imax(1, matrixK);
	colsB = imax(1, matrixN);
	rowsC = imax(1, matrixM);
	colsC = imax(1, matrixN);

	matrixSizeA = rowsA * colsA;
	matrixSizeB = rowsB * colsB;
	matrixSizeC = rowsC * colsC;

	params.transa = CUBLAS_OP_N;
	params.transb = CUBLAS_OP_N;
	m = matrixM;
	n = matrixN;
	k = matrixK;
	params.m = m;
	params.n = n;
	params.k = k;
	params.alpha.x = 1.0; params.alpha.y = 0.0;
	params.beta.x = 0.0; params.beta.y = 0.0;

	devPtrA = (T_ELEM **)malloc(opts.N * sizeof(T_ELEM *));
	devPtrB = (T_ELEM **)malloc(opts.N * sizeof(*devPtrB));
	devPtrC = (T_ELEM **)malloc(opts.N * sizeof(*devPtrC));

	for (int i = 0; i < opts.N; i++)
	{
		cudaError_t err1 = cudaMalloc((void **)&devPtrA[i], matrixSizeA * sizeof(T_ELEM ));
		cudaError_t err2 = cudaMalloc((void **)&devPtrB[i], matrixSizeB * sizeof(devPtrB[0][0]));
		cudaError_t err3 = cudaMalloc((void **)&devPtrC[i], matrixSizeC * sizeof(devPtrC[0][0]));


	}
	// For batched processing we need those arrays on the device

	cudaError_t err1 = cudaMalloc((void **)&devPtrA_dev, opts.N * sizeof(*devPtrA));
	cudaError_t err2 = cudaMalloc((void **)&devPtrB_dev, opts.N * sizeof(*devPtrB));
	cudaError_t err3 = cudaMalloc((void **)&devPtrC_dev, opts.N * sizeof(*devPtrC));



	err1 = cudaMemcpy(devPtrA_dev, devPtrA, opts.N * sizeof(*devPtrA), cudaMemcpyHostToDevice);
	err2 = cudaMemcpy(devPtrB_dev, devPtrB, opts.N * sizeof(*devPtrB), cudaMemcpyHostToDevice);
	err3 = cudaMemcpy(devPtrC_dev, devPtrC, opts.N * sizeof(*devPtrC), cudaMemcpyHostToDevice);

	A = (T_ELEM *)malloc(matrixSizeA * sizeof(A[0]));
	B = (T_ELEM *)malloc(matrixSizeB * sizeof(B[0]));
	C = (T_ELEM *)malloc(matrixSizeC * sizeof(C[0]));

	printf("#### args: lda=%d ldb=%d ldc=%d\n", rowsA, rowsB, rowsC);
	m = cuRand() % matrixM;
	n = cuRand() % matrixN;
	k = cuRand() % matrixK;
	memset(A, 0xFF, matrixSizeA* sizeof(A[0]));
	fillupMatrixDebug(A, rowsA, rowsA, rowsA);
	memset(B, 0xFF, matrixSizeB* sizeof(B[0]));
	fillupMatrixDebug(B, rowsB, rowsA, rowsA);

	for (int i = 0; i < opts.N; i++)
	{
		status1 = cublasSetMatrix(rowsA, colsA, sizeof(A[0]), A, rowsA, devPtrA[i], rowsA);
		status2 = cublasSetMatrix(rowsB, colsB, sizeof(B[0]), B, rowsB, devPtrB[i], rowsB);
		status3 = cublasSetMatrix(rowsC, colsC, sizeof(C[0]), C, rowsC, devPtrC[i], rowsC);

	}
	start = second();

	status1 = cublasCgemmBatched(handle, params.transa, params.transb, params.m, params.n,
		params.k, &params.alpha, (const T_ELEM **)devPtrA_dev, rowsA,
		(const T_ELEM **)devPtrB_dev, rowsB, &params.beta, devPtrC_dev, rowsC, opts.N);

	
	//cudaMemcpy(devPtrC_dev, devPtrC, opts.N * sizeof(*devPtrC), cudaMemcpyHostToDevice);

	for (int i = 0; i < opts.N; i++)
	{
		//status1 = cublasSetMatrix(rowsA, colsA, sizeof(A[0]), A, rowsA, devPtrA[i], rowsA);
		//status2 = cublasSetMatrix(rowsB, colsB, sizeof(B[0]), B, rowsB, devPtrB[i], rowsB);
		status3 = cublasGetMatrix(rowsC, colsC, sizeof(C[0]), devPtrC[i], rowsC, C, rowsC);

	}

	PrintMatrixDebug(A, params.m, params.n, params.k);
	PrintMatrixDebug(B, params.m, params.n, params.k);
	PrintMatrixDebug(C, params.m, params.n, params.k);

	stop = second();
	fprintf(stdout, "^^^^ elapsed = %10.8f sec  \n", (stop - start));




	CLEANUP();
	cublasDestroy(handle);
	printf("\nTest Summary\n");
	system("pause");
	return 0;

}

输出结果，验证乘法结果是正确的。

 

kewang93
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CUDA：矩阵乘法，并使用CUBLAS库演示了最佳性能实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-22 191
CUDA：矩阵乘法，并使用CUBLAS库演示了最佳性能实例
贤者之路，Cuda block内部矩阵求逆，mxm矩阵 复杂度为O(m)
chanzhennan的博客
01-30 3399
在做线性变换上经常要用到NXN的矩阵求逆。在CUDA用的是高斯消元比较适合并行计算。下面是3X3Cuda实现矩阵求逆的Device函数，也就是说可以直接写到你的kernel函数上去。当然也可以是任何NXN矩阵另外时间上，测试过6X6的矩阵用时在0.016ms，所以可以说基本不耗时。以后会把速度的梯度测试和精度测试结果都放上去。*   1   2   1   |  1  0   0         ...
GPU编程 CUDA C++ 线性代数求解器 cuSolver库
行子的博客
04-05 1489
cuSolver库较cuBLAS库更为高级，其能处理矩阵求逆，矩阵对角化，矩阵分解，特征值计算等问题。cuSolver库的实现是基于cuBLAS库和cuSPARSE库这两个基本库。cuSolver库的功能类似于Fortran中的LAPACK库：是Linear Algebra PACKage的简称。
利用cublas库函数cublasSgetrfBatched和cublasSgetriBatched求矩阵的逆
lumanman_的博客
08-30 3590
折腾了好几天终于把cublas矩阵求逆调好了，但是依然还是有很多疑问，因为是按照网上别人的程序凑出来的。主要的疑惑有两点，在这里贴出来，希望有大神可以指点一二，大家交流交流。 ①矩阵初始化的时候，matHost[0]，为什么不可以像我注释掉的那两句那样子初始化，那样初始化的时候就会报错:expected an expression。 ②为什么要定义一个在host端的指针srchd，它的
一个简介的简洁的cublasSgetrfBatched和cublasSgetriBatched示例
eloudy的专栏
12-19 764
放入一个能够编译cublas函数的环境中运行： #include <stdio.h> #include <stdlib.h> #include <string.h> /* Includes, cuda */ #include <cublas_v2.h> #include <cuda_runtime.h> float* d_Get3DInv(float* L, int n, int J) { cublasHandle_t cu
python使用skcuda包实现GPU上的矩阵乘法，矩阵求逆
qq_38402294的博客
03-26 2658
导入需要的包： import pycuda.gpuarray as gpuarray import pycuda.autoinit import skcuda.linalg as sklin 创建两个矩阵： a = numpy.random.randn(4, 4).astype(numpy.float32) #为了后续GPU上的计算顺利进行，矩阵数值设定为float32 b = numpy.ra...
PyTorch中的蝴蝶矩阵乘法_Python_Cuda_下载.zip
04-13
总结来说，"PyTorch中的蝴蝶矩阵乘法_Python_Cuda_下载.zip"这个压缩包提供了一套使用Python和CUDA在PyTorch中实现蝴蝶矩阵乘法的解决方案，适用于需要高效矩阵运算的场景。通过理解和应用这些知识，开发者可以提升...
libcudart.so.8.0 Cuda8库文件，可用于Cuda文件的补充
10-18
`libcublas.so.8.0`代表CUDA Basic Linear Algebra Subprograms，是CUDA的基础线性代数库，提供了大量的BLAS（基本线性代数子程序）函数，如矩阵乘法、向量加法等，是进行矩阵运算和解决线性系统的首选工具。...
cublas64-10.rar
09-09
在使用cublas64_10.dll时，开发人员需要遵循CUDA编程模型，首先加载库，然后调用对应的函数进行计算。同时，为了确保最佳性能，需要考虑GPU的内存管理、数据传输效率以及适当的计算算法选择。NVIDIA还提供了cuBLAS...
虚拟无线电中CUDA技术实现GPU通用计算及性能分析.pdf
09-25
在CUDA架构下，程序流程包括创建二维随机矩阵并进行FFT计算。CUDA提供的cufftExecC2C函数用于执行复数FFT，不同大小的N会带来不同的计算速度。通过比较使用CUDA技术时的计算时间和基于CPU的计算时间，可以观察CUDA对...
实数及复数矩阵加法并行CUDA
08-28
内容：1、实数矩阵加法以及 2、复数矩阵加法 GPU并行 CUDA代码 MATLAB Cmex混合编程。MATLAB CUDA C++
两个比较实用的矩阵类
03-07
7. **友元函数和重载运算符**：为了方便使用，可以重载`+`、`-`、`*`等运算符，并可能使用友元函数来实现更高效的矩阵乘法。 8. **输入/输出**：支持从文件或标准输入读取和写入矩阵，通常使用`std::ifstream`和`...
CUDA学习笔记（十二） CUDA库简介
最新发布
qq_45788429的博客
10-23 1020
上图是CUDA 库的位置，本文简要介绍cuSPARSE、cuBLAS、cuFFT和cuRAND，之后会介绍OpenACC。CUDA库和CPU编程所用到的库没有什么区别，都是一系列接口的集合，主要好处是，只需要编写host代码，调用相应API即可，可以节约很多开发时间。而且我们完全可以信任这些库能够达到很好的性能，写这些库的人都是在CUDA上的大能，一般人比不了。当然，完全依赖于这些库而对CUDA性能优化一无所知也是不行的，我们依然需要手动做一些改进来挖掘出更好的性能。
CUDA学习--矩阵乘法的并行运算
Yi_M的博客
08-24 1万+
1. CUDA学习步骤 CPU实现 a*b = c 的矩阵乘法（矩阵尺寸是n*m的，n和m大于1000） 下载 https://developer.nvidia.com/cuda-downloads，安装好cuda 将cpu代码移植到cuda。将CPU值传入GPU，使用cuda计算，与cpu结果对比。 优化思路1：将矩阵分块进行计算 优化思路2：使用share memory进行优化 优化思路3：将数
CUDA8.0矩阵乘法例子解释（matrixMul.cpp）
groundhappy的专栏
12-16 4966
通过学习英伟达自带的例子matrixMul学CUDA库的使用。 简略部分垃圾。只说核心代码。 这个例子是实现 C=A*B的矩阵相乘 // Use a larger block size for Fermi and above int block_size = 32; //original: dim3 dimsA(5*2*block_size, 5*2*bl
cublasSgemm详解
Summit的专栏
10-28 1万+
cublasSgemm函数详解cublasSgemm是CUDA的cublas库的矩阵相乘函数，由于cublas中矩阵的存储是列优先，所以cublasSgemm函数的参数容易让人误解，防止忘记，留笔记如下。首先，在一般的C/C++程序中，我们开辟一段连续的内存，放入1,2,3,4,5,6,7,8,9，指定矩阵行和列均为3，则可表示矩阵[1,2,3 ; 4,5,6 ; 7,8,9]，然而，在使用cubl
CUDA中的复数定义、开内存空间以及运算
HPC&Geophysics攻城狮
03-19 4884
最近在做时频混合域的全波形反演（FWI），用CUDA加速，要做复数运算，所以研究了一下CUDA中复数运算等。简单说一下CUDA中复数的基本应用。在CUDA中用CUFFT的库来定义与运算复数，基本如下：#include "cufft.h" int main（） { /* Transform real field to complex field */ cufftComplex *...
Cuda矩阵运算库cuBLAS介绍
热门推荐
zcy0xy的博客
11-27 2万+
文章目录简介cuBLAS库新特性 简介 cuBLAS库用于进行矩阵运算，它包含两套API，一个是常用到的cuBLAS API，需要用户自己分配GPU内存空间，按照规定格式填入数据，；还有一套CUBLASXT API，可以分配数据在CPU端，然后调用函数，它会自动管理内存、执行计算。既然都用cuda了，其实还是用第一套API多一点。 官方文档参考 最初，为了尽可能地兼容Fortran语言环境，cuB...
写一段用cublas库进行批处理矩阵乘法的代码
07-10
以下是使用CUBLAS库进行批处理矩阵乘法的示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <cuda_runtime.h> #include <cublas_v2.h> #define N 3 // 矩阵大小 #define BATCH_SIZE 2 // 批处理大小 void printMatrix(float* matrix, int rows, int cols) { for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { printf("%f ", matrix[i * cols + j]); } printf("\n"); } printf("\n"); } int main() { cublasHandle_t handle; cublasCreate(&handle); float* h_A[BATCH_SIZE]; // 批处理输入矩阵A float* h_B[BATCH_SIZE]; // 批处理输入矩阵B float* h_C[BATCH_SIZE]; // 批处理输出矩阵C float* d_A[BATCH_SIZE]; // GPU上的输入矩阵A float* d_B[BATCH_SIZE]; // GPU上的输入矩阵B float* d_C[BATCH_SIZE]; // GPU上的输出矩阵C // 为批处理矩阵分配内存 for (int i = 0; i < BATCH_SIZE; i++) { h_A[i] = (float*)malloc(N * N * sizeof(float)); h_B[i] = (float*)malloc(N * N * sizeof(float)); h_C[i] = (float*)malloc(N * N * sizeof(float)); cudaMalloc((void**)&d_A[i], N * N * sizeof(float)); cudaMalloc((void**)&d_B[i], N * N * sizeof(float)); cudaMalloc((void**)&d_C[i], N * N * sizeof(float)); } // 初始化输入矩阵A和B for (int i = 0; i < BATCH_SIZE; i++) { for (int j = 0; j < N * N; j++) { h_A[i][j] = i + j; h_B[i][j] = i - j; } } // 将输入矩阵A和B从主机内存复制到GPU内存 for (int i = 0; i < BATCH_SIZE; i++) { cudaMemcpy(d_A[i], h_A[i], N * N * sizeof(float), cudaMemcpyHostToDevice); cudaMemcpy(d_B[i], h_B[i], N * N * sizeof(float), cudaMemcpyHostToDevice); } const float alpha = 1.0f; const float beta = 0.0f; // 执行批处理矩阵乘法 cublasSgemmBatched(handle, CUBLAS_OP_N, CUBLAS_OP_N, N, N, N, &alpha, (const float**)d_A, N, (const float**)d_B, N, &beta, d_C, N, BATCH_SIZE); // 将输出矩阵C从GPU内存复制到主机内存 for (int i = 0; i < BATCH_SIZE; i++) { cudaMemcpy(h_C[i], d_C[i], N * N * sizeof(float), cudaMemcpyDeviceToHost); } // 打印输入矩阵A和B printf("Matrix A:\n"); for (int i = 0; i < BATCH_SIZE; i++) { printf("Batch %d:\n", i); printMatrix(h_A[i], N, N); } printf("Matrix B:\n"); for (int i = 0; i < BATCH_SIZE; i++) { printf("Batch %d:\n", i); printMatrix(h_B[i], N, N); } // 打印输出矩阵C printf("Matrix C:\n"); for (int i = 0; i < BATCH_SIZE; i++) { printf("Batch %d:\n", i); printMatrix(h_C[i], N, N); } // 释放内存 for (int i = 0; i < BATCH_SIZE; i++) { free(h_A[i]); free(h_B[i]); free(h_C[i]); cudaFree(d_A[i]); cudaFree(d_B[i]); cudaFree(d_C[i]); } cublasDestroy(handle); return 0; } ``` 这个示例代码演示了如何使用CUBLAS库进行批处理矩阵乘法。它创建了两个批处理的输入矩阵A和B，并分配了相应的GPU内存。然后，它将输入矩阵从主机内存复制到GPU内存，并使用`cublasSgemmBatched`函数执行批处理矩阵乘法。最后，它将输出矩阵C从GPU内存复制到主机内存，并打印输入矩阵A和B以及输出矩阵C的内容。请确保您已正确安装CUDA和CUBLAS，并将代码与适当的编译器和库进行编译和链接。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值