CUDA一维纹理内存

最新推荐文章于 2024-03-01 23:37:58 发布
最新推荐文章于 2024-03-01 23:37:58 发布
阅读量376 收藏
点赞数
分类专栏： Nvidia 文章标签： CUDA 一维纹理
原文链接：https://blog.csdn.net/zhangfuliang123/article/details/76528075
版权

纹理一词来源于GPU图形世界，GPU通用并行计算“盗用”了纹理一词，定义了一个纹理内存的概念。纹理内存缓存在 设备上，在某些情况下能减少对内存的请求并降低内存带宽的使用，是专门为那些在内存访问模式中存在大量空间局部性的图形应用而设计，意味着一个线程读取的位置可能与邻近线程读取的位置“非常接近”。对于GPU内核而言，纹理内存是只读内存，并且只有通过特殊的纹理API才能对其访问。

纹理内存分为一维纹理内存和二维纹理内存，理解纹理内存最好的方式是丢掉“纹理”两个字，纹理内存本质上是一块内存，是GPU在特定应用中对一维、二维变量的特殊声明定义以及特殊使用，这种特殊使用能够减少内存流量，提升运算性能。

纹理变量（引用）必须声明为文件作用域内的全局变量，这里先探讨一下一维纹理内存的使用方法。一维纹理内存的关键操作如下：

1、用texture<类型>类型声明。
如声明一个unsigned char 型的一维纹理tex1，格式为：

texture<unsigned char,1,cudaReadmodeElementType> tex1;

2、通过cudaBindTexture()绑定到纹理内存中，并关联到对应的数据上。
如将unsigned char类型的dev_A绑定到一维纹理tex1上，格式为：

cudaBindTexture(0,tex1,dev_A);

注意一旦将数据绑定到一个纹理内存上，该数据就已经传输到了设备缓存上，在核函数中就可以直接访问，不再需要额外传入。

3、 通过tex1Dfetch()来读取纹理内存中的数据。
纹理内存是一种特殊的内存，需要使用特定的纹理API来访问其中的数据。如访问tex1数组的第3个元素，格式为：

tex1Dfetch(tex1,2);

4、 通过cudaUnbindTexture()取消绑定纹理内存。
纹理内存使用完之后需要取消绑定，释放空间，如解除纹理tex1的绑定，格式为：

cudaUnbindTexture(tex1)；

考虑一个简单的应用，把一个长度是100的向量A中的数据拷贝到一个向量B中，使用普通CPU编程实现如下：

#include <iostream>  
  
using namespace std;  
  
#define _length 100  
  
//CPU函数实现复制一个数组  
void Copy_CPU(unsigned int * listSource, unsigned int * listTarget, int length)  
{  
    for (int i = 0; i < length; i++)  
    {  
        listTarget[i] = listSource[i];  
    }  
}  
  
int main()  
{  
    unsigned int * listSource = new unsigned int[_length];  
    unsigned int * listTarget = new unsigned int[_length];  
  
    //赋值  
    for (int i = 0; i < _length; i++)  
    {  
        listSource[i] = i;  
    }  
  
    //调用CPU复制函数  
    Copy_CPU(listSource, listTarget, _length);  
  
    cout << "原始数据： ";  
    for (int i = 0; i < _length; i++)  
    {  
        cout << listSource[i] << " ";  
    }  
    cout << endl << endl << "通过CPU拷贝的数据： ";  
    for (int i = 0; i < _length; i++)  
    {  
        cout << listTarget[i] << " ";  
    }  
    getchar();  
}  

#include <iostream>
 
using namespace std;
 
#define _length 100
 
//CPU函数实现复制一个数组
void Copy_CPU(unsigned int * listSource, unsigned int * listTarget, int length)
{
	for (int i = 0; i < length; i++)
	{
		listTarget[i] = listSource[i];
	}
}
 
int main()
{
	unsigned int * listSource = new unsigned int[_length];
	unsigned int * listTarget = new unsigned int[_length];
 
	//赋值
	for (int i = 0; i < _length; i++)
	{
		listSource[i] = i;
	}
 
	//调用CPU复制函数
	Copy_CPU(listSource, listTarget, _length);
 
	cout << "原始数据： ";
	for (int i = 0; i < _length; i++)
	{
		cout << listSource[i] << " ";
	}
	cout << endl << endl << "通过CPU拷贝的数据： ";
	for (int i = 0; i < _length; i++)
	{
		cout << listTarget[i] << " ";
	}
	getchar();
}

