CUDA：求平方和

最新推荐文章于 2023-10-23 14:09:12 发布
最新推荐文章于 2023-10-23 14:09:12 发布
阅读量3.1k 收藏 7
点赞数
分类专栏： CUDA C和C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DUBO160/article/details/45247137
版权

CUDA：求平方和

1.求平方和(1)

#include<stdio.h>
#include<stdlib.h>
#include<cuda_runtime.h>
#define DATA_SIZE 1048576
int data[DATA_SIZE];

void GenerateNumbers(int *number,int size)
{
	//这个函式会产生一大堆 0 ~ 9 之间的随机数
	for(int i=0;i<size;i++)
	{
		number[i]=rand()%10;
	}

}

//在 CUDA 中，在函式前面加上__global__表示这个函式是要在显示芯片上执行的。因此，加入以下的函式：
__global__ static void sumOfSquares(int *num,int *result,clock_t *time)
{
	int sum=0;
	int i;
	clock_t start=clock();
	//CUDA 提供了一个clock 函式，可以取得目前的 timestamp
	for(i=0;i<DATA_SIZE;i++)
	{
		sum+=num[i]*num[i];
	}
	*result=sum;
	printf("%d\n",*result);
	*time=clock()-start;
}
int main()
{
	//要利用 CUDA 进行计算之前，要先把数据复制到显卡内存中，才能让显示芯片使用。
	GenerateNumbers(data, DATA_SIZE);
	int* gpudata, *result;
	clock_t *time;
	cudaMalloc((void **)&gpudata, sizeof(int)*DATA_SIZE);
	cudaMalloc((void **)&result, sizeof(int));
	cudaMalloc((void**) &time, sizeof(clock_t));
	cudaMemcpy(gpudata,data,sizeof(int)*DATA_SIZE,cudaMemcpyHostToDevice);
	//上面这段程序会先呼叫GenerateNumbers 产生随机数，并呼叫cudaMalloc 取得一块显卡内存
	//（result 则是用来存取计算结果，在稍后会用到），并透过 cudaMemcpy将产生的随机数复制到显卡内存中

	//函式名称<<<block 数目, thread 数目, shared memory 大小>>>(参数...);
	//因为这个程序只使用一个 thread，所以 block 数目、thread 数目都是 1。我们也没有使用到任何 shared memory，所以设为 0
	sumOfSquares<<<1,1,0>>>(gpudata,result,time);
	int sum;
	clock_t time_used;
	cudaMemcpy(&sum,result,sizeof(int),cudaMemcpyDeviceToHost);
	cudaMemcpy(&time_used, time, sizeof(clock_t), cudaMemcpyDeviceToHost);
	cudaFree(gpudata);
	cudaFree(result);
	printf("sum:%d,time:%d\n",sum,time_used);
	sum = 0; 
	for(int i = 0; i < DATA_SIZE; i++) 
	{
		sum += data[i] * data[i]; 
	} 
	printf("sum (CPU): %d\n", sum);
	system("pause");
}

2.求平方和（2）——使用多线程

//要怎么把计算平方和的程序并行化呢？最简单的方法，似乎就是把数字分成若干组，
//把各组数字分别计算平方和后，最后再把每组的和加总起来就可以了。
//一开始，我们可以把最后加总的动作，由 CPU 来进行。
#include<stdio.h>
#include<stdlib.h>
#include<cuda_runtime.h>
#include<thread>
#define data_size 1048576
#define thread_num 256 //设定thread数目
int data[data_size];

