CUDA从入门到精通到精通_笔记4:GPU设备属性查询的代码

/*******************************************************************************************************************
*文件说明:
*        第二个CUDA程序------GPU设备性能参数的查询
*开发环境:
*        win7+OpenCv2.4.8+cudaToolkit5.0+CUDA SDK3.0+NIVIDA NVS 3100M
*参考手册:
*        CUDA_ToolKit_Reference_Manual.pdf
*时间地点:
*        陕西师范大学 2017.1.8
*作    者:
*        九月
*模块说明:
*        1--由于我们希望在【设备】上【分配内存】和【执行代码】,因此如果在程序中能够知道设备拥有多少【内存】以及具备
*           哪些功能,那么将非常的有用
*        2--而且,在一台计算机上拥有多个支持CUDA的设备也是非常常见的情形。在这些情况中,我们希望通过某种方式来确定使用
*           的是哪一个GPU设备
*        3--在深入研究如何编写【设备代码】之前,我们需要通过某种机制来判断计算机中当前有哪些设备,以及每个设备都支持哪
*           些功能。
*        4--幸运的是,我们可以通过一个非常简单的接口来获得这样的信息
*        5--首先,我们希望知道在系统中有多少个设备是支持CUDA的,并且这些设备能够运行基于CUDA C编写的【核函数】
*        6--要获得CUDA设备的数量,可以调用cudaGetDeviceCount()
*        7--在调用cudaGetDeviceCount()后,可以对每个设备进行迭代、并查询各个【设备】的【相关信息】。CUDA运行时将返回一
*           个cudaDeviceProp类型的结构,其中包含了设备的相关属性。
********************************************************************************************************************/
#include "cuda_runtime.h"                             //【1】CUDA运行时头文件,包含了许多的runtime API
#include "device_launch_parameters.h"
#include <driver_types.h>                             //【2】驱动类型的头文件,包含cudaDeviceProp【设备属性】
#include <cuda_runtime_api.h>                         //【3】cuda运行时API的头文件
#include "stdio.h"
#include <iostream>

/*******************************************************************************************************************
*模块说明：
*        控制台应用程序的入口函数----Main函数
*函数说明:
*cudaGetDeviceCount函数原型:
*        extern __host__ __cudart_builtin__ cudaError_t CUDARTAPI cudaGetDeviceCount(int *count)
*函数作用:
*        以*count的形式返回可用于执行的计算能力大于等于1.0的设备数量,如果不存在此设备,那么这个函数将会返回cudaError
*        -NoDevice
********************************************************************************************************************/
int main()
{
	cudaDeviceProp  strProp;                            //【1】定义一个【设备属性结构体】的【结构体变量】
	int            iCount;
	cudaGetDeviceCount(&iCount);                        //【2】获得GPU设备的数量
	std::printf("The number of GPU = %d\n",iCount);
	for(int i=0;i<iCount;i++)                          //【3】迭代的获取每一个【GPU设备】的属性
	{
		cudaGetDeviceProperties(&strProp,i);            //【4】获取【GPU设备属性】的函数,并将获得的设备属性存放在strProp中
		std::printf("----General Information for device = %d-----\n",i);
		std::printf("The name of Device:%s\n",strProp.name);                       //【1】NIVIDA显卡的型号         
		std::printf("The totalGlobalMem of GPU:%d\n",strProp.totalGlobalMem);      //【2】设备全局内存的总量,单位:字节
		std::printf("The sharedMemPerBlock of GPU:%d\n",strProp.sharedMemPerBlock);//【3】在一个线程块Block中可以使用的最大共享内存的数量
		std::printf("The regsPerBlock of GPU:%d\n",strProp.regsPerBlock);          //【4】每个线程块中可用的32位寄存器的数量
		std::printf("The warpSize:%d\n",strProp.warpSize);                         //【5】每一个线程束包含的线程的数量
		std::printf("The memPitch:%d\n",strProp.memPitch);                         //【6】内存复制中,最大的修正量
		std::printf("The maxThreadPerBlock:%d\n",strProp.maxThreadsPerBlock);      //【7】在一个线程块中,可以包含的最大线程数量
		std::printf("The totalConstMem:%d\n",strProp.totalConstMem);               //【8】常量内存的总量
		std::printf("The major:%d\n",strProp.major);
		std::printf("The minor:%d\n",strProp.minor);
		std::printf("The multiProcessCount:%d\n",strProp.multiProcessorCount);
	}
		

	std::system("pause");
	return 0;
}