运行结果：
在这里插入图片描述
使用GPU编程，普通变量编程实现：

#include"cuda_runtime.h"  
#include"device_launch_parameters.h"  
#include<iostream>  
  
#define _length 100  
  
using namespace std;  
  
//声明要调用的Copy_GPU函数  
extern "C" void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length);  
  
void main(int argc, char** argv)  
{  
    unsigned int *listSource = new unsigned int[_length];  
    unsigned int *listTarget = new unsigned int[_length];  
  
    //赋值  
    for (int i = 0; i < _length; i++)  
    {  
        listSource[i] = i;  
    }  
  
    // 调用Copy_GPU函数，Copy_GPU中会调用gpu端的kernel函数  
    Copy_GPU(listSource, listTarget, _length);  
  
    cout << "原始数据： ";  
    for (int i = 0; i < _length; i++)  
    {  
        cout << listSource[i] << " ";  
    }  
    cout << endl << endl << "通过GPU普通内存拷贝的数据： ";  
    for (int i = 0; i < _length; i++)  
    {  
        cout << listTarget[i] << " ";  
    }  
    getchar();  
}  
  
//核心代码，在gpu端执行的kernel，  
__global__ void Blending_Texture(unsigned int* listSource, unsigned int* listTarget, int size)  
{  
    //通过线程ID得到数组下标  
    int index = blockIdx.x * blockDim.x + threadIdx.x;  
  
    if (index < size)  
        listTarget[index] = listSource[index];  
}  
  
void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length)  
{  
    int data_size = length * sizeof(unsigned int);  
  
    unsigned int *dev_Source;  
    unsigned int *dev_Target;  
  
    //在设备上申请显存空间  
    cudaMalloc((void**)&dev_Source, data_size);  
    cudaMalloc((void**)&dev_Target, data_size);  
  
    //将host端的数据拷贝到device端  
    cudaMemcpy(dev_Source, listSource, data_size, cudaMemcpyHostToDevice);  
  
    //调用kernel  
    Blending_Texture << < ceil(_length / 10), 10 >> > (dev_Source, dev_Target, _length);  
  
    //将结果拷贝到host端 ☆host就是CPU  
    cudaMemcpy(listTarget, dev_Target, data_size, cudaMemcpyDeviceToHost);  
  
    //释放内存空间  
    cudaFree(dev_Source);  
    cudaFree(dev_Target);  
}  

#include"cuda_runtime.h"
#include"device_launch_parameters.h"
#include<iostream>
 
#define _length 100
 
using namespace std;
 
//声明要调用的Copy_GPU函数
extern "C" void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length);
 
void main(int argc, char** argv)
{
	unsigned int *listSource = new unsigned int[_length];
	unsigned int *listTarget = new unsigned int[_length];
 
	//赋值
	for (int i = 0; i < _length; i++)
	{
		listSource[i] = i;
	}
 
	// 调用Copy_GPU函数，Copy_GPU中会调用gpu端的kernel函数
	Copy_GPU(listSource, listTarget, _length);
 
	cout << "原始数据： ";
	for (int i = 0; i < _length; i++)
	{
		cout << listSource[i] << " ";
	}
	cout << endl << endl << "通过GPU普通内存拷贝的数据： ";
	for (int i = 0; i < _length; i++)
	{
		cout << listTarget[i] << " ";
	}
	getchar();
}
 
//核心代码，在gpu端执行的kernel，
__global__ void Blending_Texture(unsigned int* listSource, unsigned int* listTarget, int size)
{
	//通过线程ID得到数组下标
	int index = blockIdx.x * blockDim.x + threadIdx.x;
 
	if (index < size)
		listTarget[index] = listSource[index];
}
 
void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length)
{
	int data_size = length * sizeof(unsigned int);
 
	unsigned int *dev_Source;
	unsigned int *dev_Target;
 
	//在设备上申请显存空间
	cudaMalloc((void**)&dev_Source, data_size);
	cudaMalloc((void**)&dev_Target, data_size);
 
	//将host端的数据拷贝到device端
	cudaMemcpy(dev_Source, listSource, data_size, cudaMemcpyHostToDevice);
 
	//调用kernel
	Blending_Texture << < ceil(_length / 10), 10 >> > (dev_Source, dev_Target, _length);
 
	//将结果拷贝到host端 ☆host就是CPU
	cudaMemcpy(listTarget, dev_Target, data_size, cudaMemcpyDeviceToHost);
 
	//释放内存空间
	cudaFree(dev_Source);
	cudaFree(dev_Target);
}