//产生数组元素值
void generatenumbers(int *number,int size)
{
	for (int i=0;i<size;i++)
	{
		number[i]=rand()%10; //产生0~9的随机数
	}
}
__global__ static void sumofsquares(int *num,int *result,clock_t* time)
{

	const int tid = threadIdx.x; //取得线程号
	printf("%d\n",tid);
	//程序里的threadidx 是 cuda 的一个内建的变量，
	//表示目前的 thread 是第几个 thread（由 0 开始计算）
	const int size = data_size / thread_num;//将数据分成多少组
	int sum=0;
	int i;
	clock_t start;
	if(tid==0)
		start = clock(); //开始时间
	//for(i==0;i<DATA_SIZE;i+=thread_num)
	//我们应该要让 thread 0 读取第一个数字，thread 1 读取第二个数字…依此类推。
	for(i = tid * size; i < (tid + 1) * size; i++)
	{ 
		sum += num[i] * num[i]; 
	}
	result[tid] = sum; 
	if(tid == 0) 
		*time = clock() - start;
}

int main()
{
	//...cuda初始化
	generatenumbers(data,data_size); //产生随机数

	int *gpudata,*result; //gpu设备上的数
	clock_t* time; //计算时间(以gpu时钟为基准)

	cudaMalloc((void**) &gpudata, sizeof(int) * data_size); 
	cudaMalloc((void**) &result, sizeof(int) * thread_num);
	cudaMalloc((void**) &time, sizeof(clock_t)); 
	cudaMemcpy(gpudata, data, sizeof(int) * data_size, cudaMemcpyHostToDevice);

	// 函式名称<<<block 数目，thread 数目,shared memory 大小>>>(参数...)
	sumofsquares<<<1, thread_num, 0>>>(gpudata, result, time); 
	int sum[thread_num]; 
	clock_t time_used;
	cudaMemcpy(&sum, result, sizeof(int) * thread_num, cudaMemcpyDeviceToHost); 
	cudaMemcpy(&time_used, time, sizeof(clock_t), cudaMemcpyDeviceToHost);
	cudaFree(gpudata); 
	cudaFree(result); 
	cudaFree(time);

	//计算每个线程计算出来和的总和
	int final_sum = 0; 
	for(int i = 0; i < thread_num; i++) 
	{ final_sum += sum[i]; }
	printf("sum: %d time: %d\n", final_sum, time_used); 
	
}

3.求平方和（3）

//在 CUDA 中，thread 是可以分组的，也就是 block。
//一个 block 中的 thread，具有一个共享的 shared memory，也可以进行同步工作。
//不同 block 之间的 thread 则不行。在我们的程序中，其实不太需要进行 thread 的同步动作，
//因此我们可以使用多个 block 来进一步增加 thread 的数目。


#include<stdio.h>
#include<stdlib.h>
#include<cuda_runtime.h>
#include<thread>
#define DATA_SIZE 1048576
#define BLOCK_NUM 32 //块数量
#define THREAD_NUM 256 //每个块中线程数
int data[DATA_SIZE];
//这表示我们会建立 32 个 blocks，每个 blocks 有 256 个 threads，总共有 32*256 = 8192 个 threads。

//产生数组元素值
void GenerateNumbers(int *number,int size)
{
	for (int i=0;i<size;i++)
	{
		number[i]=rand()%10; //产生0~9的随机数
	}
}
__global__ static void sumOfSquares(int *num,int *result,clock_t* time)
{

	const int tid = threadIdx.x; //取得线程号
	const int bid = blockIdx.x; //获得块号
	int sum=0;
	int i;
	if(tid==0)
		time[bid]=clock(); //开始时间
	for(i=bid*THREAD_NUM+tid;i<DATA_SIZE;i+=BLOCK_NUM*THREAD_NUM) //注意循环内变化
	{
		sum += num[i]*num[i];
	}
	result[bid*THREAD_NUM+tid] = sum; //第bid个块内第tid个线程计算的结果
	if(tid==0)
		time[bid+BLOCK_NUM] = clock(); //运行时间
	//把计算时间的方式改成每个 block 都会记录开始时间及结束时间。
}

