Cuda编程总结2013-10-120:32:46
--------余家奎
参加书籍:NVIDIACUDA C Programming Guide
OpenGL编程指南
学习cuda例子中的总结
1、__constant__和__device__,__shared__的使用说明...2
2、分配二位数组实现两个二位数组相加...2
3、用cudaMemcpyPitch和cudaMemcpy2D实现二位数组的分配和拷贝...5
4、cudaMalloc3D()和cudaMemcpy3D()函数的用法...7
5、不带共享存储器的矩阵的相乘...9
6、带shared memory的矩阵相乘...12
7、页锁定主机存储器Page-locked Host memory.16
8、纹理存储的使用texture memory.18
9、surface Memory的使用方法...20
10、opengl和cuda的交互...22
11、Formatted output---printf函数在device的函数中,但是其需要其的compute copability至少为2.0 27
12、Asserting在设备端的函数中,但是其要求其计算能力至少为2.0.28
13、Per Thread Allocation On heap每个线程在堆上分配...29
14、Per Thread Block Allocation每个线程块在堆上分配空间...29
15、Allocation Persisting Between Kernel Launches在堆上分配...30
如有错误的地方还请指正。。。谢谢
其对应的程序:
//
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include
#include
// __constant__ int device_global_var=5;
// __device__ int device_global_var=5;
__shared__ int device_global_var ;
__global__ void kernel()
{
__shared__ int xx;
}
int main()
{
int host_var=5;
cudaMemcpyToSymbol(device_global_var,&host_var,sizeof(int));
printf("value=%d\n",host_var);
cudaMemcpyFromSymbol(&host_var,device_global_var,sizeof(int));
printf("device_value=%d\n",host_var);
system("pause");
return 0;
}
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include
#include
#define N 16
__device__ intdevice_a[N][N],device_b[N][N],device_c[N][N];
__global__ void VecAdd(inta[N][N],int b[N][N],intc[N][N])
{
int global_threadId_x=blockIdx.x*blockDim.x+threadIdx.x;
int global_threadId_y=blockIdx.y*blockDim.y+threadIdx.y;
if (global_threadId_x { c[global_threadId_y][global_threadId_x]=a[global_threadId_y][global_threadId_x]+ b[global_threadId_y][global_threadId_x]; } } void printfArray(int data[N][N]) { for (inti=0;i { for (intj=0;j { printf("%d ",data[i][j]); } printf("\n"); } } void host_Add(int a[N][N],int b[N][N],intc[N][N]) { for (inti=0;i { for (int j=0;j { c[i][j]=a[i][j]+b[i][j]; } } } int main() { int i,j; int k=0; int a[N][N],b[N][N]; int c[N][N]; for (i=0;i { for (j=0;j { a[i][j]=k; b[i][j]=k; k++; } } int tempA[N][N]; //int (*device_aa)[N]; int **device_aa; cudaMalloc((void**)&device_aa,sizeof(int)*N*N); cudaMemcpyToSymbol(device_a,a,sizeof(int)*N*N); cudaMemcpyFromSymbol(tempA,device_a,sizeof(int)*N*N); printf("tempA====\n"); printfArray(tempA); system("pause"); return 0; } 代码: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include #include // kernel which copies data from d_arrayto destinationArray __global__ void CopyData(float*d_array, float* destinationArray, size_tpitch, int columnCount, int rowCount) { for (int row = 0; row< rowCount; row++) { // update the pointer to point to the beginning of the nextrow float* rowData = (float*)(((char*)d_array) +(row * pitch)); for (int column = 0;column < columnCount; column++) { rowData[column] =123.0; // make every value in the array123.0 destinationArray[(row*columnCount) + column] = rowData[column]; } } } int main(int argc,char**argv) { int columnCount = 15; int rowCount = 10; float* d_array; // thedevice array which memory will be allocated to float* d_destinationArray; //the device array // allocate memory on the host float* h_array = new float[columnCount*rowCount]; // the pitch value assigned by cudaMallocPitch // (which ensures correct data structure alignment) size_tpitch; //allocated the device memory for source array cudaMallocPitch(&d_array, &pitch,columnCount * sizeof(float), rowCount); //allocate the device memory for destination array cudaMalloc(&d_destinationArray,columnCount*rowCount*sizeof(float)); //call the kernel which copies values from d_array tod_destinationArray CopyData<<<100, 512>>>(d_array, d_destinationArray,pitch, columnCount, rowCount); //copy the data back to the host memory float *h_result=(float*)malloc(sizeof(float)*columnCount*rowCount); memset(h_result,0,sizeof(float)*columnCount*rowCount); cudaMemcpy2D(h_result,columnCount*sizeof(float),d_array,pitch,columnCount*sizeof(float),rowCount,cudaMemcpyDeviceToHost); cudaMemcpy(h_array, d_destinationArray, columnCount*rowCount*sizeof(float), cudaMemcpyDeviceToHost); for(int i = 0 ; i< rowCount ; i++) { for(int j = 0 ; j < columnCount ; j++) { cout << "h_result["<< (i*columnCount) + j <<"]="<< h_result[(i*columnCount) + j] << endl; } } system("pause"); printf("h_array==\n"); //print out the values (all the values are 123.0) for(int i = 0 ; i< rowCount ; i++) { for(int j = 0 ; j< columnCount ; j++) { cout<< "h_array[" <<(i*columnCount) + j <<"]="<< h_array[(i*columnCount) + j] << endl; } } system("pause"); } 代码: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include // Device code __global__ void MyKernel(cudaPitchedPtrdevPitchedPtr,cudaExtent extent) { char* devPtr = (char*)devPitchedPtr.ptr; size_t pitch= devPitchedPtr.pitch; size_tslicePitch = pitch * extent.height; for(int k=0; k char* slice = devPtr + k * slicePitch; for(int j=0; j float3* row = (float3*)(slice+j*pitch); for (inti=0;i { row[i].x=2; row[i].y=3; row[i].z=4; } } } } const int x=6; const int y=60; const int z=66; int main(){ size_tbuf_pf=900000000; // cudaPrintfInit(buf_pf); cudaError_tstatus = cudaSuccess; //======== Mem Host float3 *mem_host = (float3*)malloc(sizeof(float3)*x*y*z); float3 *mem_host2 = (float3*)malloc(sizeof(float3)*x*y*z); for(int i=0;i mem_host[i].x=10; mem_host[i].y=100; mem_host[i].z=1000; } //======== Mem Device cudaExtentextent; extent.width=x*sizeof(float3); extent.height=y; extent.depth=z; cudaPitchedPtrmem_device; status=cudaMalloc3D(&mem_device,extent); // if(status!= cudaSuccess){fprintf(stderr, "Malloc: %s\n", cudaGetErrorString(status));} // // //========Cpy HostToDevice // // cudaMemcpy3DParmsp = { 0 }; // p.srcPtr= make_cudaPitchedPtr((void*)mem_host, x*sizeof(float3),x,y); // p.dstPtr= mem_device; // p.extent= extent; // p.kind= cudaMemcpyHostToDevice; // status=cudaMemcpy3D(&p); // if(status!= cudaSuccess){fprintf(stderr, "MemcpyHtD: %s\n",cudaGetErrorString(status));} MyKernel<<<1,1>>>(mem_device,extent); //======== Cpy DeviceToHost !!!!!!! UNTESTED !!!!!!!! cudaMemcpy3DParmsq = {0}; q.srcPtr =mem_device; q.dstPtr =make_cudaPitchedPtr((void*)mem_host2,x*sizeof(float3),x,y); q.extent=extent; q.kind =cudaMemcpyDeviceToHost; status=cudaMemcpy3D(&q); if(status != cudaSuccess){fprintf(stderr,"MemcpyDtoH: %s\n",cudaGetErrorString(status));} for(int i=0;i printf("%f %f %f\n",mem_host2[i].x,mem_host2[i].y,mem_host2[i].z); cudaFree(mem_device.ptr); system("pause"); } 代码: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include #include typedef struct { int width; int height; float *element; }Matrix; #define BLOCK_SIZE 16 __global__ void MatMulKernel(const Matrix,const Matrix,Matrix); void printMatrix(const Matrix &A) { for (inti=0;i { for (intj=0;j { printf("%f ",A.element[i*A.width+j]); } printf("\n"); } } void MatMul(const Matrix &A,const Matrix &B,Matrix &C) { printf("matrix A"); printMatrix(A); printf("matrix B"); printMatrix(B); system("pause"); Matrix d_A; d_A.width=A.width; d_A.height=A.height; size_tsize=A.width*A.height*sizeof(float); cudaMalloc(&d_A.element,size); cudaMemcpy(d_A.element,A.element,size,cudaMemcpyHostToDevice); Matrix d_B; d_B.width=B.width; d_B.height=B.height; size=B.width*B.height*sizeof(float); cudaMalloc(&d_B.element,size); cudaMemcpy(d_B.element,B.element,size,cudaMemcpyHostToDevice); Matrix d_C; d_C.width=C.width; d_C.height=C.height; size=C.width*C.height*sizeof(float); cudaMalloc(&d_C.element,size); dim3 dimBlock(BLOCK_SIZE,BLOCK_SIZE); dim3 dimGrid(B.width/dimBlock.x,A.height/dimBlock.y); MatMulKernel<< cudaMemcpy(C.element,d_C.element,size,cudaMemcpyDeviceToHost); cudaFree(d_A.element); cudaFree(d_B.element); cudaFree(d_C.element); for (inti=0;i { for (intj=0;j { printf("%f ",C.element[i*C.width+j]); } printf("\n"); } system("pause"); } void SetMatrixValue(Matrix &A,int value) { for (inti=0;i { for (intj=0;j { A.element[i*A.width+j]=value; } } } void main() { MatrixA,B,C; A.width=128; A.height=128; A.element=(float*)malloc(A.width*A.height*sizeof(float)); SetMatrixValue(A,2); B.width=128; B.height=128; B.element=(float*)malloc(B.width*B.height*sizeof(float)); //memset(B.element,2,sizeof(float)*B.width*B.height); SetMatrixValue(B,2); C.width=128; C.height=128; C.element=(float*)malloc(C.width*C.height*sizeof(float)); //memset(C.element,2,sizeof(float)*C.width*C.height); MatMul(A,B,C); for (inti=0;i { for (intj=0;j { printf("%f ",C.element[i*C.width+j]); } printf("\n"); } system("pause"); } __global__ void MatMulKernel(Matrix A,MatrixB,Matrix C) { float CValue=0; int row=blockIdx.y*blockDim.y+threadIdx.y; int col=blockIdx.x*blockDim.x+threadIdx.x; for (inte=0;e { CValue+=A.element[row*A.width+e]*B.element[e*B.width+col]; } C.element[row*C.width+col]=CValue; } 代码: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include #define BLOCK_SIZE 16 typedef struct { int width; int height; int stride; float *elements; }Matrix; __device__ float GetElement(constMatrix A, int row,intcol) { return A.elements[row*A.stride+col]; } __device__ void SetElement(Matrix A,int row,int col,float value) { A.elements[row*A.stride+col]=value; } __device__ Matrix GetSubMatrix(Matrix A,int row,int col) { Matrix Asub; Asub.width=BLOCK_SIZE; Asub.height=BLOCK_SIZE; Asub.stride=A.stride; Asub.elements=&A.elements[A.stride*BLOCK_SIZE*row+BLOCK_SIZE*col]; return Asub; } __global__ void MatMulKernel(const Matrix,const Matrix,Matrix); void MatMul(const Matrix &A,const Matrix &B,Matrix &C) { Matrix d_A; d_A.width=A.width; d_A.height=A.height; d_A.stride=A.width; size_tsize=d_A.width*d_A.height*sizeof(float); cudaMalloc(&d_A.elements,size); cudaMemcpy(d_A.elements,A.elements,size,cudaMemcpyHostToDevice); Matrix d_B; d_B.width=B.width; d_B.height=B.height; d_B.stride=B.width; size=B.width*B.height*sizeof(float); cudaMalloc(&d_B.elements,size); cudaMemcpy(d_B.elements,B.elements,size,cudaMemcpyHostToDevice); Matrix d_C; d_C.width=C.width; d_C.height=C.height; d_C.stride=C.width; size=C.width*C.height*sizeof(float); cudaMalloc(&d_C.elements,size); dim3 dimBlock(BLOCK_SIZE,BLOCK_SIZE); dim3 dimGrid(B.width/BLOCK_SIZE,B.height/BLOCK_SIZE); MatMulKernel<< cudaMemcpy(C.elements,d_C.elements,size,cudaMemcpyDeviceToHost); cudaFree(d_A.elements); cudaFree(d_B.elements); cudaFree(d_C.elements); } __global__ void MatMulKernel(Matrix A,MatrixB,Matrix C) { int blockRow=blockIdx.y; int blockCol=blockIdx.x; MatrixCsub=GetSubMatrix(C,blockRow,blockCol); float Cvalue=0; int row=threadIdx.y; int col=threadIdx.x; for (intm=0;m { MatrixAsub=GetSubMatrix(A,blockRow,m); MatrixBsub=GetSubMatrix(B,m,blockCol); __shared__ floatAs[BLOCK_SIZE][BLOCK_SIZE]; __shared__ floatBs[BLOCK_SIZE][BLOCK_SIZE]; As[row][col]=GetElement(Asub,row,col); Bs[row][col]=GetElement(Bsub,row,col); __syncthreads(); for (inte=0;e { Cvalue+=As[row][e]*Bs[e][col]; } __syncthreads(); } SetElement(Csub,row,col,Cvalue); } void SetMatValue(Matrix A,int value) { for (inti=0;i { for (intj=0;j { A.elements[i*A.width+j]=value; } } } void PrintMat(const Matrix A) { for (int i=0;i { for(intj=0;j { printf("%f ",A.elements[i*A.width+j]); } printf("\n"); } } void main() { MatrixA,B,C; A.width=128; A.height=128; A.elements=(float*)malloc(A.width*A.height*sizeof(float)); SetMatValue(A,2); B.width=128; B.height=128; B.elements=(float*)malloc(B.width*B.height*sizeof(float)); SetMatValue(B,2); C.width=128; C.height=128; C.elements=(float *)malloc(C.width*C.height*sizeof(float)); MatMul(A,B,C); PrintMat(C); system("pause"); } 代码: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include #define N 256 void SetArrayValue(float *pData,int size,float value) { for (inti=0;i { pData[i]=value; } } __global__ void VecAdd(float*A,float *B,float*C) { int index=threadIdx.x; C[index]=A[index]+B[index]; } void PrintArray(float *data,int size) { for(inti=0;i { if((i+1)%10==0) { printf("\n"); } printf("%f ",data[i]); } } void main() { //cudaSetDeviceFlags(cudaDeviceMapHost);---可有可无 cudaDevicePropdeviceProp; cudaGetDeviceProperties(&deviceProp,0); if (deviceProp.integrated) { printf("GPU is integrated\n"); return; } if(!deviceProp.canMapHostMemory) { printf("can't map host memory\n"); return; } float *hostPtrA; cudaHostAlloc(&hostPtrA,sizeof(float)*N,cudaHostAllocDefault| cudaHostAllocMapped); SetArrayValue(hostPtrA,N,29); PrintArray(hostPtrA,N); system("pause"); float *hostPtrB; cudaHostAlloc(&hostPtrB,sizeof(float)*N,cudaHostAllocDefault| cudaHostAllocMapped); SetArrayValue(hostPtrB,N,31); float *devPtrA,*devPtrB; cudaHostGetDevicePointer(&devPtrA,hostPtrA,0); cudaHostGetDevicePointer(&devPtrB,hostPtrB,0); float *hostPtrC; cudaHostAlloc(&hostPtrC,sizeof(float)*N,cudaHostAllocDefault| cudaHostAllocMapped); float *devPtrC; cudaHostGetDevicePointer(&devPtrC,hostPtrC,0); VecAdd<<<1,N>>>(devPtrA,devPtrB,devPtrC); cudaDeviceSynchronize(); for(inti=0;i { if ((i+1)%10==0) { printf("\n"); } printf("%f ",hostPtrC[i]); } system("pause"); } 代码: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include #define size 256 texture<float,cudaTextureType2D,cudaReadModeElementType>texRef; __global__ void transformKernel(float *output,intwidth,int height,floattheta) { unsigned int x=blockIdx.x*blockDim.x+threadIdx.x; unsigned int y=blockIdx.y*blockDim.y+threadIdx.y; float u=x/(float)width; float v=y/(float)height; u-=0.5f; v-=0.5f; float tu=u*cosf(theta)-v*sin(theta)+0.5f; float tv=v*cosf(theta)+u*sinf(theta)+0.5f; output[y*width+x]=tex2D(texRef,tu,tv); } void main() { int width=25,height=25; cudaChannelFormatDescchannelDesc=cudaCreateChannelDesc(32,0,0,0,cudaChannelFormatKindFloat); cudaArray*cuArray; cudaMallocArray(&cuArray,&channelDesc,width,height); float *h_data=(float*)malloc(width*height*sizeof(float)); for (inti=0;i { for (intj=0;j { h_data[i*width+j]=i*width+j; } } cudaMemcpyToArray(cuArray,0,0,h_data,width*height*sizeof(float),cudaMemcpyHostToDevice); texRef.addressMode[0]=cudaAddressModeWrap; texRef.addressMode[1]=cudaAddressModeWrap; texRef.filterMode=cudaFilterModeLinear; texRef.normalized=true; cudaBindTextureToArray(texRef,cuArray,channelDesc); float *output; cudaMalloc(&output,width*height*sizeof(float)); dim3 dimBlock(16,16); dim3dimGrid((width+dimBlock.x-1)/dimBlock.x,(height+dimBlock.y-1)/dimBlock.y); float angle=30; transformKernel<< float *hostPtr=(float*)malloc(sizeof(float)*width*height); cudaMemcpy(hostPtr,output,sizeof(float)*width*height,cudaMemcpyDeviceToHost); for (inti=0;i { for (intj=0;j { printf("%f ",hostPtr[i*width+j]); } printf("\n"); } free(hostPtr); cudaFreeArray(cuArray); cudaFree(output); system("pause"); } 代码: #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include surface<void,2> inputSurfRef; surface<void,2>outputSurfRef; __global__ void copyKernel(intwidth,int height) { unsigned int x=blockIdx.x*blockDim.x+threadIdx.x; unsigned int y=blockIdx.y*blockDim.y+threadIdx.y; if(x { uchar4 data; surf2Dread(&data,inputSurfRef,x*4,y); surf2Dwrite(data,outputSurfRef,x*4,y); } } void main() { int width=256,height=256; unsigned int*h_data=(unsigned int*)malloc(width*height*sizeof(unsignedint)); for (inti=0;i { for (intj=0;j { h_data[i*width+j]=3; } } int size=width*height*sizeof(unsignedint); cudaChannelFormatDescchannelDesc=cudaCreateChannelDesc(8,8,8,8,cudaChannelFormatKindUnsigned); cudaArray*cuInputArray; cudaMallocArray(&cuInputArray,&channelDesc,width,height,cudaArraySurfaceLoadStore); cudaArray*cuOutputArray; cudaMallocArray(&cuOutputArray,&channelDesc,width,height,cudaArraySurfaceLoadStore); cudaMemcpyToArray(cuInputArray,0,0,h_data,size,cudaMemcpyHostToDevice); cudaBindSurfaceToArray(inputSurfRef,cuInputArray); cudaBindSurfaceToArray(outputSurfRef,cuOutputArray); dim3 dimBlock(16,16); dim3dimGrid((width+dimBlock.x-1)/dimBlock.x,(height+dimBlock.y-1)/dimBlock.y); copyKernel<< unsigned int*host_output=(unsigned int*)malloc(sizeof(unsignedint)*width*height); cudaMemcpyFromArray(host_output,cuOutputArray,0,0,size,cudaMemcpyDeviceToHost); for (inti=0;i { for (intj=0;j { printf("%u ",host_output[i*width+j]); } printf("\n"); } system("pause"); free(host_output); free(h_data); cudaFreeArray(cuInputArray); cudaFreeArray(cuOutputArray); } 代码:https://devtalk.nvidia.com/default/topic/502692/how-to-use-open_gl/ http://stackoverflow.com/questions/12082357/errors-while-using-opengl-buffers-using-visual-studio-2010-in-windows7 #include #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include "cuda_gl_interop.h" #include #include //#include #include GLuint postionsVBO=1; struct cudaGraphicsResource * postionsVBO_CUDA; int width=256; int height=256; __device__ float dev_time=1; float host_time=1; __global__ void createVertices(float4 *positions,floattime,unsignedintwidth ,unsignedintheight); void init() { glClearColor(0.f,0.f,0.f,1.f); glClear(GL_DEPTH_BUFFER_BIT| GL_COLOR_BUFFER_BIT); } void reshape(int width,int height) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); if (width>height) { gluPerspective(45,(GLfloat)width/height,0.001,1000); }else { gluPerspective(45,(GLfloat)height/width,0.001,1000); } glMatrixMode(GL_MATRIX_MODE); glLoadIdentity(); } void display() { float4 *positions; cudaGraphicsMapResources(1,&postionsVBO_CUDA,0); size_tnumb_bytes; cudaGraphicsResourceGetMappedPointer((void**)&positions,&numb_bytes,postionsVBO_CUDA); dim3 dimBlock(16,16,1); dim3 dimGrid(width/dimBlock.x,height/dimBlock.y,1); createVertices<< dev_time++; cudaMemcpy(&time,&host_time,sizeof(float),cudaMemcpyHostToDevice); cudaGraphicsUnmapResources(1,&postionsVBO_CUDA,0); glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT); glBindBuffer(GL_ARRAY_BUFFER,postionsVBO); glVertexPointer(4,GL_FLOAT,0,0); glEnableClientState(GL_VERTEX_ARRAY); glDrawArrays(GL_POINTS,0,width*height); glDisableClientState(GL_VERTEX_ARRAY); glutSwapBuffers(); glutPostRedisplay(); } __global__ void createVertices(float4 *positions,floattime,unsignedintwidth ,unsignedintheight) { unsigned int x=blockIdx.x*blockDim.x+threadIdx.x; unsigned int y=blockIdx.y*blockDim.y+threadIdx.y; float u=x/(float)width; float v=y/(float)height; u=u*2.f-1.f; v=v*2.f-1.f; float freq=4.f; float w=sinf(u*freq+time)*cosf(v*freq+time)*0.5f; positions[y*width+x]=make_float4(u,w,v,1.f); } int main(int argc,char*argv[]) { cudaGLSetGLDevice(0); glutInit(&argc,argv); glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGB); glutInitWindowPosition(0,0); glutInitWindowSize(100,100); glutCreateWindow("opengl-cuda"); init(); glutDisplayFunc(display); glutReshapeFunc(reshape); glewInit();//http://stackoverflow.com/questions/12344612/unusual-error-using-opengl-buffers-with-cuda-interop-on-ms-visual-studio-2010 glGenBuffers(1,&postionsVBO); glBindBuffer(GL_ARRAY_BUFFER,postionsVBO); unsigned intsize=width*height*4*sizeof(float); glBufferData(GL_ARRAY_BUFFER,size,0,GL_DYNAMIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,0); cudaGraphicsGLRegisterBuffer(&postionsVBO_CUDA,postionsVBO,cudaGraphicsMapFlagsWriteDiscard); glutMainLoop(); } 代码: #include #include #include "cuda_runtime.h" #include "device_launch_parameters.h" __global__ void bcast() { printf("%d\n",threadIdx.x); } void main() { bcast<<<1,32>>>(); cudaDeviceSynchronize(); system("pause"); } 代码: #include #include #include "cuda_runtime.h" #include "device_launch_parameters.h" #include #include __global__ void testAssert(void) { int is_one=1; int should_be_one=0; assert(is_one); assert(should_be_one); } void main() { testAssert<<<1,1>>>(); cudaDeviceSynchronize(); cudaDeviceReset(); system("pause"); } 代码: #include #include #include #include #include "cuda_runtime.h" #include "device_launch_parameters.h" __global__ void mallocTestPerThread() { char *ptr=(char *)malloc(100); printf("Thread %d got pointer:%p\n",threadIdx.x,ptr); free(ptr); } int main() { cudaDeviceSetLimit(cudaLimitMallocHeapSize,128*1024*1024); mallocTestPerThread<<<1,5>>>(); cudaDeviceSynchronize(); system("pause"); return 0; } 代码: #include #include #include #include #include "cuda_runtime.h" #include "device_launch_parameters.h" __global__ void mallocTestPerThreadBlock() { __shared__ int *data; if (threadIdx.x==0) { data=(int*)malloc(blockDim.x*64); } __syncthreads(); if (data==NULL) { return; } int *ptr=data; for (inti=0;i<64;++i) { ptr[i*blockDim.x+threadIdx.x]=threadIdx.x; } __syncthreads(); if (threadIdx.x==0) { free(data); } } int main() { cudaDeviceSetLimit(cudaLimitMallocHeapSize,128*1024*1024); mallocTestPerThreadBlock<<<10,128>>>(); cudaDeviceSynchronize(); system("pause"); return 0; } 代码: #include #include #include #include #include "cuda_runtime.h" #include "device_launch_parameters.h" #define NUM_BLOCKS 20 __device__ int *dataptr[NUM_BLOCKS]; __global__ void allocmem() { if (threadIdx.x==0) { dataptr[blockIdx.x]=(int*)malloc(blockDim.x*4); } __syncthreads(); if (dataptr[blockIdx.x]==NULL) { return; } dataptr[blockIdx.x][threadIdx.x]=0; } __global__ void usemem() { int *ptr=dataptr[blockIdx.x]; if (ptr!=NULL) { ptr[threadIdx.x]+=threadIdx.x; } } __global__ void freemem() { int *ptr=dataptr[blockIdx.x]; if(ptr!=NULL) printf("Block %d,Thread=%d:final value=%d\n",blockIdx.x,threadIdx.x,ptr[threadIdx.x]); if (threadIdx.x==0) { free(ptr); } } int main() { cudaDeviceSetLimit(cudaLimitMallocHeapSize,128*1024*1024); allocmem<< usemem<< usemem<< usemem<< freemem<< cudaDeviceSynchronize(); system("pause"); return 0; } 3、用cudaMemcpyPitch和cudaMemcpy2D实现二位数组的分配和拷贝
4、cudaMalloc3D()和cudaMemcpy3D()函数的用法
5、不带共享存储器的矩阵的相乘
6、带shared memory的矩阵相乘
7、页锁定主机存储器Page-lockedHost memory
8、纹理存储的使用texturememory
9、surface Memory的使用方法
10、opengl和cuda的交互
11、Formattedoutput---printf函数在device的函数中,但是其需要其的compute copability至少为2.0
12、Asserting在设备端的函数中,但是其要求其计算能力至少为2.0
13、Per ThreadAllocation On heap每个线程在堆上分配
14、Per Thread BlockAllocation每个线程块在堆上分配空间
15、AllocationPersisting Between Kernel Launches在堆上分配