运行结果：

在这里插入图片描述
使用GPU编程，一维纹理变量编程实现：

#include"cuda_runtime.h"  
#include"device_launch_parameters.h"  
#include<iostream>  
  
#define _length 100  
  
using namespace std;  
  
//声明纹理，用来绑定纹理，其实也就是个纹理标识  
texture<unsigned int, 1, cudaReadModeElementType> rT1;  
  
//声明要调用的Copy_GPU函数  
extern "C" void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length);  
  
void main(int argc, char** argv)  
{  
    unsigned int *listSource = new unsigned int[_length];  
    unsigned int *listTarget = new unsigned int[_length];  
  
    //赋值  
    for (int i = 0; i < _length; i++)  
    {  
        listSource[i] = i;  
    }  
  
    // 调用Copy_GPU函数，Copy_GPU中会调用gpu端的kernel函数  
    Copy_GPU(listSource, listTarget, _length);  
  
    cout << "原始数据： ";  
    for (int i = 0; i < _length; i++)  
    {  
        cout << listSource[i] << " ";  
    }  
    cout << endl << endl << "通过GPU纹理内存拷贝的数据： ";  
    for (int i = 0; i < _length; i++)  
    {  
        cout << listTarget[i] << " ";  
    }  
    getchar();  
}  
  
//核心代码，在gpu端执行的kernel，  
__global__ void Blending_Texture(unsigned int* listTarget, int size)  
{  
    //通过线程ID得到数组下标  
    int index = blockIdx.x * blockDim.x + threadIdx.x;  
  
    //通过纹理获取函数得到数据再运算  
    if (index < size)  
        listTarget[index] = tex1Dfetch(rT1, index);  
}  
  
void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length)  
{  
    int data_size = length * sizeof(unsigned int);  
  
    unsigned int *dev_Source;  
    unsigned int *dev_Target;  
  
    //在设备上申请显存空间  
    cudaMalloc((void**)&dev_Source, data_size);  
    cudaMalloc((void**)&dev_Target, data_size);  
  
    //将host端的数据拷贝到device端  
    cudaMemcpy(dev_Source, listSource, data_size, cudaMemcpyHostToDevice);  
  
    //绑定纹理，绑定的纹理标识对应的数据   
    cudaBindTexture(0, rT1, dev_Source);  
  
    //调用kernel  
    Blending_Texture << < ceil(_length / 10), 10 >> > (dev_Target, _length);  
  
    //将结果拷贝到host端 ☆host就是CPU  
    cudaMemcpy(listTarget, dev_Target, data_size, cudaMemcpyDeviceToHost);  
  
    //取消绑定  
    cudaUnbindTexture(rT1);  
  
    //释放内存空间  
    cudaFree(dev_Source);  
    cudaFree(dev_Target);  
}  

#include"cuda_runtime.h"
#include"device_launch_parameters.h"
#include<iostream>
 
#define _length 100
 
using namespace std;
 
//声明纹理，用来绑定纹理，其实也就是个纹理标识
texture<unsigned int, 1, cudaReadModeElementType> rT1;
 
//声明要调用的Copy_GPU函数
extern "C" void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length);
 
void main(int argc, char** argv)
{
	unsigned int *listSource = new unsigned int[_length];
	unsigned int *listTarget = new unsigned int[_length];
 
	//赋值
	for (int i = 0; i < _length; i++)
	{
		listSource[i] = i;
	}
 
	// 调用Copy_GPU函数，Copy_GPU中会调用gpu端的kernel函数
	Copy_GPU(listSource, listTarget, _length);
 
	cout << "原始数据： ";
	for (int i = 0; i < _length; i++)
	{
		cout << listSource[i] << " ";
	}
	cout << endl << endl << "通过GPU纹理内存拷贝的数据： ";
	for (int i = 0; i < _length; i++)
	{
		cout << listTarget[i] << " ";
	}
	getchar();
}
 
//核心代码，在gpu端执行的kernel，
__global__ void Blending_Texture(unsigned int* listTarget, int size)
{
	//通过线程ID得到数组下标
	int index = blockIdx.x * blockDim.x + threadIdx.x;
 
	//通过纹理获取函数得到数据再运算
	if (index < size)
		listTarget[index] = tex1Dfetch(rT1, index);
}
 
