CUDA一维纹理内存

CUDA 学习——纹理内存(CUDA实战 第七章) 1. 纹理内存使用 纹理内存的使用依赖于API函数。下面直接给出常见的使用流程: 1.1 声明纹理变量 texture<Type, Dim, ReadMode> VarName; //Type: 前面提到的基本的整型和浮点类型,以及其它的对齐类型 //Dim: 纹理数组的维度,值为1或2或3,默认缺省为1 //ReadMode:cudaReadModelNormalizedFloat 或 cudaReadModelElementType(默认) NOTE: cudaReadModelNor 阅读详情

纹理一词来源于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);
}

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

cuda 三维纹理使用 cuda 三维纹理使用一维、二维纹理使用三维纹理内存官方指南 一维、二维纹理使用 一维、二维纹理的使用相对简单,只需像定义全局变量一样,在代码最前面声明texture,如下例子 // 定义了一个int4类型的,read模式的一维纹理 size texture<int4, 1, cudaReadModeElementType> size; int4 imageSize = make_int4(width,height,depth,0); //这里的0是因为我只用到了int4的前面三个,但是 阅读详情

相关推荐

第八章 CUDA内存应用与性能优化篇(下篇)

学习我的教程专栏,你将绝对能实现CUDA工程化,实现环境安装、index计算、kernel核函数编程、内存优化与steam性能优化、原子操作、nms的cuda算子、yolov5的cuda部署等内容,并开源教程源码。以上章节中,我们已经比较熟练掌握如何使用cuda编写自己想要的计算逻辑,已能成功编写cuda代码了。那么,另外一个重要问题值得我们关注,如何优化其性能,使其工程部署能加速运行了。而这种性能优化与cuda内存密切相关。为此,我们在本节中介绍cuda内存相关内容,并附其源码。

weixin_38252409的博客 1327

什么是GPU,GPU怎么工作的,什么是图形的渲染,渲染怎么完成的。

参考博客:博客1, 博客2, 博客3. 首先回答什么是GPU: GPU主要完成对3D图形的处理,即图形的生成渲染。 GPU怎么工作的: 概况来讲:就是完成3D图形的生成,将图形映射到相应的像素点上,对每个像素进行计算确定最终颜色并完成输出。 1.顶点处理:这阶段GPU读取描述3D图形外观的顶点数据并根据顶点数据确定3D图形的形状及位置关系,建立起3D图形的骨架。在支持DX8和D

Juery_Lee的专栏 4018

FID指标实战:如何用Python快速计算生成图像的质量分数(附完整代码)

本文详细介绍了如何使用Python计算Fréchet Inception Distance(FID)指标,以评估生成图像的质量。通过完整的代码示例和优化技巧,帮助开发者快速实现FID计算,并解读分数背后的实际意义,适用于GAN和扩散模型的性能评估。

weixin_28718487的博客 379

GPU 纹理

纹理映射(Texture Mapping)是绘制复杂场景真实感图形最为常用的技术,它可以通过纹理来表达表面丰富的几何细节和光照细节,甚至可以通过映射后纹理的变形来表达物体的几何形状:在未增加物体多边形数情况下,增强了物体的真实感效果。...

bravegogo的专栏 1816

新手别怕!用‘东北天’和‘右前上’坐标系,5分钟搞懂惯性导航姿态矩阵(含Python验证代码)

本文通过‘东北天(ENU)’和‘右前上(RFU)’坐标系,详细解析惯性导航中的姿态矩阵概念。包含Python代码验证,帮助新手快速理解坐标变换、欧拉角及旋转矩阵的构建与应用,特别强调有限转动不可交换性与无限转动次序无关的区别。

weixin_29062255的博客 333

Synopsys工具链实战:如何用VCS、DC、ICC和Calibre跑通你的第一个数字IC设计项目?

本文详细介绍了如何使用Synopsys工具链(VCS、Design Compiler、ICC和Calibre)完成数字IC设计项目,从RTL代码到GDSII版图的全流程。涵盖环境配置、RTL设计验证、逻辑综合、物理实现及签核验证等关键步骤,帮助工程师掌握高效的数字IC设计流程。