int main()
{
	//...CUDA初始化
	GenerateNumbers(data,DATA_SIZE); //产生随机数

	int *gpudata,*result; //gpu设备上的数
	clock_t* time; //计算时间(以GPU时钟为基准)

	cudaMalloc((void**)&gpudata,sizeof(int)*DATA_SIZE); //分配显存，Allocate memory on the device
	cudaMalloc((void**)&result,sizeof(int)*BLOCK_NUM*THREAD_NUM);
	cudaMalloc((void**)&time,sizeof(clock_t)*BLOCK_NUM*2);
	// Copies data between host and device
	cudaMemcpy(gpudata,data,sizeof(int)*DATA_SIZE,cudaMemcpyHostToDevice); //Host->Device

	// 函式名称<<<block 数目，thread 数目,shared memory 大小>>>(参数...)
	sumOfSquares<<<BLOCK_NUM,THREAD_NUM,0>>>(gpudata,result,time);

	int sum[THREAD_NUM*BLOCK_NUM];
	clock_t time_used[BLOCK_NUM*2]; //运行时间
	cudaMemcpy(&sum,result,sizeof(int)*THREAD_NUM*BLOCK_NUM,cudaMemcpyDeviceToHost);
	cudaMemcpy(&time_used,time,sizeof(clock_t)*BLOCK_NUM*2,cudaMemcpyDeviceToHost);
	cudaFree(gpudata); //释放显存
	cudaFree(result);
	cudaFree(time);

	//计算每个线程计算出来和的总和
	int final_sum=0;
	for(int i=0;i<THREAD_NUM*BLOCK_NUM;i++)
	{
		final_sum += sum[i];
	}
	clock_t min_start,max_end;
	min_start=time_used[0];
	max_end=time_used[BLOCK_NUM];
	//计算GPU上总运行时间
	//找到计算时间最长的block，
	//把每个 block 最早的开始时间，和最晚的结束时间相减，取得总运行时间。
	for (int i=0;i<BLOCK_NUM;i++)
	{
		if(min_start>time_used[i])
			min_start=time_used[i];
		if(max_end<time_used[i+BLOCK_NUM])
			max_end=time_used[i+BLOCK_NUM];
	}
	printf("sum:%d  time:%d\n",final_sum,max_end-min_start);

	//在上面的代码后
	//在cpu上计算验证
	final_sum=0;
	for(int i=0;i<DATA_SIZE;i++)
	{
		final_sum += data[i]*data[i];
	}
	printf("(CPU) sum:%d\n",final_sum);
	system("pause");
}




4.求平方和（4）——Thread的同步

//一个block内的thread可以有共享的内存，也可以进行同步。
//我们可以利用这一点，让每个block内的所有thread把自己计算的结果加起来。

#include<stdio.h>
#include<stdlib.h>
#include<cuda_runtime.h>
#include<thread>
#define DATA_SIZE 1048576
#define BLOCK_NUM 32 //块数量
#define THREAD_NUM 256 //每个块中线程数
int data[DATA_SIZE];
//这表示我们会建立 32 个 blocks，每个 blocks 有 256 个 threads，总共有 32*256 = 8192 个 threads。

//产生数组元素值
void GenerateNumbers(int *number,int size)
{
	for (int i=0;i<size;i++)
	{
		number[i]=rand()%10; //产生0~9的随机数
	}
}
__global__ static void sumOfSquares(int *num,int *result,clock_t* time){
	extern __shared__ int shared[];
	//利用__shared__ 声明的变量表示这是 shared memory，是一个 block 中每个 thread 都共享的内存。
	//它会使用在 GPU 上的内存，所以存取的速度相当快，不需要担心 latency 的问题。
	const int tid = threadIdx.x; //取得线程号
	const int bid = blockIdx.x; //获得块号
	int i;
	if(tid==0)time[bid]=clock();
	shared[tid]=0;
	for(i=bid*THREAD_NUM+tid;i<DATA_SIZE;i+=BLOCK_NUM*THREAD_NUM)
	{
		shared[tid]+=num[i]*num[i];
	}

	__syncthreads();
	//__syncthreads() 是一个 CUDA 的内部函数，
	//表示 block 中所有的 thread 都要同步到这个点，才能继续执行。
	//在我们的例子中，由于之后要把所有 thread 计算的结果进行加总，
	//所以我们需要确定每个 thread 都已经把结果写到 shared[tid] 里面了。
	if(tid==0){
		for(i=1;i<THREAD_NUM;i++){
			shared[0]+=shared[i];
		}
		result[bid]=shared[0];
	}
	if(tid == 0) time[bid + BLOCK_NUM] = clock();
}