void Copy_GPU(unsigned int* listSource, unsigned int* listTarget, int length)
{
	int data_size = length * sizeof(unsigned int);
 
	unsigned int *dev_Source;
	unsigned int *dev_Target;
 
	//在设备上申请显存空间
	cudaMalloc((void**)&dev_Source, data_size);
	cudaMalloc((void**)&dev_Target, data_size);
 
	//将host端的数据拷贝到device端
	cudaMemcpy(dev_Source, listSource, data_size, cudaMemcpyHostToDevice);
 
	//绑定纹理，绑定的纹理标识对应的数据 
	cudaBindTexture(0, rT1, dev_Source);
 
	//调用kernel
	Blending_Texture << < ceil(_length / 10), 10 >> > (dev_Target, _length);
 
	//将结果拷贝到host端 ☆host就是CPU
	cudaMemcpy(listTarget, dev_Target, data_size, cudaMemcpyDeviceToHost);
 
	//取消绑定
	cudaUnbindTexture(rT1);
 
	//释放内存空间
	cudaFree(dev_Source);
	cudaFree(dev_Target);
}

运行结果：
在这里插入图片描述
再举一个使用CUDA+OpenCv编程，实现复制一幅图像的例子：

#include"cuda_runtime.h"  
#include<iostream>  
#include<highgui/highgui.hpp>  
#include<imgproc/imgproc.hpp>  
  
#define DIM 512   //图像尺寸  
  
using namespace std;  
using namespace cv;  
  
//一维纹理声明  
texture<unsigned char, 1, cudaReadModeElementType> rT1;  
  
__global__ void Kernel_Copy(unsigned char* imageTarget)  
{  
    int x = threadIdx.x + blockIdx.x*blockDim.x;  
    int y = threadIdx.y + blockIdx.y*blockDim.y;  
    int offset = x + y*blockDim.x*gridDim.x;  
  
    //复制图像  
    imageTarget[offset * 3 + 2] = tex1Dfetch(rT1, offset * 3 + 2);  
    imageTarget[offset * 3 + 1] = tex1Dfetch(rT1, offset * 3 + 1);  
    imageTarget[offset * 3 + 0] = tex1Dfetch(rT1, offset * 3 + 0);  
}  
  
void main(int argc, char** argv)  
{  
    Mat image = imread("D:\\lena.jpg");  
    Mat imageSource;  
    resize(image, imageSource, Size(DIM, DIM)); //调整图像大小  
  
    Mat imageTarget = Mat(Size(DIM, DIM), CV_8UC3, Scalar::all(0));  
  
    //分配空间  
    unsigned char *dev_imageSource;  
    unsigned char *dev_imageTarget;  
    cudaMalloc((void**)&dev_imageSource, 3 * imageSource.rows*imageSource.cols);  
    cudaMalloc((void**)&dev_imageTarget, 3 * imageSource.rows*imageSource.cols);  
  
    cudaMemcpy(dev_imageSource, imageSource.data, 3 * imageSource.cols*imageSource.rows, cudaMemcpyHostToDevice);  
    cudaMemcpy(dev_imageTarget, imageTarget.data, 3 * imageSource.cols*imageSource.rows, cudaMemcpyHostToDevice);  
  
    //绑定纹理  
    cudaBindTexture(0, rT1, dev_imageSource);  
  
    dim3 grids(DIM / 16, DIM / 16);  
    dim3 threads(16, 16);  
    //调用kernel  
    Kernel_Copy << < grids, threads >> > (dev_imageTarget);  
  
    //将结果拷贝到host端 ☆host就是CPU  
    cudaMemcpy(imageTarget.data, dev_imageTarget, 3 * imageSource.cols*imageSource.rows, cudaMemcpyDeviceToHost);  
  
    imshow("CUDA纹理内存使用示例", imageTarget);  
    waitKey();  
  
    //解除纹理绑定  
    cudaUnbindTexture(rT1);  
  
    cudaFree(dev_imageSource);  
    cudaFree(dev_imageSource);  
}  


#include"cuda_runtime.h"
#include<iostream>
#include<highgui/highgui.hpp>
#include<imgproc/imgproc.hpp>
 
#define DIM 512   //图像尺寸
 
using namespace std;
using namespace cv;
 
//一维纹理声明
texture<unsigned char, 1, cudaReadModeElementType> rT1;
 
