主要整理了N多年前（2013年）学习CUDA的时候开始总结的知识点，好长时间不写CUDA代码了，现在LLM推理需要重新学习CUDA编程，看来出来混迟早要还的。
1.CUDA数组
解析：CUDA数组是使用cudaMallocArray()、cudaMalloc3DArray()分配的，使用cudaFreeArray()释放。
2.OpenGL/DirectX Interoperability
解析：OpenGL的帧缓冲与DirectX的顶点缓冲可以被映射到CUDA可操作的地址空间中，让CUDA读写帧缓冲里面的数据。OpenGL与CUDA互操作，主要是缓冲对象的注册与取消注册、映射与取消映射。如下所示：
（1）cudaGLRegisterBufferObject()：缓冲对象注册。
（2）cudaGLUnregisterBufferObject()：取消缓冲对象注册。
（3）cudaGLMapBufferObject()：映射缓冲对象。
（4）cudaGLUnmapBufferObject()：取消映射。
（5）cudaGLMapBufferObject()：映射缓冲对象后，CUDA可以使用其返回的设备存储器地址读取和写入缓冲对象。Direct 3D与CUDA互操作，主要是Direct 3D设备的设置、资源的注册、资源映射、映射后信息获取、取消映射、取消注册。以Direct3D9为例，如下所示：
（1）cudaD3D9SetDirect3DDevice()：Direct3D设备的设置。
（2）cudaD3D9RegisterResource ()：注册资源。
（3）cudaD3D9MapResources()：资源映射。
（4）cudaD3D9ResourceGetMappedPointer()：获取资源映射后的CUDA设备存储器地址。
（5）cudaD3D9ResourceGetMappedSize()：获取大小。
（6）cudaD3D9ResourceGetMappedPitch()：获取间隔。
（7）cudaD3D9UnmapResources()：取消映射。
（8）cudaD3D9UnregisterResource()：取消注册。
3.CUDA软件环境
解析：
（1）NVIDIA Jetson TK1：NVIDIA提供的基于GPU的嵌入式开发板。
（2）NVRTC（NVIDIA Runtime Compilation）：基于CUDA C++的运行时编译库。
（3）cuSolver：基于cuBLAS和cuSPARSE库的高级包。
（4）ptxas：PTX汇编工具。
（5）cuobjdump：CUDA目标文件转储工具。
（6）nvidia-smi：英伟达系统管理接口。
（7）CUDA Binary Utilities：cuobjdump；nvdisasm；nvprune。
（8）CUDA-MEMCHECK：CUDA工具套件中提供的独立的内存检查实用程序。
4.cudaGetLastError和cudaGetErrorString
解析：
（1）cudaError_t cudaGetLastError( void )：返回同一主线程中运行时调用所返回的最新错误，并将其重置为cudaSuccess。
（2）cudaError_t cudaGetLastError( void )：返回同一主线程中运行时调用所返回的最新错误，并将其重置为cudaSuccess。
5.零拷贝内存
解析：可以在CUDA核函数中直接访问主机内存，不需要复制到GPU。如下所示：
（1）开辟Host内存空间：cudaHostAlloc((void**)&host_data_to_device, size_in_bytes, cudaHostAllocMapped);
（2）获取Device端指针：cudaHostGetDevicePointer(&dev_host_data_to_device, host_data_to_device, 0);
说明：零拷贝内存技术适用于计算密集型、读取写入次数少的程序中。
6.static函数
解析：静态函数（内部函数）只在声明的文件中可见，不能被其它文件调用。
7.cudaError_t和checkCudaErrors
解析：
（1）#include <helper_cuda.h>
（2）#include <helper_functions.h>
8.texture<type, dimension, readtype> texreference;[4]
解析：
（1）type：int，uchar，float等。
（2）dimension：1，2，3。
（3）readtype：cudaReadModeNormalizedFloat（归一化），cudaReadModeElementType（默认）。
9.纹理存储器绑定[5]
解析：纹理存储器绑定有两种，一种是绑定到cudaMalloc()，cudaMemcpy()开辟的一维数组，另一种是绑定到cudaMallocArray，cudaMemcpyToArray开辟的二维数组或者三维数组。
10.cudaCreateChannelDesc
解析：__host__ cudaChannelFormatDesc cudaCreateChannelDesc ( int x, int y, int z, int w, cudaChannelFormatKind f )：Returns a channel descriptor using the specified format。
说明：where cudaChannelFormatKind is one of cudaChannelFormatKindSigned, cudaChannelFormatKindUnsigned, or cudaChannelFormatKindFloat.
11.cudaBindTextureToArray
解析：__host__ cudaError_t cudaBindTextureToArray ( const textureReference* texref, cudaArray_const_t array, const cudaChannelFormatDesc* desc )：Binds an array to a texture。
说明：texref：Texture to bind；array：Memory array on device；desc：Channel format.
12.CUDA同步函数
解析：
（1）cudaDeviceSynchronize()：停止CPU端线程执行，直到GPU端完成CUDA任务，包括kernel、数据拷贝等。
（2）cudaThreadSynchronize()：和cudaDeviceSynchronize()基本相同，过时版本。
（3）cudaStreamSynchronize()：该方法接受一个Stream ID，它将阻止CPU执行直到GPU端完成相应Stream ID的CUDA任务，但并不关心其它Stream ID中的CUDA任务是否完成。
13.cudaGetLastError
解析：__host__ __device__ cudaError_t cudaGetLastError ( void )：返回运行时调用的最后错误。
14.PGM图像格式
解析：PGM是Portable Gray Map的缩写，它是灰度图像格式中一种最简单的格式标准。
15.CUDA架构
解析：Tesla架构，Femi架构，Kepler架构，Maxwell架构，Pascal架构，Volta架构。
16.tex2D
解析：在核函数中访问纹理存储器的操作称为纹理拾取。通过tex2D()来读取纹理内存中的数据。
17.simpleTexture.cu代码剖析
解析：
#include <iostream>
#include <cuda_runtime.h>
#include <helper_image.h>
using namespace std;
const char *imagePath = "./data/lena_bw.pgm";
const char *outputFilename = "./data/lena_bw_out.pgm";
const float angle = 0.5f;
// Texture reference for 2D float texture
texture<float, 2, cudaReadModeElementType> tex;
// @param outputData output data in global memory
__global__ void transformKernel(float *outputData, int width, int height, float theta)
{
// calculate normalized texture coordinates
unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
float u = (float)x - (float)width / 2;
float v = (float)y - (float)height / 2;
u /= (float)width;
v /= (float)height;
float tu = u*cosf(theta) - v*sinf(theta);
float tv = v*cosf(theta) + u*sinf(theta);
// read from texture and write to global memory
outputData[y * width + x] = tex2D(tex, tu + 0.5f, tv + 0.5f);
}
int main(int argc, char **argv)
{
unsigned int width = 512;
unsigned int height = 512;
unsigned int size = width * height * sizeof(float);
// Allocate device memory for result
float *dData = NULL;
cudaMalloc((void **)&dData, size);
float *hData = NULL;
sdkLoadPGM(imagePath, &hData, &width, &height);
// Allocate array and copy image data
cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);
cudaArray *cuArray;
cudaMallocArray(&cuArray, &channelDesc, width, height);
cudaMemcpyToArray(cuArray, 0, 0, hData, size, cudaMemcpyHostToDevice);
// Set texture parameters
tex.addressMode[0] = cudaAddressModeWrap;
tex.addressMode[1] = cudaAddressModeWrap;
tex.filterMode = cudaFilterModeLinear;
tex.normalized = true;
// Bind the array to the texture
cudaBindTextureToArray(tex, cuArray, channelDesc);
dim3 dimBlock(8, 8, 1);
dim3 dimGrid(width / dimBlock.x, height / dimBlock.y, 1);
// Execute the kernel
transformKernel << <dimGrid, dimBlock, 0 >> >(dData, width, height, angle);
// Allocate mem for the result on host side
float *hOutputData = (float *)malloc(size);
// copy result from device to host
cudaMemcpy(hOutputData, dData, size, cudaMemcpyDeviceToHost);
sdkSavePGM(outputFilename, hOutputData, width, height);
cudaFree(dData);
cudaFreeArray(cuArray);
}
18.Texrure<Type, Dim, ReadMode> texRef;
解析：
（1）Type：数据类型。
（2）Dim：纹理引用维数。
（3）ReadMode：cudaReadModeNormalizedFloat或cudaReadModeElementType。
说明：纹理引用只能声明为全局静态变量，不能作为函数参数传递。
19.struct cudaChannelFormatDesc { int x, y, z, w; enum cudaChannelFormatKind f;};
解析：
（1）结构体中的成员x，y，z以及w指定了纹理元素中每个成员的比特数。比如，仅包含一个浮点元素的纹理对应的x为32，其它成员的值为0。
（2）结构体cudaChannelFormatKind指明了该数据的类型，是带符号的整数（cudaChannelFormatKindSigned），还是无符号整数（cudaChannelFormatKindUnsigned），或者浮点数（cudaChannelFormatKindFloat）。
20.struct cudaChannelFormatDesc cudaCreateChannelDesc(int x,int y,int z,int w,enum cudaChannelFormatKind f);
解析：通过函数cudaCreateChannelDesc创建cudaChannelFormatDesc结构体。
21.cudaError_t cudaMallocArray(struct cudaArray** array, const struct cudaChannelFormatDesc* desc, size_t width, size_t height);
解析：根据cudaChannelFormatDesc结构desc分配一个CUDA 数组，并返回一个在*array的新CUDA数组的句柄。
22.cudaError_t cudaMemcpyToArray(struct cudaArray* dstArray, size_t dstX, size_t dstY, const void* src, size_t count, enum cudaMemcpyKind kind);
解析：拷贝count字节，从src指向的内存区域到dstArray指向的CUDA数组，从数组的左上角（dstX, dstY）开始，kind可以是cudaMemcpyHostToHost，cudaMemcpyHostToDevice，cudaMemcpyDeviceToHost，或cudaMemcpyDeviceToDevice的拷贝方向。
23.struct textureReference {int normalized; enum cudaTextureFilterMode filterMode; enum cudaTextureAddressMode addressMode[2]; struct cudaChannelFormatDesc channelDesc;}[1]
解析：
（1）normalized：归一化模式。
（2）filterMode：cudaFilterModePoint或cudaFilterModeLinear。（滤波模式）
（3）addressMode：cudaAddressModeClamp或cudaAddressModeWrap。（寻址模式）
24.cudaError_t cudaBindTextureToArray(const struct textureReference* texRef, const struct cudaArray* array, const struct cudaChannelFormatDesc* desc);
解析：绑定CUDA数组array到纹理引用texRef。desc描述了在纹理拾取时内存如何被解释。任何之前被绑定到texRef的内存将被解除绑定。
25.CUDA数组纹理操作
解析：
（1）template<class Type, enum cudaTextureReadMode readMode> Type tex1D(texture<Type, 1, readMode> texRef, float x);
（2）template<class Type, enum cudaTextureReadMode readMode> Type tex2D(texture<Type, 2, readMode> texRef, float x, float y);
说明：tex1D和tex2D函数通过纹理坐标x和y拾取CUDA数组中绑定到纹理引用texRef的区域。
26.CPU/GPU并发性
解析：CPU/GPU并发性指CPU在已经发送一些请求给GPU后能够继续处理的能力。其实，CPU/GPU并发性最重要的用处就是隐藏来自GPU请求任务的开销。
27.cudaError_t cudaThreadSynchronize(void);
解析：阻止直到设备上所有请求任务执行完毕。cudaThreadSynchronize()返回一个错误，如果其中一个任务失败。
28.cudaError_t cudaThreadExit(void);
解析：清除主机调用的线程中所有runtime相关的资源。任何后来的API将重新初始化runtime。
29.cudaError_t cudaStreamCreate(cudaStream_t* stream);
解析：创建一个流。
30.cudaError_t cudaStreamQuery(cudaStream_t stream);
解析：返回cudasuccess，如果所有流中的操作完成。返回cudaErrorNotReady，如果不是。
31.cudaError_t cudaStreamSyncronize(cudaStream_t stream)
解析：阻止直到设备上完成流中的所有操。
32.cudaError_t cudaStreamDestroy(cudaStream_t stream);
解析：销毁一个流。
33.cudaError_t cudaEventCreate(cudaEvent_t* event);
解析：创建一个事件。
34.cudaError_t cudaEventRecord(cudaEvent_t event, CUstream stream);
解析：记录一个事件。如果stream是非零的，当流中所有的操作完毕，事件被记录；否则，当CUDA context中所有的操作完毕，事件被记录。由于这个操作是异步的，必须使用cudaEventQuery和/或cudaEventSyncronize 来决定何时事件被真的记录了。
35.cudaError_t cudaEventQuery(cudaEvent_t event);
解析：返回cudaSuccess，如果事件被真的记录了。返回cudaErrorNotReady，如果不是。
36.cudaError_t cudaEventSyncronize(cudaEvent_t event);
解析：阻止直到事件被真的记录了。如果cudaEventRecord()在这个事件中没有被调用，函数返回cudaErrorInvalidValue。
37.cudaError_t cudaEventDestroy(cudaEvent_t event);
解析：销毁一个事件。
38.cudaError_t cudaEventElapsedTime(float* time, cudaEvent_t start, cudaEvent_t end);
解析：计算两个事件之间花费的时间（millisecond）。如果事件未被记录，函数返回cudaErrorInvalidValue。
39.cudaError_t cudaGetDeviceCount(int* count);
解析：返回计算兼容性大于等于1.0的设备数量到指针*count。
40.cudaError_t cudaSetDevice(int dev);
解析：记录dev作为设备在哪个活动的主机线程中执行设备代码。
41.cudaError_t cudaGetDevice(int* dev);
解析：返回设备在哪个活动的主机线程中执行设备代码到指针*dev。
42.cudaError_t cudaGetDeviceProperties(struct cudaDeviceProp* prop, int dev);
解析：返回设备dev的属性到指针*prop。
43.cudaError_t cudaChooseDevice(int* dev, const struct cudaDeviceProp* prop);
解析：返回设备的哪些属性最匹配*prop到指针*dev。
44.CUDA Runtime API
解析：
（1）低级API（cuda_runtime_api.h）是C接口类型的，不需要nvcc编译。
（2）高级API（cuda_runtime.h ）是C++接口类型的，基于低级API之上的，可直接使用C++代码，并被任何的C++编译器编译。高级API还有一些CUDA特定的包，它们需要nvcc编译。
说明：CUDA Runtime API和CUDA Driver API提供了设备管理，线程管理，流管理，事件管理，内存管理，纹理引用管理，执行控制，OpenGL互操作性，Direct3D互操作性，错误处理等函数。
45.__noinline__
解析：默认下，__device__函数总是inline的。__noinline__函数可以作为一个非inline函数的提示。
46.#pragma unroll
解析：编译器默认情况下将循环展开小的次数，#pragma unroll能够指定循环以多少次展开。
47.CUDA内置矢量类型
解析：char1，uchar1，char2，uchar2，char3，uchar3，char4，uchar4，short1，ushort1，short2，ushort2，short3，ushort3，short4，ushort4，int1，uint1，int2，uint2，int3，uint3，int4，uint4，long1，ulong1，long2，ulong2，long3，ulong3，long4，ulong4，float1，float2，float3，float4。
48.CUDA类型转换函数
解析：
（1）int __float2int_[rn,rz,ru,rd](float);：用指定的舍入模式转换浮点参数到整型。
（2）unsigned int __float2unit_[rn,rz,ru,zd](float);:用指定的舍入模式转换浮点参数到无符号整型。
（3）float __int2float_[rn,rz,ru,rd](int);：用指定的舍入模式转换整型参数到浮点数。
（4）float __int2float_[rn,rz,ru,rd](unsigned int);：用指定的舍入模式转换无符号整型参数到浮点数。
说明：rn是求最近的偶数，rz是逼近零，ru是向上舍入[到正无穷]，rd是向下舍入[到负无穷]。
49.asyncAPI.cu代码剖析
解析：
#include <stdio.h>
#include <cuda_runtime.h>
#include <helper_cuda.h>
#include <helper_functions.h>
__global__ void increment_kernel(int *g_data, int inc_value)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
g_data[idx] = g_data[idx] + inc_value;
}
int main(int argc, char *argv[])
{
int n = 16 * 1024 * 1024;
int nbytes = n * sizeof(int);
int value = 26;
// allocate host memory
int *a = 0;
cudaMallocHost((void **)&a, nbytes);
memset(a, 0, nbytes);
// allocate device memory
int *d_a = 0;
cudaMalloc((void **)&d_a, nbytes);
cudaMemset(d_a, 255, nbytes);
// set kernel launch configuration
dim3 threads = dim3(512, 1);
dim3 blocks = dim3(n / threads.x, 1);
// create cuda event handles
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
// define time
StopWatchInterface *timer = NULL;
sdkCreateTimer(&timer);
sdkResetTimer(&timer);
cudaDeviceSynchronize();
float gpu_time = 0.0f;
// asynchronously issue work to the GPU (all to stream 0)
sdkStartTimer(&timer);
cudaEventRecord(start, 0);
cudaMemcpyAsync(d_a, a, nbytes, cudaMemcpyHostToDevice, 0);
increment_kernel << <blocks, threads, 0, 0 >> >(d_a, value);
cudaMemcpyAsync(a, d_a, nbytes, cudaMemcpyDeviceToHost, 0);
cudaEventRecord(stop, 0);
sdkStopTimer(&timer);
// have CPU do some work while waiting for stage 1 to finish
unsigned long int counter = 0;
while (cudaEventQuery(stop) == cudaErrorNotReady)
{
counter++;
}
cudaEventElapsedTime(&gpu_time, start, stop);
// print the cpu and gpu times
printf("time spent executing by the GPU: %.2f\n", gpu_time);
printf("time spent by CPU in CUDA calls: %.2f\n", sdkGetTimerValue(&timer));
printf("CPU executed %lu iterations while waiting for GPU to finish\n", counter);
// release resources
cudaEventDestroy(start);
cudaEventDestroy(stop);
cudaFreeHost(a);
cudaFree(d_a);
cudaDeviceReset();
}
解析：
（1）使用事件管理API主要作用是用于记录GPU状态，使CPU可以通过查询CUDA事件来确定GPU是否执行结束。
（2）常见的异步执行（主机端和设备端）函数包括Kernel启动；以Async为后缀的内存拷贝函数；device到device内存拷贝函数；存储器初始化函数，比如cudaMemset()，cudaMemset2D()，cudaMemset3D()。
50.流的创建与初始化
解析：
cudaStream_t *streams = (cudaStream_t *)malloc(nstreams * sizeof(cudaStream_t));
for (int i = 0; i < nstreams; i++)
{
checkCudaErrors(cudaStreamCreate(&(streams[i])));
}
51.simpleStreams.cu代码剖析
解析：
#include <stdio.h>
#include <cuda_runtime.h>
__global__ void init_array(int *g_data, int *factor, int num_iterations)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
for (int i = 0; i<num_iterations; i++) { g_data[idx] += *factor;}
}
int main(int argc, char **argv)
{
int nstreams = 4;
int nreps = 10;
int n = 16 * 1024 * 1024;
int nbytes = n * sizeof(int);
dim3 threads, blocks;
float elapsed_time, time_memcpy, time_kernel;
int niterations = 5;
// allocate host memory
int c = 5;
int *h_a = 0;
cudaMallocHost((void**)&h_a, nbytes);
// allocate device memory
int *d_a = 0, *d_c = 0;
cudaMalloc((void **)&d_a, nbytes);
cudaMalloc((void **)&d_c, sizeof(int));
cudaMemcpy(d_c, &c, sizeof(int), cudaMemcpyHostToDevice);
// allocate and initialize an array of stream handles
cudaStream_t *streams = (cudaStream_t *)malloc(nstreams * sizeof(cudaStream_t));
for (int i = 0; i < nstreams; i++)
{ cudaStreamCreate(&(streams[i]));}
// create CUDA event handles, use blocking sync
cudaEvent_t start_event, stop_event;
cudaEventCreate(&start_event);
cudaEventCreate(&stop_event);
// time memcopy from device
cudaEventRecord(start_event, 0);
cudaMemcpyAsync(h_a, d_a, nbytes, cudaMemcpyDeviceToHost, streams[0]);
cudaEventRecord(stop_event, 0);
cudaEventSynchronize(stop_event);
cudaEventElapsedTime(&time_memcpy, start_event, stop_event);
printf("memcopy:\t%.2f\n", time_memcpy);
// time kernel
threads = dim3(512, 1);
blocks = dim3(n / threads.x, 1);
cudaEventRecord(start_event, 0);
init_array << <blocks, threads, 0, streams[0] >> >(d_a, d_c, niterations);
cudaEventRecord(stop_event, 0);
cudaEventSynchronize(stop_event);
cudaEventElapsedTime(&time_kernel, start_event, stop_event);
printf("kernel:\t\t%.2f\n", time_kernel);
// time non-streamed execution for reference
threads = dim3(512, 1);
blocks = dim3(n / threads.x, 1);
cudaEventRecord(start_event, 0);
for (int k = 0; k < nreps; k++)
{
init_array << <blocks, threads >> >(d_a, d_c, niterations);
cudaMemcpy(h_a, d_a, nbytes, cudaMemcpyDeviceToHost);
}
cudaEventRecord(stop_event, 0);
cudaEventSynchronize(stop_event);
cudaEventElapsedTime(&elapsed_time, start_event, stop_event);
printf("non-streamed:\t%.2f\n", elapsed_time / nreps);
// time execution with nstreams streams
threads = dim3(512, 1);
blocks = dim3(n / (nstreams*threads.x), 1);
memset(h_a, 255, nbytes);
cudaMemset(d_a, 0, nbytes);
cudaEventRecord(start_event, 0);
for (int k = 0; k < nreps; k++)
{ // 异步加载nstreams个kernel
for (int i = 0; i < nstreams; i++)
{
init_array << <blocks, threads, 0, streams[i] >> >(d_a + i *n / nstreams, d_c, niterations);
}
// 异步加载nstreams个memcopy
for (int i = 0; i < nstreams; i++)
{
cudaMemcpyAsync(h_a + i * n / nstreams, d_a + i * n / nstreams, nbytes / nstreams, cudaMemcpyDeviceToHost, streams[i]);
}
}
cudaEventRecord(stop_event, 0);
cudaEventSynchronize(stop_event);
cudaEventElapsedTime(&elapsed_time, start_event, stop_event);
printf("%d streams:\t%.2f\n", nstreams, elapsed_time / nreps);
// release resources
for (int i = 0; i < nstreams; i++) { cudaStreamDestroy(streams[i]); }
cudaEventDestroy(start_event);
cudaEventDestroy(stop_event);
cudaFree(h_a);
cudaFree(d_a);
cudaFree(d_c);
cudaDeviceReset();
}
解析：simpleStreams.cu进行了流与事件的创建，并分别进行了内存拷贝计时，使用流的kernel执行计时，不使用流的kernel执行计时，以及使用nstreams个流的整体计时。为了使计时更加准确，采用了执行nreps次求平均值的方法。
52.CUDA中的流
解析：在一个给定的流中，操作顺序进行，但在不同流上的操作是乱序执行的，也可能是并行执行的。流的定义方法是创建一个cudaStream_t对象，并在启动内核和进行内存复制时将该对象作为参数传入，参数相同的属于同一个流，参数不同的属于不同的流。
53.Tegra
解析：Tegra是于推出的基于ARM构架通用处理器品牌（即CPU，NVIDIA称为"Computer on a chip"片上计算机），能够为便携设备提供高性能、低功耗体验。
54.Ubuntu 16.04安装CUDA 10.1
解析：
（1）禁用nouveau驱动
lsmod | grep nouveau
sudo vim /etc/modprobe.d/blacklist.conf
blacklist nouveau
options nouveau modeset=0
sudo update-initramfs –u
sudo reboot
lsmod | grep nouveau
（2）文本命令行模式运行runfile文件安装CUDA
sudo service lightdm stop
sudo sh cuda_10.1.168_418.67_linux.run --no-opengl-libs
sudo /usr/local/cuda-10.1/bin/cuda-uninstaller
sudo /usr/bin/nvidia-uninstall
ls /dev/nvidia*
（3）设置环境变量/etc/profile
sudo vim /etc/profile
export PATH=/usr/local/cuda-10.1/bin${PATH:+:${PATH}}
export LD_LIBRARY_PATH=/usr/local/cuda-10.1/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
cat /proc/driver/nvidia/version
nvcc -v
（4）编译cuda提供的samples
cd /home/xxx/NVIDIA_CUDA-10.1_Samples
make
cd /home/lxxx/NVIDIA_CUDA-10.1_Samples/bin/x86_64/linux/release
./deviceQuery
./bandwidthTest
（5）安装cudnn
sudo cp cuda/include/cudnn.h /usr/local/cuda/include/
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64/
（6）查看cuDNN是否安装成功
~/Downloads$ cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2
#define CUDNN_MAJOR 7
#define CUDNN_MINOR 6
#define CUDNN_PATCHLEVEL 4
--
#define CUDNN_VERSION (CUDNN_MAJOR * 1000 + CUDNN_MINOR * 100 + CUDNN_PATCHLEVEL)
#include "driver_types.h"
说明：至此就把CUDA和cuDNN安装好了。
55.CMakeLists.txt
解析：
[1]MESSAGE(STATUS "Project: SERVER")：打印相关消息
[2]SET(CMAKE_BUILE_TYPE DEBUG)：指定编译类型，debug或者为release
[3]SET(CMAKE_C_FLAGS_DEBUG "-g -Wall")：指定编译器
[4]CMAKE_C_FLAGS_DEBUG：C编译器
[5]CMAKE_CXX_FLAGS_DEBUG：C++编译器
[6]-g：只是编译器，在编译的时候，产生调试信息
[7]-Wall：生成所有警告信息
[8]ADD_SUBDIRECTORY()：添加子目录
[9]SET(*.cpp)：设置变量，表示所有的源文件
[10]INCLUDE_DIRECTORIES：相关头文件的目录
[11]LINK_DIRECTORIES：相关库文件的目录
[12]ADD_LIBRARY：生成静态链接库
[13]TARGET_LINK_LIBRARY：依赖的库文件
[14]SET_TARGET_PROPERTIES：表示生成的执行文件所在路径
[15]add_executable：指定生成目标
[16]find_package()：用来查找依赖包的
[17]FILE(GLOB EXTENDED doc/**)：加载doc文件夹下的所有文件
56.CUDA API
解析：Runtime API和Driver API，两种API各有其适用的范围。
57.PTX代码
解析：并行线程执行（Parallel Thread eXecution，PTX）代码是编译后的GPU代码的一种中间形式，它可以再次编译为原生的GPU微码。
58.Clang
解析：Clang是一个C语言、C++、Objective-C语言的轻量级编译器。源代码发布于BSD协议下。Clang将支持其普通lambda表达式、返回类型的简化处理以及更好的处理constexpr关键字。
59.clang-tidy
解析：clang-tidy是一个基于clang的静态代码分析框架，支持C++/C/Objective-C。
参考文献：
[1] CUDA编程：http://www.cnblogs.com/stewart/archive/2013/01/05/2846860.html
[2] DirectX学习经典参考书籍：http://blog.csdn.net/kuangfengwu/article/details/7344009
[3] 数字图像处理高级应用：基于MATLAB与CUDA的实现
[4] CUDA里面的Texture Memory：http://blog.csdn.net/qq_25716575/article/details/52444686
[5] CUDA纹理的使用：http://preston2006.blog.sohu.com/253531751.html
[6] CUDA纹理存储器的特性及其使用：http://blog.csdn.net/darkstorm2111203/articl
[7]CUDA计算能力查询表：https://blog.csdn.net/allyli0022/article/details/54628987e/details/4294012