DtHelperCuda.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2018 VT-MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once

#include <helper_cuda.h>

namespace makVrv
{
   template <typename T>
   void DtCheck(T result, char const *const func, const char *const file, int const line, DtDe* theDe)
   {
      if (result) 
      {
         if (theDe != NULL)
         {
            theDe->DT_LOG_WARN << "CUDA error at " << file << ":" << line <<
               "code=" << static_cast<unsigned int>(result) << "(" << _cudaGetErrorEnum(result) <<
               ") \"" << func << "\"" << std::endl;
         }
         DEVICE_RESET
            // Make sure we call CUDA Device Reset before exiting
      }
   }

#define DtCheckCudaErrors(val, theDe) DtCheck((val), #val, __FILE__, __LINE__, theDe)

   inline int DtGpuGetMaxGflopsDeviceId(DtDe* theDe)
   {
      int current_device = 0, sm_per_multiproc = 0;
      int max_perf_device = 0;
      int device_count = 0, best_SM_arch = 0;
      int devices_prohibited = 0;

      uint64_t max_compute_perf = 0;
      cudaDeviceProp deviceProp;
      DtCheckCudaErrors(cudaGetDeviceCount(&device_count), theDe);

      if (device_count == 0) 
      {
         if (theDe != NULL)
         {
            theDe->DT_LOG_WARN << "gpuGetMaxGflopsDeviceId() CUDA error:" <<
               " no devices supporting CUDA. Try updating your NVidia driver to a more recent one that support the CUDA version of this application." << std::endl;
         }         
         return -1;
      }

      // Find the best major SM Architecture GPU device
      while (current_device < device_count) 
      {
         cudaGetDeviceProperties(&deviceProp, current_device);

         // If this GPU is not running on Compute Mode prohibited,
         // then we can add it to the list
         if (deviceProp.computeMode != cudaComputeModeProhibited) 
         {
            if (deviceProp.major > 0 && deviceProp.major < 9999) 
            {
               best_SM_arch = MAX(best_SM_arch, deviceProp.major);
            }
         }
         else 
         {
            devices_prohibited++;
         }

         current_device++;
      }

      if (devices_prohibited == device_count) 
      {
         if (theDe != NULL)
         {
            theDe->DT_LOG_WARN << "gpuGetMaxGflopsDeviceId() CUDA error:" <<
               " all devices have compute mode prohibited." << std::endl;
         }         
         return -1;
      }

      // Find the best CUDA capable GPU device
      current_device = 0;

      while (current_device < device_count) 
      {
         cudaGetDeviceProperties(&deviceProp, current_device);

         // If this GPU is not running on Compute Mode prohibited,
         // then we can add it to the list
         if (deviceProp.computeMode != cudaComputeModeProhibited)
         {
            if (deviceProp.major == 9999 && deviceProp.minor == 9999) 
            {
               sm_per_multiproc = 1;
            }
            else 
            {
               sm_per_multiproc =
                  _ConvertSMVer2Cores(deviceProp.major, deviceProp.minor);
            }

            uint64_t compute_perf = (uint64_t)deviceProp.multiProcessorCount *
               sm_per_multiproc * deviceProp.clockRate;

            if (compute_perf > max_compute_perf)
            {
               // If we find GPU with SM major > 2, search only these
               if (best_SM_arch > 2)
               {
                  // If our device==dest_SM_arch, choose this, or else pass
                  if (deviceProp.major == best_SM_arch) 
                  {
                     max_compute_perf = compute_perf;
                     max_perf_device = current_device;
                  }
               }
               else 
               {
                  max_compute_perf = compute_perf;
                  max_perf_device = current_device;
               }
            }
         }

         ++current_device;
      }

      return max_perf_device;
   }
}