int main()
{
	//...CUDA初始化
	GenerateNumbers(data,DATA_SIZE); //产生随机数

	int *gpudata,*result; //gpu设备上的数
	clock_t* time; //计算时间(以GPU时钟为基准)

	cudaMalloc((void**)&gpudata,sizeof(int)*DATA_SIZE); //分配显存，Allocate memory on the device
	cudaMalloc((void**)&result,sizeof(int)*BLOCK_NUM);
	cudaMalloc((void**)&time,sizeof(clock_t)*BLOCK_NUM*2);
	
	cudaMemcpy(gpudata,data,sizeof(int)*DATA_SIZE,cudaMemcpyHostToDevice); //Host->Device

	// 函式名称<<<block 数目，thread 数目,shared memory 大小>>>(参数...)
	sumOfSquares<<<BLOCK_NUM,THREAD_NUM,THREAD_NUM*sizeof(int)>>>(gpudata,result,time);

	int sum[BLOCK_NUM];
	clock_t time_used[BLOCK_NUM*2]; //运行时间
	cudaMemcpy(&sum,result,sizeof(int)*BLOCK_NUM,cudaMemcpyDeviceToHost);
	cudaMemcpy(&time_used,time,sizeof(clock_t)*BLOCK_NUM*2,cudaMemcpyDeviceToHost);
	cudaFree(gpudata); //释放显存
	cudaFree(result);
	cudaFree(time);

	//计算每个线程计算出来和的总和
	int final_sum=0;
	for(int i=0;i<BLOCK_NUM;i++)
	{
		final_sum += sum[i];
	}
	clock_t min_start,max_end;
	min_start=time_used[0];
	max_end=time_used[BLOCK_NUM];
	//计算GPU上总运行时间
	//找到计算时间最长的block，
	//把每个 block 最早的开始时间，和最晚的结束时间相减，取得总运行时间。
	for (int i=0;i<BLOCK_NUM;i++)
	{
		if(min_start>time_used[i])
			min_start=time_used[i];
		if(max_end<time_used[i+BLOCK_NUM])
			max_end=time_used[i+BLOCK_NUM];
	}
	printf("sum:%d  time:%d\n",final_sum,max_end-min_start);

	//在上面的代码后
	//在cpu上计算验证
	final_sum=0;
	for(int i=0;i<DATA_SIZE;i++)
	{
		final_sum += data[i]*data[i];
	}
	printf("(CPU) sum:%d\n",final_sum);
	system("pause");
}



5.求平方和（5）

//求平方和（4）中最后加总的工作，只由每个 block 的 thread 0 来进行，但这并不是最有效率的方法。
//理论上，把 256 个数字加总的动作，是可以并行化的。最常见的方法，是透过树状的加法：
#include<stdio.h>
#include<stdlib.h>
#include<cuda_runtime.h>
#include<thread>
#define DATA_SIZE 1048576
#define BLOCK_NUM 32 //块数量
#define THREAD_NUM 256 //每个块中线程数
int data[DATA_SIZE];
//这表示我们会建立 32 个 blocks，每个 blocks 有 256 个 threads，总共有 32*256 = 8192 个 threads。