__global__ void Kernel_Copy(unsigned char* imageTarget)
{
	int x = threadIdx.x + blockIdx.x*blockDim.x;
	int y = threadIdx.y + blockIdx.y*blockDim.y;
	int offset = x + y*blockDim.x*gridDim.x;
 
	//复制图像
	imageTarget[offset * 3 + 2] = tex1Dfetch(rT1, offset * 3 + 2);
	imageTarget[offset * 3 + 1] = tex1Dfetch(rT1, offset * 3 + 1);
	imageTarget[offset * 3 + 0] = tex1Dfetch(rT1, offset * 3 + 0);
}
 
void main(int argc, char** argv)
{
	Mat image = imread("D:\\lena.jpg");
	Mat imageSource;
	resize(image, imageSource, Size(DIM, DIM)); //调整图像大小
 
	Mat imageTarget = Mat(Size(DIM, DIM), CV_8UC3, Scalar::all(0));
 
	//分配空间
	unsigned char *dev_imageSource;
	unsigned char *dev_imageTarget;
	cudaMalloc((void**)&dev_imageSource, 3 * imageSource.rows*imageSource.cols);
	cudaMalloc((void**)&dev_imageTarget, 3 * imageSource.rows*imageSource.cols);
 
	cudaMemcpy(dev_imageSource, imageSource.data, 3 * imageSource.cols*imageSource.rows, cudaMemcpyHostToDevice);
	cudaMemcpy(dev_imageTarget, imageTarget.data, 3 * imageSource.cols*imageSource.rows, cudaMemcpyHostToDevice);
 
	//绑定纹理
	cudaBindTexture(0, rT1, dev_imageSource);
 
	dim3 grids(DIM / 16, DIM / 16);
	dim3 threads(16, 16);
	//调用kernel
	Kernel_Copy << < grids, threads >> > (dev_imageTarget);
 
	//将结果拷贝到host端 ☆host就是CPU
	cudaMemcpy(imageTarget.data, dev_imageTarget, 3 * imageSource.cols*imageSource.rows, cudaMemcpyDeviceToHost);
 
	imshow("CUDA纹理内存使用示例", imageTarget);
	waitKey();
 
	//解除纹理绑定
	cudaUnbindTexture(rT1);
 
	cudaFree(dev_imageSource);
	cudaFree(dev_imageSource);
}

运行结果：
在这里插入图片描述