struct __device_builtin__ cudaDeviceProp
{
    char   name[256];                  /**< ASCII string identifying device */
    size_t totalGlobalMem;             /**< Global memory available on device in bytes */
    size_t sharedMemPerBlock;          /**< Shared memory available per block in bytes */
    int    regsPerBlock;               /**< 32-bit registers available per block */
    int    warpSize;                   /**< Warp size in threads */
    size_t memPitch;                   /**< Maximum pitch in bytes allowed by memory copies */
    int    maxThreadsPerBlock;         /**< Maximum number of threads per block */
    int    maxThreadsDim[3];           /**< Maximum size of each dimension of a block */
    int    maxGridSize[3];             /**< Maximum size of each dimension of a grid */
    int    clockRate;                  /**< Clock frequency in kilohertz */
    size_t totalConstMem;              /**< Constant memory available on device in bytes */
    int    major;                      /**< Major compute capability */
    int    minor;                      /**< Minor compute capability */
    size_t textureAlignment;           /**< Alignment requirement for textures */
    size_t texturePitchAlignment;      /**< Pitch alignment requirement for texture references bound to pitched memory */
    int    deviceOverlap;              /**< Device can concurrently copy memory and execute a kernel. Deprecated. Use instead asyncEngineCount. */
    int    multiProcessorCount;        /**< Number of multiprocessors on device */
    int    kernelExecTimeoutEnabled;   /**< Specified whether there is a run time limit on kernels */
    int    integrated;                 /**< Device is integrated as opposed to discrete */
    int    canMapHostMemory;           /**< Device can map host memory with cudaHostAlloc/cudaHostGetDevicePointer */
    int    computeMode;                /**< Compute mode (See ::cudaComputeMode) */
    int    maxTexture1D;               /**< Maximum 1D texture size */
    int    maxTexture1DMipmap;         /**< Maximum 1D mipmapped texture size */
    int    maxTexture1DLinear;         /**< Maximum size for 1D textures bound to linear memory */
    int    maxTexture2D[2];            /**< Maximum 2D texture dimensions */
    int    maxTexture2DMipmap[2];      /**< Maximum 2D mipmapped texture dimensions */
    int    maxTexture2DLinear[3];      /**< Maximum dimensions (width, height, pitch) for 2D textures bound to pitched memory */
    int    maxTexture2DGather[2];      /**< Maximum 2D texture dimensions if texture gather operations have to be performed */
    int    maxTexture3D[3];            /**< Maximum 3D texture dimensions */
    int    maxTextureCubemap;          /**< Maximum Cubemap texture dimensions */
    int    maxTexture1DLayered[2];     /**< Maximum 1D layered texture dimensions */
    int    maxTexture2DLayered[3];     /**< Maximum 2D layered texture dimensions */
    int    maxTextureCubemapLayered[2];/**< Maximum Cubemap layered texture dimensions */
    int    maxSurface1D;               /**< Maximum 1D surface size */
    int    maxSurface2D[2];            /**< Maximum 2D surface dimensions */
    int    maxSurface3D[3];            /**< Maximum 3D surface dimensions */
    int    maxSurface1DLayered[2];     /**< Maximum 1D layered surface dimensions */
    int    maxSurface2DLayered[3];     /**< Maximum 2D layered surface dimensions */
    int    maxSurfaceCubemap;          /**< Maximum Cubemap surface dimensions */
    int    maxSurfaceCubemapLayered[2];/**< Maximum Cubemap layered surface dimensions */
    size_t surfaceAlignment;           /**< Alignment requirements for surfaces */
    int    concurrentKernels;          /**< Device can possibly execute multiple kernels concurrently */
    int    ECCEnabled;                 /**< Device has ECC support enabled */
    int    pciBusID;                   /**< PCI bus ID of the device */
    int    pciDeviceID;                /**< PCI device ID of the device */
    int    pciDomainID;                /**< PCI domain ID of the device */
    int    tccDriver;                  /**< 1 if device is a Tesla device using TCC driver, 0 otherwise */
    int    asyncEngineCount;           /**< Number of asynchronous engines */
    int    unifiedAddressing;          /**< Device shares a unified address space with the host */
    int    memoryClockRate;            /**< Peak memory clock frequency in kilohertz */
    int    memoryBusWidth;             /**< Global memory bus width in bits */
    int    l2CacheSize;                /**< Size of L2 cache in bytes */
    int    maxThreadsPerMultiProcessor;/**< Maximum resident threads per multiprocessor */
};