//产生数组元素值
void GenerateNumbers(int *number,int size)
{
	for (int i=0;i<size;i++)
	{
		number[i]=rand()%10; //产生0~9的随机数
	}
}
__global__ static void sumOfSquares(int *num,int *result,clock_t* time){
	extern __shared__ int shared[];
	//利用__shared__ 声明的变量表示这是 shared memory，是一个 block 中每个 thread 都共享的内存。
	//它会使用在 GPU 上的内存，所以存取的速度相当快，不需要担心 latency 的问题。
	const int tid = threadIdx.x; //取得线程号
	const int bid = blockIdx.x; //获得块号
	int i;
	int offset=1,mask=1;
	if(tid==0)time[bid]=clock();
	shared[tid]=0;
	for(i=bid*THREAD_NUM+tid;i<DATA_SIZE;i+=BLOCK_NUM*THREAD_NUM)
	{
		shared[tid]+=num[i]*num[i];
	}

	__syncthreads();
	//__syncthreads() 是一个 CUDA 的内部函数，
	//表示 block 中所有的 thread 都要同步到这个点，才能继续执行。
	//在我们的例子中，由于之后要把所有 thread 计算的结果进行加总，
	//所以我们需要确定每个 thread 都已经把结果写到 shared[tid] 里面了。

	while(offset<THREAD_NUM)
	{// while 循环就是进行树状加法。
		if((tid & mask)==0){
			shared[tid]+=shared[tid+offset];
		}
		offset+=offset;
		mask=offset+mask;
		__syncthreads();
	}
	//树状加法是一般的写法，但是它在 GPU 上执行的时候，会有 share memory 的 bank conflict 的问题
	//采用下面的方法，可以避免这个问题：
    //offset = THREAD_NUM / 2;
	//while(offset > 0) { if(tid < offset) { shared[tid] += shared[tid + offset]; } offset >>= 1; __syncthreads(); }

	//这样同时也省去了mask 变数。因此，这个版本的执行的效率就可以再提高一些
	//如果还要再提高效率，可以把树状加法整个展开：
	//if(tid < 128) { shared[tid] += shared[tid + 128]; } __syncthreads(); 
	//if(tid < 64) { shared[tid] += shared[tid + 64]; } __syncthreads(); 
	//if(tid < 32) { shared[tid] += shared[tid + 32]; } __syncthreads(); 
	//if(tid < 16) { shared[tid] += shared[tid + 16]; } __syncthreads(); 
	//if(tid < 8) { shared[tid] += shared[tid + 8]; } __syncthreads();
	//if(tid < 4) { shared[tid] += shared[tid + 4]; } __syncthreads(); 
	//if(tid < 2) { shared[tid] += shared[tid + 2]; } __syncthreads(); 
	//if(tid < 1) { shared[tid] += shared[tid + 1]; }__syncthreads();
	if(tid == 0) 
	{ 
		result[bid] = shared[0];
		time[bid + BLOCK_NUM] = clock();
	}
}

int main()
{
	//...CUDA初始化
	GenerateNumbers(data,DATA_SIZE); //产生随机数

	int *gpudata,*result; //gpu设备上的数
	clock_t* time; //计算时间(以GPU时钟为基准)

	cudaMalloc((void**)&gpudata,sizeof(int)*DATA_SIZE); //分配显存，Allocate memory on the device
	cudaMalloc((void**)&result,sizeof(int)*BLOCK_NUM);
	cudaMalloc((void**)&time,sizeof(clock_t)*BLOCK_NUM*2);
	
	cudaMemcpy(gpudata,data,sizeof(int)*DATA_SIZE,cudaMemcpyHostToDevice); //Host->Device

	// 函式名称<<<block 数目，thread 数目,shared memory 大小>>>(参数...)
	sumOfSquares<<<BLOCK_NUM,THREAD_NUM,THREAD_NUM*sizeof(int)>>>(gpudata,result,time);

	int sum[BLOCK_NUM];
	clock_t time_used[BLOCK_NUM*2]; //运行时间
	cudaMemcpy(&sum,result,sizeof(int)*BLOCK_NUM,cudaMemcpyDeviceToHost);
	cudaMemcpy(&time_used,time,sizeof(clock_t)*BLOCK_NUM*2,cudaMemcpyDeviceToHost);
	cudaFree(gpudata); //释放显存
	cudaFree(result);
	cudaFree(time);

	//计算每个线程计算出来和的总和
	int final_sum=0;
	for(int i=0;i<BLOCK_NUM;i++)
	{
		final_sum += sum[i];
	}
	clock_t min_start,max_end;
	min_start=time_used[0];
	max_end=time_used[BLOCK_NUM];
	//计算GPU上总运行时间
	//找到计算时间最长的block，
	//把每个 block 最早的开始时间，和最晚的结束时间相减，取得总运行时间。
	for (int i=0;i<BLOCK_NUM;i++)
	{
		if(min_start>time_used[i])
			min_start=time_used[i];
		if(max_end<time_used[i+BLOCK_NUM])
			max_end=time_used[i+BLOCK_NUM];
	}
	printf("sum:%d  time:%d\n",final_sum,max_end-min_start);

	//在上面的代码后
	//在cpu上计算验证
	final_sum=0;
	for(int i=0;i<DATA_SIZE;i++)
	{
		final_sum += data[i]*data[i];
	}
	printf("(CPU) sum:%d\n",final_sum);
	system("pause");
}