weixin_42525005的博客 199

GPU介绍,图片格式、纹理、size

介绍了各种移动设备所使用的GPU,以及各个GPU所支持的压缩纹理的格式和使用方法。 1. 移动GPU大全 目前移动市场的GPU主要有四大厂商系列: 1)Imagination Technologies的PowerVR SGX系列 代表型号:PowerVR SGX 535、PowerVR SGX 540、PowerVR SGX 543MP、PowerVR SGX 554MP等 代表

u011612549的专栏 4054

基于Multisim设计电子密码锁

一、设计任务与要求:(可软件仿真实现)1)基本要求:设计一个数字密码锁,要求只有按正确的顺序,输入正确的密码,方能输出开锁信号,实现开锁。设置三个正确的密码键和若干个伪键,任何伪键按下后,密码锁都无法打开。每次只能接受四次按键信号,而且第四个键只能是“确定”或者“重输键”,其他无效。能显示已输入键的个数2)扩展要求:第一次密码输错后,可以输入第二次,但是连续三次输错,密码将被锁,必须按复位键才能解锁。

ablinger的博客 4425

计算机图形学:纹理综述

纹理综述

最不正经的计算机专业学生 1835

2025认证杯数学建模第二阶段B题完整论文(代码齐全):谣言在社交网络上的传播

这需要我们深入理解抽样检测所得的次品率的不确定性及其对生产决策的影响。对于问题二的决策分析,我们可将其细分为四个关键的决策节点,分别是零件 1 的质量检测、零件 2 的质量检测、成品的质量检测,以及成品检测不合格时的拆解处理。该策略的实施,保证了在算法迭代过程中,表现最为优异的个体能够得到保留,并顺利传递至下一代,从而保障了算法在寻求最优解过程中的收敛性和优化效果。因此,我们采用假设检验的方法,将次品分布构造成 t 分布,从而确定在相应置信度的条件下,抽样次数 n 和次品数 k 所需满足的要求。

2301_81596622的博客 1009

Reeds-Shepp曲线公式推导及代码实现-第二部分(共三部分)

文章目录2. Reeds-Shepp求解2.1 L+S+L+L^+S^+L^+L+S+L+2.2 L+S+R+L^+S^+R^+L+S+R+2.3 L+R−L+L^+R^-L^+L+R−L+2.4 L+R−L−L^+R^-L^-L+R−L−2.5 L+R+L−L^+R^+L^-L+R+L−2.6 L+Rβ+Lβ−R−L^+R_{\beta}^+L_{\beta}^-R^-L+Rβ+​Lβ−​R−2.7 L+Rβ−Lβ−R+L^+R_{\beta}^-L_{\beta}^-R^+L+Rβ−​Lβ−​R+2.8

jianmo的博客 1213

GPU渲染管线之旅|04 纹理和采样

上一篇讨论了顶点着色器,涵盖了GPU通用着色器处理单元的一些内容。它们都仅仅是向量处理单元, 但是当我们在访问Resource的时候,通常都不是这种向量的形式,所以GPU中还需要另一个专门用来在Pipeline中处理整数的单元:Texture Sampler. 这个单元内部相对比较复杂,复杂(也很有趣)到我们需要用单独的一篇文章来讨论它们。 1.纹理阶段 在我们开始了解真正的纹理操作之前,让我们先对API阶段的纹理操作有个完整的认识。在D3D11中,这主要由三个部分组成: 采样阶段。设置滤波模式,设置寻址

翼遥君的博客 2555

【异常】Claude Code 第三方API 400报错(thinking type should be enabled or disabled)解决方案

摘要: Claude Code接入第三方API端点时出现400参数错误,主要因新版默认启用的Adaptive Thinking功能与旧版接口参数格式不兼容(需thinking: {type: "adaptive"},但第三方仅支持布尔值)。解决方案为修改本地settings.json配置文件,添加"CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING": "1"环境变量并重启客户端,即可恢复思考模式功能。Adaptive Th