元宇宙MetaAI
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CUDA：在CUDA中使用纹理获取的实例
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-21 131
CUDA：在CUDA中使用纹理获取的实例
基于纹理内存的CUDA热传导模拟
09-24
纹理内存是只读内存，与常量内存相同的是，纹理内存也缓存在芯片中，因此某些情况下，它能减少对内存的请求并提供更高效的内存宽带。纹理内存专门为那些内存访问模式中存在大量空间局部性的图形应用程序而设计的。在某个计算应用程序中，这意味着一个线程读取的位置可能与邻近线程读取的位置“非常接近”。纹理缓存为了加速访问不连续的地址而设计的。
CUDA by example Chapter7 纹理内存
wolfcsharp的博客
09-02 401
纹理内存纹理内存简介热传导模拟简单的传热模型代码中温度更新的计算GPU不使用纹理内存的热传导模拟计算GPU使用一维纹理内存的热传导模拟计算GPU使用二维纹理内存的热传导模拟计算 纹理内存简介 和常量内存一样，纹理内存是另一种类型的只读内存。纹理内存是专门为那些在内存访问模式中存在大量空间局部性的图形应用程序而设计的。假如在某个计算应用程序中，一个线程读取的位置与邻近线程读取的位置"非常接近"，使用...
CUDA中共享内存、常量内存和纹理内存的概念和应用（小白入门）
小P的博客
03-09 3309
刚接触CUDA，结合教材和资料整理了这篇共享内存、常量内存和纹理内存的基础内容，希望能帮到路过的你:P
CUDA：实现使用纹理内存(附完整源码)
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-01 52
CUDA：实现使用纹理内存(附完整源码)
CUDA 纹理内存
weixin_30381793的博客
04-11 232
1、概述 　　纹理存储器中的数据以一维、二维或者三维数组的形式存储在显存中，可以通过缓存加速访问，并且可以声明大小比常数存储器要大的多。 　　在kernel中访问纹理存储器的操作称为纹理拾取(texture fetching)。将显存中的数据与纹理参照系关联的操作，称为将数据与纹理绑定(texture binding). 　　显存中可以绑定到纹理的数据有两种，分别是普通的线性存储器...
CUDA 学习——纹理内存（CUDA实战 第七章）
ygf666的博客
05-18 2299
1. 纹理内存使用 纹理内存的使用依赖于API函数。下面直接给出常见的使用流程： 1.1 声明纹理变量 texture<Type, Dim, ReadMode> VarName; //Type: 前面提到的基本的整型和浮点类型，以及其它的对齐类型 //Dim： 纹理数组的维度，值为1或2或3，默认缺省为1 //ReadMode：cudaReadModelNormalizedFloat 或 cudaReadModelElementType(默认) NOTE： cudaReadModelNor
CUDA By Example(六)——纹理内存
hhhcbw的博客，欢迎各位来访
11-17 963
CUDA C中纹理内存使用的说明，并以热传导模拟为例
记一次CUDA编程
02-25
这个月6号开始，着手解决一个具有实际意义的计算任务。任务数据有9879896条，每条包含30个整数，任务是计算每两条数据之间的斯皮尔相关系数及其P值。原始数据只有500+MB，因此我并不认为这是个多么大的计算任务。...
CUDA纹理使用
11-06
对CUDA中如何使用纹理进行了总结和详细说明
cuda纹理使用实例源代码
11-25
cuda纹理使用实例源代码，看书不太懂得可以参考这个实例
CUDA总结：纹理内存
热门推荐
Kelvin_Yan的专栏
01-04 1万+
来源：《CUDA_Runtime_API》、《CUDA_C_Programming_Guide-V8.0》 纹理内存和表面内存（surface memory）实质上是全局内存的一个特殊形态，全局内存被绑定为纹理内存（表面内存），对其的读（写）操作将通过专门的texture cache（纹理缓存）进行，其实称为纹理缓存更加贴切。 纹理缓存的优势：纹理缓存具备硬件插值特性，可以实现最近邻插值和线性
CUDA——纹理内存（纹理参考）
weixin_44444450的博客
02-09 1143
纹理内存 1.1纹理类型 CUDA支持GPU上的一部分纹理硬件（它们原本是为图形处理而设计的），所以，纹理内存一般会用于加速图片的滤波和图片的resize操作上。 纹理内存实质上市全局内存的特殊形态，全局内存被绑定为纹理内存，对其的读，写操作将通过专门的texture cache（纹理缓存）进行。 纹理缓存的优势：纹理缓存具备硬件插值特性，可以实现最近邻插值和线性插值。纹理缓存访问二维矩阵的领域会...
VS2017 CUDA编程学习10：纹理内存
DU_YULIN的博客
11-03 1045
文章目录前言1. 纹理内存的理解2. C++ CUDA实现常量内存使用3. 执行结果总结学习资料 VS2017 CUDA编程学习1：CUDA编程两变量加法运算 VS2017 CUDA编程学习2：在GPU上执行线程 VS2017 CUDA编程学习3：CUDA获取设备上属性信息 VS2017 CUDA编程学习4：CUDA并行处理初探 - 向量加法实现 VS2017 CUDA编程学习5：CUDA并行执行-线程 VS2017 CUDA编程学习6: GPU存储器架构 VS2017 CUDA编程学习7：线程同步-共享内
cuda纹理内存使用
yyp1164868098的专栏
06-08 447
http://blog.csdn.net/linj_m/article/details/41522573
CUDA纹理内存入门详解
hgkjbm的博客
03-31 2842
CUDA 进阶技巧 纹理内存 入门指南
关于CUDA-纹理内存的使用
czw0723的博客
04-04 1683
简要介绍一下 还是直接上代码：---有个要点注意一下，由于init_data操作的是设备内存，所以必须在设备代码中操作，为了简单起见所以直接使用了<<<1,1>>>直接初始化，还是停留在串行的程序设计中。然后调用1个块1024条线程进行并行进入设备代码，输出。主要是记住，使用纹理内存必须的5个步骤------分配内存-绑定内存-核函数调用-接触绑定-释放内...
cuda 核函数声明一维数组
08-15
在 CUDA 中声明一个一维数组作为核函数的参数，可以按照以下方式进行： ```cpp __global__ void yourKernelFunction(float* array, int size) { // 核函数的代码逻辑 // 使用 array 数组进行计算 } int main() {...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值