flamimg
关注
专栏目录
CUDA编程之 02 数组加法
iCloudEnd的博客
03-07 159
在此博客中，我将指导您完成如何编写用于数组添加的 cuda 内核代码。
CUDA计算随机数平方和
06-08
在“CUDA计算随机数平方和”这个主题中，我们将探讨如何使用CUDA技术来加速随机数平方和的计算过程。 首先，CUDA编程主要通过C++或Fortran的扩展语法实现，其中`.cu`文件是CUDA特有的源代码文件。`calculate_...
cuda示例代码 数组相加
qq_43594926的博客
05-26 403
#include “cuda_runtime.h” #include “device_launch_parameters.h” #include <stdio.h> cudaError_t addWithCuda(int *c, const int *a, const int *b, unsigned int size); global void addKernel(int *c, const int *a, const int *b) { int i = threadIdx.x; c[i] =
利用CUDA C将两个数组相加
最新发布
weixin_45669101的博客
10-23 139
跟CPU的数组运算相比，GPU计算需要将Host中储存的数组复制到GPU的全局内存中，再GPU上完成相加的操作再转移到Host上。最近开始了CUDA C的学习，开贴记录下学习过程。
cuda 优化实例--计算平方和
EdiosnMa的博客
11-01 491
平方和程序的渐进优化 当线程访问global memory没有顺序访问 线程顺序访问global memory 在1的基础之上增加并行计算规模，也就是使用多个block 如何选择最优的的线程配置，可能影响线程配置的因素有一下几个： 为了高效地使用寄存器，每个sm上至少要有192个激活的线程 为了将bank冲突将到最低，应尽量使每个block含有的线程数是64的倍数 当某个block中的线程被同步时候，为了避免对应的sm出现闲置，通常让block的数量是sm的2倍以上，以便使得处于不同状态的（闲置或者不闲
cgls_cuda:CUDA中最小二乘的共轭梯度
05-12
CGLS在Nvidia Tesla K40c上中的两个最大的非平方矩阵上运行。 矩阵名称 尺寸 非零 Iter。 时间 时间/（iter * nnz） 吉安.mesh_grid （230k，9k） 85万 794 0.52秒 0.77纳秒 JGD_GL7d.GL7d18 （200万，150万...
SDK_CUDA-Fortran_SDK_
10-03
例如，以下是一个简单的 CUDA-Fortran Kernel 示例，用于计算数组的平方： ```fortran !$cuda subroutine square_array(d_a, d_b, size) implicit none integer :: i, size real, device, intent(in) :: d_a(*) ...
CUDA简要入门PPT
04-10
以一个简单的例子来说明CUDA并行计算的优势，比如计算1000个0到10的随机数的平方和。在传统CPU程序中，我们需要遍历数组，逐个计算平方并累加。而在CUDA中，我们可以利用GPU的并行计算能力，将计算任务分配给多个...
kmeans-master_基于cuda的kmeans算法_cuda加速kmeans_源码
10-01
KMeans算法的核心是将数据集中的样本点按照它们之间的距离划分为K个不同的簇，通过迭代调整簇中心和样本点的归属，以最小化簇内样本点的平方误差和。具体步骤包括初始化簇中心、分配样本点到最近的簇、更新簇中心，...
CUDA之常用算法：求平方和
Bruce_0712的博客
11-18 2076
CUDA：求平方和 http://blog.csdn.net/dubo160/article/details/45247137 CUDA并行算法系列之规约 http://www.cnblogs.com/5long/p/algorithms-on-cuda-reduction.html CUDA并行算法系列之FFT快速卷积 http://www.cnblogs.com/5
新的Cuda的归并累加算法, O(lgN) , n可以是任意值，不规定2的幂
weixin_30342827的博客
10-15 516
把一个n元素数组里面的值全部加起来的程序，大家都会写，一个for循环搞定。但是如果在cuda代码里面也这么写的话，速度会比cpu上还慢，毕竟人家一对一对拼的话，肯定是干不过cpu的。 在cuda里面的算法是n个线程一起参与这个运算。 nvidia貌似有个官方的算法，几乎所有看到的cuda代码里面都是用的它： for(int i=(blockDim.x>>1);i>0;i...
CUDA代码计算0-63的平方
Hughie999的博客
05-05 128
计算0~63的平方数并输出。
CUDA——可用于核函数中的CUDA基本数学运算函数总结
Irving.Gao的博客
11-22 2833
对于单、双浮点类型和整型的数学函数，用法基本和math.h库的用法相同，举几个例子：函数功能CPU MathCUDA Math单精度求平方单精度求根号可以看出基本都是一一对应的。其他主要用法还是参考手册~
CUDA编程--Square函数
qq_35781447的博客
09-23 1219
编程思路： host: cpu device: gpu 1.分配host内存, 并进行数据初始化; 2.分配device内存, 并从host将数据拷贝到device上; 3.调用CUDA的核函数在device上完成指定的运算; 4.将device 上的运算结果拷贝到host上 (性能) 5.释放device和host上分配的内存 ...
CUDA C编程（二十一）CUDA指令概述
AAAA202012的博客
02-04 2286
   浮 点 指 令    内 部 函 数 和 标 准 函 数    原 子 操 作 指 令   
CUDA学习笔记 (一)
Darchan的博客
07-08 1773
CUDA学习笔记: 零基础了解CUDA编程相关操作与实战
多线程CUDA实例 167页 平方求和
NYG8945的博客
10-28 845
//GPGPU编程技术-从GLSL、CUDA到OpenCL 平方和算法第二版 增加计时函数 没有为主机变量分配内存 多线程求和// //书中程序167页 #include <stdio.h> #include <iostream> #include <cuda_runtime.h> // For the CUDA runtime routines (prefixed with "cuda_") #
CUDA编程（六）进一步并行
weixin_34319111的博客
04-06 656
CUDA编程（六） 进一步并行 在之前我们使用Thread完成了简单的并行加速，虽然我们的程序运行速度有了50甚至上百倍的提升，但是根据内存带宽来评估的话我们的程序还远远不够，在上一篇博客中给大家介绍了一个访存方面非常重要的优化，我们通过使用连续的内存存取模式，取得了令人满意的优化效果，最终内存带宽也达到了GB/s的级别。 之...
如何理解C run-time library （C运行时库）
han012的专栏
08-30 1604
注： 以下内容部分引自CSND中相关讨论的帖子，并结合自己的理解整理而成。仅供参考。1)运行时库就是 C run-time library，是 C 而非 C++ 语言世界的概念:取这个名字就是因为你的 C 程序运行时需要这些库中的函数.2)C 语言是所谓的“小内核”语言，就其语言本身来说很小（不多的关键字，程序流程控制，数据类型等）；所以，C 语言内核开发出来之后，Dennis Ritch
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值