奶爸的编程之路,也就一周冷个三天 1万+

CUDA By Example(六)——纹理内存

CUDA C中纹理内存使用的说明,并以热传导模拟为例

hhhcbw的博客,欢迎各位来访 1568

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

关于CUDA-纹理内存的使用

简要介绍一下 还是直接上代码:---有个要点注意一下,由于init_data操作的是设备内存,所以必须在设备代码中操作,为了简单起见所以直接使用了<<<1,1>>>直接初始化,还是停留在串行的程序设计中。然后调用1个块1024条线程进行并行进入设备代码,输出。主要是记住,使用纹理内存必须的5个步骤------分配内存-绑定内存-核函数调用-接触绑定-释放内...

czw0723的博客 2115

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

CUDA(Ⅷ):纹理内存(Texture Memory)

1.学习目标: 了解纹理内存的性能特性 了解如何在CUDA C中使用一维纹理内存 了解如何在CUDA C中使用二维纹理内存 2.背景提出: 特定环境中使用特殊的内存将极大地提升应用程序的性能。与Constant Memory相似,Texture Memory同样缓存在芯片上,只读内存,在某些情况下,能减少对内存的请求并提供更高效的内存带宽。Texture Mmeory是专门为那些在内存访...

每天进步一点点! 7386

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

CUDA 二维纹理的创建和使用测试

CUDA 复杂问题 + 细节问题 解答见CUDA复杂问题 + 细节问题 解答 首先先把程序贴上: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include <cuda_runtime_api.h> #include <cuda.h> #include <iostream> #define width 10 #define height 11 using std::cout;..

Dezeming的博客 2548

《CUDA By Example》【Chapter 07】纹理内存 ?

7.1 本章目标 纹理内存和常量内存一样,都是只读内存,用来减少带宽流量,提升性能。 1,了解纹理内存的特性 2,了解如何在CUDA C中使用一维纹理内存 3,了解如何在CUDA C中使用二维纹理内存 7.2 纹理内存简介(Texture Memory) 7.3 热传导模拟...

wondervictor的博客 357

cuda 纹理内存 texture memory

纹理内存的使用

驽马十驾,功在不舍;锲而不舍,金石可镂。 1278

CUDA 复杂问题 + 细节问题 详细解答

CUDA 复杂问题 + 细节问题 详细解答 见 本人在使用CUDA做项目时,会遇到很多比较细节或者复杂的问题,在这里以博客的形式记录下来,喜欢的可以关注收藏。 CUDA纹理

Dezeming的博客 2354

CUDA学习之纹理内存

1、纹理存储器的特性     纹理存储器中的数据以一维、二维或者三维数组的形式存储在显存中,可以通过缓存加速访问,并且可以声明大小比常数存储器要大的多。在kernel中访问纹理存储器的操作称为纹理拾取(texture fetching)。将显存中的数据与纹理参照系关联的操作,称为将数据与纹理绑定(texture binding). 显存中可以绑定到纹理的数据有两种,分别是普通的线性存储器和c

DreamerZhang的专栏 6700

【CUDA学习笔记】1.纹理内存

并没有一个专门的显存空间作为纹理内存,而是数据以一维、二维或者三维数组的形式存储在显存中,可以通过缓存加速访问的内存,并且可以声明大小比常数存储器要大的多。 调用纹理获取函数读取纹理的过程称为纹理获取(texture fetch)。每一个纹理获取都需要指定一个参数,如果使用纹理对象API则该参数称为纹理对象,使用纹理引用API时称为纹理引用参数。 ·纹理是被获取的一块纹理内存。纹理对象在运行时

dgh_dean的博客 1385

Cuda里面的Texture Memory

how to use cuda textute memory

Uwen 5549
上一篇: Ubuntu18 安装CUDA 11 Cudnn8
下一篇: md 文件的编辑
元宇宙MetaAI
博客等级 码龄10年 331粉丝 333原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值